cases

package

v1.1.0 Latest Latest Go to latest Published: Jul 23, 2022 License: Apache-2.0 Imports: 5 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.OpsForKey().Exists(ctx, "mykey")
		if err != nil {
			t.Fatal()
		}
		assert.Equal(t, r1, int64(0))

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

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

		r4, err := c.OpsForString().Get(ctx, "mykey")
		if err != nil {
			t.Fatal()
		}
		assert.Equal(t, r4, "Hello World")
	},
	Data: `
	{
		"Session": "df3b64266ebe4e63a464e135000a07cd",
		"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.OpsForString().Set(ctx, "mykey", "foobar")
		if err != nil {
			t.Fatal(err)
		}
		assert.True(t, redis.IsOK(r1))

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

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

		r4, err := c.OpsForBitmap().BitCount(ctx, "mykey", 1, 1)
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r4, int64(6))
	},
	Data: `{
	  "Session": "df3b64266ebe4e63a464e135000a07cd",
	  "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.OpsForString().Set(ctx, "key1", "foobar")
		if err != nil {
			t.Fatal(err)
		}
		assert.True(t, redis.IsOK(r1))

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

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

		r4, err := c.OpsForString().Get(ctx, "dest")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r4, "`bc`ab")
	},
	Data: `{
	  "Session": "df3b64266ebe4e63a464e135000a07cd",
	  "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.OpsForString().Set(ctx, "mykey", "\xff\xf0\x00")
		if err != nil {
			t.Fatal(err)
		}
		assert.True(t, redis.IsOK(r1))

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

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

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

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

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

		r7, err := c.OpsForBitmap().BitPos(ctx, "mykey", 1)
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r7, int64(-1))
	},
	Data: `
	{
		"Session": "df3b64266ebe4e63a464e135000a07cd",
		"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.OpsForString().Set(ctx, "mykey", "10")
		if err != nil {
			t.Fatal(err)
		}
		assert.True(t, redis.IsOK(r1))

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

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

		_, err = c.OpsForString().Decr(ctx, "mykey")
		assert.Error(t, err, "ERR value is not an integer or out of range")
	},
	Data: `
	{
		"Session": "df3b64266ebe4e63a464e135000a07cd",
		"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.OpsForString().Set(ctx, "mykey", "10")
		if err != nil {
			t.Fatal(err)
		}
		assert.True(t, redis.IsOK(r1))

		r2, err := c.OpsForString().DecrBy(ctx, "mykey", 3)
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r2, int64(7))
	},
	Data: `
	{
		"Session": "df3b64266ebe4e63a464e135000a07cd",
		"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.OpsForString().Set(ctx, "key1", "Hello")
		if err != nil {
			t.Fatal(err)
		}
		assert.True(t, redis.IsOK(r1))

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

		r3, err := c.OpsForKey().Del(ctx, "key1", "key2", "key3")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r3, int64(2))
	},
	Data: `
	{
		"Session": "df3b64266ebe4e63a464e135000a07cd",
		"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.OpsForString().Set(ctx, "mykey", 10)
		if err != nil {
			t.Fatal(err)
		}
		assert.True(t, redis.IsOK(r1))

		r2, err := c.OpsForKey().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",
		"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.OpsForString().Set(ctx, "key1", "Hello")
		if err != nil {
			t.Fatal(err)
		}
		assert.True(t, redis.IsOK(r1))

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

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

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

		r5, err := c.OpsForKey().Exists(ctx, "key1", "key2", "nosuchkey")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r5, int64(2))
	},
	Data: `
	{
		"Session": "df3b64266ebe4e63a464e135000a07cd",
		"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.OpsForString().Set(ctx, "mykey", "Hello")
		if err != nil {
			t.Fatal(err)
		}
		assert.True(t, redis.IsOK(r1))

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

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

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

		r5, err := c.OpsForKey().TTL(ctx, "mykey")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r5, int64(-1))
	},
	Data: `
	{
		"Session": "df3b64266ebe4e63a464e135000a07cd",
		"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.OpsForString().Set(ctx, "mykey", "Hello")
		if err != nil {
			t.Fatal(err)
		}
		assert.True(t, redis.IsOK(r1))

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

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

		r4, err := c.OpsForKey().Exists(ctx, "mykey")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r4, int64(0))
	},
	Data: `
	{
		"Session": "df3b64266ebe4e63a464e135000a07cd",
		"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.OpsForString().Get(ctx, "nonexisting")
		assert.True(t, redis.IsErrNil(err))

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

		r3, err := c.OpsForString().Get(ctx, "mykey")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r3, "Hello")
	},
	Data: `
	{
		"Session": "df3b64266ebe4e63a464e135000a07cd",
		"Actions": [{
			"Protocol": "REDIS",
			"Request": "GET nonexisting",
			"Response": "NULL"
		}, {
			"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.OpsForBitmap().SetBit(ctx, "mykey", 7, 1)
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, int64(0))

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

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

		r4, err := c.OpsForBitmap().GetBit(ctx, "mykey", 100)
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r4, int64(0))
	},
	Data: `
	{
		"Session": "df3b64266ebe4e63a464e135000a07cd",
		"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.OpsForString().Set(ctx, "mykey", "Hello")
		if err != nil {
			t.Fatal(err)
		}
		assert.True(t, redis.IsOK(r1))

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

		_, err = c.OpsForString().Get(ctx, "mykey")
		assert.True(t, redis.IsErrNil(err))
	},
	Data: `
	{
		"Session": "df3b64266ebe4e63a464e135000a07cd",
		"Actions": [{
			"Protocol": "REDIS",
			"Request": "SET mykey Hello",
			"Response": "\"OK\""
		}, {
			"Protocol": "REDIS",
			"Request": "GETDEL mykey",
			"Response": "\"Hello\""
		}, {
			"Protocol": "REDIS",
			"Request": "GET mykey",
			"Response": "NULL"
		}]
	}`,
}

