Files
porto/pkg/redisclient/redisclient_test.go
2026-10-12 19:13:13 -05:00

1148 lines
38 KiB
Go

package redisclient_test
import (
"bytes"
"context"
"encoding/json"
"fmt"
"slices"
"sync"
"testing"
"time"
"github.com/cockroachdb/errors"
"github.com/effective-security/porto/pkg/redisclient"
"github.com/effective-security/xlog"
"github.com/moby/moby/api/types/container"
"github.com/redis/go-redis/v9"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"github.com/testcontainers/testcontainers-go"
rediscon "github.com/testcontainers/testcontainers-go/modules/redis"
)
func Test_Redis(t *testing.T) {
ctx := context.Background()
redisContainer, err := rediscon.Run(ctx, "redis:8.2",
testcontainers.WithConfigModifier(func(config *container.Config) {
config.Env = []string{
"ALLOW_EMPTY_PASSWORD=yes",
"REDIS_PASSWORD=redis",
"REDIS_TLS_PORT=16379",
}
}),
)
require.NoError(t, err)
t.Cleanup(func() {
require.NoError(t, redisContainer.Terminate(ctx))
})
host, err := redisContainer.ConnectionString(ctx)
require.NoError(t, err)
rcfg := &redisclient.Config{
Server: host,
Password: "redis",
}
rootclient, err := redisclient.New(rcfg)
require.NoError(t, err)
defer rootclient.Close()
client := rootclient.WithPrefix("/test")
err = client.Ping(ctx)
require.NoError(t, err)
assert.Equal(t, "/test", client.Key(""))
assert.Equal(t, "/test/test_key", client.Key("test_key"))
assert.Equal(t, "/test/test_key", client.Key("/test_key"))
assert.Equal(t, "/test/test_key", client.Key("/test_key/"))
// ".." cannot leave the prefix (formerly P-044)
assert.Equal(t, "/test/other/x", client.Key("../other/x"))
assert.Equal(t, "/test/x", client.Key("a/../../x"))
assert.Equal(t, "/test", client.Key(".."))
assert.Equal(t, "", client.SubKey(client.Key("")))
assert.Equal(t, "a/b", client.SubKey(client.Key("/a//b/")))
assert.Equal(t, "../x", rootclient.Key("../x"), "no prefix: key unchanged")
nested := rootclient.WithPrefix(" /a//b/../c/ ")
assert.Equal(t, "/a/c/k", nested.Key("k"))
assert.Equal(t, "k", nested.SubKey(nested.Key("k")))
assert.Equal(t, "/k", rootclient.WithPrefix("a/..").Key("k"))
t.Run("string", func(t *testing.T) {
ok, err := client.Exists(ctx, "test_key_str")
require.NoError(t, err)
assert.False(t, ok)
// Set a key-value pair in Redis
err = client.Set(ctx, "test_key_str", "test_value", time.Hour)
require.NoError(t, err)
exp, err := client.TTL(ctx, "test_key_str")
require.NoError(t, err)
assert.Equal(t, exp, time.Hour)
client.Expire(ctx, "test_key_str", time.Second*10)
exp, err = client.TTL(ctx, "test_key_str")
require.NoError(t, err)
assert.Equal(t, exp, time.Second*10)
var strval string
err = client.Get(ctx, "test_key_str", &strval)
require.NoError(t, err)
assert.Equal(t, "test_value", strval)
ok, err = client.Exists(ctx, "test_key_str")
require.NoError(t, err)
assert.True(t, ok)
list, err := client.Keys(ctx, "test_*")
require.NoError(t, err)
assert.Equal(t, []string{"test_key_str"}, list)
list, err = client.ScanKeys(ctx, "test_*", 10)
require.NoError(t, err)
assert.Equal(t, []string{"test_key_str"}, list)
err = client.Del(ctx, "test_key_str")
require.NoError(t, err)
ok, err = client.Exists(ctx, "test_key_str")
require.NoError(t, err)
assert.False(t, ok)
})
t.Run("sbytestring", func(t *testing.T) {
// Set a key-value pair in Redis
err = client.Set(ctx, "test_key_bytes", []byte("test_value"), 0)
require.NoError(t, err)
var bval []byte
err = client.Get(ctx, "test_key_bytes", &bval)
require.NoError(t, err)
assert.Equal(t, []byte("test_value"), bval)
err = client.Del(ctx, "test_key_bytes")
require.NoError(t, err)
ok, err := client.Exists(ctx, "test_key_bytes")
require.NoError(t, err)
assert.False(t, ok)
})
t.Run("obj", func(t *testing.T) {
// Set a key-value pair in Redis
err = client.Set(ctx, "test_key_obj", rcfg, 0)
require.NoError(t, err)
var obj redisclient.Config
err = client.Get(ctx, "test_key_obj", &obj)
require.NoError(t, err)
assert.Equal(t, rcfg, &obj)
err = client.Del(ctx, "test_key_obj")
require.NoError(t, err)
ok, err := client.Exists(ctx, "test_key_obj")
require.NoError(t, err)
assert.False(t, ok)
})
t.Run("List", func(t *testing.T) {
err = client.LPush(ctx, "test_list", "value1", "value2", "value3")
require.NoError(t, err)
err = client.RPush(ctx, "test_list", "Rvalue1", "Rvalue2", "Rvalue3")
require.NoError(t, err)
list, err := client.LRange(ctx, "test_list", 0, -1)
require.NoError(t, err)
assert.Equal(t, []string{"value3", "value2", "value1", "Rvalue1", "Rvalue2", "Rvalue3"}, list)
val, err := client.LPop(ctx, "test_list")
require.NoError(t, err)
assert.Equal(t, "value3", val)
val, err = client.RPop(ctx, "test_list")
require.NoError(t, err)
assert.Equal(t, "Rvalue3", val)
list, err = client.LRange(ctx, "test_list", 0, -1)
require.NoError(t, err)
assert.Equal(t, []string{"value2", "value1", "Rvalue1", "Rvalue2"}, list)
err = client.LTrim(ctx, "test_list", 1, 3)
require.NoError(t, err)
list, err = client.LRange(ctx, "test_list", 0, -1)
require.NoError(t, err)
assert.Equal(t, []string{"value1", "Rvalue1", "Rvalue2"}, list)
err = client.Del(ctx, "test_list")
require.NoError(t, err)
ok, err := client.Exists(ctx, "test_list")
require.NoError(t, err)
assert.False(t, ok)
})
t.Run("Set", func(t *testing.T) {
err = client.SAdd(ctx, "test_set", "value1", "value2", "value3")
require.NoError(t, err)
err = client.SAdd(ctx, "test_set", "value4")
require.NoError(t, err)
members, err := client.SMembers(ctx, "test_set")
require.NoError(t, err)
assert.ElementsMatch(t, []string{"value1", "value2", "value3", "value4"}, members)
err = client.SRem(ctx, "test_set", "value2")
require.NoError(t, err)
members, err = client.SMembers(ctx, "test_set")
require.NoError(t, err)
assert.ElementsMatch(t, []string{"value1", "value3", "value4"}, members)
size, err := client.SCard(ctx, "test_set")
require.NoError(t, err)
assert.Equal(t, int64(3), size)
err = client.Del(ctx, "test_set")
require.NoError(t, err)
ok, err := client.Exists(ctx, "test_set")
require.NoError(t, err)
assert.False(t, ok)
})
t.Run("SetWithEviction", func(t *testing.T) {
for i := 0; i < 12; i++ {
err = client.SAddWithEviction(ctx, "gap_test_set", "gap_test_set_list", 10, fmt.Sprintf("v%d", i))
require.NoError(t, err)
}
members, err := client.SMembers(ctx, "gap_test_set")
require.NoError(t, err)
assert.Len(t, members, 10)
assert.Equal(t, []string{"v2", "v3", "v4", "v5", "v6", "v7", "v8", "v9", "v10", "v11"}, members)
list, err := client.LRange(ctx, "gap_test_set_list", 0, -1)
require.NoError(t, err)
assert.Len(t, list, 10)
err = client.Del(ctx, "gap_test_set")
require.NoError(t, err)
err = client.Del(ctx, "gap_test_set_list")
require.NoError(t, err)
//
err = client.Del(ctx, "test_set")
require.NoError(t, err)
err = client.Del(ctx, "test_set_list")
require.NoError(t, err)
})
t.Run("Hash", func(t *testing.T) {
err = client.HSet(ctx, "test_hash", "field1", "value1")
require.NoError(t, err)
err = client.HSetMany(ctx, "test_hash", map[string]any{"field2": "value2", "field3": "value3"})
require.NoError(t, err)
val, err := client.HGet(ctx, "test_hash", "field1")
require.NoError(t, err)
assert.Equal(t, "value1", val)
val, err = client.HGet(ctx, "test_hash", "field2")
require.NoError(t, err)
assert.Equal(t, "value2", val)
fields, err := client.HKeys(ctx, "test_hash")
require.NoError(t, err)
assert.ElementsMatch(t, []string{"field1", "field2", "field3"}, fields)
err = client.HDel(ctx, "test_hash", "field1")
require.NoError(t, err)
_, err = client.HGet(ctx, "test_hash", "field1")
require.EqualError(t, err, "not found")
assert.ErrorIs(t, err, redisclient.ErrNotFound)
assert.NotNil(t, errors.Unwrap(err), "a missing field must carry a stack")
err = client.Del(ctx, "test_hash")
require.NoError(t, err)
ok, err := client.Exists(ctx, "test_hash")
require.NoError(t, err)
assert.False(t, ok)
})
t.Run("HashWithEviction", func(t *testing.T) {
for i := 0; i < 12; i++ {
err = client.HSetWithEviction(ctx, "gap_test_hash", "gap_test_hash_list", 10, fmt.Sprintf("field%d", i), fmt.Sprintf("value%d", i))
require.NoError(t, err)
}
fields, err := client.HKeys(ctx, "gap_test_hash")
require.NoError(t, err)
assert.Len(t, fields, 10)
assert.Equal(t, []string{"field2", "field3", "field4", "field5", "field6", "field7", "field8", "field9", "field10", "field11"}, fields)
list, err := client.LRange(ctx, "gap_test_hash_list", 0, -1)
require.NoError(t, err)
assert.Len(t, list, 10)
err = client.Del(ctx, "gap_test_hash")
require.NoError(t, err)
err = client.Del(ctx, "gap_test_hash_list")
require.NoError(t, err)
err = client.Del(ctx, "test_hash")
require.NoError(t, err)
err = client.Del(ctx, "test_hash_list")
require.NoError(t, err)
})
t.Run("Zset", func(t *testing.T) {
for i := 0; i < 12; i++ {
err = client.ZAdd(ctx, "test_zset", 1.0, fmt.Sprintf("value%d", i))
require.NoError(t, err)
}
for i := 0; i < 12; i++ {
for j := 0; j < i; j++ {
err = client.ZIncrBy(ctx, "test_zset", 1.0, fmt.Sprintf("value%d", j))
require.NoError(t, err)
}
}
card, err := client.ZCard(ctx, "test_zset")
require.NoError(t, err)
assert.Equal(t, int64(12), card)
// Get the top 3 elements
members, err := client.ZRevRangeWithScores(ctx, "test_zset", 0, 2)
require.NoError(t, err)
assert.Equal(t, []redis.Z{
{Score: 12.0, Member: "value0"},
{Score: 11.0, Member: "value1"},
{Score: 10.0, Member: "value2"},
}, members)
// Get the bottom 3 elements
members, err = client.ZRevRangeWithScores(ctx, "test_zset", -3, -1)
require.NoError(t, err)
assert.Equal(t, []redis.Z{
{Score: 3.0, Member: "value9"},
{Score: 2.0, Member: "value10"},
{Score: 1.0, Member: "value11"},
}, members)
// Keep the top 3 elements
removed, err := client.ZRemRangeByRank(ctx, "test_zset", 0, -4)
require.NoError(t, err)
assert.Equal(t, int64(9), removed)
card, err = client.ZCard(ctx, "test_zset")
require.NoError(t, err)
assert.Equal(t, int64(3), card)
err = client.Del(ctx, "test_zset")
require.NoError(t, err)
})
t.Run("SetWithEvictionReAdd", func(t *testing.T) {
const set, list = "evict_readd_set", "evict_readd_list"
t.Cleanup(func() { cleanup(ctx, t, client, set, list) })
// re-adding "a" keeps its position, so "a" is evicted first and the
// set keeps the three newest distinct members (formerly P-063)
for _, m := range []string{"a", "b", "c", "a", "d"} {
require.NoError(t, client.SAddWithEviction(ctx, set, list, 3, m))
}
members, err := client.SMembers(ctx, set)
require.NoError(t, err)
assert.ElementsMatch(t, []string{"b", "c", "d"}, members)
order, err := client.LRange(ctx, list, 0, -1)
require.NoError(t, err)
assert.Equal(t, []string{"b", "c", "d"}, order)
// a lower limit evicts down to it in one call
require.NoError(t, client.SAddWithEviction(ctx, set, list, 1, "e"))
members, err = client.SMembers(ctx, set)
require.NoError(t, err)
assert.Equal(t, []string{"e"}, members)
order, err = client.LRange(ctx, list, 0, -1)
require.NoError(t, err)
assert.Equal(t, []string{"e"}, order)
})
t.Run("SetWithEvictionStaleEntries", func(t *testing.T) {
const set, list = "evict_stale_set", "evict_stale_list"
t.Cleanup(func() { cleanup(ctx, t, client, set, list) })
for _, m := range []string{"a", "b", "c"} {
require.NoError(t, client.SAddWithEviction(ctx, set, list, 3, m))
}
// "a" removed from the set only, and a duplicate "b" as written by
// earlier versions: neither stale entry may evict the re-added member
require.NoError(t, client.SRem(ctx, set, "a"))
require.NoError(t, client.RPush(ctx, list, "b"))
require.NoError(t, client.SRem(ctx, set, "b"))
require.NoError(t, client.SAddWithEviction(ctx, set, list, 3, "a"))
require.NoError(t, client.SAddWithEviction(ctx, set, list, 3, "b"))
members, err := client.SMembers(ctx, set)
require.NoError(t, err)
assert.ElementsMatch(t, []string{"a", "b", "c"}, members)
order, err := client.LRange(ctx, list, 0, -1)
require.NoError(t, err)
assert.Equal(t, []string{"c", "a", "b"}, order)
// the same for a hash whose field was deleted directly
const hash, hlist = "evict_stale_hash", "evict_stale_hlist"
t.Cleanup(func() { cleanup(ctx, t, client, hash, hlist) })
for _, f := range []string{"f1", "f2"} {
require.NoError(t, client.HSetWithEviction(ctx, hash, hlist, 2, f, "v"))
}
require.NoError(t, client.HDel(ctx, hash, "f1"))
require.NoError(t, client.HSetWithEviction(ctx, hash, hlist, 2, "f1", "v1"))
vals, err := client.HGetAll(ctx, hash)
require.NoError(t, err)
assert.Equal(t, map[string]string{"f1": "v1", "f2": "v"}, vals)
order, err = client.LRange(ctx, hlist, 0, -1)
require.NoError(t, err)
assert.Equal(t, []string{"f2", "f1"}, order)
})
t.Run("SetWithEvictionErrors", func(t *testing.T) {
const set, list, str = "evict_err_set", "evict_err_list", "evict_err_str"
t.Cleanup(func() { cleanup(ctx, t, client, set, list, str) })
err := client.SAddWithEviction(ctx, set, list, 0, "m")
require.EqualError(t, err, "eviction limit for evict_err_set must be positive: 0")
err = client.SAddWithEviction(ctx, set, "/"+set+"/", 3, "m")
require.EqualError(t, err, "eviction list key must differ from evict_err_set")
// a key of the wrong type fails before anything is written
require.NoError(t, client.Set(ctx, str, "x", time.Minute))
err = client.SAddWithEviction(ctx, set, str, 3, "m")
require.ErrorContains(t, err, "unable to add member to bounded set evict_err_set")
require.ErrorContains(t, err, "WRONGTYPE")
ok, err := client.Exists(ctx, set)
require.NoError(t, err)
assert.False(t, ok, "set written before the list type error")
err = client.SAddWithEviction(ctx, str, list, 3, "m")
require.ErrorContains(t, err, "WRONGTYPE")
ok, err = client.Exists(ctx, list)
require.NoError(t, err)
assert.False(t, ok, "list written before the set type error")
})
t.Run("HashWithEvictionUpdate", func(t *testing.T) {
const hash, list = "evict_upd_hash", "evict_upd_list"
t.Cleanup(func() { cleanup(ctx, t, client, hash, list) })
// updating f1 keeps its position, so f1 is evicted first
for _, kv := range [][2]string{{"f1", "v1"}, {"f2", "v2"}, {"f1", "v1b"}, {"f3", "v3"}} {
require.NoError(t, client.HSetWithEviction(ctx, hash, list, 2, kv[0], kv[1]))
}
vals, err := client.HGetAll(ctx, hash)
require.NoError(t, err)
assert.Equal(t, map[string]string{"f2": "v2", "f3": "v3"}, vals)
order, err := client.LRange(ctx, list, 0, -1)
require.NoError(t, err)
assert.Equal(t, []string{"f2", "f3"}, order)
// values are encoded as by HSet
require.NoError(t, client.HSetWithEviction(ctx, hash, list, 2, "f4", 42))
val, err := client.HGet(ctx, hash, "f4")
require.NoError(t, err)
assert.Equal(t, "42", val)
})
t.Run("HashWithEvictionErrors", func(t *testing.T) {
const hash, list, str = "evict_err_hash", "evict_err_hlist", "evict_err_hstr"
t.Cleanup(func() { cleanup(ctx, t, client, hash, list, str) })
err := client.HSetWithEviction(ctx, hash, list, -1, "f", "v")
require.EqualError(t, err, "eviction limit for evict_err_hash must be positive: -1")
err = client.HSetWithEviction(ctx, hash, hash, 3, "f", "v")
require.EqualError(t, err, "eviction list key must differ from evict_err_hash")
require.NoError(t, client.Set(ctx, str, "x", time.Minute))
err = client.HSetWithEviction(ctx, hash, str, 3, "f", "v")
require.ErrorContains(t, err, "unable to set field f in bounded hash evict_err_hash")
require.ErrorContains(t, err, "WRONGTYPE")
ok, err := client.Exists(ctx, hash)
require.NoError(t, err)
assert.False(t, ok, "hash written before the list type error")
})
t.Run("KeyNamespace", func(t *testing.T) {
other := rootclient.WithPrefix("other")
t.Cleanup(func() { cleanup(ctx, t, client, "other/x") })
// a ".." key stays under the client prefix (formerly P-044)
require.NoError(t, client.Set(ctx, "../other/x", "v", time.Minute))
ok, err := other.Exists(ctx, "x")
require.NoError(t, err)
assert.False(t, ok, "key escaped into the sibling prefix")
var val string
require.NoError(t, client.Get(ctx, "other/x", &val))
assert.Equal(t, "v", val)
// glob metacharacters in the prefix match literally: "/m*[1]/*"
// unescaped would also match the sibling "/mX1/"
meta := rootclient.WithPrefix("m*[1]")
sibling := rootclient.WithPrefix("mX1")
t.Cleanup(func() {
cleanup(ctx, t, meta, "k1", "k2")
cleanup(ctx, t, sibling, "k3")
})
require.NoError(t, meta.Set(ctx, "k1", "v", time.Minute))
require.NoError(t, meta.Set(ctx, "k2", "v", time.Minute))
require.NoError(t, sibling.Set(ctx, "k3", "v", time.Minute))
keys, err := meta.Keys(ctx, "*")
require.NoError(t, err)
assert.ElementsMatch(t, []string{"k1", "k2"}, keys)
keys, err = meta.ScanKeys(ctx, "k*", 0)
require.NoError(t, err)
assert.ElementsMatch(t, []string{"k1", "k2"}, keys)
keys, err = meta.Keys(ctx, "../*1")
require.NoError(t, err)
assert.Equal(t, []string{"k1"}, keys)
keys, err = sibling.Keys(ctx, "*")
require.NoError(t, err)
assert.Equal(t, []string{"k3"}, keys)
})
t.Run("DistributedLock", func(t *testing.T) {
token, remaining, err := client.TryLock(ctx, "test_lock", 5*time.Second)
require.NoError(t, err)
assert.NotEmpty(t, token)
assert.Equal(t, time.Duration(0), remaining)
locked, err := client.IsLocked(ctx, "test_lock")
require.NoError(t, err)
assert.True(t, locked)
// held: no token, remaining time of the holder
token2, remaining2, err := client.TryLock(ctx, "test_lock", 5*time.Second)
require.NoError(t, err)
assert.Empty(t, token2)
assert.Greater(t, remaining2, time.Duration(0))
assert.LessOrEqual(t, remaining2, 5*time.Second)
// another owner's token does not release the lock (formerly P-047)
released, err := client.ReleaseLock(ctx, "test_lock", "not-the-owner")
require.NoError(t, err)
assert.False(t, released)
locked, err = client.IsLocked(ctx, "test_lock")
require.NoError(t, err)
assert.True(t, locked)
released, err = client.ReleaseLock(ctx, "test_lock", token)
require.NoError(t, err)
assert.True(t, released)
locked, err = client.IsLocked(ctx, "test_lock")
require.NoError(t, err)
assert.False(t, locked)
// released already
released, err = client.ReleaseLock(ctx, "test_lock", token)
require.NoError(t, err)
assert.False(t, released)
// a new acquisition gets a new token
token3, _, err := client.TryLock(ctx, "test_lock", 5*time.Second)
require.NoError(t, err)
assert.NotEmpty(t, token3)
assert.NotEqual(t, token, token3)
released, err = client.ReleaseLock(ctx, "test_lock", token3)
require.NoError(t, err)
assert.True(t, released)
})
t.Run("LockExpiredOwner", func(t *testing.T) {
// the first owner's lock expires and a second owner acquires it;
// the first owner's late release leaves it alone (formerly P-047)
first, _, err := client.TryLock(ctx, "expire_lock", 100*time.Millisecond)
require.NoError(t, err)
require.NotEmpty(t, first)
require.Eventually(t, func() bool {
locked, err := client.IsLocked(ctx, "expire_lock")
return err == nil && !locked
}, 5*time.Second, 20*time.Millisecond)
second, _, err := client.TryLock(ctx, "expire_lock", 5*time.Second)
require.NoError(t, err)
require.NotEmpty(t, second)
released, err := client.ReleaseLock(ctx, "expire_lock", first)
require.NoError(t, err)
assert.False(t, released)
locked, err := client.IsLocked(ctx, "expire_lock")
require.NoError(t, err)
assert.True(t, locked)
released, err = client.ReleaseLock(ctx, "expire_lock", second)
require.NoError(t, err)
assert.True(t, released)
})
t.Run("LockArguments", func(t *testing.T) {
for _, timeout := range []time.Duration{0, -time.Second, 500 * time.Microsecond} {
token, remaining, err := client.TryLock(ctx, "arg_lock", timeout)
require.EqualError(t, err, fmt.Sprintf("lock timeout for key arg_lock must be at least 1ms: %s", timeout))
assert.Empty(t, token)
assert.Equal(t, time.Duration(0), remaining)
}
locked, err := client.IsLocked(ctx, "arg_lock")
require.NoError(t, err)
assert.False(t, locked)
released, err := client.ReleaseLock(ctx, "arg_lock", "")
require.EqualError(t, err, "empty lock token for key: arg_lock")
assert.False(t, released)
})
t.Run("CoordinationKeyNamespace", func(t *testing.T) {
// ".." cannot turn a lock or rate-limit key into a data key
require.NoError(t, client.Set(ctx, "victim", "v", time.Minute))
t.Cleanup(func() { cleanup(ctx, t, client, "victim") })
const escaping = "x/../../victim"
token, _, err := client.TryLock(ctx, escaping, time.Second)
require.EqualError(t, err, `invalid key "x/../../victim": leaves the "lock" namespace`)
assert.Empty(t, token)
locked, err := client.IsLocked(ctx, escaping)
require.EqualError(t, err, `invalid key "x/../../victim": leaves the "lock" namespace`)
assert.False(t, locked)
released, err := client.ReleaseLock(ctx, escaping, "token")
require.EqualError(t, err, `invalid key "x/../../victim": leaves the "lock" namespace`)
assert.False(t, released)
allowed, _, err := client.TryAcquireRateLimit(ctx, escaping, time.Second)
require.EqualError(t, err, `invalid key "x/../../victim": leaves the "ratelimit" namespace`)
assert.False(t, allowed)
remaining, err := client.GetRateLimitRemainingTime(ctx, escaping)
require.EqualError(t, err, `invalid key "x/../../victim": leaves the "ratelimit" namespace`)
assert.Equal(t, time.Duration(0), remaining)
var val string
require.NoError(t, client.Get(ctx, "victim", &val))
assert.Equal(t, "v", val)
// without a prefix the key is not cleaned and cannot leave
token, _, err = rootclient.TryLock(ctx, escaping, time.Second)
require.NoError(t, err)
require.NotEmpty(t, token)
exists, err := rootclient.Exists(ctx, "lock:"+escaping)
require.NoError(t, err)
assert.True(t, exists)
released, err = rootclient.ReleaseLock(ctx, escaping, token)
require.NoError(t, err)
assert.True(t, released)
// ".." inside the lock namespace is fine
token, _, err = client.TryLock(ctx, "a/b/../c", time.Second)
require.NoError(t, err)
require.NotEmpty(t, token)
locked, err = client.IsLocked(ctx, "a/c")
require.NoError(t, err)
assert.True(t, locked)
released, err = client.ReleaseLock(ctx, "a/c", token)
require.NoError(t, err)
assert.True(t, released)
})
t.Run("RateLimiter", func(t *testing.T) {
const window = time.Second
allowed, remaining, err := client.TryAcquireRateLimit(ctx, "test_rate_limit", window)
require.NoError(t, err)
assert.True(t, allowed)
assert.Equal(t, time.Duration(0), remaining)
allowed, remaining, err = client.TryAcquireRateLimit(ctx, "test_rate_limit", window)
require.NoError(t, err)
assert.False(t, allowed)
assert.Greater(t, remaining, time.Duration(0))
assert.LessOrEqual(t, remaining, window)
remaining, err = client.GetRateLimitRemainingTime(ctx, "test_rate_limit")
require.NoError(t, err)
assert.Greater(t, remaining, time.Duration(0))
assert.LessOrEqual(t, remaining, window)
// the window ends on the server
require.Eventually(t, func() bool {
remaining, err := client.GetRateLimitRemainingTime(ctx, "test_rate_limit")
return err == nil && remaining == 0
}, 5*time.Second, 20*time.Millisecond)
allowed, remaining, err = client.TryAcquireRateLimit(ctx, "test_rate_limit", window)
require.NoError(t, err)
assert.True(t, allowed)
assert.Equal(t, time.Duration(0), remaining)
remaining, err = client.GetRateLimitRemainingTime(ctx, "non_existent_rate_limit")
require.NoError(t, err)
assert.Equal(t, time.Duration(0), remaining)
for _, w := range []time.Duration{0, -time.Second, time.Microsecond} {
allowed, remaining, err = client.TryAcquireRateLimit(ctx, "arg_rate_limit", w)
require.EqualError(t, err, fmt.Sprintf("rate limit window for key arg_rate_limit must be at least 1ms: %s", w))
assert.False(t, allowed)
assert.Equal(t, time.Duration(0), remaining)
}
})
t.Run("RateLimiterPolling", func(t *testing.T) {
// callers polling faster than the window, from several goroutines,
// are allowed once per window: denied polls do not extend the window
// and two callers never win the same window (formerly P-043)
const (
window = 200 * time.Millisecond
pollers = 4
polling = 1100 * time.Millisecond
)
// call is the client-clock span of an allowed call; the server
// started its window somewhere inside it
type call struct{ start, end time.Time }
var (
mu sync.Mutex
allowed []call
errs = make(chan error, pollers)
wg sync.WaitGroup
)
deadline := time.Now().Add(polling)
for range pollers {
wg.Add(1)
go func() {
defer wg.Done()
for time.Now().Before(deadline) {
start := time.Now()
ok, _, err := client.TryAcquireRateLimit(ctx, "polling_rate_limit", window)
if err != nil {
errs <- err
return
}
if ok {
mu.Lock()
allowed = append(allowed, call{start: start, end: time.Now()})
mu.Unlock()
}
time.Sleep(10 * time.Millisecond)
}
}()
}
wg.Wait()
close(errs)
for err := range errs {
require.NoError(t, err)
}
slices.SortFunc(allowed, func(a, b call) int { return a.start.Compare(b.start) })
// about polling/window windows start; before the fix only the first did
assert.GreaterOrEqual(t, len(allowed), 3)
for i := 1; i < len(allowed); i++ {
// windows start at least window apart on the server and each
// start lies inside its call's span; the calls may have been
// served in either order
prev, cur := allowed[i-1], allowed[i]
assert.GreaterOrEqual(t, max(cur.end.Sub(prev.start), prev.end.Sub(cur.start)), window,
"two calls allowed within one window")
}
})
t.Run("RateLimiterLegacyWindow", func(t *testing.T) {
// a window written by an earlier version (a sorted set) is honored
key := client.Key("ratelimit:legacy_rate_limit")
require.NoError(t, client.Client.ZAdd(ctx, key, redis.Z{Score: 1, Member: 1}).Err())
require.NoError(t, client.Client.Expire(ctx, key, 5*time.Second).Err())
t.Cleanup(func() { cleanup(ctx, t, client, "ratelimit:legacy_rate_limit") })
allowed, remaining, err := client.TryAcquireRateLimit(ctx, "legacy_rate_limit", time.Second)
require.NoError(t, err)
assert.False(t, allowed)
assert.Greater(t, remaining, time.Second)
assert.LessOrEqual(t, remaining, 5*time.Second)
})
t.Run("ConcurrentLocking", func(t *testing.T) {
const numGoroutines = 10
type result struct {
token string
err error
}
results := make(chan result, numGoroutines)
for range numGoroutines {
go func() {
token, _, err := client.TryLock(ctx, "concurrent_lock", 5*time.Second)
results <- result{token: token, err: err}
}()
}
var tokens []string
for range numGoroutines {
r := <-results
require.NoError(t, r.err)
if r.token != "" {
tokens = append(tokens, r.token)
}
}
// only one acquired the lock
require.Len(t, tokens, 1)
released, err := client.ReleaseLock(ctx, "concurrent_lock", tokens[0])
require.NoError(t, err)
assert.True(t, released)
})
t.Run("ConcurrentRateLimiting", func(t *testing.T) {
const numGoroutines = 10
type result struct {
allowed bool
err error
}
results := make(chan result, numGoroutines)
for range numGoroutines {
go func() {
allowed, _, err := client.TryAcquireRateLimit(ctx, "concurrent_rate_limit", 5*time.Second)
results <- result{allowed: allowed, err: err}
}()
}
allowedCount := 0
for range numGoroutines {
r := <-results
require.NoError(t, r.err)
if r.allowed {
allowedCount++
}
}
// only one is allowed
assert.Equal(t, 1, allowedCount)
})
t.Run("KeyPrefixing", func(t *testing.T) {
token, _, err := client.TryLock(ctx, "prefix_test", 5*time.Second)
require.NoError(t, err)
require.NotEmpty(t, token)
// the lock key is prefixed
exists, err := client.Exists(ctx, "lock:prefix_test")
require.NoError(t, err)
assert.True(t, exists)
exists, err = rootclient.Exists(ctx, "/test/lock:prefix_test")
require.NoError(t, err)
assert.True(t, exists)
allowed, _, err := client.TryAcquireRateLimit(ctx, "prefix_rate_test", 5*time.Second)
require.NoError(t, err)
assert.True(t, allowed)
// the rate limit key is prefixed
exists, err = client.Exists(ctx, "ratelimit:prefix_rate_test")
require.NoError(t, err)
assert.True(t, exists)
released, err := client.ReleaseLock(ctx, "prefix_test", token)
require.NoError(t, err)
assert.True(t, released)
})
t.Run("DifferentKeys", func(t *testing.T) {
token1, remaining1, err := client.TryLock(ctx, "key1", 5*time.Second)
require.NoError(t, err)
assert.NotEmpty(t, token1)
assert.Equal(t, time.Duration(0), remaining1)
token2, remaining2, err := client.TryLock(ctx, "key2", 5*time.Second)
require.NoError(t, err)
assert.NotEmpty(t, token2)
assert.Equal(t, time.Duration(0), remaining2)
// the same keys are held
again, remaining, err := client.TryLock(ctx, "key1", 5*time.Second)
require.NoError(t, err)
assert.Empty(t, again)
assert.Greater(t, remaining, time.Duration(0))
again, remaining, err = client.TryLock(ctx, "key2", 5*time.Second)
require.NoError(t, err)
assert.Empty(t, again)
assert.Greater(t, remaining, time.Duration(0))
// a token releases only its own key
released, err := client.ReleaseLock(ctx, "key2", token1)
require.NoError(t, err)
assert.False(t, released)
allowed1, remaining1, err := client.TryAcquireRateLimit(ctx, "rate_key1", 5*time.Second)
require.NoError(t, err)
assert.True(t, allowed1)
assert.Equal(t, time.Duration(0), remaining1)
allowed2, remaining2, err := client.TryAcquireRateLimit(ctx, "rate_key2", 5*time.Second)
require.NoError(t, err)
assert.True(t, allowed2)
assert.Equal(t, time.Duration(0), remaining2)
allowed1, remaining1, err = client.TryAcquireRateLimit(ctx, "rate_key1", 5*time.Second)
require.NoError(t, err)
assert.False(t, allowed1)
assert.Greater(t, remaining1, time.Duration(0))
allowed2, remaining2, err = client.TryAcquireRateLimit(ctx, "rate_key2", 5*time.Second)
require.NoError(t, err)
assert.False(t, allowed2)
assert.Greater(t, remaining2, time.Duration(0))
released, err = client.ReleaseLock(ctx, "key1", token1)
require.NoError(t, err)
assert.True(t, released)
released, err = client.ReleaseLock(ctx, "key2", token2)
require.NoError(t, err)
assert.True(t, released)
})
t.Run("ListLengthAndIndex", func(t *testing.T) {
const list, empty = "len_index_list", "len_index_empty"
t.Cleanup(func() { cleanup(ctx, t, client, list) })
n, err := client.LLen(ctx, list)
require.NoError(t, err)
assert.Equal(t, int64(0), n, "a missing list is empty")
require.NoError(t, client.RPush(ctx, list, "a", "b", "c"))
n, err = client.LLen(ctx, list)
require.NoError(t, err)
assert.Equal(t, int64(3), n)
n, err = rootclient.LLen(ctx, "/test/"+list)
require.NoError(t, err)
assert.Equal(t, int64(3), n, "the list lives under the prefix")
val, err := client.LIndex(ctx, list, 0)
require.NoError(t, err)
assert.Equal(t, "a", val)
val, err = client.LIndex(ctx, list, -1)
require.NoError(t, err)
assert.Equal(t, "c", val)
// an index past the end and a pop from an empty list are a wrapped
// redis.Nil, not ErrNotFound
val, err = client.LIndex(ctx, list, 3)
require.EqualError(t, err, "unable to get index 3 from list len_index_list: redis: nil")
assert.ErrorIs(t, err, redis.Nil)
assert.False(t, redisclient.IsNotFoundError(err))
assert.Empty(t, val)
val, err = client.LPop(ctx, empty)
require.EqualError(t, err, "unable to pop value from list len_index_empty: redis: nil")
assert.ErrorIs(t, err, redis.Nil)
assert.Empty(t, val)
val, err = client.RPop(ctx, empty)
require.EqualError(t, err, "unable to pop value from list len_index_empty: redis: nil")
assert.ErrorIs(t, err, redis.Nil)
assert.Empty(t, val)
})
t.Run("SetIsMember", func(t *testing.T) {
const set = "is_member_set"
t.Cleanup(func() { cleanup(ctx, t, client, set) })
ok, err := client.SIsMember(ctx, set, "a")
require.NoError(t, err)
assert.False(t, ok, "a missing set has no members")
require.NoError(t, client.SAdd(ctx, set, "a", 1))
for _, tc := range []struct {
member any
want bool
}{
{member: "a", want: true},
// members are stored as strings
{member: 1, want: true},
{member: "1", want: true},
{member: "b", want: false},
} {
ok, err = client.SIsMember(ctx, set, tc.member)
require.NoError(t, err)
assert.Equal(t, tc.want, ok, tc.member)
}
})
t.Run("HashExistsAndValues", func(t *testing.T) {
const hash = "exists_vals_hash"
t.Cleanup(func() { cleanup(ctx, t, client, hash) })
ok, err := client.HExists(ctx, hash, "f1")
require.NoError(t, err)
assert.False(t, ok)
vals, err := client.HVals(ctx, hash)
require.NoError(t, err)
assert.Empty(t, vals)
require.NoError(t, client.HSetMany(ctx, hash, map[string]any{
"f1": "v1",
"f2": 2,
}))
// an empty map writes nothing
require.NoError(t, client.HSetMany(ctx, hash, map[string]any{}))
ok, err = client.HExists(ctx, hash, "f1")
require.NoError(t, err)
assert.True(t, ok)
ok, err = client.HExists(ctx, hash, "f3")
require.NoError(t, err)
assert.False(t, ok)
vals, err = client.HVals(ctx, hash)
require.NoError(t, err)
assert.ElementsMatch(t, []string{"v1", "2"}, vals)
all, err := client.HGetAll(ctx, hash)
require.NoError(t, err)
assert.Equal(t, map[string]string{"f1": "v1", "f2": "2"}, all)
_, err = client.HGet(ctx, hash, "f3")
assert.ErrorIs(t, err, redisclient.ErrNotFound)
assert.True(t, redisclient.IsNotFoundError(err))
})
t.Run("ZRem", func(t *testing.T) {
const zset = "zrem_zset"
t.Cleanup(func() { cleanup(ctx, t, client, zset) })
// removing from a missing set is not an error
require.NoError(t, client.ZRem(ctx, zset, "a"))
for i, m := range []string{"a", "b", "c"} {
require.NoError(t, client.ZAdd(ctx, zset, float64(i+1), m))
}
require.NoError(t, client.ZRem(ctx, zset, "a", "c", "missing"))
members, err := client.ZRevRangeWithScores(ctx, zset, 0, -1)
require.NoError(t, err)
assert.Equal(t, []redis.Z{{Score: 2, Member: "b"}}, members)
card, err := client.ZCard(ctx, zset)
require.NoError(t, err)
assert.Equal(t, int64(1), card)
})
t.Run("GetErrors", func(t *testing.T) {
const text, list = "get_text", "get_list"
t.Cleanup(func() { cleanup(ctx, t, client, text, list) })
var s string
err := client.Get(ctx, "get_missing", &s)
require.EqualError(t, err, "not found")
assert.ErrorIs(t, err, redisclient.ErrNotFound)
assert.NotNil(t, errors.Unwrap(err), "a missing key must carry a stack")
assert.True(t, redisclient.IsNotFoundError(err))
// a non-JSON value cannot be decoded into a non-string target
require.NoError(t, client.Set(ctx, text, "plain", time.Minute))
var n int
err = client.Get(ctx, text, &n)
require.EqualError(t, err, "failed to unmarshal value: invalid character 'p' looking for beginning of value")
var syntaxErr *json.SyntaxError
assert.ErrorAs(t, err, &syntaxErr)
// server errors are wrapped with the relative key
require.NoError(t, client.RPush(ctx, list, "a"))
err = client.Get(ctx, list, &s)
require.EqualError(t, err, "failed to get key: get_list: WRONGTYPE Operation against a key holding the wrong kind of value")
assert.False(t, redisclient.IsNotFoundError(err))
_, err = client.HGet(ctx, list, "f")
require.EqualError(t, err, "unable to get field f from hash get_list: WRONGTYPE Operation against a key holding the wrong kind of value")
})
t.Run("NoPrefix", func(t *testing.T) {
const key = "noprefix_key"
t.Cleanup(func() { cleanup(ctx, t, rootclient, key) })
// without a prefix keys, patterns and listed names are used as is
assert.Equal(t, "a//b", rootclient.Key("a//b"))
assert.Equal(t, "/test/x", rootclient.SubKey("/test/x"))
require.NoError(t, rootclient.Set(ctx, key, "v", time.Minute))
keys, err := rootclient.Keys(ctx, "noprefix_*")
require.NoError(t, err)
assert.Equal(t, []string{key}, keys)
keys, err = rootclient.ScanKeys(ctx, "noprefix_*", 0)
require.NoError(t, err)
assert.Equal(t, []string{key}, keys)
// the prefixed client does not see it
keys, err = client.Keys(ctx, "noprefix_*")
require.NoError(t, err)
assert.Empty(t, keys)
})
}
// cleanup deletes keys created by a subtest.
func cleanup(ctx context.Context, t *testing.T, c *redisclient.RedisClient, keys ...string) {
t.Helper()
for _, key := range keys {
assert.NoError(t, c.Del(ctx, key))
}
}
// unreachableServer is a Redis URL nothing listens on; clients connect
// lazily, so tests that never send a command need no server.
const unreachableServer = "redis://127.0.0.1:1/0"
func TestClose(t *testing.T) {
t.Parallel()
ctx := context.Background()
root, err := redisclient.New(&redisclient.Config{Server: unreachableServer})
require.NoError(t, err)
child := root.WithPrefix("child")
assert.NoError(t, child.Close(), "a child does not own the connection")
require.NoError(t, root.Close())
// Close is idempotent and keeps the client, so later calls on the root
// and its children fail instead of panicking (formerly P-062)
assert.NoError(t, root.Close())
assert.NotNil(t, root.RawClient())
var val string
err = root.Get(ctx, "k", &val)
assert.ErrorIs(t, err, redis.ErrClosed)
err = child.Get(ctx, "k", &val)
assert.ErrorIs(t, err, redis.ErrClosed)
// a client from NewWithClient leaves the connection to its owner
raw, err := redisclient.NewRedisClient(&redisclient.Config{Server: unreachableServer})
require.NoError(t, err)
wrapped, err := redisclient.NewWithClient(raw)
require.NoError(t, err)
require.NoError(t, wrapped.Close())
require.NoError(t, raw.Close(), "the owner's close is the first")
}
func TestConfigSecrets(t *testing.T) {
// not parallel: installs a log formatter
const password = "s3cret-pass"
var logs bytes.Buffer
removeFormatter := xlog.InstallFormatter(xlog.NewStringFormatter(&logs))
t.Cleanup(removeFormatter)
// only the address is logged (formerly P-045)
rc, err := redisclient.New(&redisclient.Config{
Server: "redis://user:" + password + "@127.0.0.1:1/2",
})
require.NoError(t, err)
require.NoError(t, rc.Close())
// a malformed URL is reported without the URL
_, err = redisclient.New(&redisclient.Config{
Server: "redis://user:" + password + "@127.0.0.1:bad/0",
})
require.Error(t, err)
assert.Equal(t, `invalid redis address: invalid port ":bad" after host`, err.Error())
_, err = redisclient.New(&redisclient.Config{Server: "http://127.0.0.1"})
require.EqualError(t, err, "invalid redis address: redis: invalid URL scheme: http")
// removal waits for in-flight log calls, so logs is safe to read after it
removeFormatter()
assert.Contains(t, logs.String(), "127.0.0.1:1")
assert.NotContains(t, logs.String(), password)
}