mirror
/
redis
mirror of https://github.com/go-redis/redis.git
1
0
Fork 1
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'master' into ankit/add-custom-label-support

This commit is contained in:
Ankit Chahar 2024-01-02 14:34:47 +05:30 committed by GitHub
parent e57d6ba752 2e12191023
commit 1a693b080a
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
12 changed files with 212 additions and 113 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

59
.github/workflows/test-redis-enterprise.yml vendored Normal file
View File

@ -0,0 +1,59 @@
name: RE Tests
on:
push:
branches: [master]
pull_request:
permissions:
contents: read
jobs:
build:
name: build
runs-on: ubuntu-latest
strategy:
fail-fast: false
matrix:
go-version: [1.21.x]
re-build: ["7.2.4-92"]
steps:
- name: Checkout code
uses: actions/checkout@v4
- name: Clone Redis EE docker repository
uses: actions/checkout@v4
with:
repository: RedisLabs/redis-ee-docker
path: redis-ee
- name: Set up ${{ matrix.go-version }}
uses: actions/setup-go@v5
with:
go-version: ${{ matrix.go-version }}
- name: Build cluster
working-directory: redis-ee
env:
IMAGE: "redislabs/redis-internal:${{ matrix.re-build }}"
RE_USERNAME: ${{ secrets.RE_USERNAME }}
RE_PASS: ${{ secrets.RE_PASS }}
RE_CLUSTER_NAME: ${{ secrets.RE_CLUSTER_NAME }}
OSS_CLUSTER: false
DB_PORT: ${{ secrets.RE_DB_PORT }}
DOCKER_ACCESS_TOKEN: ${{ secrets.DOCKER_ACCESS_TOKEN }}
DOCKER_USERNAME: ${{ secrets.DOCKER_USERNAME }}
run: ./build.sh
- name: Test
env:
RE_CLUSTER: "1"
run: |
go test \
--ginkgo.skip-file="ring_test.go" \
--ginkgo.skip-file="sentinel_test.go" \
--ginkgo.skip-file="osscluster_test.go" \
--ginkgo.skip-file="pubsub_test.go" \
--ginkgo.skip-file="gears_commands_test.go" \
--ginkgo.label-filter='!NonRedisEnterprise'

128
commands_test.go
View File

