X-Git-Url: https://gerrit.o-ran-sc.org/r/gitweb?a=blobdiff_plain;f=internal%2Fsdlgoredis%2Fsdlgoredis_test.go;h=740674da1dd938593c306fb2b8313341613a29b6;hb=273d032db02901dba8deeb692f92ed2366dc6ee5;hp=ce7260764d4f88d5741cd8c005f589909dd3b975;hpb=97445fe7e6737da5536c5f7a6909821a1612f66c;p=ric-plt%2Fsdlgo.git diff --git a/internal/sdlgoredis/sdlgoredis_test.go b/internal/sdlgoredis/sdlgoredis_test.go index ce72607..740674d 100644 --- a/internal/sdlgoredis/sdlgoredis_test.go +++ b/internal/sdlgoredis/sdlgoredis_test.go @@ -24,14 +24,13 @@ package sdlgoredis_test import ( "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/v7" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/mock" + "strconv" + "testing" + "time" ) type clientMock struct { @@ -42,6 +41,10 @@ type pubSubMock struct { mock.Mock } +type MockOS struct { + mock.Mock +} + func (m *pubSubMock) Channel() <-chan *redis.Message { return m.Called().Get(0).(chan *redis.Message) } @@ -134,6 +137,29 @@ func (m *clientMock) ScriptLoad(script string) *redis.StringCmd { return m.Called(script).Get(0).(*redis.StringCmd) } +func (m *clientMock) Info(section ...string) *redis.StringCmd { + return m.Called(section).Get(0).(*redis.StringCmd) +} + +type MockRedisSentinel struct { + mock.Mock +} + +func (m *MockRedisSentinel) Master(name string) *redis.StringStringMapCmd { + a := m.Called(name) + return a.Get(0).(*redis.StringStringMapCmd) +} + +func (m *MockRedisSentinel) Slaves(name string) *redis.SliceCmd { + a := m.Called(name) + return a.Get(0).(*redis.SliceCmd) +} + +func (m *MockRedisSentinel) Sentinels(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 { @@ -141,16 +167,53 @@ func setSubscribeNotifications() (*pubSubMock, sdlgoredis.SubscribeFn) { } } -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) + return psm, cm, db +} + +func setupHaEnvWithSentinels(commandsExists bool) (*pubSubMock, *clientMock, []*MockRedisSentinel, *sdlgoredis.DB) { + setupVals := setupEnv( + commandsExists, + "service-ricplt-dbaas-tcp-cluster-0.ricplt", + "6376", + "dbaasmaster", + "26376", + "", + "3", + ) + return setupVals.pubSubMock[0], setupVals.rClient[0], setupVals.rSentinel, setupVals.db[0] +} + +func setupSingleEnv(commandsExists bool) (*pubSubMock, *clientMock, *sdlgoredis.DB) { + setupVals := setupEnv( + commandsExists, + "service-ricplt-dbaas-tcp-cluster-0.ricplt", + "6376", "", "", "", "", + ) + 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 +229,57 @@ 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_SERVICE_NODE_COUNT", "").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 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 +288,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 +297,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 +307,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 +317,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 +328,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 +339,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 +351,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 +361,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 +371,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 +381,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 +389,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 +397,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 +408,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 +419,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 +429,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 +439,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 +449,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 +459,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 +550,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 +561,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 +573,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 +633,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 +653,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 +663,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 +673,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 +682,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 +691,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 +700,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 +709,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 +720,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 +732,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 +743,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 +754,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 +766,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 +776,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 +786,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 +812,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", @@ -715,6 +842,7 @@ func TestSubscribeChannelDBSubscribeTwoUnsubscribeOne(t *testing.T) { receivedChannel2 = channel }, "{prefix}", "---", "{prefix}channel2") + time.Sleep(1 * time.Second) db.UnsubscribeChannelDB("{prefix}channel1") ch <- &msg2 db.UnsubscribeChannelDB("{prefix}channel2") @@ -726,8 +854,44 @@ func TestSubscribeChannelDBSubscribeTwoUnsubscribeOne(t *testing.T) { ps.AssertExpectations(t) } +func TestSubscribeChannelReDBSubscribeAfterUnsubscribe(t *testing.T) { + ps, r, db := setupHaEnv(true) + ch := make(chan *redis.Message) + msg := redis.Message{ + Channel: "{prefix}channel", + Pattern: "pattern", + Payload: "event", + } + ps.On("Channel").Return(ch) + ps.On("Unsubscribe").Return(nil) + ps.On("Close").Return(nil) + count := 0 + receivedChannel := "" + + db.SubscribeChannelDB(func(channel string, payload ...string) { + count++ + receivedChannel = channel + }, "{prefix}", "---", "{prefix}channel") + ch <- &msg + db.UnsubscribeChannelDB("{prefix}channel") + time.Sleep(1 * time.Second) + + db.SubscribeChannelDB(func(channel string, payload ...string) { + count++ + receivedChannel = channel + }, "{prefix}", "---", "{prefix}channel") + ch <- &msg + db.UnsubscribeChannelDB("{prefix}channel") + + time.Sleep(1 * time.Second) + assert.Equal(t, 2, count) + assert.Equal(t, "channel", receivedChannel) + r.AssertExpectations(t) + ps.AssertExpectations(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, @@ -739,7 +903,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, @@ -751,7 +915,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) @@ -765,7 +929,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) @@ -779,7 +943,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) @@ -791,3 +955,452 @@ 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 TestInfoOfMasterRedisWithTwoSlavesSuccessfully(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{ + MasterRole: 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 TestInfoOfMasterRedisWithOneSlaveOnlineAndOtherSlaveNotOnlineSuccessfully(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{ + MasterRole: 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 TestInfoOfStandaloneMasterRedisSuccessfully(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{ + MasterRole: 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{ + MasterRole: 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 TestStateWithMasterAndTwoSlaveRedisSuccessfully(t *testing.T) { + _, r, s, db := setupHaEnvWithSentinels(true) + redisMasterState := map[string]string{ + "role-reported": "master", + } + redisSlavesState := make([]interface{}, 2) + redisSlavesState[0] = []interface{}{ + "role-reported", "slave", + "ip", "10.20.30.40", + "port", "6379", + "flags", "slave", + "master-link-status", "up", + } + redisSlavesState[1] = []interface{}{ + "master-link-status", "up", + "ip", "10.20.30.50", + "flags", "slave", + "port", "30000", + "role-reported", "slave", + } + redisSentinelsState := make([]interface{}, 2) + redisSentinelsState[0] = []interface{}{ + "ip", "10.20.30.40", + "port", "26379", + "flags", "sentinel", + } + redisSentinelsState[1] = []interface{}{ + "ip", "10.20.30.50", + "flags", "sentinel", + "port", "30001", + } + + expState := &sdlgoredis.DbState{ + MasterDbState: sdlgoredis.MasterDbState{ + Fields: sdlgoredis.MasterDbStateFields{ + Role: "master", + }, + }, + ReplicasDbState: &sdlgoredis.ReplicasDbState{ + States: []*sdlgoredis.ReplicaDbState{ + &sdlgoredis.ReplicaDbState{ + Fields: sdlgoredis.ReplicaDbStateFields{ + Role: "slave", + Ip: "10.20.30.40", + Port: "6379", + MasterLinkStatus: "up", + Flags: "slave", + }, + }, + &sdlgoredis.ReplicaDbState{ + Fields: sdlgoredis.ReplicaDbStateFields{ + Role: "slave", + Ip: "10.20.30.50", + Port: "30000", + MasterLinkStatus: "up", + Flags: "slave", + }, + }, + }, + }, + SentinelsDbState: &sdlgoredis.SentinelsDbState{ + States: []*sdlgoredis.SentinelDbState{ + &sdlgoredis.SentinelDbState{ + Fields: sdlgoredis.SentinelDbStateFields{ + Ip: "10.20.30.40", + Port: "26379", + Flags: "sentinel", + }, + }, + &sdlgoredis.SentinelDbState{ + Fields: sdlgoredis.SentinelDbStateFields{ + Ip: "10.20.30.50", + Port: "30001", + Flags: "sentinel", + }, + }, + }, + }, + } + + s[0].On("Master", "dbaasmaster").Return(redis.NewStringStringMapResult(redisMasterState, nil)) + s[0].On("Slaves", "dbaasmaster").Return(redis.NewSliceResult(redisSlavesState, nil)) + s[0].On("Sentinels", "dbaasmaster").Return(redis.NewSliceResult(redisSentinelsState, nil)) + ret, err := db.State() + assert.Nil(t, err) + assert.Equal(t, expState, ret) + r.AssertExpectations(t) +} + +func TestStateWithMasterAndOneSlaveRedisFailureInMasterRedisCall(t *testing.T) { + _, r, s, db := setupHaEnvWithSentinels(true) + redisMasterState := map[string]string{} + redisSlavesState := make([]interface{}, 1) + redisSlavesState[0] = []interface{}{ + "role-reported", "slave", + "ip", "10.20.30.40", + "port", "6379", + "flags", "slave", + "master-link-status", "up", + } + redisSentinelsState := make([]interface{}, 1) + redisSentinelsState[0] = []interface{}{ + "ip", "10.20.30.40", + "port", "26379", + "flags", "sentinel", + } + + expState := &sdlgoredis.DbState{ + MasterDbState: sdlgoredis.MasterDbState{ + Err: errors.New("Some error"), + }, + ReplicasDbState: &sdlgoredis.ReplicasDbState{ + States: []*sdlgoredis.ReplicaDbState{ + &sdlgoredis.ReplicaDbState{ + Fields: sdlgoredis.ReplicaDbStateFields{ + Role: "slave", + Ip: "10.20.30.40", + Port: "6379", + MasterLinkStatus: "up", + Flags: "slave", + }, + }, + }, + }, + SentinelsDbState: &sdlgoredis.SentinelsDbState{ + States: []*sdlgoredis.SentinelDbState{ + &sdlgoredis.SentinelDbState{ + Fields: sdlgoredis.SentinelDbStateFields{ + Ip: "10.20.30.40", + Port: "26379", + Flags: "sentinel", + }, + }, + }, + }, + } + + s[0].On("Master", "dbaasmaster").Return(redis.NewStringStringMapResult(redisMasterState, errors.New("Some error"))) + s[0].On("Slaves", "dbaasmaster").Return(redis.NewSliceResult(redisSlavesState, nil)) + s[0].On("Sentinels", "dbaasmaster").Return(redis.NewSliceResult(redisSentinelsState, nil)) + ret, err := db.State() + assert.NotNil(t, err) + assert.Equal(t, expState, ret) + r.AssertExpectations(t) +} + +func TestStateWithMasterAndOneSlaveRedisFailureInSlavesRedisCall(t *testing.T) { + _, r, s, db := setupHaEnvWithSentinels(true) + redisMasterState := map[string]string{ + "role-reported": "master", + } + redisSlavesState := make([]interface{}, 1) + redisSlavesState[0] = []interface{}{} + redisSentinelsState := make([]interface{}, 1) + redisSentinelsState[0] = []interface{}{ + "ip", "10.20.30.40", + "port", "26379", + "flags", "sentinel", + } + + expState := &sdlgoredis.DbState{ + MasterDbState: sdlgoredis.MasterDbState{ + Fields: sdlgoredis.MasterDbStateFields{ + Role: "master", + }, + }, + ReplicasDbState: &sdlgoredis.ReplicasDbState{ + Err: errors.New("Some error"), + States: []*sdlgoredis.ReplicaDbState{}, + }, + SentinelsDbState: &sdlgoredis.SentinelsDbState{ + States: []*sdlgoredis.SentinelDbState{ + &sdlgoredis.SentinelDbState{ + Fields: sdlgoredis.SentinelDbStateFields{ + Ip: "10.20.30.40", + Port: "26379", + Flags: "sentinel", + }, + }, + }, + }, + } + + s[0].On("Master", "dbaasmaster").Return(redis.NewStringStringMapResult(redisMasterState, nil)) + s[0].On("Slaves", "dbaasmaster").Return(redis.NewSliceResult(redisSlavesState, errors.New("Some error"))) + s[0].On("Sentinels", "dbaasmaster").Return(redis.NewSliceResult(redisSentinelsState, nil)) + ret, err := db.State() + assert.NotNil(t, err) + assert.Equal(t, expState, ret) + r.AssertExpectations(t) +} + +func TestStateWithMasterAndOneSlaveRedisFailureInSentinelsRedisCall(t *testing.T) { + _, r, s, db := setupHaEnvWithSentinels(true) + redisMasterState := map[string]string{ + "role-reported": "master", + } + redisSlavesState := make([]interface{}, 1) + redisSlavesState[0] = []interface{}{ + "role-reported", "slave", + "ip", "10.20.30.40", + "port", "6379", + "flags", "slave", + "master-link-status", "up", + } + redisSentinelsState := make([]interface{}, 1) + redisSentinelsState[0] = []interface{}{ + "ip", "10.20.30.40", + "port", "26379", + "flags", "sentinel", + } + + expState := &sdlgoredis.DbState{ + MasterDbState: sdlgoredis.MasterDbState{ + Fields: sdlgoredis.MasterDbStateFields{ + Role: "master", + }, + }, + ReplicasDbState: &sdlgoredis.ReplicasDbState{ + States: []*sdlgoredis.ReplicaDbState{ + &sdlgoredis.ReplicaDbState{ + Fields: sdlgoredis.ReplicaDbStateFields{ + Role: "slave", + Ip: "10.20.30.40", + Port: "6379", + MasterLinkStatus: "up", + Flags: "slave", + }, + }, + }, + }, + SentinelsDbState: &sdlgoredis.SentinelsDbState{ + Err: errors.New("Some error"), + States: []*sdlgoredis.SentinelDbState{}, + }, + } + + s[0].On("Master", "dbaasmaster").Return(redis.NewStringStringMapResult(redisMasterState, nil)) + s[0].On("Slaves", "dbaasmaster").Return(redis.NewSliceResult(redisSlavesState, nil)) + s[0].On("Sentinels", "dbaasmaster").Return(redis.NewSliceResult(redisSentinelsState, errors.New("Some error"))) + ret, err := db.State() + assert.NotNil(t, err) + assert.Equal(t, expState, ret) + r.AssertExpectations(t) +} + +func TestStateWithSingleMasterRedisSuccessfully(t *testing.T) { + _, r, db := setupSingleEnv(true) + redisInfo := "# Replication\r\n" + + "role:master\r\n" + + "connected_slaves:0\r\n" + + "min_slaves_good_slaves:0\r\n" + + expState := &sdlgoredis.DbState{ + MasterDbState: sdlgoredis.MasterDbState{ + Fields: sdlgoredis.MasterDbStateFields{ + Role: "master", + 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 TestStateWithSingleMasterRedisFailureInInfoCall(t *testing.T) { + _, r, db := setupSingleEnv(true) + redisInfo := "" + expState := &sdlgoredis.DbState{} + + 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) +}