1 package redis_test
2
3 import (
4 "encoding/json"
5 "fmt"
6 "reflect"
7 "time"
8
9 . "github.com/onsi/ginkgo"
10 . "github.com/onsi/gomega"
11
12 "github.com/go-redis/redis"
13 "github.com/go-redis/redis/internal/proto"
14 )
15
16 var _ = Describe("Commands", func() {
17 var client *redis.Client
18
19 BeforeEach(func() {
20 client = redis.NewClient(redisOptions())
21 Expect(client.FlushDB().Err()).NotTo(HaveOccurred())
22 })
23
24 AfterEach(func() {
25 Expect(client.Close()).NotTo(HaveOccurred())
26 })
27
28 Describe("server", func() {
29
30 It("should Auth", func() {
31 cmds, err := client.Pipelined(func(pipe redis.Pipeliner) error {
32 pipe.Auth("password")
33 pipe.Auth("")
34 return nil
35 })
36 Expect(err).To(MatchError("ERR Client sent AUTH, but no password is set"))
37 Expect(cmds[0].Err()).To(MatchError("ERR Client sent AUTH, but no password is set"))
38 Expect(cmds[1].Err()).To(MatchError("ERR Client sent AUTH, but no password is set"))
39
40 stats := client.PoolStats()
41 Expect(stats.Hits).To(Equal(uint32(1)))
42 Expect(stats.Misses).To(Equal(uint32(1)))
43 Expect(stats.Timeouts).To(Equal(uint32(0)))
44 Expect(stats.TotalConns).To(Equal(uint32(1)))
45 Expect(stats.IdleConns).To(Equal(uint32(1)))
46 })
47
48 It("should Echo", func() {
49 pipe := client.Pipeline()
50 echo := pipe.Echo("hello")
51 _, err := pipe.Exec()
52 Expect(err).NotTo(HaveOccurred())
53
54 Expect(echo.Err()).NotTo(HaveOccurred())
55 Expect(echo.Val()).To(Equal("hello"))
56 })
57
58 It("should Ping", func() {
59 ping := client.Ping()
60 Expect(ping.Err()).NotTo(HaveOccurred())
61 Expect(ping.Val()).To(Equal("PONG"))
62 })
63
64 It("should Wait", func() {
65 const wait = 3 * time.Second
66
67
68 start := time.Now()
69 val, err := client.Wait(1, wait).Result()
70 Expect(err).NotTo(HaveOccurred())
71 Expect(val).To(Equal(int64(0)))
72 Expect(time.Now()).To(BeTemporally("~", start.Add(wait), 3*time.Second))
73 })
74
75 It("should Select", func() {
76 pipe := client.Pipeline()
77 sel := pipe.Select(1)
78 _, err := pipe.Exec()
79 Expect(err).NotTo(HaveOccurred())
80
81 Expect(sel.Err()).NotTo(HaveOccurred())
82 Expect(sel.Val()).To(Equal("OK"))
83 })
84
85 It("should SwapDB", func() {
86 pipe := client.Pipeline()
87 sel := pipe.SwapDB(1, 2)
88 _, err := pipe.Exec()
89 Expect(err).NotTo(HaveOccurred())
90
91 Expect(sel.Err()).NotTo(HaveOccurred())
92 Expect(sel.Val()).To(Equal("OK"))
93 })
94
95 It("should BgRewriteAOF", func() {
96 Skip("flaky test")
97
98 val, err := client.BgRewriteAOF().Result()
99 Expect(err).NotTo(HaveOccurred())
100 Expect(val).To(ContainSubstring("Background append only file rewriting"))
101 })
102
103 It("should BgSave", func() {
104 Skip("flaky test")
105
106
107 Eventually(func() string {
108 return client.BgSave().Val()
109 }, "30s").Should(Equal("Background saving started"))
110 })
111
112 It("should ClientKill", func() {
113 r := client.ClientKill("1.1.1.1:1111")
114 Expect(r.Err()).To(MatchError("ERR No such client"))
115 Expect(r.Val()).To(Equal(""))
116 })
117
118 It("should ClientKillByFilter", func() {
119 r := client.ClientKillByFilter("TYPE", "test")
120 Expect(r.Err()).To(MatchError("ERR Unknown client type 'test'"))
121 Expect(r.Val()).To(Equal(int64(0)))
122 })
123
124 It("should ClientID", func() {
125 err := client.ClientID().Err()
126 Expect(err).NotTo(HaveOccurred())
127 Expect(client.ClientID().Val()).To(BeNumerically(">=", 0))
128 })
129
130 It("should ClientUnblock", func() {
131 id := client.ClientID().Val()
132 r, err := client.ClientUnblock(id).Result()
133 Expect(err).NotTo(HaveOccurred())
134 Expect(r).To(Equal(int64(0)))
135 })
136
137 It("should ClientUnblockWithError", func() {
138 id := client.ClientID().Val()
139 r, err := client.ClientUnblockWithError(id).Result()
140 Expect(err).NotTo(HaveOccurred())
141 Expect(r).To(Equal(int64(0)))
142 })
143
144 It("should ClientPause", func() {
145 err := client.ClientPause(time.Second).Err()
146 Expect(err).NotTo(HaveOccurred())
147
148 start := time.Now()
149 err = client.Ping().Err()
150 Expect(err).NotTo(HaveOccurred())
151 Expect(time.Now()).To(BeTemporally("~", start.Add(time.Second), 800*time.Millisecond))
152 })
153
154 It("should ClientSetName and ClientGetName", func() {
155 pipe := client.Pipeline()
156 set := pipe.ClientSetName("theclientname")
157 get := pipe.ClientGetName()
158 _, err := pipe.Exec()
159 Expect(err).NotTo(HaveOccurred())
160
161 Expect(set.Err()).NotTo(HaveOccurred())
162 Expect(set.Val()).To(BeTrue())
163
164 Expect(get.Err()).NotTo(HaveOccurred())
165 Expect(get.Val()).To(Equal("theclientname"))
166 })
167
168 It("should ConfigGet", func() {
169 val, err := client.ConfigGet("*").Result()
170 Expect(err).NotTo(HaveOccurred())
171 Expect(val).NotTo(BeEmpty())
172 })
173
174 It("should ConfigResetStat", func() {
175 r := client.ConfigResetStat()
176 Expect(r.Err()).NotTo(HaveOccurred())
177 Expect(r.Val()).To(Equal("OK"))
178 })
179
180 It("should ConfigSet", func() {
181 configGet := client.ConfigGet("maxmemory")
182 Expect(configGet.Err()).NotTo(HaveOccurred())
183 Expect(configGet.Val()).To(HaveLen(2))
184 Expect(configGet.Val()[0]).To(Equal("maxmemory"))
185
186 configSet := client.ConfigSet("maxmemory", configGet.Val()[1].(string))
187 Expect(configSet.Err()).NotTo(HaveOccurred())
188 Expect(configSet.Val()).To(Equal("OK"))
189 })
190
191 It("should ConfigRewrite", func() {
192 configRewrite := client.ConfigRewrite()
193 Expect(configRewrite.Err()).NotTo(HaveOccurred())
194 Expect(configRewrite.Val()).To(Equal("OK"))
195 })
196
197 It("should DBSize", func() {
198 size, err := client.DBSize().Result()
199 Expect(err).NotTo(HaveOccurred())
200 Expect(size).To(Equal(int64(0)))
201 })
202
203 It("should Info", func() {
204 info := client.Info()
205 Expect(info.Err()).NotTo(HaveOccurred())
206 Expect(info.Val()).NotTo(Equal(""))
207 })
208
209 It("should Info cpu", func() {
210 info := client.Info("cpu")
211 Expect(info.Err()).NotTo(HaveOccurred())
212 Expect(info.Val()).NotTo(Equal(""))
213 Expect(info.Val()).To(ContainSubstring(`used_cpu_sys`))
214 })
215
216 It("should LastSave", func() {
217 lastSave := client.LastSave()
218 Expect(lastSave.Err()).NotTo(HaveOccurred())
219 Expect(lastSave.Val()).NotTo(Equal(0))
220 })
221
222 It("should Save", func() {
223
224 Eventually(func() string {
225 return client.Save().Val()
226 }, "10s").Should(Equal("OK"))
227 })
228
229 It("should SlaveOf", func() {
230 slaveOf := client.SlaveOf("localhost", "8888")
231 Expect(slaveOf.Err()).NotTo(HaveOccurred())
232 Expect(slaveOf.Val()).To(Equal("OK"))
233
234 slaveOf = client.SlaveOf("NO", "ONE")
235 Expect(slaveOf.Err()).NotTo(HaveOccurred())
236 Expect(slaveOf.Val()).To(Equal("OK"))
237 })
238
239 It("should Time", func() {
240 tm, err := client.Time().Result()
241 Expect(err).NotTo(HaveOccurred())
242 Expect(tm).To(BeTemporally("~", time.Now(), 3*time.Second))
243 })
244
245 It("should Command", func() {
246 cmds, err := client.Command().Result()
247 Expect(err).NotTo(HaveOccurred())
248 Expect(len(cmds)).To(BeNumerically("~", 200, 20))
249
250 cmd := cmds["mget"]
251 Expect(cmd.Name).To(Equal("mget"))
252 Expect(cmd.Arity).To(Equal(int8(-2)))
253 Expect(cmd.Flags).To(ContainElement("readonly"))
254 Expect(cmd.FirstKeyPos).To(Equal(int8(1)))
255 Expect(cmd.LastKeyPos).To(Equal(int8(-1)))
256 Expect(cmd.StepCount).To(Equal(int8(1)))
257
258 cmd = cmds["ping"]
259 Expect(cmd.Name).To(Equal("ping"))
260 Expect(cmd.Arity).To(Equal(int8(-1)))
261 Expect(cmd.Flags).To(ContainElement("stale"))
262 Expect(cmd.Flags).To(ContainElement("fast"))
263 Expect(cmd.FirstKeyPos).To(Equal(int8(0)))
264 Expect(cmd.LastKeyPos).To(Equal(int8(0)))
265 Expect(cmd.StepCount).To(Equal(int8(0)))
266 })
267
268 })
269
270 Describe("debugging", func() {
271
272 It("should DebugObject", func() {
273 err := client.DebugObject("foo").Err()
274 Expect(err).To(MatchError("ERR no such key"))
275
276 err = client.Set("foo", "bar", 0).Err()
277 Expect(err).NotTo(HaveOccurred())
278
279 s, err := client.DebugObject("foo").Result()
280 Expect(err).NotTo(HaveOccurred())
281 Expect(s).To(ContainSubstring("serializedlength:4"))
282 })
283
284 It("should MemoryUsage", func() {
285 err := client.MemoryUsage("foo").Err()
286 Expect(err).To(Equal(redis.Nil))
287
288 err = client.Set("foo", "bar", 0).Err()
289 Expect(err).NotTo(HaveOccurred())
290
291 n, err := client.MemoryUsage("foo").Result()
292 Expect(err).NotTo(HaveOccurred())
293 Expect(n).To(Equal(int64(50)))
294
295 n, err = client.MemoryUsage("foo", 0).Result()
296 Expect(err).NotTo(HaveOccurred())
297 Expect(n).To(Equal(int64(50)))
298 })
299
300 })
301
302 Describe("keys", func() {
303
304 It("should Del", func() {
305 err := client.Set("key1", "Hello", 0).Err()
306 Expect(err).NotTo(HaveOccurred())
307 err = client.Set("key2", "World", 0).Err()
308 Expect(err).NotTo(HaveOccurred())
309
310 n, err := client.Del("key1", "key2", "key3").Result()
311 Expect(err).NotTo(HaveOccurred())
312 Expect(n).To(Equal(int64(2)))
313 })
314
315 It("should Unlink", func() {
316 err := client.Set("key1", "Hello", 0).Err()
317 Expect(err).NotTo(HaveOccurred())
318 err = client.Set("key2", "World", 0).Err()
319 Expect(err).NotTo(HaveOccurred())
320
321 n, err := client.Unlink("key1", "key2", "key3").Result()
322 Expect(err).NotTo(HaveOccurred())
323 Expect(n).To(Equal(int64(2)))
324 })
325
326 It("should Dump", func() {
327 set := client.Set("key", "hello", 0)
328 Expect(set.Err()).NotTo(HaveOccurred())
329 Expect(set.Val()).To(Equal("OK"))
330
331 dump := client.Dump("key")
332 Expect(dump.Err()).NotTo(HaveOccurred())
333 Expect(dump.Val()).NotTo(BeEmpty())
334 })
335
336 It("should Exists", func() {
337 set := client.Set("key1", "Hello", 0)
338 Expect(set.Err()).NotTo(HaveOccurred())
339 Expect(set.Val()).To(Equal("OK"))
340
341 n, err := client.Exists("key1").Result()
342 Expect(err).NotTo(HaveOccurred())
343 Expect(n).To(Equal(int64(1)))
344
345 n, err = client.Exists("key2").Result()
346 Expect(err).NotTo(HaveOccurred())
347 Expect(n).To(Equal(int64(0)))
348
349 n, err = client.Exists("key1", "key2").Result()
350 Expect(err).NotTo(HaveOccurred())
351 Expect(n).To(Equal(int64(1)))
352
353 n, err = client.Exists("key1", "key1").Result()
354 Expect(err).NotTo(HaveOccurred())
355 Expect(n).To(Equal(int64(2)))
356 })
357
358 It("should Expire", func() {
359 set := client.Set("key", "Hello", 0)
360 Expect(set.Err()).NotTo(HaveOccurred())
361 Expect(set.Val()).To(Equal("OK"))
362
363 expire := client.Expire("key", 10*time.Second)
364 Expect(expire.Err()).NotTo(HaveOccurred())
365 Expect(expire.Val()).To(Equal(true))
366
367 ttl := client.TTL("key")
368 Expect(ttl.Err()).NotTo(HaveOccurred())
369 Expect(ttl.Val()).To(Equal(10 * time.Second))
370
371 set = client.Set("key", "Hello World", 0)
372 Expect(set.Err()).NotTo(HaveOccurred())
373 Expect(set.Val()).To(Equal("OK"))
374
375 ttl = client.TTL("key")
376 Expect(ttl.Err()).NotTo(HaveOccurred())
377 Expect(ttl.Val() < 0).To(Equal(true))
378 })
379
380 It("should ExpireAt", func() {
381 set := client.Set("key", "Hello", 0)
382 Expect(set.Err()).NotTo(HaveOccurred())
383 Expect(set.Val()).To(Equal("OK"))
384
385 n, err := client.Exists("key").Result()
386 Expect(err).NotTo(HaveOccurred())
387 Expect(n).To(Equal(int64(1)))
388
389 expireAt := client.ExpireAt("key", time.Now().Add(-time.Hour))
390 Expect(expireAt.Err()).NotTo(HaveOccurred())
391 Expect(expireAt.Val()).To(Equal(true))
392
393 n, err = client.Exists("key").Result()
394 Expect(err).NotTo(HaveOccurred())
395 Expect(n).To(Equal(int64(0)))
396 })
397
398 It("should Keys", func() {
399 mset := client.MSet("one", "1", "two", "2", "three", "3", "four", "4")
400 Expect(mset.Err()).NotTo(HaveOccurred())
401 Expect(mset.Val()).To(Equal("OK"))
402
403 keys := client.Keys("*o*")
404 Expect(keys.Err()).NotTo(HaveOccurred())
405 Expect(keys.Val()).To(ConsistOf([]string{"four", "one", "two"}))
406
407 keys = client.Keys("t??")
408 Expect(keys.Err()).NotTo(HaveOccurred())
409 Expect(keys.Val()).To(Equal([]string{"two"}))
410
411 keys = client.Keys("*")
412 Expect(keys.Err()).NotTo(HaveOccurred())
413 Expect(keys.Val()).To(ConsistOf([]string{"four", "one", "three", "two"}))
414 })
415
416 It("should Migrate", func() {
417 migrate := client.Migrate("localhost", redisSecondaryPort, "key", 0, 0)
418 Expect(migrate.Err()).NotTo(HaveOccurred())
419 Expect(migrate.Val()).To(Equal("NOKEY"))
420
421 set := client.Set("key", "hello", 0)
422 Expect(set.Err()).NotTo(HaveOccurred())
423 Expect(set.Val()).To(Equal("OK"))
424
425 migrate = client.Migrate("localhost", redisSecondaryPort, "key", 0, 0)
426 Expect(migrate.Err()).To(MatchError("IOERR error or timeout writing to target instance"))
427 Expect(migrate.Val()).To(Equal(""))
428 })
429
430 It("should Move", func() {
431 move := client.Move("key", 2)
432 Expect(move.Err()).NotTo(HaveOccurred())
433 Expect(move.Val()).To(Equal(false))
434
435 set := client.Set("key", "hello", 0)
436 Expect(set.Err()).NotTo(HaveOccurred())
437 Expect(set.Val()).To(Equal("OK"))
438
439 move = client.Move("key", 2)
440 Expect(move.Err()).NotTo(HaveOccurred())
441 Expect(move.Val()).To(Equal(true))
442
443 get := client.Get("key")
444 Expect(get.Err()).To(Equal(redis.Nil))
445 Expect(get.Val()).To(Equal(""))
446
447 pipe := client.Pipeline()
448 pipe.Select(2)
449 get = pipe.Get("key")
450 pipe.FlushDB()
451
452 _, err := pipe.Exec()
453 Expect(err).NotTo(HaveOccurred())
454 Expect(get.Val()).To(Equal("hello"))
455 })
456
457 It("should Object", func() {
458 set := client.Set("key", "hello", 0)
459 Expect(set.Err()).NotTo(HaveOccurred())
460 Expect(set.Val()).To(Equal("OK"))
461
462 refCount := client.ObjectRefCount("key")
463 Expect(refCount.Err()).NotTo(HaveOccurred())
464 Expect(refCount.Val()).To(Equal(int64(1)))
465
466 err := client.ObjectEncoding("key").Err()
467 Expect(err).NotTo(HaveOccurred())
468
469 idleTime := client.ObjectIdleTime("key")
470 Expect(idleTime.Err()).NotTo(HaveOccurred())
471 Expect(idleTime.Val()).To(Equal(time.Duration(0)))
472 })
473
474 It("should Persist", func() {
475 set := client.Set("key", "Hello", 0)
476 Expect(set.Err()).NotTo(HaveOccurred())
477 Expect(set.Val()).To(Equal("OK"))
478
479 expire := client.Expire("key", 10*time.Second)
480 Expect(expire.Err()).NotTo(HaveOccurred())
481 Expect(expire.Val()).To(Equal(true))
482
483 ttl := client.TTL("key")
484 Expect(ttl.Err()).NotTo(HaveOccurred())
485 Expect(ttl.Val()).To(Equal(10 * time.Second))
486
487 persist := client.Persist("key")
488 Expect(persist.Err()).NotTo(HaveOccurred())
489 Expect(persist.Val()).To(Equal(true))
490
491 ttl = client.TTL("key")
492 Expect(ttl.Err()).NotTo(HaveOccurred())
493 Expect(ttl.Val() < 0).To(Equal(true))
494 })
495
496 It("should PExpire", func() {
497 set := client.Set("key", "Hello", 0)
498 Expect(set.Err()).NotTo(HaveOccurred())
499 Expect(set.Val()).To(Equal("OK"))
500
501 expiration := 900 * time.Millisecond
502 pexpire := client.PExpire("key", expiration)
503 Expect(pexpire.Err()).NotTo(HaveOccurred())
504 Expect(pexpire.Val()).To(Equal(true))
505
506 ttl := client.TTL("key")
507 Expect(ttl.Err()).NotTo(HaveOccurred())
508 Expect(ttl.Val()).To(Equal(time.Second))
509
510 pttl := client.PTTL("key")
511 Expect(pttl.Err()).NotTo(HaveOccurred())
512 Expect(pttl.Val()).To(BeNumerically("~", expiration, 100*time.Millisecond))
513 })
514
515 It("should PExpireAt", func() {
516 set := client.Set("key", "Hello", 0)
517 Expect(set.Err()).NotTo(HaveOccurred())
518 Expect(set.Val()).To(Equal("OK"))
519
520 expiration := 900 * time.Millisecond
521 pexpireat := client.PExpireAt("key", time.Now().Add(expiration))
522 Expect(pexpireat.Err()).NotTo(HaveOccurred())
523 Expect(pexpireat.Val()).To(Equal(true))
524
525 ttl := client.TTL("key")
526 Expect(ttl.Err()).NotTo(HaveOccurred())
527 Expect(ttl.Val()).To(Equal(time.Second))
528
529 pttl := client.PTTL("key")
530 Expect(pttl.Err()).NotTo(HaveOccurred())
531 Expect(pttl.Val()).To(BeNumerically("~", expiration, 100*time.Millisecond))
532 })
533
534 It("should PTTL", func() {
535 set := client.Set("key", "Hello", 0)
536 Expect(set.Err()).NotTo(HaveOccurred())
537 Expect(set.Val()).To(Equal("OK"))
538
539 expiration := time.Second
540 expire := client.Expire("key", expiration)
541 Expect(expire.Err()).NotTo(HaveOccurred())
542 Expect(set.Val()).To(Equal("OK"))
543
544 pttl := client.PTTL("key")
545 Expect(pttl.Err()).NotTo(HaveOccurred())
546 Expect(pttl.Val()).To(BeNumerically("~", expiration, 100*time.Millisecond))
547 })
548
549 It("should RandomKey", func() {
550 randomKey := client.RandomKey()
551 Expect(randomKey.Err()).To(Equal(redis.Nil))
552 Expect(randomKey.Val()).To(Equal(""))
553
554 set := client.Set("key", "hello", 0)
555 Expect(set.Err()).NotTo(HaveOccurred())
556 Expect(set.Val()).To(Equal("OK"))
557
558 randomKey = client.RandomKey()
559 Expect(randomKey.Err()).NotTo(HaveOccurred())
560 Expect(randomKey.Val()).To(Equal("key"))
561 })
562
563 It("should Rename", func() {
564 set := client.Set("key", "hello", 0)
565 Expect(set.Err()).NotTo(HaveOccurred())
566 Expect(set.Val()).To(Equal("OK"))
567
568 status := client.Rename("key", "key1")
569 Expect(status.Err()).NotTo(HaveOccurred())
570 Expect(status.Val()).To(Equal("OK"))
571
572 get := client.Get("key1")
573 Expect(get.Err()).NotTo(HaveOccurred())
574 Expect(get.Val()).To(Equal("hello"))
575 })
576
577 It("should RenameNX", func() {
578 set := client.Set("key", "hello", 0)
579 Expect(set.Err()).NotTo(HaveOccurred())
580 Expect(set.Val()).To(Equal("OK"))
581
582 renameNX := client.RenameNX("key", "key1")
583 Expect(renameNX.Err()).NotTo(HaveOccurred())
584 Expect(renameNX.Val()).To(Equal(true))
585
586 get := client.Get("key1")
587 Expect(get.Err()).NotTo(HaveOccurred())
588 Expect(get.Val()).To(Equal("hello"))
589 })
590
591 It("should Restore", func() {
592 err := client.Set("key", "hello", 0).Err()
593 Expect(err).NotTo(HaveOccurred())
594
595 dump := client.Dump("key")
596 Expect(dump.Err()).NotTo(HaveOccurred())
597
598 err = client.Del("key").Err()
599 Expect(err).NotTo(HaveOccurred())
600
601 restore, err := client.Restore("key", 0, dump.Val()).Result()
602 Expect(err).NotTo(HaveOccurred())
603 Expect(restore).To(Equal("OK"))
604
605 type_, err := client.Type("key").Result()
606 Expect(err).NotTo(HaveOccurred())
607 Expect(type_).To(Equal("string"))
608
609 val, err := client.Get("key").Result()
610 Expect(err).NotTo(HaveOccurred())
611 Expect(val).To(Equal("hello"))
612 })
613
614 It("should RestoreReplace", func() {
615 err := client.Set("key", "hello", 0).Err()
616 Expect(err).NotTo(HaveOccurred())
617
618 dump := client.Dump("key")
619 Expect(dump.Err()).NotTo(HaveOccurred())
620
621 restore, err := client.RestoreReplace("key", 0, dump.Val()).Result()
622 Expect(err).NotTo(HaveOccurred())
623 Expect(restore).To(Equal("OK"))
624
625 type_, err := client.Type("key").Result()
626 Expect(err).NotTo(HaveOccurred())
627 Expect(type_).To(Equal("string"))
628
629 val, err := client.Get("key").Result()
630 Expect(err).NotTo(HaveOccurred())
631 Expect(val).To(Equal("hello"))
632 })
633
634 It("should Sort", func() {
635 size, err := client.LPush("list", "1").Result()
636 Expect(err).NotTo(HaveOccurred())
637 Expect(size).To(Equal(int64(1)))
638
639 size, err = client.LPush("list", "3").Result()
640 Expect(err).NotTo(HaveOccurred())
641 Expect(size).To(Equal(int64(2)))
642
643 size, err = client.LPush("list", "2").Result()
644 Expect(err).NotTo(HaveOccurred())
645 Expect(size).To(Equal(int64(3)))
646
647 els, err := client.Sort("list", &redis.Sort{
648 Offset: 0,
649 Count: 2,
650 Order: "ASC",
651 }).Result()
652 Expect(err).NotTo(HaveOccurred())
653 Expect(els).To(Equal([]string{"1", "2"}))
654 })
655
656 It("should Sort and Get", func() {
657 size, err := client.LPush("list", "1").Result()
658 Expect(err).NotTo(HaveOccurred())
659 Expect(size).To(Equal(int64(1)))
660
661 size, err = client.LPush("list", "3").Result()
662 Expect(err).NotTo(HaveOccurred())
663 Expect(size).To(Equal(int64(2)))
664
665 size, err = client.LPush("list", "2").Result()
666 Expect(err).NotTo(HaveOccurred())
667 Expect(size).To(Equal(int64(3)))
668
669 err = client.Set("object_2", "value2", 0).Err()
670 Expect(err).NotTo(HaveOccurred())
671
672 {
673 els, err := client.Sort("list", &redis.Sort{
674 Get: []string{"object_*"},
675 }).Result()
676 Expect(err).NotTo(HaveOccurred())
677 Expect(els).To(Equal([]string{"", "value2", ""}))
678 }
679
680 {
681 els, err := client.SortInterfaces("list", &redis.Sort{
682 Get: []string{"object_*"},
683 }).Result()
684 Expect(err).NotTo(HaveOccurred())
685 Expect(els).To(Equal([]interface{}{nil, "value2", nil}))
686 }
687 })
688
689 It("should Sort and Store", func() {
690 size, err := client.LPush("list", "1").Result()
691 Expect(err).NotTo(HaveOccurred())
692 Expect(size).To(Equal(int64(1)))
693
694 size, err = client.LPush("list", "3").Result()
695 Expect(err).NotTo(HaveOccurred())
696 Expect(size).To(Equal(int64(2)))
697
698 size, err = client.LPush("list", "2").Result()
699 Expect(err).NotTo(HaveOccurred())
700 Expect(size).To(Equal(int64(3)))
701
702 n, err := client.SortStore("list", "list2", &redis.Sort{
703 Offset: 0,
704 Count: 2,
705 Order: "ASC",
706 }).Result()
707 Expect(err).NotTo(HaveOccurred())
708 Expect(n).To(Equal(int64(2)))
709
710 els, err := client.LRange("list2", 0, -1).Result()
711 Expect(err).NotTo(HaveOccurred())
712 Expect(els).To(Equal([]string{"1", "2"}))
713 })
714
715 It("should Touch", func() {
716 set1 := client.Set("touch1", "hello", 0)
717 Expect(set1.Err()).NotTo(HaveOccurred())
718 Expect(set1.Val()).To(Equal("OK"))
719
720 set2 := client.Set("touch2", "hello", 0)
721 Expect(set2.Err()).NotTo(HaveOccurred())
722 Expect(set2.Val()).To(Equal("OK"))
723
724 touch := client.Touch("touch1", "touch2", "touch3")
725 Expect(touch.Err()).NotTo(HaveOccurred())
726 Expect(touch.Val()).To(Equal(int64(2)))
727 })
728
729 It("should TTL", func() {
730 ttl := client.TTL("key")
731 Expect(ttl.Err()).NotTo(HaveOccurred())
732 Expect(ttl.Val() < 0).To(Equal(true))
733
734 set := client.Set("key", "hello", 0)
735 Expect(set.Err()).NotTo(HaveOccurred())
736 Expect(set.Val()).To(Equal("OK"))
737
738 expire := client.Expire("key", 60*time.Second)
739 Expect(expire.Err()).NotTo(HaveOccurred())
740 Expect(expire.Val()).To(Equal(true))
741
742 ttl = client.TTL("key")
743 Expect(ttl.Err()).NotTo(HaveOccurred())
744 Expect(ttl.Val()).To(Equal(60 * time.Second))
745 })
746
747 It("should Type", func() {
748 set := client.Set("key", "hello", 0)
749 Expect(set.Err()).NotTo(HaveOccurred())
750 Expect(set.Val()).To(Equal("OK"))
751
752 type_ := client.Type("key")
753 Expect(type_.Err()).NotTo(HaveOccurred())
754 Expect(type_.Val()).To(Equal("string"))
755 })
756
757 })
758
759 Describe("scanning", func() {
760
761 It("should Scan", func() {
762 for i := 0; i < 1000; i++ {
763 set := client.Set(fmt.Sprintf("key%d", i), "hello", 0)
764 Expect(set.Err()).NotTo(HaveOccurred())
765 }
766
767 keys, cursor, err := client.Scan(0, "", 0).Result()
768 Expect(err).NotTo(HaveOccurred())
769 Expect(keys).NotTo(BeEmpty())
770 Expect(cursor).NotTo(BeZero())
771 })
772
773 It("should SScan", func() {
774 for i := 0; i < 1000; i++ {
775 sadd := client.SAdd("myset", fmt.Sprintf("member%d", i))
776 Expect(sadd.Err()).NotTo(HaveOccurred())
777 }
778
779 keys, cursor, err := client.SScan("myset", 0, "", 0).Result()
780 Expect(err).NotTo(HaveOccurred())
781 Expect(keys).NotTo(BeEmpty())
782 Expect(cursor).NotTo(BeZero())
783 })
784
785 It("should HScan", func() {
786 for i := 0; i < 1000; i++ {
787 sadd := client.HSet("myhash", fmt.Sprintf("key%d", i), "hello")
788 Expect(sadd.Err()).NotTo(HaveOccurred())
789 }
790
791 keys, cursor, err := client.HScan("myhash", 0, "", 0).Result()
792 Expect(err).NotTo(HaveOccurred())
793 Expect(keys).NotTo(BeEmpty())
794 Expect(cursor).NotTo(BeZero())
795 })
796
797 It("should ZScan", func() {
798 for i := 0; i < 1000; i++ {
799 err := client.ZAdd("myset", redis.Z{
800 Score: float64(i),
801 Member: fmt.Sprintf("member%d", i),
802 }).Err()
803 Expect(err).NotTo(HaveOccurred())
804 }
805
806 keys, cursor, err := client.ZScan("myset", 0, "", 0).Result()
807 Expect(err).NotTo(HaveOccurred())
808 Expect(keys).NotTo(BeEmpty())
809 Expect(cursor).NotTo(BeZero())
810 })
811
812 })
813
814 Describe("strings", func() {
815
816 It("should Append", func() {
817 n, err := client.Exists("key").Result()
818 Expect(err).NotTo(HaveOccurred())
819 Expect(n).To(Equal(int64(0)))
820
821 append := client.Append("key", "Hello")
822 Expect(append.Err()).NotTo(HaveOccurred())
823 Expect(append.Val()).To(Equal(int64(5)))
824
825 append = client.Append("key", " World")
826 Expect(append.Err()).NotTo(HaveOccurred())
827 Expect(append.Val()).To(Equal(int64(11)))
828
829 get := client.Get("key")
830 Expect(get.Err()).NotTo(HaveOccurred())
831 Expect(get.Val()).To(Equal("Hello World"))
832 })
833
834 It("should BitCount", func() {
835 set := client.Set("key", "foobar", 0)
836 Expect(set.Err()).NotTo(HaveOccurred())
837 Expect(set.Val()).To(Equal("OK"))
838
839 bitCount := client.BitCount("key", nil)
840 Expect(bitCount.Err()).NotTo(HaveOccurred())
841 Expect(bitCount.Val()).To(Equal(int64(26)))
842
843 bitCount = client.BitCount("key", &redis.BitCount{
844 Start: 0,
845 End: 0,
846 })
847 Expect(bitCount.Err()).NotTo(HaveOccurred())
848 Expect(bitCount.Val()).To(Equal(int64(4)))
849
850 bitCount = client.BitCount("key", &redis.BitCount{
851 Start: 1,
852 End: 1,
853 })
854 Expect(bitCount.Err()).NotTo(HaveOccurred())
855 Expect(bitCount.Val()).To(Equal(int64(6)))
856 })
857
858 It("should BitOpAnd", func() {
859 set := client.Set("key1", "1", 0)
860 Expect(set.Err()).NotTo(HaveOccurred())
861 Expect(set.Val()).To(Equal("OK"))
862
863 set = client.Set("key2", "0", 0)
864 Expect(set.Err()).NotTo(HaveOccurred())
865 Expect(set.Val()).To(Equal("OK"))
866
867 bitOpAnd := client.BitOpAnd("dest", "key1", "key2")
868 Expect(bitOpAnd.Err()).NotTo(HaveOccurred())
869 Expect(bitOpAnd.Val()).To(Equal(int64(1)))
870
871 get := client.Get("dest")
872 Expect(get.Err()).NotTo(HaveOccurred())
873 Expect(get.Val()).To(Equal("0"))
874 })
875
876 It("should BitOpOr", func() {
877 set := client.Set("key1", "1", 0)
878 Expect(set.Err()).NotTo(HaveOccurred())
879 Expect(set.Val()).To(Equal("OK"))
880
881 set = client.Set("key2", "0", 0)
882 Expect(set.Err()).NotTo(HaveOccurred())
883 Expect(set.Val()).To(Equal("OK"))
884
885 bitOpOr := client.BitOpOr("dest", "key1", "key2")
886 Expect(bitOpOr.Err()).NotTo(HaveOccurred())
887 Expect(bitOpOr.Val()).To(Equal(int64(1)))
888
889 get := client.Get("dest")
890 Expect(get.Err()).NotTo(HaveOccurred())
891 Expect(get.Val()).To(Equal("1"))
892 })
893
894 It("should BitOpXor", func() {
895 set := client.Set("key1", "\xff", 0)
896 Expect(set.Err()).NotTo(HaveOccurred())
897 Expect(set.Val()).To(Equal("OK"))
898
899 set = client.Set("key2", "\x0f", 0)
900 Expect(set.Err()).NotTo(HaveOccurred())
901 Expect(set.Val()).To(Equal("OK"))
902
903 bitOpXor := client.BitOpXor("dest", "key1", "key2")
904 Expect(bitOpXor.Err()).NotTo(HaveOccurred())
905 Expect(bitOpXor.Val()).To(Equal(int64(1)))
906
907 get := client.Get("dest")
908 Expect(get.Err()).NotTo(HaveOccurred())
909 Expect(get.Val()).To(Equal("\xf0"))
910 })
911
912 It("should BitOpNot", func() {
913 set := client.Set("key1", "\x00", 0)
914 Expect(set.Err()).NotTo(HaveOccurred())
915 Expect(set.Val()).To(Equal("OK"))
916
917 bitOpNot := client.BitOpNot("dest", "key1")
918 Expect(bitOpNot.Err()).NotTo(HaveOccurred())
919 Expect(bitOpNot.Val()).To(Equal(int64(1)))
920
921 get := client.Get("dest")
922 Expect(get.Err()).NotTo(HaveOccurred())
923 Expect(get.Val()).To(Equal("\xff"))
924 })
925
926 It("should BitPos", func() {
927 err := client.Set("mykey", "\xff\xf0\x00", 0).Err()
928 Expect(err).NotTo(HaveOccurred())
929
930 pos, err := client.BitPos("mykey", 0).Result()
931 Expect(err).NotTo(HaveOccurred())
932 Expect(pos).To(Equal(int64(12)))
933
934 pos, err = client.BitPos("mykey", 1).Result()
935 Expect(err).NotTo(HaveOccurred())
936 Expect(pos).To(Equal(int64(0)))
937
938 pos, err = client.BitPos("mykey", 0, 2).Result()
939 Expect(err).NotTo(HaveOccurred())
940 Expect(pos).To(Equal(int64(16)))
941
942 pos, err = client.BitPos("mykey", 1, 2).Result()
943 Expect(err).NotTo(HaveOccurred())
944 Expect(pos).To(Equal(int64(-1)))
945
946 pos, err = client.BitPos("mykey", 0, -1).Result()
947 Expect(err).NotTo(HaveOccurred())
948 Expect(pos).To(Equal(int64(16)))
949
950 pos, err = client.BitPos("mykey", 1, -1).Result()
951 Expect(err).NotTo(HaveOccurred())
952 Expect(pos).To(Equal(int64(-1)))
953
954 pos, err = client.BitPos("mykey", 0, 2, 1).Result()
955 Expect(err).NotTo(HaveOccurred())
956 Expect(pos).To(Equal(int64(-1)))
957
958 pos, err = client.BitPos("mykey", 0, 0, -3).Result()
959 Expect(err).NotTo(HaveOccurred())
960 Expect(pos).To(Equal(int64(-1)))
961
962 pos, err = client.BitPos("mykey", 0, 0, 0).Result()
963 Expect(err).NotTo(HaveOccurred())
964 Expect(pos).To(Equal(int64(-1)))
965 })
966
967 It("should Decr", func() {
968 set := client.Set("key", "10", 0)
969 Expect(set.Err()).NotTo(HaveOccurred())
970 Expect(set.Val()).To(Equal("OK"))
971
972 decr := client.Decr("key")
973 Expect(decr.Err()).NotTo(HaveOccurred())
974 Expect(decr.Val()).To(Equal(int64(9)))
975
976 set = client.Set("key", "234293482390480948029348230948", 0)
977 Expect(set.Err()).NotTo(HaveOccurred())
978 Expect(set.Val()).To(Equal("OK"))
979
980 decr = client.Decr("key")
981 Expect(decr.Err()).To(MatchError("ERR value is not an integer or out of range"))
982 Expect(decr.Val()).To(Equal(int64(0)))
983 })
984
985 It("should DecrBy", func() {
986 set := client.Set("key", "10", 0)
987 Expect(set.Err()).NotTo(HaveOccurred())
988 Expect(set.Val()).To(Equal("OK"))
989
990 decrBy := client.DecrBy("key", 5)
991 Expect(decrBy.Err()).NotTo(HaveOccurred())
992 Expect(decrBy.Val()).To(Equal(int64(5)))
993 })
994
995 It("should Get", func() {
996 get := client.Get("_")
997 Expect(get.Err()).To(Equal(redis.Nil))
998 Expect(get.Val()).To(Equal(""))
999
1000 set := client.Set("key", "hello", 0)
1001 Expect(set.Err()).NotTo(HaveOccurred())
1002 Expect(set.Val()).To(Equal("OK"))
1003
1004 get = client.Get("key")
1005 Expect(get.Err()).NotTo(HaveOccurred())
1006 Expect(get.Val()).To(Equal("hello"))
1007 })
1008
1009 It("should GetBit", func() {
1010 setBit := client.SetBit("key", 7, 1)
1011 Expect(setBit.Err()).NotTo(HaveOccurred())
1012 Expect(setBit.Val()).To(Equal(int64(0)))
1013
1014 getBit := client.GetBit("key", 0)
1015 Expect(getBit.Err()).NotTo(HaveOccurred())
1016 Expect(getBit.Val()).To(Equal(int64(0)))
1017
1018 getBit = client.GetBit("key", 7)
1019 Expect(getBit.Err()).NotTo(HaveOccurred())
1020 Expect(getBit.Val()).To(Equal(int64(1)))
1021
1022 getBit = client.GetBit("key", 100)
1023 Expect(getBit.Err()).NotTo(HaveOccurred())
1024 Expect(getBit.Val()).To(Equal(int64(0)))
1025 })
1026
1027 It("should GetRange", func() {
1028 set := client.Set("key", "This is a string", 0)
1029 Expect(set.Err()).NotTo(HaveOccurred())
1030 Expect(set.Val()).To(Equal("OK"))
1031
1032 getRange := client.GetRange("key", 0, 3)
1033 Expect(getRange.Err()).NotTo(HaveOccurred())
1034 Expect(getRange.Val()).To(Equal("This"))
1035
1036 getRange = client.GetRange("key", -3, -1)
1037 Expect(getRange.Err()).NotTo(HaveOccurred())
1038 Expect(getRange.Val()).To(Equal("ing"))
1039
1040 getRange = client.GetRange("key", 0, -1)
1041 Expect(getRange.Err()).NotTo(HaveOccurred())
1042 Expect(getRange.Val()).To(Equal("This is a string"))
1043
1044 getRange = client.GetRange("key", 10, 100)
1045 Expect(getRange.Err()).NotTo(HaveOccurred())
1046 Expect(getRange.Val()).To(Equal("string"))
1047 })
1048
1049 It("should GetSet", func() {
1050 incr := client.Incr("key")
1051 Expect(incr.Err()).NotTo(HaveOccurred())
1052 Expect(incr.Val()).To(Equal(int64(1)))
1053
1054 getSet := client.GetSet("key", "0")
1055 Expect(getSet.Err()).NotTo(HaveOccurred())
1056 Expect(getSet.Val()).To(Equal("1"))
1057
1058 get := client.Get("key")
1059 Expect(get.Err()).NotTo(HaveOccurred())
1060 Expect(get.Val()).To(Equal("0"))
1061 })
1062
1063 It("should Incr", func() {
1064 set := client.Set("key", "10", 0)
1065 Expect(set.Err()).NotTo(HaveOccurred())
1066 Expect(set.Val()).To(Equal("OK"))
1067
1068 incr := client.Incr("key")
1069 Expect(incr.Err()).NotTo(HaveOccurred())
1070 Expect(incr.Val()).To(Equal(int64(11)))
1071
1072 get := client.Get("key")
1073 Expect(get.Err()).NotTo(HaveOccurred())
1074 Expect(get.Val()).To(Equal("11"))
1075 })
1076
1077 It("should IncrBy", func() {
1078 set := client.Set("key", "10", 0)
1079 Expect(set.Err()).NotTo(HaveOccurred())
1080 Expect(set.Val()).To(Equal("OK"))
1081
1082 incrBy := client.IncrBy("key", 5)
1083 Expect(incrBy.Err()).NotTo(HaveOccurred())
1084 Expect(incrBy.Val()).To(Equal(int64(15)))
1085 })
1086
1087 It("should IncrByFloat", func() {
1088 set := client.Set("key", "10.50", 0)
1089 Expect(set.Err()).NotTo(HaveOccurred())
1090 Expect(set.Val()).To(Equal("OK"))
1091
1092 incrByFloat := client.IncrByFloat("key", 0.1)
1093 Expect(incrByFloat.Err()).NotTo(HaveOccurred())
1094 Expect(incrByFloat.Val()).To(Equal(10.6))
1095
1096 set = client.Set("key", "5.0e3", 0)
1097 Expect(set.Err()).NotTo(HaveOccurred())
1098 Expect(set.Val()).To(Equal("OK"))
1099
1100 incrByFloat = client.IncrByFloat("key", 2.0e2)
1101 Expect(incrByFloat.Err()).NotTo(HaveOccurred())
1102 Expect(incrByFloat.Val()).To(Equal(float64(5200)))
1103 })
1104
1105 It("should IncrByFloatOverflow", func() {
1106 incrByFloat := client.IncrByFloat("key", 996945661)
1107 Expect(incrByFloat.Err()).NotTo(HaveOccurred())
1108 Expect(incrByFloat.Val()).To(Equal(float64(996945661)))
1109 })
1110
1111 It("should MSetMGet", func() {
1112 mSet := client.MSet("key1", "hello1", "key2", "hello2")
1113 Expect(mSet.Err()).NotTo(HaveOccurred())
1114 Expect(mSet.Val()).To(Equal("OK"))
1115
1116 mGet := client.MGet("key1", "key2", "_")
1117 Expect(mGet.Err()).NotTo(HaveOccurred())
1118 Expect(mGet.Val()).To(Equal([]interface{}{"hello1", "hello2", nil}))
1119 })
1120
1121 It("should MSetNX", func() {
1122 mSetNX := client.MSetNX("key1", "hello1", "key2", "hello2")
1123 Expect(mSetNX.Err()).NotTo(HaveOccurred())
1124 Expect(mSetNX.Val()).To(Equal(true))
1125
1126 mSetNX = client.MSetNX("key2", "hello1", "key3", "hello2")
1127 Expect(mSetNX.Err()).NotTo(HaveOccurred())
1128 Expect(mSetNX.Val()).To(Equal(false))
1129 })
1130
1131 It("should Set with expiration", func() {
1132 err := client.Set("key", "hello", 100*time.Millisecond).Err()
1133 Expect(err).NotTo(HaveOccurred())
1134
1135 val, err := client.Get("key").Result()
1136 Expect(err).NotTo(HaveOccurred())
1137 Expect(val).To(Equal("hello"))
1138
1139 Eventually(func() error {
1140 return client.Get("foo").Err()
1141 }, "1s", "100ms").Should(Equal(redis.Nil))
1142 })
1143
1144 It("should SetGet", func() {
1145 set := client.Set("key", "hello", 0)
1146 Expect(set.Err()).NotTo(HaveOccurred())
1147 Expect(set.Val()).To(Equal("OK"))
1148
1149 get := client.Get("key")
1150 Expect(get.Err()).NotTo(HaveOccurred())
1151 Expect(get.Val()).To(Equal("hello"))
1152 })
1153
1154 It("should SetNX", func() {
1155 setNX := client.SetNX("key", "hello", 0)
1156 Expect(setNX.Err()).NotTo(HaveOccurred())
1157 Expect(setNX.Val()).To(Equal(true))
1158
1159 setNX = client.SetNX("key", "hello2", 0)
1160 Expect(setNX.Err()).NotTo(HaveOccurred())
1161 Expect(setNX.Val()).To(Equal(false))
1162
1163 get := client.Get("key")
1164 Expect(get.Err()).NotTo(HaveOccurred())
1165 Expect(get.Val()).To(Equal("hello"))
1166 })
1167
1168 It("should SetNX with expiration", func() {
1169 isSet, err := client.SetNX("key", "hello", time.Second).Result()
1170 Expect(err).NotTo(HaveOccurred())
1171 Expect(isSet).To(Equal(true))
1172
1173 isSet, err = client.SetNX("key", "hello2", time.Second).Result()
1174 Expect(err).NotTo(HaveOccurred())
1175 Expect(isSet).To(Equal(false))
1176
1177 val, err := client.Get("key").Result()
1178 Expect(err).NotTo(HaveOccurred())
1179 Expect(val).To(Equal("hello"))
1180 })
1181
1182 It("should SetXX", func() {
1183 isSet, err := client.SetXX("key", "hello2", 0).Result()
1184 Expect(err).NotTo(HaveOccurred())
1185 Expect(isSet).To(Equal(false))
1186
1187 err = client.Set("key", "hello", 0).Err()
1188 Expect(err).NotTo(HaveOccurred())
1189
1190 isSet, err = client.SetXX("key", "hello2", 0).Result()
1191 Expect(err).NotTo(HaveOccurred())
1192 Expect(isSet).To(Equal(true))
1193
1194 val, err := client.Get("key").Result()
1195 Expect(err).NotTo(HaveOccurred())
1196 Expect(val).To(Equal("hello2"))
1197 })
1198
1199 It("should SetXX with expiration", func() {
1200 isSet, err := client.SetXX("key", "hello2", time.Second).Result()
1201 Expect(err).NotTo(HaveOccurred())
1202 Expect(isSet).To(Equal(false))
1203
1204 err = client.Set("key", "hello", time.Second).Err()
1205 Expect(err).NotTo(HaveOccurred())
1206
1207 isSet, err = client.SetXX("key", "hello2", time.Second).Result()
1208 Expect(err).NotTo(HaveOccurred())
1209 Expect(isSet).To(Equal(true))
1210
1211 val, err := client.Get("key").Result()
1212 Expect(err).NotTo(HaveOccurred())
1213 Expect(val).To(Equal("hello2"))
1214 })
1215
1216 It("should SetRange", func() {
1217 set := client.Set("key", "Hello World", 0)
1218 Expect(set.Err()).NotTo(HaveOccurred())
1219 Expect(set.Val()).To(Equal("OK"))
1220
1221 range_ := client.SetRange("key", 6, "Redis")
1222 Expect(range_.Err()).NotTo(HaveOccurred())
1223 Expect(range_.Val()).To(Equal(int64(11)))
1224
1225 get := client.Get("key")
1226 Expect(get.Err()).NotTo(HaveOccurred())
1227 Expect(get.Val()).To(Equal("Hello Redis"))
1228 })
1229
1230 It("should StrLen", func() {
1231 set := client.Set("key", "hello", 0)
1232 Expect(set.Err()).NotTo(HaveOccurred())
1233 Expect(set.Val()).To(Equal("OK"))
1234
1235 strLen := client.StrLen("key")
1236 Expect(strLen.Err()).NotTo(HaveOccurred())
1237 Expect(strLen.Val()).To(Equal(int64(5)))
1238
1239 strLen = client.StrLen("_")
1240 Expect(strLen.Err()).NotTo(HaveOccurred())
1241 Expect(strLen.Val()).To(Equal(int64(0)))
1242 })
1243
1244 })
1245
1246 Describe("hashes", func() {
1247
1248 It("should HDel", func() {
1249 hSet := client.HSet("hash", "key", "hello")
1250 Expect(hSet.Err()).NotTo(HaveOccurred())
1251
1252 hDel := client.HDel("hash", "key")
1253 Expect(hDel.Err()).NotTo(HaveOccurred())
1254 Expect(hDel.Val()).To(Equal(int64(1)))
1255
1256 hDel = client.HDel("hash", "key")
1257 Expect(hDel.Err()).NotTo(HaveOccurred())
1258 Expect(hDel.Val()).To(Equal(int64(0)))
1259 })
1260
1261 It("should HExists", func() {
1262 hSet := client.HSet("hash", "key", "hello")
1263 Expect(hSet.Err()).NotTo(HaveOccurred())
1264
1265 hExists := client.HExists("hash", "key")
1266 Expect(hExists.Err()).NotTo(HaveOccurred())
1267 Expect(hExists.Val()).To(Equal(true))
1268
1269 hExists = client.HExists("hash", "key1")
1270 Expect(hExists.Err()).NotTo(HaveOccurred())
1271 Expect(hExists.Val()).To(Equal(false))
1272 })
1273
1274 It("should HGet", func() {
1275 hSet := client.HSet("hash", "key", "hello")
1276 Expect(hSet.Err()).NotTo(HaveOccurred())
1277
1278 hGet := client.HGet("hash", "key")
1279 Expect(hGet.Err()).NotTo(HaveOccurred())
1280 Expect(hGet.Val()).To(Equal("hello"))
1281
1282 hGet = client.HGet("hash", "key1")
1283 Expect(hGet.Err()).To(Equal(redis.Nil))
1284 Expect(hGet.Val()).To(Equal(""))
1285 })
1286
1287 It("should HGetAll", func() {
1288 err := client.HSet("hash", "key1", "hello1").Err()
1289 Expect(err).NotTo(HaveOccurred())
1290 err = client.HSet("hash", "key2", "hello2").Err()
1291 Expect(err).NotTo(HaveOccurred())
1292
1293 m, err := client.HGetAll("hash").Result()
1294 Expect(err).NotTo(HaveOccurred())
1295 Expect(m).To(Equal(map[string]string{"key1": "hello1", "key2": "hello2"}))
1296 })
1297
1298 It("should HIncrBy", func() {
1299 hSet := client.HSet("hash", "key", "5")
1300 Expect(hSet.Err()).NotTo(HaveOccurred())
1301
1302 hIncrBy := client.HIncrBy("hash", "key", 1)
1303 Expect(hIncrBy.Err()).NotTo(HaveOccurred())
1304 Expect(hIncrBy.Val()).To(Equal(int64(6)))
1305
1306 hIncrBy = client.HIncrBy("hash", "key", -1)
1307 Expect(hIncrBy.Err()).NotTo(HaveOccurred())
1308 Expect(hIncrBy.Val()).To(Equal(int64(5)))
1309
1310 hIncrBy = client.HIncrBy("hash", "key", -10)
1311 Expect(hIncrBy.Err()).NotTo(HaveOccurred())
1312 Expect(hIncrBy.Val()).To(Equal(int64(-5)))
1313 })
1314
1315 It("should HIncrByFloat", func() {
1316 hSet := client.HSet("hash", "field", "10.50")
1317 Expect(hSet.Err()).NotTo(HaveOccurred())
1318 Expect(hSet.Val()).To(Equal(true))
1319
1320 hIncrByFloat := client.HIncrByFloat("hash", "field", 0.1)
1321 Expect(hIncrByFloat.Err()).NotTo(HaveOccurred())
1322 Expect(hIncrByFloat.Val()).To(Equal(10.6))
1323
1324 hSet = client.HSet("hash", "field", "5.0e3")
1325 Expect(hSet.Err()).NotTo(HaveOccurred())
1326 Expect(hSet.Val()).To(Equal(false))
1327
1328 hIncrByFloat = client.HIncrByFloat("hash", "field", 2.0e2)
1329 Expect(hIncrByFloat.Err()).NotTo(HaveOccurred())
1330 Expect(hIncrByFloat.Val()).To(Equal(float64(5200)))
1331 })
1332
1333 It("should HKeys", func() {
1334 hkeys := client.HKeys("hash")
1335 Expect(hkeys.Err()).NotTo(HaveOccurred())
1336 Expect(hkeys.Val()).To(Equal([]string{}))
1337
1338 hset := client.HSet("hash", "key1", "hello1")
1339 Expect(hset.Err()).NotTo(HaveOccurred())
1340 hset = client.HSet("hash", "key2", "hello2")
1341 Expect(hset.Err()).NotTo(HaveOccurred())
1342
1343 hkeys = client.HKeys("hash")
1344 Expect(hkeys.Err()).NotTo(HaveOccurred())
1345 Expect(hkeys.Val()).To(Equal([]string{"key1", "key2"}))
1346 })
1347
1348 It("should HLen", func() {
1349 hSet := client.HSet("hash", "key1", "hello1")
1350 Expect(hSet.Err()).NotTo(HaveOccurred())
1351 hSet = client.HSet("hash", "key2", "hello2")
1352 Expect(hSet.Err()).NotTo(HaveOccurred())
1353
1354 hLen := client.HLen("hash")
1355 Expect(hLen.Err()).NotTo(HaveOccurred())
1356 Expect(hLen.Val()).To(Equal(int64(2)))
1357 })
1358
1359 It("should HMGet", func() {
1360 err := client.HSet("hash", "key1", "hello1").Err()
1361 Expect(err).NotTo(HaveOccurred())
1362 err = client.HSet("hash", "key2", "hello2").Err()
1363 Expect(err).NotTo(HaveOccurred())
1364
1365 vals, err := client.HMGet("hash", "key1", "key2", "_").Result()
1366 Expect(err).NotTo(HaveOccurred())
1367 Expect(vals).To(Equal([]interface{}{"hello1", "hello2", nil}))
1368 })
1369
1370 It("should HMSet", func() {
1371 ok, err := client.HMSet("hash", map[string]interface{}{
1372 "key1": "hello1",
1373 "key2": "hello2",
1374 }).Result()
1375 Expect(err).NotTo(HaveOccurred())
1376 Expect(ok).To(Equal("OK"))
1377
1378 v, err := client.HGet("hash", "key1").Result()
1379 Expect(err).NotTo(HaveOccurred())
1380 Expect(v).To(Equal("hello1"))
1381
1382 v, err = client.HGet("hash", "key2").Result()
1383 Expect(err).NotTo(HaveOccurred())
1384 Expect(v).To(Equal("hello2"))
1385 })
1386
1387 It("should HSet", func() {
1388 hSet := client.HSet("hash", "key", "hello")
1389 Expect(hSet.Err()).NotTo(HaveOccurred())
1390 Expect(hSet.Val()).To(Equal(true))
1391
1392 hGet := client.HGet("hash", "key")
1393 Expect(hGet.Err()).NotTo(HaveOccurred())
1394 Expect(hGet.Val()).To(Equal("hello"))
1395 })
1396
1397 It("should HSetNX", func() {
1398 hSetNX := client.HSetNX("hash", "key", "hello")
1399 Expect(hSetNX.Err()).NotTo(HaveOccurred())
1400 Expect(hSetNX.Val()).To(Equal(true))
1401
1402 hSetNX = client.HSetNX("hash", "key", "hello")
1403 Expect(hSetNX.Err()).NotTo(HaveOccurred())
1404 Expect(hSetNX.Val()).To(Equal(false))
1405
1406 hGet := client.HGet("hash", "key")
1407 Expect(hGet.Err()).NotTo(HaveOccurred())
1408 Expect(hGet.Val()).To(Equal("hello"))
1409 })
1410
1411 It("should HVals", func() {
1412 err := client.HSet("hash", "key1", "hello1").Err()
1413 Expect(err).NotTo(HaveOccurred())
1414 err = client.HSet("hash", "key2", "hello2").Err()
1415 Expect(err).NotTo(HaveOccurred())
1416
1417 v, err := client.HVals("hash").Result()
1418 Expect(err).NotTo(HaveOccurred())
1419 Expect(v).To(Equal([]string{"hello1", "hello2"}))
1420
1421 var slice []string
1422 err = client.HVals("hash").ScanSlice(&slice)
1423 Expect(err).NotTo(HaveOccurred())
1424 Expect(slice).To(Equal([]string{"hello1", "hello2"}))
1425 })
1426
1427 })
1428
1429 Describe("hyperloglog", func() {
1430 It("should PFMerge", func() {
1431 pfAdd := client.PFAdd("hll1", "1", "2", "3", "4", "5")
1432 Expect(pfAdd.Err()).NotTo(HaveOccurred())
1433
1434 pfCount := client.PFCount("hll1")
1435 Expect(pfCount.Err()).NotTo(HaveOccurred())
1436 Expect(pfCount.Val()).To(Equal(int64(5)))
1437
1438 pfAdd = client.PFAdd("hll2", "a", "b", "c", "d", "e")
1439 Expect(pfAdd.Err()).NotTo(HaveOccurred())
1440
1441 pfMerge := client.PFMerge("hllMerged", "hll1", "hll2")
1442 Expect(pfMerge.Err()).NotTo(HaveOccurred())
1443
1444 pfCount = client.PFCount("hllMerged")
1445 Expect(pfCount.Err()).NotTo(HaveOccurred())
1446 Expect(pfCount.Val()).To(Equal(int64(10)))
1447
1448 pfCount = client.PFCount("hll1", "hll2")
1449 Expect(pfCount.Err()).NotTo(HaveOccurred())
1450 Expect(pfCount.Val()).To(Equal(int64(10)))
1451 })
1452 })
1453
1454 Describe("lists", func() {
1455
1456 It("should BLPop", func() {
1457 rPush := client.RPush("list1", "a", "b", "c")
1458 Expect(rPush.Err()).NotTo(HaveOccurred())
1459
1460 bLPop := client.BLPop(0, "list1", "list2")
1461 Expect(bLPop.Err()).NotTo(HaveOccurred())
1462 Expect(bLPop.Val()).To(Equal([]string{"list1", "a"}))
1463 })
1464
1465 It("should BLPopBlocks", func() {
1466 started := make(chan bool)
1467 done := make(chan bool)
1468 go func() {
1469 defer GinkgoRecover()
1470
1471 started <- true
1472 bLPop := client.BLPop(0, "list")
1473 Expect(bLPop.Err()).NotTo(HaveOccurred())
1474 Expect(bLPop.Val()).To(Equal([]string{"list", "a"}))
1475 done <- true
1476 }()
1477 <-started
1478
1479 select {
1480 case <-done:
1481 Fail("BLPop is not blocked")
1482 case <-time.After(time.Second):
1483
1484 }
1485
1486 rPush := client.RPush("list", "a")
1487 Expect(rPush.Err()).NotTo(HaveOccurred())
1488
1489 select {
1490 case <-done:
1491
1492 case <-time.After(time.Second):
1493 Fail("BLPop is still blocked")
1494 }
1495 })
1496
1497 It("should BLPop timeout", func() {
1498 val, err := client.BLPop(time.Second, "list1").Result()
1499 Expect(err).To(Equal(redis.Nil))
1500 Expect(val).To(BeNil())
1501
1502 Expect(client.Ping().Err()).NotTo(HaveOccurred())
1503
1504 stats := client.PoolStats()
1505 Expect(stats.Hits).To(Equal(uint32(1)))
1506 Expect(stats.Misses).To(Equal(uint32(2)))
1507 Expect(stats.Timeouts).To(Equal(uint32(0)))
1508 })
1509
1510 It("should BRPop", func() {
1511 rPush := client.RPush("list1", "a", "b", "c")
1512 Expect(rPush.Err()).NotTo(HaveOccurred())
1513
1514 bRPop := client.BRPop(0, "list1", "list2")
1515 Expect(bRPop.Err()).NotTo(HaveOccurred())
1516 Expect(bRPop.Val()).To(Equal([]string{"list1", "c"}))
1517 })
1518
1519 It("should BRPop blocks", func() {
1520 started := make(chan bool)
1521 done := make(chan bool)
1522 go func() {
1523 defer GinkgoRecover()
1524
1525 started <- true
1526 brpop := client.BRPop(0, "list")
1527 Expect(brpop.Err()).NotTo(HaveOccurred())
1528 Expect(brpop.Val()).To(Equal([]string{"list", "a"}))
1529 done <- true
1530 }()
1531 <-started
1532
1533 select {
1534 case <-done:
1535 Fail("BRPop is not blocked")
1536 case <-time.After(time.Second):
1537
1538 }
1539
1540 rPush := client.RPush("list", "a")
1541 Expect(rPush.Err()).NotTo(HaveOccurred())
1542
1543 select {
1544 case <-done:
1545
1546 case <-time.After(time.Second):
1547 Fail("BRPop is still blocked")
1548
1549 }
1550 })
1551
1552 It("should BRPopLPush", func() {
1553 _, err := client.BRPopLPush("list1", "list2", time.Second).Result()
1554 Expect(err).To(Equal(redis.Nil))
1555
1556 err = client.RPush("list1", "a", "b", "c").Err()
1557 Expect(err).NotTo(HaveOccurred())
1558
1559 v, err := client.BRPopLPush("list1", "list2", 0).Result()
1560 Expect(err).NotTo(HaveOccurred())
1561 Expect(v).To(Equal("c"))
1562 })
1563
1564 It("should LIndex", func() {
1565 lPush := client.LPush("list", "World")
1566 Expect(lPush.Err()).NotTo(HaveOccurred())
1567 lPush = client.LPush("list", "Hello")
1568 Expect(lPush.Err()).NotTo(HaveOccurred())
1569
1570 lIndex := client.LIndex("list", 0)
1571 Expect(lIndex.Err()).NotTo(HaveOccurred())
1572 Expect(lIndex.Val()).To(Equal("Hello"))
1573
1574 lIndex = client.LIndex("list", -1)
1575 Expect(lIndex.Err()).NotTo(HaveOccurred())
1576 Expect(lIndex.Val()).To(Equal("World"))
1577
1578 lIndex = client.LIndex("list", 3)
1579 Expect(lIndex.Err()).To(Equal(redis.Nil))
1580 Expect(lIndex.Val()).To(Equal(""))
1581 })
1582
1583 It("should LInsert", func() {
1584 rPush := client.RPush("list", "Hello")
1585 Expect(rPush.Err()).NotTo(HaveOccurred())
1586 rPush = client.RPush("list", "World")
1587 Expect(rPush.Err()).NotTo(HaveOccurred())
1588
1589 lInsert := client.LInsert("list", "BEFORE", "World", "There")
1590 Expect(lInsert.Err()).NotTo(HaveOccurred())
1591 Expect(lInsert.Val()).To(Equal(int64(3)))
1592
1593 lRange := client.LRange("list", 0, -1)
1594 Expect(lRange.Err()).NotTo(HaveOccurred())
1595 Expect(lRange.Val()).To(Equal([]string{"Hello", "There", "World"}))
1596 })
1597
1598 It("should LLen", func() {
1599 lPush := client.LPush("list", "World")
1600 Expect(lPush.Err()).NotTo(HaveOccurred())
1601 lPush = client.LPush("list", "Hello")
1602 Expect(lPush.Err()).NotTo(HaveOccurred())
1603
1604 lLen := client.LLen("list")
1605 Expect(lLen.Err()).NotTo(HaveOccurred())
1606 Expect(lLen.Val()).To(Equal(int64(2)))
1607 })
1608
1609 It("should LPop", func() {
1610 rPush := client.RPush("list", "one")
1611 Expect(rPush.Err()).NotTo(HaveOccurred())
1612 rPush = client.RPush("list", "two")
1613 Expect(rPush.Err()).NotTo(HaveOccurred())
1614 rPush = client.RPush("list", "three")
1615 Expect(rPush.Err()).NotTo(HaveOccurred())
1616
1617 lPop := client.LPop("list")
1618 Expect(lPop.Err()).NotTo(HaveOccurred())
1619 Expect(lPop.Val()).To(Equal("one"))
1620
1621 lRange := client.LRange("list", 0, -1)
1622 Expect(lRange.Err()).NotTo(HaveOccurred())
1623 Expect(lRange.Val()).To(Equal([]string{"two", "three"}))
1624 })
1625
1626 It("should LPush", func() {
1627 lPush := client.LPush("list", "World")
1628 Expect(lPush.Err()).NotTo(HaveOccurred())
1629 lPush = client.LPush("list", "Hello")
1630 Expect(lPush.Err()).NotTo(HaveOccurred())
1631
1632 lRange := client.LRange("list", 0, -1)
1633 Expect(lRange.Err()).NotTo(HaveOccurred())
1634 Expect(lRange.Val()).To(Equal([]string{"Hello", "World"}))
1635 })
1636
1637 It("should LPushX", func() {
1638 lPush := client.LPush("list", "World")
1639 Expect(lPush.Err()).NotTo(HaveOccurred())
1640
1641 lPushX := client.LPushX("list", "Hello")
1642 Expect(lPushX.Err()).NotTo(HaveOccurred())
1643 Expect(lPushX.Val()).To(Equal(int64(2)))
1644
1645 lPushX = client.LPushX("list2", "Hello")
1646 Expect(lPushX.Err()).NotTo(HaveOccurred())
1647 Expect(lPushX.Val()).To(Equal(int64(0)))
1648
1649 lRange := client.LRange("list", 0, -1)
1650 Expect(lRange.Err()).NotTo(HaveOccurred())
1651 Expect(lRange.Val()).To(Equal([]string{"Hello", "World"}))
1652
1653 lRange = client.LRange("list2", 0, -1)
1654 Expect(lRange.Err()).NotTo(HaveOccurred())
1655 Expect(lRange.Val()).To(Equal([]string{}))
1656 })
1657
1658 It("should LRange", func() {
1659 rPush := client.RPush("list", "one")
1660 Expect(rPush.Err()).NotTo(HaveOccurred())
1661 rPush = client.RPush("list", "two")
1662 Expect(rPush.Err()).NotTo(HaveOccurred())
1663 rPush = client.RPush("list", "three")
1664 Expect(rPush.Err()).NotTo(HaveOccurred())
1665
1666 lRange := client.LRange("list", 0, 0)
1667 Expect(lRange.Err()).NotTo(HaveOccurred())
1668 Expect(lRange.Val()).To(Equal([]string{"one"}))
1669
1670 lRange = client.LRange("list", -3, 2)
1671 Expect(lRange.Err()).NotTo(HaveOccurred())
1672 Expect(lRange.Val()).To(Equal([]string{"one", "two", "three"}))
1673
1674 lRange = client.LRange("list", -100, 100)
1675 Expect(lRange.Err()).NotTo(HaveOccurred())
1676 Expect(lRange.Val()).To(Equal([]string{"one", "two", "three"}))
1677
1678 lRange = client.LRange("list", 5, 10)
1679 Expect(lRange.Err()).NotTo(HaveOccurred())
1680 Expect(lRange.Val()).To(Equal([]string{}))
1681 })
1682
1683 It("should LRem", func() {
1684 rPush := client.RPush("list", "hello")
1685 Expect(rPush.Err()).NotTo(HaveOccurred())
1686 rPush = client.RPush("list", "hello")
1687 Expect(rPush.Err()).NotTo(HaveOccurred())
1688 rPush = client.RPush("list", "key")
1689 Expect(rPush.Err()).NotTo(HaveOccurred())
1690 rPush = client.RPush("list", "hello")
1691 Expect(rPush.Err()).NotTo(HaveOccurred())
1692
1693 lRem := client.LRem("list", -2, "hello")
1694 Expect(lRem.Err()).NotTo(HaveOccurred())
1695 Expect(lRem.Val()).To(Equal(int64(2)))
1696
1697 lRange := client.LRange("list", 0, -1)
1698 Expect(lRange.Err()).NotTo(HaveOccurred())
1699 Expect(lRange.Val()).To(Equal([]string{"hello", "key"}))
1700 })
1701
1702 It("should LSet", func() {
1703 rPush := client.RPush("list", "one")
1704 Expect(rPush.Err()).NotTo(HaveOccurred())
1705 rPush = client.RPush("list", "two")
1706 Expect(rPush.Err()).NotTo(HaveOccurred())
1707 rPush = client.RPush("list", "three")
1708 Expect(rPush.Err()).NotTo(HaveOccurred())
1709
1710 lSet := client.LSet("list", 0, "four")
1711 Expect(lSet.Err()).NotTo(HaveOccurred())
1712 Expect(lSet.Val()).To(Equal("OK"))
1713
1714 lSet = client.LSet("list", -2, "five")
1715 Expect(lSet.Err()).NotTo(HaveOccurred())
1716 Expect(lSet.Val()).To(Equal("OK"))
1717
1718 lRange := client.LRange("list", 0, -1)
1719 Expect(lRange.Err()).NotTo(HaveOccurred())
1720 Expect(lRange.Val()).To(Equal([]string{"four", "five", "three"}))
1721 })
1722
1723 It("should LTrim", func() {
1724 rPush := client.RPush("list", "one")
1725 Expect(rPush.Err()).NotTo(HaveOccurred())
1726 rPush = client.RPush("list", "two")
1727 Expect(rPush.Err()).NotTo(HaveOccurred())
1728 rPush = client.RPush("list", "three")
1729 Expect(rPush.Err()).NotTo(HaveOccurred())
1730
1731 lTrim := client.LTrim("list", 1, -1)
1732 Expect(lTrim.Err()).NotTo(HaveOccurred())
1733 Expect(lTrim.Val()).To(Equal("OK"))
1734
1735 lRange := client.LRange("list", 0, -1)
1736 Expect(lRange.Err()).NotTo(HaveOccurred())
1737 Expect(lRange.Val()).To(Equal([]string{"two", "three"}))
1738 })
1739
1740 It("should RPop", func() {
1741 rPush := client.RPush("list", "one")
1742 Expect(rPush.Err()).NotTo(HaveOccurred())
1743 rPush = client.RPush("list", "two")
1744 Expect(rPush.Err()).NotTo(HaveOccurred())
1745 rPush = client.RPush("list", "three")
1746 Expect(rPush.Err()).NotTo(HaveOccurred())
1747
1748 rPop := client.RPop("list")
1749 Expect(rPop.Err()).NotTo(HaveOccurred())
1750 Expect(rPop.Val()).To(Equal("three"))
1751
1752 lRange := client.LRange("list", 0, -1)
1753 Expect(lRange.Err()).NotTo(HaveOccurred())
1754 Expect(lRange.Val()).To(Equal([]string{"one", "two"}))
1755 })
1756
1757 It("should RPopLPush", func() {
1758 rPush := client.RPush("list", "one")
1759 Expect(rPush.Err()).NotTo(HaveOccurred())
1760 rPush = client.RPush("list", "two")
1761 Expect(rPush.Err()).NotTo(HaveOccurred())
1762 rPush = client.RPush("list", "three")
1763 Expect(rPush.Err()).NotTo(HaveOccurred())
1764
1765 rPopLPush := client.RPopLPush("list", "list2")
1766 Expect(rPopLPush.Err()).NotTo(HaveOccurred())
1767 Expect(rPopLPush.Val()).To(Equal("three"))
1768
1769 lRange := client.LRange("list", 0, -1)
1770 Expect(lRange.Err()).NotTo(HaveOccurred())
1771 Expect(lRange.Val()).To(Equal([]string{"one", "two"}))
1772
1773 lRange = client.LRange("list2", 0, -1)
1774 Expect(lRange.Err()).NotTo(HaveOccurred())
1775 Expect(lRange.Val()).To(Equal([]string{"three"}))
1776 })
1777
1778 It("should RPush", func() {
1779 rPush := client.RPush("list", "Hello")
1780 Expect(rPush.Err()).NotTo(HaveOccurred())
1781 Expect(rPush.Val()).To(Equal(int64(1)))
1782
1783 rPush = client.RPush("list", "World")
1784 Expect(rPush.Err()).NotTo(HaveOccurred())
1785 Expect(rPush.Val()).To(Equal(int64(2)))
1786
1787 lRange := client.LRange("list", 0, -1)
1788 Expect(lRange.Err()).NotTo(HaveOccurred())
1789 Expect(lRange.Val()).To(Equal([]string{"Hello", "World"}))
1790 })
1791
1792 It("should RPushX", func() {
1793 rPush := client.RPush("list", "Hello")
1794 Expect(rPush.Err()).NotTo(HaveOccurred())
1795 Expect(rPush.Val()).To(Equal(int64(1)))
1796
1797 rPushX := client.RPushX("list", "World")
1798 Expect(rPushX.Err()).NotTo(HaveOccurred())
1799 Expect(rPushX.Val()).To(Equal(int64(2)))
1800
1801 rPushX = client.RPushX("list2", "World")
1802 Expect(rPushX.Err()).NotTo(HaveOccurred())
1803 Expect(rPushX.Val()).To(Equal(int64(0)))
1804
1805 lRange := client.LRange("list", 0, -1)
1806 Expect(lRange.Err()).NotTo(HaveOccurred())
1807 Expect(lRange.Val()).To(Equal([]string{"Hello", "World"}))
1808
1809 lRange = client.LRange("list2", 0, -1)
1810 Expect(lRange.Err()).NotTo(HaveOccurred())
1811 Expect(lRange.Val()).To(Equal([]string{}))
1812 })
1813
1814 })
1815
1816 Describe("sets", func() {
1817
1818 It("should SAdd", func() {
1819 sAdd := client.SAdd("set", "Hello")
1820 Expect(sAdd.Err()).NotTo(HaveOccurred())
1821 Expect(sAdd.Val()).To(Equal(int64(1)))
1822
1823 sAdd = client.SAdd("set", "World")
1824 Expect(sAdd.Err()).NotTo(HaveOccurred())
1825 Expect(sAdd.Val()).To(Equal(int64(1)))
1826
1827 sAdd = client.SAdd("set", "World")
1828 Expect(sAdd.Err()).NotTo(HaveOccurred())
1829 Expect(sAdd.Val()).To(Equal(int64(0)))
1830
1831 sMembers := client.SMembers("set")
1832 Expect(sMembers.Err()).NotTo(HaveOccurred())
1833 Expect(sMembers.Val()).To(ConsistOf([]string{"Hello", "World"}))
1834 })
1835
1836 It("should SAdd strings", func() {
1837 set := []string{"Hello", "World", "World"}
1838 sAdd := client.SAdd("set", set)
1839 Expect(sAdd.Err()).NotTo(HaveOccurred())
1840 Expect(sAdd.Val()).To(Equal(int64(2)))
1841
1842 sMembers := client.SMembers("set")
1843 Expect(sMembers.Err()).NotTo(HaveOccurred())
1844 Expect(sMembers.Val()).To(ConsistOf([]string{"Hello", "World"}))
1845 })
1846
1847 It("should SCard", func() {
1848 sAdd := client.SAdd("set", "Hello")
1849 Expect(sAdd.Err()).NotTo(HaveOccurred())
1850 Expect(sAdd.Val()).To(Equal(int64(1)))
1851
1852 sAdd = client.SAdd("set", "World")
1853 Expect(sAdd.Err()).NotTo(HaveOccurred())
1854 Expect(sAdd.Val()).To(Equal(int64(1)))
1855
1856 sCard := client.SCard("set")
1857 Expect(sCard.Err()).NotTo(HaveOccurred())
1858 Expect(sCard.Val()).To(Equal(int64(2)))
1859 })
1860
1861 It("should SDiff", func() {
1862 sAdd := client.SAdd("set1", "a")
1863 Expect(sAdd.Err()).NotTo(HaveOccurred())
1864 sAdd = client.SAdd("set1", "b")
1865 Expect(sAdd.Err()).NotTo(HaveOccurred())
1866 sAdd = client.SAdd("set1", "c")
1867 Expect(sAdd.Err()).NotTo(HaveOccurred())
1868
1869 sAdd = client.SAdd("set2", "c")
1870 Expect(sAdd.Err()).NotTo(HaveOccurred())
1871 sAdd = client.SAdd("set2", "d")
1872 Expect(sAdd.Err()).NotTo(HaveOccurred())
1873 sAdd = client.SAdd("set2", "e")
1874 Expect(sAdd.Err()).NotTo(HaveOccurred())
1875
1876 sDiff := client.SDiff("set1", "set2")
1877 Expect(sDiff.Err()).NotTo(HaveOccurred())
1878 Expect(sDiff.Val()).To(ConsistOf([]string{"a", "b"}))
1879 })
1880
1881 It("should SDiffStore", func() {
1882 sAdd := client.SAdd("set1", "a")
1883 Expect(sAdd.Err()).NotTo(HaveOccurred())
1884 sAdd = client.SAdd("set1", "b")
1885 Expect(sAdd.Err()).NotTo(HaveOccurred())
1886 sAdd = client.SAdd("set1", "c")
1887 Expect(sAdd.Err()).NotTo(HaveOccurred())
1888
1889 sAdd = client.SAdd("set2", "c")
1890 Expect(sAdd.Err()).NotTo(HaveOccurred())
1891 sAdd = client.SAdd("set2", "d")
1892 Expect(sAdd.Err()).NotTo(HaveOccurred())
1893 sAdd = client.SAdd("set2", "e")
1894 Expect(sAdd.Err()).NotTo(HaveOccurred())
1895
1896 sDiffStore := client.SDiffStore("set", "set1", "set2")
1897 Expect(sDiffStore.Err()).NotTo(HaveOccurred())
1898 Expect(sDiffStore.Val()).To(Equal(int64(2)))
1899
1900 sMembers := client.SMembers("set")
1901 Expect(sMembers.Err()).NotTo(HaveOccurred())
1902 Expect(sMembers.Val()).To(ConsistOf([]string{"a", "b"}))
1903 })
1904
1905 It("should SInter", func() {
1906 sAdd := client.SAdd("set1", "a")
1907 Expect(sAdd.Err()).NotTo(HaveOccurred())
1908 sAdd = client.SAdd("set1", "b")
1909 Expect(sAdd.Err()).NotTo(HaveOccurred())
1910 sAdd = client.SAdd("set1", "c")
1911 Expect(sAdd.Err()).NotTo(HaveOccurred())
1912
1913 sAdd = client.SAdd("set2", "c")
1914 Expect(sAdd.Err()).NotTo(HaveOccurred())
1915 sAdd = client.SAdd("set2", "d")
1916 Expect(sAdd.Err()).NotTo(HaveOccurred())
1917 sAdd = client.SAdd("set2", "e")
1918 Expect(sAdd.Err()).NotTo(HaveOccurred())
1919
1920 sInter := client.SInter("set1", "set2")
1921 Expect(sInter.Err()).NotTo(HaveOccurred())
1922 Expect(sInter.Val()).To(Equal([]string{"c"}))
1923 })
1924
1925 It("should SInterStore", func() {
1926 sAdd := client.SAdd("set1", "a")
1927 Expect(sAdd.Err()).NotTo(HaveOccurred())
1928 sAdd = client.SAdd("set1", "b")
1929 Expect(sAdd.Err()).NotTo(HaveOccurred())
1930 sAdd = client.SAdd("set1", "c")
1931 Expect(sAdd.Err()).NotTo(HaveOccurred())
1932
1933 sAdd = client.SAdd("set2", "c")
1934 Expect(sAdd.Err()).NotTo(HaveOccurred())
1935 sAdd = client.SAdd("set2", "d")
1936 Expect(sAdd.Err()).NotTo(HaveOccurred())
1937 sAdd = client.SAdd("set2", "e")
1938 Expect(sAdd.Err()).NotTo(HaveOccurred())
1939
1940 sInterStore := client.SInterStore("set", "set1", "set2")
1941 Expect(sInterStore.Err()).NotTo(HaveOccurred())
1942 Expect(sInterStore.Val()).To(Equal(int64(1)))
1943
1944 sMembers := client.SMembers("set")
1945 Expect(sMembers.Err()).NotTo(HaveOccurred())
1946 Expect(sMembers.Val()).To(Equal([]string{"c"}))
1947 })
1948
1949 It("should IsMember", func() {
1950 sAdd := client.SAdd("set", "one")
1951 Expect(sAdd.Err()).NotTo(HaveOccurred())
1952
1953 sIsMember := client.SIsMember("set", "one")
1954 Expect(sIsMember.Err()).NotTo(HaveOccurred())
1955 Expect(sIsMember.Val()).To(Equal(true))
1956
1957 sIsMember = client.SIsMember("set", "two")
1958 Expect(sIsMember.Err()).NotTo(HaveOccurred())
1959 Expect(sIsMember.Val()).To(Equal(false))
1960 })
1961
1962 It("should SMembers", func() {
1963 sAdd := client.SAdd("set", "Hello")
1964 Expect(sAdd.Err()).NotTo(HaveOccurred())
1965 sAdd = client.SAdd("set", "World")
1966 Expect(sAdd.Err()).NotTo(HaveOccurred())
1967
1968 sMembers := client.SMembers("set")
1969 Expect(sMembers.Err()).NotTo(HaveOccurred())
1970 Expect(sMembers.Val()).To(ConsistOf([]string{"Hello", "World"}))
1971 })
1972
1973 It("should SMembersMap", func() {
1974 sAdd := client.SAdd("set", "Hello")
1975 Expect(sAdd.Err()).NotTo(HaveOccurred())
1976 sAdd = client.SAdd("set", "World")
1977 Expect(sAdd.Err()).NotTo(HaveOccurred())
1978
1979 sMembersMap := client.SMembersMap("set")
1980 Expect(sMembersMap.Err()).NotTo(HaveOccurred())
1981 Expect(sMembersMap.Val()).To(Equal(map[string]struct{}{"Hello": {}, "World": {}}))
1982 })
1983
1984 It("should SMove", func() {
1985 sAdd := client.SAdd("set1", "one")
1986 Expect(sAdd.Err()).NotTo(HaveOccurred())
1987 sAdd = client.SAdd("set1", "two")
1988 Expect(sAdd.Err()).NotTo(HaveOccurred())
1989
1990 sAdd = client.SAdd("set2", "three")
1991 Expect(sAdd.Err()).NotTo(HaveOccurred())
1992
1993 sMove := client.SMove("set1", "set2", "two")
1994 Expect(sMove.Err()).NotTo(HaveOccurred())
1995 Expect(sMove.Val()).To(Equal(true))
1996
1997 sMembers := client.SMembers("set1")
1998 Expect(sMembers.Err()).NotTo(HaveOccurred())
1999 Expect(sMembers.Val()).To(Equal([]string{"one"}))
2000
2001 sMembers = client.SMembers("set2")
2002 Expect(sMembers.Err()).NotTo(HaveOccurred())
2003 Expect(sMembers.Val()).To(ConsistOf([]string{"three", "two"}))
2004 })
2005
2006 It("should SPop", func() {
2007 sAdd := client.SAdd("set", "one")
2008 Expect(sAdd.Err()).NotTo(HaveOccurred())
2009 sAdd = client.SAdd("set", "two")
2010 Expect(sAdd.Err()).NotTo(HaveOccurred())
2011 sAdd = client.SAdd("set", "three")
2012 Expect(sAdd.Err()).NotTo(HaveOccurred())
2013
2014 sPop := client.SPop("set")
2015 Expect(sPop.Err()).NotTo(HaveOccurred())
2016 Expect(sPop.Val()).NotTo(Equal(""))
2017
2018 sMembers := client.SMembers("set")
2019 Expect(sMembers.Err()).NotTo(HaveOccurred())
2020 Expect(sMembers.Val()).To(HaveLen(2))
2021
2022 })
2023
2024 It("should SPopN", func() {
2025 sAdd := client.SAdd("set", "one")
2026 Expect(sAdd.Err()).NotTo(HaveOccurred())
2027 sAdd = client.SAdd("set", "two")
2028 Expect(sAdd.Err()).NotTo(HaveOccurred())
2029 sAdd = client.SAdd("set", "three")
2030 Expect(sAdd.Err()).NotTo(HaveOccurred())
2031 sAdd = client.SAdd("set", "four")
2032 Expect(sAdd.Err()).NotTo(HaveOccurred())
2033
2034 sPopN := client.SPopN("set", 1)
2035 Expect(sPopN.Err()).NotTo(HaveOccurred())
2036 Expect(sPopN.Val()).NotTo(Equal([]string{""}))
2037
2038 sMembers := client.SMembers("set")
2039 Expect(sMembers.Err()).NotTo(HaveOccurred())
2040 Expect(sMembers.Val()).To(HaveLen(3))
2041
2042 sPopN = client.SPopN("set", 4)
2043 Expect(sPopN.Err()).NotTo(HaveOccurred())
2044 Expect(sPopN.Val()).To(HaveLen(3))
2045
2046 sMembers = client.SMembers("set")
2047 Expect(sMembers.Err()).NotTo(HaveOccurred())
2048 Expect(sMembers.Val()).To(HaveLen(0))
2049 })
2050
2051 It("should SRandMember and SRandMemberN", func() {
2052 err := client.SAdd("set", "one").Err()
2053 Expect(err).NotTo(HaveOccurred())
2054 err = client.SAdd("set", "two").Err()
2055 Expect(err).NotTo(HaveOccurred())
2056 err = client.SAdd("set", "three").Err()
2057 Expect(err).NotTo(HaveOccurred())
2058
2059 members, err := client.SMembers("set").Result()
2060 Expect(err).NotTo(HaveOccurred())
2061 Expect(members).To(HaveLen(3))
2062
2063 member, err := client.SRandMember("set").Result()
2064 Expect(err).NotTo(HaveOccurred())
2065 Expect(member).NotTo(Equal(""))
2066
2067 members, err = client.SRandMemberN("set", 2).Result()
2068 Expect(err).NotTo(HaveOccurred())
2069 Expect(members).To(HaveLen(2))
2070 })
2071
2072 It("should SRem", func() {
2073 sAdd := client.SAdd("set", "one")
2074 Expect(sAdd.Err()).NotTo(HaveOccurred())
2075 sAdd = client.SAdd("set", "two")
2076 Expect(sAdd.Err()).NotTo(HaveOccurred())
2077 sAdd = client.SAdd("set", "three")
2078 Expect(sAdd.Err()).NotTo(HaveOccurred())
2079
2080 sRem := client.SRem("set", "one")
2081 Expect(sRem.Err()).NotTo(HaveOccurred())
2082 Expect(sRem.Val()).To(Equal(int64(1)))
2083
2084 sRem = client.SRem("set", "four")
2085 Expect(sRem.Err()).NotTo(HaveOccurred())
2086 Expect(sRem.Val()).To(Equal(int64(0)))
2087
2088 sMembers := client.SMembers("set")
2089 Expect(sMembers.Err()).NotTo(HaveOccurred())
2090 Expect(sMembers.Val()).To(ConsistOf([]string{"three", "two"}))
2091 })
2092
2093 It("should SUnion", func() {
2094 sAdd := client.SAdd("set1", "a")
2095 Expect(sAdd.Err()).NotTo(HaveOccurred())
2096 sAdd = client.SAdd("set1", "b")
2097 Expect(sAdd.Err()).NotTo(HaveOccurred())
2098 sAdd = client.SAdd("set1", "c")
2099 Expect(sAdd.Err()).NotTo(HaveOccurred())
2100
2101 sAdd = client.SAdd("set2", "c")
2102 Expect(sAdd.Err()).NotTo(HaveOccurred())
2103 sAdd = client.SAdd("set2", "d")
2104 Expect(sAdd.Err()).NotTo(HaveOccurred())
2105 sAdd = client.SAdd("set2", "e")
2106 Expect(sAdd.Err()).NotTo(HaveOccurred())
2107
2108 sUnion := client.SUnion("set1", "set2")
2109 Expect(sUnion.Err()).NotTo(HaveOccurred())
2110 Expect(sUnion.Val()).To(HaveLen(5))
2111 })
2112
2113 It("should SUnionStore", func() {
2114 sAdd := client.SAdd("set1", "a")
2115 Expect(sAdd.Err()).NotTo(HaveOccurred())
2116 sAdd = client.SAdd("set1", "b")
2117 Expect(sAdd.Err()).NotTo(HaveOccurred())
2118 sAdd = client.SAdd("set1", "c")
2119 Expect(sAdd.Err()).NotTo(HaveOccurred())
2120
2121 sAdd = client.SAdd("set2", "c")
2122 Expect(sAdd.Err()).NotTo(HaveOccurred())
2123 sAdd = client.SAdd("set2", "d")
2124 Expect(sAdd.Err()).NotTo(HaveOccurred())
2125 sAdd = client.SAdd("set2", "e")
2126 Expect(sAdd.Err()).NotTo(HaveOccurred())
2127
2128 sUnionStore := client.SUnionStore("set", "set1", "set2")
2129 Expect(sUnionStore.Err()).NotTo(HaveOccurred())
2130 Expect(sUnionStore.Val()).To(Equal(int64(5)))
2131
2132 sMembers := client.SMembers("set")
2133 Expect(sMembers.Err()).NotTo(HaveOccurred())
2134 Expect(sMembers.Val()).To(HaveLen(5))
2135 })
2136
2137 })
2138
2139 Describe("sorted sets", func() {
2140
2141 It("should BZPopMax", func() {
2142 err := client.ZAdd("zset1", redis.Z{
2143 Score: 1,
2144 Member: "one",
2145 }).Err()
2146 Expect(err).NotTo(HaveOccurred())
2147 err = client.ZAdd("zset1", redis.Z{
2148 Score: 2,
2149 Member: "two",
2150 }).Err()
2151 Expect(err).NotTo(HaveOccurred())
2152 err = client.ZAdd("zset1", redis.Z{
2153 Score: 3,
2154 Member: "three",
2155 }).Err()
2156 Expect(err).NotTo(HaveOccurred())
2157
2158 member, err := client.BZPopMax(0, "zset1", "zset2").Result()
2159 Expect(err).NotTo(HaveOccurred())
2160 Expect(member).To(Equal(redis.ZWithKey{
2161 Z: redis.Z{
2162 Score: 3,
2163 Member: "three",
2164 },
2165 Key: "zset1",
2166 }))
2167 })
2168
2169 It("should BZPopMax blocks", func() {
2170 started := make(chan bool)
2171 done := make(chan bool)
2172 go func() {
2173 defer GinkgoRecover()
2174
2175 started <- true
2176 bZPopMax := client.BZPopMax(0, "zset")
2177 Expect(bZPopMax.Err()).NotTo(HaveOccurred())
2178 Expect(bZPopMax.Val()).To(Equal(redis.ZWithKey{
2179 Z: redis.Z{
2180 Member: "a",
2181 Score: 1,
2182 },
2183 Key: "zset",
2184 }))
2185 done <- true
2186 }()
2187 <-started
2188
2189 select {
2190 case <-done:
2191 Fail("BZPopMax is not blocked")
2192 case <-time.After(time.Second):
2193
2194 }
2195
2196 zAdd := client.ZAdd("zset", redis.Z{
2197 Member: "a",
2198 Score: 1,
2199 })
2200 Expect(zAdd.Err()).NotTo(HaveOccurred())
2201
2202 select {
2203 case <-done:
2204
2205 case <-time.After(time.Second):
2206 Fail("BZPopMax is still blocked")
2207 }
2208 })
2209
2210 It("should BZPopMax timeout", func() {
2211 val, err := client.BZPopMax(time.Second, "zset1").Result()
2212 Expect(err).To(Equal(redis.Nil))
2213 Expect(val).To(Equal(redis.ZWithKey{}))
2214
2215 Expect(client.Ping().Err()).NotTo(HaveOccurred())
2216
2217 stats := client.PoolStats()
2218 Expect(stats.Hits).To(Equal(uint32(1)))
2219 Expect(stats.Misses).To(Equal(uint32(2)))
2220 Expect(stats.Timeouts).To(Equal(uint32(0)))
2221 })
2222
2223 It("should BZPopMin", func() {
2224 err := client.ZAdd("zset1", redis.Z{
2225 Score: 1,
2226 Member: "one",
2227 }).Err()
2228 Expect(err).NotTo(HaveOccurred())
2229 err = client.ZAdd("zset1", redis.Z{
2230 Score: 2,
2231 Member: "two",
2232 }).Err()
2233 Expect(err).NotTo(HaveOccurred())
2234 err = client.ZAdd("zset1", redis.Z{
2235 Score: 3,
2236 Member: "three",
2237 }).Err()
2238 Expect(err).NotTo(HaveOccurred())
2239
2240 member, err := client.BZPopMin(0, "zset1", "zset2").Result()
2241 Expect(err).NotTo(HaveOccurred())
2242 Expect(member).To(Equal(redis.ZWithKey{
2243 Z: redis.Z{
2244 Score: 1,
2245 Member: "one",
2246 },
2247 Key: "zset1",
2248 }))
2249 })
2250
2251 It("should BZPopMin blocks", func() {
2252 started := make(chan bool)
2253 done := make(chan bool)
2254 go func() {
2255 defer GinkgoRecover()
2256
2257 started <- true
2258 bZPopMin := client.BZPopMin(0, "zset")
2259 Expect(bZPopMin.Err()).NotTo(HaveOccurred())
2260 Expect(bZPopMin.Val()).To(Equal(redis.ZWithKey{
2261 Z: redis.Z{
2262 Member: "a",
2263 Score: 1,
2264 },
2265 Key: "zset",
2266 }))
2267 done <- true
2268 }()
2269 <-started
2270
2271 select {
2272 case <-done:
2273 Fail("BZPopMin is not blocked")
2274 case <-time.After(time.Second):
2275
2276 }
2277
2278 zAdd := client.ZAdd("zset", redis.Z{
2279 Member: "a",
2280 Score: 1,
2281 })
2282 Expect(zAdd.Err()).NotTo(HaveOccurred())
2283
2284 select {
2285 case <-done:
2286
2287 case <-time.After(time.Second):
2288 Fail("BZPopMin is still blocked")
2289 }
2290 })
2291
2292 It("should BZPopMin timeout", func() {
2293 val, err := client.BZPopMin(time.Second, "zset1").Result()
2294 Expect(err).To(Equal(redis.Nil))
2295 Expect(val).To(Equal(redis.ZWithKey{}))
2296
2297 Expect(client.Ping().Err()).NotTo(HaveOccurred())
2298
2299 stats := client.PoolStats()
2300 Expect(stats.Hits).To(Equal(uint32(1)))
2301 Expect(stats.Misses).To(Equal(uint32(2)))
2302 Expect(stats.Timeouts).To(Equal(uint32(0)))
2303 })
2304
2305 It("should ZAdd", func() {
2306 added, err := client.ZAdd("zset", redis.Z{
2307 Score: 1,
2308 Member: "one",
2309 }).Result()
2310 Expect(err).NotTo(HaveOccurred())
2311 Expect(added).To(Equal(int64(1)))
2312
2313 added, err = client.ZAdd("zset", redis.Z{
2314 Score: 1,
2315 Member: "uno",
2316 }).Result()
2317 Expect(err).NotTo(HaveOccurred())
2318 Expect(added).To(Equal(int64(1)))
2319
2320 added, err = client.ZAdd("zset", redis.Z{
2321 Score: 2,
2322 Member: "two",
2323 }).Result()
2324 Expect(err).NotTo(HaveOccurred())
2325 Expect(added).To(Equal(int64(1)))
2326
2327 added, err = client.ZAdd("zset", redis.Z{
2328 Score: 3,
2329 Member: "two",
2330 }).Result()
2331 Expect(err).NotTo(HaveOccurred())
2332 Expect(added).To(Equal(int64(0)))
2333
2334 vals, err := client.ZRangeWithScores("zset", 0, -1).Result()
2335 Expect(err).NotTo(HaveOccurred())
2336 Expect(vals).To(Equal([]redis.Z{{
2337 Score: 1,
2338 Member: "one",
2339 }, {
2340 Score: 1,
2341 Member: "uno",
2342 }, {
2343 Score: 3,
2344 Member: "two",
2345 }}))
2346 })
2347
2348 It("should ZAdd bytes", func() {
2349 added, err := client.ZAdd("zset", redis.Z{
2350 Score: 1,
2351 Member: []byte("one"),
2352 }).Result()
2353 Expect(err).NotTo(HaveOccurred())
2354 Expect(added).To(Equal(int64(1)))
2355
2356 added, err = client.ZAdd("zset", redis.Z{
2357 Score: 1,
2358 Member: []byte("uno"),
2359 }).Result()
2360 Expect(err).NotTo(HaveOccurred())
2361 Expect(added).To(Equal(int64(1)))
2362
2363 added, err = client.ZAdd("zset", redis.Z{
2364 Score: 2,
2365 Member: []byte("two"),
2366 }).Result()
2367 Expect(err).NotTo(HaveOccurred())
2368 Expect(added).To(Equal(int64(1)))
2369
2370 added, err = client.ZAdd("zset", redis.Z{
2371 Score: 3,
2372 Member: []byte("two"),
2373 }).Result()
2374 Expect(err).NotTo(HaveOccurred())
2375 Expect(added).To(Equal(int64(0)))
2376
2377 vals, err := client.ZRangeWithScores("zset", 0, -1).Result()
2378 Expect(err).NotTo(HaveOccurred())
2379 Expect(vals).To(Equal([]redis.Z{{
2380 Score: 1,
2381 Member: "one",
2382 }, {
2383 Score: 1,
2384 Member: "uno",
2385 }, {
2386 Score: 3,
2387 Member: "two",
2388 }}))
2389 })
2390
2391 It("should ZAddNX", func() {
2392 added, err := client.ZAddNX("zset", redis.Z{
2393 Score: 1,
2394 Member: "one",
2395 }).Result()
2396 Expect(err).NotTo(HaveOccurred())
2397 Expect(added).To(Equal(int64(1)))
2398
2399 vals, err := client.ZRangeWithScores("zset", 0, -1).Result()
2400 Expect(err).NotTo(HaveOccurred())
2401 Expect(vals).To(Equal([]redis.Z{{Score: 1, Member: "one"}}))
2402
2403 added, err = client.ZAddNX("zset", redis.Z{
2404 Score: 2,
2405 Member: "one",
2406 }).Result()
2407 Expect(err).NotTo(HaveOccurred())
2408 Expect(added).To(Equal(int64(0)))
2409
2410 vals, err = client.ZRangeWithScores("zset", 0, -1).Result()
2411 Expect(err).NotTo(HaveOccurred())
2412 Expect(vals).To(Equal([]redis.Z{{Score: 1, Member: "one"}}))
2413 })
2414
2415 It("should ZAddXX", func() {
2416 added, err := client.ZAddXX("zset", redis.Z{
2417 Score: 1,
2418 Member: "one",
2419 }).Result()
2420 Expect(err).NotTo(HaveOccurred())
2421 Expect(added).To(Equal(int64(0)))
2422
2423 vals, err := client.ZRangeWithScores("zset", 0, -1).Result()
2424 Expect(err).NotTo(HaveOccurred())
2425 Expect(vals).To(BeEmpty())
2426
2427 added, err = client.ZAdd("zset", redis.Z{
2428 Score: 1,
2429 Member: "one",
2430 }).Result()
2431 Expect(err).NotTo(HaveOccurred())
2432 Expect(added).To(Equal(int64(1)))
2433
2434 added, err = client.ZAddXX("zset", redis.Z{
2435 Score: 2,
2436 Member: "one",
2437 }).Result()
2438 Expect(err).NotTo(HaveOccurred())
2439 Expect(added).To(Equal(int64(0)))
2440
2441 vals, err = client.ZRangeWithScores("zset", 0, -1).Result()
2442 Expect(err).NotTo(HaveOccurred())
2443 Expect(vals).To(Equal([]redis.Z{{Score: 2, Member: "one"}}))
2444 })
2445
2446 It("should ZAddCh", func() {
2447 changed, err := client.ZAddCh("zset", redis.Z{
2448 Score: 1,
2449 Member: "one",
2450 }).Result()
2451 Expect(err).NotTo(HaveOccurred())
2452 Expect(changed).To(Equal(int64(1)))
2453
2454 changed, err = client.ZAddCh("zset", redis.Z{
2455 Score: 1,
2456 Member: "one",
2457 }).Result()
2458 Expect(err).NotTo(HaveOccurred())
2459 Expect(changed).To(Equal(int64(0)))
2460 })
2461
2462 It("should ZAddNXCh", func() {
2463 changed, err := client.ZAddNXCh("zset", redis.Z{
2464 Score: 1,
2465 Member: "one",
2466 }).Result()
2467 Expect(err).NotTo(HaveOccurred())
2468 Expect(changed).To(Equal(int64(1)))
2469
2470 vals, err := client.ZRangeWithScores("zset", 0, -1).Result()
2471 Expect(err).NotTo(HaveOccurred())
2472 Expect(vals).To(Equal([]redis.Z{{Score: 1, Member: "one"}}))
2473
2474 changed, err = client.ZAddNXCh("zset", redis.Z{
2475 Score: 2,
2476 Member: "one",
2477 }).Result()
2478 Expect(err).NotTo(HaveOccurred())
2479 Expect(changed).To(Equal(int64(0)))
2480
2481 vals, err = client.ZRangeWithScores("zset", 0, -1).Result()
2482 Expect(err).NotTo(HaveOccurred())
2483 Expect(vals).To(Equal([]redis.Z{{
2484 Score: 1,
2485 Member: "one",
2486 }}))
2487 })
2488
2489 It("should ZAddXXCh", func() {
2490 changed, err := client.ZAddXXCh("zset", redis.Z{
2491 Score: 1,
2492 Member: "one",
2493 }).Result()
2494 Expect(err).NotTo(HaveOccurred())
2495 Expect(changed).To(Equal(int64(0)))
2496
2497 vals, err := client.ZRangeWithScores("zset", 0, -1).Result()
2498 Expect(err).NotTo(HaveOccurred())
2499 Expect(vals).To(BeEmpty())
2500
2501 added, err := client.ZAdd("zset", redis.Z{
2502 Score: 1,
2503 Member: "one",
2504 }).Result()
2505 Expect(err).NotTo(HaveOccurred())
2506 Expect(added).To(Equal(int64(1)))
2507
2508 changed, err = client.ZAddXXCh("zset", redis.Z{
2509 Score: 2,
2510 Member: "one",
2511 }).Result()
2512 Expect(err).NotTo(HaveOccurred())
2513 Expect(changed).To(Equal(int64(1)))
2514
2515 vals, err = client.ZRangeWithScores("zset", 0, -1).Result()
2516 Expect(err).NotTo(HaveOccurred())
2517 Expect(vals).To(Equal([]redis.Z{{Score: 2, Member: "one"}}))
2518 })
2519
2520 It("should ZIncr", func() {
2521 score, err := client.ZIncr("zset", redis.Z{
2522 Score: 1,
2523 Member: "one",
2524 }).Result()
2525 Expect(err).NotTo(HaveOccurred())
2526 Expect(score).To(Equal(float64(1)))
2527
2528 vals, err := client.ZRangeWithScores("zset", 0, -1).Result()
2529 Expect(err).NotTo(HaveOccurred())
2530 Expect(vals).To(Equal([]redis.Z{{Score: 1, Member: "one"}}))
2531
2532 score, err = client.ZIncr("zset", redis.Z{Score: 1, Member: "one"}).Result()
2533 Expect(err).NotTo(HaveOccurred())
2534 Expect(score).To(Equal(float64(2)))
2535
2536 vals, err = client.ZRangeWithScores("zset", 0, -1).Result()
2537 Expect(err).NotTo(HaveOccurred())
2538 Expect(vals).To(Equal([]redis.Z{{Score: 2, Member: "one"}}))
2539 })
2540
2541 It("should ZIncrNX", func() {
2542 score, err := client.ZIncrNX("zset", redis.Z{
2543 Score: 1,
2544 Member: "one",
2545 }).Result()
2546 Expect(err).NotTo(HaveOccurred())
2547 Expect(score).To(Equal(float64(1)))
2548
2549 vals, err := client.ZRangeWithScores("zset", 0, -1).Result()
2550 Expect(err).NotTo(HaveOccurred())
2551 Expect(vals).To(Equal([]redis.Z{{Score: 1, Member: "one"}}))
2552
2553 score, err = client.ZIncrNX("zset", redis.Z{
2554 Score: 1,
2555 Member: "one",
2556 }).Result()
2557 Expect(err).To(Equal(redis.Nil))
2558 Expect(score).To(Equal(float64(0)))
2559
2560 vals, err = client.ZRangeWithScores("zset", 0, -1).Result()
2561 Expect(err).NotTo(HaveOccurred())
2562 Expect(vals).To(Equal([]redis.Z{{Score: 1, Member: "one"}}))
2563 })
2564
2565 It("should ZIncrXX", func() {
2566 score, err := client.ZIncrXX("zset", redis.Z{
2567 Score: 1,
2568 Member: "one",
2569 }).Result()
2570 Expect(err).To(Equal(redis.Nil))
2571 Expect(score).To(Equal(float64(0)))
2572
2573 vals, err := client.ZRangeWithScores("zset", 0, -1).Result()
2574 Expect(err).NotTo(HaveOccurred())
2575 Expect(vals).To(BeEmpty())
2576
2577 added, err := client.ZAdd("zset", redis.Z{
2578 Score: 1,
2579 Member: "one",
2580 }).Result()
2581 Expect(err).NotTo(HaveOccurred())
2582 Expect(added).To(Equal(int64(1)))
2583
2584 score, err = client.ZIncrXX("zset", redis.Z{
2585 Score: 1,
2586 Member: "one",
2587 }).Result()
2588 Expect(err).NotTo(HaveOccurred())
2589 Expect(score).To(Equal(float64(2)))
2590
2591 vals, err = client.ZRangeWithScores("zset", 0, -1).Result()
2592 Expect(err).NotTo(HaveOccurred())
2593 Expect(vals).To(Equal([]redis.Z{{Score: 2, Member: "one"}}))
2594 })
2595
2596 It("should ZCard", func() {
2597 err := client.ZAdd("zset", redis.Z{
2598 Score: 1,
2599 Member: "one",
2600 }).Err()
2601 Expect(err).NotTo(HaveOccurred())
2602 err = client.ZAdd("zset", redis.Z{
2603 Score: 2,
2604 Member: "two",
2605 }).Err()
2606 Expect(err).NotTo(HaveOccurred())
2607
2608 card, err := client.ZCard("zset").Result()
2609 Expect(err).NotTo(HaveOccurred())
2610 Expect(card).To(Equal(int64(2)))
2611 })
2612
2613 It("should ZCount", func() {
2614 err := client.ZAdd("zset", redis.Z{
2615 Score: 1,
2616 Member: "one",
2617 }).Err()
2618 Expect(err).NotTo(HaveOccurred())
2619 err = client.ZAdd("zset", redis.Z{
2620 Score: 2,
2621 Member: "two",
2622 }).Err()
2623 Expect(err).NotTo(HaveOccurred())
2624 err = client.ZAdd("zset", redis.Z{
2625 Score: 3,
2626 Member: "three",
2627 }).Err()
2628 Expect(err).NotTo(HaveOccurred())
2629
2630 count, err := client.ZCount("zset", "-inf", "+inf").Result()
2631 Expect(err).NotTo(HaveOccurred())
2632 Expect(count).To(Equal(int64(3)))
2633
2634 count, err = client.ZCount("zset", "(1", "3").Result()
2635 Expect(err).NotTo(HaveOccurred())
2636 Expect(count).To(Equal(int64(2)))
2637
2638 count, err = client.ZLexCount("zset", "-", "+").Result()
2639 Expect(err).NotTo(HaveOccurred())
2640 Expect(count).To(Equal(int64(3)))
2641 })
2642
2643 It("should ZIncrBy", func() {
2644 err := client.ZAdd("zset", redis.Z{
2645 Score: 1,
2646 Member: "one",
2647 }).Err()
2648 Expect(err).NotTo(HaveOccurred())
2649 err = client.ZAdd("zset", redis.Z{
2650 Score: 2,
2651 Member: "two",
2652 }).Err()
2653 Expect(err).NotTo(HaveOccurred())
2654
2655 n, err := client.ZIncrBy("zset", 2, "one").Result()
2656 Expect(err).NotTo(HaveOccurred())
2657 Expect(n).To(Equal(float64(3)))
2658
2659 val, err := client.ZRangeWithScores("zset", 0, -1).Result()
2660 Expect(err).NotTo(HaveOccurred())
2661 Expect(val).To(Equal([]redis.Z{{
2662 Score: 2,
2663 Member: "two",
2664 }, {
2665 Score: 3,
2666 Member: "one",
2667 }}))
2668 })
2669
2670 It("should ZInterStore", func() {
2671 err := client.ZAdd("zset1", redis.Z{
2672 Score: 1,
2673 Member: "one",
2674 }).Err()
2675 Expect(err).NotTo(HaveOccurred())
2676 err = client.ZAdd("zset1", redis.Z{
2677 Score: 2,
2678 Member: "two",
2679 }).Err()
2680 Expect(err).NotTo(HaveOccurred())
2681
2682 err = client.ZAdd("zset2", redis.Z{Score: 1, Member: "one"}).Err()
2683 Expect(err).NotTo(HaveOccurred())
2684 err = client.ZAdd("zset2", redis.Z{Score: 2, Member: "two"}).Err()
2685 Expect(err).NotTo(HaveOccurred())
2686 err = client.ZAdd("zset3", redis.Z{Score: 3, Member: "two"}).Err()
2687 Expect(err).NotTo(HaveOccurred())
2688
2689 zInterStore := client.ZInterStore(
2690 "out", redis.ZStore{Weights: []float64{2, 3}}, "zset1", "zset2")
2691 Expect(zInterStore.Err()).NotTo(HaveOccurred())
2692 Expect(zInterStore.Val()).To(Equal(int64(2)))
2693
2694 vals, err := client.ZRangeWithScores("out", 0, -1).Result()
2695 Expect(err).NotTo(HaveOccurred())
2696 Expect(vals).To(Equal([]redis.Z{{
2697 Score: 5,
2698 Member: "one",
2699 }, {
2700 Score: 10,
2701 Member: "two",
2702 }}))
2703 })
2704
2705 It("should ZPopMax", func() {
2706 err := client.ZAdd("zset", redis.Z{
2707 Score: 1,
2708 Member: "one",
2709 }).Err()
2710 Expect(err).NotTo(HaveOccurred())
2711 err = client.ZAdd("zset", redis.Z{
2712 Score: 2,
2713 Member: "two",
2714 }).Err()
2715 Expect(err).NotTo(HaveOccurred())
2716 err = client.ZAdd("zset", redis.Z{
2717 Score: 3,
2718 Member: "three",
2719 }).Err()
2720 Expect(err).NotTo(HaveOccurred())
2721
2722 members, err := client.ZPopMax("zset").Result()
2723 Expect(err).NotTo(HaveOccurred())
2724 Expect(members).To(Equal([]redis.Z{{
2725 Score: 3,
2726 Member: "three",
2727 }}))
2728
2729
2730 err = client.ZAdd("zset", redis.Z{
2731 Score: 3,
2732 Member: "three",
2733 }).Err()
2734 Expect(err).NotTo(HaveOccurred())
2735 members, err = client.ZPopMax("zset", 2).Result()
2736 Expect(err).NotTo(HaveOccurred())
2737 Expect(members).To(Equal([]redis.Z{{
2738 Score: 3,
2739 Member: "three",
2740 }, {
2741 Score: 2,
2742 Member: "two",
2743 }}))
2744
2745
2746 err = client.ZAdd("zset", redis.Z{
2747 Score: 3,
2748 Member: "three",
2749 }).Err()
2750 Expect(err).NotTo(HaveOccurred())
2751 err = client.ZAdd("zset", redis.Z{
2752 Score: 2,
2753 Member: "two",
2754 }).Err()
2755 Expect(err).NotTo(HaveOccurred())
2756 members, err = client.ZPopMax("zset", 10).Result()
2757 Expect(err).NotTo(HaveOccurred())
2758 Expect(members).To(Equal([]redis.Z{{
2759 Score: 3,
2760 Member: "three",
2761 }, {
2762 Score: 2,
2763 Member: "two",
2764 }, {
2765 Score: 1,
2766 Member: "one",
2767 }}))
2768 })
2769
2770 It("should ZPopMin", func() {
2771 err := client.ZAdd("zset", redis.Z{
2772 Score: 1,
2773 Member: "one",
2774 }).Err()
2775 Expect(err).NotTo(HaveOccurred())
2776 err = client.ZAdd("zset", redis.Z{
2777 Score: 2,
2778 Member: "two",
2779 }).Err()
2780 Expect(err).NotTo(HaveOccurred())
2781 err = client.ZAdd("zset", redis.Z{
2782 Score: 3,
2783 Member: "three",
2784 }).Err()
2785 Expect(err).NotTo(HaveOccurred())
2786
2787 members, err := client.ZPopMin("zset").Result()
2788 Expect(err).NotTo(HaveOccurred())
2789 Expect(members).To(Equal([]redis.Z{{
2790 Score: 1,
2791 Member: "one",
2792 }}))
2793
2794
2795 err = client.ZAdd("zset", redis.Z{
2796 Score: 1,
2797 Member: "one",
2798 }).Err()
2799 Expect(err).NotTo(HaveOccurred())
2800 members, err = client.ZPopMin("zset", 2).Result()
2801 Expect(err).NotTo(HaveOccurred())
2802 Expect(members).To(Equal([]redis.Z{{
2803 Score: 1,
2804 Member: "one",
2805 }, {
2806 Score: 2,
2807 Member: "two",
2808 }}))
2809
2810
2811 err = client.ZAdd("zset", redis.Z{
2812 Score: 1,
2813 Member: "one",
2814 }).Err()
2815 Expect(err).NotTo(HaveOccurred())
2816
2817 err = client.ZAdd("zset", redis.Z{
2818 Score: 2,
2819 Member: "two",
2820 }).Err()
2821 Expect(err).NotTo(HaveOccurred())
2822
2823 members, err = client.ZPopMin("zset", 10).Result()
2824 Expect(err).NotTo(HaveOccurred())
2825 Expect(members).To(Equal([]redis.Z{{
2826 Score: 1,
2827 Member: "one",
2828 }, {
2829 Score: 2,
2830 Member: "two",
2831 }, {
2832 Score: 3,
2833 Member: "three",
2834 }}))
2835 })
2836
2837 It("should ZRange", func() {
2838 err := client.ZAdd("zset", redis.Z{Score: 1, Member: "one"}).Err()
2839 Expect(err).NotTo(HaveOccurred())
2840 err = client.ZAdd("zset", redis.Z{Score: 2, Member: "two"}).Err()
2841 Expect(err).NotTo(HaveOccurred())
2842 err = client.ZAdd("zset", redis.Z{Score: 3, Member: "three"}).Err()
2843 Expect(err).NotTo(HaveOccurred())
2844
2845 zRange := client.ZRange("zset", 0, -1)
2846 Expect(zRange.Err()).NotTo(HaveOccurred())
2847 Expect(zRange.Val()).To(Equal([]string{"one", "two", "three"}))
2848
2849 zRange = client.ZRange("zset", 2, 3)
2850 Expect(zRange.Err()).NotTo(HaveOccurred())
2851 Expect(zRange.Val()).To(Equal([]string{"three"}))
2852
2853 zRange = client.ZRange("zset", -2, -1)
2854 Expect(zRange.Err()).NotTo(HaveOccurred())
2855 Expect(zRange.Val()).To(Equal([]string{"two", "three"}))
2856 })
2857
2858 It("should ZRangeWithScores", func() {
2859 err := client.ZAdd("zset", redis.Z{Score: 1, Member: "one"}).Err()
2860 Expect(err).NotTo(HaveOccurred())
2861 err = client.ZAdd("zset", redis.Z{Score: 2, Member: "two"}).Err()
2862 Expect(err).NotTo(HaveOccurred())
2863 err = client.ZAdd("zset", redis.Z{Score: 3, Member: "three"}).Err()
2864 Expect(err).NotTo(HaveOccurred())
2865
2866 vals, err := client.ZRangeWithScores("zset", 0, -1).Result()
2867 Expect(err).NotTo(HaveOccurred())
2868 Expect(vals).To(Equal([]redis.Z{{
2869 Score: 1,
2870 Member: "one",
2871 }, {
2872 Score: 2,
2873 Member: "two",
2874 }, {
2875 Score: 3,
2876 Member: "three",
2877 }}))
2878
2879 vals, err = client.ZRangeWithScores("zset", 2, 3).Result()
2880 Expect(err).NotTo(HaveOccurred())
2881 Expect(vals).To(Equal([]redis.Z{{Score: 3, Member: "three"}}))
2882
2883 vals, err = client.ZRangeWithScores("zset", -2, -1).Result()
2884 Expect(err).NotTo(HaveOccurred())
2885 Expect(vals).To(Equal([]redis.Z{{
2886 Score: 2,
2887 Member: "two",
2888 }, {
2889 Score: 3,
2890 Member: "three",
2891 }}))
2892 })
2893
2894 It("should ZRangeByScore", func() {
2895 err := client.ZAdd("zset", redis.Z{Score: 1, Member: "one"}).Err()
2896 Expect(err).NotTo(HaveOccurred())
2897 err = client.ZAdd("zset", redis.Z{Score: 2, Member: "two"}).Err()
2898 Expect(err).NotTo(HaveOccurred())
2899 err = client.ZAdd("zset", redis.Z{Score: 3, Member: "three"}).Err()
2900 Expect(err).NotTo(HaveOccurred())
2901
2902 zRangeByScore := client.ZRangeByScore("zset", redis.ZRangeBy{
2903 Min: "-inf",
2904 Max: "+inf",
2905 })
2906 Expect(zRangeByScore.Err()).NotTo(HaveOccurred())
2907 Expect(zRangeByScore.Val()).To(Equal([]string{"one", "two", "three"}))
2908
2909 zRangeByScore = client.ZRangeByScore("zset", redis.ZRangeBy{
2910 Min: "1",
2911 Max: "2",
2912 })
2913 Expect(zRangeByScore.Err()).NotTo(HaveOccurred())
2914 Expect(zRangeByScore.Val()).To(Equal([]string{"one", "two"}))
2915
2916 zRangeByScore = client.ZRangeByScore("zset", redis.ZRangeBy{
2917 Min: "(1",
2918 Max: "2",
2919 })
2920 Expect(zRangeByScore.Err()).NotTo(HaveOccurred())
2921 Expect(zRangeByScore.Val()).To(Equal([]string{"two"}))
2922
2923 zRangeByScore = client.ZRangeByScore("zset", redis.ZRangeBy{
2924 Min: "(1",
2925 Max: "(2",
2926 })
2927 Expect(zRangeByScore.Err()).NotTo(HaveOccurred())
2928 Expect(zRangeByScore.Val()).To(Equal([]string{}))
2929 })
2930
2931 It("should ZRangeByLex", func() {
2932 err := client.ZAdd("zset", redis.Z{
2933 Score: 0,
2934 Member: "a",
2935 }).Err()
2936 Expect(err).NotTo(HaveOccurred())
2937 err = client.ZAdd("zset", redis.Z{
2938 Score: 0,
2939 Member: "b",
2940 }).Err()
2941 Expect(err).NotTo(HaveOccurred())
2942 err = client.ZAdd("zset", redis.Z{
2943 Score: 0,
2944 Member: "c",
2945 }).Err()
2946 Expect(err).NotTo(HaveOccurred())
2947
2948 zRangeByLex := client.ZRangeByLex("zset", redis.ZRangeBy{
2949 Min: "-",
2950 Max: "+",
2951 })
2952 Expect(zRangeByLex.Err()).NotTo(HaveOccurred())
2953 Expect(zRangeByLex.Val()).To(Equal([]string{"a", "b", "c"}))
2954
2955 zRangeByLex = client.ZRangeByLex("zset", redis.ZRangeBy{
2956 Min: "[a",
2957 Max: "[b",
2958 })
2959 Expect(zRangeByLex.Err()).NotTo(HaveOccurred())
2960 Expect(zRangeByLex.Val()).To(Equal([]string{"a", "b"}))
2961
2962 zRangeByLex = client.ZRangeByLex("zset", redis.ZRangeBy{
2963 Min: "(a",
2964 Max: "[b",
2965 })
2966 Expect(zRangeByLex.Err()).NotTo(HaveOccurred())
2967 Expect(zRangeByLex.Val()).To(Equal([]string{"b"}))
2968
2969 zRangeByLex = client.ZRangeByLex("zset", redis.ZRangeBy{
2970 Min: "(a",
2971 Max: "(b",
2972 })
2973 Expect(zRangeByLex.Err()).NotTo(HaveOccurred())
2974 Expect(zRangeByLex.Val()).To(Equal([]string{}))
2975 })
2976
2977 It("should ZRangeByScoreWithScoresMap", func() {
2978 err := client.ZAdd("zset", redis.Z{Score: 1, Member: "one"}).Err()
2979 Expect(err).NotTo(HaveOccurred())
2980 err = client.ZAdd("zset", redis.Z{Score: 2, Member: "two"}).Err()
2981 Expect(err).NotTo(HaveOccurred())
2982 err = client.ZAdd("zset", redis.Z{Score: 3, Member: "three"}).Err()
2983 Expect(err).NotTo(HaveOccurred())
2984
2985 vals, err := client.ZRangeByScoreWithScores("zset", redis.ZRangeBy{
2986 Min: "-inf",
2987 Max: "+inf",
2988 }).Result()
2989 Expect(err).NotTo(HaveOccurred())
2990 Expect(vals).To(Equal([]redis.Z{{
2991 Score: 1,
2992 Member: "one",
2993 }, {
2994 Score: 2,
2995 Member: "two",
2996 }, {
2997 Score: 3,
2998 Member: "three",
2999 }}))
3000
3001 vals, err = client.ZRangeByScoreWithScores("zset", redis.ZRangeBy{
3002 Min: "1",
3003 Max: "2",
3004 }).Result()
3005 Expect(err).NotTo(HaveOccurred())
3006 Expect(vals).To(Equal([]redis.Z{{
3007 Score: 1,
3008 Member: "one",
3009 }, {
3010 Score: 2,
3011 Member: "two",
3012 }}))
3013
3014 vals, err = client.ZRangeByScoreWithScores("zset", redis.ZRangeBy{
3015 Min: "(1",
3016 Max: "2",
3017 }).Result()
3018 Expect(err).NotTo(HaveOccurred())
3019 Expect(vals).To(Equal([]redis.Z{{Score: 2, Member: "two"}}))
3020
3021 vals, err = client.ZRangeByScoreWithScores("zset", redis.ZRangeBy{
3022 Min: "(1",
3023 Max: "(2",
3024 }).Result()
3025 Expect(err).NotTo(HaveOccurred())
3026 Expect(vals).To(Equal([]redis.Z{}))
3027 })
3028
3029 It("should ZRank", func() {
3030 err := client.ZAdd("zset", redis.Z{Score: 1, Member: "one"}).Err()
3031 Expect(err).NotTo(HaveOccurred())
3032 err = client.ZAdd("zset", redis.Z{Score: 2, Member: "two"}).Err()
3033 Expect(err).NotTo(HaveOccurred())
3034 err = client.ZAdd("zset", redis.Z{Score: 3, Member: "three"}).Err()
3035 Expect(err).NotTo(HaveOccurred())
3036
3037 zRank := client.ZRank("zset", "three")
3038 Expect(zRank.Err()).NotTo(HaveOccurred())
3039 Expect(zRank.Val()).To(Equal(int64(2)))
3040
3041 zRank = client.ZRank("zset", "four")
3042 Expect(zRank.Err()).To(Equal(redis.Nil))
3043 Expect(zRank.Val()).To(Equal(int64(0)))
3044 })
3045
3046 It("should ZRem", func() {
3047 err := client.ZAdd("zset", redis.Z{Score: 1, Member: "one"}).Err()
3048 Expect(err).NotTo(HaveOccurred())
3049 err = client.ZAdd("zset", redis.Z{Score: 2, Member: "two"}).Err()
3050 Expect(err).NotTo(HaveOccurred())
3051 err = client.ZAdd("zset", redis.Z{Score: 3, Member: "three"}).Err()
3052 Expect(err).NotTo(HaveOccurred())
3053
3054 zRem := client.ZRem("zset", "two")
3055 Expect(zRem.Err()).NotTo(HaveOccurred())
3056 Expect(zRem.Val()).To(Equal(int64(1)))
3057
3058 vals, err := client.ZRangeWithScores("zset", 0, -1).Result()
3059 Expect(err).NotTo(HaveOccurred())
3060 Expect(vals).To(Equal([]redis.Z{{
3061 Score: 1,
3062 Member: "one",
3063 }, {
3064 Score: 3,
3065 Member: "three",
3066 }}))
3067 })
3068
3069 It("should ZRemRangeByRank", func() {
3070 err := client.ZAdd("zset", redis.Z{Score: 1, Member: "one"}).Err()
3071 Expect(err).NotTo(HaveOccurred())
3072 err = client.ZAdd("zset", redis.Z{Score: 2, Member: "two"}).Err()
3073 Expect(err).NotTo(HaveOccurred())
3074 err = client.ZAdd("zset", redis.Z{Score: 3, Member: "three"}).Err()
3075 Expect(err).NotTo(HaveOccurred())
3076
3077 zRemRangeByRank := client.ZRemRangeByRank("zset", 0, 1)
3078 Expect(zRemRangeByRank.Err()).NotTo(HaveOccurred())
3079 Expect(zRemRangeByRank.Val()).To(Equal(int64(2)))
3080
3081 vals, err := client.ZRangeWithScores("zset", 0, -1).Result()
3082 Expect(err).NotTo(HaveOccurred())
3083 Expect(vals).To(Equal([]redis.Z{{
3084 Score: 3,
3085 Member: "three",
3086 }}))
3087 })
3088
3089 It("should ZRemRangeByScore", func() {
3090 err := client.ZAdd("zset", redis.Z{Score: 1, Member: "one"}).Err()
3091 Expect(err).NotTo(HaveOccurred())
3092 err = client.ZAdd("zset", redis.Z{Score: 2, Member: "two"}).Err()
3093 Expect(err).NotTo(HaveOccurred())
3094 err = client.ZAdd("zset", redis.Z{Score: 3, Member: "three"}).Err()
3095 Expect(err).NotTo(HaveOccurred())
3096
3097 zRemRangeByScore := client.ZRemRangeByScore("zset", "-inf", "(2")
3098 Expect(zRemRangeByScore.Err()).NotTo(HaveOccurred())
3099 Expect(zRemRangeByScore.Val()).To(Equal(int64(1)))
3100
3101 vals, err := client.ZRangeWithScores("zset", 0, -1).Result()
3102 Expect(err).NotTo(HaveOccurred())
3103 Expect(vals).To(Equal([]redis.Z{{
3104 Score: 2,
3105 Member: "two",
3106 }, {
3107 Score: 3,
3108 Member: "three",
3109 }}))
3110 })
3111
3112 It("should ZRemRangeByLex", func() {
3113 zz := []redis.Z{
3114 {Score: 0, Member: "aaaa"},
3115 {Score: 0, Member: "b"},
3116 {Score: 0, Member: "c"},
3117 {Score: 0, Member: "d"},
3118 {Score: 0, Member: "e"},
3119 {Score: 0, Member: "foo"},
3120 {Score: 0, Member: "zap"},
3121 {Score: 0, Member: "zip"},
3122 {Score: 0, Member: "ALPHA"},
3123 {Score: 0, Member: "alpha"},
3124 }
3125 for _, z := range zz {
3126 err := client.ZAdd("zset", z).Err()
3127 Expect(err).NotTo(HaveOccurred())
3128 }
3129
3130 n, err := client.ZRemRangeByLex("zset", "[alpha", "[omega").Result()
3131 Expect(err).NotTo(HaveOccurred())
3132 Expect(n).To(Equal(int64(6)))
3133
3134 vals, err := client.ZRange("zset", 0, -1).Result()
3135 Expect(err).NotTo(HaveOccurred())
3136 Expect(vals).To(Equal([]string{"ALPHA", "aaaa", "zap", "zip"}))
3137 })
3138
3139 It("should ZRevRange", func() {
3140 err := client.ZAdd("zset", redis.Z{Score: 1, Member: "one"}).Err()
3141 Expect(err).NotTo(HaveOccurred())
3142 err = client.ZAdd("zset", redis.Z{Score: 2, Member: "two"}).Err()
3143 Expect(err).NotTo(HaveOccurred())
3144 err = client.ZAdd("zset", redis.Z{Score: 3, Member: "three"}).Err()
3145 Expect(err).NotTo(HaveOccurred())
3146
3147 zRevRange := client.ZRevRange("zset", 0, -1)
3148 Expect(zRevRange.Err()).NotTo(HaveOccurred())
3149 Expect(zRevRange.Val()).To(Equal([]string{"three", "two", "one"}))
3150
3151 zRevRange = client.ZRevRange("zset", 2, 3)
3152 Expect(zRevRange.Err()).NotTo(HaveOccurred())
3153 Expect(zRevRange.Val()).To(Equal([]string{"one"}))
3154
3155 zRevRange = client.ZRevRange("zset", -2, -1)
3156 Expect(zRevRange.Err()).NotTo(HaveOccurred())
3157 Expect(zRevRange.Val()).To(Equal([]string{"two", "one"}))
3158 })
3159
3160 It("should ZRevRangeWithScoresMap", func() {
3161 err := client.ZAdd("zset", redis.Z{Score: 1, Member: "one"}).Err()
3162 Expect(err).NotTo(HaveOccurred())
3163 err = client.ZAdd("zset", redis.Z{Score: 2, Member: "two"}).Err()
3164 Expect(err).NotTo(HaveOccurred())
3165 err = client.ZAdd("zset", redis.Z{Score: 3, Member: "three"}).Err()
3166 Expect(err).NotTo(HaveOccurred())
3167
3168 val, err := client.ZRevRangeWithScores("zset", 0, -1).Result()
3169 Expect(err).NotTo(HaveOccurred())
3170 Expect(val).To(Equal([]redis.Z{{
3171 Score: 3,
3172 Member: "three",
3173 }, {
3174 Score: 2,
3175 Member: "two",
3176 }, {
3177 Score: 1,
3178 Member: "one",
3179 }}))
3180
3181 val, err = client.ZRevRangeWithScores("zset", 2, 3).Result()
3182 Expect(err).NotTo(HaveOccurred())
3183 Expect(val).To(Equal([]redis.Z{{Score: 1, Member: "one"}}))
3184
3185 val, err = client.ZRevRangeWithScores("zset", -2, -1).Result()
3186 Expect(err).NotTo(HaveOccurred())
3187 Expect(val).To(Equal([]redis.Z{{
3188 Score: 2,
3189 Member: "two",
3190 }, {
3191 Score: 1,
3192 Member: "one",
3193 }}))
3194 })
3195
3196 It("should ZRevRangeByScore", func() {
3197 err := client.ZAdd("zset", redis.Z{Score: 1, Member: "one"}).Err()
3198 Expect(err).NotTo(HaveOccurred())
3199 err = client.ZAdd("zset", redis.Z{Score: 2, Member: "two"}).Err()
3200 Expect(err).NotTo(HaveOccurred())
3201 err = client.ZAdd("zset", redis.Z{Score: 3, Member: "three"}).Err()
3202 Expect(err).NotTo(HaveOccurred())
3203
3204 vals, err := client.ZRevRangeByScore(
3205 "zset", redis.ZRangeBy{Max: "+inf", Min: "-inf"}).Result()
3206 Expect(err).NotTo(HaveOccurred())
3207 Expect(vals).To(Equal([]string{"three", "two", "one"}))
3208
3209 vals, err = client.ZRevRangeByScore(
3210 "zset", redis.ZRangeBy{Max: "2", Min: "(1"}).Result()
3211 Expect(err).NotTo(HaveOccurred())
3212 Expect(vals).To(Equal([]string{"two"}))
3213
3214 vals, err = client.ZRevRangeByScore(
3215 "zset", redis.ZRangeBy{Max: "(2", Min: "(1"}).Result()
3216 Expect(err).NotTo(HaveOccurred())
3217 Expect(vals).To(Equal([]string{}))
3218 })
3219
3220 It("should ZRevRangeByLex", func() {
3221 err := client.ZAdd("zset", redis.Z{Score: 0, Member: "a"}).Err()
3222 Expect(err).NotTo(HaveOccurred())
3223 err = client.ZAdd("zset", redis.Z{Score: 0, Member: "b"}).Err()
3224 Expect(err).NotTo(HaveOccurred())
3225 err = client.ZAdd("zset", redis.Z{Score: 0, Member: "c"}).Err()
3226 Expect(err).NotTo(HaveOccurred())
3227
3228 vals, err := client.ZRevRangeByLex(
3229 "zset", redis.ZRangeBy{Max: "+", Min: "-"}).Result()
3230 Expect(err).NotTo(HaveOccurred())
3231 Expect(vals).To(Equal([]string{"c", "b", "a"}))
3232
3233 vals, err = client.ZRevRangeByLex(
3234 "zset", redis.ZRangeBy{Max: "[b", Min: "(a"}).Result()
3235 Expect(err).NotTo(HaveOccurred())
3236 Expect(vals).To(Equal([]string{"b"}))
3237
3238 vals, err = client.ZRevRangeByLex(
3239 "zset", redis.ZRangeBy{Max: "(b", Min: "(a"}).Result()
3240 Expect(err).NotTo(HaveOccurred())
3241 Expect(vals).To(Equal([]string{}))
3242 })
3243
3244 It("should ZRevRangeByScoreWithScores", func() {
3245 err := client.ZAdd("zset", redis.Z{Score: 1, Member: "one"}).Err()
3246 Expect(err).NotTo(HaveOccurred())
3247 err = client.ZAdd("zset", redis.Z{Score: 2, Member: "two"}).Err()
3248 Expect(err).NotTo(HaveOccurred())
3249 err = client.ZAdd("zset", redis.Z{Score: 3, Member: "three"}).Err()
3250 Expect(err).NotTo(HaveOccurred())
3251
3252 vals, err := client.ZRevRangeByScoreWithScores(
3253 "zset", redis.ZRangeBy{Max: "+inf", Min: "-inf"}).Result()
3254 Expect(err).NotTo(HaveOccurred())
3255 Expect(vals).To(Equal([]redis.Z{{
3256 Score: 3,
3257 Member: "three",
3258 }, {
3259 Score: 2,
3260 Member: "two",
3261 }, {
3262 Score: 1,
3263 Member: "one",
3264 }}))
3265 })
3266
3267 It("should ZRevRangeByScoreWithScoresMap", func() {
3268 err := client.ZAdd("zset", redis.Z{Score: 1, Member: "one"}).Err()
3269 Expect(err).NotTo(HaveOccurred())
3270 err = client.ZAdd("zset", redis.Z{Score: 2, Member: "two"}).Err()
3271 Expect(err).NotTo(HaveOccurred())
3272 err = client.ZAdd("zset", redis.Z{Score: 3, Member: "three"}).Err()
3273 Expect(err).NotTo(HaveOccurred())
3274
3275 vals, err := client.ZRevRangeByScoreWithScores(
3276 "zset", redis.ZRangeBy{Max: "+inf", Min: "-inf"}).Result()
3277 Expect(err).NotTo(HaveOccurred())
3278 Expect(vals).To(Equal([]redis.Z{{
3279 Score: 3,
3280 Member: "three",
3281 }, {
3282 Score: 2,
3283 Member: "two",
3284 }, {
3285 Score: 1,
3286 Member: "one",
3287 }}))
3288
3289 vals, err = client.ZRevRangeByScoreWithScores(
3290 "zset", redis.ZRangeBy{Max: "2", Min: "(1"}).Result()
3291 Expect(err).NotTo(HaveOccurred())
3292 Expect(vals).To(Equal([]redis.Z{{Score: 2, Member: "two"}}))
3293
3294 vals, err = client.ZRevRangeByScoreWithScores(
3295 "zset", redis.ZRangeBy{Max: "(2", Min: "(1"}).Result()
3296 Expect(err).NotTo(HaveOccurred())
3297 Expect(vals).To(Equal([]redis.Z{}))
3298 })
3299
3300 It("should ZRevRank", func() {
3301 err := client.ZAdd("zset", redis.Z{Score: 1, Member: "one"}).Err()
3302 Expect(err).NotTo(HaveOccurred())
3303 err = client.ZAdd("zset", redis.Z{Score: 2, Member: "two"}).Err()
3304 Expect(err).NotTo(HaveOccurred())
3305 err = client.ZAdd("zset", redis.Z{Score: 3, Member: "three"}).Err()
3306 Expect(err).NotTo(HaveOccurred())
3307
3308 zRevRank := client.ZRevRank("zset", "one")
3309 Expect(zRevRank.Err()).NotTo(HaveOccurred())
3310 Expect(zRevRank.Val()).To(Equal(int64(2)))
3311
3312 zRevRank = client.ZRevRank("zset", "four")
3313 Expect(zRevRank.Err()).To(Equal(redis.Nil))
3314 Expect(zRevRank.Val()).To(Equal(int64(0)))
3315 })
3316
3317 It("should ZScore", func() {
3318 zAdd := client.ZAdd("zset", redis.Z{Score: 1.001, Member: "one"})
3319 Expect(zAdd.Err()).NotTo(HaveOccurred())
3320
3321 zScore := client.ZScore("zset", "one")
3322 Expect(zScore.Err()).NotTo(HaveOccurred())
3323 Expect(zScore.Val()).To(Equal(float64(1.001)))
3324 })
3325
3326 It("should ZUnionStore", func() {
3327 err := client.ZAdd("zset1", redis.Z{Score: 1, Member: "one"}).Err()
3328 Expect(err).NotTo(HaveOccurred())
3329 err = client.ZAdd("zset1", redis.Z{Score: 2, Member: "two"}).Err()
3330 Expect(err).NotTo(HaveOccurred())
3331
3332 err = client.ZAdd("zset2", redis.Z{Score: 1, Member: "one"}).Err()
3333 Expect(err).NotTo(HaveOccurred())
3334 err = client.ZAdd("zset2", redis.Z{Score: 2, Member: "two"}).Err()
3335 Expect(err).NotTo(HaveOccurred())
3336 err = client.ZAdd("zset2", redis.Z{Score: 3, Member: "three"}).Err()
3337 Expect(err).NotTo(HaveOccurred())
3338
3339 zUnionStore := client.ZUnionStore(
3340 "out", redis.ZStore{Weights: []float64{2, 3}}, "zset1", "zset2")
3341 Expect(zUnionStore.Err()).NotTo(HaveOccurred())
3342 Expect(zUnionStore.Val()).To(Equal(int64(3)))
3343
3344 val, err := client.ZRangeWithScores("out", 0, -1).Result()
3345 Expect(err).NotTo(HaveOccurred())
3346 Expect(val).To(Equal([]redis.Z{{
3347 Score: 5,
3348 Member: "one",
3349 }, {
3350 Score: 9,
3351 Member: "three",
3352 }, {
3353 Score: 10,
3354 Member: "two",
3355 }}))
3356 })
3357
3358 })
3359
3360 Describe("streams", func() {
3361 BeforeEach(func() {
3362 id, err := client.XAdd(&redis.XAddArgs{
3363 Stream: "stream",
3364 ID: "1-0",
3365 Values: map[string]interface{}{"uno": "un"},
3366 }).Result()
3367 Expect(err).NotTo(HaveOccurred())
3368 Expect(id).To(Equal("1-0"))
3369
3370 id, err = client.XAdd(&redis.XAddArgs{
3371 Stream: "stream",
3372 ID: "2-0",
3373 Values: map[string]interface{}{"dos": "deux"},
3374 }).Result()
3375 Expect(err).NotTo(HaveOccurred())
3376 Expect(id).To(Equal("2-0"))
3377
3378 id, err = client.XAdd(&redis.XAddArgs{
3379 Stream: "stream",
3380 ID: "3-0",
3381 Values: map[string]interface{}{"tres": "troix"},
3382 }).Result()
3383 Expect(err).NotTo(HaveOccurred())
3384 Expect(id).To(Equal("3-0"))
3385 })
3386
3387 It("should XTrim", func() {
3388 n, err := client.XTrim("stream", 0).Result()
3389 Expect(err).NotTo(HaveOccurred())
3390 Expect(n).To(Equal(int64(3)))
3391 })
3392
3393 It("should XTrimApprox", func() {
3394 n, err := client.XTrimApprox("stream", 0).Result()
3395 Expect(err).NotTo(HaveOccurred())
3396 Expect(n).To(Equal(int64(3)))
3397 })
3398
3399 It("should XAdd", func() {
3400 id, err := client.XAdd(&redis.XAddArgs{
3401 Stream: "stream",
3402 Values: map[string]interface{}{"quatro": "quatre"},
3403 }).Result()
3404 Expect(err).NotTo(HaveOccurred())
3405
3406 vals, err := client.XRange("stream", "-", "+").Result()
3407 Expect(err).NotTo(HaveOccurred())
3408 Expect(vals).To(Equal([]redis.XMessage{
3409 {ID: "1-0", Values: map[string]interface{}{"uno": "un"}},
3410 {ID: "2-0", Values: map[string]interface{}{"dos": "deux"}},
3411 {ID: "3-0", Values: map[string]interface{}{"tres": "troix"}},
3412 {ID: id, Values: map[string]interface{}{"quatro": "quatre"}},
3413 }))
3414 })
3415
3416 It("should XAdd with MaxLen", func() {
3417 id, err := client.XAdd(&redis.XAddArgs{
3418 Stream: "stream",
3419 MaxLen: 1,
3420 Values: map[string]interface{}{"quatro": "quatre"},
3421 }).Result()
3422 Expect(err).NotTo(HaveOccurred())
3423
3424 vals, err := client.XRange("stream", "-", "+").Result()
3425 Expect(err).NotTo(HaveOccurred())
3426 Expect(vals).To(Equal([]redis.XMessage{
3427 {ID: id, Values: map[string]interface{}{"quatro": "quatre"}},
3428 }))
3429 })
3430
3431 It("should XDel", func() {
3432 n, err := client.XDel("stream", "1-0", "2-0", "3-0").Result()
3433 Expect(err).NotTo(HaveOccurred())
3434 Expect(n).To(Equal(int64(3)))
3435 })
3436
3437 It("should XLen", func() {
3438 n, err := client.XLen("stream").Result()
3439 Expect(err).NotTo(HaveOccurred())
3440 Expect(n).To(Equal(int64(3)))
3441 })
3442
3443 It("should XRange", func() {
3444 msgs, err := client.XRange("stream", "-", "+").Result()
3445 Expect(err).NotTo(HaveOccurred())
3446 Expect(msgs).To(Equal([]redis.XMessage{
3447 {ID: "1-0", Values: map[string]interface{}{"uno": "un"}},
3448 {ID: "2-0", Values: map[string]interface{}{"dos": "deux"}},
3449 {ID: "3-0", Values: map[string]interface{}{"tres": "troix"}},
3450 }))
3451
3452 msgs, err = client.XRange("stream", "2", "+").Result()
3453 Expect(err).NotTo(HaveOccurred())
3454 Expect(msgs).To(Equal([]redis.XMessage{
3455 {ID: "2-0", Values: map[string]interface{}{"dos": "deux"}},
3456 {ID: "3-0", Values: map[string]interface{}{"tres": "troix"}},
3457 }))
3458
3459 msgs, err = client.XRange("stream", "-", "2").Result()
3460 Expect(err).NotTo(HaveOccurred())
3461 Expect(msgs).To(Equal([]redis.XMessage{
3462 {ID: "1-0", Values: map[string]interface{}{"uno": "un"}},
3463 {ID: "2-0", Values: map[string]interface{}{"dos": "deux"}},
3464 }))
3465 })
3466
3467 It("should XRangeN", func() {
3468 msgs, err := client.XRangeN("stream", "-", "+", 2).Result()
3469 Expect(err).NotTo(HaveOccurred())
3470 Expect(msgs).To(Equal([]redis.XMessage{
3471 {ID: "1-0", Values: map[string]interface{}{"uno": "un"}},
3472 {ID: "2-0", Values: map[string]interface{}{"dos": "deux"}},
3473 }))
3474
3475 msgs, err = client.XRangeN("stream", "2", "+", 1).Result()
3476 Expect(err).NotTo(HaveOccurred())
3477 Expect(msgs).To(Equal([]redis.XMessage{
3478 {ID: "2-0", Values: map[string]interface{}{"dos": "deux"}},
3479 }))
3480
3481 msgs, err = client.XRangeN("stream", "-", "2", 1).Result()
3482 Expect(err).NotTo(HaveOccurred())
3483 Expect(msgs).To(Equal([]redis.XMessage{
3484 {ID: "1-0", Values: map[string]interface{}{"uno": "un"}},
3485 }))
3486 })
3487
3488 It("should XRevRange", func() {
3489 msgs, err := client.XRevRange("stream", "+", "-").Result()
3490 Expect(err).NotTo(HaveOccurred())
3491 Expect(msgs).To(Equal([]redis.XMessage{
3492 {ID: "3-0", Values: map[string]interface{}{"tres": "troix"}},
3493 {ID: "2-0", Values: map[string]interface{}{"dos": "deux"}},
3494 {ID: "1-0", Values: map[string]interface{}{"uno": "un"}},
3495 }))
3496
3497 msgs, err = client.XRevRange("stream", "+", "2").Result()
3498 Expect(err).NotTo(HaveOccurred())
3499 Expect(msgs).To(Equal([]redis.XMessage{
3500 {ID: "3-0", Values: map[string]interface{}{"tres": "troix"}},
3501 {ID: "2-0", Values: map[string]interface{}{"dos": "deux"}},
3502 }))
3503 })
3504
3505 It("should XRevRangeN", func() {
3506 msgs, err := client.XRevRangeN("stream", "+", "-", 2).Result()
3507 Expect(err).NotTo(HaveOccurred())
3508 Expect(msgs).To(Equal([]redis.XMessage{
3509 {ID: "3-0", Values: map[string]interface{}{"tres": "troix"}},
3510 {ID: "2-0", Values: map[string]interface{}{"dos": "deux"}},
3511 }))
3512
3513 msgs, err = client.XRevRangeN("stream", "+", "2", 1).Result()
3514 Expect(err).NotTo(HaveOccurred())
3515 Expect(msgs).To(Equal([]redis.XMessage{
3516 {ID: "3-0", Values: map[string]interface{}{"tres": "troix"}},
3517 }))
3518 })
3519
3520 It("should XRead", func() {
3521 res, err := client.XReadStreams("stream", "0").Result()
3522 Expect(err).NotTo(HaveOccurred())
3523 Expect(res).To(Equal([]redis.XStream{{
3524 Stream: "stream",
3525 Messages: []redis.XMessage{
3526 {ID: "1-0", Values: map[string]interface{}{"uno": "un"}},
3527 {ID: "2-0", Values: map[string]interface{}{"dos": "deux"}},
3528 {ID: "3-0", Values: map[string]interface{}{"tres": "troix"}},
3529 }},
3530 }))
3531
3532 _, err = client.XReadStreams("stream", "3").Result()
3533 Expect(err).To(Equal(redis.Nil))
3534 })
3535
3536 It("should XRead", func() {
3537 res, err := client.XRead(&redis.XReadArgs{
3538 Streams: []string{"stream", "0"},
3539 Count: 2,
3540 Block: 100 * time.Millisecond,
3541 }).Result()
3542 Expect(err).NotTo(HaveOccurred())
3543 Expect(res).To(Equal([]redis.XStream{{
3544 Stream: "stream",
3545 Messages: []redis.XMessage{
3546 {ID: "1-0", Values: map[string]interface{}{"uno": "un"}},
3547 {ID: "2-0", Values: map[string]interface{}{"dos": "deux"}},
3548 }},
3549 }))
3550
3551 _, err = client.XRead(&redis.XReadArgs{
3552 Streams: []string{"stream", "3"},
3553 Count: 1,
3554 Block: 100 * time.Millisecond,
3555 }).Result()
3556 Expect(err).To(Equal(redis.Nil))
3557 })
3558
3559 Describe("group", func() {
3560 BeforeEach(func() {
3561 err := client.XGroupCreate("stream", "group", "0").Err()
3562 Expect(err).NotTo(HaveOccurred())
3563
3564 res, err := client.XReadGroup(&redis.XReadGroupArgs{
3565 Group: "group",
3566 Consumer: "consumer",
3567 Streams: []string{"stream", ">"},
3568 }).Result()
3569 Expect(err).NotTo(HaveOccurred())
3570 Expect(res).To(Equal([]redis.XStream{{
3571 Stream: "stream",
3572 Messages: []redis.XMessage{
3573 {ID: "1-0", Values: map[string]interface{}{"uno": "un"}},
3574 {ID: "2-0", Values: map[string]interface{}{"dos": "deux"}},
3575 {ID: "3-0", Values: map[string]interface{}{"tres": "troix"}},
3576 }},
3577 }))
3578 })
3579
3580 AfterEach(func() {
3581 n, err := client.XGroupDestroy("stream", "group").Result()
3582 Expect(err).NotTo(HaveOccurred())
3583 Expect(n).To(Equal(int64(1)))
3584 })
3585
3586 It("should XReadGroup skip empty", func() {
3587 n, err := client.XDel("stream", "2-0").Result()
3588 Expect(err).NotTo(HaveOccurred())
3589 Expect(n).To(Equal(int64(1)))
3590
3591 res, err := client.XReadGroup(&redis.XReadGroupArgs{
3592 Group: "group",
3593 Consumer: "consumer",
3594 Streams: []string{"stream", "0"},
3595 }).Result()
3596 Expect(err).NotTo(HaveOccurred())
3597 Expect(res).To(Equal([]redis.XStream{{
3598 Stream: "stream",
3599 Messages: []redis.XMessage{
3600 {ID: "1-0", Values: map[string]interface{}{"uno": "un"}},
3601 {ID: "2-0", Values: nil},
3602 {ID: "3-0", Values: map[string]interface{}{"tres": "troix"}},
3603 }},
3604 }))
3605 })
3606
3607 It("should XGroupCreateMkStream", func() {
3608 err := client.XGroupCreateMkStream("stream2", "group", "0").Err()
3609 Expect(err).NotTo(HaveOccurred())
3610
3611 err = client.XGroupCreateMkStream("stream2", "group", "0").Err()
3612 Expect(err).To(Equal(proto.RedisError("BUSYGROUP Consumer Group name already exists")))
3613
3614 n, err := client.XGroupDestroy("stream2", "group").Result()
3615 Expect(err).NotTo(HaveOccurred())
3616 Expect(n).To(Equal(int64(1)))
3617
3618 n, err = client.Del("stream2").Result()
3619 Expect(err).NotTo(HaveOccurred())
3620 Expect(n).To(Equal(int64(1)))
3621 })
3622
3623 It("should XPending", func() {
3624 info, err := client.XPending("stream", "group").Result()
3625 Expect(err).NotTo(HaveOccurred())
3626 Expect(info).To(Equal(&redis.XPending{
3627 Count: 3,
3628 Lower: "1-0",
3629 Higher: "3-0",
3630 Consumers: map[string]int64{"consumer": 3},
3631 }))
3632
3633 infoExt, err := client.XPendingExt(&redis.XPendingExtArgs{
3634 Stream: "stream",
3635 Group: "group",
3636 Start: "-",
3637 End: "+",
3638 Count: 10,
3639 Consumer: "consumer",
3640 }).Result()
3641 Expect(err).NotTo(HaveOccurred())
3642 for i := range infoExt {
3643 infoExt[i].Idle = 0
3644 }
3645 Expect(infoExt).To(Equal([]redis.XPendingExt{
3646 {Id: "1-0", Consumer: "consumer", Idle: 0, RetryCount: 1},
3647 {Id: "2-0", Consumer: "consumer", Idle: 0, RetryCount: 1},
3648 {Id: "3-0", Consumer: "consumer", Idle: 0, RetryCount: 1},
3649 }))
3650
3651 n, err := client.XGroupDelConsumer("stream", "group", "consumer").Result()
3652 Expect(err).NotTo(HaveOccurred())
3653 Expect(n).To(Equal(int64(3)))
3654 })
3655
3656 It("should XClaim", func() {
3657 msgs, err := client.XClaim(&redis.XClaimArgs{
3658 Stream: "stream",
3659 Group: "group",
3660 Consumer: "consumer",
3661 Messages: []string{"1-0", "2-0", "3-0"},
3662 }).Result()
3663 Expect(err).NotTo(HaveOccurred())
3664 Expect(msgs).To(Equal([]redis.XMessage{{
3665 ID: "1-0",
3666 Values: map[string]interface{}{"uno": "un"},
3667 }, {
3668 ID: "2-0",
3669 Values: map[string]interface{}{"dos": "deux"},
3670 }, {
3671 ID: "3-0",
3672 Values: map[string]interface{}{"tres": "troix"},
3673 }}))
3674
3675 ids, err := client.XClaimJustID(&redis.XClaimArgs{
3676 Stream: "stream",
3677 Group: "group",
3678 Consumer: "consumer",
3679 Messages: []string{"1-0", "2-0", "3-0"},
3680 }).Result()
3681 Expect(err).NotTo(HaveOccurred())
3682 Expect(ids).To(Equal([]string{"1-0", "2-0", "3-0"}))
3683 })
3684
3685 It("should XAck", func() {
3686 n, err := client.XAck("stream", "group", "1-0", "2-0", "4-0").Result()
3687 Expect(err).NotTo(HaveOccurred())
3688 Expect(n).To(Equal(int64(2)))
3689 })
3690 })
3691 })
3692
3693 Describe("Geo add and radius search", func() {
3694 BeforeEach(func() {
3695 n, err := client.GeoAdd(
3696 "Sicily",
3697 &redis.GeoLocation{Longitude: 13.361389, Latitude: 38.115556, Name: "Palermo"},
3698 &redis.GeoLocation{Longitude: 15.087269, Latitude: 37.502669, Name: "Catania"},
3699 ).Result()
3700 Expect(err).NotTo(HaveOccurred())
3701 Expect(n).To(Equal(int64(2)))
3702 })
3703
3704 It("should not add same geo location", func() {
3705 geoAdd := client.GeoAdd(
3706 "Sicily",
3707 &redis.GeoLocation{Longitude: 13.361389, Latitude: 38.115556, Name: "Palermo"},
3708 )
3709 Expect(geoAdd.Err()).NotTo(HaveOccurred())
3710 Expect(geoAdd.Val()).To(Equal(int64(0)))
3711 })
3712
3713 It("should search geo radius", func() {
3714 res, err := client.GeoRadius("Sicily", 15, 37, &redis.GeoRadiusQuery{
3715 Radius: 200,
3716 }).Result()
3717 Expect(err).NotTo(HaveOccurred())
3718 Expect(res).To(HaveLen(2))
3719 Expect(res[0].Name).To(Equal("Palermo"))
3720 Expect(res[1].Name).To(Equal("Catania"))
3721 })
3722
3723 It("should search geo radius with options", func() {
3724 res, err := client.GeoRadius("Sicily", 15, 37, &redis.GeoRadiusQuery{
3725 Radius: 200,
3726 Unit: "km",
3727 WithGeoHash: true,
3728 WithCoord: true,
3729 WithDist: true,
3730 Count: 2,
3731 Sort: "ASC",
3732 }).Result()
3733 Expect(err).NotTo(HaveOccurred())
3734 Expect(res).To(HaveLen(2))
3735 Expect(res[1].Name).To(Equal("Palermo"))
3736 Expect(res[1].Dist).To(Equal(190.4424))
3737 Expect(res[1].GeoHash).To(Equal(int64(3479099956230698)))
3738 Expect(res[1].Longitude).To(Equal(13.361389338970184))
3739 Expect(res[1].Latitude).To(Equal(38.115556395496299))
3740 Expect(res[0].Name).To(Equal("Catania"))
3741 Expect(res[0].Dist).To(Equal(56.4413))
3742 Expect(res[0].GeoHash).To(Equal(int64(3479447370796909)))
3743 Expect(res[0].Longitude).To(Equal(15.087267458438873))
3744 Expect(res[0].Latitude).To(Equal(37.50266842333162))
3745 })
3746
3747 It("should search geo radius with WithDist=false", func() {
3748 res, err := client.GeoRadius("Sicily", 15, 37, &redis.GeoRadiusQuery{
3749 Radius: 200,
3750 Unit: "km",
3751 WithGeoHash: true,
3752 WithCoord: true,
3753 Count: 2,
3754 Sort: "ASC",
3755 }).Result()
3756 Expect(err).NotTo(HaveOccurred())
3757 Expect(res).To(HaveLen(2))
3758 Expect(res[1].Name).To(Equal("Palermo"))
3759 Expect(res[1].Dist).To(Equal(float64(0)))
3760 Expect(res[1].GeoHash).To(Equal(int64(3479099956230698)))
3761 Expect(res[1].Longitude).To(Equal(13.361389338970184))
3762 Expect(res[1].Latitude).To(Equal(38.115556395496299))
3763 Expect(res[0].Name).To(Equal("Catania"))
3764 Expect(res[0].Dist).To(Equal(float64(0)))
3765 Expect(res[0].GeoHash).To(Equal(int64(3479447370796909)))
3766 Expect(res[0].Longitude).To(Equal(15.087267458438873))
3767 Expect(res[0].Latitude).To(Equal(37.50266842333162))
3768 })
3769
3770 It("should search geo radius by member with options", func() {
3771 res, err := client.GeoRadiusByMember("Sicily", "Catania", &redis.GeoRadiusQuery{
3772 Radius: 200,
3773 Unit: "km",
3774 WithGeoHash: true,
3775 WithCoord: true,
3776 WithDist: true,
3777 Count: 2,
3778 Sort: "ASC",
3779 }).Result()
3780 Expect(err).NotTo(HaveOccurred())
3781 Expect(res).To(HaveLen(2))
3782 Expect(res[0].Name).To(Equal("Catania"))
3783 Expect(res[0].Dist).To(Equal(0.0))
3784 Expect(res[0].GeoHash).To(Equal(int64(3479447370796909)))
3785 Expect(res[0].Longitude).To(Equal(15.087267458438873))
3786 Expect(res[0].Latitude).To(Equal(37.50266842333162))
3787 Expect(res[1].Name).To(Equal("Palermo"))
3788 Expect(res[1].Dist).To(Equal(166.2742))
3789 Expect(res[1].GeoHash).To(Equal(int64(3479099956230698)))
3790 Expect(res[1].Longitude).To(Equal(13.361389338970184))
3791 Expect(res[1].Latitude).To(Equal(38.115556395496299))
3792 })
3793
3794 It("should search geo radius with no results", func() {
3795 res, err := client.GeoRadius("Sicily", 99, 37, &redis.GeoRadiusQuery{
3796 Radius: 200,
3797 Unit: "km",
3798 WithGeoHash: true,
3799 WithCoord: true,
3800 WithDist: true,
3801 }).Result()
3802 Expect(err).NotTo(HaveOccurred())
3803 Expect(res).To(HaveLen(0))
3804 })
3805
3806 It("should get geo distance with unit options", func() {
3807
3808
3809
3810
3811
3812
3813
3814
3815 dist, err := client.GeoDist("Sicily", "Palermo", "Catania", "km").Result()
3816 Expect(err).NotTo(HaveOccurred())
3817 Expect(dist).To(BeNumerically("~", 166.27, 0.01))
3818
3819 dist, err = client.GeoDist("Sicily", "Palermo", "Catania", "m").Result()
3820 Expect(err).NotTo(HaveOccurred())
3821 Expect(dist).To(BeNumerically("~", 166274.15, 0.01))
3822 })
3823
3824 It("should get geo hash in string representation", func() {
3825 hashes, err := client.GeoHash("Sicily", "Palermo", "Catania").Result()
3826 Expect(err).NotTo(HaveOccurred())
3827 Expect(hashes).To(ConsistOf([]string{"sqc8b49rny0", "sqdtr74hyu0"}))
3828 })
3829
3830 It("should return geo position", func() {
3831 pos, err := client.GeoPos("Sicily", "Palermo", "Catania", "NonExisting").Result()
3832 Expect(err).NotTo(HaveOccurred())
3833 Expect(pos).To(ConsistOf([]*redis.GeoPos{
3834 {
3835 Longitude: 13.361389338970184,
3836 Latitude: 38.1155563954963,
3837 },
3838 {
3839 Longitude: 15.087267458438873,
3840 Latitude: 37.50266842333162,
3841 },
3842 nil,
3843 }))
3844 })
3845 })
3846
3847 Describe("marshaling/unmarshaling", func() {
3848
3849 type convTest struct {
3850 value interface{}
3851 wanted string
3852 dest interface{}
3853 }
3854
3855 convTests := []convTest{
3856 {nil, "", nil},
3857 {"hello", "hello", new(string)},
3858 {[]byte("hello"), "hello", new([]byte)},
3859 {int(1), "1", new(int)},
3860 {int8(1), "1", new(int8)},
3861 {int16(1), "1", new(int16)},
3862 {int32(1), "1", new(int32)},
3863 {int64(1), "1", new(int64)},
3864 {uint(1), "1", new(uint)},
3865 {uint8(1), "1", new(uint8)},
3866 {uint16(1), "1", new(uint16)},
3867 {uint32(1), "1", new(uint32)},
3868 {uint64(1), "1", new(uint64)},
3869 {float32(1.0), "1", new(float32)},
3870 {float64(1.0), "1", new(float64)},
3871 {true, "1", new(bool)},
3872 {false, "0", new(bool)},
3873 }
3874
3875 It("should convert to string", func() {
3876 for _, test := range convTests {
3877 err := client.Set("key", test.value, 0).Err()
3878 Expect(err).NotTo(HaveOccurred())
3879
3880 s, err := client.Get("key").Result()
3881 Expect(err).NotTo(HaveOccurred())
3882 Expect(s).To(Equal(test.wanted))
3883
3884 if test.dest == nil {
3885 continue
3886 }
3887
3888 err = client.Get("key").Scan(test.dest)
3889 Expect(err).NotTo(HaveOccurred())
3890 Expect(deref(test.dest)).To(Equal(test.value))
3891 }
3892 })
3893
3894 })
3895
3896 Describe("json marshaling/unmarshaling", func() {
3897
3898 BeforeEach(func() {
3899 value := &numberStruct{Number: 42}
3900 err := client.Set("key", value, 0).Err()
3901 Expect(err).NotTo(HaveOccurred())
3902 })
3903
3904 It("should marshal custom values using json", func() {
3905 s, err := client.Get("key").Result()
3906 Expect(err).NotTo(HaveOccurred())
3907 Expect(s).To(Equal(`{"Number":42}`))
3908 })
3909
3910 It("should scan custom values using json", func() {
3911 value := &numberStruct{}
3912 err := client.Get("key").Scan(value)
3913 Expect(err).NotTo(HaveOccurred())
3914 Expect(value.Number).To(Equal(42))
3915 })
3916
3917 })
3918
3919 Describe("Eval", func() {
3920
3921 It("returns keys and values", func() {
3922 vals, err := client.Eval(
3923 "return {KEYS[1],ARGV[1]}",
3924 []string{"key"},
3925 "hello",
3926 ).Result()
3927 Expect(err).NotTo(HaveOccurred())
3928 Expect(vals).To(Equal([]interface{}{"key", "hello"}))
3929 })
3930
3931 It("returns all values after an error", func() {
3932 vals, err := client.Eval(
3933 `return {12, {err="error"}, "abc"}`,
3934 nil,
3935 ).Result()
3936 Expect(err).NotTo(HaveOccurred())
3937 Expect(vals).To(Equal([]interface{}{int64(12), proto.RedisError("error"), "abc"}))
3938 })
3939
3940 })
3941
3942 })
3943
3944 type numberStruct struct {
3945 Number int
3946 }
3947
3948 func (s *numberStruct) MarshalBinary() ([]byte, error) {
3949 return json.Marshal(s)
3950 }
3951
3952 func (s *numberStruct) UnmarshalBinary(b []byte) error {
3953 return json.Unmarshal(b, s)
3954 }
3955
3956 func deref(viface interface{}) interface{} {
3957 v := reflect.ValueOf(viface)
3958 for v.Kind() == reflect.Ptr {
3959 v = v.Elem()
3960 }
3961 return v.Interface()
3962 }
3963
View as plain text