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