@ -107,7 +107,7 @@ var _ = Describe("Commands", func() {
Expect(time.Now()).To(BeTemporally("~", start.Add(waitAOF), 3*time.Second)) Expect(time.Now()).To(BeTemporally("~", start.Add(waitAOF), 3*time.Second))
}) })
It("should Select", func() { It("should Select", Label("NonRedisEnterprise"), func() {
pipe := client.Pipeline() pipe := client.Pipeline()
sel := pipe.Select(ctx, 1) sel := pipe.Select(ctx, 1)
_, err := pipe.Exec(ctx) _, err := pipe.Exec(ctx)
@ -117,7 +117,7 @@ var _ = Describe("Commands", func() {
Expect(sel.Val()).To(Equal("OK")) Expect(sel.Val()).To(Equal("OK"))
}) })
It("should SwapDB", func() { It("should SwapDB", Label("NonRedisEnterprise"), func() {
pipe := client.Pipeline() pipe := client.Pipeline()
sel := pipe.SwapDB(ctx, 1, 2) sel := pipe.SwapDB(ctx, 1, 2)
_, err := pipe.Exec(ctx) _, err := pipe.Exec(ctx)
@ -219,7 +219,7 @@ var _ = Describe("Commands", func() {
Expect(info).NotTo(BeNil()) Expect(info).NotTo(BeNil())
}) })
It("should ClientPause", func() { It("should ClientPause", Label("NonRedisEnterprise"), func() {
err := client.ClientPause(ctx, time.Second).Err() err := client.ClientPause(ctx, time.Second).Err()
Expect(err).NotTo(HaveOccurred()) Expect(err).NotTo(HaveOccurred())
@ -299,13 +299,13 @@ var _ = Describe("Commands", func() {
Expect(val).NotTo(BeEmpty()) Expect(val).NotTo(BeEmpty())
}) })
It("should ConfigResetStat", func() { It("should ConfigResetStat", Label("NonRedisEnterprise"), func() {
r := client.ConfigResetStat(ctx) r := client.ConfigResetStat(ctx)
Expect(r.Err()).NotTo(HaveOccurred()) Expect(r.Err()).NotTo(HaveOccurred())
Expect(r.Val()).To(Equal("OK")) Expect(r.Val()).To(Equal("OK"))
}) })
It("should ConfigSet", func() { It("should ConfigSet", Label("NonRedisEnterprise"), func() {
configGet := client.ConfigGet(ctx, "maxmemory") configGet := client.ConfigGet(ctx, "maxmemory")
Expect(configGet.Err()).NotTo(HaveOccurred()) Expect(configGet.Err()).NotTo(HaveOccurred())
Expect(configGet.Val()).To(HaveLen(1)) Expect(configGet.Val()).To(HaveLen(1))
@ -317,7 +317,7 @@ var _ = Describe("Commands", func() {
Expect(configSet.Val()).To(Equal("OK")) Expect(configSet.Val()).To(Equal("OK"))
}) })
It("should ConfigRewrite", func() { It("should ConfigRewrite", Label("NonRedisEnterprise"), func() {
configRewrite := client.ConfigRewrite(ctx) configRewrite := client.ConfigRewrite(ctx)
Expect(configRewrite.Err()).NotTo(HaveOccurred()) Expect(configRewrite.Err()).NotTo(HaveOccurred())
Expect(configRewrite.Val()).To(Equal("OK")) Expect(configRewrite.Val()).To(Equal("OK"))
@ -364,20 +364,20 @@ var _ = Describe("Commands", func() {
Expect(info.Val()).To(ContainSubstring(`memory`)) Expect(info.Val()).To(ContainSubstring(`memory`))
}) })
It("should LastSave", func() { It("should LastSave", Label("NonRedisEnterprise"), func() {
lastSave := client.LastSave(ctx) lastSave := client.LastSave(ctx)
Expect(lastSave.Err()).NotTo(HaveOccurred()) Expect(lastSave.Err()).NotTo(HaveOccurred())
Expect(lastSave.Val()).NotTo(Equal(0)) Expect(lastSave.Val()).NotTo(Equal(0))
}) })
It("should Save", func() { It("should Save", Label("NonRedisEnterprise"), func() {
// workaround for "ERR Background save already in progress" // workaround for "ERR Background save already in progress"
Eventually(func() string { Eventually(func() string {
return client.Save(ctx).Val() return client.Save(ctx).Val()
}, "10s").Should(Equal("OK")) }, "10s").Should(Equal("OK"))
}) })
It("should SlaveOf", func() { It("should SlaveOf", Label("NonRedisEnterprise"), func() {
slaveOf := client.SlaveOf(ctx, "localhost", "8888") slaveOf := client.SlaveOf(ctx, "localhost", "8888")
Expect(slaveOf.Err()).NotTo(HaveOccurred()) Expect(slaveOf.Err()).NotTo(HaveOccurred())
Expect(slaveOf.Val()).To(Equal("OK")) Expect(slaveOf.Val()).To(Equal("OK"))
@ -393,7 +393,7 @@ var _ = Describe("Commands", func() {
Expect(tm).To(BeTemporally("~", time.Now(), 3*time.Second)) Expect(tm).To(BeTemporally("~", time.Now(), 3*time.Second))
}) })
It("should Command", func() { It("should Command", Label("NonRedisEnterprise"), func() {
cmds, err := client.Command(ctx).Result() cmds, err := client.Command(ctx).Result()
Expect(err).NotTo(HaveOccurred()) Expect(err).NotTo(HaveOccurred())
Expect(len(cmds)).To(BeNumerically("~", 240, 25)) Expect(len(cmds)).To(BeNumerically("~", 240, 25))
@ -624,7 +624,7 @@ var _ = Describe("Commands", func() {
Expect(keys.Val()).To(ConsistOf([]string{"four", "one", "three", "two"})) Expect(keys.Val()).To(ConsistOf([]string{"four", "one", "three", "two"}))
}) })
It("should Migrate", func() { It("should Migrate", Label("NonRedisEnterprise"), func() {
migrate := client.Migrate(ctx, "localhost", redisSecondaryPort, "key", 0, 0) migrate := client.Migrate(ctx, "localhost", redisSecondaryPort, "key", 0, 0)
Expect(migrate.Err()).NotTo(HaveOccurred()) Expect(migrate.Err()).NotTo(HaveOccurred())
Expect(migrate.Val()).To(Equal("NOKEY")) Expect(migrate.Val()).To(Equal("NOKEY"))
@ -638,7 +638,7 @@ var _ = Describe("Commands", func() {
Expect(migrate.Val()).To(Equal("")) Expect(migrate.Val()).To(Equal(""))
}) })
It("should Move", func() { It("should Move", Label("NonRedisEnterprise"), func() {
move := client.Move(ctx, "key", 2) move := client.Move(ctx, "key", 2)
Expect(move.Err()).NotTo(HaveOccurred()) Expect(move.Err()).NotTo(HaveOccurred())
Expect(move.Val()).To(Equal(false)) Expect(move.Val()).To(Equal(false))
@ -799,7 +799,7 @@ var _ = Describe("Commands", func() {
Expect(randomKey.Val()).To(Equal("key")) Expect(randomKey.Val()).To(Equal("key"))
}) })
It("should Rename", func() { It("should Rename", Label("NonRedisEnterprise"), func() {
set := client.Set(ctx, "key", "hello", 0) set := client.Set(ctx, "key", "hello", 0)
Expect(set.Err()).NotTo(HaveOccurred()) Expect(set.Err()).NotTo(HaveOccurred())
Expect(set.Val()).To(Equal("OK")) Expect(set.Val()).To(Equal("OK"))
@ -813,7 +813,7 @@ var _ = Describe("Commands", func() {
Expect(get.Val()).To(Equal("hello")) Expect(get.Val()).To(Equal("hello"))
}) })
It("should RenameNX", func() { It("should RenameNX", Label("NonRedisEnterprise"), func() {
set := client.Set(ctx, "key", "hello", 0) set := client.Set(ctx, "key", "hello", 0)
Expect(set.Err()).NotTo(HaveOccurred()) Expect(set.Err()).NotTo(HaveOccurred())
Expect(set.Val()).To(Equal("OK")) Expect(set.Val()).To(Equal("OK"))
@ -914,7 +914,7 @@ var _ = Describe("Commands", func() {
Expect(els).To(Equal([]string{"1", "2"})) Expect(els).To(Equal([]string{"1", "2"}))
}) })
It("should Sort and Get", func() { It("should Sort and Get", Label("NonRedisEnterprise"), func() {
size, err := client.LPush(ctx, "list", "1").Result() size, err := client.LPush(ctx, "list", "1").Result()
Expect(err).NotTo(HaveOccurred()) Expect(err).NotTo(HaveOccurred())
Expect(size).To(Equal(int64(1))) Expect(size).To(Equal(int64(1)))
@ -947,7 +947,7 @@ var _ = Describe("Commands", func() {
} }
}) })
It("should Sort and Store", func() { It("should Sort and Store", Label("NonRedisEnterprise"), func() {
size, err := client.LPush(ctx, "list", "1").Result() size, err := client.LPush(ctx, "list", "1").Result()
Expect(err).NotTo(HaveOccurred()) Expect(err).NotTo(HaveOccurred())
Expect(size).To(Equal(int64(1))) Expect(size).To(Equal(int64(1)))
@ -1147,7 +1147,7 @@ var _ = Describe("Commands", func() {
Expect(bitCount.Val()).To(Equal(int64(6))) Expect(bitCount.Val()).To(Equal(int64(6)))
}) })
It("should BitOpAnd", func() { It("should BitOpAnd", Label("NonRedisEnterprise"), func() {
set := client.Set(ctx, "key1", "1", 0) set := client.Set(ctx, "key1", "1", 0)
Expect(set.Err()).NotTo(HaveOccurred()) Expect(set.Err()).NotTo(HaveOccurred())
Expect(set.Val()).To(Equal("OK")) Expect(set.Val()).To(Equal("OK"))
@ -1165,7 +1165,7 @@ var _ = Describe("Commands", func() {
Expect(get.Val()).To(Equal("0")) Expect(get.Val()).To(Equal("0"))
}) })
It("should BitOpOr", func() { It("should BitOpOr", Label("NonRedisEnterprise"), func() {
set := client.Set(ctx, "key1", "1", 0) set := client.Set(ctx, "key1", "1", 0)
Expect(set.Err()).NotTo(HaveOccurred()) Expect(set.Err()).NotTo(HaveOccurred())
Expect(set.Val()).To(Equal("OK")) Expect(set.Val()).To(Equal("OK"))
@ -1183,7 +1183,7 @@ var _ = Describe("Commands", func() {
Expect(get.Val()).To(Equal("1")) Expect(get.Val()).To(Equal("1"))
}) })
It("should BitOpXor", func() { It("should BitOpXor", Label("NonRedisEnterprise"), func() {
set := client.Set(ctx, "key1", "\xff", 0) set := client.Set(ctx, "key1", "\xff", 0)
Expect(set.Err()).NotTo(HaveOccurred()) Expect(set.Err()).NotTo(HaveOccurred())
Expect(set.Val()).To(Equal("OK")) Expect(set.Val()).To(Equal("OK"))
@ -1201,7 +1201,7 @@ var _ = Describe("Commands", func() {
Expect(get.Val()).To(Equal("\xf0")) Expect(get.Val()).To(Equal("\xf0"))
}) })
It("should BitOpNot", func() { It("should BitOpNot", Label("NonRedisEnterprise"), func() {
set := client.Set(ctx, "key1", "\x00", 0) set := client.Set(ctx, "key1", "\x00", 0)
Expect(set.Err()).NotTo(HaveOccurred()) Expect(set.Err()).NotTo(HaveOccurred())
Expect(set.Val()).To(Equal("OK")) Expect(set.Val()).To(Equal("OK"))
@ -1530,7 +1530,7 @@ var _ = Describe("Commands", func() {
})) }))
}) })
It("should MSetNX", func() { It("should MSetNX", Label("NonRedisEnterprise"), func() {
mSetNX := client.MSetNX(ctx, "key1", "hello1", "key2", "hello2") mSetNX := client.MSetNX(ctx, "key1", "hello1", "key2", "hello2")
Expect(mSetNX.Err()).NotTo(HaveOccurred()) Expect(mSetNX.Err()).NotTo(HaveOccurred())
Expect(mSetNX.Val()).To(Equal(true)) Expect(mSetNX.Val()).To(Equal(true))
@ -1995,7 +1995,7 @@ var _ = Describe("Commands", func() {
Expect(strLen.Val()).To(Equal(int64(0))) Expect(strLen.Val()).To(Equal(int64(0)))
}) })
It("should Copy", func() { It("should Copy", Label("NonRedisEnterprise"), func() {
set := client.Set(ctx, "key", "hello", 0) set := client.Set(ctx, "key", "hello", 0)
Expect(set.Err()).NotTo(HaveOccurred()) Expect(set.Err()).NotTo(HaveOccurred())
Expect(set.Val()).To(Equal("OK")) Expect(set.Val()).To(Equal("OK"))
@ -2027,7 +2027,7 @@ var _ = Describe("Commands", func() {
Expect(dryRun.Val()).To(Equal("OK")) Expect(dryRun.Val()).To(Equal("OK"))
}) })
It("should fail module loadex", func() { It("should fail module loadex", Label("NonRedisEnterprise"), func() {
dryRun := client.ModuleLoadex(ctx, &redis.ModuleLoadexConfig{ dryRun := client.ModuleLoadex(ctx, &redis.ModuleLoadexConfig{
Path: "/path/to/non-existent-library.so", Path: "/path/to/non-existent-library.so",
Conf: map[string]interface{}{ Conf: map[string]interface{}{
@ -2075,7 +2075,7 @@ var _ = Describe("Commands", func() {
Expect(args).To(Equal(expectedArgs)) Expect(args).To(Equal(expectedArgs))
}) })
It("should ACL LOG", func() { It("should ACL LOG", Label("NonRedisEnterprise"), func() {
err := client.Do(ctx, "acl", "setuser", "test", ">test", "on", "allkeys", "+get").Err() err := client.Do(ctx, "acl", "setuser", "test", ">test", "on", "allkeys", "+get").Err()
Expect(err).NotTo(HaveOccurred()) Expect(err).NotTo(HaveOccurred())
@ -2108,7 +2108,7 @@ var _ = Describe("Commands", func() {
Expect(len(limitedLogEntries)).To(Equal(2)) Expect(len(limitedLogEntries)).To(Equal(2))
}) })
It("should ACL LOG RESET", func() { It("should ACL LOG RESET", Label("NonRedisEnterprise"), func() {
// Call ACL LOG RESET // Call ACL LOG RESET
resetCmd := client.ACLLogReset(ctx) resetCmd := client.ACLLogReset(ctx)
Expect(resetCmd.Err()).NotTo(HaveOccurred()) Expect(resetCmd.Err()).NotTo(HaveOccurred())
@ -2417,7 +2417,7 @@ var _ = Describe("Commands", func() {
}) })
Describe("hyperloglog", func() { Describe("hyperloglog", func() {
It("should PFMerge", func() { It("should PFMerge", Label("NonRedisEnterprise"), func() {
pfAdd := client.PFAdd(ctx, "hll1", "1", "2", "3", "4", "5") pfAdd := client.PFAdd(ctx, "hll1", "1", "2", "3", "4", "5")
Expect(pfAdd.Err()).NotTo(HaveOccurred()) Expect(pfAdd.Err()).NotTo(HaveOccurred())
@ -2442,7 +2442,7 @@ var _ = Describe("Commands", func() {
}) })
Describe("lists", func() { Describe("lists", func() {
It("should BLPop", func() { It("should BLPop", Label("NonRedisEnterprise"), func() {
rPush := client.RPush(ctx, "list1", "a", "b", "c") rPush := client.RPush(ctx, "list1", "a", "b", "c")
Expect(rPush.Err()).NotTo(HaveOccurred()) Expect(rPush.Err()).NotTo(HaveOccurred())
@ -2496,7 +2496,7 @@ var _ = Describe("Commands", func() {
Expect(stats.Timeouts).To(Equal(uint32(0))) Expect(stats.Timeouts).To(Equal(uint32(0)))
}) })
It("should BRPop", func() { It("should BRPop", Label("NonRedisEnterprise"), func() {
rPush := client.RPush(ctx, "list1", "a", "b", "c") rPush := client.RPush(ctx, "list1", "a", "b", "c")
Expect(rPush.Err()).NotTo(HaveOccurred()) Expect(rPush.Err()).NotTo(HaveOccurred())
@ -2538,7 +2538,7 @@ var _ = Describe("Commands", func() {
} }
}) })
It("should BRPopLPush", func() { It("should BRPopLPush", Label("NonRedisEnterprise"), func() {
_, err := client.BRPopLPush(ctx, "list1", "list2", time.Second).Result() _, err := client.BRPopLPush(ctx, "list1", "list2", time.Second).Result()
Expect(err).To(Equal(redis.Nil)) Expect(err).To(Equal(redis.Nil))
@ -2550,7 +2550,7 @@ var _ = Describe("Commands", func() {
Expect(v).To(Equal("c")) Expect(v).To(Equal("c"))
}) })
It("should LCS", func() { It("should LCS", Label("NonRedisEnterprise"), func() {
err := client.MSet(ctx, "key1", "ohmytext", "key2", "mynewtext").Err() err := client.MSet(ctx, "key1", "ohmytext", "key2", "mynewtext").Err()
Expect(err).NotTo(HaveOccurred()) Expect(err).NotTo(HaveOccurred())
@ -2664,7 +2664,7 @@ var _ = Describe("Commands", func() {
Expect(lRange.Val()).To(Equal([]string{"Hello", "There", "World"})) Expect(lRange.Val()).To(Equal([]string{"Hello", "There", "World"}))
}) })
It("should LMPop", func() { It("should LMPop", Label("NonRedisEnterprise"), func() {
err := client.LPush(ctx, "list1", "one", "two", "three", "four", "five").Err() err := client.LPush(ctx, "list1", "one", "two", "three", "four", "five").Err()
Expect(err).NotTo(HaveOccurred()) Expect(err).NotTo(HaveOccurred())
@ -2704,7 +2704,7 @@ var _ = Describe("Commands", func() {
Expect(err).To(HaveOccurred()) Expect(err).To(HaveOccurred())
}) })
It("should BLMPop", func() { It("should BLMPop", Label("NonRedisEnterprise"), func() {
err := client.LPush(ctx, "list1", "one", "two", "three", "four", "five").Err() err := client.LPush(ctx, "list1", "one", "two", "three", "four", "five").Err()
Expect(err).NotTo(HaveOccurred()) Expect(err).NotTo(HaveOccurred())
@ -3038,7 +3038,7 @@ var _ = Describe("Commands", func() {
Expect(lRange.Val()).To(Equal([]string{"one", "two"})) Expect(lRange.Val()).To(Equal([]string{"one", "two"}))
}) })
It("should RPopLPush", func() { It("should RPopLPush", Label("NonRedisEnterprise"), func() {
rPush := client.RPush(ctx, "list", "one") rPush := client.RPush(ctx, "list", "one")
Expect(rPush.Err()).NotTo(HaveOccurred()) Expect(rPush.Err()).NotTo(HaveOccurred())
rPush = client.RPush(ctx, "list", "two") rPush = client.RPush(ctx, "list", "two")
@ -3107,7 +3107,7 @@ var _ = Describe("Commands", func() {
Expect(lRange.Val()).To(Equal([]string{})) Expect(lRange.Val()).To(Equal([]string{}))
}) })
It("should LMove", func() { It("should LMove", Label("NonRedisEnterprise"), func() {
rPush := client.RPush(ctx, "lmove1", "ichi") rPush := client.RPush(ctx, "lmove1", "ichi")
Expect(rPush.Err()).NotTo(HaveOccurred()) Expect(rPush.Err()).NotTo(HaveOccurred())
Expect(rPush.Val()).To(Equal(int64(1))) Expect(rPush.Val()).To(Equal(int64(1)))
@ -3129,7 +3129,7 @@ var _ = Describe("Commands", func() {
Expect(lRange.Val()).To(Equal([]string{"san"})) Expect(lRange.Val()).To(Equal([]string{"san"}))
}) })
It("should BLMove", func() { It("should BLMove", Label("NonRedisEnterprise"), func() {
rPush := client.RPush(ctx, "blmove1", "ichi") rPush := client.RPush(ctx, "blmove1", "ichi")
Expect(rPush.Err()).NotTo(HaveOccurred()) Expect(rPush.Err()).NotTo(HaveOccurred())
Expect(rPush.Val()).To(Equal(int64(1))) Expect(rPush.Val()).To(Equal(int64(1)))
@ -3196,7 +3196,7 @@ var _ = Describe("Commands", func() {
Expect(sCard.Val()).To(Equal(int64(2))) Expect(sCard.Val()).To(Equal(int64(2)))
}) })
It("should SDiff", func() { It("should SDiff", Label("NonRedisEnterprise"), func() {
sAdd := client.SAdd(ctx, "set1", "a") sAdd := client.SAdd(ctx, "set1", "a")
Expect(sAdd.Err()).NotTo(HaveOccurred()) Expect(sAdd.Err()).NotTo(HaveOccurred())
sAdd = client.SAdd(ctx, "set1", "b") sAdd = client.SAdd(ctx, "set1", "b")
@ -3216,7 +3216,7 @@ var _ = Describe("Commands", func() {
Expect(sDiff.Val()).To(ConsistOf([]string{"a", "b"})) Expect(sDiff.Val()).To(ConsistOf([]string{"a", "b"}))
}) })
It("should SDiffStore", func() { It("should SDiffStore", Label("NonRedisEnterprise"), func() {
sAdd := client.SAdd(ctx, "set1", "a") sAdd := client.SAdd(ctx, "set1", "a")
Expect(sAdd.Err()).NotTo(HaveOccurred()) Expect(sAdd.Err()).NotTo(HaveOccurred())
sAdd = client.SAdd(ctx, "set1", "b") sAdd = client.SAdd(ctx, "set1", "b")
@ -3240,7 +3240,7 @@ var _ = Describe("Commands", func() {
Expect(sMembers.Val()).To(ConsistOf([]string{"a", "b"})) Expect(sMembers.Val()).To(ConsistOf([]string{"a", "b"}))
}) })
It("should SInter", func() { It("should SInter", Label("NonRedisEnterprise"), func() {
sAdd := client.SAdd(ctx, "set1", "a") sAdd := client.SAdd(ctx, "set1", "a")
Expect(sAdd.Err()).NotTo(HaveOccurred()) Expect(sAdd.Err()).NotTo(HaveOccurred())
sAdd = client.SAdd(ctx, "set1", "b") sAdd = client.SAdd(ctx, "set1", "b")
@ -3260,7 +3260,7 @@ var _ = Describe("Commands", func() {
Expect(sInter.Val()).To(Equal([]string{"c"})) Expect(sInter.Val()).To(Equal([]string{"c"}))
}) })
It("should SInterCard", func() { It("should SInterCard", Label("NonRedisEnterprise"), func() {
sAdd := client.SAdd(ctx, "set1", "a") sAdd := client.SAdd(ctx, "set1", "a")
Expect(sAdd.Err()).NotTo(HaveOccurred()) Expect(sAdd.Err()).NotTo(HaveOccurred())
sAdd = client.SAdd(ctx, "set1", "b") sAdd = client.SAdd(ctx, "set1", "b")
@ -3290,7 +3290,7 @@ var _ = Describe("Commands", func() {
Expect(sInterCard.Val()).To(Equal(int64(2))) Expect(sInterCard.Val()).To(Equal(int64(2)))
}) })
It("should SInterStore", func() { It("should SInterStore", Label("NonRedisEnterprise"), func() {
sAdd := client.SAdd(ctx, "set1", "a") sAdd := client.SAdd(ctx, "set1", "a")
Expect(sAdd.Err()).NotTo(HaveOccurred()) Expect(sAdd.Err()).NotTo(HaveOccurred())
sAdd = client.SAdd(ctx, "set1", "b") sAdd = client.SAdd(ctx, "set1", "b")
@ -3358,7 +3358,7 @@ var _ = Describe("Commands", func() {
Expect(sMembersMap.Val()).To(Equal(map[string]struct{}{"Hello": {}, "World": {}})) Expect(sMembersMap.Val()).To(Equal(map[string]struct{}{"Hello": {}, "World": {}}))
}) })
It("should SMove", func() { It("should SMove", Label("NonRedisEnterprise"), func() {
sAdd := client.SAdd(ctx, "set1", "one") sAdd := client.SAdd(ctx, "set1", "one")
Expect(sAdd.Err()).NotTo(HaveOccurred()) Expect(sAdd.Err()).NotTo(HaveOccurred())
sAdd = client.SAdd(ctx, "set1", "two") sAdd = client.SAdd(ctx, "set1", "two")
@ -3466,7 +3466,7 @@ var _ = Describe("Commands", func() {
Expect(sMembers.Val()).To(ConsistOf([]string{"three", "two"})) Expect(sMembers.Val()).To(ConsistOf([]string{"three", "two"}))
}) })
It("should SUnion", func() { It("should SUnion", Label("NonRedisEnterprise"), func() {
sAdd := client.SAdd(ctx, "set1", "a") sAdd := client.SAdd(ctx, "set1", "a")
Expect(sAdd.Err()).NotTo(HaveOccurred()) Expect(sAdd.Err()).NotTo(HaveOccurred())
sAdd = client.SAdd(ctx, "set1", "b") sAdd = client.SAdd(ctx, "set1", "b")
@ -3486,7 +3486,7 @@ var _ = Describe("Commands", func() {
Expect(sUnion.Val()).To(HaveLen(5)) Expect(sUnion.Val()).To(HaveLen(5))
}) })
It("should SUnionStore", func() { It("should SUnionStore", Label("NonRedisEnterprise"), func() {
sAdd := client.SAdd(ctx, "set1", "a") sAdd := client.SAdd(ctx, "set1", "a")
Expect(sAdd.Err()).NotTo(HaveOccurred()) Expect(sAdd.Err()).NotTo(HaveOccurred())
sAdd = client.SAdd(ctx, "set1", "b") sAdd = client.SAdd(ctx, "set1", "b")
@ -3512,7 +3512,7 @@ var _ = Describe("Commands", func() {
}) })
Describe("sorted sets", func() { Describe("sorted sets", func() {
It("should BZPopMax", func() { It("should BZPopMax", Label("NonRedisEnterprise"), func() {
err := client.ZAdd(ctx, "zset1", redis.Z{ err := client.ZAdd(ctx, "zset1", redis.Z{
Score: 1, Score: 1,
Member: "one", Member: "one",
@ -3594,7 +3594,7 @@ var _ = Describe("Commands", func() {
Expect(stats.Timeouts).To(Equal(uint32(0))) Expect(stats.Timeouts).To(Equal(uint32(0)))
}) })
It("should BZPopMin", func() { It("should BZPopMin", Label("NonRedisEnterprise"), func() {
err := client.ZAdd(ctx, "zset1", redis.Z{ err := client.ZAdd(ctx, "zset1", redis.Z{
Score: 1, Score: 1,
Member: "one", Member: "one",
@ -4176,7 +4176,7 @@ var _ = Describe("Commands", func() {
}})) }}))
}) })
It("should ZInterStore", func() { It("should ZInterStore", Label("NonRedisEnterprise"), func() {
err := client.ZAdd(ctx, "zset1", redis.Z{ err := client.ZAdd(ctx, "zset1", redis.Z{
Score: 1, Score: 1,
Member: "one", Member: "one",
@ -4213,7 +4213,7 @@ var _ = Describe("Commands", func() {
}})) }}))
}) })
It("should ZMPop", func() { It("should ZMPop", Label("NonRedisEnterprise"), func() {
err := client.ZAdd(ctx, "zset", redis.Z{Score: 1, Member: "one"}).Err() err := client.ZAdd(ctx, "zset", redis.Z{Score: 1, Member: "one"}).Err()
Expect(err).NotTo(HaveOccurred()) Expect(err).NotTo(HaveOccurred())
err = client.ZAdd(ctx, "zset", redis.Z{Score: 2, Member: "two"}).Err() err = client.ZAdd(ctx, "zset", redis.Z{Score: 2, Member: "two"}).Err()
@ -4287,7 +4287,7 @@ var _ = Describe("Commands", func() {
}})) }}))
}) })
It("should BZMPop", func() { It("should BZMPop", Label("NonRedisEnterprise"), func() {
err := client.ZAdd(ctx, "zset", redis.Z{Score: 1, Member: "one"}).Err() err := client.ZAdd(ctx, "zset", redis.Z{Score: 1, Member: "one"}).Err()
Expect(err).NotTo(HaveOccurred()) Expect(err).NotTo(HaveOccurred())
err = client.ZAdd(ctx, "zset", redis.Z{Score: 2, Member: "two"}).Err() err = client.ZAdd(ctx, "zset", redis.Z{Score: 2, Member: "two"}).Err()
@ -4827,7 +4827,7 @@ var _ = Describe("Commands", func() {
Expect(vals).To(Equal([]redis.Z{})) Expect(vals).To(Equal([]redis.Z{}))
}) })
It("should ZRangeStore", func() { It("should ZRangeStore", Label("NonRedisEnterprise"), func() {
added, err := client.ZAddArgs(ctx, "zset", redis.ZAddArgs{ added, err := client.ZAddArgs(ctx, "zset", redis.ZAddArgs{
Members: []redis.Z{ Members: []redis.Z{
{Score: 1, Member: "one"}, {Score: 1, Member: "one"},
@ -5203,7 +5203,7 @@ var _ = Describe("Commands", func() {
Expect(zScore.Val()).To(Equal(1.001)) Expect(zScore.Val()).To(Equal(1.001))
}) })
It("should ZUnion", func() { It("should ZUnion", Label("NonRedisEnterprise"), func() {
err := client.ZAddArgs(ctx, "zset1", redis.ZAddArgs{ err := client.ZAddArgs(ctx, "zset1", redis.ZAddArgs{
Members: []redis.Z{ Members: []redis.Z{
{Score: 1, Member: "one"}, {Score: 1, Member: "one"},
@ -5242,7 +5242,7 @@ var _ = Describe("Commands", func() {
})) }))
}) })
It("should ZUnionStore", func() { It("should ZUnionStore", Label("NonRedisEnterprise"), func() {
err := client.ZAdd(ctx, "zset1", redis.Z{Score: 1, Member: "one"}).Err() err := client.ZAdd(ctx, "zset1", redis.Z{Score: 1, Member: "one"}).Err()
Expect(err).NotTo(HaveOccurred()) Expect(err).NotTo(HaveOccurred())
err = client.ZAdd(ctx, "zset1", redis.Z{Score: 2, Member: "two"}).Err() err = client.ZAdd(ctx, "zset1", redis.Z{Score: 2, Member: "two"}).Err()
@ -5298,7 +5298,7 @@ var _ = Describe("Commands", func() {
)) ))
}) })
It("should ZDiff", func() { It("should ZDiff", Label("NonRedisEnterprise"), func() {
err := client.ZAdd(ctx, "zset1", redis.Z{Score: 1, Member: "one"}).Err() err := client.ZAdd(ctx, "zset1", redis.Z{Score: 1, Member: "one"}).Err()
Expect(err).NotTo(HaveOccurred()) Expect(err).NotTo(HaveOccurred())
err = client.ZAdd(ctx, "zset1", redis.Z{Score: 2, Member: "two"}).Err() err = client.ZAdd(ctx, "zset1", redis.Z{Score: 2, Member: "two"}).Err()
@ -5313,7 +5313,7 @@ var _ = Describe("Commands", func() {
Expect(v).To(Equal([]string{"two", "three"})) Expect(v).To(Equal([]string{"two", "three"}))
}) })
It("should ZDiffWithScores", func() { It("should ZDiffWithScores", Label("NonRedisEnterprise"), func() {
err := client.ZAdd(ctx, "zset1", redis.Z{Score: 1, Member: "one"}).Err() err := client.ZAdd(ctx, "zset1", redis.Z{Score: 1, Member: "one"}).Err()
Expect(err).NotTo(HaveOccurred()) Expect(err).NotTo(HaveOccurred())
err = client.ZAdd(ctx, "zset1", redis.Z{Score: 2, Member: "two"}).Err() err = client.ZAdd(ctx, "zset1", redis.Z{Score: 2, Member: "two"}).Err()
@ -5337,7 +5337,7 @@ var _ = Describe("Commands", func() {
})) }))
}) })
It("should ZInter", func() { It("should ZInter", Label("NonRedisEnterprise"), func() {
err := client.ZAdd(ctx, "zset1", redis.Z{Score: 1, Member: "one"}).Err() err := client.ZAdd(ctx, "zset1", redis.Z{Score: 1, Member: "one"}).Err()
Expect(err).NotTo(HaveOccurred()) Expect(err).NotTo(HaveOccurred())
err = client.ZAdd(ctx, "zset1", redis.Z{Score: 2, Member: "two"}).Err() err = client.ZAdd(ctx, "zset1", redis.Z{Score: 2, Member: "two"}).Err()
@ -5356,7 +5356,7 @@ var _ = Describe("Commands", func() {
Expect(v).To(Equal([]string{"one", "two"})) Expect(v).To(Equal([]string{"one", "two"}))
}) })
It("should ZInterCard", func() { It("should ZInterCard", Label("NonRedisEnterprise"), func() {
err := client.ZAdd(ctx, "zset1", redis.Z{Score: 1, Member: "one"}).Err() err := client.ZAdd(ctx, "zset1", redis.Z{Score: 1, Member: "one"}).Err()
Expect(err).NotTo(HaveOccurred()) Expect(err).NotTo(HaveOccurred())
err = client.ZAdd(ctx, "zset1", redis.Z{Score: 2, Member: "two"}).Err() err = client.ZAdd(ctx, "zset1", redis.Z{Score: 2, Member: "two"}).Err()
@ -5382,7 +5382,7 @@ var _ = Describe("Commands", func() {
Expect(sInterCard.Val()).To(Equal(int64(2))) Expect(sInterCard.Val()).To(Equal(int64(2)))
}) })
It("should ZInterWithScores", func() { It("should ZInterWithScores", Label("NonRedisEnterprise"), func() {
err := client.ZAdd(ctx, "zset1", redis.Z{Score: 1, Member: "one"}).Err() err := client.ZAdd(ctx, "zset1", redis.Z{Score: 1, Member: "one"}).Err()
Expect(err).NotTo(HaveOccurred()) Expect(err).NotTo(HaveOccurred())
err = client.ZAdd(ctx, "zset1", redis.Z{Score: 2, Member: "two"}).Err() err = client.ZAdd(ctx, "zset1", redis.Z{Score: 2, Member: "two"}).Err()
@ -5412,7 +5412,7 @@ var _ = Describe("Commands", func() {
})) }))
}) })
It("should ZDiffStore", func() { It("should ZDiffStore", Label("NonRedisEnterprise"), func() {
err := client.ZAdd(ctx, "zset1", redis.Z{Score: 1, Member: "one"}).Err() err := client.ZAdd(ctx, "zset1", redis.Z{Score: 1, Member: "one"}).Err()
Expect(err).NotTo(HaveOccurred()) Expect(err).NotTo(HaveOccurred())
err = client.ZAdd(ctx, "zset1", redis.Z{Score: 2, Member: "two"}).Err() err = client.ZAdd(ctx, "zset1", redis.Z{Score: 2, Member: "two"}).Err()
@ -6143,7 +6143,7 @@ var _ = Describe("Commands", func() {
Expect(res[1].Name).To(Equal("Catania")) Expect(res[1].Name).To(Equal("Catania"))
}) })
It("should geo radius and store the result", func() { It("should geo radius and store the result", Label("NonRedisEnterprise"), func() {
n, err := client.GeoRadiusStore(ctx, "Sicily", 15, 37, &redis.GeoRadiusQuery{ n, err := client.GeoRadiusStore(ctx, "Sicily", 15, 37, &redis.GeoRadiusQuery{
Radius: 200, Radius: 200,
Store: "result", Store: "result",
@ -6163,7 +6163,7 @@ var _ = Describe("Commands", func() {
})) }))
}) })
It("should geo radius and store dist", func() { It("should geo radius and store dist", Label("NonRedisEnterprise"), func() {
n, err := client.GeoRadiusStore(ctx, "Sicily", 15, 37, &redis.GeoRadiusQuery{ n, err := client.GeoRadiusStore(ctx, "Sicily", 15, 37, &redis.GeoRadiusQuery{
Radius: 200, Radius: 200,
StoreDist: "result", StoreDist: "result",
@ -6445,7 +6445,7 @@ var _ = Describe("Commands", func() {
})) }))
}) })
It("should geo search store", func() { It("should geo search store", Label("NonRedisEnterprise"), func() {
q := &redis.GeoSearchStoreQuery{ q := &redis.GeoSearchStoreQuery{
GeoSearchQuery: redis.GeoSearchQuery{ GeoSearchQuery: redis.GeoSearchQuery{
Longitude: 15, Longitude: 15,
@ -6705,7 +6705,7 @@ var _ = Describe("Commands", func() {
q = redis.FunctionListQuery{} q = redis.FunctionListQuery{}
}) })
It("Loads a new library", func() { It("Loads a new library", Label("NonRedisEnterprise"), func() {
functionLoad := client.FunctionLoad(ctx, lib1Code) functionLoad := client.FunctionLoad(ctx, lib1Code)
Expect(functionLoad.Err()).NotTo(HaveOccurred()) Expect(functionLoad.Err()).NotTo(HaveOccurred())
Expect(functionLoad.Val()).To(Equal(lib1.Name)) Expect(functionLoad.Val()).To(Equal(lib1.Name))
@ -6715,7 +6715,7 @@ var _ = Describe("Commands", func() {
Expect(functionList.Val()).To(HaveLen(1)) Expect(functionList.Val()).To(HaveLen(1))
}) })
It("Loads and replaces a new library", func() { It("Loads and replaces a new library", Label("NonRedisEnterprise"), func() {
// Load a library for the first time // Load a library for the first time
err := client.FunctionLoad(ctx, lib1Code).Err() err := client.FunctionLoad(ctx, lib1Code).Err()
Expect(err).NotTo(HaveOccurred()) Expect(err).NotTo(HaveOccurred())
@ -6786,7 +6786,7 @@ var _ = Describe("Commands", func() {
// Add test for a long-running function, once we make the test for `function stats` pass // Add test for a long-running function, once we make the test for `function stats` pass
}) })
It("Lists registered functions", func() { It("Lists registered functions", Label("NonRedisEnterprise"), func() {
err := client.FunctionLoad(ctx, lib1Code).Err() err := client.FunctionLoad(ctx, lib1Code).Err()
Expect(err).NotTo(HaveOccurred()) Expect(err).NotTo(HaveOccurred())
@ -6825,7 +6825,7 @@ var _ = Describe("Commands", func() {
Expect(err).To(Equal(redis.Nil)) Expect(err).To(Equal(redis.Nil))
}) })
It("Dump and restores all libraries", func() { It("Dump and restores all libraries", Label("NonRedisEnterprise"), func() {
err := client.FunctionLoad(ctx, lib1Code).Err() err := client.FunctionLoad(ctx, lib1Code).Err()
Expect(err).NotTo(HaveOccurred()) Expect(err).NotTo(HaveOccurred())
err = client.FunctionLoad(ctx, lib2Code).Err() err = client.FunctionLoad(ctx, lib2Code).Err()

5
example_test.go
View File

@ -657,6 +657,11 @@ func ExampleNewUniversalClient_cluster() {
} }
func ExampleClient_SlowLogGet() { func ExampleClient_SlowLogGet() {
if RECluster {
// skip slowlog test for cluster
fmt.Println(2)
return
}
const key = "slowlog-log-slower-than" const key = "slowlog-log-slower-than"
old := rdb.ConfigGet(ctx, key).Val() old := rdb.ConfigGet(ctx, key).Val()

10
json_test.go
View File

@ -19,7 +19,7 @@ var _ = Describe("JSON Commands", Label("json"), func() {
BeforeEach(func() { BeforeEach(func() {
client = redis.NewClient(&redis.Options{Addr: ":6379"}) client = redis.NewClient(&redis.Options{Addr: ":6379"})
Expect(client.FlushDB(ctx).Err()).NotTo(HaveOccurred()) Expect(client.FlushAll(ctx).Err()).NotTo(HaveOccurred())
}) })
AfterEach(func() { AfterEach(func() {
@ -270,7 +270,7 @@ var _ = Describe("JSON Commands", Label("json"), func() {
Expect(res).To(Equal(`[{"a":1,"b":3,"c":4}]`)) Expect(res).To(Equal(`[{"a":1,"b":3,"c":4}]`))
}) })
It("should JSONMSet", Label("json.mset", "json"), func() { It("should JSONMSet", Label("json.mset", "json", "NonRedisEnterprise"), func() {
doc1 := redis.JSONSetArgs{Key: "mset1", Path: "$", Value: `{"a": 1}`} doc1 := redis.JSONSetArgs{Key: "mset1", Path: "$", Value: `{"a": 1}`}
doc2 := redis.JSONSetArgs{Key: "mset2", Path: "$", Value: 2} doc2 := redis.JSONSetArgs{Key: "mset2", Path: "$", Value: 2}
docs := []redis.JSONSetArgs{doc1, doc2} docs := []redis.JSONSetArgs{doc1, doc2}
@ -287,11 +287,11 @@ var _ = Describe("JSON Commands", Label("json"), func() {
Expect(err).NotTo(HaveOccurred()) Expect(err).NotTo(HaveOccurred())
Expect(res).To(Equal([]interface{}{`[{"a":1}]`, "[2]"})) Expect(res).To(Equal([]interface{}{`[{"a":1}]`, "[2]"}))
mSetResult, err = client.JSONMSet(ctx, "mset1", "$.a", 2, "mset3", "$", `[1]`).Result() _, err = client.JSONMSet(ctx, "mset1", "$.a", 2, "mset3", "$", `[1]`).Result()
Expect(err).NotTo(HaveOccurred()) Expect(err).NotTo(HaveOccurred())
}) })
It("should JSONMGet", Label("json.mget", "json"), func() { It("should JSONMGet", Label("json.mget", "json", "NonRedisEnterprise"), func() {
cmd1 := client.JSONSet(ctx, "mget2a", "$", `{"a": ["aa", "ab", "ac", "ad"], "b": {"a": ["ba", "bb", "bc", "bd"]}}`) cmd1 := client.JSONSet(ctx, "mget2a", "$", `{"a": ["aa", "ab", "ac", "ad"], "b": {"a": ["ba", "bb", "bc", "bd"]}}`)
Expect(cmd1.Err()).NotTo(HaveOccurred()) Expect(cmd1.Err()).NotTo(HaveOccurred())
Expect(cmd1.Val()).To(Equal("OK")) Expect(cmd1.Val()).To(Equal("OK"))
@ -306,7 +306,7 @@ var _ = Describe("JSON Commands", Label("json"), func() {
Expect(cmd3.Val()[1]).To(Equal(`[[100,200,300,200],[100,200,300,200]]`)) Expect(cmd3.Val()[1]).To(Equal(`[[100,200,300,200],[100,200,300,200]]`))
}) })
It("should JSONMget with $", Label("json.mget", "json"), func() { It("should JSONMget with $", Label("json.mget", "json", "NonRedisEnterprise"), func() {
res, err := client.JSONSet(ctx, "doc1", "$", `{"a": 1, "b": 2, "nested": {"a": 3}, "c": "", "nested2": {"a": ""}}`).Result() res, err := client.JSONSet(ctx, "doc1", "$", `{"a": 1, "b": 2, "nested": {"a": 3}, "c": "", "nested2": {"a": ""}}`).Result()
Expect(err).NotTo(HaveOccurred()) Expect(err).NotTo(HaveOccurred())
Expect(res).To(Equal("OK")) Expect(res).To(Equal("OK"))

81
main_test.go
View File

@ -6,6 +6,7 @@ import (
"os" "os"
"os/exec" "os/exec"
"path/filepath" "path/filepath"
"strconv"
"sync" "sync"
"testing" "testing"
"time" "time"
@ -64,6 +65,8 @@ var cluster = &clusterScenario{
clients: make(map[string]*redis.Client, 6), clients: make(map[string]*redis.Client, 6),
} }
var RECluster = false
func registerProcess(port string, p *redisProcess) { func registerProcess(port string, p *redisProcess) {
if processes == nil { if processes == nil {
processes = make(map[string]*redisProcess) processes = make(map[string]*redisProcess)
@ -78,47 +81,56 @@ var _ = BeforeSuite(func() {
redisAddr = ":" + redisPort redisAddr = ":" + redisPort
} }
var err error var err error
RECluster, _ = strconv.ParseBool(os.Getenv("RE_CLUSTER"))
redisMain, err = startRedis(redisPort) if !RECluster {
Expect(err).NotTo(HaveOccurred())
ringShard1, err = startRedis(ringShard1Port) redisMain, err = startRedis(redisPort)
Expect(err).NotTo(HaveOccurred()) Expect(err).NotTo(HaveOccurred())
ringShard2, err = startRedis(ringShard2Port) ringShard1, err = startRedis(ringShard1Port)
Expect(err).NotTo(HaveOccurred()) Expect(err).NotTo(HaveOccurred())
ringShard3, err = startRedis(ringShard3Port) ringShard2, err = startRedis(ringShard2Port)
Expect(err).NotTo(HaveOccurred()) Expect(err).NotTo(HaveOccurred())
sentinelMaster, err = startRedis(sentinelMasterPort) ringShard3, err = startRedis(ringShard3Port)
Expect(err).NotTo(HaveOccurred()) Expect(err).NotTo(HaveOccurred())
sentinel1, err = startSentinel(sentinelPort1, sentinelName, sentinelMasterPort) sentinelMaster, err = startRedis(sentinelMasterPort)
Expect(err).NotTo(HaveOccurred()) Expect(err).NotTo(HaveOccurred())
sentinel2, err = startSentinel(sentinelPort2, sentinelName, sentinelMasterPort) sentinel1, err = startSentinel(sentinelPort1, sentinelName, sentinelMasterPort)
Expect(err).NotTo(HaveOccurred()) Expect(err).NotTo(HaveOccurred())
sentinel3, err = startSentinel(sentinelPort3, sentinelName, sentinelMasterPort) sentinel2, err = startSentinel(sentinelPort2, sentinelName, sentinelMasterPort)
Expect(err).NotTo(HaveOccurred()) Expect(err).NotTo(HaveOccurred())
sentinelSlave1, err = startRedis( sentinel3, err = startSentinel(sentinelPort3, sentinelName, sentinelMasterPort)
sentinelSlave1Port, "--slaveof", "127.0.0.1", sentinelMasterPort) Expect(err).NotTo(HaveOccurred())
Expect(err).NotTo(HaveOccurred())
sentinelSlave2, err = startRedis( sentinelSlave1, err = startRedis(
sentinelSlave2Port, "--slaveof", "127.0.0.1", sentinelMasterPort) sentinelSlave1Port, "--slaveof", "127.0.0.1", sentinelMasterPort)
Expect(err).NotTo(HaveOccurred()) Expect(err).NotTo(HaveOccurred())
Expect(startCluster(ctx, cluster)).NotTo(HaveOccurred()) sentinelSlave2, err = startRedis(
sentinelSlave2Port, "--slaveof", "127.0.0.1", sentinelMasterPort)
Expect(err).NotTo(HaveOccurred())
Expect(startCluster(ctx, cluster)).NotTo(HaveOccurred())
} else {
redisPort = rediStackPort
redisAddr = rediStackAddr
}
}) })
var _ = AfterSuite(func() { var _ = AfterSuite(func() {
Expect(cluster.Close()).NotTo(HaveOccurred()) if !RECluster {
Expect(cluster.Close()).NotTo(HaveOccurred())
for _, p := range processes { for _, p := range processes {
Expect(p.Close()).NotTo(HaveOccurred()) Expect(p.Close()).NotTo(HaveOccurred())
}
} }
processes = nil processes = nil
}) })
@ -131,6 +143,23 @@ func TestGinkgoSuite(t *testing.T) {
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
func redisOptions() *redis.Options { func redisOptions() *redis.Options {
if RECluster {
return &redis.Options{
Addr: redisAddr,
DB: 0,
DialTimeout: 10 * time.Second,
ReadTimeout: 30 * time.Second,
WriteTimeout: 30 * time.Second,
ContextTimeoutEnabled: true,
MaxRetries: -1,
PoolSize: 10,
PoolTimeout: 30 * time.Second,
ConnMaxIdleTime: time.Minute,
}
}
return &redis.Options{ return &redis.Options{
Addr: redisAddr, Addr: redisAddr,
DB: 15, DB: 15,

2
pipeline_test.go
View File

@ -71,7 +71,7 @@ var _ = Describe("pipelining", func() {
Expect(cmds).To(HaveLen(1)) Expect(cmds).To(HaveLen(1))
}) })
It("handles large pipelines", func() { It("handles large pipelines", Label("NonRedisEnterprise"), func() {
for callCount := 1; callCount < 16; callCount++ { for callCount := 1; callCount < 16; callCount++ {
for i := 1; i <= callCount; i++ { for i := 1; i <= callCount; i++ {
pipe.SetNX(ctx, strconv.Itoa(i)+"_key", strconv.Itoa(i)+"_value", 0) pipe.SetNX(ctx, strconv.Itoa(i)+"_key", strconv.Itoa(i)+"_value", 0)

4
probabilistic_test.go
View File

@ -460,7 +460,7 @@ var _ = Describe("Probabilistic commands", Label("probabilistic"), func() {
Expect(info).To(BeAssignableToTypeOf(redis.CMSInfo{})) Expect(info).To(BeAssignableToTypeOf(redis.CMSInfo{}))
}) })
It("should CMSMerge, CMSMergeWithWeight and CMSQuery", Label("cms", "cmsmerge", "cmsquery"), func() { It("should CMSMerge, CMSMergeWithWeight and CMSQuery", Label("cms", "cmsmerge", "cmsquery", "NonRedisEnterprise"), func() {
err := client.CMSMerge(ctx, "destCms1", "testcms2", "testcms3").Err() err := client.CMSMerge(ctx, "destCms1", "testcms2", "testcms3").Err()
Expect(err).To(HaveOccurred()) Expect(err).To(HaveOccurred())
Expect(err).To(MatchError("CMS: key does not exist")) Expect(err).To(MatchError("CMS: key does not exist"))
@ -697,7 +697,7 @@ var _ = Describe("Probabilistic commands", Label("probabilistic"), func() {
Expect(info.Compression).To(BeEquivalentTo(int64(2000))) Expect(info.Compression).To(BeEquivalentTo(int64(2000)))
}) })
It("should TDigestMerge", Label("tdigest", "tmerge"), func() { It("should TDigestMerge", Label("tdigest", "tmerge", "NonRedisEnterprise"), func() {
err := client.TDigestCreate(ctx, "tdigest1").Err() err := client.TDigestCreate(ctx, "tdigest1").Err()
Expect(err).NotTo(HaveOccurred()) Expect(err).NotTo(HaveOccurred())
err = client.TDigestAdd(ctx, "tdigest1", 10, 20, 30, 40, 50, 60, 70, 80, 90, 100).Err() err = client.TDigestAdd(ctx, "tdigest1", 10, 20, 30, 40, 50, 60, 70, 80, 90, 100).Err()

4
race_test.go
View File

@ -137,7 +137,7 @@ var _ = Describe("races", func() {
}) })
}) })
It("should select db", func() { It("should select db", Label("NonRedisEnterprise"), func() {
err := client.Set(ctx, "db", 1, 0).Err() err := client.Set(ctx, "db", 1, 0).Err()
Expect(err).NotTo(HaveOccurred()) Expect(err).NotTo(HaveOccurred())
@ -243,7 +243,7 @@ var _ = Describe("races", func() {
}) })
}) })
var _ = Describe("cluster races", func() { var _ = Describe("cluster races", Label("NonRedisEnterprise"), func() {
var client *redis.ClusterClient var client *redis.ClusterClient
var C, N int var C, N int

12
redis_test.go
View File

@ -65,7 +65,11 @@ var _ = Describe("Client", func() {
}) })
It("should Stringer", func() { It("should Stringer", func() {
Expect(client.String()).To(Equal(fmt.Sprintf("Redis<:%s db:15>", redisPort))) if RECluster {
Expect(client.String()).To(Equal(fmt.Sprintf("Redis<:%s db:0>", redisPort)))
} else {
Expect(client.String()).To(Equal(fmt.Sprintf("Redis<:%s db:15>", redisPort)))
}
}) })
It("supports context", func() { It("supports context", func() {
@ -76,7 +80,7 @@ var _ = Describe("Client", func() {
Expect(err).To(MatchError("context canceled")) Expect(err).To(MatchError("context canceled"))
}) })
It("supports WithTimeout", func() { It("supports WithTimeout", Label("NonRedisEnterprise"), func() {
err := client.ClientPause(ctx, time.Second).Err() err := client.ClientPause(ctx, time.Second).Err()
Expect(err).NotTo(HaveOccurred()) Expect(err).NotTo(HaveOccurred())
@ -151,7 +155,7 @@ var _ = Describe("Client", func() {
Expect(pubsub.Close()).NotTo(HaveOccurred()) Expect(pubsub.Close()).NotTo(HaveOccurred())
}) })
It("should select DB", func() { It("should select DB", Label("NonRedisEnterprise"), func() {
db2 := redis.NewClient(&redis.Options{ db2 := redis.NewClient(&redis.Options{
Addr: redisAddr, Addr: redisAddr,
DB: 2, DB: 2,
@ -503,7 +507,7 @@ var _ = Describe("Conn", func() {
Expect(err).NotTo(HaveOccurred()) Expect(err).NotTo(HaveOccurred())
}) })
It("TxPipeline", func() { It("TxPipeline", Label("NonRedisEnterprise"), func() {
tx := client.Conn().TxPipeline() tx := client.Conn().TxPipeline()
tx.SwapDB(ctx, 0, 2) tx.SwapDB(ctx, 0, 2)
tx.SwapDB(ctx, 1, 0) tx.SwapDB(ctx, 1, 0)

16
timeseries_commands_test.go
View File

@ -15,7 +15,7 @@ var _ = Describe("RedisTimeseries commands", Label("timeseries"), func() {
var client *redis.Client var client *redis.Client
BeforeEach(func() { BeforeEach(func() {
client = redis.NewClient(&redis.Options{Addr: ":6379"}) client = redis.NewClient(&redis.Options{Addr: rediStackAddr})
Expect(client.FlushDB(ctx).Err()).NotTo(HaveOccurred()) Expect(client.FlushDB(ctx).Err()).NotTo(HaveOccurred())
}) })
@ -290,15 +290,17 @@ var _ = Describe("RedisTimeseries commands", Label("timeseries"), func() {
Expect(result.Value).To(BeEquivalentTo(151)) Expect(result.Value).To(BeEquivalentTo(151))
}) })
It("should TSGet Latest", Label("timeseries", "tsgetlatest"), func() { It("should TSGet Latest", Label("timeseries", "tsgetlatest", "NonRedisEnterprise"), func() {
resultGet, err := client.TSCreate(ctx, "tsgl-1").Result() resultGet, err := client.TSCreate(ctx, "tsgl-1").Result()
Expect(err).NotTo(HaveOccurred()) Expect(err).NotTo(HaveOccurred())
Expect(resultGet).To(BeEquivalentTo("OK")) Expect(resultGet).To(BeEquivalentTo("OK"))
resultGet, err = client.TSCreate(ctx, "tsgl-2").Result() resultGet, err = client.TSCreate(ctx, "tsgl-2").Result()
Expect(err).NotTo(HaveOccurred()) Expect(err).NotTo(HaveOccurred())
Expect(resultGet).To(BeEquivalentTo("OK")) Expect(resultGet).To(BeEquivalentTo("OK"))
resultGet, err = client.TSCreateRule(ctx, "tsgl-1", "tsgl-2", redis.Sum, 10).Result() resultGet, err = client.TSCreateRule(ctx, "tsgl-1", "tsgl-2", redis.Sum, 10).Result()
Expect(err).NotTo(HaveOccurred()) Expect(err).NotTo(HaveOccurred())
Expect(resultGet).To(BeEquivalentTo("OK")) Expect(resultGet).To(BeEquivalentTo("OK"))
_, err = client.TSAdd(ctx, "tsgl-1", 1, 1).Result() _, err = client.TSAdd(ctx, "tsgl-1", 1, 1).Result()
Expect(err).NotTo(HaveOccurred()) Expect(err).NotTo(HaveOccurred())
@ -344,7 +346,7 @@ var _ = Describe("RedisTimeseries commands", Label("timeseries"), func() {
Expect(result).To(BeEquivalentTo([]int64{1, 2, 3})) Expect(result).To(BeEquivalentTo([]int64{1, 2, 3}))
}) })
It("should TSMGet and TSMGetWithArgs", Label("timeseries", "tsmget", "tsmgetWithArgs"), func() { It("should TSMGet and TSMGetWithArgs", Label("timeseries", "tsmget", "tsmgetWithArgs", "NonRedisEnterprise"), func() {
opt := &redis.TSOptions{Labels: map[string]string{"Test": "This"}} opt := &redis.TSOptions{Labels: map[string]string{"Test": "This"}}
resultCreate, err := client.TSCreateWithArgs(ctx, "a", opt).Result() resultCreate, err := client.TSCreateWithArgs(ctx, "a", opt).Result()
Expect(err).NotTo(HaveOccurred()) Expect(err).NotTo(HaveOccurred())
@ -429,7 +431,7 @@ var _ = Describe("RedisTimeseries commands", Label("timeseries"), func() {
Expect(resultRange[0]).To(BeEquivalentTo(redis.TSTimestampValue{Timestamp: 22, Value: 1})) Expect(resultRange[0]).To(BeEquivalentTo(redis.TSTimestampValue{Timestamp: 22, Value: 1}))
}) })
It("should TSRange, TSRangeWithArgs", Label("timeseries", "tsrange", "tsrangeWithArgs"), func() { It("should TSRange, TSRangeWithArgs", Label("timeseries", "tsrange", "tsrangeWithArgs", "NonRedisEnterprise"), func() {
for i := 0; i < 100; i++ { for i := 0; i < 100; i++ {
_, err := client.TSAdd(ctx, "a", i, float64(i%7)).Result() _, err := client.TSAdd(ctx, "a", i, float64(i%7)).Result()
Expect(err).NotTo(HaveOccurred()) Expect(err).NotTo(HaveOccurred())
@ -541,7 +543,7 @@ var _ = Describe("RedisTimeseries commands", Label("timeseries"), func() {
Expect(len(resultRange)).To(BeEquivalentTo(7)) Expect(len(resultRange)).To(BeEquivalentTo(7))
}) })
It("should TSRevRange, TSRevRangeWithArgs", Label("timeseries", "tsrevrange", "tsrevrangeWithArgs"), func() { It("should TSRevRange, TSRevRangeWithArgs", Label("timeseries", "tsrevrange", "tsrevrangeWithArgs", "NonRedisEnterprise"), func() {
for i := 0; i < 100; i++ { for i := 0; i < 100; i++ {
_, err := client.TSAdd(ctx, "a", i, float64(i%7)).Result() _, err := client.TSAdd(ctx, "a", i, float64(i%7)).Result()
Expect(err).NotTo(HaveOccurred()) Expect(err).NotTo(HaveOccurred())
@ -755,7 +757,7 @@ var _ = Describe("RedisTimeseries commands", Label("timeseries"), func() {
Expect(result["a"][2]).To(BeEquivalentTo([]interface{}{[]interface{}{int64(0), 5.0}, []interface{}{int64(5), 6.0}})) Expect(result["a"][2]).To(BeEquivalentTo([]interface{}{[]interface{}{int64(0), 5.0}, []interface{}{int64(5), 6.0}}))
}) })
It("should TSMRangeWithArgs Latest", Label("timeseries", "tsmrangeWithArgs", "tsmrangelatest"), func() { It("should TSMRangeWithArgs Latest", Label("timeseries", "tsmrangeWithArgs", "tsmrangelatest", "NonRedisEnterprise"), func() {
resultCreate, err := client.TSCreate(ctx, "a").Result() resultCreate, err := client.TSCreate(ctx, "a").Result()
Expect(err).NotTo(HaveOccurred()) Expect(err).NotTo(HaveOccurred())
Expect(resultCreate).To(BeEquivalentTo("OK")) Expect(resultCreate).To(BeEquivalentTo("OK"))
@ -888,7 +890,7 @@ var _ = Describe("RedisTimeseries commands", Label("timeseries"), func() {
Expect(result["a"][2]).To(BeEquivalentTo([]interface{}{[]interface{}{int64(1), 10.0}, []interface{}{int64(0), 1.0}})) Expect(result["a"][2]).To(BeEquivalentTo([]interface{}{[]interface{}{int64(1), 10.0}, []interface{}{int64(0), 1.0}}))
}) })
It("should TSMRevRangeWithArgs Latest", Label("timeseries", "tsmrevrangeWithArgs", "tsmrevrangelatest"), func() { It("should TSMRevRangeWithArgs Latest", Label("timeseries", "tsmrevrangeWithArgs", "tsmrevrangelatest", "NonRedisEnterprise"), func() {
resultCreate, err := client.TSCreate(ctx, "a").Result() resultCreate, err := client.TSCreate(ctx, "a").Result()
Expect(err).NotTo(HaveOccurred()) Expect(err).NotTo(HaveOccurred())
Expect(resultCreate).To(BeEquivalentTo("OK")) Expect(resultCreate).To(BeEquivalentTo("OK"))

2
tx_test.go
View File

@ -64,7 +64,7 @@ var _ = Describe("Tx", func() {
Expect(n).To(Equal(int64(100))) Expect(n).To(Equal(int64(100)))
}) })
It("should discard", func() { It("should discard", Label("NonRedisEnterprise"), func() {
err := client.Watch(ctx, func(tx *redis.Tx) error { err := client.Watch(ctx, func(tx *redis.Tx) error {
cmds, err := tx.TxPipelined(ctx, func(pipe redis.Pipeliner) error { cmds, err := tx.TxPipelined(ctx, func(pipe redis.Pipeliner) error {
pipe.Set(ctx, "key1", "hello1", 0) pipe.Set(ctx, "key1", "hello1", 0)

2
universal_test.go
View File

@ -32,7 +32,7 @@ var _ = Describe("UniversalClient", func() {
Expect(client.Ping(ctx).Err()).NotTo(HaveOccurred()) Expect(client.Ping(ctx).Err()).NotTo(HaveOccurred())
}) })
It("should connect to clusters", func() { It("should connect to clusters", Label("NonRedisEnterprise"), func() {
client = redis.NewUniversalClient(&redis.UniversalOptions{ client = redis.NewUniversalClient(&redis.UniversalOptions{
Addrs: cluster.addrs(), Addrs: cluster.addrs(),
}) })