cases

package

v1.1.0-rc3 Latest Latest Go to latest Published: Jan 9, 2022 License: Apache-2.0 Imports: 6 Imported by: 0

Details

Valid go.mod file
Redistributable license
Tagged version
Stable version
Learn more about best practices

Repository

github.com/go-spring/spring-core

Links

Open Source Insights

Documentation ¶

Constants ¶

This section is empty.

Variables ¶

View Source

var Append = Case{
	Func: func(t *testing.T, ctx context.Context, c redis.Client) {

		r1, err := c.Exists(ctx, "mykey")
		if err != nil {
			t.Fatal()
		}
		assert.Equal(t, r1, int64(0))

		r2, err := c.Append(ctx, "mykey", "Hello")
		if err != nil {
			t.Fatal()
		}
		assert.Equal(t, r2, int64(5))

		r3, err := c.Append(ctx, "mykey", " World")
		if err != nil {
			t.Fatal()
		}
		assert.Equal(t, r3, int64(11))

		r4, err := c.Get(ctx, "mykey")
		if err != nil {
			t.Fatal()
		}
		assert.Equal(t, r4, "Hello World")
	},
	Data: `
	{
		"session": "df3b64266ebe4e63a464e135000a07cd",
		"inbound": {},
		"actions": [{
			"protocol": "redis",
			"request": "EXISTS mykey",
			"response": 0
		}, {
			"protocol": "redis",
			"request": "APPEND mykey Hello",
			"response": 5
		}, {
			"protocol": "redis",
			"request": "APPEND mykey @\" World\"@",
			"response": 11
		}, {
			"protocol": "redis",
			"request": "GET mykey",
			"response": "Hello World"
		}]
	}`,
}

View Source

var BitCount = Case{
	Func: func(t *testing.T, ctx context.Context, c redis.Client) {

		r1, err := c.Set(ctx, "mykey", "foobar")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, redis.OK)

		r2, err := c.BitCount(ctx, "mykey")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r2, int64(26))

		r3, err := c.BitCount(ctx, "mykey", 0, 0)
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r3, int64(4))

		r4, err := c.BitCount(ctx, "mykey", 1, 1)
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r4, int64(6))
	},
	Data: `
	{
		"session": "df3b64266ebe4e63a464e135000a07cd",
		"inbound": {},
		"actions": [{
			"protocol": "redis",
			"request": "SET mykey foobar",
			"response": "OK"
		}, {
			"protocol": "redis",
			"request": "BITCOUNT mykey",
			"response": 26
		}, {
			"protocol": "redis",
			"request": "BITCOUNT mykey 0 0",
			"response": 4
		}, {
			"protocol": "redis",
			"request": "BITCOUNT mykey 1 1",
			"response": 6
		}]
	}`,
}

View Source

var BitOpAnd = Case{
	Func: func(t *testing.T, ctx context.Context, c redis.Client) {

		r1, err := c.Set(ctx, "key1", "foobar")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, redis.OK)

		r2, err := c.Set(ctx, "key2", "abcdef")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r2, redis.OK)

		r3, err := c.BitOpAnd(ctx, "dest", "key1", "key2")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r3, int64(6))

		r4, err := c.Get(ctx, "dest")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r4, "`bc`ab")
	},
	Data: `
	{
		"session": "df3b64266ebe4e63a464e135000a07cd",
		"inbound": {},
		"actions": [{
			"protocol": "redis",
			"request": "SET key1 foobar",
			"response": "OK"
		}, {
			"protocol": "redis",
			"request": "SET key2 abcdef",
			"response": "OK"
		}, {
			"protocol": "redis",
			"request": "BITOP AND dest key1 key2",
			"response": 6
		}, {
			"protocol": "redis",
			"request": "GET dest",
			"response": "` + "`bc`ab\"" + `
		}]
	}`,
}

View Source

var BitPos = Case{
	Func: func(t *testing.T, ctx context.Context, c redis.Client) {

		r1, err := c.Set(ctx, "mykey", "\xff\xf0\x00")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, redis.OK)

		r2, err := c.BitPos(ctx, "mykey", 0)
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r2, int64(12))

		r3, err := c.Set(ctx, "mykey", "\x00\xff\xf0")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r3, redis.OK)

		r4, err := c.BitPos(ctx, "mykey", 1, 0)
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r4, int64(8))

		r5, err := c.BitPos(ctx, "mykey", 1, 2)
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r5, int64(16))

		r6, err := c.Set(ctx, "mykey", "\x00\x00\x00")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r6, redis.OK)

		r7, err := c.BitPos(ctx, "mykey", 1)
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r7, int64(-1))
	},
	Data: `
	{
		"session": "df3b64266ebe4e63a464e135000a07cd",
		"inbound": {},
		"actions": [{
			"protocol": "redis",
			"request": "SET mykey @\"\\xff\\xf0\\x00\"@",
			"response": "OK"
		}, {
			"protocol": "redis",
			"request": "BITPOS mykey 0",
			"response": 12
		}, {
			"protocol": "redis",
			"request": "SET mykey @\"\\x00\\xff\\xf0\"@",
			"response": "OK"
		}, {
			"protocol": "redis",
			"request": "BITPOS mykey 1 0",
			"response": 8
		}, {
			"protocol": "redis",
			"request": "BITPOS mykey 1 2",
			"response": 16
		}, {
			"protocol": "redis",
			"request": "SET mykey \u0000\u0000\u0000",
			"response": "OK"
		}, {
			"protocol": "redis",
			"request": "BITPOS mykey 1",
			"response": -1
		}]
	}`,
}

View Source

var Decr = Case{
	Func: func(t *testing.T, ctx context.Context, c redis.Client) {

		r1, err := c.Set(ctx, "mykey", "10")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, redis.OK)

		r2, err := c.Decr(ctx, "mykey")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r2, int64(9))

		r3, err := c.Set(ctx, "mykey", "234293482390480948029348230948")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r3, redis.OK)

		_, err = c.Decr(ctx, "mykey")
		assert.Error(t, err, "ERR value is not an integer or out of range")
	},
	Data: `
	{
		"session": "df3b64266ebe4e63a464e135000a07cd",
		"inbound": {},
		"actions": [{
			"protocol": "redis",
			"request": "SET mykey 10",
			"response": "OK"
		}, {
			"protocol": "redis",
			"request": "DECR mykey",
			"response": 9
		}, {
			"protocol": "redis",
			"request": "SET mykey 234293482390480948029348230948",
			"response": "OK"
		}, {
			"protocol": "redis",
			"request": "DECR mykey",
			"response": "(err) ERR value is not an integer or out of range"
		}]
	}`,
}

View Source

var DecrBy = Case{
	Func: func(t *testing.T, ctx context.Context, c redis.Client) {

		r1, err := c.Set(ctx, "mykey", "10")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, redis.OK)

		r2, err := c.DecrBy(ctx, "mykey", 3)
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r2, int64(7))
	},
	Data: `
	{
		"session": "df3b64266ebe4e63a464e135000a07cd",
		"inbound": {},
		"actions": [{
			"protocol": "redis",
			"request": "SET mykey 10",
			"response": "OK"
		}, {
			"protocol": "redis",
			"request": "DECRBY mykey 3",
			"response": 7
		}]
	}`,
}

View Source

var Del = Case{
	Func: func(t *testing.T, ctx context.Context, c redis.Client) {

		r1, err := c.Set(ctx, "key1", "Hello")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, redis.OK)

		r2, err := c.Set(ctx, "key2", "World")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r2, redis.OK)

		r3, err := c.Del(ctx, "key1", "key2", "key3")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r3, int64(2))
	},
	Data: `
	{
		"session": "df3b64266ebe4e63a464e135000a07cd",
		"inbound": {},
		"actions": [{
			"protocol": "redis",
			"request": "SET key1 Hello",
			"response": "OK"
		}, {
			"protocol": "redis",
			"request": "SET key2 World",
			"response": "OK"
		}, {
			"protocol": "redis",
			"request": "DEL key1 key2 key3",
			"response": 2
		}]
	}`,
}

View Source

var Dump = Case{
	Func: func(t *testing.T, ctx context.Context, c redis.Client) {

		r1, err := c.Set(ctx, "mykey", 10)
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, redis.OK)

		r2, err := c.Dump(ctx, "mykey")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r2, "\u0000\xC0\n\t\u0000\xBEm\u0006\x89Z(\u0000\n")
	},
	Data: `
	{
		"session": "df3b64266ebe4e63a464e135000a07cd",
		"inbound": {},
		"actions": [{
			"protocol": "redis",
			"request": "SET mykey 10",
			"response": "OK"
		}, {
			"protocol": "redis",
			"request": "DUMP mykey",
			"response": "@\"\\x00\\xc0\\n\\t\\x00\\xbem\\x06\\x89Z(\\x00\\n\"@"
		}]
	}`,
}

View Source

var Exists = Case{
	Func: func(t *testing.T, ctx context.Context, c redis.Client) {

		r1, err := c.Set(ctx, "key1", "Hello")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, redis.OK)

		r2, err := c.Exists(ctx, "key1")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r2, int64(1))

		r3, err := c.Exists(ctx, "nosuchkey")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r3, int64(0))

		r4, err := c.Set(ctx, "key2", "World")
		if err != nil {
			t.Fatal(err)
		}

		assert.Equal(t, r4, redis.OK)

		r5, err := c.Exists(ctx, "key1", "key2", "nosuchkey")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r5, int64(2))
	},
	Data: `
	{
		"session": "df3b64266ebe4e63a464e135000a07cd",
		"inbound": {},
		"actions": [{
			"protocol": "redis",
			"request": "SET key1 Hello",
			"response": "OK"
		}, {
			"protocol": "redis",
			"request": "EXISTS key1",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "EXISTS nosuchkey",
			"response": 0
		}, {
			"protocol": "redis",
			"request": "SET key2 World",
			"response": "OK"
		}, {
			"protocol": "redis",
			"request": "EXISTS key1 key2 nosuchkey",
			"response": 2
		}]
	}`,
}

View Source

var Expire = Case{
	Func: func(t *testing.T, ctx context.Context, c redis.Client) {

		r1, err := c.Set(ctx, "mykey", "Hello")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, redis.OK)

		r2, err := c.Expire(ctx, "mykey", 10)
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r2, 1)

		r3, err := c.TTL(ctx, "mykey")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r3, int64(10))

		r4, err := c.Set(ctx, "mykey", "Hello World")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r4, redis.OK)

		r5, err := c.TTL(ctx, "mykey")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r5, int64(-1))
	},
	Data: `
	{
		"session": "df3b64266ebe4e63a464e135000a07cd",
		"inbound": {},
		"actions": [{
			"protocol": "redis",
			"request": "SET mykey Hello",
			"response": "OK"
		}, {
			"protocol": "redis",
			"request": "EXPIRE mykey 10",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "TTL mykey",
			"response": 10
		}, {
			"protocol": "redis",
			"request": "SET mykey @\"Hello World\"@",
			"response": "OK"
		}, {
			"protocol": "redis",
			"request": "TTL mykey",
			"response": -1
		}]
	}`,
}

View Source

var ExpireAt = Case{
	Func: func(t *testing.T, ctx context.Context, c redis.Client) {

		r1, err := c.Set(ctx, "mykey", "Hello")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, redis.OK)

		r2, err := c.Exists(ctx, "mykey")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r2, int64(1))

		r3, err := c.ExpireAt(ctx, "mykey", 1293840000)
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r3, 1)

		r4, err := c.Exists(ctx, "mykey")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r4, int64(0))
	},
	Data: `
	{
		"session": "df3b64266ebe4e63a464e135000a07cd",
		"inbound": {},
		"actions": [{
			"protocol": "redis",
			"request": "SET mykey Hello",
			"response": "OK"
		}, {
			"protocol": "redis",
			"request": "EXISTS mykey",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "EXPIREAT mykey 1293840000",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "EXISTS mykey",
			"response": 0
		}]
	}`,
}

View Source

var Get = Case{
	Func: func(t *testing.T, ctx context.Context, c redis.Client) {

		_, err := c.Get(ctx, "nonexisting")
		assert.Equal(t, err, redis.ErrNil)

		r2, err := c.Set(ctx, "mykey", "Hello")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r2, redis.OK)

		r3, err := c.Get(ctx, "mykey")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r3, "Hello")
	},
	Data: `
	{
		"session": "df3b64266ebe4e63a464e135000a07cd",
		"inbound": {},
		"actions": [{
			"protocol": "redis",
			"request": "GET nonexisting",
			"response": "(nil)"
		}, {
			"protocol": "redis",
			"request": "SET mykey Hello",
			"response": "OK"
		}, {
			"protocol": "redis",
			"request": "GET mykey",
			"response": "Hello"
		}]
	}`,
}

View Source

var GetBit = Case{
	Func: func(t *testing.T, ctx context.Context, c redis.Client) {

		r1, err := c.SetBit(ctx, "mykey", 7, 1)
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, int64(0))

		r2, err := c.GetBit(ctx, "mykey", 0)
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r2, int64(0))

		r3, err := c.GetBit(ctx, "mykey", 7)
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r3, int64(1))

		r4, err := c.GetBit(ctx, "mykey", 100)
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r4, int64(0))
	},
	Data: `
	{
		"session": "df3b64266ebe4e63a464e135000a07cd",
		"inbound": {},
		"actions": [{
			"protocol": "redis",
			"request": "SETBIT mykey 7 1",
			"response": 0
		}, {
			"protocol": "redis",
			"request": "GETBIT mykey 0",
			"response": 0
		}, {
			"protocol": "redis",
			"request": "GETBIT mykey 7",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "GETBIT mykey 100",
			"response": 0
		}]
	}`,
}

View Source

var GetDel = Case{
	Func: func(t *testing.T, ctx context.Context, c redis.Client) {

		r1, err := c.Set(ctx, "mykey", "Hello")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, redis.OK)

		r2, err := c.GetDel(ctx, "mykey")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r2, "Hello")

		_, err = c.Get(ctx, "mykey")
		assert.Equal(t, err, redis.ErrNil)
	},
	Data: `
	{
		"session": "df3b64266ebe4e63a464e135000a07cd",
		"inbound": {},
		"actions": [{
			"protocol": "redis",
			"request": "SET mykey Hello",
			"response": "OK"
		}, {
			"protocol": "redis",
			"request": "GETDEL mykey",
			"response": "Hello"
		}, {
			"protocol": "redis",
			"request": "GET mykey",
			"response": "(nil)"
		}]
	}`,
}

View Source

