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