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 {
mock.Mock
}
+type MockOS struct {
+ mock.Mock
+}
+
func (m *pubSubMock) Channel() <-chan *redis.Message {
return m.Called().Get(0).(chan *redis.Message)
}
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 {
}
}
-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,
}
}
- 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)
}
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)
}
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))
}
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")))
}
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)
}
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))
}
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,
}
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))
}
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")))
}
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)
}
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"}))
}
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"}))
}
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))
}
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,
}
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")
}
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")
}
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")
}
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")
}
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))
}
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))
}
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)).
}
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)
}
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")
}
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)
}
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")
}
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))
}
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")))
}
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))
}
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")))
}
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))
}
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,
}
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))
}
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))
}
func TestSIsMemberFailure(t *testing.T) {
- _, r, db := setup(true)
+ _, r, db := setupHaEnv(true)
expectedKey := "key"
expectedData := "data"
r.On("SIsMember", expectedKey, expectedData).
}
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")
}
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")
}
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",
}
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",
}
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",
}
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,
}
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,
}
func TestPExpireIESuccessfully(t *testing.T) {
- _, r, db := setup(true)
+ _, r, db := setupHaEnv(true)
expectedKey := "key"
expectedData := "data"
expectedDuration := strconv.FormatInt(int64(10000), 10)
}
func TestPExpireIEFailure(t *testing.T) {
- _, r, db := setup(true)
+ _, r, db := setupHaEnv(true)
expectedKey := "key"
expectedData := "data"
expectedDuration := strconv.FormatInt(int64(10000), 10)
}
func TestPExpireIELockNotHeld(t *testing.T) {
- _, r, db := setup(true)
+ _, r, db := setupHaEnv(true)
expectedKey := "key"
expectedData := "data"
expectedDuration := strconv.FormatInt(int64(10000), 10)
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)
+}
Code Review / ric-plt / sdlgo.git / blobdiff