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{}{"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)
 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{}{"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)
 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{}{"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)
 382 }
 383
 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)
 392 }
 393
 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)
 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{}{"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)
 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{}{"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)
 422 }
 423
 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)
 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{}{"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)
 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{}{"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)
 484         assert.Nil(t, err)
 485         r.AssertExpectations(t)
 486 }
 487
 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)
 494         assert.Nil(t, err)
 495         r.AssertExpectations(t)
 496 }
 497
 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)
 506 }
 507
 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)
 516 }
 517
 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)
 524         assert.Nil(t, err)
 525         r.AssertExpectations(t)
 526 }
 527
 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)
 534         assert.Nil(t, err)
 535         r.AssertExpectations(t)
 536 }
 537
 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)
 544         assert.Nil(t, err)
 545         r.AssertExpectations(t)
 546 }
 547
 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)
 556 }
 557
 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)
 566 }
 567
 568 func TestSAddSuccessfully(t *testing.T) {
 569         _, r, db := setup(true)
 570         expectedKey := "key"
 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)
 575 }
 576
 577 func TestSAddFailure(t *testing.T) {
 578         _, r, db := setup(true)
 579         expectedKey := "key"
 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)
 584 }
 585
 586 func TestSRemSuccessfully(t *testing.T) {
 587         _, r, db := setup(true)
 588         expectedKey := "key"
 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)
 593 }
 594
 595 func TestSRemFailure(t *testing.T) {
 596         _, r, db := setup(true)
 597         expectedKey := "key"
 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)
 602 }
 603
 604 func TestSMembersSuccessfully(t *testing.T) {
 605         _, r, db := setup(true)
 606         expectedKey := "key"
 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)
 611         assert.Nil(t, err)
 612         r.AssertExpectations(t)
 613 }
 614
 615 func TestSMembersFailure(t *testing.T) {
 616         _, r, db := setup(true)
 617         expectedKey := "key"
 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)
 625 }
 626
 627 func TestSIsMemberIsMember(t *testing.T) {
 628         _, r, db := setup(true)
 629         expectedKey := "key"
 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)
 634         assert.Nil(t, err)
 635         r.AssertExpectations(t)
 636 }
 637
 638 func TestSIsMemberIsNotMember(t *testing.T) {
 639         _, r, db := setup(true)
 640         expectedKey := "key"
 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)
 645         assert.Nil(t, err)
 646         r.AssertExpectations(t)
 647 }
 648
 649 func TestSIsMemberFailure(t *testing.T) {
 650         _, r, db := setup(true)
 651         expectedKey := "key"
 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)
 659 }
 660
 661 func TestSCardSuccessfully(t *testing.T) {
 662         _, r, db := setup(true)
 663         expectedKey := "key"
 664         r.On("SCard", expectedKey).Return(redis.NewIntResult(1, nil))
 665         result, err := db.SCard("key")
 666         assert.Equal(t, int64(1), result)
 667         assert.Nil(t, err)
 668         r.AssertExpectations(t)
 669 }
 670
 671 func TestSCardFailure(t *testing.T) {
 672         _, r, db := setup(true)
 673         expectedKey := "key"
 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)
 679 }
 680
 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",
 686                 Pattern: "pattern",
 687                 Payload: "event",
 688         }
 689         ps.On("Channel").Return(ch)
 690         ps.On("Unsubscribe").Return(nil)
 691         ps.On("Close").Return(nil)
 692         count := 0
 693         receivedChannel := ""
 694         db.SubscribeChannelDB(func(channel string, payload ...string) {
 695                 count++
 696                 receivedChannel = channel
 697         }, "{prefix}", "---", "{prefix}channel")
 698         ch <- &msg
 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)
 705 }
 706
 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",
 712                 Pattern: "pattern",
 713                 Payload: "event",
 714         }
 715         msg2 := redis.Message{
 716                 Channel: "{prefix}channel2",
 717                 Pattern: "pattern",
 718                 Payload: "event",
 719         }
 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)
 725         count := 0
 726         receivedChannel1 := ""
 727         db.SubscribeChannelDB(func(channel string, payload ...string) {
 728                 count++
 729                 receivedChannel1 = channel
 730         }, "{prefix}", "---", "{prefix}channel1")
 731         ch <- &msg1
 732         receivedChannel2 := ""
 733         db.SubscribeChannelDB(func(channel string, payload ...string) {
 734                 count++
 735                 receivedChannel2 = channel
 736         }, "{prefix}", "---", "{prefix}channel2")
 737
 738         time.Sleep(1 * time.Second)
 739         db.UnsubscribeChannelDB("{prefix}channel1")
 740         ch <- &msg2
 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)
 748 }
 749
 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",
 755                 Pattern: "pattern",
 756                 Payload: "event",
 757         }
 758         ps.On("Channel").Return(ch)
 759         ps.On("Unsubscribe").Return(nil)
 760         ps.On("Close").Return(nil)
 761         count := 0
 762         receivedChannel := ""
 763
 764         db.SubscribeChannelDB(func(channel string, payload ...string) {
 765                 count++
 766                 receivedChannel = channel
 767         }, "{prefix}", "---", "{prefix}channel")
 768         ch <- &msg
 769         db.UnsubscribeChannelDB("{prefix}channel")
 770         time.Sleep(1 * time.Second)
 771
 772         db.SubscribeChannelDB(func(channel string, payload ...string) {
 773                 count++
 774                 receivedChannel = channel
 775         }, "{prefix}", "---", "{prefix}channel")
 776         ch <- &msg
 777         db.UnsubscribeChannelDB("{prefix}channel")
 778
 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)
 784 }
 785
 786 func TestPTTLSuccessfully(t *testing.T) {
 787         _, r, db := setup(true)
 788         expectedKey := "key"
 789         expectedResult := time.Duration(1)
 790         r.On("PTTL", expectedKey).Return(redis.NewDurationResult(expectedResult,
 791                 nil))
 792         result, err := db.PTTL("key")
 793         assert.Equal(t, result, expectedResult)
 794         assert.Nil(t, err)
 795         r.AssertExpectations(t)
 796 }
 797
 798 func TestPTTLFailure(t *testing.T) {
 799         _, r, db := setup(true)
 800         expectedKey := "key"
 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)
 808 }
 809
 810 func TestPExpireIESuccessfully(t *testing.T) {
 811         _, r, db := setup(true)
 812         expectedKey := "key"
 813         expectedData := "data"
 814         expectedDuration := strconv.FormatInt(int64(10000), 10)
 815
 816         r.On("EvalSha", mock.Anything, []string{expectedKey}, []interface{}{expectedData, expectedDuration}).
 817                 Return(redis.NewCmdResult(int64(1), nil))
 818
 819         err := db.PExpireIE("key", "data", 10*time.Second)
 820         assert.Nil(t, err)
 821         r.AssertExpectations(t)
 822 }
 823
 824 func TestPExpireIEFailure(t *testing.T) {
 825         _, r, db := setup(true)
 826         expectedKey := "key"
 827         expectedData := "data"
 828         expectedDuration := strconv.FormatInt(int64(10000), 10)
 829
 830         r.On("EvalSha", mock.Anything, []string{expectedKey}, []interface{}{expectedData, expectedDuration}).
 831                 Return(redis.NewCmdResult(int64(1), errors.New("Some error")))
 832
 833         err := db.PExpireIE("key", "data", 10*time.Second)
 834         assert.NotNil(t, err)
 835         r.AssertExpectations(t)
 836 }
 837
 838 func TestPExpireIELockNotHeld(t *testing.T) {
 839         _, r, db := setup(true)
 840         expectedKey := "key"
 841         expectedData := "data"
 842         expectedDuration := strconv.FormatInt(int64(10000), 10)
 843
 844         r.On("EvalSha", mock.Anything, []string{expectedKey}, []interface{}{expectedData, expectedDuration}).
 845                 Return(redis.NewCmdResult(int64(0), nil))
 846
 847         err := db.PExpireIE("key", "data", 10*time.Second)
 848         assert.NotNil(t, err)
 849         r.AssertExpectations(t)
 850 }