sdl_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 sdlgo_test
  24
  25 import (
  26         "errors"
  27         "reflect"
  28         "testing"
  29         "time"
  30
  31         "gerrit.o-ran-sc.org/r/ric-plt/sdlgo"
  32         "github.com/stretchr/testify/assert"
  33         "github.com/stretchr/testify/mock"
  34 )
  35
  36 type mockDB struct {
  37         mock.Mock
  38 }
  39
  40 func (m *mockDB) SubscribeChannelDB(cb func(string, ...string), channelPrefix, eventSeparator string, channels ...string) {
  41         m.Called(cb, channelPrefix, eventSeparator, channels)
  42 }
  43
  44 func (m *mockDB) UnsubscribeChannelDB(channels ...string) {
  45         m.Called(channels)
  46 }
  47
  48 func (m *mockDB) MSet(pairs ...interface{}) error {
  49         a := m.Called(pairs)
  50         return a.Error(0)
  51 }
  52
  53 func (m *mockDB) MSetMPub(channelsAndEvents []string, pairs ...interface{}) error {
  54         a := m.Called(channelsAndEvents, pairs)
  55         return a.Error(0)
  56 }
  57
  58 func (m *mockDB) MGet(keys []string) ([]interface{}, error) {
  59         a := m.Called(keys)
  60         return a.Get(0).([]interface{}), a.Error(1)
  61 }
  62
  63 func (m *mockDB) CloseDB() error {
  64         a := m.Called()
  65         return a.Error(0)
  66 }
  67
  68 func (m *mockDB) Del(keys []string) error {
  69         a := m.Called(keys)
  70         return a.Error(0)
  71 }
  72
  73 func (m *mockDB) DelMPub(channelsAndEvents []string, keys []string) error {
  74         a := m.Called(channelsAndEvents, keys)
  75         return a.Error(0)
  76 }
  77
  78 func (m *mockDB) Keys(pattern string) ([]string, error) {
  79         a := m.Called(pattern)
  80         return a.Get(0).([]string), a.Error(1)
  81 }
  82
  83 func (m *mockDB) SetIE(key string, oldData, newData interface{}) (bool, error) {
  84         a := m.Called(key, oldData, newData)
  85         return a.Bool(0), a.Error(1)
  86 }
  87
  88 func (m *mockDB) SetIEPub(channelsAndEvents []string, key string, oldData, newData interface{}) (bool, error) {
  89         a := m.Called(channelsAndEvents, key, oldData, newData)
  90         return a.Bool(0), a.Error(1)
  91 }
  92
  93 func (m *mockDB) SetNX(key string, data interface{}, expiration time.Duration) (bool, error) {
  94         a := m.Called(key, data, expiration)
  95         return a.Bool(0), a.Error(1)
  96 }
  97
  98 func (m *mockDB) SetNXPub(channelsAndEvents []string, key string, data interface{}) (bool, error) {
  99         a := m.Called(channelsAndEvents, key, data)
 100         return a.Bool(0), a.Error(1)
 101 }
 102
 103 func (m *mockDB) DelIE(key string, data interface{}) (bool, error) {
 104         a := m.Called(key, data)
 105         return a.Bool(0), a.Error(1)
 106 }
 107
 108 func (m *mockDB) DelIEPub(channelsAndEvents []string, key string, data interface{}) (bool, error) {
 109         a := m.Called(channelsAndEvents, key, data)
 110         return a.Bool(0), a.Error(1)
 111 }
 112
 113 func (m *mockDB) SAdd(key string, data ...interface{}) error {
 114         a := m.Called(key, data)
 115         return a.Error(0)
 116 }
 117
 118 func (m *mockDB) SRem(key string, data ...interface{}) error {
 119         a := m.Called(key, data)
 120         return a.Error(0)
 121 }
 122 func (m *mockDB) SMembers(key string) ([]string, error) {
 123         a := m.Called(key)
 124         return a.Get(0).([]string), a.Error(1)
 125 }
 126
 127 func (m *mockDB) SIsMember(key string, data interface{}) (bool, error) {
 128         a := m.Called(key, data)
 129         return a.Bool(0), a.Error(1)
 130 }
 131
 132 func (m *mockDB) SCard(key string) (int64, error) {
 133         a := m.Called(key)
 134         return a.Get(0).(int64), a.Error(1)
 135 }
 136
 137 func (m *mockDB) PTTL(key string) (time.Duration, error) {
 138         a := m.Called(key)
 139         return a.Get(0).(time.Duration), a.Error(1)
 140 }
 141
 142 func (m *mockDB) PExpireIE(key string, data interface{}, expiration time.Duration) error {
 143         a := m.Called(key, data, expiration)
 144         return a.Error(0)
 145 }
 146
 147 func setup() (*mockDB, *sdlgo.SdlInstance) {
 148         m := new(mockDB)
 149         i := sdlgo.NewSdlInstanceForTest("namespace", m)
 150         return m, i
 151 }
 152
 153 func verifySliceInOrder(a, b []string) bool {
 154         for i, v := range a {
 155                 found := false
 156                 if i%2 == 0 {
 157                         for j, x := range b {
 158                                 if j%2 == 0 && x == v && a[i+1] == b[j+1] {
 159                                         found = true
 160                                         break
 161                                 }
 162                         }
 163                         if !found {
 164                                 return false
 165                         }
 166                 }
 167         }
 168         return true
 169
 170 }
 171
 172 func TestSubscribeChannel(t *testing.T) {
 173         m, i := setup()
 174
 175         expectedCB := func(channel string, events ...string) {}
 176         expectedChannels := []string{"{namespace},channel1", "{namespace},channel2"}
 177
 178         m.On("SubscribeChannelDB", mock.AnythingOfType("func(string, ...string)"), "{namespace},", "___", expectedChannels).Return()
 179         i.SubscribeChannel(expectedCB, "channel1", "channel2")
 180         m.AssertExpectations(t)
 181 }
 182
 183 func TestUnsubscribeChannel(t *testing.T) {
 184         m, i := setup()
 185
 186         expectedChannels := []string{"{namespace},channel1", "{namespace},channel2"}
 187
 188         m.On("UnsubscribeChannelDB", expectedChannels).Return()
 189         i.UnsubscribeChannel("channel1", "channel2")
 190         m.AssertExpectations(t)
 191 }
 192 func TestGetOneKey(t *testing.T) {
 193         m, i := setup()
 194
 195         mgetExpected := []string{"{namespace},key"}
 196         mReturn := []interface{}{"somevalue"}
 197         mReturnExpected := make(map[string]interface{})
 198         mReturnExpected["key"] = "somevalue"
 199
 200         m.On("MGet", mgetExpected).Return(mReturn, nil)
 201         retVal, err := i.Get([]string{"key"})
 202         assert.Nil(t, err)
 203         assert.Equal(t, mReturnExpected, retVal)
 204         m.AssertExpectations(t)
 205 }
 206
 207 func TestGetSeveralKeys(t *testing.T) {
 208         m, i := setup()
 209
 210         mgetExpected := []string{"{namespace},key1", "{namespace},key2", "{namespace},key3"}
 211         mReturn := []interface{}{"somevalue1", 2, "someothervalue"}
 212         mReturnExpected := make(map[string]interface{})
 213         mReturnExpected["key1"] = "somevalue1"
 214         mReturnExpected["key2"] = 2
 215         mReturnExpected["key3"] = "someothervalue"
 216
 217         m.On("MGet", mgetExpected).Return(mReturn, nil)
 218         retVal, err := i.Get([]string{"key1", "key2", "key3"})
 219         assert.Nil(t, err)
 220         assert.Equal(t, mReturnExpected, retVal)
 221         m.AssertExpectations(t)
 222 }
 223
 224 func TestGetSeveralKeysSomeFail(t *testing.T) {
 225         m, i := setup()
 226
 227         mgetExpected := []string{"{namespace},key1", "{namespace},key2", "{namespace},key3"}
 228         mReturn := []interface{}{"somevalue1", nil, "someothervalue"}
 229         mReturnExpected := make(map[string]interface{})
 230         mReturnExpected["key1"] = "somevalue1"
 231         mReturnExpected["key2"] = nil
 232         mReturnExpected["key3"] = "someothervalue"
 233
 234         m.On("MGet", mgetExpected).Return(mReturn, nil)
 235         retVal, err := i.Get([]string{"key1", "key2", "key3"})
 236         assert.Nil(t, err)
 237         assert.Equal(t, mReturnExpected, retVal)
 238         m.AssertExpectations(t)
 239 }
 240
 241 func TestGetKeyReturnError(t *testing.T) {
 242         m, i := setup()
 243
 244         mgetExpected := []string{"{namespace},key"}
 245         mReturn := []interface{}{nil}
 246         mReturnExpected := make(map[string]interface{})
 247
 248         m.On("MGet", mgetExpected).Return(mReturn, errors.New("Some error"))
 249         retVal, err := i.Get([]string{"key"})
 250         assert.NotNil(t, err)
 251         assert.Equal(t, mReturnExpected, retVal)
 252         m.AssertExpectations(t)
 253 }
 254
 255 func TestGetEmptyList(t *testing.T) {
 256         m, i := setup()
 257
 258         mgetExpected := []string{}
 259
 260         retval, err := i.Get([]string{})
 261         assert.Nil(t, err)
 262         assert.Len(t, retval, 0)
 263         m.AssertNotCalled(t, "MGet", mgetExpected)
 264 }
 265
 266 func TestWriteOneKey(t *testing.T) {
 267         m, i := setup()
 268
 269         msetExpected := []interface{}{"{namespace},key1", "data1"}
 270
 271         m.On("MSet", msetExpected).Return(nil)
 272         err := i.Set("key1", "data1")
 273         assert.Nil(t, err)
 274         m.AssertExpectations(t)
 275 }
 276
 277 func TestWriteByteSliceAsValue(t *testing.T) {
 278         m, i := setup()
 279
 280         msetExpected := []interface{}{"{namespace},key1", []byte{1, 2, 3, 4, 5}}
 281
 282         m.On("MSet", msetExpected).Return(nil)
 283         err := i.Set("key1", []byte{1, 2, 3, 4, 5})
 284         assert.Nil(t, err)
 285         m.AssertExpectations(t)
 286 }
 287
 288 func TestWriteByteSliceAsValueMixed(t *testing.T) {
 289         m, i := setup()
 290
 291         msetExpected := []interface{}{"{namespace},key1", []byte{1, 2, 3, 4, 5}, "{namespace},key2", "value2"}
 292
 293         m.On("MSet", msetExpected).Return(nil)
 294         err := i.Set("key1", []byte{1, 2, 3, 4, 5}, []string{"key2", "value2"})
 295         assert.Nil(t, err)
 296         m.AssertExpectations(t)
 297 }
 298
 299 func TestWriteByteArrayAsValue(t *testing.T) {
 300         m, i := setup()
 301
 302         msetExpected := []interface{}{"{namespace},key1", [5]byte{1, 2, 3, 4, 5}}
 303
 304         m.On("MSet", msetExpected).Return(nil)
 305         err := i.Set("key1", [5]byte{1, 2, 3, 4, 5})
 306         assert.Nil(t, err)
 307         m.AssertExpectations(t)
 308 }
 309
 310 func TestWriteMapAsInput(t *testing.T) {
 311         m, i := setup()
 312
 313         setExpected := []interface{}{"{namespace},key1", "string123",
 314                 "{namespace},key22", 12,
 315                 "{namespace},key333", []byte{1, 2, 3, 4, 5}}
 316         inputMap := map[string]interface{}{
 317                 "key1":   "string123",
 318                 "key22":  12,
 319                 "key333": []byte{1, 2, 3, 4, 5},
 320         }
 321
 322         m.On("MSet", mock.MatchedBy(func(input []interface{}) bool {
 323                 for _, v := range input {
 324                         found := false
 325                         for _, x := range setExpected {
 326                                 found = reflect.DeepEqual(x, v)
 327                                 if found == true {
 328                                         break
 329                                 }
 330                         }
 331                         if found == false {
 332                                 return false
 333                         }
 334                 }
 335                 return true
 336         })).Return(nil)
 337
 338         err := i.Set(inputMap)
 339         assert.Nil(t, err)
 340         m.AssertExpectations(t)
 341 }
 342
 343 func TestWriteMixed(t *testing.T) {
 344         m, i := setup()
 345
 346         msetExpected := []interface{}{"{namespace},key1", "data1", "{namespace},key2", "data2", "{namespace},key3", "data3"}
 347
 348         m.On("MSet", msetExpected).Return(nil)
 349         err := i.Set("key1", "data1", []string{"key2", "data2"}, [2]string{"key3", "data3"})
 350         assert.Nil(t, err)
 351         m.AssertExpectations(t)
 352 }
 353
 354 func TestWriteIncorrectMixed(t *testing.T) {
 355         m, i := setup()
 356
 357         msetExpected := []interface{}{"{namespace},key1", "data1", "{namespace},key2", "data2", "{namespace},key3", "data3"}
 358
 359         m.AssertNotCalled(t, "MSet", msetExpected)
 360         err := i.Set("key1", []string{"key2", "data2"}, [2]string{"key3", "data3"})
 361         assert.NotNil(t, err)
 362         m.AssertExpectations(t)
 363 }
 364 func TestWriteIncorrectPairs(t *testing.T) {
 365         m, i := setup()
 366
 367         msetExpected := []interface{}{}
 368
 369         m.AssertNotCalled(t, "MSet", msetExpected)
 370         err := i.Set("key")
 371         assert.NotNil(t, err)
 372         m.AssertExpectations(t)
 373 }
 374 func TestWriteSeveralKeysSlice(t *testing.T) {
 375         m, i := setup()
 376
 377         msetExpected := []interface{}{"{namespace},key1", "data1", "{namespace},key2", 22}
 378
 379         m.On("MSet", msetExpected).Return(nil)
 380         err := i.Set([]interface{}{"key1", "data1", "key2", 22})
 381         assert.Nil(t, err)
 382         m.AssertExpectations(t)
 383
 384 }
 385
 386 func TestWriteSeveralKeysIncorrectSlice(t *testing.T) {
 387         m, i := setup()
 388
 389         msetExpected := []interface{}{"{namespace},key1", "data1", "{namespace},key2", 22}
 390
 391         m.AssertNotCalled(t, "MSet", msetExpected)
 392         err := i.Set([]interface{}{"key1", "data1", "key2"})
 393         assert.NotNil(t, err)
 394         m.AssertExpectations(t)
 395
 396 }
 397
 398 func TestWriteSeveralKeysArray(t *testing.T) {
 399         m, i := setup()
 400
 401         msetExpected := []interface{}{"{namespace},key1", "data1", "{namespace},key2", "data2"}
 402
 403         m.On("MSet", msetExpected).Return(nil)
 404         err := i.Set([4]string{"key1", "data1", "key2", "data2"})
 405         assert.Nil(t, err)
 406         m.AssertExpectations(t)
 407 }
 408
 409 func TestWriteSeveralKeysIncorrectArray(t *testing.T) {
 410         m, i := setup()
 411
 412         msetExpected := []interface{}{}
 413
 414         m.AssertNotCalled(t, "MSet", msetExpected)
 415         err := i.Set([3]string{"key1", "data1", "key2"})
 416         assert.NotNil(t, err)
 417         m.AssertExpectations(t)
 418 }
 419
 420 func TestWriteFail(t *testing.T) {
 421         m, i := setup()
 422
 423         msetExpected := []interface{}{"{namespace},key1", "data1"}
 424
 425         m.On("MSet", msetExpected).Return(errors.New("Some error"))
 426         err := i.Set("key1", "data1")
 427         assert.NotNil(t, err)
 428         m.AssertExpectations(t)
 429 }
 430
 431 func TestWriteEmptyList(t *testing.T) {
 432         m, i := setup()
 433
 434         msetExpected := []interface{}{}
 435         err := i.Set()
 436         assert.Nil(t, err)
 437         m.AssertNotCalled(t, "MSet", msetExpected)
 438 }
 439
 440 func TestWriteAndPublishOneKeyOneChannel(t *testing.T) {
 441         m, i := setup()
 442
 443         expectedChannelAndEvent := []string{"{namespace},channel", "event"}
 444         expectedKeyVal := []interface{}{"{namespace},key1", "data1"}
 445
 446         m.On("MSetMPub", expectedChannelAndEvent, expectedKeyVal).Return(nil)
 447         m.AssertNotCalled(t, "MSet", expectedKeyVal)
 448         err := i.SetAndPublish([]string{"channel", "event"}, "key1", "data1")
 449         assert.Nil(t, err)
 450         m.AssertExpectations(t)
 451 }
 452
 453 func TestWriteAndPublishSeveralChannelsAndEvents(t *testing.T) {
 454         m, i := setup()
 455
 456         expectedChannelsAndEvents := []string{"{namespace},channel1", "event1___event2",
 457                 "{namespace},channel2", "event3___event4"}
 458         expectedKeyVal := []interface{}{"{namespace},key", "data"}
 459
 460         verifyChannelAndEvent := func(input []string) bool {
 461                 return verifySliceInOrder(input, expectedChannelsAndEvents)
 462         }
 463         m.On("MSetMPub", mock.MatchedBy(verifyChannelAndEvent), expectedKeyVal).Return(nil)
 464         m.AssertNotCalled(t, "MSet", expectedKeyVal)
 465         err := i.SetAndPublish([]string{"channel1", "event1", "channel2", "event3", "channel1", "event2", "channel2", "event4"},
 466                 "key", "data")
 467         assert.Nil(t, err)
 468         m.AssertExpectations(t)
 469 }
 470
 471 func TestWriteAndPublishOneKeyOneChannelTwoEvents(t *testing.T) {
 472         m, i := setup()
 473
 474         expectedChannelAndEvents := []string{"{namespace},channel", "event1___event2"}
 475         expectedKeyVal := []interface{}{"{namespace},key1", "data1"}
 476
 477         m.On("MSetMPub", expectedChannelAndEvents, expectedKeyVal).Return(nil)
 478         m.AssertNotCalled(t, "MSet", expectedKeyVal)
 479         err := i.SetAndPublish([]string{"channel", "event1", "channel", "event2"}, "key1", "data1")
 480         assert.Nil(t, err)
 481         m.AssertExpectations(t)
 482 }
 483
 484 func TestWriteAndPublishIncorrectChannelAndEvent(t *testing.T) {
 485         m, i := setup()
 486
 487         expectedChannelAndEvent := []string{}
 488         expectedKeyVal := []interface{}{"{namespace},key1", "data1"}
 489         m.AssertNotCalled(t, "MSetMPub", expectedChannelAndEvent, expectedKeyVal)
 490         m.AssertNotCalled(t, "MSet", expectedKeyVal)
 491         err := i.SetAndPublish([]string{"channel", "event1", "channel"}, "key1", "data1")
 492         assert.NotNil(t, err)
 493         m.AssertExpectations(t)
 494 }
 495
 496 func TestWriteAndPublishNotAllowedCharactersInEvents(t *testing.T) {
 497         m, i := setup()
 498
 499         expectedChannelAndEvent := []string{}
 500         expectedKeyVal := []interface{}{"{namespace},key1", "data1"}
 501         m.AssertNotCalled(t, "MSetMPub", expectedChannelAndEvent, expectedKeyVal)
 502         m.AssertNotCalled(t, "MSet", expectedKeyVal)
 503         err := i.SetAndPublish([]string{"channel", "event1___event2"}, "key1", "data1")
 504         assert.NotNil(t, err)
 505         m.AssertExpectations(t)
 506 }
 507
 508 func TestWriteAndPublishNoData(t *testing.T) {
 509         m, i := setup()
 510
 511         expectedChannelAndEvent := []string{}
 512         expectedKeyVal := []interface{}{"key"}
 513
 514         m.AssertNotCalled(t, "MSetMPub", expectedChannelAndEvent, expectedKeyVal)
 515         m.AssertNotCalled(t, "MSet", expectedKeyVal)
 516         err := i.SetAndPublish([]string{"channel", "event"}, []interface{}{"key"})
 517         assert.NotNil(t, err)
 518         m.AssertExpectations(t)
 519 }
 520
 521 func TestWriteAndPublishNoChannelEvent(t *testing.T) {
 522         m, i := setup()
 523
 524         expectedKeyVal := []interface{}{"{namespace},key1", "data1"}
 525
 526         m.On("MSet", expectedKeyVal).Return(nil)
 527         m.AssertNotCalled(t, "MSetMPub", "", "", expectedKeyVal)
 528         err := i.SetAndPublish([]string{}, "key1", "data1")
 529         assert.Nil(t, err)
 530         m.AssertExpectations(t)
 531
 532 }
 533
 534 func TestRemoveAndPublishSuccessfully(t *testing.T) {
 535         m, i := setup()
 536
 537         expectedChannelAndEvent := []string{"{namespace},channel", "event"}
 538         expectedKeys := []string{"{namespace},key1", "{namespace},key2"}
 539
 540         m.On("DelMPub", expectedChannelAndEvent, expectedKeys).Return(nil)
 541         err := i.RemoveAndPublish([]string{"channel", "event"}, []string{"key1", "key2"})
 542         assert.Nil(t, err)
 543         m.AssertExpectations(t)
 544 }
 545
 546 func TestRemoveAndPublishSeveralChannelsAndEventsSuccessfully(t *testing.T) {
 547         m, i := setup()
 548
 549         expectedChannelAndEvent := []string{"{namespace},channel1", "event1___event2",
 550                 "{namespace},channel2", "event3___event4"}
 551         expectedKeys := []string{"{namespace},key1", "{namespace},key2"}
 552
 553         verifyChannelAndEvent := func(input []string) bool {
 554                 return verifySliceInOrder(input, expectedChannelAndEvent)
 555         }
 556         m.On("DelMPub", mock.MatchedBy(verifyChannelAndEvent), expectedKeys).Return(nil)
 557         err := i.RemoveAndPublish([]string{"channel1", "event1", "channel2", "event3",
 558                 "channel1", "event2", "channel2", "event4"},
 559                 []string{"key1", "key2"})
 560         assert.Nil(t, err)
 561         m.AssertExpectations(t)
 562 }
 563 func TestRemoveAndPublishFail(t *testing.T) {
 564         m, i := setup()
 565
 566         expectedChannelAndEvent := []string{"{namespace},channel", "event"}
 567         expectedKeys := []string{"{namespace},key1", "{namespace},key2"}
 568
 569         m.On("DelMPub", expectedChannelAndEvent, expectedKeys).Return(errors.New("Some error"))
 570         err := i.RemoveAndPublish([]string{"channel", "event"}, []string{"key1", "key2"})
 571         assert.NotNil(t, err)
 572         m.AssertExpectations(t)
 573 }
 574
 575 func TestRemoveAndPublishNoChannels(t *testing.T) {
 576         m, i := setup()
 577
 578         expectedKeys := []string{"{namespace},key1", "{namespace},key2"}
 579
 580         m.On("Del", expectedKeys).Return(nil)
 581         err := i.RemoveAndPublish([]string{}, []string{"key1", "key2"})
 582         assert.Nil(t, err)
 583         m.AssertExpectations(t)
 584 }
 585
 586 func TestRemoveAndPublishIncorrectChannel(t *testing.T) {
 587         m, i := setup()
 588
 589         notExpectedChannelAndEvent := []string{}
 590         notExpectedKeys := []string{"{namespace},key"}
 591
 592         m.AssertNotCalled(t, "DelMPub", notExpectedChannelAndEvent, notExpectedKeys)
 593         m.AssertNotCalled(t, "Del", notExpectedKeys)
 594         err := i.RemoveAndPublish([]string{"channel", "event", "channel2"}, []string{})
 595         assert.Nil(t, err)
 596         m.AssertExpectations(t)
 597
 598 }
 599 func TestRemoveAndPublishNoKeys(t *testing.T) {
 600         m, i := setup()
 601
 602         notExpectedChannelAndEvent := []string{}
 603         notExpectedKeys := []string{"{namespace},key"}
 604
 605         m.AssertNotCalled(t, "DelMPub", notExpectedChannelAndEvent, notExpectedKeys)
 606         m.AssertNotCalled(t, "Del", notExpectedKeys)
 607         err := i.RemoveAndPublish([]string{"channel", "event"}, []string{})
 608         assert.Nil(t, err)
 609         m.AssertExpectations(t)
 610 }
 611 func TestRemoveAndPublishNoChannelsError(t *testing.T) {
 612         m, i := setup()
 613
 614         expectedKeys := []string{"{namespace},key1", "{namespace},key2"}
 615
 616         m.On("Del", expectedKeys).Return(errors.New("Some error"))
 617         err := i.RemoveAndPublish([]string{}, []string{"key1", "key2"})
 618         assert.NotNil(t, err)
 619         m.AssertExpectations(t)
 620 }
 621 func TestRemoveSuccessfully(t *testing.T) {
 622         m, i := setup()
 623
 624         msetExpected := []string{"{namespace},key1", "{namespace},key2"}
 625         m.On("Del", msetExpected).Return(nil)
 626
 627         err := i.Remove([]string{"key1", "key2"})
 628         assert.Nil(t, err)
 629         m.AssertExpectations(t)
 630 }
 631
 632 func TestRemoveFail(t *testing.T) {
 633         m, i := setup()
 634
 635         msetExpected := []string{"{namespace},key"}
 636         m.On("Del", msetExpected).Return(errors.New("Some error"))
 637
 638         err := i.Remove([]string{"key"})
 639         assert.NotNil(t, err)
 640         m.AssertExpectations(t)
 641 }
 642
 643 func TestRemoveEmptyList(t *testing.T) {
 644         m, i := setup()
 645
 646         err := i.Remove([]string{})
 647         assert.Nil(t, err)
 648         m.AssertNotCalled(t, "Del", []string{})
 649 }
 650
 651 func TestGetAllSuccessfully(t *testing.T) {
 652         m, i := setup()
 653
 654         mKeysExpected := string("{namespace},*")
 655         mReturnExpected := []string{"{namespace},key1", "{namespace},key2"}
 656         expectedReturn := []string{"key1", "key2"}
 657         m.On("Keys", mKeysExpected).Return(mReturnExpected, nil)
 658         retVal, err := i.GetAll()
 659         assert.Nil(t, err)
 660         assert.Equal(t, expectedReturn, retVal)
 661         m.AssertExpectations(t)
 662 }
 663
 664 func TestGetAllFail(t *testing.T) {
 665         m, i := setup()
 666
 667         mKeysExpected := string("{namespace},*")
 668         mReturnExpected := []string{}
 669         m.On("Keys", mKeysExpected).Return(mReturnExpected, errors.New("some error"))
 670         retVal, err := i.GetAll()
 671         assert.NotNil(t, err)
 672         assert.Nil(t, retVal)
 673         assert.Equal(t, len(retVal), 0)
 674         m.AssertExpectations(t)
 675 }
 676
 677 func TestGetAllReturnEmpty(t *testing.T) {
 678         m, i := setup()
 679
 680         mKeysExpected := string("{namespace},*")
 681         var mReturnExpected []string = nil
 682         m.On("Keys", mKeysExpected).Return(mReturnExpected, nil)
 683         retVal, err := i.GetAll()
 684         assert.Nil(t, err)
 685         assert.Nil(t, retVal)
 686         assert.Equal(t, len(retVal), 0)
 687         m.AssertExpectations(t)
 688
 689 }
 690
 691 func TestRemoveAllSuccessfully(t *testing.T) {
 692         m, i := setup()
 693
 694         mKeysExpected := string("{namespace},*")
 695         mKeysReturn := []string{"{namespace},key1", "{namespace},key2"}
 696         mDelExpected := mKeysReturn
 697         m.On("Keys", mKeysExpected).Return(mKeysReturn, nil)
 698         m.On("Del", mDelExpected).Return(nil)
 699         err := i.RemoveAll()
 700         assert.Nil(t, err)
 701         m.AssertExpectations(t)
 702 }
 703
 704 func TestRemoveAllNoKeysFound(t *testing.T) {
 705         m, i := setup()
 706
 707         mKeysExpected := string("{namespace},*")
 708         var mKeysReturn []string = nil
 709         m.On("Keys", mKeysExpected).Return(mKeysReturn, nil)
 710         m.AssertNumberOfCalls(t, "Del", 0)
 711         err := i.RemoveAll()
 712         assert.Nil(t, err)
 713         m.AssertExpectations(t)
 714 }
 715
 716 func TestRemoveAllKeysReturnError(t *testing.T) {
 717         m, i := setup()
 718
 719         mKeysExpected := string("{namespace},*")
 720         var mKeysReturn []string = nil
 721         m.On("Keys", mKeysExpected).Return(mKeysReturn, errors.New("Some error"))
 722         m.AssertNumberOfCalls(t, "Del", 0)
 723         err := i.RemoveAll()
 724         assert.NotNil(t, err)
 725         m.AssertExpectations(t)
 726 }
 727
 728 func TestRemoveAllDelReturnError(t *testing.T) {
 729         m, i := setup()
 730
 731         mKeysExpected := string("{namespace},*")
 732         mKeysReturn := []string{"{namespace},key1", "{namespace},key2"}
 733         mDelExpected := mKeysReturn
 734         m.On("Keys", mKeysExpected).Return(mKeysReturn, nil)
 735         m.On("Del", mDelExpected).Return(errors.New("Some Error"))
 736         err := i.RemoveAll()
 737         assert.NotNil(t, err)
 738         m.AssertExpectations(t)
 739 }
 740
 741 func TestSetIfSuccessfullyOkStatus(t *testing.T) {
 742         m, i := setup()
 743
 744         mSetIEExpectedKey := string("{namespace},key1")
 745         mSetIEExpectedOldData := interface{}("olddata")
 746         mSetIEExpectedNewData := interface{}("newdata")
 747         m.On("SetIE", mSetIEExpectedKey, mSetIEExpectedOldData, mSetIEExpectedNewData).Return(true, nil)
 748         status, err := i.SetIf("key1", "olddata", "newdata")
 749         assert.Nil(t, err)
 750         assert.True(t, status)
 751         m.AssertExpectations(t)
 752 }
 753
 754 func TestSetIfSuccessfullyNOKStatus(t *testing.T) {
 755         m, i := setup()
 756
 757         mSetIEExpectedKey := string("{namespace},key1")
 758         mSetIEExpectedOldData := interface{}("olddata")
 759         mSetIEExpectedNewData := interface{}("newdata")
 760         m.On("SetIE", mSetIEExpectedKey, mSetIEExpectedOldData, mSetIEExpectedNewData).Return(false, nil)
 761         status, err := i.SetIf("key1", "olddata", "newdata")
 762         assert.Nil(t, err)
 763         assert.False(t, status)
 764         m.AssertExpectations(t)
 765 }
 766
 767 func TestSetIfFailure(t *testing.T) {
 768         m, i := setup()
 769
 770         mSetIEExpectedKey := string("{namespace},key1")
 771         mSetIEExpectedOldData := interface{}("olddata")
 772         mSetIEExpectedNewData := interface{}("newdata")
 773         m.On("SetIE", mSetIEExpectedKey, mSetIEExpectedOldData, mSetIEExpectedNewData).Return(false, errors.New("Some error"))
 774         status, err := i.SetIf("key1", "olddata", "newdata")
 775         assert.NotNil(t, err)
 776         assert.False(t, status)
 777         m.AssertExpectations(t)
 778 }
 779
 780 func TestSetIfAndPublishSuccessfully(t *testing.T) {
 781         m, i := setup()
 782
 783         expectedChannelAndEvent := []string{"{namespace},channel", "event"}
 784         expectedKey := "{namespace},key"
 785         expectedOldData := interface{}("olddata")
 786         expectedNewData := interface{}("newdata")
 787         m.On("SetIEPub", expectedChannelAndEvent, expectedKey, expectedOldData, expectedNewData).Return(true, nil)
 788         status, err := i.SetIfAndPublish([]string{"channel", "event"}, "key", "olddata", "newdata")
 789         assert.Nil(t, err)
 790         assert.True(t, status)
 791         m.AssertExpectations(t)
 792 }
 793
 794 func TestSetIfAndPublishIncorrectChannelAndEvent(t *testing.T) {
 795         m, i := setup()
 796
 797         expectedChannelAndEvent := []string{"{namespace},channel", "event"}
 798         expectedKey := "{namespace},key"
 799         expectedOldData := interface{}("olddata")
 800         expectedNewData := interface{}("newdata")
 801         m.AssertNotCalled(t, "SetIEPub", expectedChannelAndEvent, expectedKey, expectedOldData, expectedNewData)
 802         m.AssertNotCalled(t, "SetIE", expectedKey, expectedOldData, expectedNewData)
 803         status, err := i.SetIfAndPublish([]string{"channel", "event1", "channel"}, "key", "olddata", "newdata")
 804         assert.NotNil(t, err)
 805         assert.False(t, status)
 806         m.AssertExpectations(t)
 807 }
 808 func TestSetIfAndPublishNOKStatus(t *testing.T) {
 809         m, i := setup()
 810
 811         expectedChannelAndEvent := []string{"{namespace},channel", "event"}
 812         expectedKey := "{namespace},key"
 813         expectedOldData := interface{}("olddata")
 814         expectedNewData := interface{}("newdata")
 815         m.On("SetIEPub", expectedChannelAndEvent, expectedKey, expectedOldData, expectedNewData).Return(false, nil)
 816         status, err := i.SetIfAndPublish([]string{"channel", "event"}, "key", "olddata", "newdata")
 817         assert.Nil(t, err)
 818         assert.False(t, status)
 819         m.AssertExpectations(t)
 820 }
 821
 822 func TestSetIfAndPublishNoChannels(t *testing.T) {
 823         m, i := setup()
 824
 825         expectedKey := "{namespace},key"
 826         expectedOldData := interface{}("olddata")
 827         expectedNewData := interface{}("newdata")
 828         m.On("SetIE", expectedKey, expectedOldData, expectedNewData).Return(true, nil)
 829         status, err := i.SetIfAndPublish([]string{}, "key", "olddata", "newdata")
 830         assert.Nil(t, err)
 831         assert.True(t, status)
 832         m.AssertExpectations(t)
 833 }
 834
 835 func TestSetIfNotExistsAndPublishSuccessfully(t *testing.T) {
 836         m, i := setup()
 837
 838         expectedChannelAndEvent := []string{"{namespace},channel", "event"}
 839         expectedKey := "{namespace},key"
 840         expectedData := interface{}("data")
 841
 842         m.On("SetNXPub", expectedChannelAndEvent, expectedKey, expectedData).Return(true, nil)
 843         status, err := i.SetIfNotExistsAndPublish([]string{"channel", "event"}, "key", "data")
 844         assert.Nil(t, err)
 845         assert.True(t, status)
 846         m.AssertExpectations(t)
 847 }
 848
 849 func TestSetIfNotExistsAndPublishSeveralEvents(t *testing.T) {
 850         m, i := setup()
 851
 852         expectedChannelAndEvent := []string{"{namespace},channel", "event1___event2"}
 853         expectedKey := "{namespace},key"
 854         expectedData := interface{}("data")
 855
 856         m.On("SetNXPub", expectedChannelAndEvent, expectedKey, expectedData).Return(true, nil)
 857         status, err := i.SetIfNotExistsAndPublish([]string{"channel", "event1", "channel", "event2"}, "key", "data")
 858         assert.Nil(t, err)
 859         assert.True(t, status)
 860         m.AssertExpectations(t)
 861 }
 862
 863 func TestSetIfNotExistsAndPublishNoChannels(t *testing.T) {
 864         m, i := setup()
 865
 866         expectedKey := "{namespace},key"
 867         expectedData := interface{}("data")
 868
 869         m.On("SetNX", expectedKey, expectedData, time.Duration(0)).Return(true, nil)
 870         status, err := i.SetIfNotExistsAndPublish([]string{}, "key", "data")
 871         assert.Nil(t, err)
 872         assert.True(t, status)
 873         m.AssertExpectations(t)
 874 }
 875
 876 func TestSetIfNotExistsAndPublishFail(t *testing.T) {
 877         m, i := setup()
 878
 879         expectedChannelAndEvent := []string{"{namespace},channel", "event"}
 880         expectedKey := "{namespace},key"
 881         expectedData := interface{}("data")
 882
 883         m.On("SetNXPub", expectedChannelAndEvent, expectedKey, expectedData).Return(false, nil)
 884         status, err := i.SetIfNotExistsAndPublish([]string{"channel", "event"}, "key", "data")
 885         assert.Nil(t, err)
 886         assert.False(t, status)
 887         m.AssertExpectations(t)
 888 }
 889
 890 func TestSetIfNotExistsAndPublishIncorrectChannels(t *testing.T) {
 891         m, i := setup()
 892
 893         expectedChannelAndEvent := []string{"{namespace},channel", "event"}
 894         expectedKey := "{namespace},key"
 895         expectedData := interface{}("data")
 896
 897         m.AssertNotCalled(t, "SetNXPub", expectedChannelAndEvent, expectedKey, expectedData)
 898         m.AssertNotCalled(t, "SetNX", expectedKey, expectedData, 0)
 899         status, err := i.SetIfNotExistsAndPublish([]string{"channel", "event", "channel2"}, "key", "data")
 900         assert.NotNil(t, err)
 901         assert.False(t, status)
 902         m.AssertExpectations(t)
 903 }
 904
 905 func TestSetIfNotExistsAndPublishError(t *testing.T) {
 906         m, i := setup()
 907
 908         expectedChannelAndEvent := []string{"{namespace},channel", "event"}
 909         expectedKey := "{namespace},key"
 910         expectedData := interface{}("data")
 911
 912         m.On("SetNXPub", expectedChannelAndEvent, expectedKey, expectedData).Return(false, errors.New("Some error"))
 913         status, err := i.SetIfNotExistsAndPublish([]string{"channel", "event"}, "key", "data")
 914         assert.NotNil(t, err)
 915         assert.False(t, status)
 916         m.AssertExpectations(t)
 917 }
 918
 919 func TestSetIfNotExistsSuccessfullyOkStatus(t *testing.T) {
 920         m, i := setup()
 921
 922         mSetNXExpectedKey := string("{namespace},key1")
 923         mSetNXExpectedData := interface{}("data")
 924         m.On("SetNX", mSetNXExpectedKey, mSetNXExpectedData, time.Duration(0)).Return(true, nil)
 925         status, err := i.SetIfNotExists("key1", "data")
 926         assert.Nil(t, err)
 927         assert.True(t, status)
 928         m.AssertExpectations(t)
 929 }
 930
 931 func TestSetIfNotExistsSuccessfullyNOKStatus(t *testing.T) {
 932         m, i := setup()
 933
 934         mSetNXExpectedKey := string("{namespace},key1")
 935         mSetNXExpectedData := interface{}("data")
 936         m.On("SetNX", mSetNXExpectedKey, mSetNXExpectedData, time.Duration(0)).Return(false, nil)
 937         status, err := i.SetIfNotExists("key1", "data")
 938         assert.Nil(t, err)
 939         assert.False(t, status)
 940         m.AssertExpectations(t)
 941 }
 942
 943 func TestSetIfNotExistsFailure(t *testing.T) {
 944         m, i := setup()
 945
 946         mSetNXExpectedKey := string("{namespace},key1")
 947         mSetNXExpectedData := interface{}("data")
 948         m.On("SetNX", mSetNXExpectedKey, mSetNXExpectedData, time.Duration(0)).Return(false, errors.New("Some error"))
 949         status, err := i.SetIfNotExists("key1", "data")
 950         assert.NotNil(t, err)
 951         assert.False(t, status)
 952         m.AssertExpectations(t)
 953 }
 954
 955 func TestRemoveIfAndPublishSuccessfully(t *testing.T) {
 956         m, i := setup()
 957
 958         expectedChannelAndEvent := []string{"{namespace},channel", "event1___event2"}
 959         expectedKey := "{namespace},key"
 960         expectedValue := interface{}("data")
 961
 962         m.On("DelIEPub", expectedChannelAndEvent, expectedKey, expectedValue).Return(true, nil)
 963         status, err := i.RemoveIfAndPublish([]string{"channel", "event1", "channel", "event2"}, "key", "data")
 964         assert.Nil(t, err)
 965         assert.True(t, status)
 966         m.AssertExpectations(t)
 967 }
 968
 969 func TestRemoveIfAndPublishNok(t *testing.T) {
 970         m, i := setup()
 971
 972         expectedChannelAndEvent := []string{"{namespace},channel", "event1___event2"}
 973         expectedKey := "{namespace},key"
 974         expectedValue := interface{}("data")
 975
 976         m.On("DelIEPub", expectedChannelAndEvent, expectedKey, expectedValue).Return(false, nil)
 977         status, err := i.RemoveIfAndPublish([]string{"channel", "event1", "channel", "event2"}, "key", "data")
 978         assert.Nil(t, err)
 979         assert.False(t, status)
 980         m.AssertExpectations(t)
 981 }
 982
 983 func TestRemoveIfAndPublishError(t *testing.T) {
 984         m, i := setup()
 985
 986         expectedChannelAndEvent := []string{"{namespace},channel", "event1___event2"}
 987         expectedKey := "{namespace},key"
 988         expectedValue := interface{}("data")
 989
 990         m.On("DelIEPub", expectedChannelAndEvent, expectedKey, expectedValue).Return(false, errors.New("Some error"))
 991         status, err := i.RemoveIfAndPublish([]string{"channel", "event1", "channel", "event2"}, "key", "data")
 992         assert.NotNil(t, err)
 993         assert.False(t, status)
 994         m.AssertExpectations(t)
 995 }
 996
 997 func TestRemoveIfAndPublishIncorrectChannel(t *testing.T) {
 998         m, i := setup()
 999
1000         expectedChannelAndEvent := []string{"{namespace},channel", "event"}
1001         expectedKey := "{namespace},key"
1002         expectedValue := interface{}("data")
1003
1004         m.AssertNotCalled(t, "DelIEPub", expectedChannelAndEvent, expectedKey, expectedValue)
1005         m.AssertNotCalled(t, "DelIE", expectedKey, expectedValue)
1006         status, err := i.RemoveIfAndPublish([]string{"channel", "event1", "channel"}, "key", "data")
1007         assert.NotNil(t, err)
1008         assert.False(t, status)
1009         m.AssertExpectations(t)
1010 }
1011
1012 func TestRemoveIfAndPublishNoChannels(t *testing.T) {
1013         m, i := setup()
1014
1015         expectedKey := "{namespace},key"
1016         expectedValue := interface{}("data")
1017
1018         m.On("DelIE", expectedKey, expectedValue).Return(true, nil)
1019         status, err := i.RemoveIfAndPublish([]string{}, "key", "data")
1020         assert.Nil(t, err)
1021         assert.True(t, status)
1022         m.AssertExpectations(t)
1023
1024 }
1025 func TestRemoveIfSuccessfullyOkStatus(t *testing.T) {
1026         m, i := setup()
1027
1028         mDelIEExpectedKey := string("{namespace},key1")
1029         mDelIEExpectedData := interface{}("data")
1030         m.On("DelIE", mDelIEExpectedKey, mDelIEExpectedData).Return(true, nil)
1031         status, err := i.RemoveIf("key1", "data")
1032         assert.Nil(t, err)
1033         assert.True(t, status)
1034         m.AssertExpectations(t)
1035 }
1036
1037 func TestRemoveIfSuccessfullyNOKStatus(t *testing.T) {
1038         m, i := setup()
1039
1040         mDelIEExpectedKey := string("{namespace},key1")
1041         mDelIEExpectedData := interface{}("data")
1042         m.On("DelIE", mDelIEExpectedKey, mDelIEExpectedData).Return(false, nil)
1043         status, err := i.RemoveIf("key1", "data")
1044         assert.Nil(t, err)
1045         assert.False(t, status)
1046         m.AssertExpectations(t)
1047 }
1048
1049 func TestRemoveIfFailure(t *testing.T) {
1050         m, i := setup()
1051
1052         mDelIEExpectedKey := string("{namespace},key1")
1053         mDelIEExpectedData := interface{}("data")
1054         m.On("DelIE", mDelIEExpectedKey, mDelIEExpectedData).Return(true, errors.New("Some error"))
1055         status, err := i.RemoveIf("key1", "data")
1056         assert.NotNil(t, err)
1057         assert.False(t, status)
1058         m.AssertExpectations(t)
1059 }
1060
1061 func TestRemoveAllAndPublishSuccessfully(t *testing.T) {
1062         m, i := setup()
1063
1064         mKeysExpected := string("{namespace},*")
1065         mKeysReturn := []string{"{namespace},key1", "{namespace},key2"}
1066         mDelExpected := mKeysReturn
1067         expectedChannelAndEvent := []string{"{namespace},channel", "event"}
1068         m.On("Keys", mKeysExpected).Return(mKeysReturn, nil)
1069         m.On("DelMPub", expectedChannelAndEvent, mDelExpected).Return(nil)
1070         err := i.RemoveAllAndPublish([]string{"channel", "event"})
1071         assert.Nil(t, err)
1072         m.AssertExpectations(t)
1073 }
1074
1075 func TestRemoveAllAndPublishKeysReturnError(t *testing.T) {
1076         m, i := setup()
1077
1078         mKeysExpected := string("{namespace},*")
1079         mKeysReturn := []string{"{namespace},key1", "{namespace},key2"}
1080         mDelExpected := mKeysReturn
1081         expectedChannelAndEvent := []string{"{namespace},channel", "event"}
1082         m.On("Keys", mKeysExpected).Return(mKeysReturn, errors.New("Some error"))
1083         m.AssertNotCalled(t, "DelMPub", expectedChannelAndEvent, mDelExpected)
1084         err := i.RemoveAllAndPublish([]string{"channel", "event"})
1085         assert.NotNil(t, err)
1086         m.AssertExpectations(t)
1087 }
1088
1089 func TestRemoveAllAndPublishKeysDelReturnsError(t *testing.T) {
1090         m, i := setup()
1091
1092         mKeysExpected := string("{namespace},*")
1093         mKeysReturn := []string{"{namespace},key1", "{namespace},key2"}
1094         mDelExpected := mKeysReturn
1095         expectedChannelAndEvent := []string{"{namespace},channel", "event"}
1096         m.On("Keys", mKeysExpected).Return(mKeysReturn, nil)
1097         m.On("DelMPub", expectedChannelAndEvent, mDelExpected).Return(errors.New("Some error"))
1098         err := i.RemoveAllAndPublish([]string{"channel", "event"})
1099         assert.NotNil(t, err)
1100         m.AssertExpectations(t)
1101 }
1102
1103 func TestRemoveAllAndPublishKeysEventsWithIllegalCharacters(t *testing.T) {
1104         m, i := setup()
1105
1106         mKeysExpected := string("{namespace},*")
1107         mKeysReturn := []string{"{namespace},key1", "{namespace},key2"}
1108         mDelExpected := mKeysReturn
1109         expectedChannelAndEvent := []string{"{namespace},channel", "event"}
1110         m.On("Keys", mKeysExpected).Return(mKeysReturn, nil)
1111         m.AssertNotCalled(t, "DelMPub", expectedChannelAndEvent, mDelExpected)
1112         err := i.RemoveAllAndPublish([]string{"channel", "event___anotherEvent"})
1113         assert.NotNil(t, err)
1114         m.AssertExpectations(t)
1115
1116 }
1117
1118 func TestRemoveAllAndPublishNoChannels(t *testing.T) {
1119         m, i := setup()
1120
1121         mKeysExpected := string("{namespace},*")
1122         mKeysReturn := []string{"{namespace},key1", "{namespace},key2"}
1123         mDelExpected := mKeysReturn
1124         m.On("Keys", mKeysExpected).Return(mKeysReturn, nil)
1125         m.On("Del", mDelExpected).Return(nil)
1126         m.AssertNotCalled(t, "DelMPub", "", "", mDelExpected)
1127         err := i.RemoveAllAndPublish([]string{})
1128         assert.Nil(t, err)
1129         m.AssertExpectations(t)
1130 }
1131
1132 func TestRemoveAllAndPublishIncorrectChannel(t *testing.T) {
1133         m, i := setup()
1134
1135         mKeysExpected := string("{namespace},*")
1136         mKeysReturn := []string{"{namespace},key1", "{namespace},key2"}
1137         mDelExpected := mKeysReturn
1138         m.On("Keys", mKeysExpected).Return(mKeysReturn, nil)
1139         m.AssertNotCalled(t, "DelMPub", "", "", mDelExpected)
1140         err := i.RemoveAllAndPublish([]string{"channel", "event", "channel2"})
1141         assert.NotNil(t, err)
1142         m.AssertExpectations(t)
1143
1144 }
1145
1146 func TestAddMemberSuccessfully(t *testing.T) {
1147         m, i := setup()
1148
1149         groupExpected := string("{namespace},group")
1150         membersExpected := []interface{}{"member1", "member2"}
1151
1152         m.On("SAdd", groupExpected, membersExpected).Return(nil)
1153
1154         err := i.AddMember("group", "member1", "member2")
1155         assert.Nil(t, err)
1156         m.AssertExpectations(t)
1157 }
1158
1159 func TestAddMemberFail(t *testing.T) {
1160         m, i := setup()
1161
1162         groupExpected := string("{namespace},group")
1163         membersExpected := []interface{}{"member1", "member2"}
1164
1165         m.On("SAdd", groupExpected, membersExpected).Return(errors.New("Some error"))
1166
1167         err := i.AddMember("group", "member1", "member2")
1168         assert.NotNil(t, err)
1169         m.AssertExpectations(t)
1170 }
1171 func TestRemoveMemberSuccessfully(t *testing.T) {
1172         m, i := setup()
1173
1174         groupExpected := string("{namespace},group")
1175         membersExpected := []interface{}{"member1", "member2"}
1176
1177         m.On("SRem", groupExpected, membersExpected).Return(nil)
1178
1179         err := i.RemoveMember("group", "member1", "member2")
1180         assert.Nil(t, err)
1181         m.AssertExpectations(t)
1182 }
1183
1184 func TestRemoveMemberFail(t *testing.T) {
1185         m, i := setup()
1186
1187         groupExpected := string("{namespace},group")
1188         membersExpected := []interface{}{"member1", "member2"}
1189
1190         m.On("SRem", groupExpected, membersExpected).Return(errors.New("Some error"))
1191
1192         err := i.RemoveMember("group", "member1", "member2")
1193         assert.NotNil(t, err)
1194         m.AssertExpectations(t)
1195 }
1196
1197 func TestRemoveGroupSuccessfully(t *testing.T) {
1198         m, i := setup()
1199
1200         groupExpected := []string{"{namespace},group"}
1201
1202         m.On("Del", groupExpected).Return(nil)
1203
1204         err := i.RemoveGroup("group")
1205         assert.Nil(t, err)
1206         m.AssertExpectations(t)
1207 }
1208 func TestRemoveGroupFail(t *testing.T) {
1209         m, i := setup()
1210
1211         groupExpected := []string{"{namespace},group"}
1212
1213         m.On("Del", groupExpected).Return(errors.New("Some error"))
1214
1215         err := i.RemoveGroup("group")
1216         assert.NotNil(t, err)
1217         m.AssertExpectations(t)
1218 }
1219
1220 func TestGetMembersSuccessfully(t *testing.T) {
1221         m, i := setup()
1222
1223         groupExpected := "{namespace},group"
1224         returnExpected := []string{"member1", "member2"}
1225
1226         m.On("SMembers", groupExpected).Return(returnExpected, nil)
1227
1228         result, err := i.GetMembers("group")
1229         assert.Nil(t, err)
1230         assert.Equal(t, result, returnExpected)
1231         m.AssertExpectations(t)
1232 }
1233 func TestGetMembersFail(t *testing.T) {
1234         m, i := setup()
1235
1236         groupExpected := "{namespace},group"
1237         returnExpected := []string{"member1", "member2"}
1238
1239         m.On("SMembers", groupExpected).Return(returnExpected, errors.New("Some error"))
1240
1241         result, err := i.GetMembers("group")
1242         assert.NotNil(t, err)
1243         assert.Equal(t, []string{}, result)
1244         m.AssertExpectations(t)
1245 }
1246
1247 func TestIsMemberSuccessfullyIsMember(t *testing.T) {
1248         m, i := setup()
1249
1250         groupExpected := "{namespace},group"
1251         memberExpected := "member"
1252
1253         m.On("SIsMember", groupExpected, memberExpected).Return(true, nil)
1254
1255         result, err := i.IsMember("group", "member")
1256         assert.Nil(t, err)
1257         assert.True(t, result)
1258         m.AssertExpectations(t)
1259 }
1260 func TestIsMemberSuccessfullyIsNotMember(t *testing.T) {
1261         m, i := setup()
1262
1263         groupExpected := "{namespace},group"
1264         memberExpected := "member"
1265
1266         m.On("SIsMember", groupExpected, memberExpected).Return(false, nil)
1267
1268         result, err := i.IsMember("group", "member")
1269         assert.Nil(t, err)
1270         assert.False(t, result)
1271         m.AssertExpectations(t)
1272 }
1273 func TestIsMemberFailure(t *testing.T) {
1274         m, i := setup()
1275
1276         groupExpected := "{namespace},group"
1277         memberExpected := "member"
1278
1279         m.On("SIsMember", groupExpected, memberExpected).Return(true, errors.New("Some error"))
1280
1281         result, err := i.IsMember("group", "member")
1282         assert.NotNil(t, err)
1283         assert.False(t, result)
1284         m.AssertExpectations(t)
1285 }
1286
1287 func TestGroupSizeSuccessfully(t *testing.T) {
1288         m, i := setup()
1289
1290         var expectedSize int64
1291         expectedSize = 2
1292         groupExpected := "{namespace},group"
1293
1294         m.On("SCard", groupExpected).Return(expectedSize, nil)
1295
1296         result, err := i.GroupSize("group")
1297         assert.Nil(t, err)
1298         assert.Equal(t, expectedSize, result)
1299         m.AssertExpectations(t)
1300 }
1301 func TestGroupSizeFail(t *testing.T) {
1302         m, i := setup()
1303
1304         var expectedSize int64
1305         expectedSize = 2
1306         groupExpected := "{namespace},group"
1307
1308         m.On("SCard", groupExpected).Return(expectedSize, errors.New("Some error"))
1309
1310         result, err := i.GroupSize("group")
1311         assert.NotNil(t, err)
1312         assert.Equal(t, int64(0), result)
1313         m.AssertExpectations(t)
1314 }
1315
1316 func TestLockResourceSuccessfully(t *testing.T) {
1317         m, i := setup()
1318
1319         resourceExpected := "{namespace},resource"
1320         m.On("SetNX", resourceExpected, mock.Anything, time.Duration(1)).Return(true, nil)
1321
1322         lock, err := i.LockResource("resource", time.Duration(1), &sdlgo.Options{})
1323         assert.Nil(t, err)
1324         assert.NotNil(t, lock)
1325         m.AssertExpectations(t)
1326 }
1327
1328 func TestLockResourceFailure(t *testing.T) {
1329         m, i := setup()
1330
1331         resourceExpected := "{namespace},resource"
1332         m.On("SetNX", resourceExpected, mock.Anything, time.Duration(1)).Return(true, errors.New("Some error"))
1333
1334         lock, err := i.LockResource("resource", time.Duration(1), &sdlgo.Options{})
1335         assert.NotNil(t, err)
1336         assert.Nil(t, lock)
1337         m.AssertExpectations(t)
1338 }
1339
1340 func TestLockResourceTrySeveralTimesSuccessfully(t *testing.T) {
1341         m, i := setup()
1342
1343         resourceExpected := "{namespace},resource"
1344         m.On("SetNX", resourceExpected, mock.Anything, time.Duration(1)).Return(false, nil).Once()
1345         m.On("SetNX", resourceExpected, mock.Anything, time.Duration(1)).Return(true, nil).Once()
1346
1347         lock, err := i.LockResource("resource", time.Duration(1), &sdlgo.Options{
1348                 RetryCount: 2,
1349         })
1350         assert.Nil(t, err)
1351         assert.NotNil(t, lock)
1352         m.AssertExpectations(t)
1353 }
1354
1355 func TestLockResourceTrySeveralTimesFailure(t *testing.T) {
1356         m, i := setup()
1357
1358         resourceExpected := "{namespace},resource"
1359         m.On("SetNX", resourceExpected, mock.Anything, time.Duration(1)).Return(false, nil).Once()
1360         m.On("SetNX", resourceExpected, mock.Anything, time.Duration(1)).Return(true, errors.New("Some error")).Once()
1361
1362         lock, err := i.LockResource("resource", time.Duration(1), &sdlgo.Options{
1363                 RetryCount: 2,
1364         })
1365         assert.NotNil(t, err)
1366         assert.Nil(t, lock)
1367         m.AssertExpectations(t)
1368 }
1369
1370 func TestLockResourceTrySeveralTimesUnableToGetResource(t *testing.T) {
1371         m, i := setup()
1372
1373         resourceExpected := "{namespace},resource"
1374         m.On("SetNX", resourceExpected, mock.Anything, time.Duration(1)).Return(false, nil).Once()
1375         m.On("SetNX", resourceExpected, mock.Anything, time.Duration(1)).Return(false, nil).Once()
1376
1377         lock, err := i.LockResource("resource", time.Duration(1), &sdlgo.Options{
1378                 RetryCount: 1,
1379         })
1380         assert.NotNil(t, err)
1381         assert.EqualError(t, err, "Lock not obtained")
1382         assert.Nil(t, lock)
1383         m.AssertExpectations(t)
1384 }
1385
1386 func TestReleaseResourceSuccessfully(t *testing.T) {
1387         m, i := setup()
1388
1389         resourceExpected := "{namespace},resource"
1390         m.On("SetNX", resourceExpected, mock.Anything, time.Duration(1)).Return(true, nil).Once()
1391         m.On("DelIE", resourceExpected, mock.Anything).Return(true, nil).Once()
1392
1393         lock, err := i.LockResource("resource", time.Duration(1), &sdlgo.Options{
1394                 RetryCount: 1,
1395         })
1396         err2 := lock.ReleaseResource()
1397         assert.Nil(t, err)
1398         assert.NotNil(t, lock)
1399         assert.Nil(t, err2)
1400         m.AssertExpectations(t)
1401 }
1402
1403 func TestReleaseResourceFailure(t *testing.T) {
1404         m, i := setup()
1405
1406         resourceExpected := "{namespace},resource"
1407         m.On("SetNX", resourceExpected, mock.Anything, time.Duration(1)).Return(true, nil).Once()
1408         m.On("DelIE", resourceExpected, mock.Anything).Return(true, errors.New("Some error")).Once()
1409
1410         lock, err := i.LockResource("resource", time.Duration(1), &sdlgo.Options{
1411                 RetryCount: 1,
1412         })
1413         err2 := lock.ReleaseResource()
1414         assert.Nil(t, err)
1415         assert.NotNil(t, lock)
1416         assert.NotNil(t, err2)
1417         m.AssertExpectations(t)
1418 }
1419
1420 func TestReleaseResourceLockNotHeld(t *testing.T) {
1421         m, i := setup()
1422
1423         resourceExpected := "{namespace},resource"
1424         m.On("SetNX", resourceExpected, mock.Anything, time.Duration(1)).Return(true, nil).Once()
1425         m.On("DelIE", resourceExpected, mock.Anything).Return(false, nil).Once()
1426
1427         lock, err := i.LockResource("resource", time.Duration(1), &sdlgo.Options{
1428                 RetryCount: 1,
1429         })
1430         err2 := lock.ReleaseResource()
1431         assert.Nil(t, err)
1432         assert.NotNil(t, lock)
1433         assert.NotNil(t, err2)
1434         assert.EqualError(t, err2, "Lock not held")
1435         m.AssertExpectations(t)
1436 }
1437
1438 func TestRefreshResourceSuccessfully(t *testing.T) {
1439         m, i := setup()
1440
1441         resourceExpected := "{namespace},resource"
1442         m.On("SetNX", resourceExpected, mock.Anything, time.Duration(1)).Return(true, nil).Once()
1443         m.On("PExpireIE", resourceExpected, mock.Anything, time.Duration(1)).Return(nil).Once()
1444
1445         lock, err := i.LockResource("resource", time.Duration(1), &sdlgo.Options{
1446                 RetryCount: 1,
1447         })
1448         err2 := lock.RefreshResource(time.Duration(1))
1449         assert.Nil(t, err)
1450         assert.NotNil(t, lock)
1451         assert.Nil(t, err2)
1452         m.AssertExpectations(t)
1453 }
1454
1455 func TestRefreshResourceFailure(t *testing.T) {
1456         m, i := setup()
1457
1458         resourceExpected := "{namespace},resource"
1459         m.On("SetNX", resourceExpected, mock.Anything, time.Duration(1)).Return(true, nil).Once()
1460         m.On("PExpireIE", resourceExpected, mock.Anything, time.Duration(1)).Return(errors.New("Some error")).Once()
1461
1462         lock, err := i.LockResource("resource", time.Duration(1), &sdlgo.Options{
1463                 RetryCount: 1,
1464         })
1465         err2 := lock.RefreshResource(time.Duration(1))
1466         assert.Nil(t, err)
1467         assert.NotNil(t, lock)
1468         assert.NotNil(t, err2)
1469         m.AssertExpectations(t)
1470 }
1471
1472 func TestCheckResourceSuccessfully(t *testing.T) {
1473         m, i := setup()
1474
1475         resourceExpected := "{namespace},resource"
1476         m.On("PTTL", resourceExpected).Return(time.Duration(1), nil)
1477         result, err := i.CheckResource("resource")
1478         assert.Nil(t, err)
1479         assert.Equal(t, result, time.Duration(1))
1480         m.AssertExpectations(t)
1481 }
1482
1483 func TestCheckResourceFailure(t *testing.T) {
1484         m, i := setup()
1485
1486         resourceExpected := "{namespace},resource"
1487         m.On("PTTL", resourceExpected).Return(time.Duration(1), errors.New("Some error"))
1488         result, err := i.CheckResource("resource")
1489         assert.NotNil(t, err)
1490         assert.EqualError(t, err, "Some error")
1491         assert.Equal(t, result, time.Duration(0))
1492         m.AssertExpectations(t)
1493 }
1494
1495 func TestCheckResourceInvalidResource(t *testing.T) {
1496         m, i := setup()
1497
1498         resourceExpected := "{namespace},resource"
1499         m.On("PTTL", resourceExpected).Return(time.Duration(-1), nil)
1500         result, err := i.CheckResource("resource")
1501         assert.NotNil(t, err)
1502         assert.EqualError(t, err, "invalid resource given, no expiration time attached")
1503         assert.Equal(t, result, time.Duration(0))
1504         m.AssertExpectations(t)
1505 }