+
+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)
+}