var GetRange = Case{
	Func: func(t *testing.T, ctx context.Context, c redis.Client) {

		r1, err := c.Set(ctx, "mykey", "This is a string")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, redis.OK)

		r2, err := c.GetRange(ctx, "mykey", 0, 3)
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r2, "This")

		r3, err := c.GetRange(ctx, "mykey", -3, -1)
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r3, "ing")

		r4, err := c.GetRange(ctx, "mykey", 0, -1)
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r4, "This is a string")

		r5, err := c.GetRange(ctx, "mykey", 10, 100)
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r5, "string")
	},
	Data: `
	{
		"session": "df3b64266ebe4e63a464e135000a07cd",
		"inbound": {},
		"actions": [{
			"protocol": "redis",
			"request": "SET mykey @\"This is a string\"@",
			"response": "OK"
		}, {
			"protocol": "redis",
			"request": "GETRANGE mykey 0 3",
			"response": "This"
		}, {
			"protocol": "redis",
			"request": "GETRANGE mykey -3 -1",
			"response": "ing"
		}, {
			"protocol": "redis",
			"request": "GETRANGE mykey 0 -1",
			"response": "This is a string"
		}, {
			"protocol": "redis",
			"request": "GETRANGE mykey 10 100",
			"response": "string"
		}]
	}`,
}

View Source

var GetSet = Case{
	Func: func(t *testing.T, ctx context.Context, c redis.Client) {

		r1, err := c.Incr(ctx, "mycounter")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, int64(1))

		r2, err := c.GetSet(ctx, "mycounter", "0")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r2, "1")

		r3, err := c.Get(ctx, "mycounter")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r3, "0")

		r4, err := c.Set(ctx, "mykey", "Hello")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r4, redis.OK)

		r5, err := c.GetSet(ctx, "mykey", "World")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r5, "Hello")

		r6, err := c.Get(ctx, "mykey")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r6, "World")
	},
	Data: `
	{
		"session": "df3b64266ebe4e63a464e135000a07cd",
		"inbound": {},
		"actions": [{
			"protocol": "redis",
			"request": "INCR mycounter",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "GETSET mycounter 0",
			"response": "1"
		}, {
			"protocol": "redis",
			"request": "GET mycounter",
			"response": "0"
		}, {
			"protocol": "redis",
			"request": "SET mykey Hello",
			"response": "OK"
		}, {
			"protocol": "redis",
			"request": "GETSET mykey World",
			"response": "Hello"
		}, {
			"protocol": "redis",
			"request": "GET mykey",
			"response": "World"
		}]
	}`,
}

View Source

var HDel = Case{
	Func: func(t *testing.T, ctx context.Context, c redis.Client) {

		r1, err := c.HSet(ctx, "myhash", "field1", "foo")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, int64(1))

		r2, err := c.HDel(ctx, "myhash", "field1")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r2, int64(1))

		r3, err := c.HDel(ctx, "myhash", "field2")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r3, int64(0))
	},
	Data: `
	{
		"session": "df3b64266ebe4e63a464e135000a07cd",
		"inbound": {},
		"actions": [{
			"protocol": "redis",
			"request": "HSET myhash field1 foo",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "HDEL myhash field1",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "HDEL myhash field2",
			"response": 0
		}]
	}`,
}

View Source

var HExists = Case{
	Func: func(t *testing.T, ctx context.Context, c redis.Client) {

		r1, err := c.HSet(ctx, "myhash", "field1", "foo")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, int64(1))

		r2, err := c.HExists(ctx, "myhash", "field1")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r2, 1)

		r3, err := c.HExists(ctx, "myhash", "field2")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r3, 0)
	},
	Data: `
	{
		"session": "df3b64266ebe4e63a464e135000a07cd",
		"inbound": {},
		"actions": [{
			"protocol": "redis",
			"request": "HSET myhash field1 foo",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "HEXISTS myhash field1",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "HEXISTS myhash field2",
			"response": 0
		}]
	}`,
}

View Source

var HGet = Case{
	Func: func(t *testing.T, ctx context.Context, c redis.Client) {

		r1, err := c.HSet(ctx, "myhash", "field1", "foo")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, int64(1))

		r2, err := c.HGet(ctx, "myhash", "field1")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r2, "foo")

		_, err = c.HGet(ctx, "myhash", "field2")
		assert.Equal(t, err, redis.ErrNil)
	},
	Data: `
	{
		"session": "df3b64266ebe4e63a464e135000a07cd",
		"inbound": {},
		"actions": [{
			"protocol": "redis",
			"request": "HSET myhash field1 foo",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "HGET myhash field1",
			"response": "foo"
		}, {
			"protocol": "redis",
			"request": "HGET myhash field2",
			"response": "(nil)"
		}]
	}`,
}

View Source

var HGetAll = Case{
	Func: func(t *testing.T, ctx context.Context, c redis.Client) {

		r1, err := c.HSet(ctx, "myhash", "field1", "Hello")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, int64(1))

		r2, err := c.HSet(ctx, "myhash", "field2", "World")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r2, int64(1))

		r3, err := c.HGetAll(ctx, "myhash")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r3, map[string]string{
			"field1": "Hello",
			"field2": "World",
		})
	},
	Data: `
	{
		"session": "df3b64266ebe4e63a464e135000a07cd",
		"inbound": {},
		"actions": [{
			"protocol": "redis",
			"request": "HSET myhash field1 Hello",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "HSET myhash field2 World",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "HGETALL myhash",
			"response": {
				"field1": "Hello",
				"field2": "World"
			}
		}]
	}`,
}

View Source

var HIncrBy = Case{
	Func: func(t *testing.T, ctx context.Context, c redis.Client) {

		r1, err := c.HSet(ctx, "myhash", "field", 5)
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, int64(1))

		r2, err := c.HIncrBy(ctx, "myhash", "field", 1)
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r2, int64(6))

		r3, err := c.HIncrBy(ctx, "myhash", "field", -1)
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r3, int64(5))

		r4, err := c.HIncrBy(ctx, "myhash", "field", -10)
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r4, int64(-5))
	},
	Data: `
	{
		"session": "df3b64266ebe4e63a464e135000a07cd",
		"inbound": {},
		"actions": [{
			"protocol": "redis",
			"request": "HSET myhash field 5",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "HINCRBY myhash field 1",
			"response": 6
		}, {
			"protocol": "redis",
			"request": "HINCRBY myhash field -1",
			"response": 5
		}, {
			"protocol": "redis",
			"request": "HINCRBY myhash field -10",
			"response": -5
		}]
	}`,
}

View Source

var HIncrByFloat = Case{
	Func: func(t *testing.T, ctx context.Context, c redis.Client) {

		r1, err := c.HSet(ctx, "mykey", "field", 10.50)
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, int64(1))

		r2, err := c.HIncrByFloat(ctx, "mykey", "field", 0.1)
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r2, 10.6)

		r3, err := c.HIncrByFloat(ctx, "mykey", "field", -5)
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r3, 5.6)

		r4, err := c.HSet(ctx, "mykey", "field", 5.0e3)
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r4, int64(0))

		r5, err := c.HIncrByFloat(ctx, "mykey", "field", 2.0e2)
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r5, float64(5200))
	},
	Data: `
	{
		"session": "df3b64266ebe4e63a464e135000a07cd",
		"inbound": {},
		"actions": [{
			"protocol": "redis",
			"request": "HSET mykey field 10.5",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "HINCRBYFLOAT mykey field 0.1",
			"response": "10.6"
		}, {
			"protocol": "redis",
			"request": "HINCRBYFLOAT mykey field -5",
			"response": "5.6"
		}, {
			"protocol": "redis",
			"request": "HSET mykey field 5000",
			"response": 0
		}, {
			"protocol": "redis",
			"request": "HINCRBYFLOAT mykey field 200",
			"response": "5200"
		}]
	}`,
}

View Source

var HKeys = Case{
	Func: func(t *testing.T, ctx context.Context, c redis.Client) {

		r1, err := c.HSet(ctx, "myhash", "field1", "Hello")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, int64(1))

		r2, err := c.HSet(ctx, "myhash", "field2", "World")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r2, int64(1))

		r3, err := c.HKeys(ctx, "myhash")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r3, []string{"field1", "field2"})
	},
	Data: `
	{
		"session": "df3b64266ebe4e63a464e135000a07cd",
		"inbound": {},
		"actions": [{
			"protocol": "redis",
			"request": "HSET myhash field1 Hello",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "HSET myhash field2 World",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "HKEYS myhash",
			"response": ["field1", "field2"]
		}]
	}`,
}

View Source

var HLen = Case{
	Func: func(t *testing.T, ctx context.Context, c redis.Client) {

		r1, err := c.HSet(ctx, "myhash", "field1", "Hello")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, int64(1))

		r2, err := c.HSet(ctx, "myhash", "field2", "World")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r2, int64(1))

		r3, err := c.HLen(ctx, "myhash")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r3, int64(2))
	},
	Data: `
	{
		"session": "df3b64266ebe4e63a464e135000a07cd",
		"inbound": {},
		"actions": [{
			"protocol": "redis",
			"request": "HSET myhash field1 Hello",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "HSET myhash field2 World",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "HLEN myhash",
			"response": 2
		}]
	}`,
}

View Source

var HMGet = Case{
	Func: func(t *testing.T, ctx context.Context, c redis.Client) {

		r1, err := c.HSet(ctx, "myhash", "field1", "Hello")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, int64(1))

		r2, err := c.HSet(ctx, "myhash", "field2", "World")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r2, int64(1))

		r3, err := c.HMGet(ctx, "myhash", "field1", "field2", "nofield")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r3, []interface{}{"Hello", "World", nil})
	},
	Data: `
	{
		"session": "df3b64266ebe4e63a464e135000a07cd",
		"inbound": {},
		"actions": [{
			"protocol": "redis",
			"request": "HSET myhash field1 Hello",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "HSET myhash field2 World",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "HMGET myhash field1 field2 nofield",
			"response": ["Hello", "World", null]
		}]
	}`,
}

View Source

var HSet = Case{
	Func: func(t *testing.T, ctx context.Context, c redis.Client) {

		r1, err := c.HSet(ctx, "myhash", "field1", "Hello")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, int64(1))

		r2, err := c.HGet(ctx, "myhash", "field1")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r2, "Hello")
	},
	Data: `
	{
		"session": "df3b64266ebe4e63a464e135000a07cd",
		"inbound": {},
		"actions": [{
			"protocol": "redis",
			"request": "HSET myhash field1 Hello",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "HGET myhash field1",
			"response": "Hello"
		}]
	}`,
}

View Source

var HSetNX = Case{
	Func: func(t *testing.T, ctx context.Context, c redis.Client) {

		r1, err := c.HSetNX(ctx, "myhash", "field", "Hello")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, 1)

		r2, err := c.HSetNX(ctx, "myhash", "field", "World")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r2, 0)

		r3, err := c.HGet(ctx, "myhash", "field")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r3, "Hello")
	},
	Data: `
	{
		"session": "df3b64266ebe4e63a464e135000a07cd",
		"inbound": {},
		"actions": [{
			"protocol": "redis",
			"request": "HSETNX myhash field Hello",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "HSETNX myhash field World",
			"response": 0
		}, {
			"protocol": "redis",
			"request": "HGET myhash field",
			"response": "Hello"
		}]
	}`,
}

View Source

var HStrLen = Case{
	Func: func(t *testing.T, ctx context.Context, c redis.Client) {

		r1, err := c.HSet(ctx, "myhash", "f1", "HelloWorld", "f2", 99, "f3", -256)
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, int64(3))

		r2, err := c.HStrLen(ctx, "myhash", "f1")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r2, int64(10))

		r3, err := c.HStrLen(ctx, "myhash", "f2")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r3, int64(2))

		r4, err := c.HStrLen(ctx, "myhash", "f3")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r4, int64(4))
	},
	Data: `
	{
		"session": "df3b64266ebe4e63a464e135000a07cd",
		"inbound": {},
		"actions": [{
			"protocol": "redis",
			"request": "HSET myhash f1 HelloWorld f2 99 f3 -256",
			"response": 3
		}, {
			"protocol": "redis",
			"request": "HSTRLEN myhash f1",
			"response": 10
		}, {
			"protocol": "redis",
			"request": "HSTRLEN myhash f2",
			"response": 2
		}, {
			"protocol": "redis",
			"request": "HSTRLEN myhash f3",
			"response": 4
		}]
	}`,
}

View Source

var HVals = Case{
	Func: func(t *testing.T, ctx context.Context, c redis.Client) {

		r1, err := c.HSet(ctx, "myhash", "field1", "Hello")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, int64(1))

		r2, err := c.HSet(ctx, "myhash", "field2", "World")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r2, int64(1))

		r3, err := c.HVals(ctx, "myhash")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r3, []string{"Hello", "World"})
	},
	Data: `
	{
		"session": "df3b64266ebe4e63a464e135000a07cd",
		"inbound": {},
		"actions": [{
			"protocol": "redis",
			"request": "HSET myhash field1 Hello",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "HSET myhash field2 World",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "HVALS myhash",
			"response": ["Hello", "World"]
		}]
	}`,
}

View Source

var Incr = Case{
	Func: func(t *testing.T, ctx context.Context, c redis.Client) {

		r1, err := c.Set(ctx, "mykey", "10")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, redis.OK)

		r2, err := c.Incr(ctx, "mykey")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r2, int64(11))

		r3, err := c.Get(ctx, "mykey")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r3, "11")
	},
	Data: `
	{
		"session": "df3b64266ebe4e63a464e135000a07cd",
		"inbound": {},
		"actions": [{
			"protocol": "redis",
			"request": "SET mykey 10",
			"response": "OK"
		}, {
			"protocol": "redis",
			"request": "INCR mykey",
			"response": 11
		}, {
			"protocol": "redis",
			"request": "GET mykey",
			"response": "11"
		}]
	}`,
}

View Source

var IncrBy = Case{
	Func: func(t *testing.T, ctx context.Context, c redis.Client) {

		r1, err := c.Set(ctx, "mykey", "10")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, redis.OK)

		r2, err := c.IncrBy(ctx, "mykey", 5)
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r2, int64(15))
	},
	Data: `
	{
		"session": "df3b64266ebe4e63a464e135000a07cd",
		"inbound": {},
		"actions": [{
			"protocol": "redis",
			"request": "SET mykey 10",
			"response": "OK"
		}, {
			"protocol": "redis",
			"request": "INCRBY mykey 5",
			"response": 15
		}]
	}`,
}

View Source