View Source

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

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

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

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

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

		r5, err := c.OpsForString().GetRange(ctx, "mykey", 10, 100)
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r5, "string")
	},
	Data: `
	{
		"Session": "df3b64266ebe4e63a464e135000a07cd",
		"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.OpsForString().Incr(ctx, "mycounter")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, int64(1))

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

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

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

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

		r6, err := c.OpsForString().Get(ctx, "mykey")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r6, "World")
	},
	Data: `
	{
		"Session": "df3b64266ebe4e63a464e135000a07cd",
		"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.OpsForHash().HSet(ctx, "myhash", "field1", "foo")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, int64(1))

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

		r3, err := c.OpsForHash().HDel(ctx, "myhash", "field2")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r3, int64(0))
	},
	Data: `
	{
		"Session": "df3b64266ebe4e63a464e135000a07cd",
		"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.OpsForHash().HSet(ctx, "myhash", "field1", "foo")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, int64(1))

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

		r3, err := c.OpsForHash().HExists(ctx, "myhash", "field2")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r3, int64(0))
	},
	Data: `
	{
		"Session": "df3b64266ebe4e63a464e135000a07cd",
		"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.OpsForHash().HSet(ctx, "myhash", "field1", "foo")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, int64(1))

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

		_, err = c.OpsForHash().HGet(ctx, "myhash", "field2")
		assert.True(t, redis.IsErrNil(err))
	},
	Data: `
	{
		"Session": "df3b64266ebe4e63a464e135000a07cd",
		"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": "NULL"
		}]
	}`,
}

