internal/sdlgoredis/sdlgoredis_test.go

   1 /*
   2    Copyright (c) 2019 AT&T Intellectual Property.
   3    Copyright (c) 2018-2019 Nokia.
   4
   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
   8
   9        http://www.apache.org/licenses/LICENSE-2.0
  10
  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.
  16 */
  17
  18 /*
  19  * This source code is part of the near-RT RIC (RAN Intelligent Controller)
  20  * platform project (RICP).
  21  */
  22
  23 package sdlgoredis_test
  24
  25 import (
  26         "errors"
  27         "strconv"
  28         "testing"
  29         "time"
  30
  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"
  35 )
  36
  37 type clientMock struct {
  38         mock.Mock
  39 }
  40
  41 type pubSubMock struct {
  42         mock.Mock
  43 }
  44
  45 func (m *pubSubMock) Channel() <-chan *redis.Message {
  46         return m.Called().Get(0).(chan *redis.Message)
  47 }
  48
  49 func (m *pubSubMock) Subscribe(channels ...string) error {
  50         return m.Called().Error(0)
  51 }
  52
  53 func (m *pubSubMock) Unsubscribe(channels ...string) error {
  54         return m.Called().Error(0)
  55 }
  56
  57 func (m *pubSubMock) Close() error {
  58         return m.Called().Error(0)
  59 }
  60
  61 func (m *clientMock) Command() *redis.CommandsInfoCmd {
  62         return m.Called().Get(0).(*redis.CommandsInfoCmd)
  63 }
  64
  65 func (m *clientMock) Close() error {
  66         return m.Called().Error(0)
  67 }
  68
  69 func (m *clientMock) Subscribe(channels ...string) *redis.PubSub {
  70         return m.Called(channels).Get(0).(*redis.PubSub)
  71 }
  72
  73 func (m *clientMock) MSet(pairs ...interface{}) *redis.StatusCmd {
  74         return m.Called(pairs).Get(0).(*redis.StatusCmd)
  75 }
  76
  77 func (m *clientMock) Do(args ...interface{}) *redis.Cmd {
  78         return m.Called(args).Get(0).(*redis.Cmd)
  79 }
  80
  81 func (m *clientMock) MGet(keys ...string) *redis.SliceCmd {
  82         return m.Called(keys).Get(0).(*redis.SliceCmd)
  83 }
  84
  85 func (m *clientMock) Del(keys ...string) *redis.IntCmd {
  86         return m.Called(keys).Get(0).(*redis.IntCmd)
  87 }
  88
  89 func (m *clientMock) Keys(pattern string) *redis.StringSliceCmd {
  90         return m.Called(pattern).Get(0).(*redis.StringSliceCmd)
  91 }
  92
  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)
  95 }
  96
  97 func (m *clientMock) SAdd(key string, members ...interface{}) *redis.IntCmd {
  98         return m.Called(key, members).Get(0).(*redis.IntCmd)
  99 }
 100
 101 func (m *clientMock) SRem(key string, members ...interface{}) *redis.IntCmd {
 102         return m.Called(key, members).Get(0).(*redis.IntCmd)
 103 }
 104
 105 func (m *clientMock) SMembers(key string) *redis.StringSliceCmd {
 106         return m.Called(key).Get(0).(*redis.StringSliceCmd)
 107 }
 108
 109 func (m *clientMock) SIsMember(key string, member interface{}) *redis.BoolCmd {
 110         return m.Called(key, member).Get(0).(*redis.BoolCmd)
 111 }
 112
 113 func (m *clientMock) SCard(key string) *redis.IntCmd {
 114         return m.Called(key).Get(0).(*redis.IntCmd)
 115 }
 116
 117 func (m *clientMock) PTTL(key string) *redis.DurationCmd {
 118         return m.Called(key).Get(0).(*redis.DurationCmd)
 119 }
 120
 121 func (m *clientMock) Eval(script string, keys []string, args ...interface{}) *redis.Cmd {
 122         return m.Called(script, keys).Get(0).(*redis.Cmd)
 123 }
 124
 125 func (m *clientMock) EvalSha(sha1 string, keys []string, args ...interface{}) *redis.Cmd {
 126         return m.Called(sha1, keys, args).Get(0).(*redis.Cmd)
 127 }
 128
 129 func (m *clientMock) ScriptExists(scripts ...string) *redis.BoolSliceCmd {
 130         return m.Called(scripts).Get(0).(*redis.BoolSliceCmd)
 131 }
 132
 133 func (m *clientMock) ScriptLoad(script string) *redis.StringCmd {
 134         return m.Called(script).Get(0).(*redis.StringCmd)
 135 }
 136
 137 func setSubscribeNotifications() (*pubSubMock, sdlgoredis.SubscribeFn) {
 138         mock := new(pubSubMock)
 139         return mock, func(client sdlgoredis.RedisClient, channels ...string) sdlgoredis.Subscriber {
 140                 return mock
 141         }
 142 }
 143
 144 func setup(commandsExists bool) (*pubSubMock, *clientMock, *sdlgoredis.DB) {
 145         mock := new(clientMock)
 146         pubSubMock, subscribeNotifications := setSubscribeNotifications()
 147         db := sdlgoredis.CreateDB(mock, subscribeNotifications)
 148
 149         dummyCommandInfo := redis.CommandInfo{
 150                 Name: "dummy",
 151         }
 152         cmdResult := make(map[string]*redis.CommandInfo, 0)
 153
 154         if commandsExists {
 155                 cmdResult = map[string]*redis.CommandInfo{
 156                         "setie":    &dummyCommandInfo,
 157                         "delie":    &dummyCommandInfo,
 158                         "setiepub": &dummyCommandInfo,
 159                         "setnxpub": &dummyCommandInfo,
 160                         "msetmpub": &dummyCommandInfo,
 161                         "delmpub":  &dummyCommandInfo,
 162                 }
 163         } else {
 164                 cmdResult = map[string]*redis.CommandInfo{
 165                         "dummy": &dummyCommandInfo,
 166                 }
 167         }
 168
 169         mock.On("Command").Return(redis.NewCommandsInfoCmdResult(cmdResult, nil))
 170         db.CheckCommands()
 171         return pubSubMock, mock, db
 172 }
 173
 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)
 179         assert.Nil(t, err)
 180         r.AssertExpectations(t)
 181 }
 182
 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)
 190 }
 191
 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)
 200 }
 201
 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)
 210 }
 211
 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)
 220
 221 }
 222
 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)
 230         assert.Nil(t, err)
 231         r.AssertExpectations(t)
 232 }
 233
 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)
 244 }
 245
 246 func TestDelMPubSuccessfully(t *testing.T) {
 247         _, r, db := setup(true)
 248         expectedMessage := []interface{}{"DELMPUB", 2, 2, "key1", "key2", "chan1", "event1",
 249                 "chan2", "event2"}
 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)
 254 }
 255
 256 func TestDelMPubFailure(t *testing.T) {
 257         _, r, db := setup(true)
 258         expectedMessage := []interface{}{"DELMPUB", 2, 2, "key1", "key2", "chan1", "event1",
 259                 "chan2", "event2"}
 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)
 264 }
 265
 266 func TestDelMPubCommandMissing(t *testing.T) {
 267         _, r, db := setup(false)
 268         expectedMessage := []interface{}{"DELMPUB", 2, 2, "key1", "key2", "chan1", "event1",
 269                 "chan2", "event2"}
 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)
 274 }
 275
 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)
 282 }
 283
 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)
 290 }
 291
 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)
 299         assert.Nil(t, err)
 300         r.AssertExpectations(t)
 301 }
 302
 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)
 312 }
 313
 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)
 320         assert.Nil(t, err)
 321         r.AssertExpectations(t)
 322 }
 323
 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)
 330         assert.Nil(t, err)
 331         r.AssertExpectations(t)
 332 }
 333
 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)
 342 }
 343
 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)
 352 }
 353
 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)
 360         assert.Nil(t, err)
 361         r.AssertExpectations(t)
 362 }
 363
 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)
 370         assert.Nil(t, err)
 371         r.AssertExpectations(t)
 372 }
 373
 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)
 382 }
 383
 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)
 392 }
 393
 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)
 400         assert.Nil(t, err)
 401         r.AssertExpectations(t)
 402 }
 403
 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)
 410         assert.Nil(t, err)
 411         r.AssertExpectations(t)
 412 }
 413
 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)
 422 }
 423
 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)
 432 }
 433
 434 func TestSetNXSuccessfully(t *testing.T) {
 435         _, r, db := setup(true)
 436         expectedKey := "key"
 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)
 441         assert.Nil(t, err)
 442         r.AssertExpectations(t)
 443 }
 444
 445 func TestSetNXUnsuccessfully(t *testing.T) {
 446         _, r, db := setup(true)
 447         expectedKey := "key"
 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)
 452         assert.Nil(t, err)
 453         r.AssertExpectations(t)
 454 }
 455
 456 func TestSetNXFailure(t *testing.T) {
 457         _, r, db := setup(true)
 458         expectedKey := "key"
 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)
 466 }
 467
 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)
 474         assert.Nil(t, err)
 475         r.AssertExpectations(t)
 476 }
 477
 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)
 484         assert.Nil(t, err)
 485         r.AssertExpectations(t)
 486 }
 487
 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)
 496 }
 497
 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)
 506 }
 507
 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)
 514         assert.Nil(t, err)
 515         r.AssertExpectations(t)
 516 }
 517
 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)
 524         assert.Nil(t, err)
 525         r.AssertExpectations(t)
 526 }
 527
 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)
 536 }
 537
 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)
 546 }
 547
 548 func TestSAddSuccessfully(t *testing.T) {
 549         _, r, db := setup(true)
 550         expectedKey := "key"
 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)
 555 }
 556
 557 func TestSAddFailure(t *testing.T) {
 558         _, r, db := setup(true)
 559         expectedKey := "key"
 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)
 564 }
 565
 566 func TestSRemSuccessfully(t *testing.T) {
 567         _, r, db := setup(true)
 568         expectedKey := "key"
 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)
 573 }
 574
 575 func TestSRemFailure(t *testing.T) {
 576         _, r, db := setup(true)
 577         expectedKey := "key"
 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)
 582 }
 583
 584 func TestSMembersSuccessfully(t *testing.T) {
 585         _, r, db := setup(true)
 586         expectedKey := "key"
 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)
 591         assert.Nil(t, err)
 592         r.AssertExpectations(t)
 593 }
 594
 595 func TestSMembersFailure(t *testing.T) {
 596         _, r, db := setup(true)
 597         expectedKey := "key"
 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)
 605 }
 606
 607 func TestSIsMemberIsMember(t *testing.T) {
 608         _, r, db := setup(true)
 609         expectedKey := "key"
 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)
 614         assert.Nil(t, err)
 615         r.AssertExpectations(t)
 616 }
 617
 618 func TestSIsMemberIsNotMember(t *testing.T) {
 619         _, r, db := setup(true)
 620         expectedKey := "key"
 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)
 625         assert.Nil(t, err)
 626         r.AssertExpectations(t)
 627 }
 628
 629 func TestSIsMemberFailure(t *testing.T) {
 630         _, r, db := setup(true)
 631         expectedKey := "key"
 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)
 639 }
 640
 641 func TestSCardSuccessfully(t *testing.T) {
 642         _, r, db := setup(true)
 643         expectedKey := "key"
 644         r.On("SCard", expectedKey).Return(redis.NewIntResult(1, nil))
 645         result, err := db.SCard("key")
 646         assert.Equal(t, int64(1), result)
 647         assert.Nil(t, err)
 648         r.AssertExpectations(t)
 649 }
 650
 651 func TestSCardFailure(t *testing.T) {
 652         _, r, db := setup(true)
 653         expectedKey := "key"
 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)
 659 }
 660
 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",
 666                 Pattern: "pattern",
 667                 Payload: "event",
 668         }
 669         ps.On("Channel").Return(ch)
 670         ps.On("Unsubscribe").Return(nil)
 671         ps.On("Close").Return(nil)
 672         count := 0
 673         receivedChannel := ""
 674         db.SubscribeChannelDB(func(channel string, payload ...string) {
 675                 count++
 676                 receivedChannel = channel
 677         }, "{prefix}", "---", "{prefix}channel")
 678         ch <- &msg
 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)
 685 }
 686
 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",
 692                 Pattern: "pattern",
 693                 Payload: "event",
 694         }
 695         msg2 := redis.Message{
 696                 Channel: "{prefix}channel2",
 697                 Pattern: "pattern",
 698                 Payload: "event",
 699         }
 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)
 705         count := 0
 706         receivedChannel1 := ""
 707         db.SubscribeChannelDB(func(channel string, payload ...string) {
 708                 count++
 709                 receivedChannel1 = channel
 710         }, "{prefix}", "---", "{prefix}channel1")
 711         ch <- &msg1
 712         receivedChannel2 := ""
 713         db.SubscribeChannelDB(func(channel string, payload ...string) {
 714                 count++
 715                 receivedChannel2 = channel
 716         }, "{prefix}", "---", "{prefix}channel2")
 717
 718         time.Sleep(1 * time.Second)
 719         db.UnsubscribeChannelDB("{prefix}channel1")
 720         ch <- &msg2
 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)
 728 }
 729
 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",
 735                 Pattern: "pattern",
 736                 Payload: "event",
 737         }
 738         ps.On("Channel").Return(ch)
 739         ps.On("Unsubscribe").Return(nil)
 740         ps.On("Close").Return(nil)
 741         count := 0
 742         receivedChannel := ""
 743
 744         db.SubscribeChannelDB(func(channel string, payload ...string) {
 745                 count++
 746                 receivedChannel = channel
 747         }, "{prefix}", "---", "{prefix}channel")
 748         ch <- &msg
 749         db.UnsubscribeChannelDB("{prefix}channel")
 750         time.Sleep(1 * time.Second)
 751
 752         db.SubscribeChannelDB(func(channel string, payload ...string) {
 753                 count++
 754                 receivedChannel = channel
 755         }, "{prefix}", "---", "{prefix}channel")
 756         ch <- &msg
 757         db.UnsubscribeChannelDB("{prefix}channel")
 758
 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)
 764 }
 765
 766 func TestPTTLSuccessfully(t *testing.T) {
 767         _, r, db := setup(true)
 768         expectedKey := "key"
 769         expectedResult := time.Duration(1)
 770         r.On("PTTL", expectedKey).Return(redis.NewDurationResult(expectedResult,
 771                 nil))
 772         result, err := db.PTTL("key")
 773         assert.Equal(t, result, expectedResult)
 774         assert.Nil(t, err)
 775         r.AssertExpectations(t)
 776 }
 777
 778 func TestPTTLFailure(t *testing.T) {
 779         _, r, db := setup(true)
 780         expectedKey := "key"
 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)
 788 }
 789
 790 func TestPExpireIESuccessfully(t *testing.T) {
 791         _, r, db := setup(true)
 792         expectedKey := "key"
 793         expectedData := "data"
 794         expectedDuration := strconv.FormatInt(int64(10000), 10)
 795
 796         r.On("EvalSha", mock.Anything, []string{expectedKey}, []interface{}{expectedData, expectedDuration}).
 797                 Return(redis.NewCmdResult(int64(1), nil))
 798
 799         err := db.PExpireIE("key", "data", 10*time.Second)
 800         assert.Nil(t, err)
 801         r.AssertExpectations(t)
 802 }
 803
 804 func TestPExpireIEFailure(t *testing.T) {
 805         _, r, db := setup(true)
 806         expectedKey := "key"
 807         expectedData := "data"
 808         expectedDuration := strconv.FormatInt(int64(10000), 10)
 809
 810         r.On("EvalSha", mock.Anything, []string{expectedKey}, []interface{}{expectedData, expectedDuration}).
 811                 Return(redis.NewCmdResult(int64(1), errors.New("Some error")))
 812
 813         err := db.PExpireIE("key", "data", 10*time.Second)
 814         assert.NotNil(t, err)
 815         r.AssertExpectations(t)
 816 }
 817
 818 func TestPExpireIELockNotHeld(t *testing.T) {
 819         _, r, db := setup(true)
 820         expectedKey := "key"
 821         expectedData := "data"
 822         expectedDuration := strconv.FormatInt(int64(10000), 10)
 823
 824         r.On("EvalSha", mock.Anything, []string{expectedKey}, []interface{}{expectedData, expectedDuration}).
 825                 Return(redis.NewCmdResult(int64(0), nil))
 826
 827         err := db.PExpireIE("key", "data", 10*time.Second)
 828         assert.NotNil(t, err)
 829         r.AssertExpectations(t)
 830 }