2 Copyright (c) 2019 AT&T Intellectual Property.
3 Copyright (c) 2018-2019 Nokia.
5 Licensed under the Apache License, Version 2.0 (the "License");
6 you may not use this file except in compliance with the License.
7 You may obtain a copy of the License at
9 http://www.apache.org/licenses/LICENSE-2.0
11 Unless required by applicable law or agreed to in writing, software
12 distributed under the License is distributed on an "AS IS" BASIS,
13 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 See the License for the specific language governing permissions and
15 limitations under the License.
19 * This source code is part of the near-RT RIC (RAN Intelligent Controller)
20 * platform project (RICP).
23 package sdlgoredis_test
27 "gerrit.o-ran-sc.org/r/ric-plt/sdlgo/internal/sdlgoredis"
28 "github.com/go-redis/redis/v7"
29 "github.com/stretchr/testify/assert"
30 "github.com/stretchr/testify/mock"
36 type clientMock struct {
40 type pubSubMock struct {
48 func (m *pubSubMock) Channel() <-chan *redis.Message {
49 return m.Called().Get(0).(chan *redis.Message)
52 func (m *pubSubMock) Subscribe(channels ...string) error {
53 return m.Called().Error(0)
56 func (m *pubSubMock) Unsubscribe(channels ...string) error {
57 return m.Called().Error(0)
60 func (m *pubSubMock) Close() error {
61 return m.Called().Error(0)
64 func (m *clientMock) Command() *redis.CommandsInfoCmd {
65 return m.Called().Get(0).(*redis.CommandsInfoCmd)
68 func (m *clientMock) Close() error {
69 return m.Called().Error(0)
72 func (m *clientMock) Subscribe(channels ...string) *redis.PubSub {
73 return m.Called(channels).Get(0).(*redis.PubSub)
76 func (m *clientMock) MSet(pairs ...interface{}) *redis.StatusCmd {
77 return m.Called(pairs).Get(0).(*redis.StatusCmd)
80 func (m *clientMock) Do(args ...interface{}) *redis.Cmd {
81 return m.Called(args).Get(0).(*redis.Cmd)
84 func (m *clientMock) MGet(keys ...string) *redis.SliceCmd {
85 return m.Called(keys).Get(0).(*redis.SliceCmd)
88 func (m *clientMock) Del(keys ...string) *redis.IntCmd {
89 return m.Called(keys).Get(0).(*redis.IntCmd)
92 func (m *clientMock) Keys(pattern string) *redis.StringSliceCmd {
93 return m.Called(pattern).Get(0).(*redis.StringSliceCmd)
96 func (m *clientMock) SetNX(key string, value interface{}, expiration time.Duration) *redis.BoolCmd {
97 return m.Called(key, value, expiration).Get(0).(*redis.BoolCmd)
100 func (m *clientMock) SAdd(key string, members ...interface{}) *redis.IntCmd {
101 return m.Called(key, members).Get(0).(*redis.IntCmd)
104 func (m *clientMock) SRem(key string, members ...interface{}) *redis.IntCmd {
105 return m.Called(key, members).Get(0).(*redis.IntCmd)
108 func (m *clientMock) SMembers(key string) *redis.StringSliceCmd {
109 return m.Called(key).Get(0).(*redis.StringSliceCmd)
112 func (m *clientMock) SIsMember(key string, member interface{}) *redis.BoolCmd {
113 return m.Called(key, member).Get(0).(*redis.BoolCmd)
116 func (m *clientMock) SCard(key string) *redis.IntCmd {
117 return m.Called(key).Get(0).(*redis.IntCmd)
120 func (m *clientMock) PTTL(key string) *redis.DurationCmd {
121 return m.Called(key).Get(0).(*redis.DurationCmd)
124 func (m *clientMock) Eval(script string, keys []string, args ...interface{}) *redis.Cmd {
125 return m.Called(script, keys).Get(0).(*redis.Cmd)
128 func (m *clientMock) EvalSha(sha1 string, keys []string, args ...interface{}) *redis.Cmd {
129 return m.Called(sha1, keys, args).Get(0).(*redis.Cmd)
132 func (m *clientMock) ScriptExists(scripts ...string) *redis.BoolSliceCmd {
133 return m.Called(scripts).Get(0).(*redis.BoolSliceCmd)
136 func (m *clientMock) ScriptLoad(script string) *redis.StringCmd {
137 return m.Called(script).Get(0).(*redis.StringCmd)
140 func (m *clientMock) Info(section ...string) *redis.StringCmd {
141 return m.Called(section).Get(0).(*redis.StringCmd)
144 type MockRedisSentinel struct {
148 func (m *MockRedisSentinel) Master(name string) *redis.StringStringMapCmd {
150 return a.Get(0).(*redis.StringStringMapCmd)
153 func (m *MockRedisSentinel) Slaves(name string) *redis.SliceCmd {
155 return a.Get(0).(*redis.SliceCmd)
158 func (m *MockRedisSentinel) Sentinels(name string) *redis.SliceCmd {
160 return a.Get(0).(*redis.SliceCmd)
163 func setSubscribeNotifications() (*pubSubMock, sdlgoredis.SubscribeFn) {
164 mock := new(pubSubMock)
165 return mock, func(client sdlgoredis.RedisClient, channels ...string) sdlgoredis.Subscriber {
170 func (m *MockOS) Getenv(key string, defValue string) string {
171 a := m.Called(key, defValue)
175 type setupEv struct {
176 pubSubMock []*pubSubMock
177 rClient []*clientMock
178 rSentinel []*MockRedisSentinel
182 func setupHaEnv(commandsExists bool) (*pubSubMock, *clientMock, *sdlgoredis.DB) {
183 psm, cm, _, db := setupHaEnvWithSentinels(commandsExists)
187 func setupHaEnvWithSentinels(commandsExists bool) (*pubSubMock, *clientMock, []*MockRedisSentinel, *sdlgoredis.DB) {
188 setupVals := setupEnv(
190 "service-ricplt-dbaas-tcp-cluster-0.ricplt",
197 return setupVals.pubSubMock[0], setupVals.rClient[0], setupVals.rSentinel, setupVals.db[0]
200 func setupSingleEnv(commandsExists bool) (*pubSubMock, *clientMock, *sdlgoredis.DB) {
201 setupVals := setupEnv(
203 "service-ricplt-dbaas-tcp-cluster-0.ricplt",
204 "6376", "", "", "", "",
206 return setupVals.pubSubMock[0], setupVals.rClient[0], setupVals.db[0]
209 func setupEnv(commandsExists bool, host, port, msname, sntport, clsaddrlist, nodeCnt string) setupEv {
212 dummyCommandInfo := redis.CommandInfo{
216 cmdResult := make(map[string]*redis.CommandInfo, 0)
218 cmdResult = map[string]*redis.CommandInfo{
219 "setie": &dummyCommandInfo,
220 "delie": &dummyCommandInfo,
221 "setiepub": &dummyCommandInfo,
222 "setnxpub": &dummyCommandInfo,
223 "msetmpub": &dummyCommandInfo,
224 "delmpub": &dummyCommandInfo,
227 cmdResult = map[string]*redis.CommandInfo{
228 "dummy": &dummyCommandInfo,
232 osmock := new(MockOS)
233 osmock.On("Getenv", "DBAAS_SERVICE_HOST", "localhost").Return(host)
234 osmock.On("Getenv", "DBAAS_SERVICE_PORT", "6379").Return(port)
235 osmock.On("Getenv", "DBAAS_MASTER_NAME", "").Return(msname)
236 osmock.On("Getenv", "DBAAS_SERVICE_SENTINEL_PORT", "").Return(sntport)
237 osmock.On("Getenv", "DBAAS_CLUSTER_ADDR_LIST", "").Return(clsaddrlist)
238 osmock.On("Getenv", "DBAAS_SERVICE_NODE_COUNT", "").Return(nodeCnt)
240 pubSubMock, subscribeNotifications := setSubscribeNotifications()
241 smock := new(MockRedisSentinel)
242 ret.rSentinel = append(ret.rSentinel, smock)
243 clients := sdlgoredis.ReadConfigAndCreateDbClients(
245 func(addr, port, clusterName string, isHa bool) sdlgoredis.RedisClient {
246 clm := new(clientMock)
247 clm.On("Command").Return(redis.NewCommandsInfoCmdResult(cmdResult, nil))
248 ret.rClient = append(ret.rClient, clm)
249 ret.pubSubMock = append(ret.pubSubMock, pubSubMock)
252 subscribeNotifications,
253 func(cfg *sdlgoredis.Config, addr string) *sdlgoredis.Sentinel {
254 s := &sdlgoredis.Sentinel{
255 IredisSentinelClient: smock,
265 func TestCloseDbSuccessfully(t *testing.T) {
266 _, r, db := setupHaEnv(true)
267 r.On("Close").Return(nil)
270 r.AssertExpectations(t)
273 func TestCloseDbFailure(t *testing.T) {
274 _, r, db := setupHaEnv(true)
275 r.On("Close").Return(errors.New("Some error"))
277 assert.NotNil(t, err)
278 r.AssertExpectations(t)
281 func TestMSetSuccessfully(t *testing.T) {
282 _, r, db := setupHaEnv(true)
283 expectedKeysAndValues := []interface{}{"key1", "value1", "key2", 2}
284 r.On("MSet", expectedKeysAndValues).Return(redis.NewStatusResult("OK", nil))
285 err := db.MSet("key1", "value1", "key2", 2)
287 r.AssertExpectations(t)
290 func TestMSetFailure(t *testing.T) {
291 _, r, db := setupHaEnv(true)
292 expectedKeysAndValues := []interface{}{"key1", "value1", "key2", 2}
293 r.On("MSet", expectedKeysAndValues).Return(redis.NewStatusResult("OK", errors.New("Some error")))
294 err := db.MSet("key1", "value1", "key2", 2)
295 assert.NotNil(t, err)
296 r.AssertExpectations(t)
299 func TestMSetMPubSuccessfully(t *testing.T) {
300 _, r, db := setupHaEnv(true)
301 expectedMessage := []interface{}{"MSETMPUB", 2, 2, "key1", "val1", "key2", "val2",
302 "chan1", "event1", "chan2", "event2"}
303 r.On("Do", expectedMessage).Return(redis.NewCmdResult("", nil))
304 assert.Nil(t, db.MSetMPub([]string{"chan1", "event1", "chan2", "event2"},
305 "key1", "val1", "key2", "val2"))
306 r.AssertExpectations(t)
309 func TestMsetMPubFailure(t *testing.T) {
310 _, r, db := setupHaEnv(true)
311 expectedMessage := []interface{}{"MSETMPUB", 2, 2, "key1", "val1", "key2", "val2",
312 "chan1", "event1", "chan2", "event2"}
313 r.On("Do", expectedMessage).Return(redis.NewCmdResult("", errors.New("Some error")))
314 assert.NotNil(t, db.MSetMPub([]string{"chan1", "event1", "chan2", "event2"},
315 "key1", "val1", "key2", "val2"))
316 r.AssertExpectations(t)
319 func TestMSetMPubCommandMissing(t *testing.T) {
320 _, r, db := setupHaEnv(false)
321 expectedMessage := []interface{}{"MSETMPUB", 2, 2, "key1", "val1", "key2", "val2",
322 "chan1", "event1", "chan2", "event2"}
323 r.AssertNotCalled(t, "Do", expectedMessage)
324 assert.NotNil(t, db.MSetMPub([]string{"chan1", "event1", "chan2", "event2"},
325 "key1", "val1", "key2", "val2"))
326 r.AssertExpectations(t)
330 func TestMGetSuccessfully(t *testing.T) {
331 _, r, db := setupHaEnv(true)
332 expectedKeys := []string{"key1", "key2", "key3"}
333 expectedResult := []interface{}{"val1", 2, nil}
334 r.On("MGet", expectedKeys).Return(redis.NewSliceResult(expectedResult, nil))
335 result, err := db.MGet([]string{"key1", "key2", "key3"})
336 assert.Equal(t, result, expectedResult)
338 r.AssertExpectations(t)
341 func TestMGetFailure(t *testing.T) {
342 _, r, db := setupHaEnv(true)
343 expectedKeys := []string{"key1", "key2", "key3"}
344 expectedResult := []interface{}{nil}
345 r.On("MGet", expectedKeys).Return(redis.NewSliceResult(expectedResult,
346 errors.New("Some error")))
347 result, err := db.MGet([]string{"key1", "key2", "key3"})
348 assert.Equal(t, result, expectedResult)
349 assert.NotNil(t, err)
350 r.AssertExpectations(t)
353 func TestDelMPubSuccessfully(t *testing.T) {
354 _, r, db := setupHaEnv(true)
355 expectedMessage := []interface{}{"DELMPUB", 2, 2, "key1", "key2", "chan1", "event1",
357 r.On("Do", expectedMessage).Return(redis.NewCmdResult("", nil))
358 assert.Nil(t, db.DelMPub([]string{"chan1", "event1", "chan2", "event2"},
359 []string{"key1", "key2"}))
360 r.AssertExpectations(t)
363 func TestDelMPubFailure(t *testing.T) {
364 _, r, db := setupHaEnv(true)
365 expectedMessage := []interface{}{"DELMPUB", 2, 2, "key1", "key2", "chan1", "event1",
367 r.On("Do", expectedMessage).Return(redis.NewCmdResult("", errors.New("Some error")))
368 assert.NotNil(t, db.DelMPub([]string{"chan1", "event1", "chan2", "event2"},
369 []string{"key1", "key2"}))
370 r.AssertExpectations(t)
373 func TestDelMPubCommandMissing(t *testing.T) {
374 _, r, db := setupHaEnv(false)
375 expectedMessage := []interface{}{"DELMPUB", 2, 2, "key1", "key2", "chan1", "event1",
377 r.AssertNotCalled(t, "Do", expectedMessage)
378 assert.NotNil(t, db.DelMPub([]string{"chan1", "event1", "chan2", "event2"},
379 []string{"key1", "key2"}))
380 r.AssertExpectations(t)
383 func TestDelSuccessfully(t *testing.T) {
384 _, r, db := setupHaEnv(true)
385 expectedKeys := []string{"key1", "key2"}
386 r.On("Del", expectedKeys).Return(redis.NewIntResult(2, nil))
387 assert.Nil(t, db.Del([]string{"key1", "key2"}))
388 r.AssertExpectations(t)
391 func TestDelFailure(t *testing.T) {
392 _, r, db := setupHaEnv(true)
393 expectedKeys := []string{"key1", "key2"}
394 r.On("Del", expectedKeys).Return(redis.NewIntResult(2, errors.New("Some error")))
395 assert.NotNil(t, db.Del([]string{"key1", "key2"}))
396 r.AssertExpectations(t)
399 func TestKeysSuccessfully(t *testing.T) {
400 _, r, db := setupHaEnv(true)
401 expectedPattern := "pattern*"
402 expectedResult := []string{"pattern1", "pattern2"}
403 r.On("Keys", expectedPattern).Return(redis.NewStringSliceResult(expectedResult, nil))
404 result, err := db.Keys("pattern*")
405 assert.Equal(t, result, expectedResult)
407 r.AssertExpectations(t)
410 func TestKeysFailure(t *testing.T) {
411 _, r, db := setupHaEnv(true)
412 expectedPattern := "pattern*"
413 expectedResult := []string{}
414 r.On("Keys", expectedPattern).Return(redis.NewStringSliceResult(expectedResult,
415 errors.New("Some error")))
416 _, err := db.Keys("pattern*")
417 assert.NotNil(t, err)
418 r.AssertExpectations(t)
421 func TestSetIEKeyExists(t *testing.T) {
422 _, r, db := setupHaEnv(true)
423 expectedMessage := []interface{}{"SETIE", "key", "newdata", "olddata"}
424 r.On("Do", expectedMessage).Return(redis.NewCmdResult("OK", nil))
425 result, err := db.SetIE("key", "olddata", "newdata")
426 assert.True(t, result)
428 r.AssertExpectations(t)
431 func TestSetIEKeyDoesntExists(t *testing.T) {
432 _, r, db := setupHaEnv(true)
433 expectedMessage := []interface{}{"SETIE", "key", "newdata", "olddata"}
434 r.On("Do", expectedMessage).Return(redis.NewCmdResult(nil, nil))
435 result, err := db.SetIE("key", "olddata", "newdata")
436 assert.False(t, result)
438 r.AssertExpectations(t)
441 func TestSetIEFailure(t *testing.T) {
442 _, r, db := setupHaEnv(true)
443 expectedMessage := []interface{}{"SETIE", "key", "newdata", "olddata"}
444 r.On("Do", expectedMessage).Return(redis.NewCmdResult(nil, errors.New("Some error")))
445 result, err := db.SetIE("key", "olddata", "newdata")
446 assert.False(t, result)
447 assert.NotNil(t, err)
448 r.AssertExpectations(t)
451 func TestSetIECommandMissing(t *testing.T) {
452 _, r, db := setupHaEnv(false)
453 expectedMessage := []interface{}{"SETIE", "key", "newdata", "olddata"}
454 r.AssertNotCalled(t, "Do", expectedMessage)
455 result, err := db.SetIE("key", "olddata", "newdata")
456 assert.False(t, result)
457 assert.NotNil(t, err)
458 r.AssertExpectations(t)
461 func TestSetIEPubKeyExists(t *testing.T) {
462 _, r, db := setupHaEnv(true)
463 expectedMessage := []interface{}{"SETIEMPUB", "key", "newdata", "olddata", "channel", "message"}
464 r.On("Do", expectedMessage).Return(redis.NewCmdResult("OK", nil))
465 result, err := db.SetIEPub([]string{"channel", "message"}, "key", "olddata", "newdata")
466 assert.True(t, result)
468 r.AssertExpectations(t)
471 func TestSetIEPubKeyDoesntExists(t *testing.T) {
472 _, r, db := setupHaEnv(true)
473 expectedMessage := []interface{}{"SETIEMPUB", "key", "newdata", "olddata", "channel", "message"}
474 r.On("Do", expectedMessage).Return(redis.NewCmdResult(nil, nil))
475 result, err := db.SetIEPub([]string{"channel", "message"}, "key", "olddata", "newdata")
476 assert.False(t, result)
478 r.AssertExpectations(t)
481 func TestSetIEPubFailure(t *testing.T) {
482 _, r, db := setupHaEnv(true)
483 expectedMessage := []interface{}{"SETIEMPUB", "key", "newdata", "olddata", "channel", "message"}
484 r.On("Do", expectedMessage).Return(redis.NewCmdResult(nil, errors.New("Some error")))
485 result, err := db.SetIEPub([]string{"channel", "message"}, "key", "olddata", "newdata")
486 assert.False(t, result)
487 assert.NotNil(t, err)
488 r.AssertExpectations(t)
491 func TestSetIEPubCommandMissing(t *testing.T) {
492 _, r, db := setupHaEnv(false)
493 expectedMessage := []interface{}{"SETIEMPUB", "key", "newdata", "olddata", "channel", "message"}
494 r.AssertNotCalled(t, "Do", expectedMessage)
495 result, err := db.SetIEPub([]string{"channel", "message"}, "key", "olddata", "newdata")
496 assert.False(t, result)
497 assert.NotNil(t, err)
498 r.AssertExpectations(t)
501 func TestSetNXPubKeyDoesntExist(t *testing.T) {
502 _, r, db := setupHaEnv(true)
503 expectedMessage := []interface{}{"SETNXMPUB", "key", "data", "channel", "message"}
504 r.On("Do", expectedMessage).Return(redis.NewCmdResult("OK", nil))
505 result, err := db.SetNXPub([]string{"channel", "message"}, "key", "data")
506 assert.True(t, result)
508 r.AssertExpectations(t)
511 func TestSetNXPubKeyExists(t *testing.T) {
512 _, r, db := setupHaEnv(true)
513 expectedMessage := []interface{}{"SETNXMPUB", "key", "data", "channel", "message"}
514 r.On("Do", expectedMessage).Return(redis.NewCmdResult(nil, nil))
515 result, err := db.SetNXPub([]string{"channel", "message"}, "key", "data")
516 assert.False(t, result)
518 r.AssertExpectations(t)
521 func TestSetNXPubFailure(t *testing.T) {
522 _, r, db := setupHaEnv(true)
523 expectedMessage := []interface{}{"SETNXMPUB", "key", "data", "channel", "message"}
524 r.On("Do", expectedMessage).Return(redis.NewCmdResult(nil, errors.New("Some error")))
525 result, err := db.SetNXPub([]string{"channel", "message"}, "key", "data")
526 assert.False(t, result)
527 assert.NotNil(t, err)
528 r.AssertExpectations(t)
531 func TestSetNXPubCommandMissing(t *testing.T) {
532 _, r, db := setupHaEnv(false)
533 expectedMessage := []interface{}{"SETNXMPUB", "key", "data", "channel", "message"}
534 r.AssertNotCalled(t, "Do", expectedMessage)
535 result, err := db.SetNXPub([]string{"channel", "message"}, "key", "data")
536 assert.False(t, result)
537 assert.NotNil(t, err)
538 r.AssertExpectations(t)
541 func TestSetNXSuccessfully(t *testing.T) {
542 _, r, db := setupHaEnv(true)
544 expectedData := "data"
545 r.On("SetNX", expectedKey, expectedData, time.Duration(0)).Return(redis.NewBoolResult(true, nil))
546 result, err := db.SetNX("key", "data", 0)
547 assert.True(t, result)
549 r.AssertExpectations(t)
552 func TestSetNXUnsuccessfully(t *testing.T) {
553 _, r, db := setupHaEnv(true)
555 expectedData := "data"
556 r.On("SetNX", expectedKey, expectedData, time.Duration(0)).Return(redis.NewBoolResult(false, nil))
557 result, err := db.SetNX("key", "data", 0)
558 assert.False(t, result)
560 r.AssertExpectations(t)
563 func TestSetNXFailure(t *testing.T) {
564 _, r, db := setupHaEnv(true)
566 expectedData := "data"
567 r.On("SetNX", expectedKey, expectedData, time.Duration(0)).
568 Return(redis.NewBoolResult(false, errors.New("Some error")))
569 result, err := db.SetNX("key", "data", 0)
570 assert.False(t, result)
571 assert.NotNil(t, err)
572 r.AssertExpectations(t)
575 func TestDelIEPubKeyDoesntExist(t *testing.T) {
576 _, r, db := setupHaEnv(true)
577 expectedMessage := []interface{}{"DELIEMPUB", "key", "data", "channel", "message"}
578 r.On("Do", expectedMessage).Return(redis.NewCmdResult(int64(0), nil))
579 result, err := db.DelIEPub([]string{"channel", "message"}, "key", "data")
580 assert.False(t, result)
582 r.AssertExpectations(t)
585 func TestDelIEPubKeyExists(t *testing.T) {
586 _, r, db := setupHaEnv(true)
587 expectedMessage := []interface{}{"DELIEMPUB", "key", "data", "channel", "message"}
588 r.On("Do", expectedMessage).Return(redis.NewCmdResult(int64(1), nil))
589 result, err := db.DelIEPub([]string{"channel", "message"}, "key", "data")
590 assert.True(t, result)
592 r.AssertExpectations(t)
595 func TestDelIEPubKeyExistsIntTypeRedisValue(t *testing.T) {
596 _, r, db := setupHaEnv(true)
597 expectedMessage := []interface{}{"DELIEMPUB", "key", "data", "channel", "message"}
598 r.On("Do", expectedMessage).Return(redis.NewCmdResult(1, nil))
599 result, err := db.DelIEPub([]string{"channel", "message"}, "key", "data")
600 assert.True(t, result)
602 r.AssertExpectations(t)
605 func TestDelIEPubFailure(t *testing.T) {
606 _, r, db := setupHaEnv(true)
607 expectedMessage := []interface{}{"DELIEMPUB", "key", "data", "channel", "message"}
608 r.On("Do", expectedMessage).Return(redis.NewCmdResult(int64(0), errors.New("Some error")))
609 result, err := db.DelIEPub([]string{"channel", "message"}, "key", "data")
610 assert.False(t, result)
611 assert.NotNil(t, err)
612 r.AssertExpectations(t)
615 func TestDelIEPubCommandMissing(t *testing.T) {
616 _, r, db := setupHaEnv(false)
617 expectedMessage := []interface{}{"DELIEMPUB", "key", "data", "channel", "message"}
618 r.AssertNotCalled(t, "Do", expectedMessage)
619 result, err := db.DelIEPub([]string{"channel", "message"}, "key", "data")
620 assert.False(t, result)
621 assert.NotNil(t, err)
622 r.AssertExpectations(t)
625 func TestDelIEKeyDoesntExist(t *testing.T) {
626 _, r, db := setupHaEnv(true)
627 expectedMessage := []interface{}{"DELIE", "key", "data"}
628 r.On("Do", expectedMessage).Return(redis.NewCmdResult(int64(0), nil))
629 result, err := db.DelIE("key", "data")
630 assert.False(t, result)
632 r.AssertExpectations(t)
635 func TestDelIEKeyExists(t *testing.T) {
636 _, r, db := setupHaEnv(true)
637 expectedMessage := []interface{}{"DELIE", "key", "data"}
638 r.On("Do", expectedMessage).Return(redis.NewCmdResult(int64(1), nil))
639 result, err := db.DelIE("key", "data")
640 assert.True(t, result)
642 r.AssertExpectations(t)
645 func TestDelIEKeyExistsIntTypeRedisValue(t *testing.T) {
646 _, r, db := setupHaEnv(true)
647 expectedMessage := []interface{}{"DELIE", "key", "data"}
648 r.On("Do", expectedMessage).Return(redis.NewCmdResult(1, nil))
649 result, err := db.DelIE("key", "data")
650 assert.True(t, result)
652 r.AssertExpectations(t)
655 func TestDelIEFailure(t *testing.T) {
656 _, r, db := setupHaEnv(true)
657 expectedMessage := []interface{}{"DELIE", "key", "data"}
658 r.On("Do", expectedMessage).Return(redis.NewCmdResult(int64(0), errors.New("Some error")))
659 result, err := db.DelIE("key", "data")
660 assert.False(t, result)
661 assert.NotNil(t, err)
662 r.AssertExpectations(t)
665 func TestDelIECommandMissing(t *testing.T) {
666 _, r, db := setupHaEnv(false)
667 expectedMessage := []interface{}{"DELIE", "key", "data"}
668 r.AssertNotCalled(t, "Do", expectedMessage)
669 result, err := db.DelIE("key", "data")
670 assert.False(t, result)
671 assert.NotNil(t, err)
672 r.AssertExpectations(t)
675 func TestSAddSuccessfully(t *testing.T) {
676 _, r, db := setupHaEnv(true)
678 expectedData := []interface{}{"data", 2}
679 r.On("SAdd", expectedKey, expectedData).Return(redis.NewIntResult(2, nil))
680 assert.Nil(t, db.SAdd("key", "data", 2))
681 r.AssertExpectations(t)
684 func TestSAddFailure(t *testing.T) {
685 _, r, db := setupHaEnv(true)
687 expectedData := []interface{}{"data", 2}
688 r.On("SAdd", expectedKey, expectedData).Return(redis.NewIntResult(2, errors.New("Some error")))
689 assert.NotNil(t, db.SAdd("key", "data", 2))
690 r.AssertExpectations(t)
693 func TestSRemSuccessfully(t *testing.T) {
694 _, r, db := setupHaEnv(true)
696 expectedData := []interface{}{"data", 2}
697 r.On("SRem", expectedKey, expectedData).Return(redis.NewIntResult(2, nil))
698 assert.Nil(t, db.SRem("key", "data", 2))
699 r.AssertExpectations(t)
702 func TestSRemFailure(t *testing.T) {
703 _, r, db := setupHaEnv(true)
705 expectedData := []interface{}{"data", 2}
706 r.On("SRem", expectedKey, expectedData).Return(redis.NewIntResult(2, errors.New("Some error")))
707 assert.NotNil(t, db.SRem("key", "data", 2))
708 r.AssertExpectations(t)
711 func TestSMembersSuccessfully(t *testing.T) {
712 _, r, db := setupHaEnv(true)
714 expectedResult := []string{"member1", "member2"}
715 r.On("SMembers", expectedKey).Return(redis.NewStringSliceResult(expectedResult, nil))
716 result, err := db.SMembers("key")
717 assert.Equal(t, result, expectedResult)
719 r.AssertExpectations(t)
722 func TestSMembersFailure(t *testing.T) {
723 _, r, db := setupHaEnv(true)
725 expectedResult := []string{"member1", "member2"}
726 r.On("SMembers", expectedKey).Return(redis.NewStringSliceResult(expectedResult,
727 errors.New("Some error")))
728 result, err := db.SMembers("key")
729 assert.Equal(t, result, expectedResult)
730 assert.NotNil(t, err)
731 r.AssertExpectations(t)
734 func TestSIsMemberIsMember(t *testing.T) {
735 _, r, db := setupHaEnv(true)
737 expectedData := "data"
738 r.On("SIsMember", expectedKey, expectedData).Return(redis.NewBoolResult(true, nil))
739 result, err := db.SIsMember("key", "data")
740 assert.True(t, result)
742 r.AssertExpectations(t)
745 func TestSIsMemberIsNotMember(t *testing.T) {
746 _, r, db := setupHaEnv(true)
748 expectedData := "data"
749 r.On("SIsMember", expectedKey, expectedData).Return(redis.NewBoolResult(false, nil))
750 result, err := db.SIsMember("key", "data")
751 assert.False(t, result)
753 r.AssertExpectations(t)
756 func TestSIsMemberFailure(t *testing.T) {
757 _, r, db := setupHaEnv(true)
759 expectedData := "data"
760 r.On("SIsMember", expectedKey, expectedData).
761 Return(redis.NewBoolResult(false, errors.New("Some error")))
762 result, err := db.SIsMember("key", "data")
763 assert.False(t, result)
764 assert.NotNil(t, err)
765 r.AssertExpectations(t)
768 func TestSCardSuccessfully(t *testing.T) {
769 _, r, db := setupHaEnv(true)
771 r.On("SCard", expectedKey).Return(redis.NewIntResult(1, nil))
772 result, err := db.SCard("key")
773 assert.Equal(t, int64(1), result)
775 r.AssertExpectations(t)
778 func TestSCardFailure(t *testing.T) {
779 _, r, db := setupHaEnv(true)
781 r.On("SCard", expectedKey).Return(redis.NewIntResult(1, errors.New("Some error")))
782 result, err := db.SCard("key")
783 assert.Equal(t, int64(1), result)
784 assert.NotNil(t, err)
785 r.AssertExpectations(t)
788 func TestSubscribeChannelDBSubscribeRXUnsubscribe(t *testing.T) {
789 ps, r, db := setupHaEnv(true)
790 ch := make(chan *redis.Message)
791 msg := redis.Message{
792 Channel: "{prefix}channel",
796 ps.On("Channel").Return(ch)
797 ps.On("Unsubscribe").Return(nil)
798 ps.On("Close").Return(nil)
800 receivedChannel := ""
801 db.SubscribeChannelDB(func(channel string, payload ...string) {
803 receivedChannel = channel
804 }, "{prefix}", "---", "{prefix}channel")
806 db.UnsubscribeChannelDB("{prefix}channel")
807 time.Sleep(1 * time.Second)
808 assert.Equal(t, 1, count)
809 assert.Equal(t, "channel", receivedChannel)
810 r.AssertExpectations(t)
811 ps.AssertExpectations(t)
814 func TestSubscribeChannelDBSubscribeTwoUnsubscribeOne(t *testing.T) {
815 ps, r, db := setupHaEnv(true)
816 ch := make(chan *redis.Message)
817 msg1 := redis.Message{
818 Channel: "{prefix}channel1",
822 msg2 := redis.Message{
823 Channel: "{prefix}channel2",
827 ps.On("Channel").Return(ch)
828 ps.On("Subscribe").Return(nil)
829 ps.On("Unsubscribe").Return(nil)
830 ps.On("Unsubscribe").Return(nil)
831 ps.On("Close").Return(nil)
833 receivedChannel1 := ""
834 db.SubscribeChannelDB(func(channel string, payload ...string) {
836 receivedChannel1 = channel
837 }, "{prefix}", "---", "{prefix}channel1")
839 receivedChannel2 := ""
840 db.SubscribeChannelDB(func(channel string, payload ...string) {
842 receivedChannel2 = channel
843 }, "{prefix}", "---", "{prefix}channel2")
845 time.Sleep(1 * time.Second)
846 db.UnsubscribeChannelDB("{prefix}channel1")
848 db.UnsubscribeChannelDB("{prefix}channel2")
849 time.Sleep(1 * time.Second)
850 assert.Equal(t, 2, count)
851 assert.Equal(t, "channel1", receivedChannel1)
852 assert.Equal(t, "channel2", receivedChannel2)
853 r.AssertExpectations(t)
854 ps.AssertExpectations(t)
857 func TestSubscribeChannelReDBSubscribeAfterUnsubscribe(t *testing.T) {
858 ps, r, db := setupHaEnv(true)
859 ch := make(chan *redis.Message)
860 msg := redis.Message{
861 Channel: "{prefix}channel",
865 ps.On("Channel").Return(ch)
866 ps.On("Unsubscribe").Return(nil)
867 ps.On("Close").Return(nil)
869 receivedChannel := ""
871 db.SubscribeChannelDB(func(channel string, payload ...string) {
873 receivedChannel = channel
874 }, "{prefix}", "---", "{prefix}channel")
876 db.UnsubscribeChannelDB("{prefix}channel")
877 time.Sleep(1 * time.Second)
879 db.SubscribeChannelDB(func(channel string, payload ...string) {
881 receivedChannel = channel
882 }, "{prefix}", "---", "{prefix}channel")
884 db.UnsubscribeChannelDB("{prefix}channel")
886 time.Sleep(1 * time.Second)
887 assert.Equal(t, 2, count)
888 assert.Equal(t, "channel", receivedChannel)
889 r.AssertExpectations(t)
890 ps.AssertExpectations(t)
893 func TestPTTLSuccessfully(t *testing.T) {
894 _, r, db := setupHaEnv(true)
896 expectedResult := time.Duration(1)
897 r.On("PTTL", expectedKey).Return(redis.NewDurationResult(expectedResult,
899 result, err := db.PTTL("key")
900 assert.Equal(t, result, expectedResult)
902 r.AssertExpectations(t)
905 func TestPTTLFailure(t *testing.T) {
906 _, r, db := setupHaEnv(true)
908 expectedResult := time.Duration(1)
909 r.On("PTTL", expectedKey).Return(redis.NewDurationResult(expectedResult,
910 errors.New("Some error")))
911 result, err := db.PTTL("key")
912 assert.Equal(t, result, expectedResult)
913 assert.NotNil(t, err)
914 r.AssertExpectations(t)
917 func TestPExpireIESuccessfully(t *testing.T) {
918 _, r, db := setupHaEnv(true)
920 expectedData := "data"
921 expectedDuration := strconv.FormatInt(int64(10000), 10)
923 r.On("EvalSha", mock.Anything, []string{expectedKey}, []interface{}{expectedData, expectedDuration}).
924 Return(redis.NewCmdResult(int64(1), nil))
926 err := db.PExpireIE("key", "data", 10*time.Second)
928 r.AssertExpectations(t)
931 func TestPExpireIEFailure(t *testing.T) {
932 _, r, db := setupHaEnv(true)
934 expectedData := "data"
935 expectedDuration := strconv.FormatInt(int64(10000), 10)
937 r.On("EvalSha", mock.Anything, []string{expectedKey}, []interface{}{expectedData, expectedDuration}).
938 Return(redis.NewCmdResult(int64(1), errors.New("Some error")))
940 err := db.PExpireIE("key", "data", 10*time.Second)
941 assert.NotNil(t, err)
942 r.AssertExpectations(t)
945 func TestPExpireIELockNotHeld(t *testing.T) {
946 _, r, db := setupHaEnv(true)
948 expectedData := "data"
949 expectedDuration := strconv.FormatInt(int64(10000), 10)
951 r.On("EvalSha", mock.Anything, []string{expectedKey}, []interface{}{expectedData, expectedDuration}).
952 Return(redis.NewCmdResult(int64(0), nil))
954 err := db.PExpireIE("key", "data", 10*time.Second)
955 assert.NotNil(t, err)
956 r.AssertExpectations(t)
959 func TestClientStandaloneRedisLegacyEnv(t *testing.T) {
960 setupVals := setupEnv(
962 "service-ricplt-dbaas-tcp-cluster-0.ricplt", "6376", "", "", "", "",
964 assert.Equal(t, 1, len(setupVals.rClient))
965 assert.Equal(t, 1, len(setupVals.db))
967 expectedKeysAndValues := []interface{}{"key1", "value1"}
968 setupVals.rClient[0].On("MSet", expectedKeysAndValues).Return(redis.NewStatusResult("OK", nil))
969 err := setupVals.db[0].MSet("key1", "value1")
971 setupVals.rClient[0].AssertExpectations(t)
974 func TestClientSentinelRedisLegacyEnv(t *testing.T) {
975 setupVals := setupEnv(
977 "service-ricplt-dbaas-tcp-cluster-0.ricplt", "6376", "dbaasmaster", "26376", "", "3",
979 assert.Equal(t, 1, len(setupVals.rClient))
980 assert.Equal(t, 1, len(setupVals.db))
982 expectedKeysAndValues := []interface{}{"key1", "value1"}
983 setupVals.rClient[0].On("MSet", expectedKeysAndValues).Return(redis.NewStatusResult("OK", nil))
984 err := setupVals.db[0].MSet("key1", "value1")
986 setupVals.rClient[0].AssertExpectations(t)
989 func TestClientTwoStandaloneRedisEnvs(t *testing.T) {
990 setupVals := setupEnv(
992 "service-ricplt-dbaas-tcp-cluster-0.ricplt", "6376", "", "",
993 "service-ricplt-dbaas-tcp-cluster-0.ricplt,service-ricplt-dbaas-tcp-cluster-1.ricplt", "",
995 assert.Equal(t, 2, len(setupVals.rClient))
996 assert.Equal(t, 2, len(setupVals.db))
998 expectedKeysAndValues := []interface{}{"key1", "value1"}
999 setupVals.rClient[0].On("MSet", expectedKeysAndValues).Return(redis.NewStatusResult("OK", nil))
1000 err := setupVals.db[0].MSet("key1", "value1")
1002 setupVals.rClient[0].AssertExpectations(t)
1004 expectedKeysAndValues = []interface{}{"key2", "value2"}
1005 setupVals.rClient[1].On("MSet", expectedKeysAndValues).Return(redis.NewStatusResult("OK", nil))
1006 err = setupVals.db[1].MSet("key2", "value2")
1008 setupVals.rClient[0].AssertExpectations(t)
1009 setupVals.rClient[1].AssertExpectations(t)
1012 func TestClientTwoSentinelRedisEnvs(t *testing.T) {
1013 setupVals := setupEnv(
1015 "service-ricplt-dbaas-tcp-cluster-0.ricplt", "6376", "dbaasmaster", "26376",
1016 "service-ricplt-dbaas-tcp-cluster-0.ricplt,service-ricplt-dbaas-tcp-cluster-1.ricplt", "3",
1018 assert.Equal(t, 2, len(setupVals.rClient))
1019 assert.Equal(t, 2, len(setupVals.db))
1021 expectedKeysAndValues := []interface{}{"key1", "value1"}
1022 setupVals.rClient[0].On("MSet", expectedKeysAndValues).Return(redis.NewStatusResult("OK", nil))
1023 err := setupVals.db[0].MSet("key1", "value1")
1025 setupVals.rClient[0].AssertExpectations(t)
1027 expectedKeysAndValues = []interface{}{"key2", "value2"}
1028 setupVals.rClient[1].On("MSet", expectedKeysAndValues).Return(redis.NewStatusResult("OK", nil))
1029 err = setupVals.db[1].MSet("key2", "value2")
1031 setupVals.rClient[0].AssertExpectations(t)
1032 setupVals.rClient[1].AssertExpectations(t)
1035 func TestInfoOfMasterRedisWithTwoSlavesSuccessfully(t *testing.T) {
1036 _, r, db := setupHaEnv(true)
1037 redisInfo := "# Replication\r\n" +
1039 "connected_slaves:2\r\n" +
1040 "min_slaves_good_slaves:2\r\n" +
1041 "slave0:ip=1.2.3.4,port=6379,state=online,offset=100200300,lag=0\r\n" +
1042 "slave1:ip=5.6.7.8,port=6379,state=online,offset=100200300,lag=0\r\n"
1043 expInfo := &sdlgoredis.DbInfo{
1044 Fields: sdlgoredis.DbInfoFields{
1046 ConnectedReplicaCnt: 2,
1050 r.On("Info", []string{"all"}).Return(redis.NewStringResult(redisInfo, nil))
1051 info, err := db.Info()
1053 assert.Equal(t, expInfo, info)
1054 r.AssertExpectations(t)
1057 func TestInfoOfMasterRedisWithOneSlaveOnlineAndOtherSlaveNotOnlineSuccessfully(t *testing.T) {
1058 _, r, db := setupHaEnv(true)
1059 redisInfo := "# Replication\r\n" +
1061 "connected_slaves:1\r\n" +
1062 "min_slaves_good_slaves:2\r\n" +
1063 "slave0:ip=1.2.3.4,port=6379,state=online,offset=100200300,lag=0\r\n" +
1064 "slave1:ip=5.6.7.8,port=6379,state=wait_bgsave,offset=100200300,lag=0\r\n"
1065 expInfo := &sdlgoredis.DbInfo{
1066 Fields: sdlgoredis.DbInfoFields{
1068 ConnectedReplicaCnt: 1,
1072 r.On("Info", []string{"all"}).Return(redis.NewStringResult(redisInfo, nil))
1073 info, err := db.Info()
1075 assert.Equal(t, expInfo, info)
1076 r.AssertExpectations(t)
1079 func TestInfoOfStandaloneMasterRedisSuccessfully(t *testing.T) {
1080 _, r, db := setupHaEnv(true)
1081 redisInfo := "# Replication\r\n" +
1083 "connected_slaves:0\r\n" +
1084 "min_slaves_good_slaves:0\r\n"
1085 expInfo := &sdlgoredis.DbInfo{
1086 Fields: sdlgoredis.DbInfoFields{
1088 ConnectedReplicaCnt: 0,
1092 r.On("Info", []string{"all"}).Return(redis.NewStringResult(redisInfo, nil))
1093 info, err := db.Info()
1095 assert.Equal(t, expInfo, info)
1096 r.AssertExpectations(t)
1099 func TestInfoWithGibberishContentSuccessfully(t *testing.T) {
1100 _, r, db := setupHaEnv(true)
1101 redisInfo := "!#¤%&?+?´-\r\n"
1102 expInfo := &sdlgoredis.DbInfo{}
1104 r.On("Info", []string{"all"}).Return(redis.NewStringResult(redisInfo, nil))
1105 info, err := db.Info()
1107 assert.Equal(t, expInfo, info)
1108 r.AssertExpectations(t)
1111 func TestInfoWithEmptyContentSuccessfully(t *testing.T) {
1112 _, r, db := setupHaEnv(true)
1113 var redisInfo string
1114 expInfo := &sdlgoredis.DbInfo{
1115 Fields: sdlgoredis.DbInfoFields{
1120 r.On("Info", []string{"all"}).Return(redis.NewStringResult(redisInfo, nil))
1121 info, err := db.Info()
1123 assert.Equal(t, expInfo, info)
1124 r.AssertExpectations(t)
1127 func TestStateWithMasterAndTwoSlaveRedisSuccessfully(t *testing.T) {
1128 _, r, s, db := setupHaEnvWithSentinels(true)
1129 redisMasterState := map[string]string{
1130 "role-reported": "master",
1132 redisSlavesState := make([]interface{}, 2)
1133 redisSlavesState[0] = []interface{}{
1134 "role-reported", "slave",
1135 "ip", "10.20.30.40",
1138 "master-link-status", "up",
1140 redisSlavesState[1] = []interface{}{
1141 "master-link-status", "up",
1142 "ip", "10.20.30.50",
1145 "role-reported", "slave",
1147 redisSentinelsState := make([]interface{}, 2)
1148 redisSentinelsState[0] = []interface{}{
1149 "ip", "10.20.30.40",
1151 "flags", "sentinel",
1153 redisSentinelsState[1] = []interface{}{
1154 "ip", "10.20.30.50",
1155 "flags", "sentinel",
1159 expState := &sdlgoredis.DbState{
1160 MasterDbState: sdlgoredis.MasterDbState{
1161 Fields: sdlgoredis.MasterDbStateFields{
1165 ReplicasDbState: &sdlgoredis.ReplicasDbState{
1166 States: []*sdlgoredis.ReplicaDbState{
1167 &sdlgoredis.ReplicaDbState{
1168 Fields: sdlgoredis.ReplicaDbStateFields{
1172 MasterLinkStatus: "up",
1176 &sdlgoredis.ReplicaDbState{
1177 Fields: sdlgoredis.ReplicaDbStateFields{
1181 MasterLinkStatus: "up",
1187 SentinelsDbState: &sdlgoredis.SentinelsDbState{
1188 States: []*sdlgoredis.SentinelDbState{
1189 &sdlgoredis.SentinelDbState{
1190 Fields: sdlgoredis.SentinelDbStateFields{
1196 &sdlgoredis.SentinelDbState{
1197 Fields: sdlgoredis.SentinelDbStateFields{
1207 s[0].On("Master", "dbaasmaster").Return(redis.NewStringStringMapResult(redisMasterState, nil))
1208 s[0].On("Slaves", "dbaasmaster").Return(redis.NewSliceResult(redisSlavesState, nil))
1209 s[0].On("Sentinels", "dbaasmaster").Return(redis.NewSliceResult(redisSentinelsState, nil))
1210 ret, err := db.State()
1212 assert.Equal(t, expState, ret)
1213 r.AssertExpectations(t)
1216 func TestStateWithMasterAndOneSlaveRedisFailureInMasterRedisCall(t *testing.T) {
1217 _, r, s, db := setupHaEnvWithSentinels(true)
1218 redisMasterState := map[string]string{}
1219 redisSlavesState := make([]interface{}, 1)
1220 redisSlavesState[0] = []interface{}{
1221 "role-reported", "slave",
1222 "ip", "10.20.30.40",
1225 "master-link-status", "up",
1227 redisSentinelsState := make([]interface{}, 1)
1228 redisSentinelsState[0] = []interface{}{
1229 "ip", "10.20.30.40",
1231 "flags", "sentinel",
1234 expState := &sdlgoredis.DbState{
1235 MasterDbState: sdlgoredis.MasterDbState{
1236 Err: errors.New("Some error"),
1238 ReplicasDbState: &sdlgoredis.ReplicasDbState{
1239 States: []*sdlgoredis.ReplicaDbState{
1240 &sdlgoredis.ReplicaDbState{
1241 Fields: sdlgoredis.ReplicaDbStateFields{
1245 MasterLinkStatus: "up",
1251 SentinelsDbState: &sdlgoredis.SentinelsDbState{
1252 States: []*sdlgoredis.SentinelDbState{
1253 &sdlgoredis.SentinelDbState{
1254 Fields: sdlgoredis.SentinelDbStateFields{
1264 s[0].On("Master", "dbaasmaster").Return(redis.NewStringStringMapResult(redisMasterState, errors.New("Some error")))
1265 s[0].On("Slaves", "dbaasmaster").Return(redis.NewSliceResult(redisSlavesState, nil))
1266 s[0].On("Sentinels", "dbaasmaster").Return(redis.NewSliceResult(redisSentinelsState, nil))
1267 ret, err := db.State()
1268 assert.NotNil(t, err)
1269 assert.Equal(t, expState, ret)
1270 r.AssertExpectations(t)
1273 func TestStateWithMasterAndOneSlaveRedisFailureInSlavesRedisCall(t *testing.T) {
1274 _, r, s, db := setupHaEnvWithSentinels(true)
1275 redisMasterState := map[string]string{
1276 "role-reported": "master",
1278 redisSlavesState := make([]interface{}, 1)
1279 redisSlavesState[0] = []interface{}{}
1280 redisSentinelsState := make([]interface{}, 1)
1281 redisSentinelsState[0] = []interface{}{
1282 "ip", "10.20.30.40",
1284 "flags", "sentinel",
1287 expState := &sdlgoredis.DbState{
1288 MasterDbState: sdlgoredis.MasterDbState{
1289 Fields: sdlgoredis.MasterDbStateFields{
1293 ReplicasDbState: &sdlgoredis.ReplicasDbState{
1294 Err: errors.New("Some error"),
1295 States: []*sdlgoredis.ReplicaDbState{},
1297 SentinelsDbState: &sdlgoredis.SentinelsDbState{
1298 States: []*sdlgoredis.SentinelDbState{
1299 &sdlgoredis.SentinelDbState{
1300 Fields: sdlgoredis.SentinelDbStateFields{
1310 s[0].On("Master", "dbaasmaster").Return(redis.NewStringStringMapResult(redisMasterState, nil))
1311 s[0].On("Slaves", "dbaasmaster").Return(redis.NewSliceResult(redisSlavesState, errors.New("Some error")))
1312 s[0].On("Sentinels", "dbaasmaster").Return(redis.NewSliceResult(redisSentinelsState, nil))
1313 ret, err := db.State()
1314 assert.NotNil(t, err)
1315 assert.Equal(t, expState, ret)
1316 r.AssertExpectations(t)
1319 func TestStateWithMasterAndOneSlaveRedisFailureInSentinelsRedisCall(t *testing.T) {
1320 _, r, s, db := setupHaEnvWithSentinels(true)
1321 redisMasterState := map[string]string{
1322 "role-reported": "master",
1324 redisSlavesState := make([]interface{}, 1)
1325 redisSlavesState[0] = []interface{}{
1326 "role-reported", "slave",
1327 "ip", "10.20.30.40",
1330 "master-link-status", "up",
1332 redisSentinelsState := make([]interface{}, 1)
1333 redisSentinelsState[0] = []interface{}{
1334 "ip", "10.20.30.40",
1336 "flags", "sentinel",
1339 expState := &sdlgoredis.DbState{
1340 MasterDbState: sdlgoredis.MasterDbState{
1341 Fields: sdlgoredis.MasterDbStateFields{
1345 ReplicasDbState: &sdlgoredis.ReplicasDbState{
1346 States: []*sdlgoredis.ReplicaDbState{
1347 &sdlgoredis.ReplicaDbState{
1348 Fields: sdlgoredis.ReplicaDbStateFields{
1352 MasterLinkStatus: "up",
1358 SentinelsDbState: &sdlgoredis.SentinelsDbState{
1359 Err: errors.New("Some error"),
1360 States: []*sdlgoredis.SentinelDbState{},
1364 s[0].On("Master", "dbaasmaster").Return(redis.NewStringStringMapResult(redisMasterState, nil))
1365 s[0].On("Slaves", "dbaasmaster").Return(redis.NewSliceResult(redisSlavesState, nil))
1366 s[0].On("Sentinels", "dbaasmaster").Return(redis.NewSliceResult(redisSentinelsState, errors.New("Some error")))
1367 ret, err := db.State()
1368 assert.NotNil(t, err)
1369 assert.Equal(t, expState, ret)
1370 r.AssertExpectations(t)
1373 func TestStateWithSingleMasterRedisSuccessfully(t *testing.T) {
1374 _, r, db := setupSingleEnv(true)
1375 redisInfo := "# Replication\r\n" +
1377 "connected_slaves:0\r\n" +
1378 "min_slaves_good_slaves:0\r\n"
1380 expState := &sdlgoredis.DbState{
1381 MasterDbState: sdlgoredis.MasterDbState{
1382 Fields: sdlgoredis.MasterDbStateFields{
1389 r.On("Info", []string{"all"}).Return(redis.NewStringResult(redisInfo, nil))
1390 ret, err := db.State()
1392 assert.Equal(t, expState, ret)
1393 r.AssertExpectations(t)
1396 func TestStateWithSingleMasterRedisFailureInInfoCall(t *testing.T) {
1397 _, r, db := setupSingleEnv(true)
1399 expState := &sdlgoredis.DbState{}
1401 r.On("Info", []string{"all"}).Return(redis.NewStringResult(redisInfo, errors.New("Some error")))
1402 ret, err := db.State()
1403 assert.NotNil(t, err)
1404 assert.Equal(t, expState, ret)
1405 r.AssertExpectations(t)