View Source

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

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

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

		r3, err := c.OpsForHash().HGetAll(ctx, "myhash")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r3, map[string]string{
			"field1": "Hello",
			"field2": "World",
		})
	},
	Data: `
	{
		"Session": "df3b64266ebe4e63a464e135000a07cd",
		"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.OpsForHash().HSet(ctx, "myhash", "field", 5)
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, int64(1))

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

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

		r4, err := c.OpsForHash().HIncrBy(ctx, "myhash", "field", -10)
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r4, int64(-5))
	},
	Data: `
	{
		"Session": "df3b64266ebe4e63a464e135000a07cd",
		"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.OpsForHash().HSet(ctx, "mykey", "field", 10.50)
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, int64(1))

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

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

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

		r5, err := c.OpsForHash().HIncrByFloat(ctx, "mykey", "field", 2.0e2)
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r5, float64(5200))
	},
	Data: `
	{
		"Session": "df3b64266ebe4e63a464e135000a07cd",
		"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.OpsForHash().HSet(ctx, "myhash", "field1", "Hello")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, int64(1))

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

		r3, err := c.OpsForHash().HKeys(ctx, "myhash")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r3, []string{"field1", "field2"})
	},
	Data: `
	{
		"Session": "df3b64266ebe4e63a464e135000a07cd",
		"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.OpsForHash().HSet(ctx, "myhash", "field1", "Hello")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, int64(1))

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

		r3, err := c.OpsForHash().HLen(ctx, "myhash")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r3, int64(2))
	},
	Data: `
	{
		"Session": "df3b64266ebe4e63a464e135000a07cd",
		"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.OpsForHash().HSet(ctx, "myhash", "field1", "Hello")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, int64(1))

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

		r3, err := c.OpsForHash().HMGet(ctx, "myhash", "field1", "field2", "nofield")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r3, []interface{}{"Hello", "World", nil})
	},
	Data: `
	{
		"Session": "df3b64266ebe4e63a464e135000a07cd",
		"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.OpsForHash().HSet(ctx, "myhash", "field1", "Hello")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, int64(1))

		r2, err := c.OpsForHash().HGet(ctx, "myhash", "field1")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r2, "Hello")
	},
	Data: `
	{
		"Session": "df3b64266ebe4e63a464e135000a07cd",
		"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.OpsForHash().HSetNX(ctx, "myhash", "field", "Hello")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, int64(1))

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

		r3, err := c.OpsForHash().HGet(ctx, "myhash", "field")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r3, "Hello")
	},
	Data: `
	{
		"Session": "df3b64266ebe4e63a464e135000a07cd",
		"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.OpsForHash().HSet(ctx, "myhash", "f1", "HelloWorld", "f2", 99, "f3", -256)
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, int64(3))

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

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

		r4, err := c.OpsForHash().HStrLen(ctx, "myhash", "f3")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r4, int64(4))
	},
	Data: `
	{
		"Session": "df3b64266ebe4e63a464e135000a07cd",
		"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.OpsForHash().HSet(ctx, "myhash", "field1", "Hello")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, int64(1))

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

		r3, err := c.OpsForHash().HVals(ctx, "myhash")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r3, []string{"Hello", "World"})
	},
	Data: `
	{
		"Session": "df3b64266ebe4e63a464e135000a07cd",
		"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.OpsForString().Set(ctx, "mykey", "10")
		if err != nil {
			t.Fatal(err)
		}
		assert.True(t, redis.IsOK(r1))

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

		r3, err := c.OpsForString().Get(ctx, "mykey")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r3, "11")
	},
	Data: `
	{
		"Session": "df3b64266ebe4e63a464e135000a07cd",
		"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.OpsForString().Set(ctx, "mykey", "10")
		if err != nil {
			t.Fatal(err)
		}
		assert.True(t, redis.IsOK(r1))

		r2, err := c.OpsForString().IncrBy(ctx, "mykey", 5)
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r2, int64(15))
	},
	Data: `
	{
		"Session": "df3b64266ebe4e63a464e135000a07cd",
		"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.OpsForString().Set(ctx, "mykey", 10.50)
		if err != nil {
			t.Fatal(err)
		}
		assert.True(t, redis.IsOK(r1))

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

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

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

		r5, err := c.OpsForString().IncrByFloat(ctx, "mykey", 2.0e2)
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r5, float64(5200))
	},
	Data: `
	{
		"Session": "df3b64266ebe4e63a464e135000a07cd",
		"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.OpsForString().MSet(ctx, "firstname", "Jack", "lastname", "Stuntman", "age", 35)
		if err != nil {
			t.Fatal(err)
		}
		assert.True(t, redis.IsOK(r1))

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

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

		r4, err := c.OpsForKey().Keys(ctx, "*")
		if err != nil {
			t.Fatal(err)
		}
		sort.Strings(r4)
		assert.Equal(t, r4, []string{"age", "firstname", "lastname"})
	},
	Skip: true,
	Data: `
	{
		"Session": "df3b64266ebe4e63a464e135000a07cd",
		"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.OpsForList().LPush(ctx, "mylist", "World")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, int64(1))

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

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

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

		_, err = c.OpsForList().LIndex(ctx, "mylist", 3)
		assert.True(t, redis.IsErrNil(err))
	},
	Data: `
	{
		"Session": "df3b64266ebe4e63a464e135000a07cd",
		"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": "NULL"
		}]
	}`,
}