var IncrByFloat = Case{
	Func: func(t *testing.T, ctx context.Context, c redis.Client) {

		r1, err := c.Set(ctx, "mykey", 10.50)
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, redis.OK)

		r2, err := c.IncrByFloat(ctx, "mykey", 0.1)
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r2, 10.6)

		r3, err := c.IncrByFloat(ctx, "mykey", -5)
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r3, 5.6)

		r4, err := c.Set(ctx, "mykey", 5.0e3)
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r4, redis.OK)

		r5, err := c.IncrByFloat(ctx, "mykey", 2.0e2)
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r5, float64(5200))
	},
	Data: `
	{
		"session": "df3b64266ebe4e63a464e135000a07cd",
		"inbound": {},
		"actions": [{
			"protocol": "redis",
			"request": "SET mykey 10.5",
			"response": "OK"
		}, {
			"protocol": "redis",
			"request": "INCRBYFLOAT mykey 0.1",
			"response": "10.6"
		}, {
			"protocol": "redis",
			"request": "INCRBYFLOAT mykey -5",
			"response": "5.6"
		}, {
			"protocol": "redis",
			"request": "SET mykey 5000",
			"response": "OK"
		}, {
			"protocol": "redis",
			"request": "INCRBYFLOAT mykey 200",
			"response": "5200"
		}]
	}`,
}

View Source

var Keys = Case{
	Func: func(t *testing.T, ctx context.Context, c redis.Client) {

		r1, err := c.MSet(ctx, "firstname", "Jack", "lastname", "Stuntman", "age", 35)
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, redis.OK)

		r2, err := c.Keys(ctx, "*name*")
		if err != nil {
			t.Fatal(err)
		}
		sort.Strings(r2)
		assert.Equal(t, r2, []string{"firstname", "lastname"})

		r3, err := c.Keys(ctx, "a??")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r3, []string{"age"})

		r4, err := c.Keys(ctx, "*")
		if err != nil {
			t.Fatal(err)
		}
		sort.Strings(r4)
		assert.Equal(t, r4, []string{"age", "firstname", "lastname"})
	},
	Data: `
	{
		"session": "df3b64266ebe4e63a464e135000a07cd",
		"inbound": {},
		"actions": [{
			"protocol": "redis",
			"request": "MSET firstname Jack lastname Stuntman age 35",
			"response": "OK"
		}, {
			"protocol": "redis",
			"request": "KEYS *name*",
			"response": ["lastname", "firstname"]
		}, {
			"protocol": "redis",
			"request": "KEYS a??",
			"response": ["age"]
		}, {
			"protocol": "redis",
			"request": "KEYS *",
			"response": ["age", "lastname", "firstname"]
		}]
	}`,
}

View Source

var LIndex = Case{
	Func: func(t *testing.T, ctx context.Context, c redis.Client) {

		r1, err := c.LPush(ctx, "mylist", "World")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, int64(1))

		r2, err := c.LPush(ctx, "mylist", "Hello")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r2, int64(2))

		r3, err := c.LIndex(ctx, "mylist", 0)
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r3, "Hello")

		r4, err := c.LIndex(ctx, "mylist", -1)
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r4, "World")

		_, err = c.LIndex(ctx, "mylist", 3)
		assert.Equal(t, err, redis.ErrNil)
	},
	Data: `
	{
		"session": "df3b64266ebe4e63a464e135000a07cd",
		"inbound": {},
		"actions": [{
			"protocol": "redis",
			"request": "LPUSH mylist World",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "LPUSH mylist Hello",
			"response": 2
		}, {
			"protocol": "redis",
			"request": "LINDEX mylist 0",
			"response": "Hello"
		}, {
			"protocol": "redis",
			"request": "LINDEX mylist -1",
			"response": "World"
		}, {
			"protocol": "redis",
			"request": "LINDEX mylist 3",
			"response": "(nil)"
		}]
	}`,
}

View Source

var LInsert = Case{
	Func: func(t *testing.T, ctx context.Context, c redis.Client) {

		r1, err := c.RPush(ctx, "mylist", "Hello")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, int64(1))

		r2, err := c.RPush(ctx, "mylist", "World")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r2, int64(2))

		r3, err := c.LInsertBefore(ctx, "mylist", "World", "There")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r3, int64(3))

		r4, err := c.LRange(ctx, "mylist", 0, -1)
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r4, []string{"Hello", "There", "World"})
	},
	Data: `
	{
		"session": "df3b64266ebe4e63a464e135000a07cd",
		"inbound": {},
		"actions": [{
			"protocol": "redis",
			"request": "RPUSH mylist Hello",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "RPUSH mylist World",
			"response": 2
		}, {
			"protocol": "redis",
			"request": "LINSERT mylist BEFORE World There",
			"response": 3
		}, {
			"protocol": "redis",
			"request": "LRANGE mylist 0 -1",
			"response": ["Hello", "There", "World"]
		}]
	}`,
}

View Source

var LLen = Case{
	Func: func(t *testing.T, ctx context.Context, c redis.Client) {

		r1, err := c.LPush(ctx, "mylist", "World")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, int64(1))

		r2, err := c.LPush(ctx, "mylist", "Hello")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r2, int64(2))

		r3, err := c.LLen(ctx, "mylist")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r3, int64(2))
	},
	Data: `
	{
		"session": "df3b64266ebe4e63a464e135000a07cd",
		"inbound": {},
		"actions": [{
			"protocol": "redis",
			"request": "LPUSH mylist World",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "LPUSH mylist Hello",
			"response": 2
		}, {
			"protocol": "redis",
			"request": "LLEN mylist",
			"response": 2
		}]
	}`,
}

View Source

var LMove = Case{
	Func: func(t *testing.T, ctx context.Context, c redis.Client) {

		r1, err := c.RPush(ctx, "mylist", "one")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, int64(1))

		r2, err := c.RPush(ctx, "mylist", "two")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r2, int64(2))

		r3, err := c.RPush(ctx, "mylist", "three")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r3, int64(3))

		r4, err := c.LMove(ctx, "mylist", "myotherlist", "RIGHT", "LEFT")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r4, "three")

		r5, err := c.LMove(ctx, "mylist", "myotherlist", "LEFT", "RIGHT")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r5, "one")

		r6, err := c.LRange(ctx, "mylist", 0, -1)
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r6, []string{"two"})

		r7, err := c.LRange(ctx, "myotherlist", 0, -1)
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r7, []string{"three", "one"})
	},
	Data: `
	{
		"session": "df3b64266ebe4e63a464e135000a07cd",
		"inbound": {},
		"actions": [{
			"protocol": "redis",
			"request": "RPUSH mylist one",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "RPUSH mylist two",
			"response": 2
		}, {
			"protocol": "redis",
			"request": "RPUSH mylist three",
			"response": 3
		}, {
			"protocol": "redis",
			"request": "LMOVE mylist myotherlist RIGHT LEFT",
			"response": "three"
		}, {
			"protocol": "redis",
			"request": "LMOVE mylist myotherlist LEFT RIGHT",
			"response": "one"
		}, {
			"protocol": "redis",
			"request": "LRANGE mylist 0 -1",
			"response": ["two"]
		}, {
			"protocol": "redis",
			"request": "LRANGE myotherlist 0 -1",
			"response": ["three", "one"]
		}]
	}`,
}

View Source

var LPop = Case{
	Func: func(t *testing.T, ctx context.Context, c redis.Client) {

		r1, err := c.RPush(ctx, "mylist", "one", "two", "three", "four", "five")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, int64(5))

		r2, err := c.LPop(ctx, "mylist")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r2, "one")

		r3, err := c.LPopN(ctx, "mylist", 2)
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r3, []string{"two", "three"})

		r4, err := c.LRange(ctx, "mylist", 0, -1)
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r4, []string{"four", "five"})
	},
	Data: `
	{
		"session": "df3b64266ebe4e63a464e135000a07cd",
		"inbound": {},
		"actions": [{
			"protocol": "redis",
			"request": "RPUSH mylist one two three four five",
			"response": 5
		}, {
			"protocol": "redis",
			"request": "LPOP mylist",
			"response": "one"
		}, {
			"protocol": "redis",
			"request": "LPOP mylist 2",
			"response": ["two", "three"]
		}, {
			"protocol": "redis",
			"request": "LRANGE mylist 0 -1",
			"response": ["four", "five"]
		}]
	}`,
}

View Source

var LPos = Case{
	Func: func(t *testing.T, ctx context.Context, c redis.Client) {

		r1, err := c.RPush(ctx, "mylist", 'a', 'b', 'c', 'd', 1, 2, 3, 4, 3, 3, 3)
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, int64(11))

		r2, err := c.LPos(ctx, "mylist", 3)
		if err != nil {
			return
		}
		assert.Equal(t, r2, int64(6))

		r3, err := c.LPosN(ctx, "mylist", "3", 0, "RANK", 2)
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r3, []int64{8, 9, 10})
	},
	Data: `
	{
		"session": "df3b64266ebe4e63a464e135000a07cd",
		"inbound": {},
		"actions": [{
			"protocol": "redis",
			"request": "RPUSH mylist 97 98 99 100 1 2 3 4 3 3 3",
			"response": 11
		}, {
			"protocol": "redis",
			"request": "LPOS mylist 3",
			"response": 6
		}, {
			"protocol": "redis",
			"request": "LPOS mylist 3 COUNT 0 RANK 2",
			"response": [8, 9, 10]
		}]
	}`,
}

View Source

var LPush = Case{
	Func: func(t *testing.T, ctx context.Context, c redis.Client) {

		r1, err := c.LPush(ctx, "mylist", "world")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, int64(1))

		r2, err := c.LPush(ctx, "mylist", "hello")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r2, int64(2))

		r3, err := c.LRange(ctx, "mylist", 0, -1)
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r3, []string{"hello", "world"})
	},
	Data: `
	{
		"session": "df3b64266ebe4e63a464e135000a07cd",
		"inbound": {},
		"actions": [{
			"protocol": "redis",
			"request": "LPUSH mylist world",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "LPUSH mylist hello",
			"response": 2
		}, {
			"protocol": "redis",
			"request": "LRANGE mylist 0 -1",
			"response": ["hello", "world"]
		}]
	}`,
}

View Source

var LPushX = Case{
	Func: func(t *testing.T, ctx context.Context, c redis.Client) {

		r1, err := c.LPush(ctx, "mylist", "World")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, int64(1))

		r2, err := c.LPushX(ctx, "mylist", "Hello")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r2, int64(2))

		r3, err := c.LPushX(ctx, "myotherlist", "Hello")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r3, int64(0))

		r4, err := c.LRange(ctx, "mylist", 0, -1)
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r4, []string{"Hello", "World"})

		r5, err := c.LRange(ctx, "myotherlist", 0, -1)
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r5, []string{})
	},
	Data: `
	{
		"session": "df3b64266ebe4e63a464e135000a07cd",
		"inbound": {},
		"actions": [{
			"protocol": "redis",
			"request": "LPUSH mylist World",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "LPUSHX mylist Hello",
			"response": 2
		}, {
			"protocol": "redis",
			"request": "LPUSHX myotherlist Hello",
			"response": 0
		}, {
			"protocol": "redis",
			"request": "LRANGE mylist 0 -1",
			"response": ["Hello", "World"]
		}, {
			"protocol": "redis",
			"request": "LRANGE myotherlist 0 -1",
			"response": []
		}]
	}`,
}

View Source

var LRange = Case{
	Func: func(t *testing.T, ctx context.Context, c redis.Client) {

		r1, err := c.RPush(ctx, "mylist", "one")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, int64(1))

		r2, err := c.RPush(ctx, "mylist", "two")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r2, int64(2))

		r3, err := c.RPush(ctx, "mylist", "three")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r3, int64(3))

		r4, err := c.LRange(ctx, "mylist", 0, 0)
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r4, []string{"one"})

		r5, err := c.LRange(ctx, "mylist", -3, 2)
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r5, []string{"one", "two", "three"})

		r6, err := c.LRange(ctx, "mylist", -100, 100)
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r6, []string{"one", "two", "three"})

		r7, err := c.LRange(ctx, "mylist", 5, 10)
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r7, []string{})
	},
	Data: `
	{
		"session": "df3b64266ebe4e63a464e135000a07cd",
		"inbound": {},
		"actions": [{
			"protocol": "redis",
			"request": "RPUSH mylist one",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "RPUSH mylist two",
			"response": 2
		}, {
			"protocol": "redis",
			"request": "RPUSH mylist three",
			"response": 3
		}, {
			"protocol": "redis",
			"request": "LRANGE mylist 0 0",
			"response": ["one"]
		}, {
			"protocol": "redis",
			"request": "LRANGE mylist -3 2",
			"response": ["one", "two", "three"]
		}, {
			"protocol": "redis",
			"request": "LRANGE mylist -100 100",
			"response": ["one", "two", "three"]
		}, {
			"protocol": "redis",
			"request": "LRANGE mylist 5 10",
			"response": []
		}]
	}`,
}

View Source

var LRem = Case{
	Func: func(t *testing.T, ctx context.Context, c redis.Client) {

		r1, err := c.RPush(ctx, "mylist", "hello")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, int64(1))

		r2, err := c.RPush(ctx, "mylist", "hello")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r2, int64(2))

		r3, err := c.RPush(ctx, "mylist", "foo")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r3, int64(3))

		r4, err := c.RPush(ctx, "mylist", "hello")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r4, int64(4))

		r5, err := c.LRem(ctx, "mylist", -2, "hello")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r5, int64(2))

		r6, err := c.LRange(ctx, "mylist", 0, -1)
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r6, []string{"hello", "foo"})
	},
	Data: `
	{
		"session": "df3b64266ebe4e63a464e135000a07cd",
		"inbound": {},
		"actions": [{
			"protocol": "redis",
			"request": "RPUSH mylist hello",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "RPUSH mylist hello",
			"response": 2
		}, {
			"protocol": "redis",
			"request": "RPUSH mylist foo",
			"response": 3
		}, {
			"protocol": "redis",
			"request": "RPUSH mylist hello",
			"response": 4
		}, {
			"protocol": "redis",
			"request": "LREM mylist -2 hello",
			"response": 2
		}, {
			"protocol": "redis",
			"request": "LRANGE mylist 0 -1",
			"response": ["hello", "foo"]
		}]
	}`,
}

View Source

