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