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