var LSet = Case{
	Func: func(t *testing.T, ctx context.Context, c redis.Client) {

		r1, err := c.RPush(ctx, "mylist", "one")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, int64(1))

		r2, err := c.RPush(ctx, "mylist", "two")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r2, int64(2))

		r3, err := c.RPush(ctx, "mylist", "three")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r3, int64(3))

		r4, err := c.LSet(ctx, "mylist", 0, "four")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r4, redis.OK)

		r5, err := c.LSet(ctx, "mylist", -2, "five")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r5, redis.OK)

		r6, err := c.LRange(ctx, "mylist", 0, -1)
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r6, []string{"four", "five", "three"})
	},
	Data: `
	{
		"session": "df3b64266ebe4e63a464e135000a07cd",
		"inbound": {},
		"actions": [{
			"protocol": "redis",
			"request": "RPUSH mylist one",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "RPUSH mylist two",
			"response": 2
		}, {
			"protocol": "redis",
			"request": "RPUSH mylist three",
			"response": 3
		}, {
			"protocol": "redis",
			"request": "LSET mylist 0 four",
			"response": "OK"
		}, {
			"protocol": "redis",
			"request": "LSET mylist -2 five",
			"response": "OK"
		}, {
			"protocol": "redis",
			"request": "LRANGE mylist 0 -1",
			"response": ["four", "five", "three"]
		}]
	}`,
}

View Source

var LTrim = Case{
	Func: func(t *testing.T, ctx context.Context, c redis.Client) {

		r1, err := c.RPush(ctx, "mylist", "one")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, int64(1))

		r2, err := c.RPush(ctx, "mylist", "two")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r2, int64(2))

		r3, err := c.RPush(ctx, "mylist", "three")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r3, int64(3))

		r4, err := c.LTrim(ctx, "mylist", 1, -1)
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r4, redis.OK)

		r5, err := c.LRange(ctx, "mylist", 0, -1)
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r5, []string{"two", "three"})
	},
	Data: `
	{
		"session": "df3b64266ebe4e63a464e135000a07cd",
		"inbound": {},
		"actions": [{
			"protocol": "redis",
			"request": "RPUSH mylist one",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "RPUSH mylist two",
			"response": 2
		}, {
			"protocol": "redis",
			"request": "RPUSH mylist three",
			"response": 3
		}, {
			"protocol": "redis",
			"request": "LTRIM mylist 1 -1",
			"response": "OK"
		}, {
			"protocol": "redis",
			"request": "LRANGE mylist 0 -1",
			"response": ["two", "three"]
		}]
	}`,
}

View Source

var MGet = Case{
	Func: func(t *testing.T, ctx context.Context, c redis.Client) {

		r1, err := c.Set(ctx, "key1", "Hello")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, redis.OK)

		r2, err := c.Set(ctx, "key2", "World")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r2, redis.OK)

		r3, err := c.MGet(ctx, "key1", "key2", "nonexisting")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r3, []interface{}{"Hello", "World", nil})
	},
	Data: `
	{
		"session": "df3b64266ebe4e63a464e135000a07cd",
		"inbound": {},
		"actions": [{
			"protocol": "redis",
			"request": "SET key1 Hello",
			"response": "OK"
		}, {
			"protocol": "redis",
			"request": "SET key2 World",
			"response": "OK"
		}, {
			"protocol": "redis",
			"request": "MGET key1 key2 nonexisting",
			"response": ["Hello", "World", null]
		}]
	}`,
}

View Source

var MSet = Case{
	Func: func(t *testing.T, ctx context.Context, c redis.Client) {

		r1, err := c.MSet(ctx, "key1", "Hello", "key2", "World")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, redis.OK)

		r2, err := c.Get(ctx, "key1")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r2, "Hello")

		r3, err := c.Get(ctx, "key2")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r3, "World")
	},
	Data: `
	{
		"session": "df3b64266ebe4e63a464e135000a07cd",
		"inbound": {},
		"actions": [{
			"protocol": "redis",
			"request": "MSET key1 Hello key2 World",
			"response": "OK"
		}, {
			"protocol": "redis",
			"request": "GET key1",
			"response": "Hello"
		}, {
			"protocol": "redis",
			"request": "GET key2",
			"response": "World"
		}]
	}`,
}

View Source

var MSetNX = Case{
	Func: func(t *testing.T, ctx context.Context, c redis.Client) {

		r1, err := c.MSetNX(ctx, "key1", "Hello", "key2", "there")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, 1)

		r2, err := c.MSetNX(ctx, "key2", "new", "key3", "world")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r2, 0)

		r3, err := c.MGet(ctx, "key1", "key2", "key3")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r3, []interface{}{"Hello", "there", nil})
	},
	Data: `
	{
		"session": "df3b64266ebe4e63a464e135000a07cd",
		"inbound": {},
		"actions": [{
			"protocol": "redis",
			"request": "MSETNX key1 Hello key2 there",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "MSETNX key2 new key3 world",
			"response": 0
		}, {
			"protocol": "redis",
			"request": "MGET key1 key2 key3",
			"response": ["Hello", "there", null]
		}]
	}`,
}

View Source

var PExpire = Case{
	Func: func(t *testing.T, ctx context.Context, c redis.Client) {

		r1, err := c.Set(ctx, "mykey", "Hello")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, redis.OK)

		r2, err := c.PExpire(ctx, "mykey", 1500)
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r2, 1)

		r3, err := c.TTL(ctx, "mykey")
		if err != nil {
			t.Fatal(err)
		}
		assert.True(t, r3 >= 1 && r3 <= 2)

		r4, err := c.PTTL(ctx, "mykey")
		if err != nil {
			t.Fatal(err)
		}
		assert.True(t, r4 >= 1400 && r4 <= 1500)
	},
	Data: `
	{
		"session": "df3b64266ebe4e63a464e135000a07cd",
		"inbound": {},
		"actions": [{
			"protocol": "redis",
			"request": "SET mykey Hello",
			"response": "OK"
		}, {
			"protocol": "redis",
			"request": "PEXPIRE mykey 1500",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "TTL mykey",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "PTTL mykey",
			"response": 1499
		}]
	}`,
}

View Source

var PExpireAt = Case{
	Func: func(t *testing.T, ctx context.Context, c redis.Client) {

		r1, err := c.Set(ctx, "mykey", "Hello")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, redis.OK)

		r2, err := c.PExpireAt(ctx, "mykey", 1555555555005)
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r2, 1)

		r3, err := c.TTL(ctx, "mykey")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r3, int64(-2))

		r4, err := c.PTTL(ctx, "mykey")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r4, int64(-2))
	},
	Data: `
	{
		"session": "df3b64266ebe4e63a464e135000a07cd",
		"inbound": {},
		"actions": [{
			"protocol": "redis",
			"request": "SET mykey Hello",
			"response": "OK"
		}, {
			"protocol": "redis",
			"request": "PEXPIREAT mykey 1555555555005",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "TTL mykey",
			"response": -2
		}, {
			"protocol": "redis",
			"request": "PTTL mykey",
			"response": -2
		}]
	}`,
}

View Source

var PSetEX = Case{
	Func: func(t *testing.T, ctx context.Context, c redis.Client) {

		r1, err := c.PSetEX(ctx, "mykey", "Hello", 1000)
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, redis.OK)

		r2, err := c.PTTL(ctx, "mykey")
		if err != nil {
			t.Fatal(err)
		}
		assert.True(t, r2 <= 1000 && r2 >= 900)

		r3, err := c.Get(ctx, "mykey")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r3, "Hello")
	},
	Data: `
	{
		"session": "df3b64266ebe4e63a464e135000a07cd",
		"inbound": {},
		"actions": [{
			"protocol": "redis",
			"request": "PSETEX mykey 1000 Hello",
			"response": "OK"
		}, {
			"protocol": "redis",
			"request": "PTTL mykey",
			"response": 1000
		}, {
			"protocol": "redis",
			"request": "GET mykey",
			"response": "Hello"
		}]
	}`,
}

View Source

var PTTL = Case{
	Func: func(t *testing.T, ctx context.Context, c redis.Client) {

		r1, err := c.Set(ctx, "mykey", "Hello")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, redis.OK)

		r2, err := c.Expire(ctx, "mykey", 1)
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r2, 1)

		r3, err := c.PTTL(ctx, "mykey")
		if err != nil {
			t.Fatal(err)
		}
		assert.True(t, r3 >= 990 && r3 <= 1000)
	},
	Data: `
	{
		"session": "df3b64266ebe4e63a464e135000a07cd",
		"inbound": {},
		"actions": [{
			"protocol": "redis",
			"request": "SET mykey Hello",
			"response": "OK"
		}, {
			"protocol": "redis",
			"request": "EXPIRE mykey 1",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "PTTL mykey",
			"response": 1000
		}]
	}`,
}

View Source

var Persist = Case{
	Func: func(t *testing.T, ctx context.Context, c redis.Client) {

		r1, err := c.Set(ctx, "mykey", "Hello")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, redis.OK)

		r2, err := c.Expire(ctx, "mykey", 10)
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r2, 1)

		r3, err := c.TTL(ctx, "mykey")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r3, int64(10))

		r4, err := c.Persist(ctx, "mykey")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r4, 1)

		r5, err := c.TTL(ctx, "mykey")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r5, int64(-1))
	},
	Data: `
	{
		"session": "df3b64266ebe4e63a464e135000a07cd",
		"inbound": {},
		"actions": [{
			"protocol": "redis",
			"request": "SET mykey Hello",
			"response": "OK"
		}, {
			"protocol": "redis",
			"request": "EXPIRE mykey 10",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "TTL mykey",
			"response": 10
		}, {
			"protocol": "redis",
			"request": "PERSIST mykey",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "TTL mykey",
			"response": -1
		}]
	}`,
}

View Source

var RPop = Case{
	Func: func(t *testing.T, ctx context.Context, c redis.Client) {

		r1, err := c.RPush(ctx, "mylist", "one", "two", "three", "four", "five")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, int64(5))

		r2, err := c.RPop(ctx, "mylist")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r2, "five")

		r3, err := c.RPopN(ctx, "mylist", 2)
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r3, []string{"four", "three"})

		r4, err := c.LRange(ctx, "mylist", 0, -1)
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r4, []string{"one", "two"})
	},
	Data: `
	{
		"session": "df3b64266ebe4e63a464e135000a07cd",
		"inbound": {},
		"actions": [{
			"protocol": "redis",
			"request": "RPUSH mylist one two three four five",
			"response": 5
		}, {
			"protocol": "redis",
			"request": "RPOP mylist",
			"response": "five"
		}, {
			"protocol": "redis",
			"request": "RPOP mylist 2",
			"response": ["four", "three"]
		}, {
			"protocol": "redis",
			"request": "LRANGE mylist 0 -1",
			"response": ["one", "two"]
		}]
	}`,
}

View Source

var RPopLPush = Case{
	Func: func(t *testing.T, ctx context.Context, c redis.Client) {

		r1, err := c.RPush(ctx, "mylist", "one")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, int64(1))

		r2, err := c.RPush(ctx, "mylist", "two")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r2, int64(2))

		r3, err := c.RPush(ctx, "mylist", "three")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r3, int64(3))

		r4, err := c.RPopLPush(ctx, "mylist", "myotherlist")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r4, "three")

		r5, err := c.LRange(ctx, "mylist", 0, -1)
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r5, []string{"one", "two"})

		r6, err := c.LRange(ctx, "myotherlist", 0, -1)
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r6, []string{"three"})
	},
	Data: `
	{
		"session": "df3b64266ebe4e63a464e135000a07cd",
		"inbound": {},
		"actions": [{
			"protocol": "redis",
			"request": "RPUSH mylist one",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "RPUSH mylist two",
			"response": 2
		}, {
			"protocol": "redis",
			"request": "RPUSH mylist three",
			"response": 3
		}, {
			"protocol": "redis",
			"request": "RPOPLPUSH mylist myotherlist",
			"response": "three"
		}, {
			"protocol": "redis",
			"request": "LRANGE mylist 0 -1",
			"response": ["one", "two"]
		}, {
			"protocol": "redis",
			"request": "LRANGE myotherlist 0 -1",
			"response": ["three"]
		}]
	}`,
}

View Source

var RPush = Case{
	Func: func(t *testing.T, ctx context.Context, c redis.Client) {

		r1, err := c.RPush(ctx, "mylist", "hello")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, int64(1))

		r2, err := c.RPush(ctx, "mylist", "world")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r2, int64(2))

		r3, err := c.LRange(ctx, "mylist", 0, -1)
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r3, []string{"hello", "world"})
	},
	Data: `
	{
		"session": "df3b64266ebe4e63a464e135000a07cd",
		"inbound": {},
		"actions": [{
			"protocol": "redis",
			"request": "RPUSH mylist hello",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "RPUSH mylist world",
			"response": 2
		}, {
			"protocol": "redis",
			"request": "LRANGE mylist 0 -1",
			"response": ["hello", "world"]
		}]
	}`,
}

View Source

var RPushX = Case{
	Func: func(t *testing.T, ctx context.Context, c redis.Client) {

		r1, err := c.RPush(ctx, "mylist", "Hello")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, int64(1))

		r2, err := c.RPushX(ctx, "mylist", "World")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r2, int64(2))

		r3, err := c.RPushX(ctx, "myotherlist", "World")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r3, int64(0))

		r4, err := c.LRange(ctx, "mylist", 0, -1)
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r4, []string{"Hello", "World"})

		r5, err := c.LRange(ctx, "myotherlist", 0, -1)
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r5, []string{})
	},
	Data: `
	{
		"session": "df3b64266ebe4e63a464e135000a07cd",
		"inbound": {},
		"actions": [{
			"protocol": "redis",
			"request": "RPUSH mylist Hello",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "RPUSHX mylist World",
			"response": 2
		}, {
			"protocol": "redis",
			"request": "RPUSHX myotherlist World",
			"response": 0
		}, {
			"protocol": "redis",
			"request": "LRANGE mylist 0 -1",
			"response": ["Hello", "World"]
		}, {
			"protocol": "redis",
			"request": "LRANGE myotherlist 0 -1",
			"response": []
		}]
	}`,
}

View Source

var Rename = Case{
	Func: func(t *testing.T, ctx context.Context, c redis.Client) {

		r1, err := c.Set(ctx, "mykey", "Hello")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, redis.OK)

		r2, err := c.Rename(ctx, "mykey", "myotherkey")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r2, redis.OK)

		r3, err := c.Get(ctx, "myotherkey")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r3, "Hello")
	},
	Data: `
	{
		"session": "df3b64266ebe4e63a464e135000a07cd",
		"inbound": {},
		"actions": [{
			"protocol": "redis",
			"request": "SET mykey Hello",
			"response": "OK"
		}, {
			"protocol": "redis",
			"request": "RENAME mykey myotherkey",
			"response": "OK"
		}, {
			"protocol": "redis",
			"request": "GET myotherkey",
			"response": "Hello"
		}]
	}`,
}

