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(channel, message, key string, oldData, newData interface{}) (bool, error) {
  89         a := m.Called(channel, message, 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(channel, message, key string, data interface{}) (bool, error) {
  99         a := m.Called(channel, message, 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(channel, message, key string, data interface{}) (bool, error) {
 109         a := m.Called(channel, message, 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         expectedChannel := "{namespace},channel"
 784         expectedEvent := "event"
 785         expectedKey := "{namespace},key"
 786         expectedOldData := interface{}("olddata")
 787         expectedNewData := interface{}("newdata")
 788         m.On("SetIEPub", expectedChannel, expectedEvent, expectedKey, expectedOldData, expectedNewData).Return(true, nil)
 789         status, err := i.SetIfAndPublish([]string{"channel", "event"}, "key", "olddata", "newdata")
 790         assert.Nil(t, err)
 791         assert.True(t, status)
 792         m.AssertExpectations(t)
 793 }
 794
 795 func TestSetIfAndPublishIncorrectChannelAndEvent(t *testing.T) {
 796         m, i := setup()
 797
 798         expectedChannel := "{namespace},channel"
 799         expectedEvent := "event"
 800         expectedKey := "{namespace},key"
 801         expectedOldData := interface{}("olddata")
 802         expectedNewData := interface{}("newdata")
 803         m.AssertNotCalled(t, "SetIEPub", expectedChannel, expectedEvent, expectedKey, expectedOldData, expectedNewData)
 804         m.AssertNotCalled(t, "SetIE", expectedKey, expectedOldData, expectedNewData)
 805         status, err := i.SetIfAndPublish([]string{"channel", "event1", "channel"}, "key", "olddata", "newdata")
 806         assert.NotNil(t, err)
 807         assert.False(t, status)
 808         m.AssertExpectations(t)
 809 }
 810 func TestSetIfAndPublishNOKStatus(t *testing.T) {
 811         m, i := setup()
 812
 813         expectedChannel := "{namespace},channel"
 814         expectedEvent := "event"
 815         expectedKey := "{namespace},key"
 816         expectedOldData := interface{}("olddata")
 817         expectedNewData := interface{}("newdata")
 818         m.On("SetIEPub", expectedChannel, expectedEvent, expectedKey, expectedOldData, expectedNewData).Return(false, nil)
 819         status, err := i.SetIfAndPublish([]string{"channel", "event"}, "key", "olddata", "newdata")
 820         assert.Nil(t, err)
 821         assert.False(t, status)
 822         m.AssertExpectations(t)
 823 }
 824
 825 func TestSetIfAndPublishNoChannels(t *testing.T) {
 826         m, i := setup()
 827
 828         expectedKey := "{namespace},key"
 829         expectedOldData := interface{}("olddata")
 830         expectedNewData := interface{}("newdata")
 831         m.On("SetIE", expectedKey, expectedOldData, expectedNewData).Return(true, nil)
 832         status, err := i.SetIfAndPublish([]string{}, "key", "olddata", "newdata")
 833         assert.Nil(t, err)
 834         assert.True(t, status)
 835         m.AssertExpectations(t)
 836 }
 837
 838 func TestSetIfNotExistsAndPublishSuccessfully(t *testing.T) {
 839         m, i := setup()
 840
 841         expectedChannel := "{namespace},channel"
 842         expectedEvent := "event"
 843         expectedKey := "{namespace},key"
 844         expectedData := interface{}("data")
 845
 846         m.On("SetNXPub", expectedChannel, expectedEvent, expectedKey, expectedData).Return(true, nil)
 847         status, err := i.SetIfNotExistsAndPublish([]string{"channel", "event"}, "key", "data")
 848         assert.Nil(t, err)
 849         assert.True(t, status)
 850         m.AssertExpectations(t)
 851 }
 852
 853 func TestSetIfNotExistsAndPublishSeveralEvents(t *testing.T) {
 854         m, i := setup()
 855
 856         expectedChannel := "{namespace},channel"
 857         expectedEvent := "event1___event2"
 858         expectedKey := "{namespace},key"
 859         expectedData := interface{}("data")
 860
 861         m.On("SetNXPub", expectedChannel, expectedEvent, expectedKey, expectedData).Return(true, nil)
 862         status, err := i.SetIfNotExistsAndPublish([]string{"channel", "event1", "channel", "event2"}, "key", "data")
 863         assert.Nil(t, err)
 864         assert.True(t, status)
 865         m.AssertExpectations(t)
 866 }
 867
 868 func TestSetIfNotExistsAndPublishNoChannels(t *testing.T) {
 869         m, i := setup()
 870
 871         expectedKey := "{namespace},key"
 872         expectedData := interface{}("data")
 873
 874         m.On("SetNX", expectedKey, expectedData, time.Duration(0)).Return(true, nil)
 875         status, err := i.SetIfNotExistsAndPublish([]string{}, "key", "data")
 876         assert.Nil(t, err)
 877         assert.True(t, status)
 878         m.AssertExpectations(t)
 879 }
 880
 881 func TestSetIfNotExistsAndPublishFail(t *testing.T) {
 882         m, i := setup()
 883
 884         expectedChannel := "{namespace},channel"
 885         expectedEvent := "event"
 886         expectedKey := "{namespace},key"
 887         expectedData := interface{}("data")
 888
 889         m.On("SetNXPub", expectedChannel, expectedEvent, expectedKey, expectedData).Return(false, nil)
 890         status, err := i.SetIfNotExistsAndPublish([]string{"channel", "event"}, "key", "data")
 891         assert.Nil(t, err)
 892         assert.False(t, status)
 893         m.AssertExpectations(t)
 894 }
 895
 896 func TestSetIfNotExistsAndPublishIncorrectChannels(t *testing.T) {
 897         m, i := setup()
 898
 899         expectedChannel := "{namespace},channel"
 900         expectedEvent := "event"
 901         expectedKey := "{namespace},key"
 902         expectedData := interface{}("data")
 903
 904         m.AssertNotCalled(t, "SetNXPub", expectedChannel, expectedEvent, expectedKey, expectedData)
 905         m.AssertNotCalled(t, "SetNX", expectedKey, expectedData, 0)
 906         status, err := i.SetIfNotExistsAndPublish([]string{"channel", "event", "channel2"}, "key", "data")
 907         assert.NotNil(t, err)
 908         assert.False(t, status)
 909         m.AssertExpectations(t)
 910 }
 911
 912 func TestSetIfNotExistsAndPublishError(t *testing.T) {
 913         m, i := setup()
 914
 915         expectedChannel := "{namespace},channel"
 916         expectedEvent := "event"
 917         expectedKey := "{namespace},key"
 918         expectedData := interface{}("data")
 919
 920         m.On("SetNXPub", expectedChannel, expectedEvent, expectedKey, expectedData).Return(false, errors.New("Some error"))
 921         status, err := i.SetIfNotExistsAndPublish([]string{"channel", "event"}, "key", "data")
 922         assert.NotNil(t, err)
 923         assert.False(t, status)
 924         m.AssertExpectations(t)
 925 }
 926
 927 func TestSetIfNotExistsSuccessfullyOkStatus(t *testing.T) {
 928         m, i := setup()
 929
 930         mSetNXExpectedKey := string("{namespace},key1")
 931         mSetNXExpectedData := interface{}("data")
 932         m.On("SetNX", mSetNXExpectedKey, mSetNXExpectedData, time.Duration(0)).Return(true, nil)
 933         status, err := i.SetIfNotExists("key1", "data")
 934         assert.Nil(t, err)
 935         assert.True(t, status)
 936         m.AssertExpectations(t)
 937 }
 938
 939 func TestSetIfNotExistsSuccessfullyNOKStatus(t *testing.T) {
 940         m, i := setup()
 941
 942         mSetNXExpectedKey := string("{namespace},key1")
 943         mSetNXExpectedData := interface{}("data")
 944         m.On("SetNX", mSetNXExpectedKey, mSetNXExpectedData, time.Duration(0)).Return(false, nil)
 945         status, err := i.SetIfNotExists("key1", "data")
 946         assert.Nil(t, err)
 947         assert.False(t, status)
 948         m.AssertExpectations(t)
 949 }
 950
 951 func TestSetIfNotExistsFailure(t *testing.T) {
 952         m, i := setup()
 953
 954         mSetNXExpectedKey := string("{namespace},key1")
 955         mSetNXExpectedData := interface{}("data")
 956         m.On("SetNX", mSetNXExpectedKey, mSetNXExpectedData, time.Duration(0)).Return(false, errors.New("Some error"))
 957         status, err := i.SetIfNotExists("key1", "data")
 958         assert.NotNil(t, err)
 959         assert.False(t, status)
 960         m.AssertExpectations(t)
 961 }
 962
 963 func TestRemoveIfAndPublishSuccessfully(t *testing.T) {
 964         m, i := setup()
 965
 966         expectedChannel := "{namespace},channel"
 967         expectedEvent := "event1___event2"
 968         expectedKey := "{namespace},key"
 969         expectedValue := interface{}("data")
 970
 971         m.On("DelIEPub", expectedChannel, expectedEvent, expectedKey, expectedValue).Return(true, nil)
 972         status, err := i.RemoveIfAndPublish([]string{"channel", "event1", "channel", "event2"}, "key", "data")
 973         assert.Nil(t, err)
 974         assert.True(t, status)
 975         m.AssertExpectations(t)
 976 }
 977
 978 func TestRemoveIfAndPublishNok(t *testing.T) {
 979         m, i := setup()
 980
 981         expectedChannel := "{namespace},channel"
 982         expectedEvent := "event1___event2"
 983         expectedKey := "{namespace},key"
 984         expectedValue := interface{}("data")
 985
 986         m.On("DelIEPub", expectedChannel, expectedEvent, expectedKey, expectedValue).Return(false, nil)
 987         status, err := i.RemoveIfAndPublish([]string{"channel", "event1", "channel", "event2"}, "key", "data")
 988         assert.Nil(t, err)
 989         assert.False(t, status)
 990         m.AssertExpectations(t)
 991 }
 992
 993 func TestRemoveIfAndPublishError(t *testing.T) {
 994         m, i := setup()
 995
 996         expectedChannel := "{namespace},channel"
 997         expectedEvent := "event1___event2"
 998         expectedKey := "{namespace},key"
 999         expectedValue := interface{}("data")
1000
1001         m.On("DelIEPub", expectedChannel, expectedEvent, expectedKey, expectedValue).Return(false, errors.New("Some error"))
1002         status, err := i.RemoveIfAndPublish([]string{"channel", "event1", "channel", "event2"}, "key", "data")
1003         assert.NotNil(t, err)
1004         assert.False(t, status)
1005         m.AssertExpectations(t)
1006 }
1007
1008 func TestRemoveIfAndPublishIncorrectChannel(t *testing.T) {
1009         m, i := setup()
1010
1011         expectedChannel := "{namespace},channel"
1012         expectedEvent := "event"
1013         expectedKey := "{namespace},key"
1014         expectedValue := interface{}("data")
1015
1016         m.AssertNotCalled(t, "DelIEPub", expectedChannel, expectedEvent, expectedKey, expectedValue)
1017         m.AssertNotCalled(t, "DelIE", expectedKey, expectedValue)
1018         status, err := i.RemoveIfAndPublish([]string{"channel", "event1", "channel"}, "key", "data")
1019         assert.NotNil(t, err)
1020         assert.False(t, status)
1021         m.AssertExpectations(t)
1022 }
1023
1024 func TestRemoveIfAndPublishNoChannels(t *testing.T) {
1025         m, i := setup()
1026
1027         expectedKey := "{namespace},key"
1028         expectedValue := interface{}("data")
1029
1030         m.On("DelIE", expectedKey, expectedValue).Return(true, nil)
1031         status, err := i.RemoveIfAndPublish([]string{}, "key", "data")
1032         assert.Nil(t, err)
1033         assert.True(t, status)
1034         m.AssertExpectations(t)
1035
1036 }
1037 func TestRemoveIfSuccessfullyOkStatus(t *testing.T) {
1038         m, i := setup()
1039
1040         mDelIEExpectedKey := string("{namespace},key1")
1041         mDelIEExpectedData := interface{}("data")
1042         m.On("DelIE", mDelIEExpectedKey, mDelIEExpectedData).Return(true, nil)
1043         status, err := i.RemoveIf("key1", "data")
1044         assert.Nil(t, err)
1045         assert.True(t, status)
1046         m.AssertExpectations(t)
1047 }
1048
1049 func TestRemoveIfSuccessfullyNOKStatus(t *testing.T) {
1050         m, i := setup()
1051
1052         mDelIEExpectedKey := string("{namespace},key1")
1053         mDelIEExpectedData := interface{}("data")
1054         m.On("DelIE", mDelIEExpectedKey, mDelIEExpectedData).Return(false, nil)
1055         status, err := i.RemoveIf("key1", "data")
1056         assert.Nil(t, err)
1057         assert.False(t, status)
1058         m.AssertExpectations(t)
1059 }
1060
1061 func TestRemoveIfFailure(t *testing.T) {
1062         m, i := setup()
1063
1064         mDelIEExpectedKey := string("{namespace},key1")
1065         mDelIEExpectedData := interface{}("data")
1066         m.On("DelIE", mDelIEExpectedKey, mDelIEExpectedData).Return(true, errors.New("Some error"))
1067         status, err := i.RemoveIf("key1", "data")
1068         assert.NotNil(t, err)
1069         assert.False(t, status)
1070         m.AssertExpectations(t)
1071 }
1072
1073 func TestRemoveAllAndPublishSuccessfully(t *testing.T) {
1074         m, i := setup()
1075
1076         mKeysExpected := string("{namespace},*")
1077         mKeysReturn := []string{"{namespace},key1", "{namespace},key2"}
1078         mDelExpected := mKeysReturn
1079         expectedChannelAndEvent := []string{"{namespace},channel", "event"}
1080         m.On("Keys", mKeysExpected).Return(mKeysReturn, nil)
1081         m.On("DelMPub", expectedChannelAndEvent, mDelExpected).Return(nil)
1082         err := i.RemoveAllAndPublish([]string{"channel", "event"})
1083         assert.Nil(t, err)
1084         m.AssertExpectations(t)
1085 }
1086
1087 func TestRemoveAllAndPublishKeysReturnError(t *testing.T) {
1088         m, i := setup()
1089
1090         mKeysExpected := string("{namespace},*")
1091         mKeysReturn := []string{"{namespace},key1", "{namespace},key2"}
1092         mDelExpected := mKeysReturn
1093         expectedChannelAndEvent := []string{"{namespace},channel", "event"}
1094         m.On("Keys", mKeysExpected).Return(mKeysReturn, errors.New("Some error"))
1095         m.AssertNotCalled(t, "DelMPub", expectedChannelAndEvent, mDelExpected)
1096         err := i.RemoveAllAndPublish([]string{"channel", "event"})
1097         assert.NotNil(t, err)
1098         m.AssertExpectations(t)
1099 }
1100
1101 func TestRemoveAllAndPublishKeysDelReturnsError(t *testing.T) {
1102         m, i := setup()
1103
1104         mKeysExpected := string("{namespace},*")
1105         mKeysReturn := []string{"{namespace},key1", "{namespace},key2"}
1106         mDelExpected := mKeysReturn
1107         expectedChannelAndEvent := []string{"{namespace},channel", "event"}
1108         m.On("Keys", mKeysExpected).Return(mKeysReturn, nil)
1109         m.On("DelMPub", expectedChannelAndEvent, mDelExpected).Return(errors.New("Some error"))
1110         err := i.RemoveAllAndPublish([]string{"channel", "event"})
1111         assert.NotNil(t, err)
1112         m.AssertExpectations(t)
1113 }
1114
1115 func TestRemoveAllAndPublishKeysEventsWithIllegalCharacters(t *testing.T) {
1116         m, i := setup()
1117
1118         mKeysExpected := string("{namespace},*")
1119         mKeysReturn := []string{"{namespace},key1", "{namespace},key2"}
1120         mDelExpected := mKeysReturn
1121         expectedChannelAndEvent := []string{"{namespace},channel", "event"}
1122         m.On("Keys", mKeysExpected).Return(mKeysReturn, nil)
1123         m.AssertNotCalled(t, "DelMPub", expectedChannelAndEvent, mDelExpected)
1124         err := i.RemoveAllAndPublish([]string{"channel", "event___anotherEvent"})
1125         assert.NotNil(t, err)
1126         m.AssertExpectations(t)
1127
1128 }
1129
1130 func TestRemoveAllAndPublishNoChannels(t *testing.T) {
1131         m, i := setup()
1132
1133         mKeysExpected := string("{namespace},*")
1134         mKeysReturn := []string{"{namespace},key1", "{namespace},key2"}
1135         mDelExpected := mKeysReturn
1136         m.On("Keys", mKeysExpected).Return(mKeysReturn, nil)
1137         m.On("Del", mDelExpected).Return(nil)
1138         m.AssertNotCalled(t, "DelMPub", "", "", mDelExpected)
1139         err := i.RemoveAllAndPublish([]string{})
1140         assert.Nil(t, err)
1141         m.AssertExpectations(t)
1142 }
1143
1144 func TestRemoveAllAndPublishIncorrectChannel(t *testing.T) {
1145         m, i := setup()
1146
1147         mKeysExpected := string("{namespace},*")
1148         mKeysReturn := []string{"{namespace},key1", "{namespace},key2"}
1149         mDelExpected := mKeysReturn
1150         m.On("Keys", mKeysExpected).Return(mKeysReturn, nil)
1151         m.AssertNotCalled(t, "DelMPub", "", "", mDelExpected)
1152         err := i.RemoveAllAndPublish([]string{"channel", "event", "channel2"})
1153         assert.NotNil(t, err)
1154         m.AssertExpectations(t)
1155
1156 }
1157
1158 func TestAddMemberSuccessfully(t *testing.T) {
1159         m, i := setup()
1160
1161         groupExpected := string("{namespace},group")
1162         membersExpected := []interface{}{"member1", "member2"}
1163
1164         m.On("SAdd", groupExpected, membersExpected).Return(nil)
1165
1166         err := i.AddMember("group", "member1", "member2")
1167         assert.Nil(t, err)
1168         m.AssertExpectations(t)
1169 }
1170
1171 func TestAddMemberFail(t *testing.T) {
1172         m, i := setup()
1173
1174         groupExpected := string("{namespace},group")
1175         membersExpected := []interface{}{"member1", "member2"}
1176
1177         m.On("SAdd", groupExpected, membersExpected).Return(errors.New("Some error"))
1178
1179         err := i.AddMember("group", "member1", "member2")
1180         assert.NotNil(t, err)
1181         m.AssertExpectations(t)
1182 }
1183 func TestRemoveMemberSuccessfully(t *testing.T) {
1184         m, i := setup()
1185
1186         groupExpected := string("{namespace},group")
1187         membersExpected := []interface{}{"member1", "member2"}
1188
1189         m.On("SRem", groupExpected, membersExpected).Return(nil)
1190
1191         err := i.RemoveMember("group", "member1", "member2")
1192         assert.Nil(t, err)
1193         m.AssertExpectations(t)
1194 }
1195
1196 func TestRemoveMemberFail(t *testing.T) {
1197         m, i := setup()
1198
1199         groupExpected := string("{namespace},group")
1200         membersExpected := []interface{}{"member1", "member2"}
1201
1202         m.On("SRem", groupExpected, membersExpected).Return(errors.New("Some error"))
1203
1204         err := i.RemoveMember("group", "member1", "member2")
1205         assert.NotNil(t, err)
1206         m.AssertExpectations(t)
1207 }
1208
1209 func TestRemoveGroupSuccessfully(t *testing.T) {
1210         m, i := setup()
1211
1212         groupExpected := []string{"{namespace},group"}
1213
1214         m.On("Del", groupExpected).Return(nil)
1215
1216         err := i.RemoveGroup("group")
1217         assert.Nil(t, err)
1218         m.AssertExpectations(t)
1219 }
1220 func TestRemoveGroupFail(t *testing.T) {
1221         m, i := setup()
1222
1223         groupExpected := []string{"{namespace},group"}
1224
1225         m.On("Del", groupExpected).Return(errors.New("Some error"))
1226
1227         err := i.RemoveGroup("group")
1228         assert.NotNil(t, err)
1229         m.AssertExpectations(t)
1230 }
1231
1232 func TestGetMembersSuccessfully(t *testing.T) {
1233         m, i := setup()
1234
1235         groupExpected := "{namespace},group"
1236         returnExpected := []string{"member1", "member2"}
1237
1238         m.On("SMembers", groupExpected).Return(returnExpected, nil)
1239
1240         result, err := i.GetMembers("group")
1241         assert.Nil(t, err)
1242         assert.Equal(t, result, returnExpected)
1243         m.AssertExpectations(t)
1244 }
1245 func TestGetMembersFail(t *testing.T) {
1246         m, i := setup()
1247
1248         groupExpected := "{namespace},group"
1249         returnExpected := []string{"member1", "member2"}
1250
1251         m.On("SMembers", groupExpected).Return(returnExpected, errors.New("Some error"))
1252
1253         result, err := i.GetMembers("group")
1254         assert.NotNil(t, err)
1255         assert.Equal(t, []string{}, result)
1256         m.AssertExpectations(t)
1257 }
1258
1259 func TestIsMemberSuccessfullyIsMember(t *testing.T) {
1260         m, i := setup()
1261
1262         groupExpected := "{namespace},group"
1263         memberExpected := "member"
1264
1265         m.On("SIsMember", groupExpected, memberExpected).Return(true, nil)
1266
1267         result, err := i.IsMember("group", "member")
1268         assert.Nil(t, err)
1269         assert.True(t, result)
1270         m.AssertExpectations(t)
1271 }
1272 func TestIsMemberSuccessfullyIsNotMember(t *testing.T) {
1273         m, i := setup()
1274
1275         groupExpected := "{namespace},group"
1276         memberExpected := "member"
1277
1278         m.On("SIsMember", groupExpected, memberExpected).Return(false, nil)
1279
1280         result, err := i.IsMember("group", "member")
1281         assert.Nil(t, err)
1282         assert.False(t, result)
1283         m.AssertExpectations(t)
1284 }
1285 func TestIsMemberFailure(t *testing.T) {
1286         m, i := setup()
1287
1288         groupExpected := "{namespace},group"
1289         memberExpected := "member"
1290
1291         m.On("SIsMember", groupExpected, memberExpected).Return(true, errors.New("Some error"))
1292
1293         result, err := i.IsMember("group", "member")
1294         assert.NotNil(t, err)
1295         assert.False(t, result)
1296         m.AssertExpectations(t)
1297 }
1298
1299 func TestGroupSizeSuccessfully(t *testing.T) {
1300         m, i := setup()
1301
1302         var expectedSize int64
1303         expectedSize = 2
1304         groupExpected := "{namespace},group"
1305
1306         m.On("SCard", groupExpected).Return(expectedSize, nil)
1307
1308         result, err := i.GroupSize("group")
1309         assert.Nil(t, err)
1310         assert.Equal(t, expectedSize, result)
1311         m.AssertExpectations(t)
1312 }
1313 func TestGroupSizeFail(t *testing.T) {
1314         m, i := setup()
1315
1316         var expectedSize int64
1317         expectedSize = 2
1318         groupExpected := "{namespace},group"
1319
1320         m.On("SCard", groupExpected).Return(expectedSize, errors.New("Some error"))
1321
1322         result, err := i.GroupSize("group")
1323         assert.NotNil(t, err)
1324         assert.Equal(t, int64(0), result)
1325         m.AssertExpectations(t)
1326 }
1327
1328 func TestLockResourceSuccessfully(t *testing.T) {
1329         m, i := setup()
1330
1331         resourceExpected := "{namespace},resource"
1332         m.On("SetNX", resourceExpected, mock.Anything, time.Duration(1)).Return(true, nil)
1333
1334         lock, err := i.LockResource("resource", time.Duration(1), &sdlgo.Options{})
1335         assert.Nil(t, err)
1336         assert.NotNil(t, lock)
1337         m.AssertExpectations(t)
1338 }
1339
1340 func TestLockResourceFailure(t *testing.T) {
1341         m, i := setup()
1342
1343         resourceExpected := "{namespace},resource"
1344         m.On("SetNX", resourceExpected, mock.Anything, time.Duration(1)).Return(true, errors.New("Some error"))
1345
1346         lock, err := i.LockResource("resource", time.Duration(1), &sdlgo.Options{})
1347         assert.NotNil(t, err)
1348         assert.Nil(t, lock)
1349         m.AssertExpectations(t)
1350 }
1351
1352 func TestLockResourceTrySeveralTimesSuccessfully(t *testing.T) {
1353         m, i := setup()
1354
1355         resourceExpected := "{namespace},resource"
1356         m.On("SetNX", resourceExpected, mock.Anything, time.Duration(1)).Return(false, nil).Once()
1357         m.On("SetNX", resourceExpected, mock.Anything, time.Duration(1)).Return(true, nil).Once()
1358
1359         lock, err := i.LockResource("resource", time.Duration(1), &sdlgo.Options{
1360                 RetryCount: 2,
1361         })
1362         assert.Nil(t, err)
1363         assert.NotNil(t, lock)
1364         m.AssertExpectations(t)
1365 }
1366
1367 func TestLockResourceTrySeveralTimesFailure(t *testing.T) {
1368         m, i := setup()
1369
1370         resourceExpected := "{namespace},resource"
1371         m.On("SetNX", resourceExpected, mock.Anything, time.Duration(1)).Return(false, nil).Once()
1372         m.On("SetNX", resourceExpected, mock.Anything, time.Duration(1)).Return(true, errors.New("Some error")).Once()
1373
1374         lock, err := i.LockResource("resource", time.Duration(1), &sdlgo.Options{
1375                 RetryCount: 2,
1376         })
1377         assert.NotNil(t, err)
1378         assert.Nil(t, lock)
1379         m.AssertExpectations(t)
1380 }
1381
1382 func TestLockResourceTrySeveralTimesUnableToGetResource(t *testing.T) {
1383         m, i := setup()
1384
1385         resourceExpected := "{namespace},resource"
1386         m.On("SetNX", resourceExpected, mock.Anything, time.Duration(1)).Return(false, nil).Once()
1387         m.On("SetNX", resourceExpected, mock.Anything, time.Duration(1)).Return(false, nil).Once()
1388
1389         lock, err := i.LockResource("resource", time.Duration(1), &sdlgo.Options{
1390                 RetryCount: 1,
1391         })
1392         assert.NotNil(t, err)
1393         assert.EqualError(t, err, "Lock not obtained")
1394         assert.Nil(t, lock)
1395         m.AssertExpectations(t)
1396 }
1397
1398 func TestReleaseResourceSuccessfully(t *testing.T) {
1399         m, i := setup()
1400
1401         resourceExpected := "{namespace},resource"
1402         m.On("SetNX", resourceExpected, mock.Anything, time.Duration(1)).Return(true, nil).Once()
1403         m.On("DelIE", resourceExpected, mock.Anything).Return(true, nil).Once()
1404
1405         lock, err := i.LockResource("resource", time.Duration(1), &sdlgo.Options{
1406                 RetryCount: 1,
1407         })
1408         err2 := lock.ReleaseResource()
1409         assert.Nil(t, err)
1410         assert.NotNil(t, lock)
1411         assert.Nil(t, err2)
1412         m.AssertExpectations(t)
1413 }
1414
1415 func TestReleaseResourceFailure(t *testing.T) {
1416         m, i := setup()
1417
1418         resourceExpected := "{namespace},resource"
1419         m.On("SetNX", resourceExpected, mock.Anything, time.Duration(1)).Return(true, nil).Once()
1420         m.On("DelIE", resourceExpected, mock.Anything).Return(true, errors.New("Some error")).Once()
1421
1422         lock, err := i.LockResource("resource", time.Duration(1), &sdlgo.Options{
1423                 RetryCount: 1,
1424         })
1425         err2 := lock.ReleaseResource()
1426         assert.Nil(t, err)
1427         assert.NotNil(t, lock)
1428         assert.NotNil(t, err2)
1429         m.AssertExpectations(t)
1430 }
1431
1432 func TestReleaseResourceLockNotHeld(t *testing.T) {
1433         m, i := setup()
1434
1435         resourceExpected := "{namespace},resource"
1436         m.On("SetNX", resourceExpected, mock.Anything, time.Duration(1)).Return(true, nil).Once()
1437         m.On("DelIE", resourceExpected, mock.Anything).Return(false, nil).Once()
1438
1439         lock, err := i.LockResource("resource", time.Duration(1), &sdlgo.Options{
1440                 RetryCount: 1,
1441         })
1442         err2 := lock.ReleaseResource()
1443         assert.Nil(t, err)
1444         assert.NotNil(t, lock)
1445         assert.NotNil(t, err2)
1446         assert.EqualError(t, err2, "Lock not held")
1447         m.AssertExpectations(t)
1448 }
1449
1450 func TestRefreshResourceSuccessfully(t *testing.T) {
1451         m, i := setup()
1452
1453         resourceExpected := "{namespace},resource"
1454         m.On("SetNX", resourceExpected, mock.Anything, time.Duration(1)).Return(true, nil).Once()
1455         m.On("PExpireIE", resourceExpected, mock.Anything, time.Duration(1)).Return(nil).Once()
1456
1457         lock, err := i.LockResource("resource", time.Duration(1), &sdlgo.Options{
1458                 RetryCount: 1,
1459         })
1460         err2 := lock.RefreshResource(time.Duration(1))
1461         assert.Nil(t, err)
1462         assert.NotNil(t, lock)
1463         assert.Nil(t, err2)
1464         m.AssertExpectations(t)
1465 }
1466
1467 func TestRefreshResourceFailure(t *testing.T) {
1468         m, i := setup()
1469
1470         resourceExpected := "{namespace},resource"
1471         m.On("SetNX", resourceExpected, mock.Anything, time.Duration(1)).Return(true, nil).Once()
1472         m.On("PExpireIE", resourceExpected, mock.Anything, time.Duration(1)).Return(errors.New("Some error")).Once()
1473
1474         lock, err := i.LockResource("resource", time.Duration(1), &sdlgo.Options{
1475                 RetryCount: 1,
1476         })
1477         err2 := lock.RefreshResource(time.Duration(1))
1478         assert.Nil(t, err)
1479         assert.NotNil(t, lock)
1480         assert.NotNil(t, err2)
1481         m.AssertExpectations(t)
1482 }
1483
1484 func TestCheckResourceSuccessfully(t *testing.T) {
1485         m, i := setup()
1486
1487         resourceExpected := "{namespace},resource"
1488         m.On("PTTL", resourceExpected).Return(time.Duration(1), nil)
1489         result, err := i.CheckResource("resource")
1490         assert.Nil(t, err)
1491         assert.Equal(t, result, time.Duration(1))
1492         m.AssertExpectations(t)
1493 }
1494
1495 func TestCheckResourceFailure(t *testing.T) {
1496         m, i := setup()
1497
1498         resourceExpected := "{namespace},resource"
1499         m.On("PTTL", resourceExpected).Return(time.Duration(1), errors.New("Some error"))
1500         result, err := i.CheckResource("resource")
1501         assert.NotNil(t, err)
1502         assert.EqualError(t, err, "Some error")
1503         assert.Equal(t, result, time.Duration(0))
1504         m.AssertExpectations(t)
1505 }
1506
1507 func TestCheckResourceInvalidResource(t *testing.T) {
1508         m, i := setup()
1509
1510         resourceExpected := "{namespace},resource"
1511         m.On("PTTL", resourceExpected).Return(time.Duration(-1), nil)
1512         result, err := i.CheckResource("resource")
1513         assert.NotNil(t, err)
1514         assert.EqualError(t, err, "invalid resource given, no expiration time attached")
1515         assert.Equal(t, result, time.Duration(0))
1516         m.AssertExpectations(t)
1517 }