redis/go-redis
1
0
Fork 0
mirror of https://github.com/redis/go-redis.git synced 2025-07-28 06:42:00 +03:00
Code Activity

Add support for BZMPOP (#2456)

Browse Source 
* Add support for BZMPOP

* Add BZMPOP command comment
This commit is contained in:
YuGan
2023-02-23 19:25:41 +08:00
committed by GitHub
parent 621c02c583
commit 6045d2e456
2 changed files with 163 additions and 17 deletions
Download Patch File Download Diff File Expand all files Collapse all files

159
commands_test.go
View File

@ -3772,7 +3772,7 @@ var _ = Describe("Commands", func() {
Expect(err).NotTo(HaveOccurred())
Expect(key).To(Equal("zset"))
Expect(elems).To(Equal([]redis.Z{{
Score: 1,
Score: 1,
Member: "one",
}}))
@ -3790,22 +3790,21 @@ var _ = Describe("Commands", func() {
Expect(err).NotTo(HaveOccurred())
Expect(key).To(Equal("myzset"))
Expect(elems).To(Equal([]redis.Z{{
Score:1,
Member:"one",
Score: 1,
Member: "one",
}}))
key, elems, err = client.ZMPop(ctx, "max", 10, "myzset").Result()
Expect(err).NotTo(HaveOccurred())
Expect(key).To(Equal("myzset"))
Expect(elems).To(Equal([]redis.Z{{
Score:3,
Member:"three",
},{
Score: 2,
Score: 3,
Member: "three",
}, {
Score: 2,
Member: "two",
}}))
err = client.ZAdd(ctx, "myzset2", redis.Z{Score: 4, Member: "four"}).Err()
Expect(err).NotTo(HaveOccurred())
err = client.ZAdd(ctx, "myzset2", redis.Z{Score: 5, Member: "five"}).Err()
@ -3813,22 +3812,148 @@ var _ = Describe("Commands", func() {
err = client.ZAdd(ctx, "myzset2", redis.Z{Score: 6, Member: "six"}).Err()
Expect(err).NotTo(HaveOccurred())
key, elems, err = client.ZMPop(ctx, "min", 10, "myzset","myzset2").Result()
key, elems, err = client.ZMPop(ctx, "min", 10, "myzset", "myzset2").Result()
Expect(err).NotTo(HaveOccurred())
Expect(key).To(Equal("myzset2"))
Expect(elems).To(Equal([]redis.Z{{
Score:4,
Member:"four",
},{
Score: 5,
Score: 4,
Member: "four",
}, {
Score: 5,
Member: "five",
},{
Score:6,
}, {
Score: 6,
Member: "six",
}}))
})
It("should BZMPop", func() {
err := client.ZAdd(ctx, "zset", redis.Z{Score: 1, Member: "one"}).Err()
Expect(err).NotTo(HaveOccurred())
err = client.ZAdd(ctx, "zset", redis.Z{Score: 2, Member: "two"}).Err()
Expect(err).NotTo(HaveOccurred())
err = client.ZAdd(ctx, "zset", redis.Z{Score: 3, Member: "three"}).Err()
Expect(err).NotTo(HaveOccurred())
err = client.ZAdd(ctx, "zset2", redis.Z{Score: 1, Member: "one"}).Err()
Expect(err).NotTo(HaveOccurred())
err = client.ZAdd(ctx, "zset2", redis.Z{Score: 2, Member: "two"}).Err()
Expect(err).NotTo(HaveOccurred())
err = client.ZAdd(ctx, "zset2", redis.Z{Score: 3, Member: "three"}).Err()
Expect(err).NotTo(HaveOccurred())
key, elems, err := client.BZMPop(ctx, 0, "min", 1, "zset").Result()
Expect(err).NotTo(HaveOccurred())
Expect(key).To(Equal("zset"))
Expect(elems).To(Equal([]redis.Z{{
Score: 1,
Member: "one",
}}))
key, elems, err = client.BZMPop(ctx, 0, "max", 1, "zset").Result()
Expect(err).NotTo(HaveOccurred())
Expect(key).To(Equal("zset"))
Expect(elems).To(Equal([]redis.Z{{
Score: 3,
Member: "three",
}}))
key, elems, err = client.BZMPop(ctx, 0, "min", 10, "zset").Result()
Expect(err).NotTo(HaveOccurred())
Expect(key).To(Equal("zset"))
Expect(elems).To(Equal([]redis.Z{{
Score: 2,
Member: "two",
}}))
key, elems, err = client.BZMPop(ctx, 0, "max", 10, "zset2").Result()
Expect(err).NotTo(HaveOccurred())
Expect(key).To(Equal("zset2"))
Expect(elems).To(Equal([]redis.Z{{
Score: 3,
Member: "three",
}, {
Score: 2,
Member: "two",
}, {
Score: 1,
Member: "one",
}}))
err = client.ZAdd(ctx, "myzset", redis.Z{Score: 1, Member: "one"}).Err()
Expect(err).NotTo(HaveOccurred())
key, elems, err = client.BZMPop(ctx, 0, "min", 10, "myzset").Result()
Expect(err).NotTo(HaveOccurred())
Expect(key).To(Equal("myzset"))
Expect(elems).To(Equal([]redis.Z{{
Score: 1,
Member: "one",
}}))
err = client.ZAdd(ctx, "myzset2", redis.Z{Score: 4, Member: "four"}).Err()
Expect(err).NotTo(HaveOccurred())
err = client.ZAdd(ctx, "myzset2", redis.Z{Score: 5, Member: "five"}).Err()
Expect(err).NotTo(HaveOccurred())
key, elems, err = client.BZMPop(ctx, 0, "min", 10, "myzset", "myzset2").Result()
Expect(err).NotTo(HaveOccurred())
Expect(key).To(Equal("myzset2"))
Expect(elems).To(Equal([]redis.Z{{
Score: 4,
Member: "four",
}, {
Score: 5,
Member: "five",
}}))
})
It("should BZMPopBlocks", func() {
started := make(chan bool)
done := make(chan bool)
go func() {
defer GinkgoRecover()
started <- true
key, elems, err := client.BZMPop(ctx, 0, "min", 1, "list_list").Result()
Expect(err).NotTo(HaveOccurred())
Expect(key).To(Equal("list_list"))
Expect(elems).To(Equal([]redis.Z{{
Score: 1,
Member: "one",
}}))
done <- true
}()
<-started
select {
case <-done:
Fail("BZMPop is not blocked")
case <-time.After(time.Second):
//ok
}
err := client.ZAdd(ctx, "list_list", redis.Z{Score: 1, Member: "one"}).Err()
Expect(err).NotTo(HaveOccurred())
select {
case <-done:
//ok
case <-time.After(time.Second):
Fail("BZMPop is still blocked")
}
})
It("should BZMPop timeout", func() {
_, val, err := client.BZMPop(ctx, time.Second, "min", 1, "list1").Result()
Expect(err).To(Equal(redis.Nil))
Expect(val).To(BeNil())
Expect(client.Ping(ctx).Err()).NotTo(HaveOccurred())
stats := client.PoolStats()
Expect(stats.Hits).To(Equal(uint32(2)))
Expect(stats.Misses).To(Equal(uint32(1)))
Expect(stats.Timeouts).To(Equal(uint32(0)))
})
It("should ZMScore", func() {