redis_test.go 5.2 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284
  1. package cache
  2. import (
  3. "errors"
  4. "strings"
  5. "sync"
  6. "testing"
  7. "time"
  8. "github.com/redis/go-redis/v9"
  9. )
  10. const (
  11. TEST_PREFIX = "test"
  12. )
  13. func getRedisConnection() error {
  14. return InitRedisClient("0.0.0.0:6379", "difyai123456", false)
  15. }
  16. func TestRedisConnection(t *testing.T) {
  17. // get redis connection
  18. if err := getRedisConnection(); err != nil {
  19. t.Errorf("get redis connection failed: %v", err)
  20. return
  21. }
  22. // close
  23. if err := Close(); err != nil {
  24. t.Errorf("close redis client failed: %v", err)
  25. return
  26. }
  27. }
  28. func TestRedisTransaction(t *testing.T) {
  29. // get redis connection
  30. if err := getRedisConnection(); err != nil {
  31. t.Errorf("get redis connection failed: %v", err)
  32. return
  33. }
  34. defer Close()
  35. // test transaction
  36. err := Transaction(func(p redis.Pipeliner) error {
  37. // set key
  38. if err := Store(
  39. strings.Join([]string{TEST_PREFIX, "key"}, ":"),
  40. "value",
  41. time.Second,
  42. p,
  43. ); err != nil {
  44. t.Errorf("store key failed: %v", err)
  45. return err
  46. }
  47. return errors.New("test transaction error")
  48. })
  49. if err == nil {
  50. t.Errorf("transaction should return error")
  51. return
  52. }
  53. // get key
  54. value, err := GetString(
  55. strings.Join([]string{TEST_PREFIX, "key"}, ":"),
  56. )
  57. if err != ErrNotFound {
  58. t.Errorf("key should not exist")
  59. return
  60. }
  61. if value != "" {
  62. t.Errorf("value should be empty")
  63. return
  64. }
  65. // test success transaction
  66. err = Transaction(func(p redis.Pipeliner) error {
  67. // set key
  68. if err := Store(
  69. strings.Join([]string{TEST_PREFIX, "key"}, ":"),
  70. "value",
  71. time.Second,
  72. p,
  73. ); err != nil {
  74. t.Errorf("store key failed: %v", err)
  75. return err
  76. }
  77. return nil
  78. })
  79. if err != nil {
  80. t.Errorf("transaction should not return error")
  81. return
  82. }
  83. defer Del(strings.Join([]string{TEST_PREFIX, "key"}, ":"))
  84. // get key
  85. value, err = GetString(
  86. strings.Join([]string{TEST_PREFIX, "key"}, ":"),
  87. )
  88. if err != nil {
  89. t.Errorf("get key failed: %v", err)
  90. return
  91. }
  92. if value != "value" {
  93. t.Errorf("value should be value")
  94. return
  95. }
  96. }
  97. func TestRedisScanMap(t *testing.T) {
  98. // get redis connection
  99. if err := getRedisConnection(); err != nil {
  100. t.Errorf("get redis connection failed: %v", err)
  101. return
  102. }
  103. defer Close()
  104. type s struct {
  105. Field string `json:"field"`
  106. }
  107. err := SetMapOneField(strings.Join([]string{TEST_PREFIX, "map"}, ":"), "key1", s{Field: "value1"})
  108. if err != nil {
  109. t.Errorf("set map failed: %v", err)
  110. return
  111. }
  112. defer Del(strings.Join([]string{TEST_PREFIX, "map"}, ":"))
  113. err = SetMapOneField(strings.Join([]string{TEST_PREFIX, "map"}, ":"), "key2", s{Field: "value2"})
  114. if err != nil {
  115. t.Errorf("set map failed: %v", err)
  116. return
  117. }
  118. err = SetMapOneField(strings.Join([]string{TEST_PREFIX, "map"}, ":"), "key3", s{Field: "value3"})
  119. if err != nil {
  120. t.Errorf("set map failed: %v", err)
  121. return
  122. }
  123. err = SetMapOneField(strings.Join([]string{TEST_PREFIX, "map"}, ":"), "4", s{Field: "value4"})
  124. if err != nil {
  125. t.Errorf("set map failed: %v", err)
  126. return
  127. }
  128. data, err := ScanMap[s](strings.Join([]string{TEST_PREFIX, "map"}, ":"), "key*")
  129. if err != nil {
  130. t.Errorf("scan map failed: %v", err)
  131. return
  132. }
  133. if len(data) != 3 {
  134. t.Errorf("scan map should return 3")
  135. return
  136. }
  137. if data["key1"].Field != "value1" {
  138. t.Errorf("scan map should return value1")
  139. return
  140. }
  141. if data["key2"].Field != "value2" {
  142. t.Errorf("scan map should return value2")
  143. return
  144. }
  145. if data["key3"].Field != "value3" {
  146. t.Errorf("scan map should return value3")
  147. return
  148. }
  149. err = ScanMapAsync[s](strings.Join([]string{TEST_PREFIX, "map"}, ":"), "4", func(m map[string]s) error {
  150. if len(m) != 1 {
  151. t.Errorf("scan map async should return 1")
  152. return errors.New("scan map async should return 1")
  153. }
  154. if m["4"].Field != "value4" {
  155. t.Errorf("scan map async should return value4")
  156. return errors.New("scan map async should return value4")
  157. }
  158. return nil
  159. })
  160. if err != nil {
  161. t.Errorf("scan map async failed: %v", err)
  162. return
  163. }
  164. }
  165. func TestRedisP2PPubsub(t *testing.T) {
  166. // get redis connection
  167. if err := getRedisConnection(); err != nil {
  168. t.Errorf("get redis connection failed: %v", err)
  169. return
  170. }
  171. defer Close()
  172. ch := "test-channel"
  173. type s struct{}
  174. sub, cancel := Subscribe[s](ch)
  175. defer cancel()
  176. wg := sync.WaitGroup{}
  177. wg.Add(1)
  178. go func() {
  179. <-sub
  180. wg.Done()
  181. }()
  182. // test pubsub
  183. err := Publish(ch, s{})
  184. if err != nil {
  185. t.Errorf("publish failed: %v", err)
  186. return
  187. }
  188. wg.Wait()
  189. }
  190. func TestRedisP2ARedis(t *testing.T) {
  191. // get redis connection
  192. if err := getRedisConnection(); err != nil {
  193. t.Errorf("get redis connection failed: %v", err)
  194. return
  195. }
  196. defer Close()
  197. ch := "test-channel-p2a"
  198. type s struct{}
  199. wg := sync.WaitGroup{}
  200. wg.Add(3)
  201. swg := sync.WaitGroup{}
  202. swg.Add(3)
  203. for i := 0; i < 3; i++ {
  204. go func() {
  205. sub, cancel := Subscribe[s](ch)
  206. swg.Done()
  207. defer cancel()
  208. <-sub
  209. wg.Done()
  210. }()
  211. }
  212. swg.Wait()
  213. // test pubsub
  214. err := Publish(ch, s{})
  215. if err != nil {
  216. t.Errorf("publish failed: %v", err)
  217. return
  218. }
  219. wg.Wait()
  220. }
  221. func TestGetRedisOptions(t *testing.T) {
  222. opts := getRedisOptions("dummy:6379", "password", false)
  223. if opts.TLSConfig != nil {
  224. t.Errorf("TLSConfig should not be set")
  225. return
  226. }
  227. opts = getRedisOptions("dummy:6379", "password", true)
  228. if opts.TLSConfig == nil {
  229. t.Errorf("TLSConfig should be set")
  230. return
  231. }
  232. }