View Source

var RenameNX = Case{
	Func: func(t *testing.T, ctx context.Context, c redis.Client) {

		r1, err := c.Set(ctx, "mykey", "Hello")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, redis.OK)

		r2, err := c.Set(ctx, "myotherkey", "World")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r2, redis.OK)

		r3, err := c.RenameNX(ctx, "mykey", "myotherkey")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r3, 0)

		r4, err := c.Get(ctx, "myotherkey")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r4, "World")
	},
	Data: `
	{
		"session": "df3b64266ebe4e63a464e135000a07cd",
		"inbound": {},
		"actions": [{
			"protocol": "redis",
			"request": "SET mykey Hello",
			"response": "OK"
		}, {
			"protocol": "redis",
			"request": "SET myotherkey World",
			"response": "OK"
		}, {
			"protocol": "redis",
			"request": "RENAMENX mykey myotherkey",
			"response": 0
		}, {
			"protocol": "redis",
			"request": "GET myotherkey",
			"response": "World"
		}]
	}`,
}

View Source

var SAdd = Case{
	Func: func(t *testing.T, ctx context.Context, c redis.Client) {

		r1, err := c.SAdd(ctx, "myset", "Hello")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, int64(1))

		r2, err := c.SAdd(ctx, "myset", "World")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r2, int64(1))

		r3, err := c.SAdd(ctx, "myset", "World")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r3, int64(0))

		r4, err := c.SMembers(ctx, "myset")
		if err != nil {
			t.Fatal(err)
		}
		sort.Strings(r4)
		assert.Equal(t, r4, []string{"Hello", "World"})
	},
	Data: `
	{
		"session": "df3b64266ebe4e63a464e135000a07cd",
		"inbound": {},
		"actions": [{
			"protocol": "redis",
			"request": "SADD myset Hello",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "SADD myset World",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "SADD myset World",
			"response": 0
		}, {
			"protocol": "redis",
			"request": "SMEMBERS myset",
			"response": ["Hello", "World"]
		}]
	}`,
}

View Source

var SCard = Case{
	Func: func(t *testing.T, ctx context.Context, c redis.Client) {

		r1, err := c.SAdd(ctx, "myset", "Hello")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, int64(1))

		r2, err := c.SAdd(ctx, "myset", "World")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r2, int64(1))

		r3, err := c.SCard(ctx, "myset")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r3, int64(2))
	},
	Data: `
	{
		"session": "df3b64266ebe4e63a464e135000a07cd",
		"inbound": {},
		"actions": [{
			"protocol": "redis",
			"request": "SADD myset Hello",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "SADD myset World",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "SCARD myset",
			"response": 2
		}]
	}`,
}

View Source

var SDiff = Case{
	Func: func(t *testing.T, ctx context.Context, c redis.Client) {

		r1, err := c.SAdd(ctx, "key1", "a")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, int64(1))

		r2, err := c.SAdd(ctx, "key1", "b")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r2, int64(1))

		r3, err := c.SAdd(ctx, "key1", "c")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r3, int64(1))

		r4, err := c.SAdd(ctx, "key2", "c")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r4, int64(1))

		r5, err := c.SAdd(ctx, "key2", "d")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r5, int64(1))

		r6, err := c.SAdd(ctx, "key2", "e")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r6, int64(1))

		r7, err := c.SDiff(ctx, "key1", "key2")
		if err != nil {
			t.Fatal(err)
		}
		sort.Strings(r7)
		assert.Equal(t, r7, []string{"a", "b"})
	},
	Data: `
	{
		"session": "df3b64266ebe4e63a464e135000a07cd",
		"inbound": {},
		"actions": [{
			"protocol": "redis",
			"request": "SADD key1 a",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "SADD key1 b",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "SADD key1 c",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "SADD key2 c",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "SADD key2 d",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "SADD key2 e",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "SDIFF key1 key2",
			"response": ["a", "b"]
		}]
	}`,
}

View Source

var SDiffStore = Case{
	Func: func(t *testing.T, ctx context.Context, c redis.Client) {

		r1, err := c.SAdd(ctx, "key1", "a")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, int64(1))

		r2, err := c.SAdd(ctx, "key1", "b")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r2, int64(1))

		r3, err := c.SAdd(ctx, "key1", "c")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r3, int64(1))

		r4, err := c.SAdd(ctx, "key2", "c")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r4, int64(1))

		r5, err := c.SAdd(ctx, "key2", "d")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r5, int64(1))

		r6, err := c.SAdd(ctx, "key2", "e")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r6, int64(1))

		r7, err := c.SDiffStore(ctx, "key", "key1", "key2")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r7, int64(2))

		r8, err := c.SMembers(ctx, "key")
		if err != nil {
			t.Fatal(err)
		}
		sort.Strings(r8)
		assert.Equal(t, r8, []string{"a", "b"})
	},
	Data: `
	{
		"session": "df3b64266ebe4e63a464e135000a07cd",
		"inbound": {},
		"actions": [{
			"protocol": "redis",
			"request": "SADD key1 a",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "SADD key1 b",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "SADD key1 c",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "SADD key2 c",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "SADD key2 d",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "SADD key2 e",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "SDIFFSTORE key key1 key2",
			"response": 2
		}, {
			"protocol": "redis",
			"request": "SMEMBERS key",
			"response": ["a", "b"]
		}]
	}`,
}

View Source

var SInter = Case{
	Func: func(t *testing.T, ctx context.Context, c redis.Client) {

		r1, err := c.SAdd(ctx, "key1", "a")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, int64(1))

		r2, err := c.SAdd(ctx, "key1", "b")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r2, int64(1))

		r3, err := c.SAdd(ctx, "key1", "c")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r3, int64(1))

		r4, err := c.SAdd(ctx, "key2", "c")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r4, int64(1))

		r5, err := c.SAdd(ctx, "key2", "d")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r5, int64(1))

		r6, err := c.SAdd(ctx, "key2", "e")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r6, int64(1))

		r7, err := c.SInter(ctx, "key1", "key2")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r7, []string{"c"})
	},
	Data: `
	{
		"session": "df3b64266ebe4e63a464e135000a07cd",
		"inbound": {},
		"actions": [{
			"protocol": "redis",
			"request": "SADD key1 a",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "SADD key1 b",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "SADD key1 c",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "SADD key2 c",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "SADD key2 d",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "SADD key2 e",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "SINTER key1 key2",
			"response": ["c"]
		}]
	}`,
}

View Source

var SInterStore = Case{
	Func: func(t *testing.T, ctx context.Context, c redis.Client) {

		r1, err := c.SAdd(ctx, "key1", "a")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, int64(1))

		r2, err := c.SAdd(ctx, "key1", "b")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r2, int64(1))

		r3, err := c.SAdd(ctx, "key1", "c")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r3, int64(1))

		r4, err := c.SAdd(ctx, "key2", "c")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r4, int64(1))

		r5, err := c.SAdd(ctx, "key2", "d")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r5, int64(1))

		r6, err := c.SAdd(ctx, "key2", "e")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r6, int64(1))

		r7, err := c.SInterStore(ctx, "key", "key1", "key2")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r7, int64(1))

		r8, err := c.SMembers(ctx, "key")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r8, []string{"c"})
	},
	Data: `
	{
		"session": "df3b64266ebe4e63a464e135000a07cd",
		"inbound": {},
		"actions": [{
			"protocol": "redis",
			"request": "SADD key1 a",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "SADD key1 b",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "SADD key1 c",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "SADD key2 c",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "SADD key2 d",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "SADD key2 e",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "SINTERSTORE key key1 key2",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "SMEMBERS key",
			"response": ["c"]
		}]
	}`,
}

View Source

var SIsMember = Case{
	Func: func(t *testing.T, ctx context.Context, c redis.Client) {

		r1, err := c.SAdd(ctx, "myset", "one")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, int64(1))

		r2, err := c.SIsMember(ctx, "myset", "one")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r2, int64(1))

		r3, err := c.SIsMember(ctx, "myset", "two")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r3, int64(0))
	},
	Data: "",
}

View Source

var SMIsMember = Case{
	Func: func(t *testing.T, ctx context.Context, c redis.Client) {

		r1, err := c.SAdd(ctx, "myset", "one")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, int64(1))

		r2, err := c.SAdd(ctx, "myset", "one")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r2, int64(0))

		r3, err := c.SMIsMember(ctx, "myset", "one", "notamember")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r3, []int64{int64(1), int64(0)})
	},
	Data: `
	{
		"session": "df3b64266ebe4e63a464e135000a07cd",
		"inbound": {},
		"actions": [{
			"protocol": "redis",
			"request": "SADD myset one",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "SADD myset one",
			"response": 0
		}, {
			"protocol": "redis",
			"request": "SMISMEMBER myset one notamember",
			"response": [1, 0]
		}]
	}`,
}

View Source

var SMembers = Case{
	Func: func(t *testing.T, ctx context.Context, c redis.Client) {

		r1, err := c.SAdd(ctx, "myset", "Hello")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, int64(1))

		r2, err := c.SAdd(ctx, "myset", "World")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r2, int64(1))

		r3, err := c.SMembers(ctx, "myset")
		if err != nil {
			t.Fatal(err)
		}
		sort.Strings(r3)
		assert.Equal(t, r3, []string{"Hello", "World"})
	},
	Data: `
	{
		"session": "df3b64266ebe4e63a464e135000a07cd",
		"inbound": {},
		"actions": [{
			"protocol": "redis",
			"request": "SADD myset Hello",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "SADD myset World",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "SMEMBERS myset",
			"response": ["Hello", "World"]
		}]
	}`,
}

View Source

var SMove = Case{
	Func: func(t *testing.T, ctx context.Context, c redis.Client) {

		r1, err := c.SAdd(ctx, "myset", "one")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, int64(1))

		r2, err := c.SAdd(ctx, "myset", "two")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r2, int64(1))

		r3, err := c.SAdd(ctx, "myotherset", "three")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r3, int64(1))

		r4, err := c.SMove(ctx, "myset", "myotherset", "two")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r4, 1)

		r5, err := c.SMembers(ctx, "myset")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r5, []string{"one"})

		r6, err := c.SMembers(ctx, "myotherset")
		if err != nil {
			t.Fatal(err)
		}
		sort.Strings(r6)
		assert.Equal(t, r6, []string{"three", "two"})
	},
	Data: `
	{
		"session": "df3b64266ebe4e63a464e135000a07cd",
		"inbound": {},
		"actions": [{
			"protocol": "redis",
			"request": "SADD myset one",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "SADD myset two",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "SADD myotherset three",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "SMOVE myset myotherset two",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "SMEMBERS myset",
			"response": ["one"]
		}, {
			"protocol": "redis",
			"request": "SMEMBERS myotherset",
			"response": ["three", "two"]
		}]
	}`,
}

View Source

var SPop = Case{
	Func: func(t *testing.T, ctx context.Context, c redis.Client) {

		r1, err := c.SAdd(ctx, "myset", "one")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, int64(1))

		r2, err := c.SAdd(ctx, "myset", "two")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r2, int64(1))

		r3, err := c.SAdd(ctx, "myset", "three")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r3, int64(1))

		r4, err := c.SPop(ctx, "myset")
		if err != nil {
			t.Fatal(err)
		}

		r5, err := c.SMembers(ctx, "myset")
		if err != nil {
			t.Fatal(err)
		}

		r6 := append([]string{r4}, r5...)
		sort.Strings(r6)
		assert.Equal(t, r6, []string{"one", "three", "two"})
	},
	Data: `
	{
		"session": "df3b64266ebe4e63a464e135000a07cd",
		"inbound": {},
		"actions": [{
			"protocol": "redis",
			"request": "SADD myset one",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "SADD myset two",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "SADD myset three",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "SPOP myset",
			"response": "two"
		}, {
			"protocol": "redis",
			"request": "SMEMBERS myset",
			"response": ["three", "one"]
		}]
	}`,
}

View Source

var SRandMember = Case{
	Func: func(t *testing.T, ctx context.Context, c redis.Client) {

		r1, err := c.SAdd(ctx, "myset", "one", "two", "three")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, int64(3))

		_, err = c.SRandMember(ctx, "myset")
		if err != nil {
			t.Fatal(err)
		}

		r3, err := c.SRandMemberN(ctx, "myset", 2)
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, len(r3), 2)

		r4, err := c.SRandMemberN(ctx, "myset", -5)
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, len(r4), 5)
	},
	Data: `
	{
		"session": "df3b64266ebe4e63a464e135000a07cd",
		"inbound": {},
		"actions": [{
			"protocol": "redis",
			"request": "SADD myset one two three",
			"response": 3
		}, {
			"protocol": "redis",
			"request": "SRANDMEMBER myset",
			"response": "one"
		}, {
			"protocol": "redis",
			"request": "SRANDMEMBER myset 2",
			"response": ["one", "three"]
		}, {
			"protocol": "redis",
			"request": "SRANDMEMBER myset -5",
			"response": ["one", "one", "one", "two", "one"]
		}]
	}`,
}

View Source

var SRem = Case{
	Func: func(t *testing.T, ctx context.Context, c redis.Client) {

		r1, err := c.SAdd(ctx, "myset", "one")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, int64(1))

		r2, err := c.SAdd(ctx, "myset", "two")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r2, int64(1))

		r3, err := c.SAdd(ctx, "myset", "three")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r3, int64(1))

		r4, err := c.SRem(ctx, "myset", "one")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r4, int64(1))

		r5, err := c.SRem(ctx, "myset", "four")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r5, int64(0))

		r6, err := c.SMembers(ctx, "myset")
		if err != nil {
			t.Fatal(err)
		}
		sort.Strings(r6)
		assert.Equal(t, r6, []string{"three", "two"})
	},
	Data: `
	{
		"session": "df3b64266ebe4e63a464e135000a07cd",
		"inbound": {},
		"actions": [{
			"protocol": "redis",
			"request": "SADD myset one",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "SADD myset two",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "SADD myset three",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "SREM myset one",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "SREM myset four",
			"response": 0
		}, {
			"protocol": "redis",
			"request": "SMEMBERS myset",
			"response": ["three", "two"]
		}]
	}`,
}

View Source

