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