Improve asserts

assertredis/asserts.go

@@ -1,129 +1,177 @@
 package assertredis
 
 import (
+	"strconv"
 	"testing"
 
 	"github.com/gomodule/redigo/redis"
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 // 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))
-
 	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.Int(do(rp, "EXISTS", key))
-
+	exists, err := redis.Bool(do(rp, "EXISTS", key))
 	assert.NoError(t, err)
-	return assert.Equal(t, 1, exists, msgAndArgs...)
+
+	if !exists {
+		assert.Fail(t, "Key should exist", msgAndArgs...)
+	}
+
+	return exists
 }
 
 // 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.Int(do(rp, "EXISTS", key))
-
+	exists, err := redis.Bool(do(rp, "EXISTS", key))
 	assert.NoError(t, err)
-	return assert.Equal(t, 0, exists, msgAndArgs...)
+
+	if exists {
+		assert.Fail(t, "Key should not exist", msgAndArgs...)
+	}
+
+	return !exists
 }
 
 // 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))
-
 	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))
-
 	assert.NoError(t, err)
+
 	return assert.Equal(t, expected, actual, msgAndArgs...)
 }
 
-// SIsMember asserts the result of calling SISMEMBER on the given key
-func SIsMember(t *testing.T, rp *redis.Pool, key, member string, expected bool, msgAndArgs ...any) bool {
-	actual, err := redis.Bool(do(rp, "SISMEMBER", key, member))
+// 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))
+	assert.NoError(t, err)
+
+	if !exists {
+		assert.Fail(t, "Key should be member", msgAndArgs...)
+	}
 
+	return exists
+}
+
+// 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))
 	assert.NoError(t, err)
-	return assert.Equal(t, expected, actual, msgAndArgs...)
+
+	if exists {
+		assert.Fail(t, "Key should not be member", msgAndArgs...)
+	}
+
+	return !exists
 }
 
 // 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))
-
 	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))
-
 	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))
-
 	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))
-
 	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))
-
 	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))
+	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))
 	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))
-
 	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, min, max float64, expected []string, msgAndArgs ...any) bool {
-	actual, err := redis.Strings(do(rp, "ZRANGE", key, min, max))
+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))
+	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"))
 	assert.NoError(t, err)
+
+	actual := make(map[string]float64, len(actualStrings))
+	for k, v := range actualStrings {
+		actual[k], err = strconv.ParseFloat(v, 64)
+		require.NoError(t, err)
+	}
+
 	return assert.Equal(t, expected, actual, msgAndArgs...)
 }
 
-// ZRange asserts the result of calling ZScore on the given key
+// 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))
-
 	assert.NoError(t, err)
+
 	return assert.Equal(t, expected, actual, msgAndArgs...)
 }
 

assertredis/asserts_test.go

@@ -0,0 +1,58 @@
+package assertredis_test
+
+import (
+	"testing"
+
+	"github.com/nyaruka/redisx/assertredis"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestAsserts(t *testing.T) {
+	rp := assertredis.TestDB()
+	rc := rp.Get()
+	defer rc.Close()
+
+	defer assertredis.FlushDB()
+
+	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"))
+
+	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"}))
+
+	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"}))
+
+	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"}))
+
+	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}))
+}