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{}{"SETIEPUB", "key", "newdata", "olddata", "channel", "message"}
357 r.On("Do", expectedMessage).Return(redis.NewCmdResult("OK", nil))
358 result, err := db.SetIEPub("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{}{"SETIEPUB", "key", "newdata", "olddata", "channel", "message"}
367 r.On("Do", expectedMessage).Return(redis.NewCmdResult(nil, nil))
368 result, err := db.SetIEPub("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{}{"SETIEPUB", "key", "newdata", "olddata", "channel", "message"}
377 r.On("Do", expectedMessage).Return(redis.NewCmdResult(nil, errors.New("Some error")))
378 result, err := db.SetIEPub("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{}{"SETIEPUB", "key", "newdata", "olddata", "channel", "message"}
387 r.AssertNotCalled(t, "Do", expectedMessage)
388 result, err := db.SetIEPub("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{}{"SETNXPUB", "key", "data", "channel", "message"}
397 r.On("Do", expectedMessage).Return(redis.NewCmdResult("OK", nil))
398 result, err := db.SetNXPub("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{}{"SETNXPUB", "key", "data", "channel", "message"}
407 r.On("Do", expectedMessage).Return(redis.NewCmdResult(nil, nil))
408 result, err := db.SetNXPub("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{}{"SETNXPUB", "key", "data", "channel", "message"}
417 r.On("Do", expectedMessage).Return(redis.NewCmdResult(nil, errors.New("Some error")))
418 result, err := db.SetNXPub("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{}{"SETNXPUB", "key", "data", "channel", "message"}
427 r.AssertNotCalled(t, "Do", expectedMessage)
428 result, err := db.SetNXPub("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{}{"DELIEPUB", "key", "data", "channel", "message"}
471 r.On("Do", expectedMessage).Return(redis.NewCmdResult(0, nil))
472 result, err := db.DelIEPub("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{}{"DELIEPUB", "key", "data", "channel", "message"}
481 r.On("Do", expectedMessage).Return(redis.NewCmdResult(1, nil))
482 result, err := db.DelIEPub("channel", "message", "key", "data")
483 assert.True(t, result)
485 r.AssertExpectations(t)
488 func TestDelIEPubFailure(t *testing.T) {
489 _, r, db := setup(true)
490 expectedMessage := []interface{}{"DELIEPUB", "key", "data", "channel", "message"}
491 r.On("Do", expectedMessage).Return(redis.NewCmdResult(0, errors.New("Some error")))
492 result, err := db.DelIEPub("channel", "message", "key", "data")
493 assert.False(t, result)
494 assert.NotNil(t, err)
495 r.AssertExpectations(t)
498 func TestDelIEPubCommandMissing(t *testing.T) {
499 _, r, db := setup(false)
500 expectedMessage := []interface{}{"DELIEPUB", "key", "data", "channel", "message"}
501 r.AssertNotCalled(t, "Do", expectedMessage)
502 result, err := db.DelIEPub("channel", "message", "key", "data")
503 assert.False(t, result)
504 assert.NotNil(t, err)
505 r.AssertExpectations(t)
508 func TestDelIEKeyDoesntExist(t *testing.T) {
509 _, r, db := setup(true)
510 expectedMessage := []interface{}{"DELIE", "key", "data"}
511 r.On("Do", expectedMessage).Return(redis.NewCmdResult(0, nil))
512 result, err := db.DelIE("key", "data")
513 assert.False(t, result)
515 r.AssertExpectations(t)
518 func TestDelIEKeyExists(t *testing.T) {
519 _, r, db := setup(true)
520 expectedMessage := []interface{}{"DELIE", "key", "data"}
521 r.On("Do", expectedMessage).Return(redis.NewCmdResult(1, nil))
522 result, err := db.DelIE("key", "data")
523 assert.True(t, result)
525 r.AssertExpectations(t)
528 func TestDelIEFailure(t *testing.T) {
529 _, r, db := setup(true)
530 expectedMessage := []interface{}{"DELIE", "key", "data"}
531 r.On("Do", expectedMessage).Return(redis.NewCmdResult(0, errors.New("Some error")))
532 result, err := db.DelIE("key", "data")
533 assert.False(t, result)
534 assert.NotNil(t, err)
535 r.AssertExpectations(t)
538 func TestDelIECommandMissing(t *testing.T) {
539 _, r, db := setup(false)
540 expectedMessage := []interface{}{"DELIE", "key", "data"}
541 r.AssertNotCalled(t, "Do", expectedMessage)
542 result, err := db.DelIE("key", "data")
543 assert.False(t, result)
544 assert.NotNil(t, err)
545 r.AssertExpectations(t)
548 func TestSAddSuccessfully(t *testing.T) {
549 _, r, db := setup(true)
551 expectedData := []interface{}{"data", 2}
552 r.On("SAdd", expectedKey, expectedData).Return(redis.NewIntResult(2, nil))
553 assert.Nil(t, db.SAdd("key", "data", 2))
554 r.AssertExpectations(t)
557 func TestSAddFailure(t *testing.T) {
558 _, r, db := setup(true)
560 expectedData := []interface{}{"data", 2}
561 r.On("SAdd", expectedKey, expectedData).Return(redis.NewIntResult(2, errors.New("Some error")))
562 assert.NotNil(t, db.SAdd("key", "data", 2))
563 r.AssertExpectations(t)
566 func TestSRemSuccessfully(t *testing.T) {
567 _, r, db := setup(true)
569 expectedData := []interface{}{"data", 2}
570 r.On("SRem", expectedKey, expectedData).Return(redis.NewIntResult(2, nil))
571 assert.Nil(t, db.SRem("key", "data", 2))
572 r.AssertExpectations(t)
575 func TestSRemFailure(t *testing.T) {
576 _, r, db := setup(true)
578 expectedData := []interface{}{"data", 2}
579 r.On("SRem", expectedKey, expectedData).Return(redis.NewIntResult(2, errors.New("Some error")))
580 assert.NotNil(t, db.SRem("key", "data", 2))
581 r.AssertExpectations(t)
584 func TestSMembersSuccessfully(t *testing.T) {
585 _, r, db := setup(true)
587 expectedResult := []string{"member1", "member2"}
588 r.On("SMembers", expectedKey).Return(redis.NewStringSliceResult(expectedResult, nil))
589 result, err := db.SMembers("key")
590 assert.Equal(t, result, expectedResult)
592 r.AssertExpectations(t)
595 func TestSMembersFailure(t *testing.T) {
596 _, r, db := setup(true)
598 expectedResult := []string{"member1", "member2"}
599 r.On("SMembers", expectedKey).Return(redis.NewStringSliceResult(expectedResult,
600 errors.New("Some error")))
601 result, err := db.SMembers("key")
602 assert.Equal(t, result, expectedResult)
603 assert.NotNil(t, err)
604 r.AssertExpectations(t)
607 func TestSIsMemberIsMember(t *testing.T) {
608 _, r, db := setup(true)
610 expectedData := "data"
611 r.On("SIsMember", expectedKey, expectedData).Return(redis.NewBoolResult(true, nil))
612 result, err := db.SIsMember("key", "data")
613 assert.True(t, result)
615 r.AssertExpectations(t)
618 func TestSIsMemberIsNotMember(t *testing.T) {
619 _, r, db := setup(true)
621 expectedData := "data"
622 r.On("SIsMember", expectedKey, expectedData).Return(redis.NewBoolResult(false, nil))
623 result, err := db.SIsMember("key", "data")
624 assert.False(t, result)
626 r.AssertExpectations(t)
629 func TestSIsMemberFailure(t *testing.T) {
630 _, r, db := setup(true)
632 expectedData := "data"
633 r.On("SIsMember", expectedKey, expectedData).
634 Return(redis.NewBoolResult(false, errors.New("Some error")))
635 result, err := db.SIsMember("key", "data")
636 assert.False(t, result)
637 assert.NotNil(t, err)
638 r.AssertExpectations(t)
641 func TestSCardSuccessfully(t *testing.T) {
642 _, r, db := setup(true)
644 r.On("SCard", expectedKey).Return(redis.NewIntResult(1, nil))
645 result, err := db.SCard("key")
646 assert.Equal(t, int64(1), result)
648 r.AssertExpectations(t)
651 func TestSCardFailure(t *testing.T) {
652 _, r, db := setup(true)
654 r.On("SCard", expectedKey).Return(redis.NewIntResult(1, errors.New("Some error")))
655 result, err := db.SCard("key")
656 assert.Equal(t, int64(1), result)
657 assert.NotNil(t, err)
658 r.AssertExpectations(t)
661 func TestSubscribeChannelDBSubscribeRXUnsubscribe(t *testing.T) {
662 ps, r, db := setup(true)
663 ch := make(chan *redis.Message)
664 msg := redis.Message{
665 Channel: "{prefix}channel",
669 ps.On("Channel").Return(ch)
670 ps.On("Unsubscribe").Return(nil)
671 ps.On("Close").Return(nil)
673 receivedChannel := ""
674 db.SubscribeChannelDB(func(channel string, payload ...string) {
676 receivedChannel = channel
677 }, "{prefix}", "---", "{prefix}channel")
679 db.UnsubscribeChannelDB("{prefix}channel")
680 time.Sleep(1 * time.Second)
681 assert.Equal(t, 1, count)
682 assert.Equal(t, "channel", receivedChannel)
683 r.AssertExpectations(t)
684 ps.AssertExpectations(t)
687 func TestSubscribeChannelDBSubscribeTwoUnsubscribeOne(t *testing.T) {
688 ps, r, db := setup(true)
689 ch := make(chan *redis.Message)
690 msg1 := redis.Message{
691 Channel: "{prefix}channel1",
695 msg2 := redis.Message{
696 Channel: "{prefix}channel2",
700 ps.On("Channel").Return(ch)
701 ps.On("Subscribe").Return(nil)
702 ps.On("Unsubscribe").Return(nil)
703 ps.On("Unsubscribe").Return(nil)
704 ps.On("Close").Return(nil)
706 receivedChannel1 := ""
707 db.SubscribeChannelDB(func(channel string, payload ...string) {
709 receivedChannel1 = channel
710 }, "{prefix}", "---", "{prefix}channel1")
712 receivedChannel2 := ""
713 db.SubscribeChannelDB(func(channel string, payload ...string) {
715 receivedChannel2 = channel
716 }, "{prefix}", "---", "{prefix}channel2")
718 time.Sleep(1 * time.Second)
719 db.UnsubscribeChannelDB("{prefix}channel1")
721 db.UnsubscribeChannelDB("{prefix}channel2")
722 time.Sleep(1 * time.Second)
723 assert.Equal(t, 2, count)
724 assert.Equal(t, "channel1", receivedChannel1)
725 assert.Equal(t, "channel2", receivedChannel2)
726 r.AssertExpectations(t)
727 ps.AssertExpectations(t)
730 func TestSubscribeChannelReDBSubscribeAfterUnsubscribe(t *testing.T) {
731 ps, r, db := setup(true)
732 ch := make(chan *redis.Message)
733 msg := redis.Message{
734 Channel: "{prefix}channel",
738 ps.On("Channel").Return(ch)
739 ps.On("Unsubscribe").Return(nil)
740 ps.On("Close").Return(nil)
742 receivedChannel := ""
744 db.SubscribeChannelDB(func(channel string, payload ...string) {
746 receivedChannel = channel
747 }, "{prefix}", "---", "{prefix}channel")
749 db.UnsubscribeChannelDB("{prefix}channel")
750 time.Sleep(1 * time.Second)
752 db.SubscribeChannelDB(func(channel string, payload ...string) {
754 receivedChannel = channel
755 }, "{prefix}", "---", "{prefix}channel")
757 db.UnsubscribeChannelDB("{prefix}channel")
759 time.Sleep(1 * time.Second)
760 assert.Equal(t, 2, count)
761 assert.Equal(t, "channel", receivedChannel)
762 r.AssertExpectations(t)
763 ps.AssertExpectations(t)
766 func TestPTTLSuccessfully(t *testing.T) {
767 _, r, db := setup(true)
769 expectedResult := time.Duration(1)
770 r.On("PTTL", expectedKey).Return(redis.NewDurationResult(expectedResult,
772 result, err := db.PTTL("key")
773 assert.Equal(t, result, expectedResult)
775 r.AssertExpectations(t)
778 func TestPTTLFailure(t *testing.T) {
779 _, r, db := setup(true)
781 expectedResult := time.Duration(1)
782 r.On("PTTL", expectedKey).Return(redis.NewDurationResult(expectedResult,
783 errors.New("Some error")))
784 result, err := db.PTTL("key")
785 assert.Equal(t, result, expectedResult)
786 assert.NotNil(t, err)
787 r.AssertExpectations(t)
790 func TestPExpireIESuccessfully(t *testing.T) {
791 _, r, db := setup(true)
793 expectedData := "data"
794 expectedDuration := strconv.FormatInt(int64(10000), 10)
796 r.On("EvalSha", mock.Anything, []string{expectedKey}, []interface{}{expectedData, expectedDuration}).
797 Return(redis.NewCmdResult(int64(1), nil))
799 err := db.PExpireIE("key", "data", 10*time.Second)
801 r.AssertExpectations(t)
804 func TestPExpireIEFailure(t *testing.T) {
805 _, r, db := setup(true)
807 expectedData := "data"
808 expectedDuration := strconv.FormatInt(int64(10000), 10)
810 r.On("EvalSha", mock.Anything, []string{expectedKey}, []interface{}{expectedData, expectedDuration}).
811 Return(redis.NewCmdResult(int64(1), errors.New("Some error")))
813 err := db.PExpireIE("key", "data", 10*time.Second)
814 assert.NotNil(t, err)
815 r.AssertExpectations(t)
818 func TestPExpireIELockNotHeld(t *testing.T) {
819 _, r, db := setup(true)
821 expectedData := "data"
822 expectedDuration := strconv.FormatInt(int64(10000), 10)
824 r.On("EvalSha", mock.Anything, []string{expectedKey}, []interface{}{expectedData, expectedDuration}).
825 Return(redis.NewCmdResult(int64(0), nil))
827 err := db.PExpireIE("key", "data", 10*time.Second)
828 assert.NotNil(t, err)
829 r.AssertExpectations(t)