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 {
45 func (m *pubSubMock) Channel() <-chan *redis.Message {
46 return m.Called().Get(0).(chan *redis.Message)
49 func (m *pubSubMock) Subscribe(channels ...string) error {
50 return m.Called().Error(0)
53 func (m *pubSubMock) Unsubscribe(channels ...string) error {
54 return m.Called().Error(0)
57 func (m *pubSubMock) Close() error {
58 return m.Called().Error(0)
61 func (m *clientMock) Command() *redis.CommandsInfoCmd {
62 return m.Called().Get(0).(*redis.CommandsInfoCmd)
65 func (m *clientMock) Close() error {
66 return m.Called().Error(0)
69 func (m *clientMock) Subscribe(channels ...string) *redis.PubSub {
70 return m.Called(channels).Get(0).(*redis.PubSub)
73 func (m *clientMock) MSet(pairs ...interface{}) *redis.StatusCmd {
74 return m.Called(pairs).Get(0).(*redis.StatusCmd)
77 func (m *clientMock) Do(args ...interface{}) *redis.Cmd {
78 return m.Called(args).Get(0).(*redis.Cmd)
81 func (m *clientMock) MGet(keys ...string) *redis.SliceCmd {
82 return m.Called(keys).Get(0).(*redis.SliceCmd)
85 func (m *clientMock) Del(keys ...string) *redis.IntCmd {
86 return m.Called(keys).Get(0).(*redis.IntCmd)
89 func (m *clientMock) Keys(pattern string) *redis.StringSliceCmd {
90 return m.Called(pattern).Get(0).(*redis.StringSliceCmd)
93 func (m *clientMock) SetNX(key string, value interface{}, expiration time.Duration) *redis.BoolCmd {
94 return m.Called(key, value, expiration).Get(0).(*redis.BoolCmd)
97 func (m *clientMock) SAdd(key string, members ...interface{}) *redis.IntCmd {
98 return m.Called(key, members).Get(0).(*redis.IntCmd)
101 func (m *clientMock) SRem(key string, members ...interface{}) *redis.IntCmd {
102 return m.Called(key, members).Get(0).(*redis.IntCmd)
105 func (m *clientMock) SMembers(key string) *redis.StringSliceCmd {
106 return m.Called(key).Get(0).(*redis.StringSliceCmd)
109 func (m *clientMock) SIsMember(key string, member interface{}) *redis.BoolCmd {
110 return m.Called(key, member).Get(0).(*redis.BoolCmd)
113 func (m *clientMock) SCard(key string) *redis.IntCmd {
114 return m.Called(key).Get(0).(*redis.IntCmd)
117 func (m *clientMock) PTTL(key string) *redis.DurationCmd {
118 return m.Called(key).Get(0).(*redis.DurationCmd)
121 func (m *clientMock) Eval(script string, keys []string, args ...interface{}) *redis.Cmd {
122 return m.Called(script, keys).Get(0).(*redis.Cmd)
125 func (m *clientMock) EvalSha(sha1 string, keys []string, args ...interface{}) *redis.Cmd {
126 return m.Called(sha1, keys, args).Get(0).(*redis.Cmd)
129 func (m *clientMock) ScriptExists(scripts ...string) *redis.BoolSliceCmd {
130 return m.Called(scripts).Get(0).(*redis.BoolSliceCmd)
133 func (m *clientMock) ScriptLoad(script string) *redis.StringCmd {
134 return m.Called(script).Get(0).(*redis.StringCmd)
137 func setSubscribeNotifications() (*pubSubMock, sdlgoredis.SubscribeFn) {
138 mock := new(pubSubMock)
139 return mock, func(client sdlgoredis.RedisClient, channels ...string) sdlgoredis.Subscriber {
144 func setup(commandsExists bool) (*pubSubMock, *clientMock, *sdlgoredis.DB) {
145 mock := new(clientMock)
146 pubSubMock, subscribeNotifications := setSubscribeNotifications()
147 db := sdlgoredis.CreateDB(mock, subscribeNotifications)
149 dummyCommandInfo := redis.CommandInfo{
152 cmdResult := make(map[string]*redis.CommandInfo, 0)
155 cmdResult = map[string]*redis.CommandInfo{
156 "setie": &dummyCommandInfo,
157 "delie": &dummyCommandInfo,
158 "setiepub": &dummyCommandInfo,
159 "setnxpub": &dummyCommandInfo,
160 "msetmpub": &dummyCommandInfo,
161 "delmpub": &dummyCommandInfo,
164 cmdResult = map[string]*redis.CommandInfo{
165 "dummy": &dummyCommandInfo,
169 mock.On("Command").Return(redis.NewCommandsInfoCmdResult(cmdResult, nil))
171 return pubSubMock, mock, db
174 func TestMSetSuccessfully(t *testing.T) {
175 _, r, db := setup(true)
176 expectedKeysAndValues := []interface{}{"key1", "value1", "key2", 2}
177 r.On("MSet", expectedKeysAndValues).Return(redis.NewStatusResult("OK", nil))
178 err := db.MSet("key1", "value1", "key2", 2)
180 r.AssertExpectations(t)
183 func TestMSetFailure(t *testing.T) {
184 _, r, db := setup(true)
185 expectedKeysAndValues := []interface{}{"key1", "value1", "key2", 2}
186 r.On("MSet", expectedKeysAndValues).Return(redis.NewStatusResult("OK", errors.New("Some error")))
187 err := db.MSet("key1", "value1", "key2", 2)
188 assert.NotNil(t, err)
189 r.AssertExpectations(t)
192 func TestMSetMPubSuccessfully(t *testing.T) {
193 _, r, db := setup(true)
194 expectedMessage := []interface{}{"MSETMPUB", 2, 2, "key1", "val1", "key2", "val2",
195 "chan1", "event1", "chan2", "event2"}
196 r.On("Do", expectedMessage).Return(redis.NewCmdResult("", nil))
197 assert.Nil(t, db.MSetMPub([]string{"chan1", "event1", "chan2", "event2"},
198 "key1", "val1", "key2", "val2"))
199 r.AssertExpectations(t)
202 func TestMsetMPubFailure(t *testing.T) {
203 _, r, db := setup(true)
204 expectedMessage := []interface{}{"MSETMPUB", 2, 2, "key1", "val1", "key2", "val2",
205 "chan1", "event1", "chan2", "event2"}
206 r.On("Do", expectedMessage).Return(redis.NewCmdResult("", errors.New("Some error")))
207 assert.NotNil(t, db.MSetMPub([]string{"chan1", "event1", "chan2", "event2"},
208 "key1", "val1", "key2", "val2"))
209 r.AssertExpectations(t)
212 func TestMSetMPubCommandMissing(t *testing.T) {
213 _, r, db := setup(false)
214 expectedMessage := []interface{}{"MSETMPUB", 2, 2, "key1", "val1", "key2", "val2",
215 "chan1", "event1", "chan2", "event2"}
216 r.AssertNotCalled(t, "Do", expectedMessage)
217 assert.NotNil(t, db.MSetMPub([]string{"chan1", "event1", "chan2", "event2"},
218 "key1", "val1", "key2", "val2"))
219 r.AssertExpectations(t)
223 func TestMGetSuccessfully(t *testing.T) {
224 _, r, db := setup(true)
225 expectedKeys := []string{"key1", "key2", "key3"}
226 expectedResult := []interface{}{"val1", 2, nil}
227 r.On("MGet", expectedKeys).Return(redis.NewSliceResult(expectedResult, nil))
228 result, err := db.MGet([]string{"key1", "key2", "key3"})
229 assert.Equal(t, result, expectedResult)
231 r.AssertExpectations(t)
234 func TestMGetFailure(t *testing.T) {
235 _, r, db := setup(true)
236 expectedKeys := []string{"key1", "key2", "key3"}
237 expectedResult := []interface{}{nil}
238 r.On("MGet", expectedKeys).Return(redis.NewSliceResult(expectedResult,
239 errors.New("Some error")))
240 result, err := db.MGet([]string{"key1", "key2", "key3"})
241 assert.Equal(t, result, expectedResult)
242 assert.NotNil(t, err)
243 r.AssertExpectations(t)
246 func TestDelMPubSuccessfully(t *testing.T) {
247 _, r, db := setup(true)
248 expectedMessage := []interface{}{"DELMPUB", 2, 2, "key1", "key2", "chan1", "event1",
250 r.On("Do", expectedMessage).Return(redis.NewCmdResult("", nil))
251 assert.Nil(t, db.DelMPub([]string{"chan1", "event1", "chan2", "event2"},
252 []string{"key1", "key2"}))
253 r.AssertExpectations(t)
256 func TestDelMPubFailure(t *testing.T) {
257 _, r, db := setup(true)
258 expectedMessage := []interface{}{"DELMPUB", 2, 2, "key1", "key2", "chan1", "event1",
260 r.On("Do", expectedMessage).Return(redis.NewCmdResult("", errors.New("Some error")))
261 assert.NotNil(t, db.DelMPub([]string{"chan1", "event1", "chan2", "event2"},
262 []string{"key1", "key2"}))
263 r.AssertExpectations(t)
266 func TestDelMPubCommandMissing(t *testing.T) {
267 _, r, db := setup(false)
268 expectedMessage := []interface{}{"DELMPUB", 2, 2, "key1", "key2", "chan1", "event1",
270 r.AssertNotCalled(t, "Do", expectedMessage)
271 assert.NotNil(t, db.DelMPub([]string{"chan1", "event1", "chan2", "event2"},
272 []string{"key1", "key2"}))
273 r.AssertExpectations(t)
276 func TestDelSuccessfully(t *testing.T) {
277 _, r, db := setup(true)
278 expectedKeys := []string{"key1", "key2"}
279 r.On("Del", expectedKeys).Return(redis.NewIntResult(2, nil))
280 assert.Nil(t, db.Del([]string{"key1", "key2"}))
281 r.AssertExpectations(t)
284 func TestDelFailure(t *testing.T) {
285 _, r, db := setup(true)
286 expectedKeys := []string{"key1", "key2"}
287 r.On("Del", expectedKeys).Return(redis.NewIntResult(2, errors.New("Some error")))
288 assert.NotNil(t, db.Del([]string{"key1", "key2"}))
289 r.AssertExpectations(t)
292 func TestKeysSuccessfully(t *testing.T) {
293 _, r, db := setup(true)
294 expectedPattern := "pattern*"
295 expectedResult := []string{"pattern1", "pattern2"}
296 r.On("Keys", expectedPattern).Return(redis.NewStringSliceResult(expectedResult, nil))
297 result, err := db.Keys("pattern*")
298 assert.Equal(t, result, expectedResult)
300 r.AssertExpectations(t)
303 func TestKeysFailure(t *testing.T) {
304 _, r, db := setup(true)
305 expectedPattern := "pattern*"
306 expectedResult := []string{}
307 r.On("Keys", expectedPattern).Return(redis.NewStringSliceResult(expectedResult,
308 errors.New("Some error")))
309 _, err := db.Keys("pattern*")
310 assert.NotNil(t, err)
311 r.AssertExpectations(t)
314 func TestSetIEKeyExists(t *testing.T) {
315 _, r, db := setup(true)
316 expectedMessage := []interface{}{"SETIE", "key", "newdata", "olddata"}
317 r.On("Do", expectedMessage).Return(redis.NewCmdResult("OK", nil))
318 result, err := db.SetIE("key", "olddata", "newdata")
319 assert.True(t, result)
321 r.AssertExpectations(t)
324 func TestSetIEKeyDoesntExists(t *testing.T) {
325 _, r, db := setup(true)
326 expectedMessage := []interface{}{"SETIE", "key", "newdata", "olddata"}
327 r.On("Do", expectedMessage).Return(redis.NewCmdResult(nil, nil))
328 result, err := db.SetIE("key", "olddata", "newdata")
329 assert.False(t, result)
331 r.AssertExpectations(t)
334 func TestSetIEFailure(t *testing.T) {
335 _, r, db := setup(true)
336 expectedMessage := []interface{}{"SETIE", "key", "newdata", "olddata"}
337 r.On("Do", expectedMessage).Return(redis.NewCmdResult(nil, errors.New("Some error")))
338 result, err := db.SetIE("key", "olddata", "newdata")
339 assert.False(t, result)
340 assert.NotNil(t, err)
341 r.AssertExpectations(t)
344 func TestSetIECommandMissing(t *testing.T) {
345 _, r, db := setup(false)
346 expectedMessage := []interface{}{"SETIE", "key", "newdata", "olddata"}
347 r.AssertNotCalled(t, "Do", expectedMessage)
348 result, err := db.SetIE("key", "olddata", "newdata")
349 assert.False(t, result)
350 assert.NotNil(t, err)
351 r.AssertExpectations(t)
354 func TestSetIEPubKeyExists(t *testing.T) {
355 _, r, db := setup(true)
356 expectedMessage := []interface{}{"SETIEMPUB", "key", "newdata", "olddata", "channel", "message"}
357 r.On("Do", expectedMessage).Return(redis.NewCmdResult("OK", nil))
358 result, err := db.SetIEPub([]string{"channel", "message"}, "key", "olddata", "newdata")
359 assert.True(t, result)
361 r.AssertExpectations(t)
364 func TestSetIEPubKeyDoesntExists(t *testing.T) {
365 _, r, db := setup(true)
366 expectedMessage := []interface{}{"SETIEMPUB", "key", "newdata", "olddata", "channel", "message"}
367 r.On("Do", expectedMessage).Return(redis.NewCmdResult(nil, nil))
368 result, err := db.SetIEPub([]string{"channel", "message"}, "key", "olddata", "newdata")
369 assert.False(t, result)
371 r.AssertExpectations(t)
374 func TestSetIEPubFailure(t *testing.T) {
375 _, r, db := setup(true)
376 expectedMessage := []interface{}{"SETIEMPUB", "key", "newdata", "olddata", "channel", "message"}
377 r.On("Do", expectedMessage).Return(redis.NewCmdResult(nil, errors.New("Some error")))
378 result, err := db.SetIEPub([]string{"channel", "message"}, "key", "olddata", "newdata")
379 assert.False(t, result)
380 assert.NotNil(t, err)
381 r.AssertExpectations(t)
384 func TestSetIEPubCommandMissing(t *testing.T) {
385 _, r, db := setup(false)
386 expectedMessage := []interface{}{"SETIEMPUB", "key", "newdata", "olddata", "channel", "message"}
387 r.AssertNotCalled(t, "Do", expectedMessage)
388 result, err := db.SetIEPub([]string{"channel", "message"}, "key", "olddata", "newdata")
389 assert.False(t, result)
390 assert.NotNil(t, err)
391 r.AssertExpectations(t)
394 func TestSetNXPubKeyDoesntExist(t *testing.T) {
395 _, r, db := setup(true)
396 expectedMessage := []interface{}{"SETNXMPUB", "key", "data", "channel", "message"}
397 r.On("Do", expectedMessage).Return(redis.NewCmdResult("OK", nil))
398 result, err := db.SetNXPub([]string{"channel", "message"}, "key", "data")
399 assert.True(t, result)
401 r.AssertExpectations(t)
404 func TestSetNXPubKeyExists(t *testing.T) {
405 _, r, db := setup(true)
406 expectedMessage := []interface{}{"SETNXMPUB", "key", "data", "channel", "message"}
407 r.On("Do", expectedMessage).Return(redis.NewCmdResult(nil, nil))
408 result, err := db.SetNXPub([]string{"channel", "message"}, "key", "data")
409 assert.False(t, result)
411 r.AssertExpectations(t)
414 func TestSetNXPubFailure(t *testing.T) {
415 _, r, db := setup(true)
416 expectedMessage := []interface{}{"SETNXMPUB", "key", "data", "channel", "message"}
417 r.On("Do", expectedMessage).Return(redis.NewCmdResult(nil, errors.New("Some error")))
418 result, err := db.SetNXPub([]string{"channel", "message"}, "key", "data")
419 assert.False(t, result)
420 assert.NotNil(t, err)
421 r.AssertExpectations(t)
424 func TestSetNXPubCommandMissing(t *testing.T) {
425 _, r, db := setup(false)
426 expectedMessage := []interface{}{"SETNXMPUB", "key", "data", "channel", "message"}
427 r.AssertNotCalled(t, "Do", expectedMessage)
428 result, err := db.SetNXPub([]string{"channel", "message"}, "key", "data")
429 assert.False(t, result)
430 assert.NotNil(t, err)
431 r.AssertExpectations(t)
434 func TestSetNXSuccessfully(t *testing.T) {
435 _, r, db := setup(true)
437 expectedData := "data"
438 r.On("SetNX", expectedKey, expectedData, time.Duration(0)).Return(redis.NewBoolResult(true, nil))
439 result, err := db.SetNX("key", "data", 0)
440 assert.True(t, result)
442 r.AssertExpectations(t)
445 func TestSetNXUnsuccessfully(t *testing.T) {
446 _, r, db := setup(true)
448 expectedData := "data"
449 r.On("SetNX", expectedKey, expectedData, time.Duration(0)).Return(redis.NewBoolResult(false, nil))
450 result, err := db.SetNX("key", "data", 0)
451 assert.False(t, result)
453 r.AssertExpectations(t)
456 func TestSetNXFailure(t *testing.T) {
457 _, r, db := setup(true)
459 expectedData := "data"
460 r.On("SetNX", expectedKey, expectedData, time.Duration(0)).
461 Return(redis.NewBoolResult(false, errors.New("Some error")))
462 result, err := db.SetNX("key", "data", 0)
463 assert.False(t, result)
464 assert.NotNil(t, err)
465 r.AssertExpectations(t)
468 func TestDelIEPubKeyDoesntExist(t *testing.T) {
469 _, r, db := setup(true)
470 expectedMessage := []interface{}{"DELIEMPUB", "key", "data", "channel", "message"}
471 r.On("Do", expectedMessage).Return(redis.NewCmdResult(int64(0), nil))
472 result, err := db.DelIEPub([]string{"channel", "message"}, "key", "data")
473 assert.False(t, result)
475 r.AssertExpectations(t)
478 func TestDelIEPubKeyExists(t *testing.T) {
479 _, r, db := setup(true)
480 expectedMessage := []interface{}{"DELIEMPUB", "key", "data", "channel", "message"}
481 r.On("Do", expectedMessage).Return(redis.NewCmdResult(int64(1), nil))
482 result, err := db.DelIEPub([]string{"channel", "message"}, "key", "data")
483 assert.True(t, result)
485 r.AssertExpectations(t)
488 func TestDelIEPubKeyExistsIntTypeRedisValue(t *testing.T) {
489 _, r, db := setup(true)
490 expectedMessage := []interface{}{"DELIEMPUB", "key", "data", "channel", "message"}
491 r.On("Do", expectedMessage).Return(redis.NewCmdResult(1, nil))
492 result, err := db.DelIEPub([]string{"channel", "message"}, "key", "data")
493 assert.True(t, result)
495 r.AssertExpectations(t)
498 func TestDelIEPubFailure(t *testing.T) {
499 _, r, db := setup(true)
500 expectedMessage := []interface{}{"DELIEMPUB", "key", "data", "channel", "message"}
501 r.On("Do", expectedMessage).Return(redis.NewCmdResult(int64(0), errors.New("Some error")))
502 result, err := db.DelIEPub([]string{"channel", "message"}, "key", "data")
503 assert.False(t, result)
504 assert.NotNil(t, err)
505 r.AssertExpectations(t)
508 func TestDelIEPubCommandMissing(t *testing.T) {
509 _, r, db := setup(false)
510 expectedMessage := []interface{}{"DELIEMPUB", "key", "data", "channel", "message"}
511 r.AssertNotCalled(t, "Do", expectedMessage)
512 result, err := db.DelIEPub([]string{"channel", "message"}, "key", "data")
513 assert.False(t, result)
514 assert.NotNil(t, err)
515 r.AssertExpectations(t)
518 func TestDelIEKeyDoesntExist(t *testing.T) {
519 _, r, db := setup(true)
520 expectedMessage := []interface{}{"DELIE", "key", "data"}
521 r.On("Do", expectedMessage).Return(redis.NewCmdResult(int64(0), nil))
522 result, err := db.DelIE("key", "data")
523 assert.False(t, result)
525 r.AssertExpectations(t)
528 func TestDelIEKeyExists(t *testing.T) {
529 _, r, db := setup(true)
530 expectedMessage := []interface{}{"DELIE", "key", "data"}
531 r.On("Do", expectedMessage).Return(redis.NewCmdResult(int64(1), nil))
532 result, err := db.DelIE("key", "data")
533 assert.True(t, result)
535 r.AssertExpectations(t)
538 func TestDelIEKeyExistsIntTypeRedisValue(t *testing.T) {
539 _, r, db := setup(true)
540 expectedMessage := []interface{}{"DELIE", "key", "data"}
541 r.On("Do", expectedMessage).Return(redis.NewCmdResult(1, nil))
542 result, err := db.DelIE("key", "data")
543 assert.True(t, result)
545 r.AssertExpectations(t)
548 func TestDelIEFailure(t *testing.T) {
549 _, r, db := setup(true)
550 expectedMessage := []interface{}{"DELIE", "key", "data"}
551 r.On("Do", expectedMessage).Return(redis.NewCmdResult(int64(0), errors.New("Some error")))
552 result, err := db.DelIE("key", "data")
553 assert.False(t, result)
554 assert.NotNil(t, err)
555 r.AssertExpectations(t)
558 func TestDelIECommandMissing(t *testing.T) {
559 _, r, db := setup(false)
560 expectedMessage := []interface{}{"DELIE", "key", "data"}
561 r.AssertNotCalled(t, "Do", expectedMessage)
562 result, err := db.DelIE("key", "data")
563 assert.False(t, result)
564 assert.NotNil(t, err)
565 r.AssertExpectations(t)
568 func TestSAddSuccessfully(t *testing.T) {
569 _, r, db := setup(true)
571 expectedData := []interface{}{"data", 2}
572 r.On("SAdd", expectedKey, expectedData).Return(redis.NewIntResult(2, nil))
573 assert.Nil(t, db.SAdd("key", "data", 2))
574 r.AssertExpectations(t)
577 func TestSAddFailure(t *testing.T) {
578 _, r, db := setup(true)
580 expectedData := []interface{}{"data", 2}
581 r.On("SAdd", expectedKey, expectedData).Return(redis.NewIntResult(2, errors.New("Some error")))
582 assert.NotNil(t, db.SAdd("key", "data", 2))
583 r.AssertExpectations(t)
586 func TestSRemSuccessfully(t *testing.T) {
587 _, r, db := setup(true)
589 expectedData := []interface{}{"data", 2}
590 r.On("SRem", expectedKey, expectedData).Return(redis.NewIntResult(2, nil))
591 assert.Nil(t, db.SRem("key", "data", 2))
592 r.AssertExpectations(t)
595 func TestSRemFailure(t *testing.T) {
596 _, r, db := setup(true)
598 expectedData := []interface{}{"data", 2}
599 r.On("SRem", expectedKey, expectedData).Return(redis.NewIntResult(2, errors.New("Some error")))
600 assert.NotNil(t, db.SRem("key", "data", 2))
601 r.AssertExpectations(t)
604 func TestSMembersSuccessfully(t *testing.T) {
605 _, r, db := setup(true)
607 expectedResult := []string{"member1", "member2"}
608 r.On("SMembers", expectedKey).Return(redis.NewStringSliceResult(expectedResult, nil))
609 result, err := db.SMembers("key")
610 assert.Equal(t, result, expectedResult)
612 r.AssertExpectations(t)
615 func TestSMembersFailure(t *testing.T) {
616 _, r, db := setup(true)
618 expectedResult := []string{"member1", "member2"}
619 r.On("SMembers", expectedKey).Return(redis.NewStringSliceResult(expectedResult,
620 errors.New("Some error")))
621 result, err := db.SMembers("key")
622 assert.Equal(t, result, expectedResult)
623 assert.NotNil(t, err)
624 r.AssertExpectations(t)
627 func TestSIsMemberIsMember(t *testing.T) {
628 _, r, db := setup(true)
630 expectedData := "data"
631 r.On("SIsMember", expectedKey, expectedData).Return(redis.NewBoolResult(true, nil))
632 result, err := db.SIsMember("key", "data")
633 assert.True(t, result)
635 r.AssertExpectations(t)
638 func TestSIsMemberIsNotMember(t *testing.T) {
639 _, r, db := setup(true)
641 expectedData := "data"
642 r.On("SIsMember", expectedKey, expectedData).Return(redis.NewBoolResult(false, nil))
643 result, err := db.SIsMember("key", "data")
644 assert.False(t, result)
646 r.AssertExpectations(t)
649 func TestSIsMemberFailure(t *testing.T) {
650 _, r, db := setup(true)
652 expectedData := "data"
653 r.On("SIsMember", expectedKey, expectedData).
654 Return(redis.NewBoolResult(false, errors.New("Some error")))
655 result, err := db.SIsMember("key", "data")
656 assert.False(t, result)
657 assert.NotNil(t, err)
658 r.AssertExpectations(t)
661 func TestSCardSuccessfully(t *testing.T) {
662 _, r, db := setup(true)
664 r.On("SCard", expectedKey).Return(redis.NewIntResult(1, nil))
665 result, err := db.SCard("key")
666 assert.Equal(t, int64(1), result)
668 r.AssertExpectations(t)
671 func TestSCardFailure(t *testing.T) {
672 _, r, db := setup(true)
674 r.On("SCard", expectedKey).Return(redis.NewIntResult(1, errors.New("Some error")))
675 result, err := db.SCard("key")
676 assert.Equal(t, int64(1), result)
677 assert.NotNil(t, err)
678 r.AssertExpectations(t)
681 func TestSubscribeChannelDBSubscribeRXUnsubscribe(t *testing.T) {
682 ps, r, db := setup(true)
683 ch := make(chan *redis.Message)
684 msg := redis.Message{
685 Channel: "{prefix}channel",
689 ps.On("Channel").Return(ch)
690 ps.On("Unsubscribe").Return(nil)
691 ps.On("Close").Return(nil)
693 receivedChannel := ""
694 db.SubscribeChannelDB(func(channel string, payload ...string) {
696 receivedChannel = channel
697 }, "{prefix}", "---", "{prefix}channel")
699 db.UnsubscribeChannelDB("{prefix}channel")
700 time.Sleep(1 * time.Second)
701 assert.Equal(t, 1, count)
702 assert.Equal(t, "channel", receivedChannel)
703 r.AssertExpectations(t)
704 ps.AssertExpectations(t)
707 func TestSubscribeChannelDBSubscribeTwoUnsubscribeOne(t *testing.T) {
708 ps, r, db := setup(true)
709 ch := make(chan *redis.Message)
710 msg1 := redis.Message{
711 Channel: "{prefix}channel1",
715 msg2 := redis.Message{
716 Channel: "{prefix}channel2",
720 ps.On("Channel").Return(ch)
721 ps.On("Subscribe").Return(nil)
722 ps.On("Unsubscribe").Return(nil)
723 ps.On("Unsubscribe").Return(nil)
724 ps.On("Close").Return(nil)
726 receivedChannel1 := ""
727 db.SubscribeChannelDB(func(channel string, payload ...string) {
729 receivedChannel1 = channel
730 }, "{prefix}", "---", "{prefix}channel1")
732 receivedChannel2 := ""
733 db.SubscribeChannelDB(func(channel string, payload ...string) {
735 receivedChannel2 = channel
736 }, "{prefix}", "---", "{prefix}channel2")
738 time.Sleep(1 * time.Second)
739 db.UnsubscribeChannelDB("{prefix}channel1")
741 db.UnsubscribeChannelDB("{prefix}channel2")
742 time.Sleep(1 * time.Second)
743 assert.Equal(t, 2, count)
744 assert.Equal(t, "channel1", receivedChannel1)
745 assert.Equal(t, "channel2", receivedChannel2)
746 r.AssertExpectations(t)
747 ps.AssertExpectations(t)
750 func TestSubscribeChannelReDBSubscribeAfterUnsubscribe(t *testing.T) {
751 ps, r, db := setup(true)
752 ch := make(chan *redis.Message)
753 msg := redis.Message{
754 Channel: "{prefix}channel",
758 ps.On("Channel").Return(ch)
759 ps.On("Unsubscribe").Return(nil)
760 ps.On("Close").Return(nil)
762 receivedChannel := ""
764 db.SubscribeChannelDB(func(channel string, payload ...string) {
766 receivedChannel = channel
767 }, "{prefix}", "---", "{prefix}channel")
769 db.UnsubscribeChannelDB("{prefix}channel")
770 time.Sleep(1 * time.Second)
772 db.SubscribeChannelDB(func(channel string, payload ...string) {
774 receivedChannel = channel
775 }, "{prefix}", "---", "{prefix}channel")
777 db.UnsubscribeChannelDB("{prefix}channel")
779 time.Sleep(1 * time.Second)
780 assert.Equal(t, 2, count)
781 assert.Equal(t, "channel", receivedChannel)
782 r.AssertExpectations(t)
783 ps.AssertExpectations(t)
786 func TestPTTLSuccessfully(t *testing.T) {
787 _, r, db := setup(true)
789 expectedResult := time.Duration(1)
790 r.On("PTTL", expectedKey).Return(redis.NewDurationResult(expectedResult,
792 result, err := db.PTTL("key")
793 assert.Equal(t, result, expectedResult)
795 r.AssertExpectations(t)
798 func TestPTTLFailure(t *testing.T) {
799 _, r, db := setup(true)
801 expectedResult := time.Duration(1)
802 r.On("PTTL", expectedKey).Return(redis.NewDurationResult(expectedResult,
803 errors.New("Some error")))
804 result, err := db.PTTL("key")
805 assert.Equal(t, result, expectedResult)
806 assert.NotNil(t, err)
807 r.AssertExpectations(t)
810 func TestPExpireIESuccessfully(t *testing.T) {
811 _, r, db := setup(true)
813 expectedData := "data"
814 expectedDuration := strconv.FormatInt(int64(10000), 10)
816 r.On("EvalSha", mock.Anything, []string{expectedKey}, []interface{}{expectedData, expectedDuration}).
817 Return(redis.NewCmdResult(int64(1), nil))
819 err := db.PExpireIE("key", "data", 10*time.Second)
821 r.AssertExpectations(t)
824 func TestPExpireIEFailure(t *testing.T) {
825 _, r, db := setup(true)
827 expectedData := "data"
828 expectedDuration := strconv.FormatInt(int64(10000), 10)
830 r.On("EvalSha", mock.Anything, []string{expectedKey}, []interface{}{expectedData, expectedDuration}).
831 Return(redis.NewCmdResult(int64(1), errors.New("Some error")))
833 err := db.PExpireIE("key", "data", 10*time.Second)
834 assert.NotNil(t, err)
835 r.AssertExpectations(t)
838 func TestPExpireIELockNotHeld(t *testing.T) {
839 _, r, db := setup(true)
841 expectedData := "data"
842 expectedDuration := strconv.FormatInt(int64(10000), 10)
844 r.On("EvalSha", mock.Anything, []string{expectedKey}, []interface{}{expectedData, expectedDuration}).
845 Return(redis.NewCmdResult(int64(0), nil))
847 err := db.PExpireIE("key", "data", 10*time.Second)
848 assert.NotNil(t, err)
849 r.AssertExpectations(t)