Skip to content

Commit

Permalink
Merge pull request #8 from nyaruka/assert_by_rc
Browse files Browse the repository at this point in the history 
Update assertredis asserts to take a connection instead of a pool
  • Loading branch information
@rowanseymour
rowanseymour authored Mar 13, 2024
2 parents 4e5a11f + fb2c6c7 commit 9a13acf
Show file tree
Hide file tree
Showing 7 changed files with 111 additions and 116 deletions.
79 changes: 36 additions & 43 deletions assertredis/asserts.go
View file
Original file line number Diff line number Diff line change
Expand Up @@ -10,16 +10,16 @@ import (
)

// Keys asserts that only the given keys exist
func Keys(t *testing.T, rp *redis.Pool, pattern string, expected []string, msgAndArgs ...any) bool {
actual, err := redis.Strings(do(rp, "KEYS", pattern))
func Keys(t *testing.T, rc redis.Conn, pattern string, expected []string, msgAndArgs ...any) bool {
actual, err := redis.Strings(rc.Do("KEYS", pattern))
assert.NoError(t, err)

return assert.ElementsMatch(t, expected, actual, msgAndArgs...)
}

// Exists asserts that the given key exists
func Exists(t *testing.T, rp *redis.Pool, key string, msgAndArgs ...any) bool {
exists, err := redis.Bool(do(rp, "EXISTS", key))
func Exists(t *testing.T, rc redis.Conn, key string, msgAndArgs ...any) bool {
exists, err := redis.Bool(rc.Do("EXISTS", key))
assert.NoError(t, err)

if !exists {
Expand All @@ -30,8 +30,8 @@ func Exists(t *testing.T, rp *redis.Pool, key string, msgAndArgs ...any) bool {
}

// NotExists asserts that the given key does not exist
func NotExists(t *testing.T, rp *redis.Pool, key string, msgAndArgs ...any) bool {
exists, err := redis.Bool(do(rp, "EXISTS", key))
func NotExists(t *testing.T, rc redis.Conn, key string, msgAndArgs ...any) bool {
exists, err := redis.Bool(rc.Do("EXISTS", key))
assert.NoError(t, err)

if exists {
Expand All @@ -42,24 +42,24 @@ func NotExists(t *testing.T, rp *redis.Pool, key string, msgAndArgs ...any) bool
}

// Get asserts that the given key contains the given string value
func Get(t *testing.T, rp *redis.Pool, key string, expected string, msgAndArgs ...any) bool {
actual, err := redis.String(do(rp, "GET", key))
func Get(t *testing.T, rc redis.Conn, key string, expected string, msgAndArgs ...any) bool {
actual, err := redis.String(rc.Do("GET", key))
assert.NoError(t, err)

return assert.Equal(t, expected, actual, msgAndArgs...)
}

// SCard asserts the result of calling SCARD on the given key
func SCard(t *testing.T, rp *redis.Pool, key string, expected int, msgAndArgs ...any) bool {
actual, err := redis.Int(do(rp, "SCARD", key))
func SCard(t *testing.T, rc redis.Conn, key string, expected int, msgAndArgs ...any) bool {
actual, err := redis.Int(rc.Do("SCARD", key))
assert.NoError(t, err)

return assert.Equal(t, expected, actual, msgAndArgs...)
}

// SIsMember asserts the result that calling SISMEMBER on the given key is true
func SIsMember(t *testing.T, rp *redis.Pool, key, member string, msgAndArgs ...any) bool {
exists, err := redis.Bool(do(rp, "SISMEMBER", key, member))
func SIsMember(t *testing.T, rc redis.Conn, key, member string, msgAndArgs ...any) bool {
exists, err := redis.Bool(rc.Do("SISMEMBER", key, member))
assert.NoError(t, err)

if !exists {
Expand All @@ -70,8 +70,8 @@ func SIsMember(t *testing.T, rp *redis.Pool, key, member string, msgAndArgs ...a
}

// SIsNotMember asserts the result of calling SISMEMBER on the given key is false
func SIsNotMember(t *testing.T, rp *redis.Pool, key, member string, msgAndArgs ...any) bool {
exists, err := redis.Bool(do(rp, "SISMEMBER", key, member))
func SIsNotMember(t *testing.T, rc redis.Conn, key, member string, msgAndArgs ...any) bool {
exists, err := redis.Bool(rc.Do("SISMEMBER", key, member))
assert.NoError(t, err)

if exists {
Expand All @@ -82,80 +82,80 @@ func SIsNotMember(t *testing.T, rp *redis.Pool, key, member string, msgAndArgs .
}

// SMembers asserts the result of calling SMEMBERS on the given key
func SMembers(t *testing.T, rp *redis.Pool, key string, expected []string, msgAndArgs ...any) bool {
actual, err := redis.Strings(do(rp, "SMEMBERS", key))
func SMembers(t *testing.T, rc redis.Conn, key string, expected []string, msgAndArgs ...any) bool {
actual, err := redis.Strings(rc.Do("SMEMBERS", key))
assert.NoError(t, err)

return assert.ElementsMatch(t, expected, actual, msgAndArgs...)
}

// HGetAll asserts the result of calling HGET on the given key and field
func HGet(t *testing.T, rp *redis.Pool, key, field string, expected string, msgAndArgs ...any) bool {
actual, err := redis.String(do(rp, "HGET", key, field))
func HGet(t *testing.T, rc redis.Conn, key, field string, expected string, msgAndArgs ...any) bool {
actual, err := redis.String(rc.Do("HGET", key, field))
assert.NoError(t, err)

return assert.Equal(t, expected, actual, msgAndArgs...)
}

// HGetAll asserts the result of calling HGETALL on the given key
func HGetAll(t *testing.T, rp *redis.Pool, key string, expected map[string]string, msgAndArgs ...any) bool {
actual, err := redis.StringMap(do(rp, "HGETALL", key))
func HGetAll(t *testing.T, rc redis.Conn, key string, expected map[string]string, msgAndArgs ...any) bool {
actual, err := redis.StringMap(rc.Do("HGETALL", key))
assert.NoError(t, err)

return assert.Equal(t, expected, actual, msgAndArgs...)
}

// HLen asserts the result of calling HLEN on the given key
func HLen(t *testing.T, rp *redis.Pool, key string, expected int, msgAndArgs ...any) bool {
actual, err := redis.Int(do(rp, "HLEN", key))
func HLen(t *testing.T, rc redis.Conn, key string, expected int, msgAndArgs ...any) bool {
actual, err := redis.Int(rc.Do("HLEN", key))
assert.NoError(t, err)

return assert.Equal(t, expected, actual, msgAndArgs...)
}

// LLen asserts the result of calling LLEN on the given key
func LLen(t *testing.T, rp *redis.Pool, key string, expected int, msgAndArgs ...any) bool {
actual, err := redis.Int(do(rp, "LLEN", key))
func LLen(t *testing.T, rc redis.Conn, key string, expected int, msgAndArgs ...any) bool {
actual, err := redis.Int(rc.Do("LLEN", key))
assert.NoError(t, err)

return assert.Equal(t, expected, actual, msgAndArgs...)
}

// LRange asserts the result of calling LRANGE on the given key
func LRange(t *testing.T, rp *redis.Pool, key string, start, stop int, expected []string, msgAndArgs ...any) bool {
actual, err := redis.Strings(do(rp, "LRANGE", key, start, stop))
func LRange(t *testing.T, rc redis.Conn, key string, start, stop int, expected []string, msgAndArgs ...any) bool {
actual, err := redis.Strings(rc.Do("LRANGE", key, start, stop))
assert.NoError(t, err)

return assert.Equal(t, expected, actual, msgAndArgs...)
}

// LGetAll asserts the result of calling LRANGE <?> 0 -1 on the given key
func LGetAll(t *testing.T, rp *redis.Pool, key string, expected []string, msgAndArgs ...any) bool {
actual, err := redis.Strings(do(rp, "LRANGE", key, 0, -1))
func LGetAll(t *testing.T, rc redis.Conn, key string, expected []string, msgAndArgs ...any) bool {
actual, err := redis.Strings(rc.Do("LRANGE", key, 0, -1))
assert.NoError(t, err)

return assert.Equal(t, expected, actual, msgAndArgs...)
}

// ZCard asserts the result of calling ZCARD on the given key
func ZCard(t *testing.T, rp *redis.Pool, key string, expected int, msgAndArgs ...any) bool {
actual, err := redis.Int(do(rp, "ZCARD", key))
func ZCard(t *testing.T, rc redis.Conn, key string, expected int, msgAndArgs ...any) bool {
actual, err := redis.Int(rc.Do("ZCARD", key))
assert.NoError(t, err)

return assert.Equal(t, expected, actual, msgAndArgs...)
}

// ZRange asserts the result of calling ZRANGE on the given key
func ZRange(t *testing.T, rp *redis.Pool, key string, start, stop int, expected []string, msgAndArgs ...any) bool {
actual, err := redis.Strings(do(rp, "ZRANGE", key, start, stop))
func ZRange(t *testing.T, rc redis.Conn, key string, start, stop int, expected []string, msgAndArgs ...any) bool {
actual, err := redis.Strings(rc.Do("ZRANGE", key, start, stop))
assert.NoError(t, err)

return assert.Equal(t, expected, actual, msgAndArgs...)
}

// ZGetAll asserts the result of calling ZRANGE <?> 0 -1 WITHSCORES on the given key
func ZGetAll(t *testing.T, rp *redis.Pool, key string, expected map[string]float64, msgAndArgs ...any) bool {
actualStrings, err := redis.StringMap(do(rp, "ZRANGE", key, 0, -1, "WITHSCORES"))
func ZGetAll(t *testing.T, rc redis.Conn, key string, expected map[string]float64, msgAndArgs ...any) bool {
actualStrings, err := redis.StringMap(rc.Do("ZRANGE", key, 0, -1, "WITHSCORES"))
assert.NoError(t, err)

actual := make(map[string]float64, len(actualStrings))
Expand All @@ -168,16 +168,9 @@ func ZGetAll(t *testing.T, rp *redis.Pool, key string, expected map[string]float
}

// ZRange asserts the result of calling ZSCORE on the given key
func ZScore(t *testing.T, rp *redis.Pool, key, member string, expected float64, msgAndArgs ...any) bool {
actual, err := redis.Float64(do(rp, "ZSCORE", key, member))
func ZScore(t *testing.T, rc redis.Conn, key, member string, expected float64, msgAndArgs ...any) bool {
actual, err := redis.Float64(rc.Do("ZSCORE", key, member))
assert.NoError(t, err)

return assert.Equal(t, expected, actual, msgAndArgs...)
}

func do(rp *redis.Pool, commandName string, args ...any) (reply any, err error) {
rc := rp.Get()
defer rc.Close()

return rc.Do(commandName, args...)
}
38 changes: 19 additions & 19 deletions assertredis/asserts_test.go
View file
Original file line number Diff line number Diff line change
Expand Up @@ -16,43 +16,43 @@ func TestAsserts(t *testing.T) {

rc.Do("SET", "mykey", "one")

assert.True(t, assertredis.Exists(t, rp, "mykey"))
assert.True(t, assertredis.NotExists(t, rp, "mykey2"))
assert.True(t, assertredis.Get(t, rp, "mykey", "one"))
assert.True(t, assertredis.Exists(t, rc, "mykey"))
assert.True(t, assertredis.NotExists(t, rc, "mykey2"))
assert.True(t, assertredis.Get(t, rc, "mykey", "one"))

rc.Do("RPUSH", "mylist", "one")
rc.Do("RPUSH", "mylist", "two")
rc.Do("RPUSH", "mylist", "three")

assert.True(t, assertredis.LLen(t, rp, "mylist", 3))
assert.True(t, assertredis.LRange(t, rp, "mylist", 0, 1, []string{"one", "two"}))
assert.True(t, assertredis.LGetAll(t, rp, "mylist", []string{"one", "two", "three"}))
assert.True(t, assertredis.LLen(t, rc, "mylist", 3))
assert.True(t, assertredis.LRange(t, rc, "mylist", 0, 1, []string{"one", "two"}))
assert.True(t, assertredis.LGetAll(t, rc, "mylist", []string{"one", "two", "three"}))

rc.Do("SADD", "myset", "one")
rc.Do("SADD", "myset", "two")
rc.Do("SADD", "myset", "three")

assert.True(t, assertredis.SCard(t, rp, "myset", 3))
assert.True(t, assertredis.SIsMember(t, rp, "myset", "two"))
assert.True(t, assertredis.SIsNotMember(t, rp, "myset", "four"))
assert.True(t, assertredis.SMembers(t, rp, "myset", []string{"two", "one", "three"}))
assert.True(t, assertredis.SCard(t, rc, "myset", 3))
assert.True(t, assertredis.SIsMember(t, rc, "myset", "two"))
assert.True(t, assertredis.SIsNotMember(t, rc, "myset", "four"))
assert.True(t, assertredis.SMembers(t, rc, "myset", []string{"two", "one", "three"}))

rc.Do("HSET", "myhash", "a", "one")
rc.Do("HSET", "myhash", "b", "two")
rc.Do("HSET", "myhash", "c", "three")

assert.True(t, assertredis.HLen(t, rp, "myhash", 3))
assert.True(t, assertredis.HGet(t, rp, "myhash", "b", "two"))
assert.True(t, assertredis.HGetAll(t, rp, "myhash", map[string]string{"a": "one", "b": "two", "c": "three"}))
assert.True(t, assertredis.HLen(t, rc, "myhash", 3))
assert.True(t, assertredis.HGet(t, rc, "myhash", "b", "two"))
assert.True(t, assertredis.HGetAll(t, rc, "myhash", map[string]string{"a": "one", "b": "two", "c": "three"}))

rc.Do("ZADD", "myzset", 1, "one")
rc.Do("ZADD", "myzset", 2, "two")
rc.Do("ZADD", "myzset", 3, "three")

assert.True(t, assertredis.ZCard(t, rp, "myzset", 3))
assert.True(t, assertredis.ZScore(t, rp, "myzset", "one", 1))
assert.True(t, assertredis.ZScore(t, rp, "myzset", "two", 2))
assert.True(t, assertredis.ZScore(t, rp, "myzset", "three", 3))
assert.True(t, assertredis.ZRange(t, rp, "myzset", 0, 1, []string{"one", "two"}))
assert.True(t, assertredis.ZGetAll(t, rp, "myzset", map[string]float64{"one": 1, "two": 2, "three": 3}))
assert.True(t, assertredis.ZCard(t, rc, "myzset", 3))
assert.True(t, assertredis.ZScore(t, rc, "myzset", "one", 1))
assert.True(t, assertredis.ZScore(t, rc, "myzset", "two", 2))
assert.True(t, assertredis.ZScore(t, rc, "myzset", "three", 3))
assert.True(t, assertredis.ZRange(t, rc, "myzset", 0, 1, []string{"one", "two"}))
assert.True(t, assertredis.ZGetAll(t, rc, "myzset", map[string]float64{"one": 1, "two": 2, "three": 3}))
}
2 changes: 1 addition & 1 deletion capped_zset_test.go
View file
Original file line number Diff line number Diff line change
Expand Up @@ -28,7 +28,7 @@ func TestCappedZSet(t *testing.T) {
assert.NoError(t, zset.Add(rc, "C", 3))
assert.NoError(t, zset.Add(rc, "B", 2))

assertredis.ZRange(t, rp, "foo", 0, -1, []string{"A", "B", "C"})
assertredis.ZGetAll(t, rc, "foo", map[string]float64{"A": 1, "B": 2, "C": 3})

card, err := zset.Card(rc)
assert.NoError(t, err)
Expand Down
38 changes: 19 additions & 19 deletions interval_hash_test.go
View file
Original file line number Diff line number Diff line change
Expand Up @@ -41,8 +41,8 @@ func TestIntervalHash(t *testing.T) {
assert.NoError(t, hash1.Set(rc, "B", "2"))
assert.NoError(t, hash1.Set(rc, "C", "3"))

assertredis.HGetAll(t, rp, "foos:2021-11-18", map[string]string{"A": "1", "B": "2", "C": "3"})
assertredis.HGetAll(t, rp, "foos:2021-11-17", map[string]string{})
assertredis.HGetAll(t, rc, "foos:2021-11-18", map[string]string{"A": "1", "B": "2", "C": "3"})
assertredis.HGetAll(t, rc, "foos:2021-11-17", map[string]string{})

assertGet(hash1, "A", "1")
assertGet(hash1, "B", "2")
Expand All @@ -60,9 +60,9 @@ func TestIntervalHash(t *testing.T) {
hash1.Set(rc, "A", "5")
hash1.Set(rc, "B", "6")

assertredis.HGetAll(t, rp, "foos:2021-11-19", map[string]string{"A": "5", "B": "6"})
assertredis.HGetAll(t, rp, "foos:2021-11-18", map[string]string{"A": "1", "B": "2", "C": "3"})
assertredis.HGetAll(t, rp, "foos:2021-11-17", map[string]string{})
assertredis.HGetAll(t, rc, "foos:2021-11-19", map[string]string{"A": "5", "B": "6"})
assertredis.HGetAll(t, rc, "foos:2021-11-18", map[string]string{"A": "1", "B": "2", "C": "3"})
assertredis.HGetAll(t, rc, "foos:2021-11-17", map[string]string{})

assertGet(hash1, "A", "5")
assertGet(hash1, "B", "6")
Expand All @@ -77,10 +77,10 @@ func TestIntervalHash(t *testing.T) {
hash1.Set(rc, "A", "7")
hash1.Set(rc, "Z", "9")

assertredis.HGetAll(t, rp, "foos:2021-11-20", map[string]string{"A": "7", "Z": "9"})
assertredis.HGetAll(t, rp, "foos:2021-11-19", map[string]string{"A": "5", "B": "6"})
assertredis.HGetAll(t, rp, "foos:2021-11-18", map[string]string{"A": "1", "B": "2", "C": "3"})
assertredis.HGetAll(t, rp, "foos:2021-11-17", map[string]string{})
assertredis.HGetAll(t, rc, "foos:2021-11-20", map[string]string{"A": "7", "Z": "9"})
assertredis.HGetAll(t, rc, "foos:2021-11-19", map[string]string{"A": "5", "B": "6"})
assertredis.HGetAll(t, rc, "foos:2021-11-18", map[string]string{"A": "1", "B": "2", "C": "3"})
assertredis.HGetAll(t, rc, "foos:2021-11-17", map[string]string{})

assertGet(hash1, "A", "7")
assertGet(hash1, "Z", "9")
Expand All @@ -94,10 +94,10 @@ func TestIntervalHash(t *testing.T) {
err = hash1.Del(rc, "B") // from yesterday
require.NoError(t, err)

assertredis.HGetAll(t, rp, "foos:2021-11-20", map[string]string{"Z": "9"})
assertredis.HGetAll(t, rp, "foos:2021-11-19", map[string]string{})
assertredis.HGetAll(t, rp, "foos:2021-11-18", map[string]string{"A": "1", "B": "2", "C": "3"})
assertredis.HGetAll(t, rp, "foos:2021-11-17", map[string]string{})
assertredis.HGetAll(t, rc, "foos:2021-11-20", map[string]string{"Z": "9"})
assertredis.HGetAll(t, rc, "foos:2021-11-19", map[string]string{})
assertredis.HGetAll(t, rc, "foos:2021-11-18", map[string]string{"A": "1", "B": "2", "C": "3"})
assertredis.HGetAll(t, rc, "foos:2021-11-17", map[string]string{})

assertGet(hash1, "A", "")
assertGet(hash1, "Z", "9")
Expand All @@ -108,8 +108,8 @@ func TestIntervalHash(t *testing.T) {
err = hash1.Clear(rc)
require.NoError(t, err)

assertredis.HGetAll(t, rp, "foos:2021-11-20", map[string]string{})
assertredis.HGetAll(t, rp, "foos:2021-11-19", map[string]string{})
assertredis.HGetAll(t, rc, "foos:2021-11-20", map[string]string{})
assertredis.HGetAll(t, rc, "foos:2021-11-19", map[string]string{})

assertGet(hash1, "A", "")
assertGet(hash1, "Z", "")
Expand All @@ -122,8 +122,8 @@ func TestIntervalHash(t *testing.T) {
hash2.Set(rc, "A", "1")
hash2.Set(rc, "B", "2")

assertredis.HGetAll(t, rp, "foos:2021-11-20T12:05", map[string]string{"A": "1", "B": "2"})
assertredis.HGetAll(t, rp, "foos:2021-11-20T12:00", map[string]string{})
assertredis.HGetAll(t, rc, "foos:2021-11-20T12:05", map[string]string{"A": "1", "B": "2"})
assertredis.HGetAll(t, rc, "foos:2021-11-20T12:00", map[string]string{})

assertGet(hash2, "A", "1")
assertGet(hash2, "B", "2")
Expand All @@ -134,8 +134,8 @@ func TestIntervalHash(t *testing.T) {
hash3.Set(rc, "A", "1")
hash3.Set(rc, "B", "2")

assertredis.HGetAll(t, rp, "foos:2021-11-20T12:07:00", map[string]string{"A": "1", "B": "2"})
assertredis.HGetAll(t, rp, "foos:2021-11-20T12:06:55", map[string]string{})
assertredis.HGetAll(t, rc, "foos:2021-11-20T12:07:00", map[string]string{"A": "1", "B": "2"})
assertredis.HGetAll(t, rc, "foos:2021-11-20T12:06:55", map[string]string{})

assertGet(hash3, "A", "1")
assertGet(hash3, "B", "2")
Expand Down
Loading

0 comments on commit 9a13acf

Please sign in to comment.