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
31 "gerrit.o-ran-sc.org/r/ric-plt/sdlgo/internal/sdlgoredis"
32 "github.com/go-redis/redis"
33 "github.com/stretchr/testify/assert"
34 "github.com/stretchr/testify/mock"
37 type clientMock struct {
41 type pubSubMock struct {
49 func (m *pubSubMock) Channel() <-chan *redis.Message {
50 return m.Called().Get(0).(chan *redis.Message)
53 func (m *pubSubMock) Subscribe(channels ...string) error {
54 return m.Called().Error(0)
57 func (m *pubSubMock) Unsubscribe(channels ...string) error {
58 return m.Called().Error(0)
61 func (m *pubSubMock) Close() error {
62 return m.Called().Error(0)
65 func (m *clientMock) Command() *redis.CommandsInfoCmd {
66 return m.Called().Get(0).(*redis.CommandsInfoCmd)
69 func (m *clientMock) Close() error {
70 return m.Called().Error(0)
73 func (m *clientMock) Subscribe(channels ...string) *redis.PubSub {
74 return m.Called(channels).Get(0).(*redis.PubSub)
77 func (m *clientMock) MSet(pairs ...interface{}) *redis.StatusCmd {
78 return m.Called(pairs).Get(0).(*redis.StatusCmd)
81 func (m *clientMock) Do(args ...interface{}) *redis.Cmd {
82 return m.Called(args).Get(0).(*redis.Cmd)
85 func (m *clientMock) MGet(keys ...string) *redis.SliceCmd {
86 return m.Called(keys).Get(0).(*redis.SliceCmd)
89 func (m *clientMock) Del(keys ...string) *redis.IntCmd {
90 return m.Called(keys).Get(0).(*redis.IntCmd)
93 func (m *clientMock) Keys(pattern string) *redis.StringSliceCmd {
94 return m.Called(pattern).Get(0).(*redis.StringSliceCmd)
97 func (m *clientMock) SetNX(key string, value interface{}, expiration time.Duration) *redis.BoolCmd {
98 return m.Called(key, value, expiration).Get(0).(*redis.BoolCmd)
101 func (m *clientMock) SAdd(key string, members ...interface{}) *redis.IntCmd {
102 return m.Called(key, members).Get(0).(*redis.IntCmd)
105 func (m *clientMock) SRem(key string, members ...interface{}) *redis.IntCmd {
106 return m.Called(key, members).Get(0).(*redis.IntCmd)
109 func (m *clientMock) SMembers(key string) *redis.StringSliceCmd {
110 return m.Called(key).Get(0).(*redis.StringSliceCmd)
113 func (m *clientMock) SIsMember(key string, member interface{}) *redis.BoolCmd {
114 return m.Called(key, member).Get(0).(*redis.BoolCmd)
117 func (m *clientMock) SCard(key string) *redis.IntCmd {
118 return m.Called(key).Get(0).(*redis.IntCmd)
121 func (m *clientMock) PTTL(key string) *redis.DurationCmd {
122 return m.Called(key).Get(0).(*redis.DurationCmd)
125 func (m *clientMock) Eval(script string, keys []string, args ...interface{}) *redis.Cmd {
126 return m.Called(script, keys).Get(0).(*redis.Cmd)
129 func (m *clientMock) EvalSha(sha1 string, keys []string, args ...interface{}) *redis.Cmd {
130 return m.Called(sha1, keys, args).Get(0).(*redis.Cmd)
133 func (m *clientMock) ScriptExists(scripts ...string) *redis.BoolSliceCmd {
134 return m.Called(scripts).Get(0).(*redis.BoolSliceCmd)
137 func (m *clientMock) ScriptLoad(script string) *redis.StringCmd {
138 return m.Called(script).Get(0).(*redis.StringCmd)
141 func setSubscribeNotifications() (*pubSubMock, sdlgoredis.SubscribeFn) {
142 mock := new(pubSubMock)
143 return mock, func(client sdlgoredis.RedisClient, channels ...string) sdlgoredis.Subscriber {
148 func (m *MockOS) Getenv(key string, defValue string) string {
149 a := m.Called(key, defValue)
153 func setup(commandsExists bool) (*pubSubMock, *clientMock, *sdlgoredis.DB) {
154 mock := new(clientMock)
155 pubSubMock, subscribeNotifications := setSubscribeNotifications()
156 db := sdlgoredis.CreateDB(mock, subscribeNotifications)
158 dummyCommandInfo := redis.CommandInfo{
161 cmdResult := make(map[string]*redis.CommandInfo, 0)
164 cmdResult = map[string]*redis.CommandInfo{
165 "setie": &dummyCommandInfo,
166 "delie": &dummyCommandInfo,
167 "setiepub": &dummyCommandInfo,
168 "setnxpub": &dummyCommandInfo,
169 "msetmpub": &dummyCommandInfo,
170 "delmpub": &dummyCommandInfo,
173 cmdResult = map[string]*redis.CommandInfo{
174 "dummy": &dummyCommandInfo,
178 mock.On("Command").Return(redis.NewCommandsInfoCmdResult(cmdResult, nil))
180 return pubSubMock, mock, db
183 func setupEnv(host, port, msname, sntport, clsaddrlist string) ([]*clientMock, []*sdlgoredis.DB) {
184 var clmocks []*clientMock
186 dummyCommandInfo := redis.CommandInfo{
189 cmdResult := make(map[string]*redis.CommandInfo, 0)
191 cmdResult = map[string]*redis.CommandInfo{
192 "dummy": &dummyCommandInfo,
195 osmock := new(MockOS)
196 osmock.On("Getenv", "DBAAS_SERVICE_HOST", "localhost").Return(host)
197 osmock.On("Getenv", "DBAAS_SERVICE_PORT", "6379").Return(port)
198 osmock.On("Getenv", "DBAAS_MASTER_NAME", "").Return(msname)
199 osmock.On("Getenv", "DBAAS_SERVICE_SENTINEL_PORT", "").Return(sntport)
200 osmock.On("Getenv", "DBAAS_CLUSTER_ADDR_LIST", "").Return(clsaddrlist)
202 clients := sdlgoredis.ReadConfigAndCreateDbClients(
204 func(addr, port, clusterName string, isHa bool) sdlgoredis.RedisClient {
205 clm := new(clientMock)
206 clm.On("Command").Return(redis.NewCommandsInfoCmdResult(cmdResult, nil))
207 clmocks = append(clmocks, clm)
212 return clmocks, clients
215 func TestCloseDbSuccessfully(t *testing.T) {
216 _, r, db := setup(true)
217 r.On("Close").Return(nil)
220 r.AssertExpectations(t)
223 func TestCloseDbFailure(t *testing.T) {
224 _, r, db := setup(true)
225 r.On("Close").Return(errors.New("Some error"))
227 assert.NotNil(t, err)
228 r.AssertExpectations(t)
231 func TestMSetSuccessfully(t *testing.T) {
232 _, r, db := setup(true)
233 expectedKeysAndValues := []interface{}{"key1", "value1", "key2", 2}
234 r.On("MSet", expectedKeysAndValues).Return(redis.NewStatusResult("OK", nil))
235 err := db.MSet("key1", "value1", "key2", 2)
237 r.AssertExpectations(t)
240 func TestMSetFailure(t *testing.T) {
241 _, r, db := setup(true)
242 expectedKeysAndValues := []interface{}{"key1", "value1", "key2", 2}
243 r.On("MSet", expectedKeysAndValues).Return(redis.NewStatusResult("OK", errors.New("Some error")))
244 err := db.MSet("key1", "value1", "key2", 2)
245 assert.NotNil(t, err)
246 r.AssertExpectations(t)
249 func TestMSetMPubSuccessfully(t *testing.T) {
250 _, r, db := setup(true)
251 expectedMessage := []interface{}{"MSETMPUB", 2, 2, "key1", "val1", "key2", "val2",
252 "chan1", "event1", "chan2", "event2"}
253 r.On("Do", expectedMessage).Return(redis.NewCmdResult("", nil))
254 assert.Nil(t, db.MSetMPub([]string{"chan1", "event1", "chan2", "event2"},
255 "key1", "val1", "key2", "val2"))
256 r.AssertExpectations(t)
259 func TestMsetMPubFailure(t *testing.T) {
260 _, r, db := setup(true)
261 expectedMessage := []interface{}{"MSETMPUB", 2, 2, "key1", "val1", "key2", "val2",
262 "chan1", "event1", "chan2", "event2"}
263 r.On("Do", expectedMessage).Return(redis.NewCmdResult("", errors.New("Some error")))
264 assert.NotNil(t, db.MSetMPub([]string{"chan1", "event1", "chan2", "event2"},
265 "key1", "val1", "key2", "val2"))
266 r.AssertExpectations(t)
269 func TestMSetMPubCommandMissing(t *testing.T) {
270 _, r, db := setup(false)
271 expectedMessage := []interface{}{"MSETMPUB", 2, 2, "key1", "val1", "key2", "val2",
272 "chan1", "event1", "chan2", "event2"}
273 r.AssertNotCalled(t, "Do", expectedMessage)
274 assert.NotNil(t, db.MSetMPub([]string{"chan1", "event1", "chan2", "event2"},
275 "key1", "val1", "key2", "val2"))
276 r.AssertExpectations(t)
280 func TestMGetSuccessfully(t *testing.T) {
281 _, r, db := setup(true)
282 expectedKeys := []string{"key1", "key2", "key3"}
283 expectedResult := []interface{}{"val1", 2, nil}
284 r.On("MGet", expectedKeys).Return(redis.NewSliceResult(expectedResult, nil))
285 result, err := db.MGet([]string{"key1", "key2", "key3"})
286 assert.Equal(t, result, expectedResult)
288 r.AssertExpectations(t)
291 func TestMGetFailure(t *testing.T) {
292 _, r, db := setup(true)
293 expectedKeys := []string{"key1", "key2", "key3"}
294 expectedResult := []interface{}{nil}
295 r.On("MGet", expectedKeys).Return(redis.NewSliceResult(expectedResult,
296 errors.New("Some error")))
297 result, err := db.MGet([]string{"key1", "key2", "key3"})
298 assert.Equal(t, result, expectedResult)
299 assert.NotNil(t, err)
300 r.AssertExpectations(t)
303 func TestDelMPubSuccessfully(t *testing.T) {
304 _, r, db := setup(true)
305 expectedMessage := []interface{}{"DELMPUB", 2, 2, "key1", "key2", "chan1", "event1",
307 r.On("Do", expectedMessage).Return(redis.NewCmdResult("", nil))
308 assert.Nil(t, db.DelMPub([]string{"chan1", "event1", "chan2", "event2"},
309 []string{"key1", "key2"}))
310 r.AssertExpectations(t)
313 func TestDelMPubFailure(t *testing.T) {
314 _, r, db := setup(true)
315 expectedMessage := []interface{}{"DELMPUB", 2, 2, "key1", "key2", "chan1", "event1",
317 r.On("Do", expectedMessage).Return(redis.NewCmdResult("", errors.New("Some error")))
318 assert.NotNil(t, db.DelMPub([]string{"chan1", "event1", "chan2", "event2"},
319 []string{"key1", "key2"}))
320 r.AssertExpectations(t)
323 func TestDelMPubCommandMissing(t *testing.T) {
324 _, r, db := setup(false)
325 expectedMessage := []interface{}{"DELMPUB", 2, 2, "key1", "key2", "chan1", "event1",
327 r.AssertNotCalled(t, "Do", expectedMessage)
328 assert.NotNil(t, db.DelMPub([]string{"chan1", "event1", "chan2", "event2"},
329 []string{"key1", "key2"}))
330 r.AssertExpectations(t)
333 func TestDelSuccessfully(t *testing.T) {
334 _, r, db := setup(true)
335 expectedKeys := []string{"key1", "key2"}
336 r.On("Del", expectedKeys).Return(redis.NewIntResult(2, nil))
337 assert.Nil(t, db.Del([]string{"key1", "key2"}))
338 r.AssertExpectations(t)
341 func TestDelFailure(t *testing.T) {
342 _, r, db := setup(true)
343 expectedKeys := []string{"key1", "key2"}
344 r.On("Del", expectedKeys).Return(redis.NewIntResult(2, errors.New("Some error")))
345 assert.NotNil(t, db.Del([]string{"key1", "key2"}))
346 r.AssertExpectations(t)
349 func TestKeysSuccessfully(t *testing.T) {
350 _, r, db := setup(true)
351 expectedPattern := "pattern*"
352 expectedResult := []string{"pattern1", "pattern2"}
353 r.On("Keys", expectedPattern).Return(redis.NewStringSliceResult(expectedResult, nil))
354 result, err := db.Keys("pattern*")
355 assert.Equal(t, result, expectedResult)
357 r.AssertExpectations(t)
360 func TestKeysFailure(t *testing.T) {
361 _, r, db := setup(true)
362 expectedPattern := "pattern*"
363 expectedResult := []string{}
364 r.On("Keys", expectedPattern).Return(redis.NewStringSliceResult(expectedResult,
365 errors.New("Some error")))
366 _, err := db.Keys("pattern*")
367 assert.NotNil(t, err)
368 r.AssertExpectations(t)
371 func TestSetIEKeyExists(t *testing.T) {
372 _, r, db := setup(true)
373 expectedMessage := []interface{}{"SETIE", "key", "newdata", "olddata"}
374 r.On("Do", expectedMessage).Return(redis.NewCmdResult("OK", nil))
375 result, err := db.SetIE("key", "olddata", "newdata")
376 assert.True(t, result)
378 r.AssertExpectations(t)
381 func TestSetIEKeyDoesntExists(t *testing.T) {
382 _, r, db := setup(true)
383 expectedMessage := []interface{}{"SETIE", "key", "newdata", "olddata"}
384 r.On("Do", expectedMessage).Return(redis.NewCmdResult(nil, nil))
385 result, err := db.SetIE("key", "olddata", "newdata")
386 assert.False(t, result)
388 r.AssertExpectations(t)
391 func TestSetIEFailure(t *testing.T) {
392 _, r, db := setup(true)
393 expectedMessage := []interface{}{"SETIE", "key", "newdata", "olddata"}
394 r.On("Do", expectedMessage).Return(redis.NewCmdResult(nil, errors.New("Some error")))
395 result, err := db.SetIE("key", "olddata", "newdata")
396 assert.False(t, result)
397 assert.NotNil(t, err)
398 r.AssertExpectations(t)
401 func TestSetIECommandMissing(t *testing.T) {
402 _, r, db := setup(false)
403 expectedMessage := []interface{}{"SETIE", "key", "newdata", "olddata"}
404 r.AssertNotCalled(t, "Do", expectedMessage)
405 result, err := db.SetIE("key", "olddata", "newdata")
406 assert.False(t, result)
407 assert.NotNil(t, err)
408 r.AssertExpectations(t)
411 func TestSetIEPubKeyExists(t *testing.T) {
412 _, r, db := setup(true)
413 expectedMessage := []interface{}{"SETIEMPUB", "key", "newdata", "olddata", "channel", "message"}
414 r.On("Do", expectedMessage).Return(redis.NewCmdResult("OK", nil))
415 result, err := db.SetIEPub([]string{"channel", "message"}, "key", "olddata", "newdata")
416 assert.True(t, result)
418 r.AssertExpectations(t)
421 func TestSetIEPubKeyDoesntExists(t *testing.T) {
422 _, r, db := setup(true)
423 expectedMessage := []interface{}{"SETIEMPUB", "key", "newdata", "olddata", "channel", "message"}
424 r.On("Do", expectedMessage).Return(redis.NewCmdResult(nil, nil))
425 result, err := db.SetIEPub([]string{"channel", "message"}, "key", "olddata", "newdata")
426 assert.False(t, result)
428 r.AssertExpectations(t)
431 func TestSetIEPubFailure(t *testing.T) {
432 _, r, db := setup(true)
433 expectedMessage := []interface{}{"SETIEMPUB", "key", "newdata", "olddata", "channel", "message"}
434 r.On("Do", expectedMessage).Return(redis.NewCmdResult(nil, errors.New("Some error")))
435 result, err := db.SetIEPub([]string{"channel", "message"}, "key", "olddata", "newdata")
436 assert.False(t, result)
437 assert.NotNil(t, err)
438 r.AssertExpectations(t)
441 func TestSetIEPubCommandMissing(t *testing.T) {
442 _, r, db := setup(false)
443 expectedMessage := []interface{}{"SETIEMPUB", "key", "newdata", "olddata", "channel", "message"}
444 r.AssertNotCalled(t, "Do", expectedMessage)
445 result, err := db.SetIEPub([]string{"channel", "message"}, "key", "olddata", "newdata")
446 assert.False(t, result)
447 assert.NotNil(t, err)
448 r.AssertExpectations(t)
451 func TestSetNXPubKeyDoesntExist(t *testing.T) {
452 _, r, db := setup(true)
453 expectedMessage := []interface{}{"SETNXMPUB", "key", "data", "channel", "message"}
454 r.On("Do", expectedMessage).Return(redis.NewCmdResult("OK", nil))
455 result, err := db.SetNXPub([]string{"channel", "message"}, "key", "data")
456 assert.True(t, result)
458 r.AssertExpectations(t)
461 func TestSetNXPubKeyExists(t *testing.T) {
462 _, r, db := setup(true)
463 expectedMessage := []interface{}{"SETNXMPUB", "key", "data", "channel", "message"}
464 r.On("Do", expectedMessage).Return(redis.NewCmdResult(nil, nil))
465 result, err := db.SetNXPub([]string{"channel", "message"}, "key", "data")
466 assert.False(t, result)
468 r.AssertExpectations(t)
471 func TestSetNXPubFailure(t *testing.T) {
472 _, r, db := setup(true)
473 expectedMessage := []interface{}{"SETNXMPUB", "key", "data", "channel", "message"}
474 r.On("Do", expectedMessage).Return(redis.NewCmdResult(nil, errors.New("Some error")))
475 result, err := db.SetNXPub([]string{"channel", "message"}, "key", "data")
476 assert.False(t, result)
477 assert.NotNil(t, err)
478 r.AssertExpectations(t)
481 func TestSetNXPubCommandMissing(t *testing.T) {
482 _, r, db := setup(false)
483 expectedMessage := []interface{}{"SETNXMPUB", "key", "data", "channel", "message"}
484 r.AssertNotCalled(t, "Do", expectedMessage)
485 result, err := db.SetNXPub([]string{"channel", "message"}, "key", "data")
486 assert.False(t, result)
487 assert.NotNil(t, err)
488 r.AssertExpectations(t)
491 func TestSetNXSuccessfully(t *testing.T) {
492 _, r, db := setup(true)
494 expectedData := "data"
495 r.On("SetNX", expectedKey, expectedData, time.Duration(0)).Return(redis.NewBoolResult(true, nil))
496 result, err := db.SetNX("key", "data", 0)
497 assert.True(t, result)
499 r.AssertExpectations(t)
502 func TestSetNXUnsuccessfully(t *testing.T) {
503 _, r, db := setup(true)
505 expectedData := "data"
506 r.On("SetNX", expectedKey, expectedData, time.Duration(0)).Return(redis.NewBoolResult(false, nil))
507 result, err := db.SetNX("key", "data", 0)
508 assert.False(t, result)
510 r.AssertExpectations(t)
513 func TestSetNXFailure(t *testing.T) {
514 _, r, db := setup(true)
516 expectedData := "data"
517 r.On("SetNX", expectedKey, expectedData, time.Duration(0)).
518 Return(redis.NewBoolResult(false, errors.New("Some error")))
519 result, err := db.SetNX("key", "data", 0)
520 assert.False(t, result)
521 assert.NotNil(t, err)
522 r.AssertExpectations(t)
525 func TestDelIEPubKeyDoesntExist(t *testing.T) {
526 _, r, db := setup(true)
527 expectedMessage := []interface{}{"DELIEMPUB", "key", "data", "channel", "message"}
528 r.On("Do", expectedMessage).Return(redis.NewCmdResult(int64(0), nil))
529 result, err := db.DelIEPub([]string{"channel", "message"}, "key", "data")
530 assert.False(t, result)
532 r.AssertExpectations(t)
535 func TestDelIEPubKeyExists(t *testing.T) {
536 _, r, db := setup(true)
537 expectedMessage := []interface{}{"DELIEMPUB", "key", "data", "channel", "message"}
538 r.On("Do", expectedMessage).Return(redis.NewCmdResult(int64(1), nil))
539 result, err := db.DelIEPub([]string{"channel", "message"}, "key", "data")
540 assert.True(t, result)
542 r.AssertExpectations(t)
545 func TestDelIEPubKeyExistsIntTypeRedisValue(t *testing.T) {
546 _, r, db := setup(true)
547 expectedMessage := []interface{}{"DELIEMPUB", "key", "data", "channel", "message"}
548 r.On("Do", expectedMessage).Return(redis.NewCmdResult(1, nil))
549 result, err := db.DelIEPub([]string{"channel", "message"}, "key", "data")
550 assert.True(t, result)
552 r.AssertExpectations(t)
555 func TestDelIEPubFailure(t *testing.T) {
556 _, r, db := setup(true)
557 expectedMessage := []interface{}{"DELIEMPUB", "key", "data", "channel", "message"}
558 r.On("Do", expectedMessage).Return(redis.NewCmdResult(int64(0), errors.New("Some error")))
559 result, err := db.DelIEPub([]string{"channel", "message"}, "key", "data")
560 assert.False(t, result)
561 assert.NotNil(t, err)
562 r.AssertExpectations(t)
565 func TestDelIEPubCommandMissing(t *testing.T) {
566 _, r, db := setup(false)
567 expectedMessage := []interface{}{"DELIEMPUB", "key", "data", "channel", "message"}
568 r.AssertNotCalled(t, "Do", expectedMessage)
569 result, err := db.DelIEPub([]string{"channel", "message"}, "key", "data")
570 assert.False(t, result)
571 assert.NotNil(t, err)
572 r.AssertExpectations(t)
575 func TestDelIEKeyDoesntExist(t *testing.T) {
576 _, r, db := setup(true)
577 expectedMessage := []interface{}{"DELIE", "key", "data"}
578 r.On("Do", expectedMessage).Return(redis.NewCmdResult(int64(0), nil))
579 result, err := db.DelIE("key", "data")
580 assert.False(t, result)
582 r.AssertExpectations(t)
585 func TestDelIEKeyExists(t *testing.T) {
586 _, r, db := setup(true)
587 expectedMessage := []interface{}{"DELIE", "key", "data"}
588 r.On("Do", expectedMessage).Return(redis.NewCmdResult(int64(1), nil))
589 result, err := db.DelIE("key", "data")
590 assert.True(t, result)
592 r.AssertExpectations(t)
595 func TestDelIEKeyExistsIntTypeRedisValue(t *testing.T) {
596 _, r, db := setup(true)
597 expectedMessage := []interface{}{"DELIE", "key", "data"}
598 r.On("Do", expectedMessage).Return(redis.NewCmdResult(1, nil))
599 result, err := db.DelIE("key", "data")
600 assert.True(t, result)
602 r.AssertExpectations(t)
605 func TestDelIEFailure(t *testing.T) {
606 _, r, db := setup(true)
607 expectedMessage := []interface{}{"DELIE", "key", "data"}
608 r.On("Do", expectedMessage).Return(redis.NewCmdResult(int64(0), errors.New("Some error")))
609 result, err := db.DelIE("key", "data")
610 assert.False(t, result)
611 assert.NotNil(t, err)
612 r.AssertExpectations(t)
615 func TestDelIECommandMissing(t *testing.T) {
616 _, r, db := setup(false)
617 expectedMessage := []interface{}{"DELIE", "key", "data"}
618 r.AssertNotCalled(t, "Do", expectedMessage)
619 result, err := db.DelIE("key", "data")
620 assert.False(t, result)
621 assert.NotNil(t, err)
622 r.AssertExpectations(t)
625 func TestSAddSuccessfully(t *testing.T) {
626 _, r, db := setup(true)
628 expectedData := []interface{}{"data", 2}
629 r.On("SAdd", expectedKey, expectedData).Return(redis.NewIntResult(2, nil))
630 assert.Nil(t, db.SAdd("key", "data", 2))
631 r.AssertExpectations(t)
634 func TestSAddFailure(t *testing.T) {
635 _, r, db := setup(true)
637 expectedData := []interface{}{"data", 2}
638 r.On("SAdd", expectedKey, expectedData).Return(redis.NewIntResult(2, errors.New("Some error")))
639 assert.NotNil(t, db.SAdd("key", "data", 2))
640 r.AssertExpectations(t)
643 func TestSRemSuccessfully(t *testing.T) {
644 _, r, db := setup(true)
646 expectedData := []interface{}{"data", 2}
647 r.On("SRem", expectedKey, expectedData).Return(redis.NewIntResult(2, nil))
648 assert.Nil(t, db.SRem("key", "data", 2))
649 r.AssertExpectations(t)
652 func TestSRemFailure(t *testing.T) {
653 _, r, db := setup(true)
655 expectedData := []interface{}{"data", 2}
656 r.On("SRem", expectedKey, expectedData).Return(redis.NewIntResult(2, errors.New("Some error")))
657 assert.NotNil(t, db.SRem("key", "data", 2))
658 r.AssertExpectations(t)
661 func TestSMembersSuccessfully(t *testing.T) {
662 _, r, db := setup(true)
664 expectedResult := []string{"member1", "member2"}
665 r.On("SMembers", expectedKey).Return(redis.NewStringSliceResult(expectedResult, nil))
666 result, err := db.SMembers("key")
667 assert.Equal(t, result, expectedResult)
669 r.AssertExpectations(t)
672 func TestSMembersFailure(t *testing.T) {
673 _, r, db := setup(true)
675 expectedResult := []string{"member1", "member2"}
676 r.On("SMembers", expectedKey).Return(redis.NewStringSliceResult(expectedResult,
677 errors.New("Some error")))
678 result, err := db.SMembers("key")
679 assert.Equal(t, result, expectedResult)
680 assert.NotNil(t, err)
681 r.AssertExpectations(t)
684 func TestSIsMemberIsMember(t *testing.T) {
685 _, r, db := setup(true)
687 expectedData := "data"
688 r.On("SIsMember", expectedKey, expectedData).Return(redis.NewBoolResult(true, nil))
689 result, err := db.SIsMember("key", "data")
690 assert.True(t, result)
692 r.AssertExpectations(t)
695 func TestSIsMemberIsNotMember(t *testing.T) {
696 _, r, db := setup(true)
698 expectedData := "data"
699 r.On("SIsMember", expectedKey, expectedData).Return(redis.NewBoolResult(false, nil))
700 result, err := db.SIsMember("key", "data")
701 assert.False(t, result)
703 r.AssertExpectations(t)
706 func TestSIsMemberFailure(t *testing.T) {
707 _, r, db := setup(true)
709 expectedData := "data"
710 r.On("SIsMember", expectedKey, expectedData).
711 Return(redis.NewBoolResult(false, errors.New("Some error")))
712 result, err := db.SIsMember("key", "data")
713 assert.False(t, result)
714 assert.NotNil(t, err)
715 r.AssertExpectations(t)
718 func TestSCardSuccessfully(t *testing.T) {
719 _, r, db := setup(true)
721 r.On("SCard", expectedKey).Return(redis.NewIntResult(1, nil))
722 result, err := db.SCard("key")
723 assert.Equal(t, int64(1), result)
725 r.AssertExpectations(t)
728 func TestSCardFailure(t *testing.T) {
729 _, r, db := setup(true)
731 r.On("SCard", expectedKey).Return(redis.NewIntResult(1, errors.New("Some error")))
732 result, err := db.SCard("key")
733 assert.Equal(t, int64(1), result)
734 assert.NotNil(t, err)
735 r.AssertExpectations(t)
738 func TestSubscribeChannelDBSubscribeRXUnsubscribe(t *testing.T) {
739 ps, r, db := setup(true)
740 ch := make(chan *redis.Message)
741 msg := redis.Message{
742 Channel: "{prefix}channel",
746 ps.On("Channel").Return(ch)
747 ps.On("Unsubscribe").Return(nil)
748 ps.On("Close").Return(nil)
750 receivedChannel := ""
751 db.SubscribeChannelDB(func(channel string, payload ...string) {
753 receivedChannel = channel
754 }, "{prefix}", "---", "{prefix}channel")
756 db.UnsubscribeChannelDB("{prefix}channel")
757 time.Sleep(1 * time.Second)
758 assert.Equal(t, 1, count)
759 assert.Equal(t, "channel", receivedChannel)
760 r.AssertExpectations(t)
761 ps.AssertExpectations(t)
764 func TestSubscribeChannelDBSubscribeTwoUnsubscribeOne(t *testing.T) {
765 ps, r, db := setup(true)
766 ch := make(chan *redis.Message)
767 msg1 := redis.Message{
768 Channel: "{prefix}channel1",
772 msg2 := redis.Message{
773 Channel: "{prefix}channel2",
777 ps.On("Channel").Return(ch)
778 ps.On("Subscribe").Return(nil)
779 ps.On("Unsubscribe").Return(nil)
780 ps.On("Unsubscribe").Return(nil)
781 ps.On("Close").Return(nil)
783 receivedChannel1 := ""
784 db.SubscribeChannelDB(func(channel string, payload ...string) {
786 receivedChannel1 = channel
787 }, "{prefix}", "---", "{prefix}channel1")
789 receivedChannel2 := ""
790 db.SubscribeChannelDB(func(channel string, payload ...string) {
792 receivedChannel2 = channel
793 }, "{prefix}", "---", "{prefix}channel2")
795 time.Sleep(1 * time.Second)
796 db.UnsubscribeChannelDB("{prefix}channel1")
798 db.UnsubscribeChannelDB("{prefix}channel2")
799 time.Sleep(1 * time.Second)
800 assert.Equal(t, 2, count)
801 assert.Equal(t, "channel1", receivedChannel1)
802 assert.Equal(t, "channel2", receivedChannel2)
803 r.AssertExpectations(t)
804 ps.AssertExpectations(t)
807 func TestSubscribeChannelReDBSubscribeAfterUnsubscribe(t *testing.T) {
808 ps, r, db := setup(true)
809 ch := make(chan *redis.Message)
810 msg := redis.Message{
811 Channel: "{prefix}channel",
815 ps.On("Channel").Return(ch)
816 ps.On("Unsubscribe").Return(nil)
817 ps.On("Close").Return(nil)
819 receivedChannel := ""
821 db.SubscribeChannelDB(func(channel string, payload ...string) {
823 receivedChannel = channel
824 }, "{prefix}", "---", "{prefix}channel")
826 db.UnsubscribeChannelDB("{prefix}channel")
827 time.Sleep(1 * time.Second)
829 db.SubscribeChannelDB(func(channel string, payload ...string) {
831 receivedChannel = channel
832 }, "{prefix}", "---", "{prefix}channel")
834 db.UnsubscribeChannelDB("{prefix}channel")
836 time.Sleep(1 * time.Second)
837 assert.Equal(t, 2, count)
838 assert.Equal(t, "channel", receivedChannel)
839 r.AssertExpectations(t)
840 ps.AssertExpectations(t)
843 func TestPTTLSuccessfully(t *testing.T) {
844 _, r, db := setup(true)
846 expectedResult := time.Duration(1)
847 r.On("PTTL", expectedKey).Return(redis.NewDurationResult(expectedResult,
849 result, err := db.PTTL("key")
850 assert.Equal(t, result, expectedResult)
852 r.AssertExpectations(t)
855 func TestPTTLFailure(t *testing.T) {
856 _, r, db := setup(true)
858 expectedResult := time.Duration(1)
859 r.On("PTTL", expectedKey).Return(redis.NewDurationResult(expectedResult,
860 errors.New("Some error")))
861 result, err := db.PTTL("key")
862 assert.Equal(t, result, expectedResult)
863 assert.NotNil(t, err)
864 r.AssertExpectations(t)
867 func TestPExpireIESuccessfully(t *testing.T) {
868 _, r, db := setup(true)
870 expectedData := "data"
871 expectedDuration := strconv.FormatInt(int64(10000), 10)
873 r.On("EvalSha", mock.Anything, []string{expectedKey}, []interface{}{expectedData, expectedDuration}).
874 Return(redis.NewCmdResult(int64(1), nil))
876 err := db.PExpireIE("key", "data", 10*time.Second)
878 r.AssertExpectations(t)
881 func TestPExpireIEFailure(t *testing.T) {
882 _, r, db := setup(true)
884 expectedData := "data"
885 expectedDuration := strconv.FormatInt(int64(10000), 10)
887 r.On("EvalSha", mock.Anything, []string{expectedKey}, []interface{}{expectedData, expectedDuration}).
888 Return(redis.NewCmdResult(int64(1), errors.New("Some error")))
890 err := db.PExpireIE("key", "data", 10*time.Second)
891 assert.NotNil(t, err)
892 r.AssertExpectations(t)
895 func TestPExpireIELockNotHeld(t *testing.T) {
896 _, r, db := setup(true)
898 expectedData := "data"
899 expectedDuration := strconv.FormatInt(int64(10000), 10)
901 r.On("EvalSha", mock.Anything, []string{expectedKey}, []interface{}{expectedData, expectedDuration}).
902 Return(redis.NewCmdResult(int64(0), nil))
904 err := db.PExpireIE("key", "data", 10*time.Second)
905 assert.NotNil(t, err)
906 r.AssertExpectations(t)
909 func TestClientStandaloneRedisLegacyEnv(t *testing.T) {
910 rcls, dbs := setupEnv(
911 "service-ricplt-dbaas-tcp-cluster-0.ricplt", "6376", "", "", "",
913 assert.Equal(t, 1, len(rcls))
914 assert.Equal(t, 1, len(dbs))
916 expectedKeysAndValues := []interface{}{"key1", "value1"}
917 rcls[0].On("MSet", expectedKeysAndValues).Return(redis.NewStatusResult("OK", nil))
918 err := dbs[0].MSet("key1", "value1")
920 rcls[0].AssertExpectations(t)
923 func TestClientSentinelRedisLegacyEnv(t *testing.T) {
924 rcls, dbs := setupEnv(
925 "service-ricplt-dbaas-tcp-cluster-0.ricplt", "6376", "dbaasmaster", "26376", "",
927 assert.Equal(t, 1, len(rcls))
928 assert.Equal(t, 1, len(dbs))
930 expectedKeysAndValues := []interface{}{"key1", "value1"}
931 rcls[0].On("MSet", expectedKeysAndValues).Return(redis.NewStatusResult("OK", nil))
932 err := dbs[0].MSet("key1", "value1")
934 rcls[0].AssertExpectations(t)
937 func TestClientTwoStandaloneRedisEnvs(t *testing.T) {
938 rcls, dbs := setupEnv(
939 "service-ricplt-dbaas-tcp-cluster-0.ricplt", "6376", "", "",
940 "service-ricplt-dbaas-tcp-cluster-0.ricplt,service-ricplt-dbaas-tcp-cluster-1.ricplt",
942 assert.Equal(t, 2, len(rcls))
943 assert.Equal(t, 2, len(dbs))
945 expectedKeysAndValues := []interface{}{"key1", "value1"}
946 rcls[0].On("MSet", expectedKeysAndValues).Return(redis.NewStatusResult("OK", nil))
947 err := dbs[0].MSet("key1", "value1")
949 rcls[0].AssertExpectations(t)
951 expectedKeysAndValues = []interface{}{"key2", "value2"}
952 rcls[1].On("MSet", expectedKeysAndValues).Return(redis.NewStatusResult("OK", nil))
953 err = dbs[1].MSet("key2", "value2")
955 rcls[0].AssertExpectations(t)
956 rcls[1].AssertExpectations(t)
959 func TestClientTwoSentinelRedisEnvs(t *testing.T) {
960 rcls, dbs := setupEnv(
961 "service-ricplt-dbaas-tcp-cluster-0.ricplt", "6376", "dbaasmaster", "26376",
962 "service-ricplt-dbaas-tcp-cluster-0.ricplt,service-ricplt-dbaas-tcp-cluster-1.ricplt",
964 assert.Equal(t, 2, len(rcls))
965 assert.Equal(t, 2, len(dbs))
967 expectedKeysAndValues := []interface{}{"key1", "value1"}
968 rcls[0].On("MSet", expectedKeysAndValues).Return(redis.NewStatusResult("OK", nil))
969 err := dbs[0].MSet("key1", "value1")
971 rcls[0].AssertExpectations(t)
973 expectedKeysAndValues = []interface{}{"key2", "value2"}
974 rcls[1].On("MSet", expectedKeysAndValues).Return(redis.NewStatusResult("OK", nil))
975 err = dbs[1].MSet("key2", "value2")
977 rcls[0].AssertExpectations(t)
978 rcls[1].AssertExpectations(t)