var SUnion = Case{
	Func: func(t *testing.T, ctx context.Context, c redis.Client) {

		r1, err := c.SAdd(ctx, "key1", "a")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, int64(1))

		r2, err := c.SAdd(ctx, "key1", "b")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r2, int64(1))

		r3, err := c.SAdd(ctx, "key1", "c")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r3, int64(1))

		r4, err := c.SAdd(ctx, "key2", "c")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r4, int64(1))

		r5, err := c.SAdd(ctx, "key2", "d")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r5, int64(1))

		r6, err := c.SAdd(ctx, "key2", "e")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r6, int64(1))

		r7, err := c.SUnion(ctx, "key1", "key2")
		if err != nil {
			t.Fatal(err)
		}
		sort.Strings(r7)
		assert.Equal(t, r7, []string{"a", "b", "c", "d", "e"})
	},
	Data: `
	{
		"session": "df3b64266ebe4e63a464e135000a07cd",
		"inbound": {},
		"actions": [{
			"protocol": "redis",
			"request": "SADD key1 a",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "SADD key1 b",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "SADD key1 c",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "SADD key2 c",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "SADD key2 d",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "SADD key2 e",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "SUNION key1 key2",
			"response": ["a", "b", "c", "e", "d"]
		}]
	}`,
}

View Source

var SUnionStore = Case{
	Func: func(t *testing.T, ctx context.Context, c redis.Client) {

		r1, err := c.SAdd(ctx, "key1", "a")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, int64(1))

		r2, err := c.SAdd(ctx, "key1", "b")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r2, int64(1))

		r3, err := c.SAdd(ctx, "key1", "c")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r3, int64(1))

		r4, err := c.SAdd(ctx, "key2", "c")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r4, int64(1))

		r5, err := c.SAdd(ctx, "key2", "d")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r5, int64(1))

		r6, err := c.SAdd(ctx, "key2", "e")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r6, int64(1))

		r7, err := c.SUnionStore(ctx, "key", "key1", "key2")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r7, int64(5))

		r8, err := c.SMembers(ctx, "key")
		if err != nil {
			t.Fatal(err)
		}
		sort.Strings(r8)
		assert.Equal(t, r8, []string{"a", "b", "c", "d", "e"})
	},
	Data: `
	{
		"session": "df3b64266ebe4e63a464e135000a07cd",
		"inbound": {},
		"actions": [{
			"protocol": "redis",
			"request": "SADD key1 a",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "SADD key1 b",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "SADD key1 c",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "SADD key2 c",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "SADD key2 d",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "SADD key2 e",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "SUNIONSTORE key key1 key2",
			"response": 5
		}, {
			"protocol": "redis",
			"request": "SMEMBERS key",
			"response": ["a", "b", "c", "e", "d"]
		}]
	}`,
}

View Source

var Set = Case{
	Func: func(t *testing.T, ctx context.Context, c redis.Client) {

		r1, err := c.Set(ctx, "mykey", "Hello")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, redis.OK)

		r2, err := c.Get(ctx, "mykey")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r2, "Hello")

		r3, err := c.SetEX(ctx, "anotherkey", "will expire in a minute", 60)
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r3, redis.OK)
	},
	Data: `
	{
		"session": "df3b64266ebe4e63a464e135000a07cd",
		"inbound": {},
		"actions": [{
			"protocol": "redis",
			"request": "SET mykey Hello",
			"response": "OK"
		}, {
			"protocol": "redis",
			"request": "GET mykey",
			"response": "Hello"
		}, {
			"protocol": "redis",
			"request": "SETEX anotherkey 60 @\"will expire in a minute\"@",
			"response": "OK"
		}]
	}`,
}

View Source

var SetBit = Case{
	Func: func(t *testing.T, ctx context.Context, c redis.Client) {

		r1, err := c.SetBit(ctx, "mykey", 7, 1)
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, int64(0))

		r2, err := c.SetBit(ctx, "mykey", 7, 0)
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r2, int64(1))

		r3, err := c.Get(ctx, "mykey")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r3, "\u0000")
	},
	Data: `
	{
		"session": "df3b64266ebe4e63a464e135000a07cd",
		"inbound": {},
		"actions": [{
			"protocol": "redis",
			"request": "SETBIT mykey 7 1",
			"response": 0
		}, {
			"protocol": "redis",
			"request": "SETBIT mykey 7 0",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "GET mykey",
			"response": "\u0000"
		}]
	}`,
}

View Source

var SetEX = Case{
	Func: func(t *testing.T, ctx context.Context, c redis.Client) {

		r1, err := c.SetEX(ctx, "mykey", "Hello", 10)
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, redis.OK)

		r2, err := c.TTL(ctx, "mykey")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r2, int64(10))

		r3, err := c.Get(ctx, "mykey")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r3, "Hello")
	},
	Data: `
	{
		"session": "df3b64266ebe4e63a464e135000a07cd",
		"inbound": {},
		"actions": [{
			"protocol": "redis",
			"request": "SETEX mykey 10 Hello",
			"response": "OK"
		}, {
			"protocol": "redis",
			"request": "TTL mykey",
			"response": 10
		}, {
			"protocol": "redis",
			"request": "GET mykey",
			"response": "Hello"
		}]
	}`,
}

View Source

var SetNX = Case{
	Func: func(t *testing.T, ctx context.Context, c redis.Client) {

		r1, err := c.SetNX(ctx, "mykey", "Hello")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, 1)

		r2, err := c.SetNX(ctx, "mykey", "World")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r2, 0)

		r3, err := c.Get(ctx, "mykey")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r3, "Hello")
	},
	Data: `
	{
		"session": "df3b64266ebe4e63a464e135000a07cd",
		"inbound": {},
		"actions": [{
			"protocol": "redis",
			"request": "SETNX mykey Hello",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "SETNX mykey World",
			"response": 0
		}, {
			"protocol": "redis",
			"request": "GET mykey",
			"response": "Hello"
		}]
	}`,
}

View Source

var SetRange = Case{
	Func: func(t *testing.T, ctx context.Context, c redis.Client) {

		r1, err := c.Set(ctx, "key1", "Hello World")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, redis.OK)

		r2, err := c.SetRange(ctx, "key1", 6, "Redis")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r2, int64(11))

		r3, err := c.Get(ctx, "key1")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r3, "Hello Redis")

		r4, err := c.SetRange(ctx, "key2", 6, "Redis")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r4, int64(11))

		r5, err := c.Get(ctx, "key2")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r5, "\u0000\u0000\u0000\u0000\u0000\u0000Redis")
	},
	Data: `
	{
		"session": "df3b64266ebe4e63a464e135000a07cd",
		"inbound": {},
		"actions": [{
			"protocol": "redis",
			"request": "SET key1 @\"Hello World\"@",
			"response": "OK"
		}, {
			"protocol": "redis",
			"request": "SETRANGE key1 6 Redis",
			"response": 11
		}, {
			"protocol": "redis",
			"request": "GET key1",
			"response": "Hello Redis"
		}, {
			"protocol": "redis",
			"request": "SETRANGE key2 6 Redis",
			"response": 11
		}, {
			"protocol": "redis",
			"request": "GET key2",
			"response": "\u0000\u0000\u0000\u0000\u0000\u0000Redis"
		}]
	}`,
}

View Source

var StrLen = Case{
	Func: func(t *testing.T, ctx context.Context, c redis.Client) {

		r1, err := c.Set(ctx, "mykey", "Hello world")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, redis.OK)

		r2, err := c.StrLen(ctx, "mykey")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r2, int64(11))

		r3, err := c.StrLen(ctx, "nonexisting")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r3, int64(0))
	},
	Data: `
	{
		"session": "df3b64266ebe4e63a464e135000a07cd",
		"inbound": {},
		"actions": [{
			"protocol": "redis",
			"request": "SET mykey @\"Hello world\"@",
			"response": "OK"
		}, {
			"protocol": "redis",
			"request": "STRLEN mykey",
			"response": 11
		}, {
			"protocol": "redis",
			"request": "STRLEN nonexisting",
			"response": 0
		}]
	}`,
}

View Source

var TTL = Case{
	Func: func(t *testing.T, ctx context.Context, c redis.Client) {

		r1, err := c.Set(ctx, "mykey", "Hello")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, redis.OK)

		r2, err := c.Expire(ctx, "mykey", 10)
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r2, 1)

		r3, err := c.TTL(ctx, "mykey")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r3, int64(10))
	},
	Data: `
	{
		"session": "df3b64266ebe4e63a464e135000a07cd",
		"inbound": {},
		"actions": [{
			"protocol": "redis",
			"request": "SET mykey Hello",
			"response": "OK"
		}, {
			"protocol": "redis",
			"request": "EXPIRE mykey 10",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "TTL mykey",
			"response": 10
		}]
	}`,
}

View Source

var Touch = Case{
	Func: func(t *testing.T, ctx context.Context, c redis.Client) {

		r1, err := c.Set(ctx, "key1", "Hello")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, redis.OK)

		r2, err := c.Set(ctx, "key2", "World")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r2, redis.OK)

		r3, err := c.Touch(ctx, "key1", "key2")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r3, int64(2))
	},
	Data: `
	{
		"session": "df3b64266ebe4e63a464e135000a07cd",
		"inbound": {},
		"actions": [{
			"protocol": "redis",
			"request": "SET key1 Hello",
			"response": "OK"
		}, {
			"protocol": "redis",
			"request": "SET key2 World",
			"response": "OK"
		}, {
			"protocol": "redis",
			"request": "TOUCH key1 key2",
			"response": 2
		}]
	}`,
}

View Source

var Type = Case{
	Func: func(t *testing.T, ctx context.Context, c redis.Client) {

		r1, err := c.Set(ctx, "key1", "value")
		if err != nil {
			return
		}
		assert.Equal(t, r1, redis.OK)

		r2, err := c.LPush(ctx, "key2", "value")
		if err != nil {
			return
		}
		assert.Equal(t, r2, int64(1))

		r3, err := c.SAdd(ctx, "key3", "value")
		if err != nil {
			return
		}
		assert.Equal(t, r3, int64(1))

		r4, err := c.Type(ctx, "key1")
		if err != nil {
			return
		}
		assert.Equal(t, r4, "string")

		r5, err := c.Type(ctx, "key2")
		if err != nil {
			return
		}
		assert.Equal(t, r5, "list")

		r6, err := c.Type(ctx, "key3")
		if err != nil {
			return
		}
		assert.Equal(t, r6, "set")
	},
	Data: `
	{
		"session": "df3b64266ebe4e63a464e135000a07cd",
		"inbound": {},
		"actions": [{
			"protocol": "redis",
			"request": "SET key1 value",
			"response": "OK"
		}, {
			"protocol": "redis",
			"request": "LPUSH key2 value",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "SADD key3 value",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "TYPE key1",
			"response": "string"
		}, {
			"protocol": "redis",
			"request": "TYPE key2",
			"response": "list"
		}, {
			"protocol": "redis",
			"request": "TYPE key3",
			"response": "set"
		}]
	}`,
}

View Source

var ZAdd = Case{
	Func: func(t *testing.T, ctx context.Context, c redis.Client) {

		r1, err := c.ZAdd(ctx, "myzset", 1, "one")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, int64(1))

		r2, err := c.ZAdd(ctx, "myzset", 1, "uno")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r2, int64(1))

		r3, err := c.ZAdd(ctx, "myzset", 2, "two", 3, "three")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r3, int64(2))

		r4, err := c.ZRangeWithScores(ctx, "myzset", 0, -1)
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r4, []redis.ZItem{{"one", 1}, {"uno", 1}, {"two", 2}, {"three", 3}})
	},
	Data: `
	{
		"session": "df3b64266ebe4e63a464e135000a07cd",
		"inbound": {},
		"actions": [{
			"protocol": "redis",
			"request": "ZADD myzset 1 one",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "ZADD myzset 1 uno",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "ZADD myzset 2 two 3 three",
			"response": 2
		}, {
			"protocol": "redis",
			"request": "ZRANGE myzset 0 -1 WITHSCORES",
			"response": [
				["one", "1"],
				["uno", "1"],
				["two", "2"],
				["three", "3"]
			]
		}]
	}`,
}

View Source

var ZCard = Case{
	Func: func(t *testing.T, ctx context.Context, c redis.Client) {

		r1, err := c.ZAdd(ctx, "myzset", 1, "one")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, int64(1))

		r2, err := c.ZAdd(ctx, "myzset", 2, "two")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r2, int64(1))

		r3, err := c.ZCard(ctx, "myzset")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r3, int64(2))
	},
	Data: `
	{
		"session": "df3b64266ebe4e63a464e135000a07cd",
		"inbound": {},
		"actions": [{
			"protocol": "redis",
			"request": "ZADD myzset 1 one",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "ZADD myzset 2 two",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "ZCARD myzset",
			"response": 2
		}]
	}`,
}

View Source

var ZCount = Case{
	Func: func(t *testing.T, ctx context.Context, c redis.Client) {

		r1, err := c.ZAdd(ctx, "myzset", 1, "one")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, int64(1))

		r2, err := c.ZAdd(ctx, "myzset", 2, "two")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r2, int64(1))

		r3, err := c.ZAdd(ctx, "myzset", 3, "three")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r3, int64(1))

		r4, err := c.ZCount(ctx, "myzset", "-inf", "+inf")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r4, int64(3))

		r5, err := c.ZCount(ctx, "myzset", "(1", "3")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r5, int64(2))
	},
	Data: `
	{
		"session": "df3b64266ebe4e63a464e135000a07cd",
		"inbound": {},
		"actions": [{
			"protocol": "redis",
			"request": "ZADD myzset 1 one",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "ZADD myzset 2 two",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "ZADD myzset 3 three",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "ZCOUNT myzset -inf +inf",
			"response": 3
		}, {
			"protocol": "redis",
			"request": "ZCOUNT myzset (1 3",
			"response": 2
		}]
	}`,
}

View Source

var ZDiff = Case{
	Func: func(t *testing.T, ctx context.Context, c redis.Client) {

		r1, err := c.ZAdd(ctx, "zset1", 1, "one")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, int64(1))

		r2, err := c.ZAdd(ctx, "zset1", 2, "two")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r2, int64(1))

		r3, err := c.ZAdd(ctx, "zset1", 3, "three")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r3, int64(1))

		r4, err := c.ZAdd(ctx, "zset2", 1, "one")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r4, int64(1))

		r5, err := c.ZAdd(ctx, "zset2", 2, "two")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r5, int64(1))

		r6, err := c.ZDiff(ctx, "zset1", "zset2")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r6, []string{"three"})

		r7, err := c.ZDiffWithScores(ctx, "zset1", "zset2")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r7, []redis.ZItem{{"three", 3}})
	},
	Data: `
	{
		"session": "df3b64266ebe4e63a464e135000a07cd",
		"inbound": {},
		"actions": [{
			"protocol": "redis",
			"request": "ZADD zset1 1 one",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "ZADD zset1 2 two",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "ZADD zset1 3 three",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "ZADD zset2 1 one",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "ZADD zset2 2 two",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "ZDIFF 2 zset1 zset2",
			"response": ["three"]
		}, {
			"protocol": "redis",
			"request": "ZDIFF 2 zset1 zset2 WITHSCORES",
			"response": [
				["three", "3"]
			]
		}]
	}`,
}

