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