sdl_test.go

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