View Source

var ZIncrBy = Case{
	Func: func(t *testing.T, ctx context.Context, c redis.Client) {

		r1, err := c.ZAdd(ctx, "myzset", 1, "one")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, int64(1))

		r2, err := c.ZAdd(ctx, "myzset", 2, "two")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r2, int64(1))

		r3, err := c.ZIncrBy(ctx, "myzset", 2, "one")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r3, float64(3))

		r4, err := c.ZRangeWithScores(ctx, "myzset", 0, -1)
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r4, []redis.ZItem{{"two", 2}, {"one", 3}})
	},
	Data: `
	{
		"session": "df3b64266ebe4e63a464e135000a07cd",
		"inbound": {},
		"actions": [{
			"protocol": "redis",
			"request": "ZADD myzset 1 one",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "ZADD myzset 2 two",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "ZINCRBY myzset 2 one",
			"response": "3"
		}, {
			"protocol": "redis",
			"request": "ZRANGE myzset 0 -1 WITHSCORES",
			"response": [
				["two", "2"],
				["one", "3"]
			]
		}]
	}`,
}

View Source

var ZInter = Case{
	Func: func(t *testing.T, ctx context.Context, c redis.Client) {

		r1, err := c.ZAdd(ctx, "zset1", 1, "one")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, int64(1))

		r2, err := c.ZAdd(ctx, "zset1", 2, "two")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r2, int64(1))

		r3, err := c.ZAdd(ctx, "zset2", 1, "one")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r3, int64(1))

		r4, err := c.ZAdd(ctx, "zset2", 2, "two")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r4, int64(1))

		r5, err := c.ZAdd(ctx, "zset2", 3, "three")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r5, int64(1))

		r6, err := c.ZInter(ctx, 2, "zset1", "zset2")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r6, []string{"one", "two"})

		r7, err := c.ZInterWithScores(ctx, 2, "zset1", "zset2")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r7, []redis.ZItem{{"one", 2}, {"two", 4}})
	},
	Data: `
	{
		"session": "df3b64266ebe4e63a464e135000a07cd",
		"inbound": {},
		"actions": [{
			"protocol": "redis",
			"request": "ZADD zset1 1 one",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "ZADD zset1 2 two",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "ZADD zset2 1 one",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "ZADD zset2 2 two",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "ZADD zset2 3 three",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "ZINTER 2 zset1 zset2",
			"response": ["one", "two"]
		}, {
			"protocol": "redis",
			"request": "ZINTER 2 zset1 zset2 WITHSCORES",
			"response": [
				["one", "2"],
				["two", "4"]
			]
		}]
	}`,
}

View Source

var ZLexCount = Case{
	Func: func(t *testing.T, ctx context.Context, c redis.Client) {

		r1, err := c.ZAdd(ctx, "myzset", 0, "a", 0, "b", 0, "c", 0, "d", 0, "e")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, int64(5))

		r2, err := c.ZAdd(ctx, "myzset", 0, "f", 0, "g")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r2, int64(2))

		r3, err := c.ZLexCount(ctx, "myzset", "-", "+")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r3, int64(7))

		r4, err := c.ZLexCount(ctx, "myzset", "[b", "[f")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r4, int64(5))
	},
	Data: `
	{
		"session": "df3b64266ebe4e63a464e135000a07cd",
		"inbound": {},
		"actions": [{
			"protocol": "redis",
			"request": "ZADD myzset 0 a 0 b 0 c 0 d 0 e",
			"response": 5
		}, {
			"protocol": "redis",
			"request": "ZADD myzset 0 f 0 g",
			"response": 2
		}, {
			"protocol": "redis",
			"request": "ZLEXCOUNT myzset - +",
			"response": 7
		}, {
			"protocol": "redis",
			"request": "ZLEXCOUNT myzset [b [f",
			"response": 5
		}]
	}`,
}

View Source

var ZMScore = Case{
	Func: func(t *testing.T, ctx context.Context, c redis.Client) {

		r1, err := c.ZAdd(ctx, "myzset", 1, "one")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, int64(1))

		r2, err := c.ZAdd(ctx, "myzset", 2, "two")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r2, int64(1))

		r3, err := c.ZMScore(ctx, "myzset", "one", "two", "nofield")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r3, []float64{1, 2, 0})
	},
	Data: `
	{
		"session": "df3b64266ebe4e63a464e135000a07cd",
		"inbound": {},
		"actions": [{
			"protocol": "redis",
			"request": "ZADD myzset 1 one",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "ZADD myzset 2 two",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "ZMSCORE myzset one two nofield",
			"response": ["1", "2", null]
		}]
	}`,
}

View Source

var ZPopMax = Case{
	Func: func(t *testing.T, ctx context.Context, c redis.Client) {

		r1, err := c.ZAdd(ctx, "myzset", 1, "one")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, int64(1))

		r2, err := c.ZAdd(ctx, "myzset", 2, "two")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r2, int64(1))

		r3, err := c.ZAdd(ctx, "myzset", 3, "three")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r3, int64(1))

		r4, err := c.ZPopMax(ctx, "myzset")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r4, []redis.ZItem{{"three", 3}})
	},
	Data: `
	{
		"session": "df3b64266ebe4e63a464e135000a07cd",
		"inbound": {},
		"actions": [{
			"protocol": "redis",
			"request": "ZADD myzset 1 one",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "ZADD myzset 2 two",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "ZADD myzset 3 three",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "ZPOPMAX myzset",
			"response": [
				["three", "3"]
			]
		}]
	}`,
}

View Source

var ZPopMin = Case{
	Func: func(t *testing.T, ctx context.Context, c redis.Client) {

		r1, err := c.ZAdd(ctx, "myzset", 1, "one")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, int64(1))

		r2, err := c.ZAdd(ctx, "myzset", 2, "two")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r2, int64(1))

		r3, err := c.ZAdd(ctx, "myzset", 3, "three")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r3, int64(1))

		r4, err := c.ZPopMin(ctx, "myzset")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r4, []redis.ZItem{{"one", 1}})
	},
	Data: `
	{
		"session": "df3b64266ebe4e63a464e135000a07cd",
		"inbound": {},
		"actions": [{
			"protocol": "redis",
			"request": "ZADD myzset 1 one",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "ZADD myzset 2 two",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "ZADD myzset 3 three",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "ZPOPMIN myzset",
			"response": [
				["one", "1"]
			]
		}]
	}`,
}

View Source

var ZRandMember = Case{
	Func: func(t *testing.T, ctx context.Context, c redis.Client) {

		r1, err := c.ZAdd(ctx, "dadi", 1, "uno", 2, "due", 3, "tre", 4, "quattro", 5, "cinque", 6, "sei")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, int64(6))

		r2, err := c.ZRandMember(ctx, "dadi")
		if err != nil {
			t.Fatal(err)
		}
		assert.NotEqual(t, r2, "")

		r3, err := c.ZRandMember(ctx, "dadi")
		if err != nil {
			t.Fatal(err)
		}
		assert.NotEqual(t, r3, "")

		r4, err := c.ZRandMemberWithScores(ctx, "dadi", -5)
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, len(r4), 5)
	},
	Data: `
	{
		"session": "df3b64266ebe4e63a464e135000a07cd",
		"inbound": {},
		"actions": [{
			"protocol": "redis",
			"request": "ZADD dadi 1 uno 2 due 3 tre 4 quattro 5 cinque 6 sei",
			"response": 6
		}, {
			"protocol": "redis",
			"request": "ZRANDMEMBER dadi",
			"response": "sei"
		}, {
			"protocol": "redis",
			"request": "ZRANDMEMBER dadi",
			"response": "sei"
		}, {
			"protocol": "redis",
			"request": "ZRANDMEMBER dadi -5 WITHSCORES",
			"response": [
				["uno", "1"],
				["uno", "1"],
				["cinque", "5"],
				["sei", "6"],
				["due", "2"]
			]
		}]
	}`,
}

View Source

var ZRange = Case{
	Func: func(t *testing.T, ctx context.Context, c redis.Client) {

		r1, err := c.ZAdd(ctx, "myzset", 1, "one")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, int64(1))

		r2, err := c.ZAdd(ctx, "myzset", 2, "two")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r2, int64(1))

		r3, err := c.ZAdd(ctx, "myzset", 3, "three")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r3, int64(1))

		r4, err := c.ZRange(ctx, "myzset", 0, -1)
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r4, []string{"one", "two", "three"})

		r5, err := c.ZRange(ctx, "myzset", 2, 3)
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r5, []string{"three"})

		r6, err := c.ZRange(ctx, "myzset", -2, -1)
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r6, []string{"two", "three"})

		r7, err := c.ZRangeWithScores(ctx, "myzset", 0, 1)
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r7, []redis.ZItem{{"one", 1}, {"two", 2}})
	},
	Data: `
	{
		"session": "df3b64266ebe4e63a464e135000a07cd",
		"inbound": {},
		"actions": [{
			"protocol": "redis",
			"request": "ZADD myzset 1 one",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "ZADD myzset 2 two",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "ZADD myzset 3 three",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "ZRANGE myzset 0 -1",
			"response": ["one", "two", "three"]
		}, {
			"protocol": "redis",
			"request": "ZRANGE myzset 2 3",
			"response": ["three"]
		}, {
			"protocol": "redis",
			"request": "ZRANGE myzset -2 -1",
			"response": ["two", "three"]
		}, {
			"protocol": "redis",
			"request": "ZRANGE myzset 0 1 WITHSCORES",
			"response": [
				["one", "1"],
				["two", "2"]
			]
		}]
	}`,
}

View Source

var ZRangeByLex = Case{
	Func: func(t *testing.T, ctx context.Context, c redis.Client) {

		r1, err := c.ZAdd(ctx, "myzset", 0, "a", 0, "b", 0, "c", 0, "d", 0, "e", 0, "f", 0, "g")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, int64(7))

		r2, err := c.ZRangeByLex(ctx, "myzset", "-", "[c")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r2, []string{"a", "b", "c"})

		r3, err := c.ZRangeByLex(ctx, "myzset", "-", "(c")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r3, []string{"a", "b"})

		r4, err := c.ZRangeByLex(ctx, "myzset", "[aaa", "(g")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r4, []string{"b", "c", "d", "e", "f"})
	},
	Data: `
	{
		"session": "df3b64266ebe4e63a464e135000a07cd",
		"inbound": {},
		"actions": [{
			"protocol": "redis",
			"request": "ZADD myzset 0 a 0 b 0 c 0 d 0 e 0 f 0 g",
			"response": 7
		}, {
			"protocol": "redis",
			"request": "ZRANGEBYLEX myzset - [c",
			"response": ["a", "b", "c"]
		}, {
			"protocol": "redis",
			"request": "ZRANGEBYLEX myzset - (c",
			"response": ["a", "b"]
		}, {
			"protocol": "redis",
			"request": "ZRANGEBYLEX myzset [aaa (g",
			"response": ["b", "c", "d", "e", "f"]
		}]
	}`,
}

View Source

var ZRangeByScore = Case{
	Func: func(t *testing.T, ctx context.Context, c redis.Client) {

		r1, err := c.ZAdd(ctx, "myzset", 1, "one")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, int64(1))

		r2, err := c.ZAdd(ctx, "myzset", 2, "two")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r2, int64(1))

		r3, err := c.ZAdd(ctx, "myzset", 3, "three")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r3, int64(1))

		r4, err := c.ZRangeByScore(ctx, "myzset", "-inf", "+inf")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r4, []string{"one", "two", "three"})

		r5, err := c.ZRangeByScore(ctx, "myzset", "1", "2")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r5, []string{"one", "two"})

		r6, err := c.ZRangeByScore(ctx, "myzset", "(1", "2")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r6, []string{"two"})

		r7, err := c.ZRangeByScore(ctx, "myzset", "(1", "(2")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, len(r7), 0)
	},
	Data: `
	{
		"session": "df3b64266ebe4e63a464e135000a07cd",
		"inbound": {},
		"actions": [{
			"protocol": "redis",
			"request": "ZADD myzset 1 one",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "ZADD myzset 2 two",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "ZADD myzset 3 three",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "ZRANGEBYSCORE myzset -inf +inf",
			"response": ["one", "two", "three"]
		}, {
			"protocol": "redis",
			"request": "ZRANGEBYSCORE myzset 1 2",
			"response": ["one", "two"]
		}, {
			"protocol": "redis",
			"request": "ZRANGEBYSCORE myzset (1 2",
			"response": ["two"]
		}, {
			"protocol": "redis",
			"request": "ZRANGEBYSCORE myzset (1 (2",
			"response": []
		}]
	}`,
}

View Source

var ZRank = Case{
	Func: func(t *testing.T, ctx context.Context, c redis.Client) {

		r1, err := c.ZAdd(ctx, "myzset", 1, "one")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, int64(1))

		r2, err := c.ZAdd(ctx, "myzset", 2, "two")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r2, int64(1))

		r3, err := c.ZAdd(ctx, "myzset", 3, "three")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r3, int64(1))

		r4, err := c.ZRank(ctx, "myzset", "three")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r4, int64(2))

		_, err = c.ZRank(ctx, "myzset", "four")
		assert.Equal(t, err, redis.ErrNil)
	},
	Data: `
	{
		"session": "df3b64266ebe4e63a464e135000a07cd",
		"inbound": {},
		"actions": [{
			"protocol": "redis",
			"request": "ZADD myzset 1 one",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "ZADD myzset 2 two",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "ZADD myzset 3 three",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "ZRANK myzset three",
			"response": 2
		}, {
			"protocol": "redis",
			"request": "ZRANK myzset four",
			"response": "(nil)"
		}]
	}`,
}

View Source

