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