simplify redis tls implementation (#606)

core/stores/redis/conf.go

@@ -14,10 +14,10 @@ var (
 type (
 	// A RedisConf is a redis config.
 	RedisConf struct {
-		Host    string
-		Type    string `json:",default=node,options=node|cluster"`
-		Pass    string `json:",optional"`
-		TLSFlag bool   `json:",default=false,options=true|false"`
+		Host string
+		Type string `json:",default=node,options=node|cluster"`
+		Pass string `json:",optional"`
+		Tls  bool   `json:",default=false,options=true|false"`
 	}
 
 	// A RedisKeyConf is a redis config with key.
@@ -29,10 +29,18 @@ type (
 
 // NewRedis returns a Redis.
 func (rc RedisConf) NewRedis() *Redis {
-	if rc.TLSFlag {
-		return NewRedisWithTLS(rc.Host, rc.Type, rc.TLSFlag, rc.Pass)
+	var opts []Option
+	if rc.Type == ClusterType {
+		opts = append(opts, Cluster())
 	}
-	return NewRedis(rc.Host, rc.Type, rc.Pass)
+	if len(rc.Pass) > 0 {
+		opts = append(opts, WithPass(rc.Pass))
+	}
+	if rc.Tls {
+		opts = append(opts, WithTLS())
+	}
+
+	return New(rc.Host, opts...)
 }
 
 // Validate validates the RedisConf.

core/stores/redis/redis.go

@@ -29,6 +29,9 @@ const (
 var ErrNilNode = errors.New("nil redis node")
 
 type (
+	// Option defines the method to customize a Redis.
+	Option func(r *Redis)
+
 	// A Pair is a key/pair set used in redis zset.
 	Pair struct {
 		Key   string
@@ -37,11 +40,11 @@ type (
 
 	// Redis defines a redis node/cluster. It is thread-safe.
 	Redis struct {
-		Addr    string
-		Type    string
-		Pass    string
-		brk     breaker.Breaker
-		TLSFlag bool
+		Addr string
+		Type string
+		Pass string
+		tls  bool
+		brk  breaker.Breaker
 	}
 
 	// RedisNode interface represents a redis node.
@@ -70,24 +73,32 @@ type (
 	FloatCmd = red.FloatCmd
 )
 
-// NewRedis returns a Redis.
-func NewRedis(redisAddr, redisType string, redisPass ...string) *Redis {
-	return NewRedisWithTLS(redisAddr, redisType, false, redisPass...)
+// New returns a Redis with given options.
+func New(addr string, opts ...Option) *Redis {
+	r := &Redis{
+		Addr: addr,
+		Type: NodeType,
+		brk:  breaker.NewBreaker(),
+	}
+
+	for _, opt := range opts {
+		opt(r)
+	}
+
+	return r
 }
 
-func NewRedisWithTLS(redisAddr, redisType string, tlsFlag bool, redisPass ...string) *Redis {
-	var pass string
+// NewRedis returns a Redis.
+func NewRedis(redisAddr, redisType string, redisPass ...string) *Redis {
+	var opts []Option
+	if redisType == ClusterType {
+		opts = append(opts, Cluster())
+	}
 	for _, v := range redisPass {
-		pass = v
+		opts = append(opts, WithPass(v))
 	}
 
-	return &Redis{
-		Addr:    redisAddr,
-		Type:    redisType,
-		Pass:    pass,
-		brk:     breaker.NewBreaker(),
-		TLSFlag: tlsFlag,
-	}
+	return New(redisAddr, opts...)
 }
 
 // BitCount is redis bitcount command implementation.
@@ -1703,6 +1714,27 @@ func (s *Redis) Zunionstore(dest string, store ZStore, keys ...string) (val int6
 	return
 }
 
+// Cluster customizes the given Redis as a cluster.
+func Cluster() Option {
+	return func(r *Redis) {
+		r.Type = ClusterType
+	}
+}
+
+// WithPass customizes the given Redis with given password.
+func WithPass(pass string) Option {
+	return func(r *Redis) {
+		r.Pass = pass
+	}
+}
+
+// WithTLS customizes the given Redis with TLS enabled.
+func WithTLS() Option {
+	return func(r *Redis) {
+		r.tls = true
+	}
+}
+
 func acceptable(err error) bool {
 	return err == nil || err == red.Nil
 }
@@ -1710,14 +1742,14 @@ func acceptable(err error) bool {
 func getRedis(r *Redis) (RedisNode, error) {
 	switch r.Type {
 	case ClusterType:
-		if r.TLSFlag {
-			return getClusterWithTLS(r.Addr, r.Pass, r.TLSFlag)
+		if r.tls {
+			return getClusterWithTLS(r.Addr, r.Pass, r.tls)
 		} else {
 			return getCluster(r.Addr, r.Pass)
 		}
 	case NodeType:
-		if r.TLSFlag {
-			return getClientWithTLS(r.Addr, r.Pass, r.TLSFlag)
+		if r.tls {
+			return getClientWithTLS(r.Addr, r.Pass, r.tls)
 		} else {
 			return getClient(r.Addr, r.Pass)
 		}

core/stores/redis/redis_test.go

@@ -15,8 +15,6 @@ import (
 
 func TestRedis_Exists(t *testing.T) {
 	runOnRedis(t, func(client *Redis) {
-		_, err := NewRedis(client.Addr, "").Exists("a")
-		assert.NotNil(t, err)
 		ok, err := client.Exists("a")
 		assert.Nil(t, err)
 		assert.False(t, ok)
@@ -29,7 +27,7 @@ func TestRedis_Exists(t *testing.T) {
 
 func TestRedisTLS_Exists(t *testing.T) {
 	runOnRedisTLS(t, func(client *Redis) {
-		_, err := NewRedisWithTLS(client.Addr, "", true).Exists("a")
+		_, err := New(client.Addr, WithTLS()).Exists("a")
 		assert.NotNil(t, err)
 		ok, err := client.Exists("a")
 		assert.NotNil(t, err)
@@ -43,9 +41,7 @@ func TestRedisTLS_Exists(t *testing.T) {
 
 func TestRedis_Eval(t *testing.T) {
 	runOnRedis(t, func(client *Redis) {
-		_, err := NewRedis(client.Addr, "").Eval(`redis.call("EXISTS", KEYS[1])`, []string{"notexist"})
-		assert.NotNil(t, err)
-		_, err = client.Eval(`redis.call("EXISTS", KEYS[1])`, []string{"notexist"})
+		_, err := client.Eval(`redis.call("EXISTS", KEYS[1])`, []string{"notexist"})
 		assert.Equal(t, Nil, err)
 		err = client.Set("key1", "value1")
 		assert.Nil(t, err)
@@ -68,8 +64,6 @@ func TestRedis_Hgetall(t *testing.T) {
 	runOnRedis(t, func(client *Redis) {
 		assert.Nil(t, client.Hset("a", "aa", "aaa"))
 		assert.Nil(t, client.Hset("a", "bb", "bbb"))
-		_, err := NewRedis(client.Addr, "").Hgetall("a")
-		assert.NotNil(t, err)
 		vals, err := client.Hgetall("a")
 		assert.Nil(t, err)
 		assert.EqualValues(t, map[string]string{
@@ -81,11 +75,8 @@ func TestRedis_Hgetall(t *testing.T) {
 
 func TestRedis_Hvals(t *testing.T) {
 	runOnRedis(t, func(client *Redis) {
-		assert.NotNil(t, NewRedis(client.Addr, "").Hset("a", "aa", "aaa"))
 		assert.Nil(t, client.Hset("a", "aa", "aaa"))
 		assert.Nil(t, client.Hset("a", "bb", "bbb"))
-		_, err := NewRedis(client.Addr, "").Hvals("a")
-		assert.NotNil(t, err)
 		vals, err := client.Hvals("a")
 		assert.Nil(t, err)
 		assert.ElementsMatch(t, []string{"aaa", "bbb"}, vals)
@@ -96,8 +87,6 @@ func TestRedis_Hsetnx(t *testing.T) {
 	runOnRedis(t, func(client *Redis) {
 		assert.Nil(t, client.Hset("a", "aa", "aaa"))
 		assert.Nil(t, client.Hset("a", "bb", "bbb"))
-		_, err := NewRedis(client.Addr, "").Hsetnx("a", "bb", "ccc")
-		assert.NotNil(t, err)
 		ok, err := client.Hsetnx("a", "bb", "ccc")
 		assert.Nil(t, err)
 		assert.False(t, ok)
@@ -114,8 +103,6 @@ func TestRedis_HdelHlen(t *testing.T) {
 	runOnRedis(t, func(client *Redis) {
 		assert.Nil(t, client.Hset("a", "aa", "aaa"))
 		assert.Nil(t, client.Hset("a", "bb", "bbb"))
-		_, err := NewRedis(client.Addr, "").Hlen("a")
-		assert.NotNil(t, err)
 		num, err := client.Hlen("a")
 		assert.Nil(t, err)
 		assert.Equal(t, 2, num)
@@ -130,8 +117,6 @@ func TestRedis_HdelHlen(t *testing.T) {
 
 func TestRedis_HIncrBy(t *testing.T) {
 	runOnRedis(t, func(client *Redis) {
-		_, err := NewRedis(client.Addr, "").Hincrby("key", "field", 2)
-		assert.NotNil(t, err)
 		val, err := client.Hincrby("key", "field", 2)
 		assert.Nil(t, err)
 		assert.Equal(t, 2, val)
@@ -145,8 +130,6 @@ func TestRedis_Hkeys(t *testing.T) {
 	runOnRedis(t, func(client *Redis) {
 		assert.Nil(t, client.Hset("a", "aa", "aaa"))
 		assert.Nil(t, client.Hset("a", "bb", "bbb"))
-		_, err := NewRedis(client.Addr, "").Hkeys("a")
-		assert.NotNil(t, err)
 		vals, err := client.Hkeys("a")
 		assert.Nil(t, err)
 		assert.ElementsMatch(t, []string{"aa", "bb"}, vals)
@@ -157,8 +140,6 @@ func TestRedis_Hmget(t *testing.T) {
 	runOnRedis(t, func(client *Redis) {
 		assert.Nil(t, client.Hset("a", "aa", "aaa"))
 		assert.Nil(t, client.Hset("a", "bb", "bbb"))
-		_, err := NewRedis(client.Addr, "").Hmget("a", "aa", "bb")
-		assert.NotNil(t, err)
 		vals, err := client.Hmget("a", "aa", "bb")
 		assert.Nil(t, err)
 		assert.EqualValues(t, []string{"aaa", "bbb"}, vals)
@@ -194,8 +175,6 @@ func TestRedis_Hscan(t *testing.T) {
 		var cursor uint64 = 0
 		sum := 0
 		for {
-			_, _, err := NewRedis(client.Addr, "").Hscan(key, cursor, "*", 100)
-			assert.NotNil(t, err)
 			reMap, next, err := client.Hscan(key, cursor, "*", 100)
 			assert.Nil(t, err)
 			sum += len(reMap)
@@ -206,8 +185,6 @@ func TestRedis_Hscan(t *testing.T) {
 		}
 
 		assert.Equal(t, sum, 3100)
-		_, err = NewRedis(client.Addr, "").Del(key)
-		assert.NotNil(t, err)
 		_, err = client.Del(key)
 		assert.Nil(t, err)
 	})
@@ -215,8 +192,6 @@ func TestRedis_Hscan(t *testing.T) {
 
 func TestRedis_Incr(t *testing.T) {
 	runOnRedis(t, func(client *Redis) {
-		_, err := NewRedis(client.Addr, "").Incr("a")
-		assert.NotNil(t, err)
 		val, err := client.Incr("a")
 		assert.Nil(t, err)
 		assert.Equal(t, int64(1), val)
@@ -228,8 +203,6 @@ func TestRedis_Incr(t *testing.T) {
 
 func TestRedis_IncrBy(t *testing.T) {
 	runOnRedis(t, func(client *Redis) {
-		_, err := NewRedis(client.Addr, "").Incrby("a", 2)
-		assert.NotNil(t, err)
 		val, err := client.Incrby("a", 2)
 		assert.Nil(t, err)
 		assert.Equal(t, int64(2), val)
@@ -245,8 +218,6 @@ func TestRedis_Keys(t *testing.T) {
 		assert.Nil(t, err)
 		err = client.Set("key2", "value2")
 		assert.Nil(t, err)
-		_, err = NewRedis(client.Addr, "").Keys("*")
-		assert.NotNil(t, err)
 		keys, err := client.Keys("*")
 		assert.Nil(t, err)
 		assert.ElementsMatch(t, []string{"key1", "key2"}, keys)
@@ -268,47 +239,33 @@ func TestRedis_HyperLogLog(t *testing.T) {
 
 func TestRedis_List(t *testing.T) {
 	runOnRedis(t, func(client *Redis) {
-		_, err := NewRedis(client.Addr, "").Lpush("key", "value1", "value2")
-		assert.NotNil(t, err)
 		val, err := client.Lpush("key", "value1", "value2")
 		assert.Nil(t, err)
 		assert.Equal(t, 2, val)
-		_, err = NewRedis(client.Addr, "").Rpush("key", "value3", "value4")
-		assert.NotNil(t, err)
 		val, err = client.Rpush("key", "value3", "value4")
 		assert.Nil(t, err)
 		assert.Equal(t, 4, val)
-		_, err = NewRedis(client.Addr, "").Llen("key")
-		assert.NotNil(t, err)
 		val, err = client.Llen("key")
 		assert.Nil(t, err)
 		assert.Equal(t, 4, val)
 		vals, err := client.Lrange("key", 0, 10)
 		assert.Nil(t, err)
 		assert.EqualValues(t, []string{"value2", "value1", "value3", "value4"}, vals)
-		_, err = NewRedis(client.Addr, "").Lpop("key")
-		assert.NotNil(t, err)
 		v, err := client.Lpop("key")
 		assert.Nil(t, err)
 		assert.Equal(t, "value2", v)
 		val, err = client.Lpush("key", "value1", "value2")
 		assert.Nil(t, err)
 		assert.Equal(t, 5, val)
-		_, err = NewRedis(client.Addr, "").Rpop("key")
-		assert.NotNil(t, err)
 		v, err = client.Rpop("key")
 		assert.Nil(t, err)
 		assert.Equal(t, "value4", v)
 		val, err = client.Rpush("key", "value4", "value3", "value3")
 		assert.Nil(t, err)
 		assert.Equal(t, 7, val)
-		_, err = NewRedis(client.Addr, "").Lrem("key", 2, "value1")
-		assert.NotNil(t, err)
 		n, err := client.Lrem("key", 2, "value1")
 		assert.Nil(t, err)
 		assert.Equal(t, 2, n)
-		_, err = NewRedis(client.Addr, "").Lrange("key", 0, 10)
-		assert.NotNil(t, err)
 		vals, err = client.Lrange("key", 0, 10)
 		assert.Nil(t, err)
 		assert.EqualValues(t, []string{"value2", "value3", "value4", "value3", "value3"}, vals)
@@ -327,8 +284,6 @@ func TestRedis_Mget(t *testing.T) {
 		assert.Nil(t, err)
 		err = client.Set("key2", "value2")
 		assert.Nil(t, err)
-		_, err = NewRedis(client.Addr, "").Mget("key1", "key0", "key2", "key3")
-		assert.NotNil(t, err)
 		vals, err := client.Mget("key1", "key0", "key2", "key3")
 		assert.Nil(t, err)
 		assert.EqualValues(t, []string{"value1", "", "value2", ""}, vals)
@@ -337,10 +292,7 @@ func TestRedis_Mget(t *testing.T) {
 
 func TestRedis_SetBit(t *testing.T) {
 	runOnRedis(t, func(client *Redis) {
-		err := NewRedis(client.Addr, "").SetBit("key", 1, 1)
-		assert.NotNil(t, err)
-		err = client.SetBit("key", 1, 1)
-		assert.Nil(t, err)
+		assert.Nil(t, client.SetBit("key", 1, 1))
 	})
 }
 
@@ -348,8 +300,6 @@ func TestRedis_GetBit(t *testing.T) {
 	runOnRedis(t, func(client *Redis) {
 		err := client.SetBit("key", 2, 1)
 		assert.Nil(t, err)
-		_, err = NewRedis(client.Addr, "").GetBit("key", 2)
-		assert.NotNil(t, err)
 		val, err := client.GetBit("key", 2)
 		assert.Nil(t, err)
 		assert.Equal(t, 1, val)
@@ -363,8 +313,6 @@ func TestRedis_BitCount(t *testing.T) {
 			assert.Nil(t, err)
 		}
 
-		_, err := NewRedis(client.Addr, "").BitCount("key", 0, -1)
-		assert.NotNil(t, err)
 		val, err := client.BitCount("key", 0, -1)
 		assert.Nil(t, err)
 		assert.Equal(t, int64(11), val)
@@ -394,14 +342,11 @@ func TestRedis_BitOpAnd(t *testing.T) {
 		assert.Nil(t, err)
 		err = client.Set("key2", "1")
 		assert.Nil(t, err)
-		_, err = NewRedis(client.Addr, "").BitOpAnd("destKey", "key1", "key2")
-		assert.NotNil(t, err)
 		val, err := client.BitOpAnd("destKey", "key1", "key2")
 		assert.Nil(t, err)
 		assert.Equal(t, int64(1), val)
 		valStr, err := client.Get("destKey")
 		assert.Nil(t, err)
-		//destKey  binary 110000   ascii 0
 		assert.Equal(t, "0", valStr)
 	})
 }
@@ -410,8 +355,6 @@ func TestRedis_BitOpNot(t *testing.T) {
 	runOnRedis(t, func(client *Redis) {
 		err := client.Set("key1", "\u0000")
 		assert.Nil(t, err)
-		_, err = NewRedis(client.Addr, "").BitOpNot("destKey", "key1")
-		assert.NotNil(t, err)
 		val, err := client.BitOpNot("destKey", "key1")
 		assert.Nil(t, err)
 		assert.Equal(t, int64(1), val)
@@ -427,8 +370,6 @@ func TestRedis_BitOpOr(t *testing.T) {
 		assert.Nil(t, err)
 		err = client.Set("key2", "0")
 		assert.Nil(t, err)
-		_, err = NewRedis(client.Addr, "").BitOpOr("destKey", "key1", "key2")
-		assert.NotNil(t, err)
 		val, err := client.BitOpOr("destKey", "key1", "key2")
 		assert.Nil(t, err)
 		assert.Equal(t, int64(1), val)
@@ -444,8 +385,6 @@ func TestRedis_BitOpXor(t *testing.T) {
 		assert.Nil(t, err)
 		err = client.Set("key2", "\x0f")
 		assert.Nil(t, err)
-		_, err = NewRedis(client.Addr, "").BitOpXor("destKey", "key1", "key2")
-		assert.NotNil(t, err)
 		val, err := client.BitOpXor("destKey", "key1", "key2")
 		assert.Nil(t, err)
 		assert.Equal(t, int64(1), val)
@@ -456,12 +395,10 @@ func TestRedis_BitOpXor(t *testing.T) {
 }
 func TestRedis_BitPos(t *testing.T) {
 	runOnRedis(t, func(client *Redis) {
-		//11111111 11110000 00000000
+		// 11111111 11110000 00000000
 		err := client.Set("key", "\xff\xf0\x00")
 		assert.Nil(t, err)
 
-		_, err = NewRedis(client.Addr, "").BitPos("key", 0, 0, -1)
-		assert.NotNil(t, err)
 		val, err := client.BitPos("key", 0, 0, 2)
 		assert.Nil(t, err)
 		assert.Equal(t, int64(12), val)
@@ -487,8 +424,6 @@ func TestRedis_BitPos(t *testing.T) {
 
 func TestRedis_Persist(t *testing.T) {
 	runOnRedis(t, func(client *Redis) {
-		_, err := NewRedis(client.Addr, "").Persist("key")
-		assert.NotNil(t, err)
 		ok, err := client.Persist("key")
 		assert.Nil(t, err)
 		assert.False(t, ok)
@@ -497,15 +432,11 @@ func TestRedis_Persist(t *testing.T) {
 		ok, err = client.Persist("key")
 		assert.Nil(t, err)
 		assert.False(t, ok)
-		err = NewRedis(client.Addr, "").Expire("key", 5)
-		assert.NotNil(t, err)
 		err = client.Expire("key", 5)
 		assert.Nil(t, err)
 		ok, err = client.Persist("key")
 		assert.Nil(t, err)
 		assert.True(t, ok)
-		err = NewRedis(client.Addr, "").Expireat("key", time.Now().Unix()+5)
-		assert.NotNil(t, err)
 		err = client.Expireat("key", time.Now().Unix()+5)
 		assert.Nil(t, err)
 		ok, err = client.Persist("key")
@@ -527,8 +458,6 @@ func TestRedis_Scan(t *testing.T) {
 		assert.Nil(t, err)
 		err = client.Set("key2", "value2")
 		assert.Nil(t, err)
-		_, _, err = NewRedis(client.Addr, "").Scan(0, "*", 100)
-		assert.NotNil(t, err)
 		keys, _, err := client.Scan(0, "*", 100)
 		assert.Nil(t, err)
 		assert.ElementsMatch(t, []string{"key1", "key2"}, keys)
@@ -549,8 +478,6 @@ func TestRedis_Sscan(t *testing.T) {
 		var cursor uint64 = 0
 		sum := 0
 		for {
-			_, _, err := NewRedis(client.Addr, "").Sscan(key, cursor, "", 100)
-			assert.NotNil(t, err)
 			keys, next, err := client.Sscan(key, cursor, "", 100)
 			assert.Nil(t, err)
 			sum += len(keys)
@@ -561,8 +488,6 @@ func TestRedis_Sscan(t *testing.T) {
 		}
 
 		assert.Equal(t, sum, 1550)
-		_, err = NewRedis(client.Addr, "").Del(key)
-		assert.NotNil(t, err)
 		_, err = client.Del(key)
 		assert.Nil(t, err)
 	})
@@ -570,72 +495,46 @@ func TestRedis_Sscan(t *testing.T) {
 
 func TestRedis_Set(t *testing.T) {
 	runOnRedis(t, func(client *Redis) {
-		_, err := NewRedis(client.Addr, "").Sadd("key", 1, 2, 3, 4)
-		assert.NotNil(t, err)
 		num, err := client.Sadd("key", 1, 2, 3, 4)
 		assert.Nil(t, err)
 		assert.Equal(t, 4, num)
-		_, err = NewRedis(client.Addr, "").Scard("key")
-		assert.NotNil(t, err)
 		val, err := client.Scard("key")
 		assert.Nil(t, err)
 		assert.Equal(t, int64(4), val)
-		_, err = NewRedis(client.Addr, "").Sismember("key", 2)
-		assert.NotNil(t, err)
 		ok, err := client.Sismember("key", 2)
 		assert.Nil(t, err)
 		assert.True(t, ok)
-		_, err = NewRedis(client.Addr, "").Srem("key", 3, 4)
-		assert.NotNil(t, err)
 		num, err = client.Srem("key", 3, 4)
 		assert.Nil(t, err)
 		assert.Equal(t, 2, num)
-		_, err = NewRedis(client.Addr, "").Smembers("key")
-		assert.NotNil(t, err)
 		vals, err := client.Smembers("key")
 		assert.Nil(t, err)
 		assert.ElementsMatch(t, []string{"1", "2"}, vals)
-		_, err = NewRedis(client.Addr, "").Srandmember("key", 1)
-		assert.NotNil(t, err)
 		members, err := client.Srandmember("key", 1)
 		assert.Nil(t, err)
 		assert.Len(t, members, 1)
 		assert.Contains(t, []string{"1", "2"}, members[0])
-		_, err = NewRedis(client.Addr, "").Spop("key")
-		assert.NotNil(t, err)
 		member, err := client.Spop("key")
 		assert.Nil(t, err)
 		assert.Contains(t, []string{"1", "2"}, member)
-		_, err = NewRedis(client.Addr, "").Smembers("key")
-		assert.NotNil(t, err)
 		vals, err = client.Smembers("key")
 		assert.Nil(t, err)
 		assert.NotContains(t, vals, member)
-		_, err = NewRedis(client.Addr, "").Sadd("key1", 1, 2, 3, 4)
-		assert.NotNil(t, err)
 		num, err = client.Sadd("key1", 1, 2, 3, 4)
 		assert.Nil(t, err)
 		assert.Equal(t, 4, num)
 		num, err = client.Sadd("key2", 2, 3, 4, 5)
 		assert.Nil(t, err)
 		assert.Equal(t, 4, num)
-		_, err = NewRedis(client.Addr, "").Sunion("key1", "key2")
-		assert.NotNil(t, err)
 		vals, err = client.Sunion("key1", "key2")
 		assert.Nil(t, err)
 		assert.ElementsMatch(t, []string{"1", "2", "3", "4", "5"}, vals)
-		_, err = NewRedis(client.Addr, "").Sunionstore("key3", "key1", "key2")
-		assert.NotNil(t, err)
 		num, err = client.Sunionstore("key3", "key1", "key2")
 		assert.Nil(t, err)
 		assert.Equal(t, 5, num)
-		_, err = NewRedis(client.Addr, "").Sdiff("key1", "key2")
-		assert.NotNil(t, err)
 		vals, err = client.Sdiff("key1", "key2")
 		assert.Nil(t, err)
 		assert.EqualValues(t, []string{"1"}, vals)
-		_, err = NewRedis(client.Addr, "").Sdiffstore("key4", "key1", "key2")
-		assert.NotNil(t, err)
 		num, err = client.Sdiffstore("key4", "key1", "key2")
 		assert.Nil(t, err)
 		assert.Equal(t, 1, num)
@@ -644,12 +543,8 @@ func TestRedis_Set(t *testing.T) {
 
 func TestRedis_SetGetDel(t *testing.T) {
 	runOnRedis(t, func(client *Redis) {
-		err := NewRedis(client.Addr, "").Set("hello", "world")
-		assert.NotNil(t, err)
-		err = client.Set("hello", "world")
+		err := client.Set("hello", "world")
 		assert.Nil(t, err)
-		_, err = NewRedis(client.Addr, "").Get("hello")
-		assert.NotNil(t, err)
 		val, err := client.Get("hello")
 		assert.Nil(t, err)
 		assert.Equal(t, "world", val)
@@ -661,12 +556,8 @@ func TestRedis_SetGetDel(t *testing.T) {
 
 func TestRedis_SetExNx(t *testing.T) {
 	runOnRedis(t, func(client *Redis) {
-		err := NewRedis(client.Addr, "").Setex("hello", "world", 5)
-		assert.NotNil(t, err)
-		err = client.Setex("hello", "world", 5)
+		err := client.Setex("hello", "world", 5)
 		assert.Nil(t, err)
-		_, err = NewRedis(client.Addr, "").Setnx("hello", "newworld")
-		assert.NotNil(t, err)
 		ok, err := client.Setnx("hello", "newworld")
 		assert.Nil(t, err)
 		assert.False(t, ok)
@@ -682,8 +573,6 @@ func TestRedis_SetExNx(t *testing.T) {
 		ttl, err := client.Ttl("hello")
 		assert.Nil(t, err)
 		assert.True(t, ttl > 0)
-		_, err = NewRedis(client.Addr, "").SetnxEx("newhello", "newworld", 5)
-		assert.NotNil(t, err)
 		ok, err = client.SetnxEx("newhello", "newworld", 5)
 		assert.Nil(t, err)
 		assert.False(t, ok)
@@ -703,18 +592,12 @@ func TestRedis_SetGetDelHashField(t *testing.T) {
 	runOnRedis(t, func(client *Redis) {
 		err := client.Hset("key", "field", "value")
 		assert.Nil(t, err)
-		_, err = NewRedis(client.Addr, "").Hget("key", "field")
-		assert.NotNil(t, err)
 		val, err := client.Hget("key", "field")
 		assert.Nil(t, err)
 		assert.Equal(t, "value", val)
-		_, err = NewRedis(client.Addr, "").Hexists("key", "field")
-		assert.NotNil(t, err)
 		ok, err := client.Hexists("key", "field")
 		assert.Nil(t, err)
 		assert.True(t, ok)
-		_, err = NewRedis(client.Addr, "").Hdel("key", "field")
-		assert.NotNil(t, err)
 		ret, err := client.Hdel("key", "field")
 		assert.Nil(t, err)
 		assert.True(t, ret)
@@ -735,18 +618,12 @@ func TestRedis_SortedSet(t *testing.T) {
 		val, err := client.Zscore("key", "value1")
 		assert.Nil(t, err)
 		assert.Equal(t, int64(2), val)
-		_, err = NewRedis(client.Addr, "").Zincrby("key", 3, "value1")
-		assert.NotNil(t, err)
 		val, err = client.Zincrby("key", 3, "value1")
 		assert.Nil(t, err)
 		assert.Equal(t, int64(5), val)
-		_, err = NewRedis(client.Addr, "").Zscore("key", "value1")
-		assert.NotNil(t, err)
 		val, err = client.Zscore("key", "value1")
 		assert.Nil(t, err)
 		assert.Equal(t, int64(5), val)
-		_, err = NewRedis(client.Addr, "").Zadds("key")
-		assert.NotNil(t, err)
 		val, err = client.Zadds("key", Pair{
 			Key:   "value2",
 			Score: 6,
@@ -756,8 +633,6 @@ func TestRedis_SortedSet(t *testing.T) {
 		})
 		assert.Nil(t, err)
 		assert.Equal(t, int64(2), val)
-		_, err = NewRedis(client.Addr, "").ZRevRangeWithScores("key", 1, 3)
-		assert.NotNil(t, err)
 		pairs, err := client.ZRevRangeWithScores("key", 1, 3)
 		assert.Nil(t, err)
 		assert.EqualValues(t, []Pair{
@@ -776,12 +651,8 @@ func TestRedis_SortedSet(t *testing.T) {
 		rank, err = client.Zrevrank("key", "value1")
 		assert.Nil(t, err)
 		assert.Equal(t, int64(2), rank)
-		_, err = NewRedis(client.Addr, "").Zrank("key", "value4")
-		assert.NotNil(t, err)
 		_, err = client.Zrank("key", "value4")
 		assert.Equal(t, Nil, err)
-		_, err = NewRedis(client.Addr, "").Zrem("key", "value2", "value3")
-		assert.NotNil(t, err)
 		num, err := client.Zrem("key", "value2", "value3")
 		assert.Nil(t, err)
 		assert.Equal(t, 2, num)
@@ -794,46 +665,30 @@ func TestRedis_SortedSet(t *testing.T) {
 		ok, err = client.Zadd("key", 8, "value4")
 		assert.Nil(t, err)
 		assert.True(t, ok)
-		_, err = NewRedis(client.Addr, "").Zremrangebyscore("key", 6, 7)
-		assert.NotNil(t, err)
 		num, err = client.Zremrangebyscore("key", 6, 7)
 		assert.Nil(t, err)
 		assert.Equal(t, 2, num)
 		ok, err = client.Zadd("key", 6, "value2")
 		assert.Nil(t, err)
 		assert.True(t, ok)
-		_, err = NewRedis(client.Addr, "").Zadd("key", 7, "value3")
-		assert.NotNil(t, err)
 		ok, err = client.Zadd("key", 7, "value3")
 		assert.Nil(t, err)
 		assert.True(t, ok)
-		_, err = NewRedis(client.Addr, "").Zcount("key", 6, 7)
-		assert.NotNil(t, err)
 		num, err = client.Zcount("key", 6, 7)
 		assert.Nil(t, err)
 		assert.Equal(t, 2, num)
-		_, err = NewRedis(client.Addr, "").Zremrangebyrank("key", 1, 2)
-		assert.NotNil(t, err)
 		num, err = client.Zremrangebyrank("key", 1, 2)
 		assert.Nil(t, err)
 		assert.Equal(t, 2, num)
-		_, err = NewRedis(client.Addr, "").Zcard("key")
-		assert.NotNil(t, err)
 		card, err := client.Zcard("key")
 		assert.Nil(t, err)
 		assert.Equal(t, 2, card)
-		_, err = NewRedis(client.Addr, "").Zrange("key", 0, -1)
-		assert.NotNil(t, err)
 		vals, err := client.Zrange("key", 0, -1)
 		assert.Nil(t, err)
 		assert.EqualValues(t, []string{"value1", "value4"}, vals)
-		_, err = NewRedis(client.Addr, "").Zrevrange("key", 0, -1)
-		assert.NotNil(t, err)
 		vals, err = client.Zrevrange("key", 0, -1)
 		assert.Nil(t, err)
 		assert.EqualValues(t, []string{"value4", "value1"}, vals)
-		_, err = NewRedis(client.Addr, "").ZrangeWithScores("key", 0, -1)
-		assert.NotNil(t, err)
 		pairs, err = client.ZrangeWithScores("key", 0, -1)
 		assert.Nil(t, err)
 		assert.EqualValues(t, []Pair{
@@ -846,8 +701,6 @@ func TestRedis_SortedSet(t *testing.T) {
 				Score: 8,
 			},
 		}, pairs)
-		_, err = NewRedis(client.Addr, "").ZrangebyscoreWithScores("key", 5, 8)
-		assert.NotNil(t, err)
 		pairs, err = client.ZrangebyscoreWithScores("key", 5, 8)
 		assert.Nil(t, err)
 		assert.EqualValues(t, []Pair{
@@ -860,9 +713,6 @@ func TestRedis_SortedSet(t *testing.T) {
 				Score: 8,
 			},
 		}, pairs)
-		_, err = NewRedis(client.Addr, "").ZrangebyscoreWithScoresAndLimit(
-			"key", 5, 8, 1, 1)
-		assert.NotNil(t, err)
 		pairs, err = client.ZrangebyscoreWithScoresAndLimit("key", 5, 8, 1, 1)
 		assert.Nil(t, err)
 		assert.EqualValues(t, []Pair{
@@ -874,8 +724,6 @@ func TestRedis_SortedSet(t *testing.T) {
 		pairs, err = client.ZrangebyscoreWithScoresAndLimit("key", 5, 8, 1, 0)
 		assert.Nil(t, err)
 		assert.Equal(t, 0, len(pairs))
-		_, err = NewRedis(client.Addr, "").ZrevrangebyscoreWithScores("key", 5, 8)
-		assert.NotNil(t, err)
 		pairs, err = client.ZrevrangebyscoreWithScores("key", 5, 8)
 		assert.Nil(t, err)
 		assert.EqualValues(t, []Pair{
@@ -888,9 +736,6 @@ func TestRedis_SortedSet(t *testing.T) {
 				Score: 5,
 			},
 		}, pairs)
-		_, err = NewRedis(client.Addr, "").ZrevrangebyscoreWithScoresAndLimit(
-			"key", 5, 8, 1, 1)
-		assert.NotNil(t, err)
 		pairs, err = client.ZrevrangebyscoreWithScoresAndLimit("key", 5, 8, 1, 1)
 		assert.Nil(t, err)
 		assert.EqualValues(t, []Pair{
@@ -902,8 +747,6 @@ func TestRedis_SortedSet(t *testing.T) {
 		pairs, err = client.ZrevrangebyscoreWithScoresAndLimit("key", 5, 8, 1, 0)
 		assert.Nil(t, err)
 		assert.Equal(t, 0, len(pairs))
-		_, err = NewRedis(client.Addr, "").Zrevrank("key", "value")
-		assert.NotNil(t, err)
 		client.Zadd("second", 2, "aa")
 		client.Zadd("third", 3, "bbb")
 		val, err = client.Zunionstore("union", ZStore{
@@ -923,9 +766,6 @@ func TestRedis_SortedSet(t *testing.T) {
 
 func TestRedis_Pipelined(t *testing.T) {
 	runOnRedis(t, func(client *Redis) {
-		assert.NotNil(t, NewRedis(client.Addr, "").Pipelined(func(pipeliner Pipeliner) error {
-			return nil
-		}))
 		err := client.Pipelined(
 			func(pipe Pipeliner) error {
 				pipe.Incr("pipelined_counter")
@@ -935,8 +775,6 @@ func TestRedis_Pipelined(t *testing.T) {
 			},
 		)
 		assert.Nil(t, err)
-		_, err = NewRedis(client.Addr, "").Ttl("pipelined_counter")
-		assert.NotNil(t, err)
 		ttl, err := client.Ttl("pipelined_counter")
 		assert.Nil(t, err)
 		assert.Equal(t, 3600, ttl)
@@ -955,16 +793,13 @@ func TestRedisString(t *testing.T) {
 		_, err := getRedis(NewRedis(client.Addr, ClusterType))
 		assert.Nil(t, err)
 		assert.Equal(t, client.Addr, client.String())
-		assert.NotNil(t, NewRedis(client.Addr, "").Ping())
 	})
 }
 
 func TestRedisScriptLoad(t *testing.T) {
 	runOnRedis(t, func(client *Redis) {
 		client.Ping()
-		_, err := NewRedis(client.Addr, "").ScriptLoad("foo")
-		assert.NotNil(t, err)
-		_, err = client.ScriptLoad("foo")
+		_, err := client.ScriptLoad("foo")
 		assert.NotNil(t, err)
 	})
 }
@@ -1098,7 +933,7 @@ func runOnRedisTLS(t *testing.T, fn func(client *Redis)) {
 			client.Close()
 		}
 	}()
-	fn(NewRedisWithTLS(s.Addr(), NodeType, true))
+	fn(New(s.Addr(), WithTLS()))
 }
 
 type mockedNode struct {

core/stores/redis/redisclientmanager.go

@@ -20,10 +20,10 @@ func getClient(server, pass string) (*red.Client, error) {
 	return getClientWithTLS(server, pass, false)
 }
 
-func getClientWithTLS(server, pass string, tlsFlag bool) (*red.Client, error) {
+func getClientWithTLS(server, pass string, tlsEnabled bool) (*red.Client, error) {
 	val, err := clientManager.GetResource(server, func() (io.Closer, error) {
-		var tlsConfig *tls.Config = nil
-		if tlsFlag {
+		var tlsConfig *tls.Config
+		if tlsEnabled {
 			tlsConfig = &tls.Config{
 				InsecureSkipVerify: true,
 			}

core/stores/redis/redisclustermanager.go

@@ -14,10 +14,10 @@ func getCluster(server, pass string) (*red.ClusterClient, error) {
 	return getClusterWithTLS(server, pass, false)
 }
 
-func getClusterWithTLS(server, pass string, tlsFlag bool) (*red.ClusterClient, error) {
+func getClusterWithTLS(server, pass string, tlsEnabled bool) (*red.ClusterClient, error) {
 	val, err := clusterManager.GetResource(server, func() (io.Closer, error) {
-		var tlsConfig *tls.Config = nil
-		if tlsFlag {
+		var tlsConfig *tls.Config
+		if tlsEnabled {
 			tlsConfig = &tls.Config{
 				InsecureSkipVerify: true,
 			}