var ZRem = Case{
	Func: func(t *testing.T, ctx context.Context, c redis.Client) {

		r1, err := c.ZAdd(ctx, "myzset", 1, "one")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, int64(1))

		r2, err := c.ZAdd(ctx, "myzset", 2, "two")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r2, int64(1))

		r3, err := c.ZAdd(ctx, "myzset", 3, "three")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r3, int64(1))

		r4, err := c.ZRem(ctx, "myzset", "two")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r4, int64(1))

		r5, err := c.ZRangeWithScores(ctx, "myzset", 0, -1)
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r5, []redis.ZItem{{"one", 1}, {"three", 3}})
	},
	Data: `
	{
		"session": "df3b64266ebe4e63a464e135000a07cd",
		"inbound": {},
		"actions": [{
			"protocol": "redis",
			"request": "ZADD myzset 1 one",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "ZADD myzset 2 two",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "ZADD myzset 3 three",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "ZREM myzset two",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "ZRANGE myzset 0 -1 WITHSCORES",
			"response": [
				["one", "1"],
				["three", "3"]
			]
		}]
	}`,
}

View Source

var ZRemRangeByLex = Case{
	Func: func(t *testing.T, ctx context.Context, c redis.Client) {

		r1, err := c.ZAdd(ctx, "myzset", 0, "aaaa", 0, "b", 0, "c", 0, "d", 0, "e")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, int64(5))

		r2, err := c.ZAdd(ctx, "myzset", 0, "foo", 0, "zap", 0, "zip", 0, "ALPHA", 0, "alpha")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r2, int64(5))

		r3, err := c.ZRange(ctx, "myzset", 0, -1)
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r3, []string{
			"ALPHA", "aaaa", "alpha", "b", "c", "d", "e", "foo", "zap", "zip",
		})

		r4, err := c.ZRemRangeByLex(ctx, "myzset", "[alpha", "[omega")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r4, int64(6))

		r5, err := c.ZRange(ctx, "myzset", 0, -1)
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r5, []string{"ALPHA", "aaaa", "zap", "zip"})
	},
	Data: `
	{
		"session": "df3b64266ebe4e63a464e135000a07cd",
		"inbound": {},
		"actions": [{
			"protocol": "redis",
			"request": "ZADD myzset 0 aaaa 0 b 0 c 0 d 0 e",
			"response": 5
		}, {
			"protocol": "redis",
			"request": "ZADD myzset 0 foo 0 zap 0 zip 0 ALPHA 0 alpha",
			"response": 5
		}, {
			"protocol": "redis",
			"request": "ZRANGE myzset 0 -1",
			"response": ["ALPHA", "aaaa", "alpha", "b", "c", "d", "e", "foo", "zap", "zip"]
		}, {
			"protocol": "redis",
			"request": "ZREMRANGEBYLEX myzset [alpha [omega",
			"response": 6
		}, {
			"protocol": "redis",
			"request": "ZRANGE myzset 0 -1",
			"response": ["ALPHA", "aaaa", "zap", "zip"]
		}]
	}`,
}

View Source

var ZRemRangeByRank = Case{
	Func: func(t *testing.T, ctx context.Context, c redis.Client) {

		r1, err := c.ZAdd(ctx, "myzset", 1, "one")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, int64(1))

		r2, err := c.ZAdd(ctx, "myzset", 2, "two")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r2, int64(1))

		r3, err := c.ZAdd(ctx, "myzset", 3, "three")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r3, int64(1))

		r4, err := c.ZRemRangeByRank(ctx, "myzset", 0, 1)
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r4, int64(2))

		r5, err := c.ZRangeWithScores(ctx, "myzset", 0, -1)
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r5, []redis.ZItem{{"three", 3}})
	},
	Data: `
	{
		"session": "df3b64266ebe4e63a464e135000a07cd",
		"inbound": {},
		"actions": [{
			"protocol": "redis",
			"request": "ZADD myzset 1 one",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "ZADD myzset 2 two",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "ZADD myzset 3 three",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "ZREMRANGEBYRANK myzset 0 1",
			"response": 2
		}, {
			"protocol": "redis",
			"request": "ZRANGE myzset 0 -1 WITHSCORES",
			"response": [
				["three", "3"]
			]
		}]
	}`,
}

View Source

var ZRemRangeByScore = Case{
	Func: func(t *testing.T, ctx context.Context, c redis.Client) {

		r1, err := c.ZAdd(ctx, "myzset", 1, "one")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, int64(1))

		r2, err := c.ZAdd(ctx, "myzset", 2, "two")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r2, int64(1))

		r3, err := c.ZAdd(ctx, "myzset", 3, "three")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r3, int64(1))

		r4, err := c.ZRemRangeByScore(ctx, "myzset", "-inf", "(2")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r4, int64(1))

		r5, err := c.ZRangeWithScores(ctx, "myzset", 0, -1)
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r5, []redis.ZItem{{"two", 2}, {"three", 3}})
	},
	Data: `
	{
		"session": "df3b64266ebe4e63a464e135000a07cd",
		"inbound": {},
		"actions": [{
			"protocol": "redis",
			"request": "ZADD myzset 1 one",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "ZADD myzset 2 two",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "ZADD myzset 3 three",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "ZREMRANGEBYSCORE myzset -inf (2",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "ZRANGE myzset 0 -1 WITHSCORES",
			"response": [
				["two", "2"],
				["three", "3"]
			]
		}]
	}`,
}

View Source

var ZRevRange = Case{
	Func: func(t *testing.T, ctx context.Context, c redis.Client) {

		r1, err := c.ZAdd(ctx, "myzset", 1, "one")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, int64(1))

		r2, err := c.ZAdd(ctx, "myzset", 2, "two")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r2, int64(1))

		r3, err := c.ZAdd(ctx, "myzset", 3, "three")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r3, int64(1))

		r4, err := c.ZRevRange(ctx, "myzset", 0, -1)
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r4, []string{"three", "two", "one"})

		r5, err := c.ZRevRange(ctx, "myzset", 2, 3)
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r5, []string{"one"})

		r6, err := c.ZRevRange(ctx, "myzset", -2, -1)
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r6, []string{"two", "one"})
	},
	Data: `
	{
		"session": "df3b64266ebe4e63a464e135000a07cd",
		"inbound": {},
		"actions": [{
			"protocol": "redis",
			"request": "ZADD myzset 1 one",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "ZADD myzset 2 two",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "ZADD myzset 3 three",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "ZREVRANGE myzset 0 -1",
			"response": ["three", "two", "one"]
		}, {
			"protocol": "redis",
			"request": "ZREVRANGE myzset 2 3",
			"response": ["one"]
		}, {
			"protocol": "redis",
			"request": "ZREVRANGE myzset -2 -1",
			"response": ["two", "one"]
		}]
	}`,
}

View Source

var ZRevRangeByLex = Case{
	Func: func(t *testing.T, ctx context.Context, c redis.Client) {

		r1, err := c.ZAdd(ctx, "myzset", 0, "a", 0, "b", 0, "c", 0, "d", 0, "e", 0, "f", 0, "g")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, int64(7))

		r2, err := c.ZRevRangeByLex(ctx, "myzset", "[c", "-")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r2, []string{"c", "b", "a"})

		r3, err := c.ZRevRangeByLex(ctx, "myzset", "(c", "-")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r3, []string{"b", "a"})

		r4, err := c.ZRevRangeByLex(ctx, "myzset", "(g", "[aaa")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r4, []string{"f", "e", "d", "c", "b"})
	},
	Data: `
	{
		"session": "df3b64266ebe4e63a464e135000a07cd",
		"inbound": {},
		"actions": [{
			"protocol": "redis",
			"request": "ZADD myzset 0 a 0 b 0 c 0 d 0 e 0 f 0 g",
			"response": 7
		}, {
			"protocol": "redis",
			"request": "ZREVRANGEBYLEX myzset [c -",
			"response": ["c", "b", "a"]
		}, {
			"protocol": "redis",
			"request": "ZREVRANGEBYLEX myzset (c -",
			"response": ["b", "a"]
		}, {
			"protocol": "redis",
			"request": "ZREVRANGEBYLEX myzset (g [aaa",
			"response": ["f", "e", "d", "c", "b"]
		}]
	}`,
}

View Source

var ZRevRangeByScore = Case{
	Func: func(t *testing.T, ctx context.Context, c redis.Client) {

		r1, err := c.ZAdd(ctx, "myzset", 1, "one")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, int64(1))

		r2, err := c.ZAdd(ctx, "myzset", 2, "two")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r2, int64(1))

		r3, err := c.ZAdd(ctx, "myzset", 3, "three")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r3, int64(1))

		r4, err := c.ZRevRangeByScore(ctx, "myzset", "+inf", "-inf")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r4, []string{"three", "two", "one"})

		r5, err := c.ZRevRangeByScore(ctx, "myzset", "2", "1")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r5, []string{"two", "one"})

		r6, err := c.ZRevRangeByScore(ctx, "myzset", "2", "(1")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r6, []string{"two"})

		r7, err := c.ZRevRangeByScore(ctx, "myzset", "(2", "(1")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, len(r7), 0)
	},
	Data: `
	{
		"session": "df3b64266ebe4e63a464e135000a07cd",
		"inbound": {},
		"actions": [{
			"protocol": "redis",
			"request": "ZADD myzset 1 one",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "ZADD myzset 2 two",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "ZADD myzset 3 three",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "ZREVRANGEBYSCORE myzset +inf -inf",
			"response": ["three", "two", "one"]
		}, {
			"protocol": "redis",
			"request": "ZREVRANGEBYSCORE myzset 2 1",
			"response": ["two", "one"]
		}, {
			"protocol": "redis",
			"request": "ZREVRANGEBYSCORE myzset 2 (1",
			"response": ["two"]
		}, {
			"protocol": "redis",
			"request": "ZREVRANGEBYSCORE myzset (2 (1",
			"response": []
		}]
	}`,
}

View Source

var ZRevRank = Case{
	Func: func(t *testing.T, ctx context.Context, c redis.Client) {

		r1, err := c.ZAdd(ctx, "myzset", 1, "one")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, int64(1))

		r2, err := c.ZAdd(ctx, "myzset", 2, "two")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r2, int64(1))

		r3, err := c.ZAdd(ctx, "myzset", 3, "three")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r3, int64(1))

		r4, err := c.ZRevRank(ctx, "myzset", "one")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r4, int64(2))

		_, err = c.ZRevRank(ctx, "myzset", "four")
		assert.Equal(t, err, redis.ErrNil)
	},
	Data: `
	{
		"session": "df3b64266ebe4e63a464e135000a07cd",
		"inbound": {},
		"actions": [{
			"protocol": "redis",
			"request": "ZADD myzset 1 one",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "ZADD myzset 2 two",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "ZADD myzset 3 three",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "ZREVRANK myzset one",
			"response": 2
		}, {
			"protocol": "redis",
			"request": "ZREVRANK myzset four",
			"response": "(nil)"
		}]
	}`,
}

View Source

var ZScore = Case{
	Func: func(t *testing.T, ctx context.Context, c redis.Client) {

		r1, err := c.ZAdd(ctx, "myzset", 1, "one")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, int64(1))

		r2, err := c.ZScore(ctx, "myzset", "one")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r2, float64(1))
	},
	Data: `
	{
		"session": "df3b64266ebe4e63a464e135000a07cd",
		"inbound": {},
		"actions": [{
			"protocol": "redis",
			"request": "ZADD myzset 1 one",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "ZSCORE myzset one",
			"response": "1"
		}]
	}`,
}

View Source

var ZUnion = Case{
	Func: func(t *testing.T, ctx context.Context, c redis.Client) {

		r1, err := c.ZAdd(ctx, "zset1", 1, "one")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, int64(1))

		r2, err := c.ZAdd(ctx, "zset1", 2, "two")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r2, int64(1))

		r3, err := c.ZAdd(ctx, "zset2", 1, "one")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r3, int64(1))

		r4, err := c.ZAdd(ctx, "zset2", 2, "two")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r4, int64(1))

		r5, err := c.ZAdd(ctx, "zset2", 3, "three")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r5, int64(1))

		r6, err := c.ZUnion(ctx, 2, "zset1", "zset2")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r6, []string{"one", "three", "two"})

		r7, err := c.ZUnionWithScores(ctx, 2, "zset1", "zset2")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r7, []redis.ZItem{{"one", 2}, {"three", 3}, {"two", 4}})
	},
	Data: `
	{
		"session": "df3b64266ebe4e63a464e135000a07cd",
		"inbound": {},
		"actions": [{
			"protocol": "redis",
			"request": "ZADD zset1 1 one",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "ZADD zset1 2 two",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "ZADD zset2 1 one",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "ZADD zset2 2 two",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "ZADD zset2 3 three",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "ZUNION 2 zset1 zset2",
			"response": ["one", "three", "two"]
		}, {
			"protocol": "redis",
			"request": "ZUNION 2 zset1 zset2 WITHSCORES",
			"response": [
				["one", "2"],
				["three", "3"],
				["two", "4"]
			]
		}]
	}`,
}

View Source

var ZUnionStore = Case{
	Func: func(t *testing.T, ctx context.Context, c redis.Client) {

		r1, err := c.ZAdd(ctx, "zset1", 1, "one")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, int64(1))

		r2, err := c.ZAdd(ctx, "zset1", 2, "two")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r2, int64(1))

		r3, err := c.ZAdd(ctx, "zset2", 1, "one")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r3, int64(1))

		r4, err := c.ZAdd(ctx, "zset2", 2, "two")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r4, int64(1))

		r5, err := c.ZAdd(ctx, "zset2", 3, "three")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r5, int64(1))

		r6, err := c.ZUnionStore(ctx, "out", 2, "zset1", "zset2", "WEIGHTS", 2, 3)
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r6, int64(3))

		r7, err := c.ZRangeWithScores(ctx, "out", 0, -1)
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r7, []redis.ZItem{{"one", 5}, {"three", 9}, {"two", 10}})
	},
	Data: `
	{
		"session": "df3b64266ebe4e63a464e135000a07cd",
		"inbound": {},
		"actions": [{
			"protocol": "redis",
			"request": "ZADD zset1 1 one",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "ZADD zset1 2 two",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "ZADD zset2 1 one",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "ZADD zset2 2 two",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "ZADD zset2 3 three",
			"response": 1
		}, {
			"protocol": "redis",
			"request": "ZUNIONSTORE out 2 zset1 zset2 WEIGHTS 2 3",
			"response": 3
		}, {
			"protocol": "redis",
			"request": "ZRANGE out 0 -1 WITHSCORES",
			"response": [
				["one", "5"],
				["three", "9"],
				["two", "10"]
			]
		}]
	}`,
}

Functions ¶

This section is empty.

Types ¶

type Case ¶

type Case struct {
	Func func(t *testing.T, ctx context.Context, c redis.Client)
	Data string
}

Source Files ¶

View all Source files

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL