internal/sdlgoredis/sdlgoredis_test.go

   1
   2 /*
   3    Copyright (c) 2019 AT&T Intellectual Property.
   4    Copyright (c) 2018-2019 Nokia.
   5
   6    Licensed under the Apache License, Version 2.0 (the "License");
   7    you may not use this file except in compliance with the License.
   8    You may obtain a copy of the License at
   9
  10        http://www.apache.org/licenses/LICENSE-2.0
  11
  12    Unless required by applicable law or agreed to in writing, software
  13    distributed under the License is distributed on an "AS IS" BASIS,
  14    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15    See the License for the specific language governing permissions and
  16    limitations under the License.
  17 */
  18
  19 package sdlgoredis_test
  20
  21 import (
  22         "testing"
  23         "errors"
  24         "time"
  25
  26         "github.com/go-redis/redis"
  27         "gerrit.o-ran-sc.org/r/ric-plt/sdlgo/internal/sdlgoredis"
  28         "github.com/stretchr/testify/assert"
  29         "github.com/stretchr/testify/mock"
  30 )
  31
  32 type clientMock struct {
  33         mock.Mock
  34 }
  35
  36 type pubSubMock struct {
  37         mock.Mock
  38 }
  39
  40 func (m *pubSubMock) Channel() <-chan *redis.Message {
  41         return m.Called().Get(0).(chan *redis.Message)
  42 }
  43
  44 func (m *pubSubMock) Subscribe(channels ...string) error {
  45         return m.Called().Error(0)
  46 }
  47
  48 func (m *pubSubMock) Unsubscribe(channels ...string) error {
  49         return m.Called().Error(0)
  50 }
  51
  52 func (m *pubSubMock) Close() error {
  53         return m.Called().Error(0)
  54 }
  55
  56 func (m *clientMock) Command() *redis.CommandsInfoCmd {
  57         return m.Called().Get(0).(*redis.CommandsInfoCmd)
  58 }
  59
  60 func (m *clientMock) Close() error {
  61         return m.Called().Error(0)
  62 }
  63
  64 func (m *clientMock) Subscribe(channels ...string) *redis.PubSub {
  65         return m.Called(channels).Get(0).(*redis.PubSub)
  66 }
  67
  68 func (m *clientMock) MSet(pairs ...interface{}) *redis.StatusCmd {
  69         return m.Called(pairs).Get(0).(*redis.StatusCmd)
  70 }
  71
  72 func (m *clientMock) Do(args ...interface{}) *redis.Cmd {
  73         return m.Called(args).Get(0).(*redis.Cmd)
  74 }
  75
  76 func (m *clientMock) MGet(keys ...string) *redis.SliceCmd {
  77         return m.Called(keys).Get(0).(*redis.SliceCmd)
  78 }
  79
  80 func (m *clientMock) Del(keys ...string) *redis.IntCmd {
  81         return m.Called(keys).Get(0).(*redis.IntCmd)
  82 }
  83
  84 func (m *clientMock) Keys(pattern string) *redis.StringSliceCmd {
  85         return m.Called(pattern).Get(0).(*redis.StringSliceCmd)
  86 }
  87
  88 func (m *clientMock) SetNX(key string, value interface{}, expiration time.Duration) *redis.BoolCmd {
  89         return m.Called(key, value, expiration).Get(0).(*redis.BoolCmd)
  90 }
  91
  92 func (m *clientMock) SAdd(key string, members ...interface{}) *redis.IntCmd {
  93         return m.Called(key, members).Get(0).(*redis.IntCmd)
  94 }
  95
  96 func (m *clientMock) SRem(key string, members ...interface{}) *redis.IntCmd {
  97         return m.Called(key, members).Get(0).(*redis.IntCmd)
  98 }
  99
 100 func (m *clientMock) SMembers(key string) *redis.StringSliceCmd {
 101         return m.Called(key).Get(0).(*redis.StringSliceCmd)
 102 }
 103
 104 func (m *clientMock) SIsMember(key string, member interface{}) *redis.BoolCmd {
 105         return m.Called(key, member).Get(0).(*redis.BoolCmd)
 106 }
 107
 108 func (m *clientMock) SCard(key string) *redis.IntCmd {
 109         return m.Called(key).Get(0).(*redis.IntCmd)
 110 }
 111
 112 func setSubscribeNotifications() (*pubSubMock, sdlgoredis.SubscribeFn) {
 113         mock := new(pubSubMock)
 114         return mock, func(client sdlgoredis.RedisClient, channels ...string) sdlgoredis.Subscriber {
 115                 return mock
 116         }
 117 }
 118
 119 func setup(commandsExists bool) (*pubSubMock, *clientMock, *sdlgoredis.DB) {
 120         mock := new(clientMock)
 121         pubSubMock, subscribeNotifications := setSubscribeNotifications()
 122         db := sdlgoredis.CreateDB(mock, subscribeNotifications)
 123
 124         dummyCommandInfo := redis.CommandInfo{
 125                 Name: "dummy",
 126         }
 127         cmdResult := make(map[string]*redis.CommandInfo, 0)
 128
 129         if commandsExists {
 130                 cmdResult = map[string]*redis.CommandInfo{
 131                         "setie": &dummyCommandInfo,
 132                         "delie": &dummyCommandInfo,
 133                         "setiepub": &dummyCommandInfo,
 134                         "setnxpub": &dummyCommandInfo,
 135                         "msetmpub": &dummyCommandInfo,
 136                         "delmpub": &dummyCommandInfo,
 137                 }
 138         } else {
 139                 cmdResult = map[string]*redis.CommandInfo{
 140                         "dummy": &dummyCommandInfo,
 141                 }
 142         }
 143
 144         mock.On("Command").Return(redis.NewCommandsInfoCmdResult(cmdResult, nil))
 145         db.CheckCommands()
 146         return pubSubMock, mock, db
 147 }
 148
 149 func TestMSetSuccessfully(t *testing.T) {
 150         _, r, db := setup(true)
 151         expectedKeysAndValues := []interface{}{"key1", "value1", "key2", 2}
 152         r.On("MSet",expectedKeysAndValues).Return(redis.NewStatusResult("OK", nil))
 153         err := db.MSet("key1", "value1", "key2", 2)
 154         assert.Nil(t, err)
 155         r.AssertExpectations(t)
 156 }
 157
 158 func TestMSetFailure(t *testing.T) {
 159         _, r, db := setup(true)
 160         expectedKeysAndValues := []interface{}{"key1", "value1", "key2", 2}
 161         r.On("MSet",expectedKeysAndValues).Return(redis.NewStatusResult("OK", errors.New("Some error")))
 162         err := db.MSet("key1", "value1", "key2", 2)
 163         assert.NotNil(t, err)
 164         r.AssertExpectations(t)
 165 }
 166
 167 func TestMSetMPubSuccessfully(t *testing.T) {
 168         _, r, db := setup(true)
 169         expectedMessage := []interface{}{"MSETMPUB", 2, 2, "key1", "val1", "key2", "val2",
 170                                                                          "chan1", "event1", "chan2", "event2"}
 171         r.On("Do", expectedMessage).Return(redis.NewCmdResult("", nil))
 172         assert.Nil(t, db.MSetMPub([]string{"chan1", "event1", "chan2", "event2"},
 173                                                           "key1", "val1", "key2", "val2"))
 174         r.AssertExpectations(t)
 175 }
 176
 177 func TestMsetMPubFailure(t *testing.T) {
 178         _, r, db := setup(true)
 179         expectedMessage := []interface{}{"MSETMPUB", 2, 2, "key1", "val1", "key2", "val2",
 180                                                                          "chan1", "event1", "chan2", "event2"}
 181         r.On("Do", expectedMessage).Return(redis.NewCmdResult("", errors.New("Some error")))
 182         assert.NotNil(t, db.MSetMPub([]string{"chan1", "event1", "chan2", "event2"},
 183                                                              "key1", "val1", "key2", "val2"))
 184         r.AssertExpectations(t)
 185 }
 186
 187 func TestMSetMPubCommandMissing(t *testing.T) {
 188         _, r, db := setup(false)
 189         expectedMessage := []interface{}{"MSETMPUB", 2, 2, "key1", "val1", "key2", "val2",
 190                                                                          "chan1", "event1", "chan2", "event2"}
 191         r.AssertNotCalled(t, "Do", expectedMessage)
 192         assert.NotNil(t, db.MSetMPub([]string{"chan1", "event1", "chan2", "event2"},
 193                                                                  "key1", "val1", "key2", "val2"))
 194         r.AssertExpectations(t)
 195
 196 }
 197
 198 func TestMGetSuccessfully(t *testing.T) {
 199         _, r, db := setup(true)
 200         expectedKeys := []string{"key1", "key2", "key3"}
 201         expectedResult := []interface{}{"val1", 2, nil}
 202         r.On("MGet", expectedKeys).Return(redis.NewSliceResult(expectedResult, nil))
 203         result, err := db.MGet([]string{"key1", "key2", "key3"})
 204         assert.Equal(t, result, expectedResult)
 205         assert.Nil(t, err)
 206         r.AssertExpectations(t)
 207 }
 208
 209 func TestMGetFailure(t *testing.T) {
 210         _, r, db := setup(true)
 211         expectedKeys := []string{"key1", "key2", "key3"}
 212         expectedResult := []interface{}{nil}
 213         r.On("MGet", expectedKeys).Return(redis.NewSliceResult(expectedResult,
 214                                                                                                                    errors.New("Some error")))
 215         result, err := db.MGet([]string{"key1", "key2", "key3"})
 216         assert.Equal(t, result, expectedResult)
 217         assert.NotNil(t, err)
 218         r.AssertExpectations(t)
 219 }
 220
 221 func TestDelMPubSuccessfully(t *testing.T) {
 222         _, r, db := setup(true)
 223         expectedMessage := []interface{}{"DELMPUB", 2, 2, "key1", "key2", "chan1", "event1",
 224                                                                          "chan2", "event2"}
 225         r.On("Do", expectedMessage).Return(redis.NewCmdResult("", nil))
 226         assert.Nil(t, db.DelMPub([]string{"chan1", "event1", "chan2", "event2"},
 227                                                          []string{"key1", "key2"}))
 228         r.AssertExpectations(t)
 229 }
 230
 231 func TestDelMPubFailure(t *testing.T) {
 232         _, r, db := setup(true)
 233         expectedMessage := []interface{}{"DELMPUB", 2, 2, "key1", "key2", "chan1", "event1",
 234                                                                          "chan2", "event2"}
 235         r.On("Do", expectedMessage).Return(redis.NewCmdResult("", errors.New("Some error")))
 236         assert.NotNil(t, db.DelMPub([]string{"chan1", "event1", "chan2", "event2"},
 237                                                                 []string{"key1", "key2"}))
 238         r.AssertExpectations(t)
 239 }
 240
 241 func TestDelMPubCommandMissing(t *testing.T) {
 242         _, r, db := setup(false)
 243         expectedMessage := []interface{}{"DELMPUB", 2, 2, "key1", "key2", "chan1", "event1",
 244                                                                          "chan2", "event2"}
 245         r.AssertNotCalled(t, "Do", expectedMessage)
 246         assert.NotNil(t, db.DelMPub([]string{"chan1", "event1", "chan2", "event2"},
 247                                                                 []string{"key1", "key2"}))
 248         r.AssertExpectations(t)
 249 }
 250
 251 func TestDelSuccessfully(t *testing.T) {
 252         _, r, db := setup(true)
 253         expectedKeys := []string{"key1", "key2"}
 254         r.On("Del", expectedKeys).Return(redis.NewIntResult(2, nil))
 255         assert.Nil(t, db.Del([]string{"key1", "key2"}))
 256         r.AssertExpectations(t)
 257 }
 258
 259 func TestDelFailure(t *testing.T) {
 260         _, r, db := setup(true)
 261         expectedKeys := []string{"key1", "key2"}
 262         r.On("Del", expectedKeys).Return(redis.NewIntResult(2, errors.New("Some error")))
 263         assert.NotNil(t, db.Del([]string{"key1", "key2"}))
 264         r.AssertExpectations(t)
 265 }
 266
 267 func TestKeysSuccessfully(t *testing.T) {
 268         _, r, db := setup(true)
 269         expectedPattern := "pattern*"
 270         expectedResult := []string{"pattern1", "pattern2"}
 271         r.On("Keys", expectedPattern).Return(redis.NewStringSliceResult(expectedResult, nil))
 272         result, err := db.Keys("pattern*")
 273         assert.Equal(t, result, expectedResult)
 274         assert.Nil(t, err)
 275         r.AssertExpectations(t)
 276 }
 277
 278 func TestKeysFailure(t *testing.T) {
 279         _, r, db := setup(true)
 280         expectedPattern := "pattern*"
 281         expectedResult := []string{}
 282         r.On("Keys", expectedPattern).Return(redis.NewStringSliceResult(expectedResult,
 283                                                                                                                                     errors.New("Some error")))
 284         _, err := db.Keys("pattern*")
 285         assert.NotNil(t, err)
 286         r.AssertExpectations(t)
 287 }
 288
 289 func TestSetIEKeyExists(t *testing.T) {
 290         _, r, db := setup(true)
 291         expectedMessage := []interface{}{"SETIE", "key", "newdata", "olddata"}
 292         r.On("Do", expectedMessage).Return(redis.NewCmdResult("OK", nil))
 293         result, err := db.SetIE("key", "olddata", "newdata")
 294         assert.True(t, result)
 295         assert.Nil(t, err)
 296         r.AssertExpectations(t)
 297 }
 298
 299 func TestSetIEKeyDoesntExists(t *testing.T) {
 300         _, r, db := setup(true)
 301         expectedMessage := []interface{}{"SETIE", "key", "newdata", "olddata"}
 302         r.On("Do", expectedMessage).Return(redis.NewCmdResult(nil, nil))
 303         result, err := db.SetIE("key", "olddata", "newdata")
 304         assert.False(t, result)
 305         assert.Nil(t, err)
 306         r.AssertExpectations(t)
 307 }
 308
 309 func TestSetIEFailure(t *testing.T) {
 310         _, r, db := setup(true)
 311         expectedMessage := []interface{}{"SETIE", "key", "newdata", "olddata"}
 312         r.On("Do", expectedMessage).Return(redis.NewCmdResult(nil, errors.New("Some error")))
 313         result, err := db.SetIE("key", "olddata", "newdata")
 314         assert.False(t, result)
 315         assert.NotNil(t, err)
 316         r.AssertExpectations(t)
 317 }
 318
 319 func TestSetIECommandMissing(t *testing.T) {
 320         _, r, db := setup(false)
 321         expectedMessage := []interface{}{"SETIE", "key", "newdata", "olddata"}
 322         r.AssertNotCalled(t, "Do", expectedMessage)
 323         result, err := db.SetIE("key", "olddata", "newdata")
 324         assert.False(t, result)
 325         assert.NotNil(t, err)
 326         r.AssertExpectations(t)
 327 }
 328
 329 func TestSetIEPubKeyExists(t *testing.T) {
 330         _, r, db := setup(true)
 331         expectedMessage := []interface{}{"SETIEPUB", "key", "newdata", "olddata", "channel", "message"}
 332         r.On("Do", expectedMessage).Return(redis.NewCmdResult("OK", nil))
 333         result, err := db.SetIEPub("channel", "message", "key", "olddata", "newdata")
 334         assert.True(t, result)
 335         assert.Nil(t, err)
 336         r.AssertExpectations(t)
 337 }
 338
 339 func TestSetIEPubKeyDoesntExists(t *testing.T) {
 340         _, r, db := setup(true)
 341         expectedMessage := []interface{}{"SETIEPUB", "key", "newdata", "olddata", "channel", "message"}
 342         r.On("Do", expectedMessage).Return(redis.NewCmdResult(nil, nil))
 343         result, err := db.SetIEPub("channel", "message", "key", "olddata", "newdata")
 344         assert.False(t, result)
 345         assert.Nil(t, err)
 346         r.AssertExpectations(t)
 347 }
 348
 349 func TestSetIEPubFailure(t *testing.T) {
 350         _, r, db := setup(true)
 351         expectedMessage := []interface{}{"SETIEPUB", "key", "newdata", "olddata", "channel", "message"}
 352         r.On("Do", expectedMessage).Return(redis.NewCmdResult(nil, errors.New("Some error")))
 353         result, err := db.SetIEPub("channel", "message", "key", "olddata", "newdata")
 354         assert.False(t, result)
 355         assert.NotNil(t, err)
 356         r.AssertExpectations(t)
 357 }
 358
 359 func TestSetIEPubCommandMissing(t *testing.T) {
 360         _, r, db := setup(false)
 361         expectedMessage := []interface{}{"SETIEPUB", "key", "newdata", "olddata", "channel", "message"}
 362         r.AssertNotCalled(t, "Do", expectedMessage)
 363         result, err := db.SetIEPub("channel", "message", "key", "olddata", "newdata")
 364         assert.False(t, result)
 365         assert.NotNil(t, err)
 366         r.AssertExpectations(t)
 367 }
 368
 369 func TestSetNXPubKeyDoesntExist(t *testing.T) {
 370         _, r, db := setup(true)
 371         expectedMessage := []interface{}{"SETNXPUB", "key", "data", "channel", "message"}
 372         r.On("Do", expectedMessage).Return(redis.NewCmdResult("OK", nil))
 373         result, err := db.SetNXPub("channel", "message", "key", "data")
 374         assert.True(t, result)
 375         assert.Nil(t, err)
 376         r.AssertExpectations(t)
 377 }
 378
 379 func TestSetNXPubKeyExists(t *testing.T) {
 380         _, r, db := setup(true)
 381         expectedMessage := []interface{}{"SETNXPUB", "key", "data", "channel", "message"}
 382         r.On("Do", expectedMessage).Return(redis.NewCmdResult(nil, nil))
 383         result, err := db.SetNXPub("channel", "message", "key", "data")
 384         assert.False(t, result)
 385         assert.Nil(t, err)
 386         r.AssertExpectations(t)
 387 }
 388
 389 func TestSetNXPubFailure(t *testing.T) {
 390         _, r, db := setup(true)
 391         expectedMessage := []interface{}{"SETNXPUB", "key", "data", "channel", "message"}
 392         r.On("Do", expectedMessage).Return(redis.NewCmdResult(nil, errors.New("Some error")))
 393         result, err := db.SetNXPub("channel", "message", "key", "data")
 394         assert.False(t, result)
 395         assert.NotNil(t, err)
 396         r.AssertExpectations(t)
 397 }
 398
 399 func TestSetNXPubCommandMissing(t *testing.T) {
 400         _, r, db := setup(false)
 401         expectedMessage := []interface{}{"SETNXPUB", "key", "data", "channel", "message"}
 402         r.AssertNotCalled(t, "Do", expectedMessage)
 403         result, err := db.SetNXPub("channel", "message", "key", "data")
 404         assert.False(t, result)
 405         assert.NotNil(t, err)
 406         r.AssertExpectations(t)
 407 }
 408
 409 func TestSetNXSuccessfully(t *testing.T) {
 410         _, r, db := setup(true)
 411         expectedKey := "key"
 412         expectedData := "data"
 413         r.On("SetNX", expectedKey, expectedData, time.Duration(0)).Return(redis.NewBoolResult(true, nil))
 414         result, err := db.SetNX("key", "data")
 415         assert.True(t, result)
 416         assert.Nil(t, err)
 417         r.AssertExpectations(t)
 418 }
 419
 420 func TestSetNXUnsuccessfully(t *testing.T) {
 421         _, r, db := setup(true)
 422         expectedKey := "key"
 423         expectedData := "data"
 424         r.On("SetNX", expectedKey, expectedData, time.Duration(0)).Return(redis.NewBoolResult(false, nil))
 425         result, err := db.SetNX("key", "data")
 426         assert.False(t, result)
 427         assert.Nil(t, err)
 428         r.AssertExpectations(t)
 429 }
 430
 431 func TestSetNXFailure(t *testing.T) {
 432         _, r, db := setup(true)
 433         expectedKey := "key"
 434         expectedData := "data"
 435         r.On("SetNX", expectedKey, expectedData, time.Duration(0)).
 436                 Return(redis.NewBoolResult(false,errors.New("Some error")))
 437         result, err := db.SetNX("key", "data")
 438         assert.False(t, result)
 439         assert.NotNil(t, err)
 440         r.AssertExpectations(t)
 441 }
 442
 443 func TestDelIEPubKeyDoesntExist(t *testing.T) {
 444         _, r, db := setup(true)
 445         expectedMessage := []interface{}{"DELIEPUB", "key", "data", "channel", "message"}
 446         r.On("Do", expectedMessage).Return(redis.NewCmdResult(0, nil))
 447         result, err := db.DelIEPub("channel", "message", "key", "data")
 448         assert.False(t, result)
 449         assert.Nil(t, err)
 450         r.AssertExpectations(t)
 451 }
 452
 453 func TestDelIEPubKeyExists(t *testing.T) {
 454         _, r, db := setup(true)
 455         expectedMessage := []interface{}{"DELIEPUB", "key", "data", "channel", "message"}
 456         r.On("Do", expectedMessage).Return(redis.NewCmdResult(1, nil))
 457         result, err := db.DelIEPub("channel", "message", "key", "data")
 458         assert.True(t, result)
 459         assert.Nil(t, err)
 460         r.AssertExpectations(t)
 461 }
 462
 463 func TestDelIEPubFailure(t *testing.T) {
 464         _, r, db := setup(true)
 465         expectedMessage := []interface{}{"DELIEPUB", "key", "data", "channel", "message"}
 466         r.On("Do", expectedMessage).Return(redis.NewCmdResult(0, errors.New("Some error")))
 467         result, err := db.DelIEPub("channel", "message", "key", "data")
 468         assert.False(t, result)
 469         assert.NotNil(t, err)
 470         r.AssertExpectations(t)
 471 }
 472
 473 func TestDelIEPubCommandMissing(t *testing.T) {
 474         _, r, db := setup(false)
 475         expectedMessage := []interface{}{"DELIEPUB", "key", "data", "channel", "message"}
 476         r.AssertNotCalled(t, "Do", expectedMessage)
 477         result, err := db.DelIEPub("channel", "message", "key", "data")
 478         assert.False(t, result)
 479         assert.NotNil(t, err)
 480         r.AssertExpectations(t)
 481 }
 482
 483 func TestDelIEKeyDoesntExist(t *testing.T) {
 484         _, r, db := setup(true)
 485         expectedMessage := []interface{}{"DELIE", "key", "data"}
 486         r.On("Do", expectedMessage).Return(redis.NewCmdResult(0, nil))
 487         result, err := db.DelIE("key", "data")
 488         assert.False(t, result)
 489         assert.Nil(t, err)
 490         r.AssertExpectations(t)
 491 }
 492
 493 func TestDelIEKeyExists(t *testing.T) {
 494         _, r, db := setup(true)
 495         expectedMessage := []interface{}{"DELIE", "key", "data"}
 496         r.On("Do", expectedMessage).Return(redis.NewCmdResult(1, nil))
 497         result, err := db.DelIE("key", "data")
 498         assert.True(t, result)
 499         assert.Nil(t, err)
 500         r.AssertExpectations(t)
 501 }
 502
 503 func TestDelIEFailure(t *testing.T) {
 504         _, r, db := setup(true)
 505         expectedMessage := []interface{}{"DELIE", "key", "data"}
 506         r.On("Do", expectedMessage).Return(redis.NewCmdResult(0, errors.New("Some error")))
 507         result, err := db.DelIE("key", "data")
 508         assert.False(t, result)
 509         assert.NotNil(t, err)
 510         r.AssertExpectations(t)
 511 }
 512
 513 func TestDelIECommandMissing(t *testing.T) {
 514         _, r, db := setup(false)
 515         expectedMessage := []interface{}{"DELIE", "key", "data"}
 516         r.AssertNotCalled(t, "Do", expectedMessage)
 517         result, err := db.DelIE("key", "data")
 518         assert.False(t, result)
 519         assert.NotNil(t, err)
 520         r.AssertExpectations(t)
 521 }
 522
 523 func TestSAddSuccessfully(t *testing.T) {
 524         _, r, db := setup(true)
 525         expectedKey := "key"
 526         expectedData := []interface{}{"data", 2}
 527         r.On("SAdd", expectedKey, expectedData).Return(redis.NewIntResult(2, nil))
 528         assert.Nil(t, db.SAdd("key", "data", 2))
 529         r.AssertExpectations(t)
 530 }
 531
 532 func TestSAddFailure(t *testing.T) {
 533         _, r, db := setup(true)
 534         expectedKey := "key"
 535         expectedData := []interface{}{"data", 2}
 536         r.On("SAdd", expectedKey, expectedData).Return(redis.NewIntResult(2, errors.New("Some error")))
 537         assert.NotNil(t, db.SAdd("key", "data", 2))
 538         r.AssertExpectations(t)
 539 }
 540
 541 func TestSRemSuccessfully(t *testing.T) {
 542         _, r, db := setup(true)
 543         expectedKey := "key"
 544         expectedData := []interface{}{"data", 2}
 545         r.On("SRem", expectedKey, expectedData).Return(redis.NewIntResult(2, nil))
 546         assert.Nil(t, db.SRem("key", "data", 2))
 547         r.AssertExpectations(t)
 548 }
 549
 550 func TestSRemFailure(t *testing.T) {
 551         _, r, db := setup(true)
 552         expectedKey := "key"
 553         expectedData := []interface{}{"data", 2}
 554         r.On("SRem", expectedKey, expectedData).Return(redis.NewIntResult(2, errors.New("Some error")))
 555         assert.NotNil(t, db.SRem("key", "data", 2))
 556         r.AssertExpectations(t)
 557 }
 558
 559 func TestSMembersSuccessfully(t *testing.T) {
 560         _, r, db := setup(true)
 561         expectedKey := "key"
 562         expectedResult := []string{"member1", "member2"}
 563         r.On("SMembers", expectedKey).Return(redis.NewStringSliceResult(expectedResult, nil))
 564         result, err := db.SMembers("key")
 565         assert.Equal(t, result, expectedResult)
 566         assert.Nil(t, err)
 567         r.AssertExpectations(t)
 568 }
 569
 570 func TestSMembersFailure(t *testing.T) {
 571         _, r, db := setup(true)
 572         expectedKey := "key"
 573         expectedResult := []string{"member1", "member2"}
 574         r.On("SMembers", expectedKey).Return(redis.NewStringSliceResult(expectedResult,
 575                                                                                                                                         errors.New("Some error")))
 576         result, err := db.SMembers("key")
 577         assert.Equal(t, result, expectedResult)
 578         assert.NotNil(t, err)
 579         r.AssertExpectations(t)
 580 }
 581
 582 func TestSIsMemberIsMember(t *testing.T) {
 583         _, r, db := setup(true)
 584         expectedKey := "key"
 585         expectedData := "data"
 586         r.On("SIsMember", expectedKey, expectedData).Return(redis.NewBoolResult(true, nil))
 587         result, err := db.SIsMember("key", "data")
 588         assert.True(t, result)
 589         assert.Nil(t, err)
 590         r.AssertExpectations(t)
 591 }
 592
 593 func TestSIsMemberIsNotMember(t *testing.T) {
 594         _, r, db := setup(true)
 595         expectedKey := "key"
 596         expectedData := "data"
 597         r.On("SIsMember", expectedKey, expectedData).Return(redis.NewBoolResult(false, nil))
 598         result, err := db.SIsMember("key", "data")
 599         assert.False(t, result)
 600         assert.Nil(t, err)
 601         r.AssertExpectations(t)
 602 }
 603
 604 func TestSIsMemberFailure(t *testing.T) {
 605         _, r, db := setup(true)
 606         expectedKey := "key"
 607         expectedData := "data"
 608         r.On("SIsMember", expectedKey, expectedData).
 609                 Return(redis.NewBoolResult(false, errors.New("Some error")))
 610         result, err := db.SIsMember("key", "data")
 611         assert.False(t, result)
 612         assert.NotNil(t, err)
 613         r.AssertExpectations(t)
 614 }
 615
 616 func TestSCardSuccessfully(t *testing.T) {
 617         _, r, db := setup(true)
 618         expectedKey := "key"
 619         r.On("SCard", expectedKey).Return(redis.NewIntResult(1, nil))
 620         result, err := db.SCard("key")
 621         assert.Equal(t, int64(1), result)
 622         assert.Nil(t, err)
 623         r.AssertExpectations(t)
 624 }
 625
 626 func TestSCardFailure(t *testing.T) {
 627         _, r, db := setup(true)
 628         expectedKey := "key"
 629         r.On("SCard", expectedKey).Return(redis.NewIntResult(1, errors.New("Some error")))
 630         result, err := db.SCard("key")
 631         assert.Equal(t, int64(1), result)
 632         assert.NotNil(t, err)
 633         r.AssertExpectations(t)
 634 }
 635
 636 func TestSubscribeChannelDBSubscribeRXUnsubscribe(t *testing.T) {
 637         ps, r, db := setup(true)
 638         ch := make(chan *redis.Message)
 639         msg := redis.Message{
 640                 Channel: "{prefix}channel",
 641                 Pattern: "pattern",
 642                 Payload: "event",
 643         }
 644         ps.On("Channel").Return(ch)
 645         ps.On("Unsubscribe").Return(nil)
 646         ps.On("Close").Return(nil)
 647         count := 0
 648         receivedChannel := ""
 649         db.SubscribeChannelDB(func(channel string, payload ...string){
 650                 count++
 651                 receivedChannel = channel
 652                 },"{prefix}", "---", "{prefix}channel")
 653         ch <- &msg
 654         db.UnsubscribeChannelDB("{prefix}channel")
 655         time.Sleep(1 * time.Second)
 656         assert.Equal(t, 1, count)
 657         assert.Equal(t, "channel", receivedChannel)
 658         r.AssertExpectations(t)
 659         ps.AssertExpectations(t)
 660 }
 661
 662 func TestSubscribeChannelDBSubscribeTwoUnsubscribeOne(t *testing.T) {
 663         ps, r, db := setup(true)
 664         ch := make(chan *redis.Message)
 665         msg1 := redis.Message{
 666                 Channel: "{prefix}channel1",
 667                 Pattern: "pattern",
 668                 Payload: "event",
 669         }
 670         msg2 := redis.Message{
 671                 Channel: "{prefix}channel2",
 672                 Pattern: "pattern",
 673                 Payload: "event",
 674         }
 675         ps.On("Channel").Return(ch)
 676         ps.On("Subscribe").Return(nil)
 677         ps.On("Unsubscribe").Return(nil)
 678         ps.On("Unsubscribe").Return(nil)
 679         ps.On("Close").Return(nil)
 680         count := 0
 681         receivedChannel1 := ""
 682         db.SubscribeChannelDB(func(channel string, payload ...string){
 683                 count++
 684                 receivedChannel1 = channel
 685                 },"{prefix}", "---", "{prefix}channel1")
 686         ch <- &msg1
 687         receivedChannel2 := ""
 688         db.SubscribeChannelDB(func(channel string, payload ...string){
 689                 count++
 690                 receivedChannel2 = channel
 691                 },"{prefix}", "---", "{prefix}channel2")
 692
 693         db.UnsubscribeChannelDB("{prefix}channel1")
 694         ch <- &msg2
 695         db.UnsubscribeChannelDB("{prefix}channel2")
 696         time.Sleep(1 * time.Second)
 697         assert.Equal(t, 2, count)
 698         assert.Equal(t, "channel1", receivedChannel1)
 699         assert.Equal(t, "channel2", receivedChannel2)
 700         r.AssertExpectations(t)
 701         ps.AssertExpectations(t)
 702 }