View Source

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

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

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

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

		r4, err := c.OpsForList().LRange(ctx, "mylist", 0, -1)
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r4, []string{"Hello", "There", "World"})
	},
	Data: `
	{
		"Session": "df3b64266ebe4e63a464e135000a07cd",
		"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.OpsForList().LPush(ctx, "mylist", "World")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, int64(1))

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

		r3, err := c.OpsForList().LLen(ctx, "mylist")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r3, int64(2))
	},
	Data: `
	{
		"Session": "df3b64266ebe4e63a464e135000a07cd",
		"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.OpsForList().RPush(ctx, "mylist", "one")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, int64(1))

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

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

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

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

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

		r7, err := c.OpsForList().LRange(ctx, "myotherlist", 0, -1)
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r7, []string{"three", "one"})
	},
	Data: `
	{
		"Session": "df3b64266ebe4e63a464e135000a07cd",
		"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.OpsForList().RPush(ctx, "mylist", "one", "two", "three", "four", "five")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, int64(5))

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

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

		r4, err := c.OpsForList().LRange(ctx, "mylist", 0, -1)
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r4, []string{"four", "five"})
	},
	Data: `
	{
		"Session": "df3b64266ebe4e63a464e135000a07cd",
		"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.OpsForList().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.OpsForList().LPos(ctx, "mylist", 3)
		if err != nil {
			return
		}
		assert.Equal(t, r2, int64(6))

		r3, err := c.OpsForList().LPosN(ctx, "mylist", "3", 0, "RANK", 2)
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r3, []int64{8, 9, 10})
	},
	Data: `
	{
		"Session": "df3b64266ebe4e63a464e135000a07cd",
		"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.OpsForList().LPush(ctx, "mylist", "world")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, int64(1))

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

		r3, err := c.OpsForList().LRange(ctx, "mylist", 0, -1)
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r3, []string{"hello", "world"})
	},
	Data: `
	{
		"Session": "df3b64266ebe4e63a464e135000a07cd",
		"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.OpsForList().LPush(ctx, "mylist", "World")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, int64(1))

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

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

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

		r5, err := c.OpsForList().LRange(ctx, "myotherlist", 0, -1)
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r5, []string{})
	},
	Data: `
	{
		"Session": "df3b64266ebe4e63a464e135000a07cd",
		"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.OpsForList().RPush(ctx, "mylist", "one")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, int64(1))

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

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

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

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

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

		r7, err := c.OpsForList().LRange(ctx, "mylist", 5, 10)
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r7, []string{})
	},
	Data: `
	{
		"Session": "df3b64266ebe4e63a464e135000a07cd",
		"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.OpsForList().RPush(ctx, "mylist", "hello")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, int64(1))

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

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

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

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

		r6, err := c.OpsForList().LRange(ctx, "mylist", 0, -1)
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r6, []string{"hello", "foo"})
	},
	Data: `
	{
		"Session": "df3b64266ebe4e63a464e135000a07cd",
		"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.OpsForList().RPush(ctx, "mylist", "one")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, int64(1))

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

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

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

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

		r6, err := c.OpsForList().LRange(ctx, "mylist", 0, -1)
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r6, []string{"four", "five", "three"})
	},
	Data: `
	{
		"Session": "df3b64266ebe4e63a464e135000a07cd",
		"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.OpsForList().RPush(ctx, "mylist", "one")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, int64(1))

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

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

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

		r5, err := c.OpsForList().LRange(ctx, "mylist", 0, -1)
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r5, []string{"two", "three"})
	},
	Data: `
	{
		"Session": "df3b64266ebe4e63a464e135000a07cd",
		"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.OpsForString().Set(ctx, "key1", "Hello")
		if err != nil {
			t.Fatal(err)
		}
		assert.True(t, redis.IsOK(r1))

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

		r3, err := c.OpsForString().MGet(ctx, "key1", "key2", "nonexisting")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r3, []interface{}{"Hello", "World", nil})
	},
	Data: `
	{
		"Session": "df3b64266ebe4e63a464e135000a07cd",
		"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.OpsForString().MSet(ctx, "key1", "Hello", "key2", "World")
		if err != nil {
			t.Fatal(err)
		}
		assert.True(t, redis.IsOK(r1))

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

		r3, err := c.OpsForString().Get(ctx, "key2")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r3, "World")
	},
	Data: `
	{
		"Session": "df3b64266ebe4e63a464e135000a07cd",
		"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.OpsForString().MSetNX(ctx, "key1", "Hello", "key2", "there")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, int64(1))

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

		r3, err := c.OpsForString().MGet(ctx, "key1", "key2", "key3")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r3, []interface{}{"Hello", "there", nil})
	},
	Data: `
	{
		"Session": "df3b64266ebe4e63a464e135000a07cd",
		"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.OpsForString().Set(ctx, "mykey", "Hello")
		if err != nil {
			t.Fatal(err)
		}
		assert.True(t, redis.IsOK(r1))

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

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

		r4, err := c.OpsForKey().PTTL(ctx, "mykey")
		if err != nil {
			t.Fatal(err)
		}
		assert.True(t, r4 >= 1400 && r4 <= 1500)
	},
	Data: `
	{
		"Session": "df3b64266ebe4e63a464e135000a07cd",
		"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.OpsForString().Set(ctx, "mykey", "Hello")
		if err != nil {
			t.Fatal(err)
		}
		assert.True(t, redis.IsOK(r1))

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

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

		r4, err := c.OpsForKey().PTTL(ctx, "mykey")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r4, int64(-2))
	},
	Data: `
	{
		"Session": "df3b64266ebe4e63a464e135000a07cd",
		"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.OpsForString().PSetEX(ctx, "mykey", "Hello", 1000)
		if err != nil {
			t.Fatal(err)
		}
		assert.True(t, redis.IsOK(r1))

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

		r3, err := c.OpsForString().Get(ctx, "mykey")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r3, "Hello")
	},
	Data: `
	{
		"Session": "df3b64266ebe4e63a464e135000a07cd",
		"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.OpsForString().Set(ctx, "mykey", "Hello")
		if err != nil {
			t.Fatal(err)
		}
		assert.True(t, redis.IsOK(r1))

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

		r3, err := c.OpsForKey().PTTL(ctx, "mykey")
		if err != nil {
			t.Fatal(err)
		}
		assert.True(t, r3 >= 990 && r3 <= 1000)
	},
	Data: `
	{
		"Session": "df3b64266ebe4e63a464e135000a07cd",
		"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.OpsForString().Set(ctx, "mykey", "Hello")
		if err != nil {
			t.Fatal(err)
		}
		assert.True(t, redis.IsOK(r1))

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

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

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

		r5, err := c.OpsForKey().TTL(ctx, "mykey")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r5, int64(-1))
	},
	Data: `
	{
		"Session": "df3b64266ebe4e63a464e135000a07cd",
		"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.OpsForList().RPush(ctx, "mylist", "one", "two", "three", "four", "five")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, int64(5))

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

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

		r4, err := c.OpsForList().LRange(ctx, "mylist", 0, -1)
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r4, []string{"one", "two"})
	},
	Data: `
	{
		"Session": "df3b64266ebe4e63a464e135000a07cd",
		"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.OpsForList().RPush(ctx, "mylist", "one")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, int64(1))

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

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

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

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

		r6, err := c.OpsForList().LRange(ctx, "myotherlist", 0, -1)
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r6, []string{"three"})
	},
	Data: `
	{
		"Session": "df3b64266ebe4e63a464e135000a07cd",
		"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.OpsForList().RPush(ctx, "mylist", "hello")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, int64(1))

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

		r3, err := c.OpsForList().LRange(ctx, "mylist", 0, -1)
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r3, []string{"hello", "world"})
	},
	Data: `
	{
		"Session": "df3b64266ebe4e63a464e135000a07cd",
		"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.OpsForList().RPush(ctx, "mylist", "Hello")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, int64(1))

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

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

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

		r5, err := c.OpsForList().LRange(ctx, "myotherlist", 0, -1)
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r5, []string{})
	},
	Data: `
	{
		"Session": "df3b64266ebe4e63a464e135000a07cd",
		"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.OpsForString().Set(ctx, "mykey", "Hello")
		if err != nil {
			t.Fatal(err)
		}
		assert.True(t, redis.IsOK(r1))

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

		r3, err := c.OpsForString().Get(ctx, "myotherkey")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r3, "Hello")
	},
	Data: `
	{
		"Session": "df3b64266ebe4e63a464e135000a07cd",
		"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.OpsForString().Set(ctx, "mykey", "Hello")
		if err != nil {
			t.Fatal(err)
		}
		assert.True(t, redis.IsOK(r1))

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

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

		r4, err := c.OpsForString().Get(ctx, "myotherkey")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r4, "World")
	},
	Data: `
	{
		"Session": "df3b64266ebe4e63a464e135000a07cd",
		"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.OpsForSet().SAdd(ctx, "myset", "Hello")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, int64(1))

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

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

		r4, err := c.OpsForSet().SMembers(ctx, "myset")
		if err != nil {
			t.Fatal(err)
		}
		sort.Strings(r4)
		assert.Equal(t, r4, []string{"Hello", "World"})
	},
	Skip: true,
	Data: `
	{
		"Session": "df3b64266ebe4e63a464e135000a07cd",
		"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.OpsForSet().SAdd(ctx, "myset", "Hello")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, int64(1))

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

		r3, err := c.OpsForSet().SCard(ctx, "myset")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r3, int64(2))
	},
	Data: `
	{
		"Session": "df3b64266ebe4e63a464e135000a07cd",
		"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.OpsForSet().SAdd(ctx, "key1", "a")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, int64(1))

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

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

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

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

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

		r7, err := c.OpsForSet().SDiff(ctx, "key1", "key2")
		if err != nil {
			t.Fatal(err)
		}
		sort.Strings(r7)
		assert.Equal(t, r7, []string{"a", "b"})
	},
	Skip: true,
	Data: `
	{
		"Session": "df3b64266ebe4e63a464e135000a07cd",
		"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.OpsForSet().SAdd(ctx, "key1", "a")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, int64(1))

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

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

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

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

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

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

		r8, err := c.OpsForSet().SMembers(ctx, "key")
		if err != nil {
			t.Fatal(err)
		}
		sort.Strings(r8)
		assert.Equal(t, r8, []string{"a", "b"})
	},
	Skip: true,
	Data: `
	{
		"Session": "df3b64266ebe4e63a464e135000a07cd",
		"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.OpsForSet().SAdd(ctx, "key1", "a")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, int64(1))

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

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

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

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

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

		r7, err := c.OpsForSet().SInter(ctx, "key1", "key2")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r7, []string{"c"})
	},
	Data: `
	{
		"Session": "df3b64266ebe4e63a464e135000a07cd",
		"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.OpsForSet().SAdd(ctx, "key1", "a")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, int64(1))

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

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

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

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

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

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

		r8, err := c.OpsForSet().SMembers(ctx, "key")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r8, []string{"c"})
	},
	Data: `
	{
		"Session": "df3b64266ebe4e63a464e135000a07cd",
		"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.OpsForSet().SAdd(ctx, "myset", "one")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, int64(1))

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

		r3, err := c.OpsForSet().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.OpsForSet().SAdd(ctx, "myset", "one")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, int64(1))

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

		r3, err := c.OpsForSet().SMIsMember(ctx, "myset", "one", "notamember")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r3, []int64{int64(1), int64(0)})
	},
	Data: `
	{
		"Session": "df3b64266ebe4e63a464e135000a07cd",
		"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.OpsForSet().SAdd(ctx, "myset", "Hello")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, int64(1))

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

		r3, err := c.OpsForSet().SMembers(ctx, "myset")
		if err != nil {
			t.Fatal(err)
		}
		sort.Strings(r3)
		assert.Equal(t, r3, []string{"Hello", "World"})
	},
	Skip: true,
	Data: `
	{
		"Session": "df3b64266ebe4e63a464e135000a07cd",
		"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.OpsForSet().SAdd(ctx, "myset", "one")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, int64(1))

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

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

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

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

		r6, err := c.OpsForSet().SMembers(ctx, "myotherset")
		if err != nil {
			t.Fatal(err)
		}
		sort.Strings(r6)
		assert.Equal(t, r6, []string{"three", "two"})
	},
	Skip: true,
	Data: `
	{
		"Session": "df3b64266ebe4e63a464e135000a07cd",
		"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": "\"two\",\"three\""
		}]
	}`,
}

View Source

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

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

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

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

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

		r5, err := c.OpsForSet().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",
		"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.OpsForSet().SAdd(ctx, "myset", "one", "two", "three")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, int64(3))

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

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

		r4, err := c.OpsForSet().SRandMemberN(ctx, "myset", -5)
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, len(r4), 5)
	},
	Data: `
	{
		"Session": "df3b64266ebe4e63a464e135000a07cd",
		"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.OpsForSet().SAdd(ctx, "myset", "one")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, int64(1))

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

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

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

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

		r6, err := c.OpsForSet().SMembers(ctx, "myset")
		if err != nil {
			t.Fatal(err)
		}
		sort.Strings(r6)
		assert.Equal(t, r6, []string{"three", "two"})
	},
	Data: `
	{
		"Session": "df3b64266ebe4e63a464e135000a07cd",
		"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.OpsForSet().SAdd(ctx, "key1", "a")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, int64(1))

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

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

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

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

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

		r7, err := c.OpsForSet().SUnion(ctx, "key1", "key2")
		if err != nil {
			t.Fatal(err)
		}
		sort.Strings(r7)
		assert.Equal(t, r7, []string{"a", "b", "c", "d", "e"})
	},
	Skip: true,
	Data: `
	{
		"Session": "df3b64266ebe4e63a464e135000a07cd",
		"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\",\"d\",\"e\""
		}]
	}`,
}

View Source

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

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

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

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

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

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

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

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

		r8, err := c.OpsForSet().SMembers(ctx, "key")
		if err != nil {
			t.Fatal(err)
		}
		sort.Strings(r8)
		assert.Equal(t, r8, []string{"a", "b", "c", "d", "e"})
	},
	Skip: true,
	Data: `
	{
		"Session": "df3b64266ebe4e63a464e135000a07cd",
		"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\",\"d\",\"e\""
		}]
	}`,
}

View Source

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

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

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

		r3, err := c.OpsForString().SetEX(ctx, "anotherkey", "will expire in a minute", 60)
		if err != nil {
			t.Fatal(err)
		}
		assert.True(t, redis.IsOK(r3))
	},
	Data: `
	{
		"Session": "df3b64266ebe4e63a464e135000a07cd",
		"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.OpsForBitmap().SetBit(ctx, "mykey", 7, 1)
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, int64(0))

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

		r3, err := c.OpsForString().Get(ctx, "mykey")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r3, "\u0000")
	},
	Data: `
	{
		"Session": "df3b64266ebe4e63a464e135000a07cd",
		"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": "\"\\x00\""
		}]
	}`,
}

