X-Git-Url: https://gerrit.o-ran-sc.org/r/gitweb?a=blobdiff_plain;f=internal%2Fsdlgoredis%2Fsdlgoredis_test.go;h=d8b8328a2738d5cbf89cff68f7676d0ea24056d4;hb=4d1222c6d4954e2a2855833696dc3b44418714a6;hp=4869d8fce8def3f4567e452baf21731b425d3a45;hpb=33961a269bf51f6c713fcb00576cdc0b9ac98ee9;p=ric-plt%2Fsdlgo.git

diff --git a/internal/sdlgoredis/sdlgoredis_test.go b/internal/sdlgoredis/sdlgoredis_test.go
index 4869d8f..d8b8328 100644
--- a/internal/sdlgoredis/sdlgoredis_test.go
+++ b/internal/sdlgoredis/sdlgoredis_test.go
@@ -23,15 +23,15 @@
 package sdlgoredis_test
 
 import (
+	"context"
 	"errors"
-	"strconv"
-	"testing"
-	"time"
-
 	"gerrit.o-ran-sc.org/r/ric-plt/sdlgo/internal/sdlgoredis"
-	"github.com/go-redis/redis"
+	"github.com/go-redis/redis/v8"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/mock"
+	"strconv"
+	"testing"
+	"time"
 )
 
 type clientMock struct {
@@ -42,15 +42,19 @@ type pubSubMock struct {
 	mock.Mock
 }
 
-func (m *pubSubMock) Channel() <-chan *redis.Message {
+type MockOS struct {
+	mock.Mock
+}
+
+func (m *pubSubMock) Channel(opts ...redis.ChannelOption) <-chan *redis.Message {
 	return m.Called().Get(0).(chan *redis.Message)
 }
 
-func (m *pubSubMock) Subscribe(channels ...string) error {
+func (m *pubSubMock) Subscribe(ctx context.Context, channels ...string) error {
 	return m.Called().Error(0)
 }
 
-func (m *pubSubMock) Unsubscribe(channels ...string) error {
+func (m *pubSubMock) Unsubscribe(ctx context.Context, channels ...string) error {
 	return m.Called().Error(0)
 }
 
@@ -58,7 +62,7 @@ func (m *pubSubMock) Close() error {
 	return m.Called().Error(0)
 }
 
-func (m *clientMock) Command() *redis.CommandsInfoCmd {
+func (m *clientMock) Command(ctx context.Context) *redis.CommandsInfoCmd {
 	return m.Called().Get(0).(*redis.CommandsInfoCmd)
 }
 
@@ -66,91 +70,151 @@ func (m *clientMock) Close() error {
 	return m.Called().Error(0)
 }
 
-func (m *clientMock) Subscribe(channels ...string) *redis.PubSub {
+func (m *clientMock) Subscribe(ctx context.Context, channels ...string) *redis.PubSub {
 	return m.Called(channels).Get(0).(*redis.PubSub)
 }
 
-func (m *clientMock) MSet(pairs ...interface{}) *redis.StatusCmd {
+func (m *clientMock) MSet(ctx context.Context, pairs ...interface{}) *redis.StatusCmd {
 	return m.Called(pairs).Get(0).(*redis.StatusCmd)
 }
 
-func (m *clientMock) Do(args ...interface{}) *redis.Cmd {
+func (m *clientMock) Do(ctx context.Context, args ...interface{}) *redis.Cmd {
 	return m.Called(args).Get(0).(*redis.Cmd)
 }
 
-func (m *clientMock) MGet(keys ...string) *redis.SliceCmd {
+func (m *clientMock) MGet(ctx context.Context, keys ...string) *redis.SliceCmd {
 	return m.Called(keys).Get(0).(*redis.SliceCmd)
 }
 
-func (m *clientMock) Del(keys ...string) *redis.IntCmd {
+func (m *clientMock) Del(ctx context.Context, keys ...string) *redis.IntCmd {
 	return m.Called(keys).Get(0).(*redis.IntCmd)
 }
 
-func (m *clientMock) Keys(pattern string) *redis.StringSliceCmd {
+func (m *clientMock) Keys(ctx context.Context, pattern string) *redis.StringSliceCmd {
 	return m.Called(pattern).Get(0).(*redis.StringSliceCmd)
 }
 
-func (m *clientMock) SetNX(key string, value interface{}, expiration time.Duration) *redis.BoolCmd {
+func (m *clientMock) SetNX(ctx context.Context, key string, value interface{}, expiration time.Duration) *redis.BoolCmd {
 	return m.Called(key, value, expiration).Get(0).(*redis.BoolCmd)
 }
 
-func (m *clientMock) SAdd(key string, members ...interface{}) *redis.IntCmd {
+func (m *clientMock) SAdd(ctx context.Context, key string, members ...interface{}) *redis.IntCmd {
 	return m.Called(key, members).Get(0).(*redis.IntCmd)
 }
 
-func (m *clientMock) SRem(key string, members ...interface{}) *redis.IntCmd {
+func (m *clientMock) SRem(ctx context.Context, key string, members ...interface{}) *redis.IntCmd {
 	return m.Called(key, members).Get(0).(*redis.IntCmd)
 }
 
-func (m *clientMock) SMembers(key string) *redis.StringSliceCmd {
+func (m *clientMock) SMembers(ctx context.Context, key string) *redis.StringSliceCmd {
 	return m.Called(key).Get(0).(*redis.StringSliceCmd)
 }
 
-func (m *clientMock) SIsMember(key string, member interface{}) *redis.BoolCmd {
+func (m *clientMock) SIsMember(ctx context.Context, key string, member interface{}) *redis.BoolCmd {
 	return m.Called(key, member).Get(0).(*redis.BoolCmd)
 }
 
-func (m *clientMock) SCard(key string) *redis.IntCmd {
+func (m *clientMock) SCard(ctx context.Context, key string) *redis.IntCmd {
 	return m.Called(key).Get(0).(*redis.IntCmd)
 }
 
-func (m *clientMock) PTTL(key string) *redis.DurationCmd {
+func (m *clientMock) PTTL(ctx context.Context, key string) *redis.DurationCmd {
 	return m.Called(key).Get(0).(*redis.DurationCmd)
 }
 
-func (m *clientMock) Eval(script string, keys []string, args ...interface{}) *redis.Cmd {
+func (m *clientMock) Eval(ctx context.Context, script string, keys []string, args ...interface{}) *redis.Cmd {
 	return m.Called(script, keys).Get(0).(*redis.Cmd)
 }
 
-func (m *clientMock) EvalSha(sha1 string, keys []string, args ...interface{}) *redis.Cmd {
+func (m *clientMock) EvalSha(ctx context.Context, sha1 string, keys []string, args ...interface{}) *redis.Cmd {
 	return m.Called(sha1, keys, args).Get(0).(*redis.Cmd)
 }
 
-func (m *clientMock) ScriptExists(scripts ...string) *redis.BoolSliceCmd {
+func (m *clientMock) ScriptExists(ctx context.Context, scripts ...string) *redis.BoolSliceCmd {
 	return m.Called(scripts).Get(0).(*redis.BoolSliceCmd)
 }
 
-func (m *clientMock) ScriptLoad(script string) *redis.StringCmd {
+func (m *clientMock) ScriptLoad(ctx context.Context, script string) *redis.StringCmd {
 	return m.Called(script).Get(0).(*redis.StringCmd)
 }
 
+func (m *clientMock) Info(ctx context.Context, section ...string) *redis.StringCmd {
+	return m.Called(section).Get(0).(*redis.StringCmd)
+}
+
+type MockRedisSentinel struct {
+	mock.Mock
+}
+
+func (m *MockRedisSentinel) Master(ctx context.Context, name string) *redis.StringStringMapCmd {
+	a := m.Called(name)
+	return a.Get(0).(*redis.StringStringMapCmd)
+}
+
+func (m *MockRedisSentinel) Slaves(ctx context.Context, name string) *redis.SliceCmd {
+	a := m.Called(name)
+	return a.Get(0).(*redis.SliceCmd)
+}
+
+func (m *MockRedisSentinel) Sentinels(ctx context.Context, name string) *redis.SliceCmd {
+	a := m.Called(name)
+	return a.Get(0).(*redis.SliceCmd)
+}
+
 func setSubscribeNotifications() (*pubSubMock, sdlgoredis.SubscribeFn) {
 	mock := new(pubSubMock)
-	return mock, func(client sdlgoredis.RedisClient, channels ...string) sdlgoredis.Subscriber {
+	return mock, func(ctx context.Context, client sdlgoredis.RedisClient, channels ...string) sdlgoredis.Subscriber {
 		return mock
 	}
 }
 
-func setup(commandsExists bool) (*pubSubMock, *clientMock, *sdlgoredis.DB) {
-	mock := new(clientMock)
-	pubSubMock, subscribeNotifications := setSubscribeNotifications()
-	db := sdlgoredis.CreateDB(mock, subscribeNotifications)
+func (m *MockOS) Getenv(key string, defValue string) string {
+	a := m.Called(key, defValue)
+	return a.String(0)
+}
+
+type setupEv struct {
+	pubSubMock []*pubSubMock
+	rClient    []*clientMock
+	rSentinel  []*MockRedisSentinel
+	db         []*sdlgoredis.DB
+}
+
+func setupHaEnv(commandsExists bool) (*pubSubMock, *clientMock, *sdlgoredis.DB) {
+	psm, cm, _, db := setupHaEnvWithSentinels(commandsExists, "3")
+	return psm, cm, db
+}
+
+func setupHaEnvWithSentinels(commandsExists bool, nodeCnt string) (*pubSubMock, *clientMock, []*MockRedisSentinel, *sdlgoredis.DB) {
+	setupVals := setupEnv(
+		commandsExists,
+		"service-ricplt-dbaas-tcp-cluster-0.ricplt",
+		"6376",
+		"dbaasmaster",
+		"26376",
+		"",
+		nodeCnt,
+	)
+	return setupVals.pubSubMock[0], setupVals.rClient[0], setupVals.rSentinel, setupVals.db[0]
+}
+
+func setupSingleEnv(commandsExists bool, nodeCnt string) (*pubSubMock, *clientMock, *sdlgoredis.DB) {
+	setupVals := setupEnv(
+		commandsExists,
+		"service-ricplt-dbaas-tcp-cluster-0.ricplt",
+		"6376", "", "", "", nodeCnt,
+	)
+	return setupVals.pubSubMock[0], setupVals.rClient[0], setupVals.db[0]
+}
+
+func setupEnv(commandsExists bool, host, port, msname, sntport, clsaddrlist, nodeCnt string) setupEv {
+	var ret setupEv
 
 	dummyCommandInfo := redis.CommandInfo{
 		Name: "dummy",
 	}
-	cmdResult := make(map[string]*redis.CommandInfo, 0)
 
+	cmdResult := make(map[string]*redis.CommandInfo, 0)
 	if commandsExists {
 		cmdResult = map[string]*redis.CommandInfo{
 			"setie":    &dummyCommandInfo,
@@ -166,13 +230,167 @@ func setup(commandsExists bool) (*pubSubMock, *clientMock, *sdlgoredis.DB) {
 		}
 	}
 
-	mock.On("Command").Return(redis.NewCommandsInfoCmdResult(cmdResult, nil))
-	db.CheckCommands()
-	return pubSubMock, mock, db
+	osmock := new(MockOS)
+	osmock.On("Getenv", "DBAAS_SERVICE_HOST", "localhost").Return(host)
+	osmock.On("Getenv", "DBAAS_SERVICE_PORT", "6379").Return(port)
+	osmock.On("Getenv", "DBAAS_MASTER_NAME", "").Return(msname)
+	osmock.On("Getenv", "DBAAS_SERVICE_SENTINEL_PORT", "").Return(sntport)
+	osmock.On("Getenv", "DBAAS_CLUSTER_ADDR_LIST", "").Return(clsaddrlist)
+	osmock.On("Getenv", "DBAAS_NODE_COUNT", "1").Return(nodeCnt)
+
+	pubSubMock, subscribeNotifications := setSubscribeNotifications()
+	smock := new(MockRedisSentinel)
+	ret.rSentinel = append(ret.rSentinel, smock)
+	clients := sdlgoredis.ReadConfigAndCreateDbClients(
+		osmock,
+		func(addr, port, clusterName string, isHa bool) sdlgoredis.RedisClient {
+			clm := new(clientMock)
+			clm.On("Command").Return(redis.NewCommandsInfoCmdResult(cmdResult, nil))
+			ret.rClient = append(ret.rClient, clm)
+			ret.pubSubMock = append(ret.pubSubMock, pubSubMock)
+			return clm
+		},
+		subscribeNotifications,
+		func(cfg *sdlgoredis.Config, addr string) *sdlgoredis.Sentinel {
+			s := &sdlgoredis.Sentinel{
+				IredisSentinelClient: smock,
+				Cfg:                  cfg,
+			}
+			return s
+		},
+	)
+	ret.db = clients
+	return ret
+}
+
+func newMockRedisMasterCallResp(role, ip, port, flag string) map[string]string {
+	resp := map[string]string{}
+	if role != "" {
+		resp["role-reported"] = role
+		resp["ip"] = ip
+		resp["port"] = port
+		resp["flags"] = flag
+	}
+	return resp
+}
+
+type mockRedisSlaves struct {
+	resp []interface{}
+}
+
+func newMockRedisSlavesCall() *mockRedisSlaves {
+	return new(mockRedisSlaves)
+}
+
+func (mrr *mockRedisSlaves) add(role, ip, port, link, flag string) {
+	mrr.resp = append(mrr.resp,
+		[]interface{}{
+			"role-reported", role,
+			"ip", ip,
+			"port", port,
+			"master-link-status", link,
+			"flags", flag,
+		},
+	)
+}
+
+type mockRedisSentinels struct {
+	resp []interface{}
+}
+
+func newMockRedisSentinelsCall() *mockRedisSentinels {
+	return new(mockRedisSentinels)
+}
+
+func (mrs *mockRedisSentinels) add(ip, port, flag string) {
+	mrs.resp = append(mrs.resp,
+		[]interface{}{
+			"ip", ip,
+			"port", port,
+			"flags", flag,
+		},
+	)
+}
+
+type ExpDbState struct {
+	s sdlgoredis.DbState
+}
+
+func newExpDbState(nodeCnt int, err error) *ExpDbState {
+	state := new(ExpDbState)
+	state.s.ConfigNodeCnt = nodeCnt
+	state.s.Err = err
+	return state
+}
+
+func (edbs *ExpDbState) addPrimary(role, ip, port, flag string, err error) {
+	edbs.s.PrimaryDbState.Err = err
+	edbs.s.PrimaryDbState.Fields = sdlgoredis.PrimaryDbStateFields{
+		Role:  role,
+		Ip:    ip,
+		Port:  port,
+		Flags: flag,
+	}
+}
+
+func (edbs *ExpDbState) addReplica(role, ip, port, link, flag string, err error) {
+	if edbs.s.ReplicasDbState == nil {
+		edbs.s.ReplicasDbState = new(sdlgoredis.ReplicasDbState)
+		edbs.s.ReplicasDbState.States = make([]*sdlgoredis.ReplicaDbState, 0)
+	}
+	edbs.s.ReplicasDbState.Err = err
+	if ip != "" || port != "" || link != "" || flag != "" {
+		edbs.s.ReplicasDbState.States = append(edbs.s.ReplicasDbState.States,
+			&sdlgoredis.ReplicaDbState{
+				Fields: sdlgoredis.ReplicaDbStateFields{
+					Role:              role,
+					Ip:                ip,
+					Port:              port,
+					PrimaryLinkStatus: link,
+					Flags:             flag,
+				},
+			},
+		)
+	}
+}
+
+func (edbs *ExpDbState) addSentinel(ip, port, flag string, err error) {
+	if edbs.s.SentinelsDbState == nil {
+		edbs.s.SentinelsDbState = new(sdlgoredis.SentinelsDbState)
+		edbs.s.SentinelsDbState.States = make([]*sdlgoredis.SentinelDbState, 0)
+	}
+	edbs.s.SentinelsDbState.Err = err
+	if ip != "" || port != "" || flag != "" {
+		edbs.s.SentinelsDbState.States = append(edbs.s.SentinelsDbState.States,
+			&sdlgoredis.SentinelDbState{
+				Fields: sdlgoredis.SentinelDbStateFields{
+					Ip:    ip,
+					Port:  port,
+					Flags: flag,
+				},
+			},
+		)
+	}
+}
+
+func TestCloseDbSuccessfully(t *testing.T) {
+	_, r, db := setupHaEnv(true)
+	r.On("Close").Return(nil)
+	err := db.CloseDB()
+	assert.Nil(t, err)
+	r.AssertExpectations(t)
+}
+
+func TestCloseDbFailure(t *testing.T) {
+	_, r, db := setupHaEnv(true)
+	r.On("Close").Return(errors.New("Some error"))
+	err := db.CloseDB()
+	assert.NotNil(t, err)
+	r.AssertExpectations(t)
 }
 
 func TestMSetSuccessfully(t *testing.T) {
-	_, r, db := setup(true)
+	_, r, db := setupHaEnv(true)
 	expectedKeysAndValues := []interface{}{"key1", "value1", "key2", 2}
 	r.On("MSet", expectedKeysAndValues).Return(redis.NewStatusResult("OK", nil))
 	err := db.MSet("key1", "value1", "key2", 2)
@@ -181,7 +399,7 @@ func TestMSetSuccessfully(t *testing.T) {
 }
 
 func TestMSetFailure(t *testing.T) {
-	_, r, db := setup(true)
+	_, r, db := setupHaEnv(true)
 	expectedKeysAndValues := []interface{}{"key1", "value1", "key2", 2}
 	r.On("MSet", expectedKeysAndValues).Return(redis.NewStatusResult("OK", errors.New("Some error")))
 	err := db.MSet("key1", "value1", "key2", 2)
@@ -190,7 +408,7 @@ func TestMSetFailure(t *testing.T) {
 }
 
 func TestMSetMPubSuccessfully(t *testing.T) {
-	_, r, db := setup(true)
+	_, r, db := setupHaEnv(true)
 	expectedMessage := []interface{}{"MSETMPUB", 2, 2, "key1", "val1", "key2", "val2",
 		"chan1", "event1", "chan2", "event2"}
 	r.On("Do", expectedMessage).Return(redis.NewCmdResult("", nil))
@@ -200,7 +418,7 @@ func TestMSetMPubSuccessfully(t *testing.T) {
 }
 
 func TestMsetMPubFailure(t *testing.T) {
-	_, r, db := setup(true)
+	_, r, db := setupHaEnv(true)
 	expectedMessage := []interface{}{"MSETMPUB", 2, 2, "key1", "val1", "key2", "val2",
 		"chan1", "event1", "chan2", "event2"}
 	r.On("Do", expectedMessage).Return(redis.NewCmdResult("", errors.New("Some error")))
@@ -210,7 +428,7 @@ func TestMsetMPubFailure(t *testing.T) {
 }
 
 func TestMSetMPubCommandMissing(t *testing.T) {
-	_, r, db := setup(false)
+	_, r, db := setupHaEnv(false)
 	expectedMessage := []interface{}{"MSETMPUB", 2, 2, "key1", "val1", "key2", "val2",
 		"chan1", "event1", "chan2", "event2"}
 	r.AssertNotCalled(t, "Do", expectedMessage)
@@ -221,7 +439,7 @@ func TestMSetMPubCommandMissing(t *testing.T) {
 }
 
 func TestMGetSuccessfully(t *testing.T) {
-	_, r, db := setup(true)
+	_, r, db := setupHaEnv(true)
 	expectedKeys := []string{"key1", "key2", "key3"}
 	expectedResult := []interface{}{"val1", 2, nil}
 	r.On("MGet", expectedKeys).Return(redis.NewSliceResult(expectedResult, nil))
@@ -232,7 +450,7 @@ func TestMGetSuccessfully(t *testing.T) {
 }
 
 func TestMGetFailure(t *testing.T) {
-	_, r, db := setup(true)
+	_, r, db := setupHaEnv(true)
 	expectedKeys := []string{"key1", "key2", "key3"}
 	expectedResult := []interface{}{nil}
 	r.On("MGet", expectedKeys).Return(redis.NewSliceResult(expectedResult,
@@ -244,7 +462,7 @@ func TestMGetFailure(t *testing.T) {
 }
 
 func TestDelMPubSuccessfully(t *testing.T) {
-	_, r, db := setup(true)
+	_, r, db := setupHaEnv(true)
 	expectedMessage := []interface{}{"DELMPUB", 2, 2, "key1", "key2", "chan1", "event1",
 		"chan2", "event2"}
 	r.On("Do", expectedMessage).Return(redis.NewCmdResult("", nil))
@@ -254,7 +472,7 @@ func TestDelMPubSuccessfully(t *testing.T) {
 }
 
 func TestDelMPubFailure(t *testing.T) {
-	_, r, db := setup(true)
+	_, r, db := setupHaEnv(true)
 	expectedMessage := []interface{}{"DELMPUB", 2, 2, "key1", "key2", "chan1", "event1",
 		"chan2", "event2"}
 	r.On("Do", expectedMessage).Return(redis.NewCmdResult("", errors.New("Some error")))
@@ -264,7 +482,7 @@ func TestDelMPubFailure(t *testing.T) {
 }
 
 func TestDelMPubCommandMissing(t *testing.T) {
-	_, r, db := setup(false)
+	_, r, db := setupHaEnv(false)
 	expectedMessage := []interface{}{"DELMPUB", 2, 2, "key1", "key2", "chan1", "event1",
 		"chan2", "event2"}
 	r.AssertNotCalled(t, "Do", expectedMessage)
@@ -274,7 +492,7 @@ func TestDelMPubCommandMissing(t *testing.T) {
 }
 
 func TestDelSuccessfully(t *testing.T) {
-	_, r, db := setup(true)
+	_, r, db := setupHaEnv(true)
 	expectedKeys := []string{"key1", "key2"}
 	r.On("Del", expectedKeys).Return(redis.NewIntResult(2, nil))
 	assert.Nil(t, db.Del([]string{"key1", "key2"}))
@@ -282,7 +500,7 @@ func TestDelSuccessfully(t *testing.T) {
 }
 
 func TestDelFailure(t *testing.T) {
-	_, r, db := setup(true)
+	_, r, db := setupHaEnv(true)
 	expectedKeys := []string{"key1", "key2"}
 	r.On("Del", expectedKeys).Return(redis.NewIntResult(2, errors.New("Some error")))
 	assert.NotNil(t, db.Del([]string{"key1", "key2"}))
@@ -290,7 +508,7 @@ func TestDelFailure(t *testing.T) {
 }
 
 func TestKeysSuccessfully(t *testing.T) {
-	_, r, db := setup(true)
+	_, r, db := setupHaEnv(true)
 	expectedPattern := "pattern*"
 	expectedResult := []string{"pattern1", "pattern2"}
 	r.On("Keys", expectedPattern).Return(redis.NewStringSliceResult(expectedResult, nil))
@@ -301,7 +519,7 @@ func TestKeysSuccessfully(t *testing.T) {
 }
 
 func TestKeysFailure(t *testing.T) {
-	_, r, db := setup(true)
+	_, r, db := setupHaEnv(true)
 	expectedPattern := "pattern*"
 	expectedResult := []string{}
 	r.On("Keys", expectedPattern).Return(redis.NewStringSliceResult(expectedResult,
@@ -312,7 +530,7 @@ func TestKeysFailure(t *testing.T) {
 }
 
 func TestSetIEKeyExists(t *testing.T) {
-	_, r, db := setup(true)
+	_, r, db := setupHaEnv(true)
 	expectedMessage := []interface{}{"SETIE", "key", "newdata", "olddata"}
 	r.On("Do", expectedMessage).Return(redis.NewCmdResult("OK", nil))
 	result, err := db.SetIE("key", "olddata", "newdata")
@@ -322,7 +540,7 @@ func TestSetIEKeyExists(t *testing.T) {
 }
 
 func TestSetIEKeyDoesntExists(t *testing.T) {
-	_, r, db := setup(true)
+	_, r, db := setupHaEnv(true)
 	expectedMessage := []interface{}{"SETIE", "key", "newdata", "olddata"}
 	r.On("Do", expectedMessage).Return(redis.NewCmdResult(nil, nil))
 	result, err := db.SetIE("key", "olddata", "newdata")
@@ -332,7 +550,7 @@ func TestSetIEKeyDoesntExists(t *testing.T) {
 }
 
 func TestSetIEFailure(t *testing.T) {
-	_, r, db := setup(true)
+	_, r, db := setupHaEnv(true)
 	expectedMessage := []interface{}{"SETIE", "key", "newdata", "olddata"}
 	r.On("Do", expectedMessage).Return(redis.NewCmdResult(nil, errors.New("Some error")))
 	result, err := db.SetIE("key", "olddata", "newdata")
@@ -342,7 +560,7 @@ func TestSetIEFailure(t *testing.T) {
 }
 
 func TestSetIECommandMissing(t *testing.T) {
-	_, r, db := setup(false)
+	_, r, db := setupHaEnv(false)
 	expectedMessage := []interface{}{"SETIE", "key", "newdata", "olddata"}
 	r.AssertNotCalled(t, "Do", expectedMessage)
 	result, err := db.SetIE("key", "olddata", "newdata")
@@ -352,87 +570,87 @@ func TestSetIECommandMissing(t *testing.T) {
 }
 
 func TestSetIEPubKeyExists(t *testing.T) {
-	_, r, db := setup(true)
-	expectedMessage := []interface{}{"SETIEPUB", "key", "newdata", "olddata", "channel", "message"}
+	_, r, db := setupHaEnv(true)
+	expectedMessage := []interface{}{"SETIEMPUB", "key", "newdata", "olddata", "channel", "message"}
 	r.On("Do", expectedMessage).Return(redis.NewCmdResult("OK", nil))
-	result, err := db.SetIEPub("channel", "message", "key", "olddata", "newdata")
+	result, err := db.SetIEPub([]string{"channel", "message"}, "key", "olddata", "newdata")
 	assert.True(t, result)
 	assert.Nil(t, err)
 	r.AssertExpectations(t)
 }
 
 func TestSetIEPubKeyDoesntExists(t *testing.T) {
-	_, r, db := setup(true)
-	expectedMessage := []interface{}{"SETIEPUB", "key", "newdata", "olddata", "channel", "message"}
+	_, r, db := setupHaEnv(true)
+	expectedMessage := []interface{}{"SETIEMPUB", "key", "newdata", "olddata", "channel", "message"}
 	r.On("Do", expectedMessage).Return(redis.NewCmdResult(nil, nil))
-	result, err := db.SetIEPub("channel", "message", "key", "olddata", "newdata")
+	result, err := db.SetIEPub([]string{"channel", "message"}, "key", "olddata", "newdata")
 	assert.False(t, result)
 	assert.Nil(t, err)
 	r.AssertExpectations(t)
 }
 
 func TestSetIEPubFailure(t *testing.T) {
-	_, r, db := setup(true)
-	expectedMessage := []interface{}{"SETIEPUB", "key", "newdata", "olddata", "channel", "message"}
+	_, r, db := setupHaEnv(true)
+	expectedMessage := []interface{}{"SETIEMPUB", "key", "newdata", "olddata", "channel", "message"}
 	r.On("Do", expectedMessage).Return(redis.NewCmdResult(nil, errors.New("Some error")))
-	result, err := db.SetIEPub("channel", "message", "key", "olddata", "newdata")
+	result, err := db.SetIEPub([]string{"channel", "message"}, "key", "olddata", "newdata")
 	assert.False(t, result)
 	assert.NotNil(t, err)
 	r.AssertExpectations(t)
 }
 
 func TestSetIEPubCommandMissing(t *testing.T) {
-	_, r, db := setup(false)
-	expectedMessage := []interface{}{"SETIEPUB", "key", "newdata", "olddata", "channel", "message"}
+	_, r, db := setupHaEnv(false)
+	expectedMessage := []interface{}{"SETIEMPUB", "key", "newdata", "olddata", "channel", "message"}
 	r.AssertNotCalled(t, "Do", expectedMessage)
-	result, err := db.SetIEPub("channel", "message", "key", "olddata", "newdata")
+	result, err := db.SetIEPub([]string{"channel", "message"}, "key", "olddata", "newdata")
 	assert.False(t, result)
 	assert.NotNil(t, err)
 	r.AssertExpectations(t)
 }
 
 func TestSetNXPubKeyDoesntExist(t *testing.T) {
-	_, r, db := setup(true)
-	expectedMessage := []interface{}{"SETNXPUB", "key", "data", "channel", "message"}
+	_, r, db := setupHaEnv(true)
+	expectedMessage := []interface{}{"SETNXMPUB", "key", "data", "channel", "message"}
 	r.On("Do", expectedMessage).Return(redis.NewCmdResult("OK", nil))
-	result, err := db.SetNXPub("channel", "message", "key", "data")
+	result, err := db.SetNXPub([]string{"channel", "message"}, "key", "data")
 	assert.True(t, result)
 	assert.Nil(t, err)
 	r.AssertExpectations(t)
 }
 
 func TestSetNXPubKeyExists(t *testing.T) {
-	_, r, db := setup(true)
-	expectedMessage := []interface{}{"SETNXPUB", "key", "data", "channel", "message"}
+	_, r, db := setupHaEnv(true)
+	expectedMessage := []interface{}{"SETNXMPUB", "key", "data", "channel", "message"}
 	r.On("Do", expectedMessage).Return(redis.NewCmdResult(nil, nil))
-	result, err := db.SetNXPub("channel", "message", "key", "data")
+	result, err := db.SetNXPub([]string{"channel", "message"}, "key", "data")
 	assert.False(t, result)
 	assert.Nil(t, err)
 	r.AssertExpectations(t)
 }
 
 func TestSetNXPubFailure(t *testing.T) {
-	_, r, db := setup(true)
-	expectedMessage := []interface{}{"SETNXPUB", "key", "data", "channel", "message"}
+	_, r, db := setupHaEnv(true)
+	expectedMessage := []interface{}{"SETNXMPUB", "key", "data", "channel", "message"}
 	r.On("Do", expectedMessage).Return(redis.NewCmdResult(nil, errors.New("Some error")))
-	result, err := db.SetNXPub("channel", "message", "key", "data")
+	result, err := db.SetNXPub([]string{"channel", "message"}, "key", "data")
 	assert.False(t, result)
 	assert.NotNil(t, err)
 	r.AssertExpectations(t)
 }
 
 func TestSetNXPubCommandMissing(t *testing.T) {
-	_, r, db := setup(false)
-	expectedMessage := []interface{}{"SETNXPUB", "key", "data", "channel", "message"}
+	_, r, db := setupHaEnv(false)
+	expectedMessage := []interface{}{"SETNXMPUB", "key", "data", "channel", "message"}
 	r.AssertNotCalled(t, "Do", expectedMessage)
-	result, err := db.SetNXPub("channel", "message", "key", "data")
+	result, err := db.SetNXPub([]string{"channel", "message"}, "key", "data")
 	assert.False(t, result)
 	assert.NotNil(t, err)
 	r.AssertExpectations(t)
 }
 
 func TestSetNXSuccessfully(t *testing.T) {
-	_, r, db := setup(true)
+	_, r, db := setupHaEnv(true)
 	expectedKey := "key"
 	expectedData := "data"
 	r.On("SetNX", expectedKey, expectedData, time.Duration(0)).Return(redis.NewBoolResult(true, nil))
@@ -443,7 +661,7 @@ func TestSetNXSuccessfully(t *testing.T) {
 }
 
 func TestSetNXUnsuccessfully(t *testing.T) {
-	_, r, db := setup(true)
+	_, r, db := setupHaEnv(true)
 	expectedKey := "key"
 	expectedData := "data"
 	r.On("SetNX", expectedKey, expectedData, time.Duration(0)).Return(redis.NewBoolResult(false, nil))
@@ -454,7 +672,7 @@ func TestSetNXUnsuccessfully(t *testing.T) {
 }
 
 func TestSetNXFailure(t *testing.T) {
-	_, r, db := setup(true)
+	_, r, db := setupHaEnv(true)
 	expectedKey := "key"
 	expectedData := "data"
 	r.On("SetNX", expectedKey, expectedData, time.Duration(0)).
@@ -466,49 +684,59 @@ func TestSetNXFailure(t *testing.T) {
 }
 
 func TestDelIEPubKeyDoesntExist(t *testing.T) {
-	_, r, db := setup(true)
-	expectedMessage := []interface{}{"DELIEPUB", "key", "data", "channel", "message"}
-	r.On("Do", expectedMessage).Return(redis.NewCmdResult(0, nil))
-	result, err := db.DelIEPub("channel", "message", "key", "data")
+	_, r, db := setupHaEnv(true)
+	expectedMessage := []interface{}{"DELIEMPUB", "key", "data", "channel", "message"}
+	r.On("Do", expectedMessage).Return(redis.NewCmdResult(int64(0), nil))
+	result, err := db.DelIEPub([]string{"channel", "message"}, "key", "data")
 	assert.False(t, result)
 	assert.Nil(t, err)
 	r.AssertExpectations(t)
 }
 
 func TestDelIEPubKeyExists(t *testing.T) {
-	_, r, db := setup(true)
-	expectedMessage := []interface{}{"DELIEPUB", "key", "data", "channel", "message"}
+	_, r, db := setupHaEnv(true)
+	expectedMessage := []interface{}{"DELIEMPUB", "key", "data", "channel", "message"}
+	r.On("Do", expectedMessage).Return(redis.NewCmdResult(int64(1), nil))
+	result, err := db.DelIEPub([]string{"channel", "message"}, "key", "data")
+	assert.True(t, result)
+	assert.Nil(t, err)
+	r.AssertExpectations(t)
+}
+
+func TestDelIEPubKeyExistsIntTypeRedisValue(t *testing.T) {
+	_, r, db := setupHaEnv(true)
+	expectedMessage := []interface{}{"DELIEMPUB", "key", "data", "channel", "message"}
 	r.On("Do", expectedMessage).Return(redis.NewCmdResult(1, nil))
-	result, err := db.DelIEPub("channel", "message", "key", "data")
+	result, err := db.DelIEPub([]string{"channel", "message"}, "key", "data")
 	assert.True(t, result)
 	assert.Nil(t, err)
 	r.AssertExpectations(t)
 }
 
 func TestDelIEPubFailure(t *testing.T) {
-	_, r, db := setup(true)
-	expectedMessage := []interface{}{"DELIEPUB", "key", "data", "channel", "message"}
-	r.On("Do", expectedMessage).Return(redis.NewCmdResult(0, errors.New("Some error")))
-	result, err := db.DelIEPub("channel", "message", "key", "data")
+	_, r, db := setupHaEnv(true)
+	expectedMessage := []interface{}{"DELIEMPUB", "key", "data", "channel", "message"}
+	r.On("Do", expectedMessage).Return(redis.NewCmdResult(int64(0), errors.New("Some error")))
+	result, err := db.DelIEPub([]string{"channel", "message"}, "key", "data")
 	assert.False(t, result)
 	assert.NotNil(t, err)
 	r.AssertExpectations(t)
 }
 
 func TestDelIEPubCommandMissing(t *testing.T) {
-	_, r, db := setup(false)
-	expectedMessage := []interface{}{"DELIEPUB", "key", "data", "channel", "message"}
+	_, r, db := setupHaEnv(false)
+	expectedMessage := []interface{}{"DELIEMPUB", "key", "data", "channel", "message"}
 	r.AssertNotCalled(t, "Do", expectedMessage)
-	result, err := db.DelIEPub("channel", "message", "key", "data")
+	result, err := db.DelIEPub([]string{"channel", "message"}, "key", "data")
 	assert.False(t, result)
 	assert.NotNil(t, err)
 	r.AssertExpectations(t)
 }
 
 func TestDelIEKeyDoesntExist(t *testing.T) {
-	_, r, db := setup(true)
+	_, r, db := setupHaEnv(true)
 	expectedMessage := []interface{}{"DELIE", "key", "data"}
-	r.On("Do", expectedMessage).Return(redis.NewCmdResult(0, nil))
+	r.On("Do", expectedMessage).Return(redis.NewCmdResult(int64(0), nil))
 	result, err := db.DelIE("key", "data")
 	assert.False(t, result)
 	assert.Nil(t, err)
@@ -516,7 +744,17 @@ func TestDelIEKeyDoesntExist(t *testing.T) {
 }
 
 func TestDelIEKeyExists(t *testing.T) {
-	_, r, db := setup(true)
+	_, r, db := setupHaEnv(true)
+	expectedMessage := []interface{}{"DELIE", "key", "data"}
+	r.On("Do", expectedMessage).Return(redis.NewCmdResult(int64(1), nil))
+	result, err := db.DelIE("key", "data")
+	assert.True(t, result)
+	assert.Nil(t, err)
+	r.AssertExpectations(t)
+}
+
+func TestDelIEKeyExistsIntTypeRedisValue(t *testing.T) {
+	_, r, db := setupHaEnv(true)
 	expectedMessage := []interface{}{"DELIE", "key", "data"}
 	r.On("Do", expectedMessage).Return(redis.NewCmdResult(1, nil))
 	result, err := db.DelIE("key", "data")
@@ -526,9 +764,9 @@ func TestDelIEKeyExists(t *testing.T) {
 }
 
 func TestDelIEFailure(t *testing.T) {
-	_, r, db := setup(true)
+	_, r, db := setupHaEnv(true)
 	expectedMessage := []interface{}{"DELIE", "key", "data"}
-	r.On("Do", expectedMessage).Return(redis.NewCmdResult(0, errors.New("Some error")))
+	r.On("Do", expectedMessage).Return(redis.NewCmdResult(int64(0), errors.New("Some error")))
 	result, err := db.DelIE("key", "data")
 	assert.False(t, result)
 	assert.NotNil(t, err)
@@ -536,7 +774,7 @@ func TestDelIEFailure(t *testing.T) {
 }
 
 func TestDelIECommandMissing(t *testing.T) {
-	_, r, db := setup(false)
+	_, r, db := setupHaEnv(false)
 	expectedMessage := []interface{}{"DELIE", "key", "data"}
 	r.AssertNotCalled(t, "Do", expectedMessage)
 	result, err := db.DelIE("key", "data")
@@ -546,7 +784,7 @@ func TestDelIECommandMissing(t *testing.T) {
 }
 
 func TestSAddSuccessfully(t *testing.T) {
-	_, r, db := setup(true)
+	_, r, db := setupHaEnv(true)
 	expectedKey := "key"
 	expectedData := []interface{}{"data", 2}
 	r.On("SAdd", expectedKey, expectedData).Return(redis.NewIntResult(2, nil))
@@ -555,7 +793,7 @@ func TestSAddSuccessfully(t *testing.T) {
 }
 
 func TestSAddFailure(t *testing.T) {
-	_, r, db := setup(true)
+	_, r, db := setupHaEnv(true)
 	expectedKey := "key"
 	expectedData := []interface{}{"data", 2}
 	r.On("SAdd", expectedKey, expectedData).Return(redis.NewIntResult(2, errors.New("Some error")))
@@ -564,7 +802,7 @@ func TestSAddFailure(t *testing.T) {
 }
 
 func TestSRemSuccessfully(t *testing.T) {
-	_, r, db := setup(true)
+	_, r, db := setupHaEnv(true)
 	expectedKey := "key"
 	expectedData := []interface{}{"data", 2}
 	r.On("SRem", expectedKey, expectedData).Return(redis.NewIntResult(2, nil))
@@ -573,7 +811,7 @@ func TestSRemSuccessfully(t *testing.T) {
 }
 
 func TestSRemFailure(t *testing.T) {
-	_, r, db := setup(true)
+	_, r, db := setupHaEnv(true)
 	expectedKey := "key"
 	expectedData := []interface{}{"data", 2}
 	r.On("SRem", expectedKey, expectedData).Return(redis.NewIntResult(2, errors.New("Some error")))
@@ -582,7 +820,7 @@ func TestSRemFailure(t *testing.T) {
 }
 
 func TestSMembersSuccessfully(t *testing.T) {
-	_, r, db := setup(true)
+	_, r, db := setupHaEnv(true)
 	expectedKey := "key"
 	expectedResult := []string{"member1", "member2"}
 	r.On("SMembers", expectedKey).Return(redis.NewStringSliceResult(expectedResult, nil))
@@ -593,7 +831,7 @@ func TestSMembersSuccessfully(t *testing.T) {
 }
 
 func TestSMembersFailure(t *testing.T) {
-	_, r, db := setup(true)
+	_, r, db := setupHaEnv(true)
 	expectedKey := "key"
 	expectedResult := []string{"member1", "member2"}
 	r.On("SMembers", expectedKey).Return(redis.NewStringSliceResult(expectedResult,
@@ -605,7 +843,7 @@ func TestSMembersFailure(t *testing.T) {
 }
 
 func TestSIsMemberIsMember(t *testing.T) {
-	_, r, db := setup(true)
+	_, r, db := setupHaEnv(true)
 	expectedKey := "key"
 	expectedData := "data"
 	r.On("SIsMember", expectedKey, expectedData).Return(redis.NewBoolResult(true, nil))
@@ -616,7 +854,7 @@ func TestSIsMemberIsMember(t *testing.T) {
 }
 
 func TestSIsMemberIsNotMember(t *testing.T) {
-	_, r, db := setup(true)
+	_, r, db := setupHaEnv(true)
 	expectedKey := "key"
 	expectedData := "data"
 	r.On("SIsMember", expectedKey, expectedData).Return(redis.NewBoolResult(false, nil))
@@ -627,7 +865,7 @@ func TestSIsMemberIsNotMember(t *testing.T) {
 }
 
 func TestSIsMemberFailure(t *testing.T) {
-	_, r, db := setup(true)
+	_, r, db := setupHaEnv(true)
 	expectedKey := "key"
 	expectedData := "data"
 	r.On("SIsMember", expectedKey, expectedData).
@@ -639,7 +877,7 @@ func TestSIsMemberFailure(t *testing.T) {
 }
 
 func TestSCardSuccessfully(t *testing.T) {
-	_, r, db := setup(true)
+	_, r, db := setupHaEnv(true)
 	expectedKey := "key"
 	r.On("SCard", expectedKey).Return(redis.NewIntResult(1, nil))
 	result, err := db.SCard("key")
@@ -649,7 +887,7 @@ func TestSCardSuccessfully(t *testing.T) {
 }
 
 func TestSCardFailure(t *testing.T) {
-	_, r, db := setup(true)
+	_, r, db := setupHaEnv(true)
 	expectedKey := "key"
 	r.On("SCard", expectedKey).Return(redis.NewIntResult(1, errors.New("Some error")))
 	result, err := db.SCard("key")
@@ -659,7 +897,7 @@ func TestSCardFailure(t *testing.T) {
 }
 
 func TestSubscribeChannelDBSubscribeRXUnsubscribe(t *testing.T) {
-	ps, r, db := setup(true)
+	ps, r, db := setupHaEnv(true)
 	ch := make(chan *redis.Message)
 	msg := redis.Message{
 		Channel: "{prefix}channel",
@@ -685,7 +923,7 @@ func TestSubscribeChannelDBSubscribeRXUnsubscribe(t *testing.T) {
 }
 
 func TestSubscribeChannelDBSubscribeTwoUnsubscribeOne(t *testing.T) {
-	ps, r, db := setup(true)
+	ps, r, db := setupHaEnv(true)
 	ch := make(chan *redis.Message)
 	msg1 := redis.Message{
 		Channel: "{prefix}channel1",
@@ -728,7 +966,7 @@ func TestSubscribeChannelDBSubscribeTwoUnsubscribeOne(t *testing.T) {
 }
 
 func TestSubscribeChannelReDBSubscribeAfterUnsubscribe(t *testing.T) {
-	ps, r, db := setup(true)
+	ps, r, db := setupHaEnv(true)
 	ch := make(chan *redis.Message)
 	msg := redis.Message{
 		Channel: "{prefix}channel",
@@ -764,7 +1002,7 @@ func TestSubscribeChannelReDBSubscribeAfterUnsubscribe(t *testing.T) {
 }
 
 func TestPTTLSuccessfully(t *testing.T) {
-	_, r, db := setup(true)
+	_, r, db := setupHaEnv(true)
 	expectedKey := "key"
 	expectedResult := time.Duration(1)
 	r.On("PTTL", expectedKey).Return(redis.NewDurationResult(expectedResult,
@@ -776,7 +1014,7 @@ func TestPTTLSuccessfully(t *testing.T) {
 }
 
 func TestPTTLFailure(t *testing.T) {
-	_, r, db := setup(true)
+	_, r, db := setupHaEnv(true)
 	expectedKey := "key"
 	expectedResult := time.Duration(1)
 	r.On("PTTL", expectedKey).Return(redis.NewDurationResult(expectedResult,
@@ -788,7 +1026,7 @@ func TestPTTLFailure(t *testing.T) {
 }
 
 func TestPExpireIESuccessfully(t *testing.T) {
-	_, r, db := setup(true)
+	_, r, db := setupHaEnv(true)
 	expectedKey := "key"
 	expectedData := "data"
 	expectedDuration := strconv.FormatInt(int64(10000), 10)
@@ -802,7 +1040,7 @@ func TestPExpireIESuccessfully(t *testing.T) {
 }
 
 func TestPExpireIEFailure(t *testing.T) {
-	_, r, db := setup(true)
+	_, r, db := setupHaEnv(true)
 	expectedKey := "key"
 	expectedData := "data"
 	expectedDuration := strconv.FormatInt(int64(10000), 10)
@@ -816,7 +1054,7 @@ func TestPExpireIEFailure(t *testing.T) {
 }
 
 func TestPExpireIELockNotHeld(t *testing.T) {
-	_, r, db := setup(true)
+	_, r, db := setupHaEnv(true)
 	expectedKey := "key"
 	expectedData := "data"
 	expectedDuration := strconv.FormatInt(int64(10000), 10)
@@ -828,3 +1066,523 @@ func TestPExpireIELockNotHeld(t *testing.T) {
 	assert.NotNil(t, err)
 	r.AssertExpectations(t)
 }
+
+func TestClientStandaloneRedisLegacyEnv(t *testing.T) {
+	setupVals := setupEnv(
+		true,
+		"service-ricplt-dbaas-tcp-cluster-0.ricplt", "6376", "", "", "", "",
+	)
+	assert.Equal(t, 1, len(setupVals.rClient))
+	assert.Equal(t, 1, len(setupVals.db))
+
+	expectedKeysAndValues := []interface{}{"key1", "value1"}
+	setupVals.rClient[0].On("MSet", expectedKeysAndValues).Return(redis.NewStatusResult("OK", nil))
+	err := setupVals.db[0].MSet("key1", "value1")
+	assert.Nil(t, err)
+	setupVals.rClient[0].AssertExpectations(t)
+}
+
+func TestClientSentinelRedisLegacyEnv(t *testing.T) {
+	setupVals := setupEnv(
+		true,
+		"service-ricplt-dbaas-tcp-cluster-0.ricplt", "6376", "dbaasmaster", "26376", "", "3",
+	)
+	assert.Equal(t, 1, len(setupVals.rClient))
+	assert.Equal(t, 1, len(setupVals.db))
+
+	expectedKeysAndValues := []interface{}{"key1", "value1"}
+	setupVals.rClient[0].On("MSet", expectedKeysAndValues).Return(redis.NewStatusResult("OK", nil))
+	err := setupVals.db[0].MSet("key1", "value1")
+	assert.Nil(t, err)
+	setupVals.rClient[0].AssertExpectations(t)
+}
+
+func TestClientTwoStandaloneRedisEnvs(t *testing.T) {
+	setupVals := setupEnv(
+		true,
+		"service-ricplt-dbaas-tcp-cluster-0.ricplt", "6376", "", "",
+		"service-ricplt-dbaas-tcp-cluster-0.ricplt,service-ricplt-dbaas-tcp-cluster-1.ricplt", "",
+	)
+	assert.Equal(t, 2, len(setupVals.rClient))
+	assert.Equal(t, 2, len(setupVals.db))
+
+	expectedKeysAndValues := []interface{}{"key1", "value1"}
+	setupVals.rClient[0].On("MSet", expectedKeysAndValues).Return(redis.NewStatusResult("OK", nil))
+	err := setupVals.db[0].MSet("key1", "value1")
+	assert.Nil(t, err)
+	setupVals.rClient[0].AssertExpectations(t)
+
+	expectedKeysAndValues = []interface{}{"key2", "value2"}
+	setupVals.rClient[1].On("MSet", expectedKeysAndValues).Return(redis.NewStatusResult("OK", nil))
+	err = setupVals.db[1].MSet("key2", "value2")
+	assert.Nil(t, err)
+	setupVals.rClient[0].AssertExpectations(t)
+	setupVals.rClient[1].AssertExpectations(t)
+}
+
+func TestClientTwoSentinelRedisEnvs(t *testing.T) {
+	setupVals := setupEnv(
+		true,
+		"service-ricplt-dbaas-tcp-cluster-0.ricplt", "6376", "dbaasmaster", "26376",
+		"service-ricplt-dbaas-tcp-cluster-0.ricplt,service-ricplt-dbaas-tcp-cluster-1.ricplt", "3",
+	)
+	assert.Equal(t, 2, len(setupVals.rClient))
+	assert.Equal(t, 2, len(setupVals.db))
+
+	expectedKeysAndValues := []interface{}{"key1", "value1"}
+	setupVals.rClient[0].On("MSet", expectedKeysAndValues).Return(redis.NewStatusResult("OK", nil))
+	err := setupVals.db[0].MSet("key1", "value1")
+	assert.Nil(t, err)
+	setupVals.rClient[0].AssertExpectations(t)
+
+	expectedKeysAndValues = []interface{}{"key2", "value2"}
+	setupVals.rClient[1].On("MSet", expectedKeysAndValues).Return(redis.NewStatusResult("OK", nil))
+	err = setupVals.db[1].MSet("key2", "value2")
+	assert.Nil(t, err)
+	setupVals.rClient[0].AssertExpectations(t)
+	setupVals.rClient[1].AssertExpectations(t)
+}
+
+func TestInfoOfPrimaryRedisWithTwoReplicasSuccessfully(t *testing.T) {
+	_, r, db := setupHaEnv(true)
+	redisInfo := "# Replication\r\n" +
+		"role:master\r\n" +
+		"connected_slaves:2\r\n" +
+		"min_slaves_good_slaves:2\r\n" +
+		"slave0:ip=1.2.3.4,port=6379,state=online,offset=100200300,lag=0\r\n" +
+		"slave1:ip=5.6.7.8,port=6379,state=online,offset=100200300,lag=0\r\n"
+	expInfo := &sdlgoredis.DbInfo{
+		Fields: sdlgoredis.DbInfoFields{
+			PrimaryRole:         true,
+			ConnectedReplicaCnt: 2,
+		},
+	}
+
+	r.On("Info", []string{"all"}).Return(redis.NewStringResult(redisInfo, nil))
+	info, err := db.Info()
+	assert.Nil(t, err)
+	assert.Equal(t, expInfo, info)
+	r.AssertExpectations(t)
+}
+
+func TestInfoOfPrimaryRedisWithOneReplicaOnlineAndOtherReplicaNotOnlineSuccessfully(t *testing.T) {
+	_, r, db := setupHaEnv(true)
+	redisInfo := "# Replication\r\n" +
+		"role:master\r\n" +
+		"connected_slaves:1\r\n" +
+		"min_slaves_good_slaves:2\r\n" +
+		"slave0:ip=1.2.3.4,port=6379,state=online,offset=100200300,lag=0\r\n" +
+		"slave1:ip=5.6.7.8,port=6379,state=wait_bgsave,offset=100200300,lag=0\r\n"
+	expInfo := &sdlgoredis.DbInfo{
+		Fields: sdlgoredis.DbInfoFields{
+			PrimaryRole:         true,
+			ConnectedReplicaCnt: 1,
+		},
+	}
+
+	r.On("Info", []string{"all"}).Return(redis.NewStringResult(redisInfo, nil))
+	info, err := db.Info()
+	assert.Nil(t, err)
+	assert.Equal(t, expInfo, info)
+	r.AssertExpectations(t)
+}
+
+func TestInfoOfStandalonePrimaryRedisSuccessfully(t *testing.T) {
+	_, r, db := setupHaEnv(true)
+	redisInfo := "# Replication\r\n" +
+		"role:master\r\n" +
+		"connected_slaves:0\r\n" +
+		"min_slaves_good_slaves:0\r\n"
+	expInfo := &sdlgoredis.DbInfo{
+		Fields: sdlgoredis.DbInfoFields{
+			PrimaryRole:         true,
+			ConnectedReplicaCnt: 0,
+		},
+	}
+
+	r.On("Info", []string{"all"}).Return(redis.NewStringResult(redisInfo, nil))
+	info, err := db.Info()
+	assert.Nil(t, err)
+	assert.Equal(t, expInfo, info)
+	r.AssertExpectations(t)
+}
+
+func TestInfoOfStandalonePrimaryRedisFailureWhenIntConversionFails(t *testing.T) {
+	_, r, db := setupHaEnv(true)
+	redisInfo := "# Replication\r\n" +
+		"role:master\r\n" +
+		"connected_slaves:not-int\r\n" +
+		"min_slaves_good_slaves:0\r\n"
+	expInfo := &sdlgoredis.DbInfo{
+		Fields: sdlgoredis.DbInfoFields{
+			PrimaryRole:         true,
+			ConnectedReplicaCnt: 0,
+		},
+	}
+
+	r.On("Info", []string{"all"}).Return(redis.NewStringResult(redisInfo, nil))
+	info, err := db.Info()
+	assert.Nil(t, err)
+	assert.Equal(t, expInfo, info)
+	r.AssertExpectations(t)
+}
+
+func TestInfoWithGibberishContentSuccessfully(t *testing.T) {
+	_, r, db := setupHaEnv(true)
+	redisInfo := "!#¤%&?+?´-\r\n"
+	expInfo := &sdlgoredis.DbInfo{}
+
+	r.On("Info", []string{"all"}).Return(redis.NewStringResult(redisInfo, nil))
+	info, err := db.Info()
+	assert.Nil(t, err)
+	assert.Equal(t, expInfo, info)
+	r.AssertExpectations(t)
+}
+
+func TestInfoWithEmptyContentSuccessfully(t *testing.T) {
+	_, r, db := setupHaEnv(true)
+	var redisInfo string
+	expInfo := &sdlgoredis.DbInfo{
+		Fields: sdlgoredis.DbInfoFields{
+			PrimaryRole: false,
+		},
+	}
+
+	r.On("Info", []string{"all"}).Return(redis.NewStringResult(redisInfo, nil))
+	info, err := db.Info()
+	assert.Nil(t, err)
+	assert.Equal(t, expInfo, info)
+	r.AssertExpectations(t)
+}
+
+func TestInfoWithSomeStatisticsOfStandalonePrimaryRedis(t *testing.T) {
+	_, r, db := setupHaEnv(true)
+	redisInfo := "# Replication\r\n" +
+		"role:master\r\n" +
+		"connected_slaves:0\r\n" +
+		"min_slaves_good_slaves:0\r\n" +
+		"# Server\r\n" +
+		"uptime_in_days:23\r\n" +
+		"# Clients\r\n" +
+		"connected_clients:2\r\n" +
+		"# Memory\r\n" +
+		"used_memory:2093808\r\n" +
+		"used_memory_human:2.00M\r\n" +
+		"mem_fragmentation_ratio:6.44\r\n" +
+		"# Stats\r\n" +
+		"total_connections_received:278\r\n" +
+		"# CPU\r\n" +
+		"used_cpu_sys:1775.254919\r\n" +
+		"# Commandstats\r\n" +
+		"cmdstat_role:calls=1,usec=3,usec_per_call=3.00\r\n" +
+		"# Keyspace\r\n" +
+		"db0:keys=4,expires=0,avg_ttl=0"
+	expInfo := &sdlgoredis.DbInfo{
+		Fields: sdlgoredis.DbInfoFields{
+			PrimaryRole:         true,
+			ConnectedReplicaCnt: 0,
+			Server: sdlgoredis.ServerInfoFields{
+				UptimeInDays: 23,
+			},
+			Clients: sdlgoredis.ClientsInfoFields{
+				ConnectedClients: 2,
+			},
+			Memory: sdlgoredis.MeroryInfoFields{
+				UsedMemory:            2093808,
+				UsedMemoryHuman:       "2.00M",
+				MemFragmentationRatio: 6.44,
+			},
+			Stats: sdlgoredis.StatsInfoFields{
+				TotalConnectionsReceived: 278,
+			},
+			Cpu: sdlgoredis.CpuInfoFields{
+				UsedCpuSys: 1775.254919,
+			},
+			Commandstats: sdlgoredis.CommandstatsInfoFields{
+				CmdstatRole: sdlgoredis.CommandstatsValues{
+					Calls:       1,
+					Usec:        3,
+					UsecPerCall: 3.00,
+				},
+			},
+			Keyspace: sdlgoredis.KeyspaceInfoFields{
+				Db: sdlgoredis.KeyspaceValues{
+					Keys: 4,
+				},
+			},
+		},
+	}
+
+	r.On("Info", []string{"all"}).Return(redis.NewStringResult(redisInfo, nil))
+	info, err := db.Info()
+	assert.Nil(t, err)
+	assert.Equal(t, expInfo, info)
+	r.AssertExpectations(t)
+}
+
+func TestStateWithPrimaryAndTwoReplicaRedisSuccessfully(t *testing.T) {
+	_, r, s, db := setupHaEnvWithSentinels(true, "3")
+
+	redisPrimaryState := newMockRedisMasterCallResp("master", "10.20.30.30", "6379", "master")
+	redisReplicasState := newMockRedisSlavesCall()
+	redisReplicasState.add("slave", "10.20.30.40", "6379", "up", "slave")
+	redisReplicasState.add("slave", "10.20.30.50", "30000", "up", "slave")
+	redisSentinelsState := newMockRedisSentinelsCall()
+	redisSentinelsState.add("10.20.30.40", "26379", "sentinel")
+	redisSentinelsState.add("10.20.30.50", "30001", "sentinel")
+
+	expState := newExpDbState(3, nil)
+	expState.addPrimary("master", "10.20.30.30", "6379", "master", nil)
+	expState.addReplica("slave", "10.20.30.40", "6379", "up", "slave", nil)
+	expState.addReplica("slave", "10.20.30.50", "30000", "up", "slave", nil)
+	expState.addSentinel("10.20.30.40", "26379", "sentinel", nil)
+	expState.addSentinel("10.20.30.50", "30001", "sentinel", nil)
+
+	s[0].On("Master", "dbaasmaster").Return(redis.NewStringStringMapResult(redisPrimaryState, nil))
+	s[0].On("Slaves", "dbaasmaster").Return(redis.NewSliceResult(redisReplicasState.resp, nil))
+	s[0].On("Sentinels", "dbaasmaster").Return(redis.NewSliceResult(redisSentinelsState.resp, nil))
+	ret, err := db.State()
+	assert.Nil(t, err)
+	assert.Equal(t, expState.s, *ret)
+	r.AssertExpectations(t)
+}
+
+func TestStateWithPrimaryAndTwoReplicaRedisFailureInPrimaryRedisCall(t *testing.T) {
+	expErr := errors.New("Some error")
+	_, r, s, db := setupHaEnvWithSentinels(true, "3")
+
+	redisPrimaryState := newMockRedisMasterCallResp("master", "10.20.30.30", "6379", "master")
+	redisReplicasState := newMockRedisSlavesCall()
+	redisReplicasState.add("slave", "10.20.30.40", "6379", "up", "slave")
+	redisReplicasState.add("slave", "10.20.30.50", "30000", "up", "slave")
+	redisSentinelsState := newMockRedisSentinelsCall()
+	redisSentinelsState.add("10.20.30.40", "26379", "sentinel")
+	redisSentinelsState.add("10.20.30.50", "30001", "sentinel")
+
+	expState := newExpDbState(3, nil)
+	expState.addPrimary("", "", "", "", expErr)
+	expState.addReplica("slave", "10.20.30.40", "6379", "up", "slave", nil)
+	expState.addReplica("slave", "10.20.30.50", "30000", "up", "slave", nil)
+	expState.addSentinel("10.20.30.40", "26379", "sentinel", nil)
+	expState.addSentinel("10.20.30.50", "30001", "sentinel", nil)
+
+	s[0].On("Master", "dbaasmaster").Return(redis.NewStringStringMapResult(redisPrimaryState, expErr))
+	s[0].On("Slaves", "dbaasmaster").Return(redis.NewSliceResult(redisReplicasState.resp, nil))
+	s[0].On("Sentinels", "dbaasmaster").Return(redis.NewSliceResult(redisSentinelsState.resp, nil))
+	ret, err := db.State()
+	assert.NotNil(t, err)
+	assert.Equal(t, expState.s, *ret)
+	r.AssertExpectations(t)
+}
+
+func TestStateWithPrimaryAndTwoReplicaRedisFailureInReplicasRedisCall(t *testing.T) {
+	expErr := errors.New("Some error")
+	_, r, s, db := setupHaEnvWithSentinels(true, "3")
+
+	redisPrimaryState := newMockRedisMasterCallResp("master", "10.20.30.30", "6379", "master")
+	redisReplicasState := newMockRedisSlavesCall()
+	redisReplicasState.add("slave", "10.20.30.40", "6379", "up", "slave")
+	redisReplicasState.add("slave", "10.20.30.50", "30000", "up", "slave")
+	redisSentinelsState := newMockRedisSentinelsCall()
+	redisSentinelsState.add("10.20.30.40", "26379", "sentinel")
+	redisSentinelsState.add("10.20.30.50", "30001", "sentinel")
+
+	expState := newExpDbState(3, nil)
+	expState.addPrimary("master", "10.20.30.30", "6379", "master", nil)
+	expState.addReplica("", "", "", "", "", expErr)
+	expState.addReplica("", "", "", "", "", expErr)
+	expState.addSentinel("10.20.30.40", "26379", "sentinel", nil)
+	expState.addSentinel("10.20.30.50", "30001", "sentinel", nil)
+
+	s[0].On("Master", "dbaasmaster").Return(redis.NewStringStringMapResult(redisPrimaryState, nil))
+	s[0].On("Slaves", "dbaasmaster").Return(redis.NewSliceResult(redisReplicasState.resp, errors.New("Some error")))
+	s[0].On("Sentinels", "dbaasmaster").Return(redis.NewSliceResult(redisSentinelsState.resp, nil))
+	ret, err := db.State()
+	assert.NotNil(t, err)
+	assert.Equal(t, expState.s, *ret)
+	r.AssertExpectations(t)
+}
+
+func TestStateWithPrimaryAndOneReplicaRedisFailureInSentinelsRedisCall(t *testing.T) {
+	expErr := errors.New("Some error")
+	_, r, s, db := setupHaEnvWithSentinels(true, "2")
+
+	redisPrimaryState := newMockRedisMasterCallResp("master", "10.20.30.30", "6379", "master")
+	redisReplicasState := newMockRedisSlavesCall()
+	redisReplicasState.add("slave", "10.20.30.40", "6379", "up", "slave")
+	redisSentinelsState := newMockRedisSentinelsCall()
+	redisSentinelsState.add("10.20.30.40", "26379", "sentinel")
+
+	expState := newExpDbState(2, nil)
+	expState.addPrimary("master", "10.20.30.30", "6379", "master", nil)
+	expState.addReplica("slave", "10.20.30.40", "6379", "up", "slave", nil)
+	expState.addSentinel("", "", "", expErr)
+
+	s[0].On("Master", "dbaasmaster").Return(redis.NewStringStringMapResult(redisPrimaryState, nil))
+	s[0].On("Slaves", "dbaasmaster").Return(redis.NewSliceResult(redisReplicasState.resp, nil))
+	s[0].On("Sentinels", "dbaasmaster").Return(redis.NewSliceResult(redisSentinelsState.resp, expErr))
+	ret, err := db.State()
+	assert.NotNil(t, err)
+	assert.Equal(t, expState.s, *ret)
+	r.AssertExpectations(t)
+}
+
+func TestStateWithPrimaryAndTwoReplicaRedisFailureWhenIntConversionFails(t *testing.T) {
+	expErr := errors.New("Sentinel DBAAS_NODE_COUNT configuration value 'no-int' conversion to integer failed")
+	_, r, s, db := setupHaEnvWithSentinels(true, "no-int")
+
+	redisPrimaryState := newMockRedisMasterCallResp("master", "10.20.30.30", "6379", "master")
+	redisReplicasState := newMockRedisSlavesCall()
+	redisReplicasState.add("slave", "10.20.30.40", "6379", "up", "slave")
+	redisReplicasState.add("slave", "10.20.30.50", "30000", "up", "slave")
+	redisSentinelsState := newMockRedisSentinelsCall()
+	redisSentinelsState.add("10.20.30.40", "26379", "sentinel")
+	redisSentinelsState.add("10.20.30.50", "30001", "sentinel")
+
+	expState := newExpDbState(0, expErr)
+	expState.addPrimary("master", "10.20.30.30", "6379", "master", nil)
+	expState.addReplica("slave", "10.20.30.40", "6379", "up", "slave", nil)
+	expState.addReplica("slave", "10.20.30.50", "30000", "up", "slave", nil)
+	expState.addSentinel("10.20.30.40", "26379", "sentinel", nil)
+	expState.addSentinel("10.20.30.50", "30001", "sentinel", nil)
+
+	s[0].On("Master", "dbaasmaster").Return(redis.NewStringStringMapResult(redisPrimaryState, nil))
+	s[0].On("Slaves", "dbaasmaster").Return(redis.NewSliceResult(redisReplicasState.resp, nil))
+	s[0].On("Sentinels", "dbaasmaster").Return(redis.NewSliceResult(redisSentinelsState.resp, nil))
+	ret, err := db.State()
+	assert.Equal(t, expErr, err)
+	assert.Equal(t, expState.s, *ret)
+	r.AssertExpectations(t)
+}
+
+// Test case to test ignoring of a sentinel entry with zero port. Implementation has been
+// done because we miss the fix for the Redis Bug #9240.
+func TestStateWithPrimaryAndTwoReplicaFirstSentinelStateIgnoredBecauseZeroPortBugRedisSuccessfully(t *testing.T) {
+	_, r, s, db := setupHaEnvWithSentinels(true, "3")
+
+	redisPrimaryState := newMockRedisMasterCallResp("master", "10.20.30.30", "6379", "master")
+	redisReplicasState := newMockRedisSlavesCall()
+	redisReplicasState.add("slave", "10.20.30.40", "6379", "up", "slave")
+	redisReplicasState.add("slave", "10.20.30.50", "30000", "up", "slave")
+	redisSentinelsState := newMockRedisSentinelsCall()
+	redisSentinelsState.add("10.20.30.40", "0", "s_down,sentinel,disconnected")
+	redisSentinelsState.add("10.20.30.50", "26379", "sentinel")
+
+	expState := newExpDbState(3, nil)
+	expState.addPrimary("master", "10.20.30.30", "6379", "master", nil)
+	expState.addReplica("slave", "10.20.30.40", "6379", "up", "slave", nil)
+	expState.addReplica("slave", "10.20.30.50", "30000", "up", "slave", nil)
+	expState.addSentinel("10.20.30.50", "26379", "sentinel", nil)
+
+	s[0].On("Master", "dbaasmaster").Return(redis.NewStringStringMapResult(redisPrimaryState, nil))
+	s[0].On("Slaves", "dbaasmaster").Return(redis.NewSliceResult(redisReplicasState.resp, nil))
+	s[0].On("Sentinels", "dbaasmaster").Return(redis.NewSliceResult(redisSentinelsState.resp, nil))
+	ret, err := db.State()
+	assert.Nil(t, err)
+	assert.Equal(t, expState.s, *ret)
+	r.AssertExpectations(t)
+}
+
+func TestStateWithSinglePrimaryRedisSuccessfully(t *testing.T) {
+	_, r, db := setupSingleEnv(true, "1")
+	redisInfo := "# Replication\r\n" +
+		"role:master\r\n" +
+		"connected_slaves:0\r\n" +
+		"min_slaves_good_slaves:0\r\n"
+
+	expState := &sdlgoredis.DbState{
+		ConfigNodeCnt: 1,
+		PrimaryDbState: sdlgoredis.PrimaryDbState{
+			Fields: sdlgoredis.PrimaryDbStateFields{
+				Role:  "master",
+				Ip:    "service-ricplt-dbaas-tcp-cluster-0.ricplt",
+				Port:  "6376",
+				Flags: "master",
+			},
+		},
+	}
+
+	r.On("Info", []string{"all"}).Return(redis.NewStringResult(redisInfo, nil))
+	ret, err := db.State()
+	assert.Nil(t, err)
+	assert.Equal(t, expState, ret)
+	r.AssertExpectations(t)
+}
+
+func TestStateWithSinglePrimaryRedisFailureWhenIntConversionFails(t *testing.T) {
+	expErr := errors.New("DBAAS_NODE_COUNT configuration value 'no-int' conversion to integer failed")
+	_, r, db := setupSingleEnv(true, "no-int")
+	redisInfo := "# Replication\r\n" +
+		"role:master\r\n" +
+		"connected_slaves:0\r\n" +
+		"min_slaves_good_slaves:0\r\n"
+
+	expState := &sdlgoredis.DbState{
+		Err:           expErr,
+		ConfigNodeCnt: 0,
+		PrimaryDbState: sdlgoredis.PrimaryDbState{
+			Fields: sdlgoredis.PrimaryDbStateFields{
+				Role:  "master",
+				Ip:    "service-ricplt-dbaas-tcp-cluster-0.ricplt",
+				Port:  "6376",
+				Flags: "master",
+			},
+		},
+	}
+
+	r.On("Info", []string{"all"}).Return(redis.NewStringResult(redisInfo, nil))
+	ret, err := db.State()
+	assert.Equal(t, expErr, err)
+	assert.Equal(t, expState, ret)
+	r.AssertExpectations(t)
+}
+
+func TestStateWithSinglePrimaryRedisFailureInInfoCall(t *testing.T) {
+	expErr := errors.New("Some error")
+	_, r, db := setupSingleEnv(true, "1")
+	redisInfo := ""
+	expState := &sdlgoredis.DbState{
+		PrimaryDbState: sdlgoredis.PrimaryDbState{
+			Err: expErr,
+		},
+	}
+
+	r.On("Info", []string{"all"}).Return(redis.NewStringResult(redisInfo, errors.New("Some error")))
+	ret, err := db.State()
+	assert.NotNil(t, err)
+	assert.Equal(t, expState, ret)
+	r.AssertExpectations(t)
+}
+
+func TestStatisticsWithSinglePrimaryRedisSuccessfully(t *testing.T) {
+	_, r, db := setupSingleEnv(true, "1")
+	redisInfo := "# Replication\r\n" +
+		"role:master\r\n" +
+		"connected_slaves:0\r\n" +
+		"min_slaves_good_slaves:0\r\n" +
+		"# Server\r\n" +
+		"uptime_in_days:12\r\n"
+
+	expStatistics := &sdlgoredis.DbStatistics{
+		Stats: []*sdlgoredis.DbStatisticsInfo{
+			{
+				IPAddr: "service-ricplt-dbaas-tcp-cluster-0.ricplt",
+				Port:   "6376",
+				Info: &sdlgoredis.DbInfo{
+					Fields: sdlgoredis.DbInfoFields{
+						PrimaryRole: true,
+						Server: sdlgoredis.ServerInfoFields{
+							UptimeInDays: 12,
+						},
+					},
+				},
+			},
+		},
+	}
+
+	r.On("Info", []string{"all"}).Return(redis.NewStringResult(redisInfo, nil))
+	ret, err := db.Statistics()
+	assert.Nil(t, err)
+	assert.Equal(t, expStatistics, ret)
+	r.AssertExpectations(t)
+}