View Source

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

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

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

		r3, err := c.OpsForString().Get(ctx, "mykey")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r3, "Hello")
	},
	Data: `
	{
		"Session": "df3b64266ebe4e63a464e135000a07cd",
		"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.OpsForString().SetNX(ctx, "mykey", "Hello")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, int64(1))

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

		r3, err := c.OpsForString().Get(ctx, "mykey")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r3, "Hello")
	},
	Data: `
	{
		"Session": "df3b64266ebe4e63a464e135000a07cd",
		"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.OpsForString().Set(ctx, "key1", "Hello World")
		if err != nil {
			t.Fatal(err)
		}
		assert.True(t, redis.IsOK(r1))

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

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

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

		r5, err := c.OpsForString().Get(ctx, "key2")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r5, "\u0000\u0000\u0000\u0000\u0000\u0000Redis")
	},
	Data: `
	{
		"Session": "df3b64266ebe4e63a464e135000a07cd",
		"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": "\"\\x00\\x00\\x00\\x00\\x00\\x00Redis\""
		}]
	}`,
}

View Source

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

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

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

		r3, err := c.OpsForString().StrLen(ctx, "nonexisting")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r3, int64(0))
	},
	Data: `
	{
		"Session": "df3b64266ebe4e63a464e135000a07cd",
		"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.OpsForString().Set(ctx, "mykey", "Hello")
		if err != nil {
			t.Fatal(err)
		}
		assert.True(t, redis.IsOK(r1))

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

		r3, err := c.OpsForKey().TTL(ctx, "mykey")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r3, int64(10))
	},
	Data: `
	{
		"Session": "df3b64266ebe4e63a464e135000a07cd",
		"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.OpsForString().Set(ctx, "key1", "Hello")
		if err != nil {
			t.Fatal(err)
		}
		assert.True(t, redis.IsOK(r1))

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

		r3, err := c.OpsForKey().Touch(ctx, "key1", "key2")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r3, int64(2))
	},
	Data: `
	{
		"Session": "df3b64266ebe4e63a464e135000a07cd",
		"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.OpsForString().Set(ctx, "key1", "value")
		if err != nil {
			return
		}
		assert.True(t, redis.IsOK(r1))

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

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

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

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

		r6, err := c.OpsForKey().Type(ctx, "key3")
		if err != nil {
			return
		}
		assert.Equal(t, r6, "set")
	},
	Data: `
	{
		"Session": "df3b64266ebe4e63a464e135000a07cd",
		"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.OpsForZSet().ZAdd(ctx, "myzset", 1, "one")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, int64(1))

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

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

		r4, err := c.OpsForZSet().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",
		"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.OpsForZSet().ZAdd(ctx, "myzset", 1, "one")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, int64(1))

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

		r3, err := c.OpsForZSet().ZCard(ctx, "myzset")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r3, int64(2))
	},
	Data: `
	{
		"Session": "df3b64266ebe4e63a464e135000a07cd",
		"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.OpsForZSet().ZAdd(ctx, "myzset", 1, "one")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, int64(1))

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

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

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

		r5, err := c.OpsForZSet().ZCount(ctx, "myzset", "(1", "3")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r5, int64(2))
	},
	Data: `
	{
		"Session": "df3b64266ebe4e63a464e135000a07cd",
		"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.OpsForZSet().ZAdd(ctx, "zset1", 1, "one")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, int64(1))

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

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

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

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

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

		r7, err := c.OpsForZSet().ZDiffWithScores(ctx, "zset1", "zset2")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r7, []redis.ZItem{{"three", 3}})
	},
	Data: `
	{
		"Session": "df3b64266ebe4e63a464e135000a07cd",
		"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.OpsForZSet().ZAdd(ctx, "myzset", 1, "one")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, int64(1))

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

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

		r4, err := c.OpsForZSet().ZRangeWithScores(ctx, "myzset", 0, -1)
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r4, []redis.ZItem{{"two", 2}, {"one", 3}})
	},
	Data: `
	{
		"Session": "df3b64266ebe4e63a464e135000a07cd",
		"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.OpsForZSet().ZAdd(ctx, "zset1", 1, "one")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, int64(1))

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

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

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

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

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

		r7, err := c.OpsForZSet().ZInterWithScores(ctx, 2, "zset1", "zset2")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r7, []redis.ZItem{{"one", 2}, {"two", 4}})
	},
	Data: `
	{
		"Session": "df3b64266ebe4e63a464e135000a07cd",
		"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.OpsForZSet().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.OpsForZSet().ZAdd(ctx, "myzset", 0, "f", 0, "g")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r2, int64(2))

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

		r4, err := c.OpsForZSet().ZLexCount(ctx, "myzset", "[b", "[f")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r4, int64(5))
	},
	Data: `
	{
		"Session": "df3b64266ebe4e63a464e135000a07cd",
		"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.OpsForZSet().ZAdd(ctx, "myzset", 1, "one")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, int64(1))

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

		r3, err := c.OpsForZSet().ZMScore(ctx, "myzset", "one", "two", "nofield")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r3, []float64{1, 2, 0})
	},
	Data: `
	{
		"Session": "df3b64266ebe4e63a464e135000a07cd",
		"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.OpsForZSet().ZAdd(ctx, "myzset", 1, "one")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, int64(1))

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

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

		r4, err := c.OpsForZSet().ZPopMax(ctx, "myzset")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r4, []redis.ZItem{{"three", 3}})
	},
	Data: `
	{
		"Session": "df3b64266ebe4e63a464e135000a07cd",
		"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.OpsForZSet().ZAdd(ctx, "myzset", 1, "one")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, int64(1))

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

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

		r4, err := c.OpsForZSet().ZPopMin(ctx, "myzset")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r4, []redis.ZItem{{"one", 1}})
	},
	Data: `
	{
		"Session": "df3b64266ebe4e63a464e135000a07cd",
		"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.OpsForZSet().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.OpsForZSet().ZRandMember(ctx, "dadi")
		if err != nil {
			t.Fatal(err)
		}
		assert.NotEqual(t, r2, "")

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

		r4, err := c.OpsForZSet().ZRandMemberWithScores(ctx, "dadi", -5)
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, len(r4), 5)
	},
	Data: `
	{
		"Session": "df3b64266ebe4e63a464e135000a07cd",
		"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.OpsForZSet().ZAdd(ctx, "myzset", 1, "one")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, int64(1))

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

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

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

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

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

		r7, err := c.OpsForZSet().ZRangeWithScores(ctx, "myzset", 0, 1)
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r7, []redis.ZItem{{"one", 1}, {"two", 2}})
	},
	Data: `
	{
		"Session": "df3b64266ebe4e63a464e135000a07cd",
		"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.OpsForZSet().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.OpsForZSet().ZRangeByLex(ctx, "myzset", "-", "[c")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r2, []string{"a", "b", "c"})

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

		r4, err := c.OpsForZSet().ZRangeByLex(ctx, "myzset", "[aaa", "(g")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r4, []string{"b", "c", "d", "e", "f"})
	},
	Data: `
	{
		"Session": "df3b64266ebe4e63a464e135000a07cd",
		"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.OpsForZSet().ZAdd(ctx, "myzset", 1, "one")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, int64(1))

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

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

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

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

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

		r7, err := c.OpsForZSet().ZRangeByScore(ctx, "myzset", "(1", "(2")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, len(r7), 0)
	},
	Data: `
	{
		"Session": "df3b64266ebe4e63a464e135000a07cd",
		"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.OpsForZSet().ZAdd(ctx, "myzset", 1, "one")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, int64(1))

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

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

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

		_, err = c.OpsForZSet().ZRank(ctx, "myzset", "four")
		assert.True(t, redis.IsErrNil(err))
	},
	Data: `
	{
		"Session": "df3b64266ebe4e63a464e135000a07cd",
		"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": "NULL"
		}]
	}`,
}

View Source

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

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

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

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

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

		r5, err := c.OpsForZSet().ZRangeWithScores(ctx, "myzset", 0, -1)
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r5, []redis.ZItem{{"one", 1}, {"three", 3}})
	},
	Data: `
	{
		"Session": "df3b64266ebe4e63a464e135000a07cd",
		"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.OpsForZSet().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.OpsForZSet().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.OpsForZSet().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.OpsForZSet().ZRemRangeByLex(ctx, "myzset", "[alpha", "[omega")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r4, int64(6))

		r5, err := c.OpsForZSet().ZRange(ctx, "myzset", 0, -1)
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r5, []string{"ALPHA", "aaaa", "zap", "zip"})
	},
	Data: `
	{
		"Session": "df3b64266ebe4e63a464e135000a07cd",
		"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.OpsForZSet().ZAdd(ctx, "myzset", 1, "one")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, int64(1))

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

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

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

		r5, err := c.OpsForZSet().ZRangeWithScores(ctx, "myzset", 0, -1)
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r5, []redis.ZItem{{"three", 3}})
	},
	Data: `
	{
		"Session": "df3b64266ebe4e63a464e135000a07cd",
		"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.OpsForZSet().ZAdd(ctx, "myzset", 1, "one")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, int64(1))

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

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

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

		r5, err := c.OpsForZSet().ZRangeWithScores(ctx, "myzset", 0, -1)
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r5, []redis.ZItem{{"two", 2}, {"three", 3}})
	},
	Data: `
	{
		"Session": "df3b64266ebe4e63a464e135000a07cd",
		"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.OpsForZSet().ZAdd(ctx, "myzset", 1, "one")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, int64(1))

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

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

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

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

		r6, err := c.OpsForZSet().ZRevRange(ctx, "myzset", -2, -1)
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r6, []string{"two", "one"})
	},
	Data: `
	{
		"Session": "df3b64266ebe4e63a464e135000a07cd",
		"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.OpsForZSet().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.OpsForZSet().ZRevRangeByLex(ctx, "myzset", "[c", "-")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r2, []string{"c", "b", "a"})

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

		r4, err := c.OpsForZSet().ZRevRangeByLex(ctx, "myzset", "(g", "[aaa")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r4, []string{"f", "e", "d", "c", "b"})
	},
	Data: `
	{
		"Session": "df3b64266ebe4e63a464e135000a07cd",
		"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.OpsForZSet().ZAdd(ctx, "myzset", 1, "one")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, int64(1))

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

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

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

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

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

		r7, err := c.OpsForZSet().ZRevRangeByScore(ctx, "myzset", "(2", "(1")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, len(r7), 0)
	},
	Data: `
	{
		"Session": "df3b64266ebe4e63a464e135000a07cd",
		"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.OpsForZSet().ZAdd(ctx, "myzset", 1, "one")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, int64(1))

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

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

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

		_, err = c.OpsForZSet().ZRevRank(ctx, "myzset", "four")
		assert.True(t, redis.IsErrNil(err))
	},
	Data: `
	{
		"Session": "df3b64266ebe4e63a464e135000a07cd",
		"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": "NULL"
		}]
	}`,
}

View Source

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

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

		r2, err := c.OpsForZSet().ZScore(ctx, "myzset", "one")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r2, float64(1))
	},
	Data: `
	{
		"Session": "df3b64266ebe4e63a464e135000a07cd",
		"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.OpsForZSet().ZAdd(ctx, "zset1", 1, "one")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, int64(1))

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

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

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

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

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

		r7, err := c.OpsForZSet().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",
		"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.OpsForZSet().ZAdd(ctx, "zset1", 1, "one")
		if err != nil {
			t.Fatal(err)
		}
		assert.Equal(t, r1, int64(1))

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

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

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

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

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

		r7, err := c.OpsForZSet().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",
		"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)
	Skip bool
	Data string
}

Source Files ¶

View all Source files

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