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         "testing"
  23         "reflect"
  24
  25         "gerrit.o-ran-sc.org/r/ric-plt/sdlgo"
  26         "gerrit.o-ran-sc.org/r/ric-plt/sdlgo/internal/sdlgoredis"
  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 sdlgoredis.ChannelNotificationCb, 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{}) (bool, error) {
  89         a := m.Called(key, data)
  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 setup() (*mockDB, *sdlgo.SdlInstance) {
 133         m := new(mockDB)
 134         i := sdlgo.NewSdlInstance("namespace", m)
 135         return m, i
 136 }
 137
 138 func verifySliceInOrder(a, b []string) bool {
 139                 for i, v := range a {
 140                         found := false
 141                         if i%2 == 0 {
 142                                 for j, x := range b {
 143                                         if j%2 == 0 && x == v && a[i+1] == b[j+1] {
 144                                                 found = true
 145                                                 break
 146                                         }
 147                                 }
 148                                 if !found {
 149                                         return false
 150                                 }
 151                         }
 152                 }
 153                 return true
 154
 155 }
 156
 157 func TestSubscribeChannel(t *testing.T) {
 158         m, i := setup()
 159
 160         expectedCB := func(channel string, events ...string) {}
 161         expectedChannels := []string{"{namespace},channel1", "{namespace},channel2"}
 162
 163         m.On("SubscribeChannelDB", mock.AnythingOfType("sdlgoredis.ChannelNotificationCb"), "{namespace},", "___", expectedChannels).Return()
 164         i.SubscribeChannel(expectedCB, "channel1", "channel2")
 165         m.AssertExpectations(t)
 166 }
 167
 168 func TestUnsubscribeChannel(t *testing.T) {
 169         m, i := setup()
 170
 171         expectedChannels := []string{"{namespace},channel1", "{namespace},channel2"}
 172
 173         m.On("UnsubscribeChannelDB", expectedChannels).Return()
 174         i.UnsubscribeChannel("channel1", "channel2")
 175         m.AssertExpectations(t)
 176 }
 177 func TestGetOneKey(t *testing.T) {
 178         m, i := setup()
 179
 180         mgetExpected := []string{"{namespace},key"}
 181         mReturn := []interface{}{"somevalue"}
 182         mReturnExpected := make(map[string]interface{})
 183         mReturnExpected["key"] = "somevalue"
 184
 185         m.On("MGet", mgetExpected).Return(mReturn, nil)
 186         retVal, err := i.Get([]string{"key"})
 187         assert.Nil(t, err)
 188         assert.Equal(t, mReturnExpected, retVal)
 189         m.AssertExpectations(t)
 190 }
 191
 192 func TestGetSeveralKeys(t *testing.T) {
 193         m, i := setup()
 194
 195         mgetExpected := []string{"{namespace},key1", "{namespace},key2", "{namespace},key3"}
 196         mReturn := []interface{}{"somevalue1", 2, "someothervalue"}
 197         mReturnExpected := make(map[string]interface{})
 198         mReturnExpected["key1"] = "somevalue1"
 199         mReturnExpected["key2"] = 2
 200         mReturnExpected["key3"] = "someothervalue"
 201
 202         m.On("MGet", mgetExpected).Return(mReturn, nil)
 203         retVal, err := i.Get([]string{"key1", "key2", "key3"})
 204         assert.Nil(t, err)
 205         assert.Equal(t, mReturnExpected, retVal)
 206         m.AssertExpectations(t)
 207 }
 208
 209 func TestGetSeveralKeysSomeFail(t *testing.T) {
 210         m, i := setup()
 211
 212         mgetExpected := []string{"{namespace},key1", "{namespace},key2", "{namespace},key3"}
 213         mReturn := []interface{}{"somevalue1", nil, "someothervalue"}
 214         mReturnExpected := make(map[string]interface{})
 215         mReturnExpected["key1"] = "somevalue1"
 216         mReturnExpected["key2"] = nil
 217         mReturnExpected["key3"] = "someothervalue"
 218
 219         m.On("MGet", mgetExpected).Return(mReturn, nil)
 220         retVal, err := i.Get([]string{"key1", "key2", "key3"})
 221         assert.Nil(t, err)
 222         assert.Equal(t, mReturnExpected, retVal)
 223         m.AssertExpectations(t)
 224 }
 225
 226 func TestGetKeyReturnError(t *testing.T) {
 227         m, i := setup()
 228
 229         mgetExpected := []string{"{namespace},key"}
 230         mReturn := []interface{}{nil}
 231         mReturnExpected := make(map[string]interface{})
 232
 233         m.On("MGet", mgetExpected).Return(mReturn, errors.New("Some error"))
 234         retVal, err := i.Get([]string{"key"})
 235         assert.NotNil(t, err)
 236         assert.Equal(t, mReturnExpected, retVal)
 237         m.AssertExpectations(t)
 238 }
 239
 240 func TestGetEmptyList(t *testing.T) {
 241         m, i := setup()
 242
 243         mgetExpected := []string{}
 244
 245         retval, err := i.Get([]string{})
 246         assert.Nil(t, err)
 247         assert.Len(t, retval, 0)
 248         m.AssertNotCalled(t, "MGet", mgetExpected)
 249 }
 250
 251 func TestWriteOneKey(t *testing.T) {
 252         m, i := setup()
 253
 254         msetExpected := []interface{}{"{namespace},key1", "data1"}
 255
 256         m.On("MSet", msetExpected).Return(nil)
 257         err := i.Set("key1", "data1")
 258         assert.Nil(t, err)
 259         m.AssertExpectations(t)
 260 }
 261
 262 func TestWriteByteSliceAsValue(t *testing.T) {
 263         m, i := setup()
 264
 265         msetExpected := []interface{}{"{namespace},key1", []byte{1, 2, 3, 4, 5}}
 266
 267         m.On("MSet", msetExpected).Return(nil)
 268         err := i.Set("key1", []byte{1, 2, 3, 4, 5})
 269         assert.Nil(t, err)
 270         m.AssertExpectations(t)
 271 }
 272
 273 func TestWriteByteSliceAsValueMixed(t *testing.T) {
 274         m, i := setup()
 275
 276         msetExpected := []interface{}{"{namespace},key1", []byte{1, 2, 3, 4, 5}, "{namespace},key2", "value2"}
 277
 278         m.On("MSet", msetExpected).Return(nil)
 279         err := i.Set("key1", []byte{1, 2, 3, 4, 5}, []string{"key2", "value2"})
 280         assert.Nil(t, err)
 281         m.AssertExpectations(t)
 282 }
 283
 284 func TestWriteByteArrayAsValue(t *testing.T) {
 285         m, i := setup()
 286
 287         msetExpected := []interface{}{"{namespace},key1", [5]byte{1, 2, 3, 4, 5}}
 288
 289         m.On("MSet", msetExpected).Return(nil)
 290         err := i.Set("key1", [5]byte{1, 2, 3, 4, 5})
 291         assert.Nil(t, err)
 292         m.AssertExpectations(t)
 293 }
 294
 295 func TestWriteMapAsInput(t *testing.T){
 296         m, i := setup()
 297
 298         setExpected := []interface{}{"{namespace},key1", "string123",
 299                                                                 "{namespace},key22", 12,
 300                                                                 "{namespace},key333", []byte{1,2,3,4,5}}
 301         inputMap := map[string]interface{}{
 302                 "key1": "string123",
 303                 "key22": 12,
 304                 "key333": []byte{1,2,3,4,5},
 305         }
 306
 307         m.On("MSet", mock.MatchedBy(func(input []interface{}) bool {
 308                 for _, v := range input {
 309                         found := false
 310                         for _, x := range setExpected {
 311                                 found = reflect.DeepEqual(x, v)
 312                                 if found == true {
 313                                         break
 314                                 }
 315                         }
 316                         if found == false {
 317                                 return false
 318                         }
 319                 }
 320                 return true
 321                 })).Return(nil)
 322
 323         err := i.Set(inputMap)
 324         assert.Nil(t, err)
 325         m.AssertExpectations(t)
 326 }
 327
 328 func TestWriteMixed(t *testing.T) {
 329         m, i := setup()
 330
 331         msetExpected := []interface{}{"{namespace},key1", "data1", "{namespace},key2", "data2", "{namespace},key3", "data3"}
 332
 333         m.On("MSet", msetExpected).Return(nil)
 334         err := i.Set("key1", "data1", []string{"key2", "data2"}, [2]string{"key3", "data3"})
 335         assert.Nil(t, err)
 336         m.AssertExpectations(t)
 337 }
 338
 339 func TestWriteIncorrectMixed(t *testing.T) {
 340         m, i := setup()
 341
 342         msetExpected := []interface{}{"{namespace},key1", "data1", "{namespace},key2", "data2", "{namespace},key3", "data3"}
 343
 344         m.AssertNotCalled(t, "MSet", msetExpected)
 345         err := i.Set("key1", []string{"key2", "data2"}, [2]string{"key3", "data3"})
 346         assert.NotNil(t, err)
 347         m.AssertExpectations(t)
 348 }
 349 func TestWriteIncorrectPairs(t *testing.T) {
 350         m, i := setup()
 351
 352         msetExpected := []interface{}{}
 353
 354         m.AssertNotCalled(t, "MSet", msetExpected)
 355         err := i.Set("key")
 356         assert.NotNil(t, err)
 357         m.AssertExpectations(t)
 358 }
 359 func TestWriteSeveralKeysSlice(t *testing.T) {
 360         m, i := setup()
 361
 362         msetExpected := []interface{}{"{namespace},key1", "data1", "{namespace},key2", 22}
 363
 364         m.On("MSet", msetExpected).Return(nil)
 365         err := i.Set([]interface{}{"key1", "data1", "key2", 22})
 366         assert.Nil(t, err)
 367         m.AssertExpectations(t)
 368
 369 }
 370
 371 func TestWriteSeveralKeysIncorrectSlice(t *testing.T) {
 372         m, i := setup()
 373
 374         msetExpected := []interface{}{"{namespace},key1", "data1", "{namespace},key2", 22}
 375
 376         m.AssertNotCalled(t, "MSet", msetExpected)
 377         err := i.Set([]interface{}{"key1", "data1", "key2"})
 378         assert.NotNil(t, err)
 379         m.AssertExpectations(t)
 380
 381 }
 382
 383 func TestWriteSeveralKeysArray(t *testing.T) {
 384         m, i := setup()
 385
 386         msetExpected := []interface{}{"{namespace},key1", "data1", "{namespace},key2", "data2"}
 387
 388         m.On("MSet", msetExpected).Return(nil)
 389         err := i.Set([4]string{"key1", "data1", "key2", "data2"})
 390         assert.Nil(t, err)
 391         m.AssertExpectations(t)
 392 }
 393
 394 func TestWriteSeveralKeysIncorrectArray(t *testing.T) {
 395         m, i := setup()
 396
 397         msetExpected := []interface{}{}
 398
 399         m.AssertNotCalled(t, "MSet", msetExpected)
 400         err := i.Set([3]string{"key1", "data1", "key2"})
 401         assert.NotNil(t, err)
 402         m.AssertExpectations(t)
 403 }
 404
 405 func TestWriteFail(t *testing.T) {
 406         m, i := setup()
 407
 408         msetExpected := []interface{}{"{namespace},key1", "data1"}
 409
 410         m.On("MSet", msetExpected).Return(errors.New("Some error"))
 411         err := i.Set("key1", "data1")
 412         assert.NotNil(t, err)
 413         m.AssertExpectations(t)
 414 }
 415
 416 func TestWriteEmptyList(t *testing.T) {
 417         m, i := setup()
 418
 419         msetExpected := []interface{}{}
 420         err := i.Set()
 421         assert.Nil(t, err)
 422         m.AssertNotCalled(t, "MSet", msetExpected)
 423 }
 424
 425 func TestWriteAndPublishOneKeyOneChannel(t *testing.T) {
 426         m, i := setup()
 427
 428         expectedChannelAndEvent := []string{"{namespace},channel", "event"}
 429         expectedKeyVal := []interface{}{"{namespace},key1", "data1"}
 430
 431         m.On("MSetMPub", expectedChannelAndEvent, expectedKeyVal).Return(nil)
 432         m.AssertNotCalled(t, "MSet", expectedKeyVal)
 433         err := i.SetAndPublish([]string{"channel", "event"}, "key1", "data1")
 434         assert.Nil(t, err)
 435         m.AssertExpectations(t)
 436 }
 437
 438 func TestWriteAndPublishSeveralChannelsAndEvents(t *testing.T) {
 439         m , i := setup()
 440
 441         expectedChannelsAndEvents := []string{"{namespace},channel1", "event1___event2",
 442                                                                                   "{namespace},channel2", "event3___event4"}
 443         expectedKeyVal := []interface{}{"{namespace},key", "data"}
 444
 445         verifyChannelAndEvent := func(input []string) bool {
 446                 return verifySliceInOrder(input, expectedChannelsAndEvents)
 447         }
 448         m.On("MSetMPub", mock.MatchedBy(verifyChannelAndEvent), expectedKeyVal).Return(nil)
 449         m.AssertNotCalled(t, "MSet", expectedKeyVal)
 450         err := i.SetAndPublish([]string{"channel1", "event1", "channel2", "event3", "channel1", "event2", "channel2", "event4"},
 451                                                                         "key", "data")
 452         assert.Nil(t, err)
 453         m.AssertExpectations(t)
 454 }
 455
 456 func TestWriteAndPublishOneKeyOneChannelTwoEvents(t *testing.T) {
 457         m, i := setup()
 458
 459         expectedChannelAndEvents := []string{"{namespace},channel", "event1___event2"}
 460         expectedKeyVal := []interface{}{"{namespace},key1", "data1"}
 461
 462         m.On("MSetMPub", expectedChannelAndEvents, expectedKeyVal).Return(nil)
 463         m.AssertNotCalled(t, "MSet", expectedKeyVal)
 464         err := i.SetAndPublish([]string{"channel", "event1", "channel", "event2"}, "key1", "data1")
 465         assert.Nil(t, err)
 466         m.AssertExpectations(t)
 467 }
 468
 469 func TestWriteAndPublishIncorrectChannelAndEvent(t *testing.T) {
 470         m, i := setup()
 471
 472         expectedChannelAndEvent := []string{}
 473         expectedKeyVal := []interface{}{"{namespace},key1", "data1"}
 474         m.AssertNotCalled(t, "MSetMPub", expectedChannelAndEvent, expectedKeyVal)
 475         m.AssertNotCalled(t, "MSet", expectedKeyVal)
 476         err := i.SetAndPublish([]string{"channel", "event1", "channel"}, "key1", "data1")
 477         assert.NotNil(t, err)
 478         m.AssertExpectations(t)
 479 }
 480
 481 func TestWriteAndPublishNotAllowedCharactersInEvents(t *testing.T) {
 482         m, i := setup()
 483
 484         expectedChannelAndEvent := []string{}
 485         expectedKeyVal := []interface{}{"{namespace},key1", "data1"}
 486         m.AssertNotCalled(t, "MSetMPub", expectedChannelAndEvent, expectedKeyVal)
 487         m.AssertNotCalled(t, "MSet", expectedKeyVal)
 488         err := i.SetAndPublish([]string{"channel", "event1___event2"}, "key1", "data1")
 489         assert.NotNil(t, err)
 490         m.AssertExpectations(t)
 491 }
 492
 493 func TestWriteAndPublishNoData(t *testing.T) {
 494         m, i := setup()
 495
 496         expectedChannelAndEvent := []string{}
 497         expectedKeyVal := []interface{}{"key"}
 498
 499         m.AssertNotCalled(t, "MSetMPub", expectedChannelAndEvent, expectedKeyVal)
 500         m.AssertNotCalled(t, "MSet", expectedKeyVal)
 501         err := i.SetAndPublish([]string{"channel", "event"}, []interface{}{"key"})
 502         assert.NotNil(t, err)
 503         m.AssertExpectations(t)
 504 }
 505
 506 func TestWriteAndPublishNoChannelEvent(t *testing.T) {
 507         m, i := setup()
 508
 509         expectedKeyVal := []interface{}{"{namespace},key1", "data1"}
 510
 511         m.On("MSet", expectedKeyVal).Return(nil)
 512         m.AssertNotCalled(t, "MSetMPub", "", "", expectedKeyVal)
 513         err := i.SetAndPublish([]string{}, "key1", "data1")
 514         assert.Nil(t, err)
 515         m.AssertExpectations(t)
 516
 517 }
 518
 519 func TestRemoveAndPublishSuccessfully(t *testing.T) {
 520         m, i := setup()
 521
 522         expectedChannelAndEvent := []string{"{namespace},channel", "event"}
 523         expectedKeys := []string{"{namespace},key1", "{namespace},key2"}
 524
 525         m.On("DelMPub", expectedChannelAndEvent, expectedKeys).Return(nil)
 526         err := i.RemoveAndPublish([]string{"channel", "event"}, []string{"key1", "key2"})
 527         assert.Nil(t, err)
 528         m.AssertExpectations(t)
 529 }
 530
 531 func TestRemoveAndPublishSeveralChannelsAndEventsSuccessfully(t *testing.T) {
 532         m, i := setup()
 533
 534         expectedChannelAndEvent := []string{"{namespace},channel1", "event1___event2",
 535                                                                                 "{namespace},channel2", "event3___event4"}
 536         expectedKeys := []string{"{namespace},key1", "{namespace},key2"}
 537
 538         verifyChannelAndEvent := func(input []string) bool {
 539                 return verifySliceInOrder(input, expectedChannelAndEvent)
 540         }
 541         m.On("DelMPub", mock.MatchedBy(verifyChannelAndEvent), expectedKeys).Return(nil)
 542         err := i.RemoveAndPublish([]string{"channel1", "event1", "channel2", "event3",
 543                                                                         "channel1", "event2", "channel2", "event4"},
 544                                                                         []string{"key1", "key2"})
 545         assert.Nil(t, err)
 546         m.AssertExpectations(t)
 547 }
 548 func TestRemoveAndPublishFail(t *testing.T) {
 549         m, i := setup()
 550
 551         expectedChannelAndEvent := []string{"{namespace},channel", "event"}
 552         expectedKeys := []string{"{namespace},key1", "{namespace},key2"}
 553
 554         m.On("DelMPub", expectedChannelAndEvent, expectedKeys).Return(errors.New("Some error"))
 555         err := i.RemoveAndPublish([]string{"channel", "event"}, []string{"key1", "key2"})
 556         assert.NotNil(t, err)
 557         m.AssertExpectations(t)
 558 }
 559
 560 func TestRemoveAndPublishNoChannels(t *testing.T) {
 561         m, i := setup()
 562
 563         expectedKeys := []string{"{namespace},key1", "{namespace},key2"}
 564
 565         m.On("Del", expectedKeys).Return(nil)
 566         err := i.RemoveAndPublish([]string{}, []string{"key1", "key2"})
 567         assert.Nil(t, err)
 568         m.AssertExpectations(t)
 569 }
 570
 571 func TestRemoveAndPublishIncorrectChannel(t *testing.T) {
 572         m, i := setup()
 573
 574         notExpectedChannelAndEvent := []string{}
 575         notExpectedKeys := []string{"{namespace},key"}
 576
 577         m.AssertNotCalled(t, "DelMPub", notExpectedChannelAndEvent, notExpectedKeys)
 578         m.AssertNotCalled(t, "Del", notExpectedKeys)
 579         err := i.RemoveAndPublish([]string{"channel", "event", "channel2"}, []string{})
 580         assert.Nil(t, err)
 581         m.AssertExpectations(t)
 582
 583 }
 584 func TestRemoveAndPublishNoKeys(t *testing.T) {
 585         m, i := setup()
 586
 587         notExpectedChannelAndEvent := []string{}
 588         notExpectedKeys := []string{"{namespace},key"}
 589
 590         m.AssertNotCalled(t, "DelMPub", notExpectedChannelAndEvent, notExpectedKeys)
 591         m.AssertNotCalled(t, "Del", notExpectedKeys)
 592         err := i.RemoveAndPublish([]string{"channel", "event"}, []string{})
 593         assert.Nil(t, err)
 594         m.AssertExpectations(t)
 595 }
 596 func TestRemoveAndPublishNoChannelsError(t *testing.T) {
 597         m, i := setup()
 598
 599         expectedKeys := []string{"{namespace},key1", "{namespace},key2"}
 600
 601         m.On("Del", expectedKeys).Return(errors.New("Some error"))
 602         err := i.RemoveAndPublish([]string{}, []string{"key1", "key2"})
 603         assert.NotNil(t, err)
 604         m.AssertExpectations(t)
 605 }
 606 func TestRemoveSuccessfully(t *testing.T) {
 607         m, i := setup()
 608
 609         msetExpected := []string{"{namespace},key1", "{namespace},key2"}
 610         m.On("Del", msetExpected).Return(nil)
 611
 612         err := i.Remove([]string{"key1", "key2"})
 613         assert.Nil(t, err)
 614         m.AssertExpectations(t)
 615 }
 616
 617 func TestRemoveFail(t *testing.T) {
 618         m, i := setup()
 619
 620         msetExpected := []string{"{namespace},key"}
 621         m.On("Del", msetExpected).Return(errors.New("Some error"))
 622
 623         err := i.Remove([]string{"key"})
 624         assert.NotNil(t, err)
 625         m.AssertExpectations(t)
 626 }
 627
 628 func TestRemoveEmptyList(t *testing.T) {
 629         m, i := setup()
 630
 631         err := i.Remove([]string{})
 632         assert.Nil(t, err)
 633         m.AssertNotCalled(t, "Del", []string{})
 634 }
 635
 636 func TestGetAllSuccessfully(t *testing.T) {
 637         m, i := setup()
 638
 639         mKeysExpected := string("{namespace},*")
 640         mReturnExpected := []string{"{namespace},key1", "{namespace},key2"}
 641         expectedReturn := []string{"key1", "key2"}
 642         m.On("Keys", mKeysExpected).Return(mReturnExpected, nil)
 643         retVal, err := i.GetAll()
 644         assert.Nil(t, err)
 645         assert.Equal(t, expectedReturn, retVal)
 646         m.AssertExpectations(t)
 647 }
 648
 649 func TestGetAllFail(t *testing.T) {
 650         m, i := setup()
 651
 652         mKeysExpected := string("{namespace},*")
 653         mReturnExpected := []string{}
 654         m.On("Keys", mKeysExpected).Return(mReturnExpected, errors.New("some error"))
 655         retVal, err := i.GetAll()
 656         assert.NotNil(t, err)
 657         assert.Nil(t, retVal)
 658         assert.Equal(t, len(retVal), 0)
 659         m.AssertExpectations(t)
 660 }
 661
 662 func TestGetAllReturnEmpty(t *testing.T) {
 663         m, i := setup()
 664
 665         mKeysExpected := string("{namespace},*")
 666         var mReturnExpected []string = nil
 667         m.On("Keys", mKeysExpected).Return(mReturnExpected, nil)
 668         retVal, err := i.GetAll()
 669         assert.Nil(t, err)
 670         assert.Nil(t, retVal)
 671         assert.Equal(t, len(retVal), 0)
 672         m.AssertExpectations(t)
 673
 674 }
 675
 676 func TestRemoveAllSuccessfully(t *testing.T) {
 677         m, i := setup()
 678
 679         mKeysExpected := string("{namespace},*")
 680         mKeysReturn := []string{"{namespace},key1", "{namespace},key2"}
 681         mDelExpected := mKeysReturn
 682         m.On("Keys", mKeysExpected).Return(mKeysReturn, nil)
 683         m.On("Del", mDelExpected).Return(nil)
 684         err := i.RemoveAll()
 685         assert.Nil(t, err)
 686         m.AssertExpectations(t)
 687 }
 688
 689 func TestRemoveAllNoKeysFound(t *testing.T) {
 690         m, i := setup()
 691
 692         mKeysExpected := string("{namespace},*")
 693         var mKeysReturn []string = nil
 694         m.On("Keys", mKeysExpected).Return(mKeysReturn, nil)
 695         m.AssertNumberOfCalls(t, "Del", 0)
 696         err := i.RemoveAll()
 697         assert.Nil(t, err)
 698         m.AssertExpectations(t)
 699 }
 700
 701 func TestRemoveAllKeysReturnError(t *testing.T) {
 702         m, i := setup()
 703
 704         mKeysExpected := string("{namespace},*")
 705         var mKeysReturn []string = nil
 706         m.On("Keys", mKeysExpected).Return(mKeysReturn, errors.New("Some error"))
 707         m.AssertNumberOfCalls(t, "Del", 0)
 708         err := i.RemoveAll()
 709         assert.NotNil(t, err)
 710         m.AssertExpectations(t)
 711 }
 712
 713 func TestRemoveAllDelReturnError(t *testing.T) {
 714         m, i := setup()
 715
 716         mKeysExpected := string("{namespace},*")
 717         mKeysReturn := []string{"{namespace},key1", "{namespace},key2"}
 718         mDelExpected := mKeysReturn
 719         m.On("Keys", mKeysExpected).Return(mKeysReturn, nil)
 720         m.On("Del", mDelExpected).Return(errors.New("Some Error"))
 721         err := i.RemoveAll()
 722         assert.NotNil(t, err)
 723         m.AssertExpectations(t)
 724 }
 725
 726 func TestSetIfSuccessfullyOkStatus(t *testing.T) {
 727         m, i := setup()
 728
 729         mSetIEExpectedKey := string("{namespace},key1")
 730         mSetIEExpectedOldData := interface{}("olddata")
 731         mSetIEExpectedNewData := interface{}("newdata")
 732         m.On("SetIE", mSetIEExpectedKey, mSetIEExpectedOldData, mSetIEExpectedNewData).Return(true, nil)
 733         status, err := i.SetIf("key1", "olddata", "newdata")
 734         assert.Nil(t, err)
 735         assert.True(t, status)
 736         m.AssertExpectations(t)
 737 }
 738
 739 func TestSetIfSuccessfullyNOKStatus(t *testing.T) {
 740         m, i := setup()
 741
 742         mSetIEExpectedKey := string("{namespace},key1")
 743         mSetIEExpectedOldData := interface{}("olddata")
 744         mSetIEExpectedNewData := interface{}("newdata")
 745         m.On("SetIE", mSetIEExpectedKey, mSetIEExpectedOldData, mSetIEExpectedNewData).Return(false, nil)
 746         status, err := i.SetIf("key1", "olddata", "newdata")
 747         assert.Nil(t, err)
 748         assert.False(t, status)
 749         m.AssertExpectations(t)
 750 }
 751
 752 func TestSetIfFailure(t *testing.T) {
 753         m, i := setup()
 754
 755         mSetIEExpectedKey := string("{namespace},key1")
 756         mSetIEExpectedOldData := interface{}("olddata")
 757         mSetIEExpectedNewData := interface{}("newdata")
 758         m.On("SetIE", mSetIEExpectedKey, mSetIEExpectedOldData, mSetIEExpectedNewData).Return(false, errors.New("Some error"))
 759         status, err := i.SetIf("key1", "olddata", "newdata")
 760         assert.NotNil(t, err)
 761         assert.False(t, status)
 762         m.AssertExpectations(t)
 763 }
 764
 765 func TestSetIfAndPublishSuccessfully(t *testing.T) {
 766         m, i := setup()
 767
 768         expectedChannel := "{namespace},channel"
 769         expectedEvent := "event"
 770         expectedKey := "{namespace},key"
 771         expectedOldData := interface{}("olddata")
 772         expectedNewData := interface{}("newdata")
 773         m.On("SetIEPub", expectedChannel, expectedEvent, expectedKey, expectedOldData, expectedNewData).Return(true, nil)
 774         status, err := i.SetIfAndPublish([]string{"channel", "event"}, "key", "olddata", "newdata")
 775         assert.Nil(t, err)
 776         assert.True(t, status)
 777         m.AssertExpectations(t)
 778 }
 779
 780 func TestSetIfAndPublishIncorrectChannelAndEvent(t *testing.T) {
 781         m, i := setup()
 782
 783         expectedChannel := "{namespace},channel"
 784         expectedEvent := "event"
 785         expectedKey := "{namespace},key"
 786         expectedOldData := interface{}("olddata")
 787         expectedNewData := interface{}("newdata")
 788         m.AssertNotCalled(t, "SetIEPub", expectedChannel, expectedEvent, expectedKey, expectedOldData, expectedNewData)
 789         m.AssertNotCalled(t, "SetIE", expectedKey, expectedOldData, expectedNewData)
 790         status, err := i.SetIfAndPublish([]string{"channel", "event1", "channel"}, "key", "olddata", "newdata")
 791         assert.NotNil(t, err)
 792         assert.False(t, status)
 793         m.AssertExpectations(t)
 794 }
 795 func TestSetIfAndPublishNOKStatus(t *testing.T) {
 796         m, i := setup()
 797
 798         expectedChannel := "{namespace},channel"
 799         expectedEvent := "event"
 800         expectedKey := "{namespace},key"
 801         expectedOldData := interface{}("olddata")
 802         expectedNewData := interface{}("newdata")
 803         m.On("SetIEPub", expectedChannel, expectedEvent, expectedKey, expectedOldData, expectedNewData).Return(false, nil)
 804         status, err := i.SetIfAndPublish([]string{"channel", "event"}, "key", "olddata", "newdata")
 805         assert.Nil(t, err)
 806         assert.False(t, status)
 807         m.AssertExpectations(t)
 808 }
 809
 810 func TestSetIfAndPublishNoChannels(t *testing.T) {
 811         m, i := setup()
 812
 813         expectedKey := "{namespace},key"
 814         expectedOldData := interface{}("olddata")
 815         expectedNewData := interface{}("newdata")
 816         m.On("SetIE", expectedKey, expectedOldData, expectedNewData).Return(true, nil)
 817         status, err := i.SetIfAndPublish([]string{}, "key", "olddata", "newdata")
 818         assert.Nil(t, err)
 819         assert.True(t, status)
 820         m.AssertExpectations(t)
 821 }
 822
 823 func TestSetIfNotExistsAndPublishSuccessfully(t *testing.T) {
 824         m, i := setup()
 825
 826         expectedChannel := "{namespace},channel"
 827         expectedEvent := "event"
 828         expectedKey := "{namespace},key"
 829         expectedData := interface{}("data")
 830
 831         m.On("SetNXPub", expectedChannel, expectedEvent, expectedKey, expectedData).Return(true, nil)
 832         status, err := i.SetIfNotExistsAndPublish([]string{"channel", "event"}, "key", "data")
 833         assert.Nil(t, err)
 834         assert.True(t, status)
 835         m.AssertExpectations(t)
 836 }
 837
 838 func TestSetIfNotExistsAndPublishSeveralEvents(t *testing.T) {
 839         m, i := setup()
 840
 841         expectedChannel := "{namespace},channel"
 842         expectedEvent := "event1___event2"
 843         expectedKey := "{namespace},key"
 844         expectedData := interface{}("data")
 845
 846         m.On("SetNXPub", expectedChannel, expectedEvent, expectedKey, expectedData).Return(true, nil)
 847         status, err := i.SetIfNotExistsAndPublish([]string{"channel", "event1", "channel", "event2"}, "key", "data")
 848         assert.Nil(t, err)
 849         assert.True(t, status)
 850         m.AssertExpectations(t)
 851 }
 852
 853 func TestSetIfNotExistsAndPublishNoChannels(t *testing.T) {
 854         m, i := setup()
 855
 856         expectedKey := "{namespace},key"
 857         expectedData := interface{}("data")
 858
 859         m.On("SetNX", expectedKey, expectedData).Return(true, nil)
 860         status, err := i.SetIfNotExistsAndPublish([]string{}, "key", "data")
 861         assert.Nil(t, err)
 862         assert.True(t, status)
 863         m.AssertExpectations(t)
 864 }
 865
 866 func TestSetIfNotExistsAndPublishFail(t *testing.T) {
 867         m, i := setup()
 868
 869         expectedChannel := "{namespace},channel"
 870         expectedEvent := "event"
 871         expectedKey := "{namespace},key"
 872         expectedData := interface{}("data")
 873
 874         m.On("SetNXPub", expectedChannel, expectedEvent, expectedKey, expectedData).Return(false, nil)
 875         status, err := i.SetIfNotExistsAndPublish([]string{"channel", "event"}, "key", "data")
 876         assert.Nil(t, err)
 877         assert.False(t, status)
 878         m.AssertExpectations(t)
 879 }
 880
 881 func TestSetIfNotExistsAndPublishIncorrectChannels(t *testing.T) {
 882         m, i := setup()
 883
 884         expectedChannel := "{namespace},channel"
 885         expectedEvent := "event"
 886         expectedKey := "{namespace},key"
 887         expectedData := interface{}("data")
 888
 889         m.AssertNotCalled(t, "SetNXPub", expectedChannel, expectedEvent, expectedKey, expectedData)
 890         m.AssertNotCalled(t, "SetNX", expectedKey, expectedData)
 891         status, err := i.SetIfNotExistsAndPublish([]string{"channel", "event", "channel2"}, "key", "data")
 892         assert.NotNil(t, err)
 893         assert.False(t, status)
 894         m.AssertExpectations(t)
 895 }
 896
 897 func TestSetIfNotExistsAndPublishError(t *testing.T) {
 898         m, i := setup()
 899
 900         expectedChannel := "{namespace},channel"
 901         expectedEvent := "event"
 902         expectedKey := "{namespace},key"
 903         expectedData := interface{}("data")
 904
 905         m.On("SetNXPub", expectedChannel, expectedEvent, expectedKey, expectedData).Return(false, errors.New("Some error"))
 906         status, err := i.SetIfNotExistsAndPublish([]string{"channel", "event"}, "key", "data")
 907         assert.NotNil(t, err)
 908         assert.False(t, status)
 909         m.AssertExpectations(t)
 910 }
 911
 912 func TestSetIfNotExistsSuccessfullyOkStatus(t *testing.T) {
 913         m, i := setup()
 914
 915         mSetNXExpectedKey := string("{namespace},key1")
 916         mSetNXExpectedData := interface{}("data")
 917         m.On("SetNX", mSetNXExpectedKey, mSetNXExpectedData).Return(true, nil)
 918         status, err := i.SetIfNotExists("key1", "data")
 919         assert.Nil(t, err)
 920         assert.True(t, status)
 921         m.AssertExpectations(t)
 922 }
 923
 924 func TestSetIfNotExistsSuccessfullyNOKStatus(t *testing.T) {
 925         m, i := setup()
 926
 927         mSetNXExpectedKey := string("{namespace},key1")
 928         mSetNXExpectedData := interface{}("data")
 929         m.On("SetNX", mSetNXExpectedKey, mSetNXExpectedData).Return(false, nil)
 930         status, err := i.SetIfNotExists("key1", "data")
 931         assert.Nil(t, err)
 932         assert.False(t, status)
 933         m.AssertExpectations(t)
 934 }
 935
 936 func TestSetIfNotExistsFailure(t *testing.T) {
 937         m, i := setup()
 938
 939         mSetNXExpectedKey := string("{namespace},key1")
 940         mSetNXExpectedData := interface{}("data")
 941         m.On("SetNX", mSetNXExpectedKey, mSetNXExpectedData).Return(false, errors.New("Some error"))
 942         status, err := i.SetIfNotExists("key1", "data")
 943         assert.NotNil(t, err)
 944         assert.False(t, status)
 945         m.AssertExpectations(t)
 946 }
 947
 948 func TestRemoveIfAndPublishSuccessfully(t *testing.T) {
 949         m, i := setup()
 950
 951         expectedChannel := "{namespace},channel"
 952         expectedEvent := "event1___event2"
 953         expectedKey := "{namespace},key"
 954         expectedValue := interface{}("data")
 955
 956         m.On("DelIEPub", expectedChannel, expectedEvent, expectedKey, expectedValue).Return(true, nil)
 957         status, err := i.RemoveIfAndPublish([]string{"channel", "event1", "channel", "event2"}, "key", "data")
 958         assert.Nil(t, err)
 959         assert.True(t, status)
 960         m.AssertExpectations(t)
 961 }
 962
 963 func TestRemoveIfAndPublishNok(t *testing.T) {
 964         m, i := setup()
 965
 966         expectedChannel := "{namespace},channel"
 967         expectedEvent := "event1___event2"
 968         expectedKey := "{namespace},key"
 969         expectedValue := interface{}("data")
 970
 971         m.On("DelIEPub", expectedChannel, expectedEvent, expectedKey, expectedValue).Return(false, nil)
 972         status, err := i.RemoveIfAndPublish([]string{"channel", "event1", "channel", "event2"}, "key", "data")
 973         assert.Nil(t, err)
 974         assert.False(t, status)
 975         m.AssertExpectations(t)
 976 }
 977
 978 func TestRemoveIfAndPublishError(t *testing.T) {
 979         m, i := setup()
 980
 981         expectedChannel := "{namespace},channel"
 982         expectedEvent := "event1___event2"
 983         expectedKey := "{namespace},key"
 984         expectedValue := interface{}("data")
 985
 986         m.On("DelIEPub", expectedChannel, expectedEvent, expectedKey, expectedValue).Return(false, errors.New("Some error"))
 987         status, err := i.RemoveIfAndPublish([]string{"channel", "event1", "channel", "event2"}, "key", "data")
 988         assert.NotNil(t, err)
 989         assert.False(t, status)
 990         m.AssertExpectations(t)
 991 }
 992
 993 func TestRemoveIfAndPublishIncorrectChannel(t *testing.T) {
 994         m, i := setup()
 995
 996         expectedChannel := "{namespace},channel"
 997         expectedEvent := "event"
 998         expectedKey := "{namespace},key"
 999         expectedValue := interface{}("data")
1000
1001         m.AssertNotCalled(t, "DelIEPub", expectedChannel, expectedEvent, expectedKey, expectedValue)
1002         m.AssertNotCalled(t, "DelIE", expectedKey, expectedValue)
1003         status, err := i.RemoveIfAndPublish([]string{"channel", "event1", "channel"}, "key", "data")
1004         assert.NotNil(t, err)
1005         assert.False(t, status)
1006         m.AssertExpectations(t)
1007 }
1008
1009 func TestRemoveIfAndPublishNoChannels(t *testing.T) {
1010         m, i := setup()
1011
1012         expectedKey := "{namespace},key"
1013         expectedValue := interface{}("data")
1014
1015         m.On("DelIE", expectedKey, expectedValue).Return(true, nil)
1016         status, err := i.RemoveIfAndPublish([]string{}, "key", "data")
1017         assert.Nil(t, err)
1018         assert.True(t, status)
1019         m.AssertExpectations(t)
1020
1021 }
1022 func TestRemoveIfSuccessfullyOkStatus(t *testing.T) {
1023         m, i := setup()
1024
1025         mDelIEExpectedKey := string("{namespace},key1")
1026         mDelIEExpectedData := interface{}("data")
1027         m.On("DelIE", mDelIEExpectedKey, mDelIEExpectedData).Return(true, nil)
1028         status, err := i.RemoveIf("key1", "data")
1029         assert.Nil(t, err)
1030         assert.True(t, status)
1031         m.AssertExpectations(t)
1032 }
1033
1034 func TestRemoveIfSuccessfullyNOKStatus(t *testing.T) {
1035         m, i := setup()
1036
1037         mDelIEExpectedKey := string("{namespace},key1")
1038         mDelIEExpectedData := interface{}("data")
1039         m.On("DelIE", mDelIEExpectedKey, mDelIEExpectedData).Return(false, nil)
1040         status, err := i.RemoveIf("key1", "data")
1041         assert.Nil(t, err)
1042         assert.False(t, status)
1043         m.AssertExpectations(t)
1044 }
1045
1046 func TestRemoveIfFailure(t *testing.T) {
1047         m, i := setup()
1048
1049         mDelIEExpectedKey := string("{namespace},key1")
1050         mDelIEExpectedData := interface{}("data")
1051         m.On("DelIE", mDelIEExpectedKey, mDelIEExpectedData).Return(true, errors.New("Some error"))
1052         status, err := i.RemoveIf("key1", "data")
1053         assert.NotNil(t, err)
1054         assert.False(t, status)
1055         m.AssertExpectations(t)
1056 }
1057
1058 func TestRemoveAllAndPublishSuccessfully(t *testing.T) {
1059         m, i := setup()
1060
1061         mKeysExpected := string("{namespace},*")
1062         mKeysReturn := []string{"{namespace},key1", "{namespace},key2"}
1063         mDelExpected := mKeysReturn
1064         expectedChannelAndEvent := []string{"{namespace},channel", "event"}
1065         m.On("Keys", mKeysExpected).Return(mKeysReturn, nil)
1066         m.On("DelMPub", expectedChannelAndEvent, mDelExpected).Return(nil)
1067         err := i.RemoveAllAndPublish([]string{"channel", "event"})
1068         assert.Nil(t, err)
1069         m.AssertExpectations(t)
1070 }
1071
1072 func TestRemoveAllAndPublishKeysReturnError(t *testing.T) {
1073         m, i := setup()
1074
1075         mKeysExpected := string("{namespace},*")
1076         mKeysReturn := []string{"{namespace},key1", "{namespace},key2"}
1077         mDelExpected := mKeysReturn
1078         expectedChannelAndEvent := []string{"{namespace},channel", "event" }
1079         m.On("Keys", mKeysExpected).Return(mKeysReturn, errors.New("Some error"))
1080         m.AssertNotCalled(t, "DelMPub", expectedChannelAndEvent, mDelExpected)
1081         err := i.RemoveAllAndPublish([]string{"channel", "event"})
1082         assert.NotNil(t, err)
1083         m.AssertExpectations(t)
1084 }
1085
1086 func TestRemoveAllAndPublishKeysDelReturnsError(t *testing.T) {
1087         m, i := setup()
1088
1089         mKeysExpected := string("{namespace},*")
1090         mKeysReturn := []string{"{namespace},key1", "{namespace},key2"}
1091         mDelExpected := mKeysReturn
1092         expectedChannelAndEvent := []string{"{namespace},channel", "event"}
1093         m.On("Keys", mKeysExpected).Return(mKeysReturn, nil)
1094         m.On("DelMPub", expectedChannelAndEvent, mDelExpected).Return(errors.New("Some error"))
1095         err := i.RemoveAllAndPublish([]string{"channel", "event"})
1096         assert.NotNil(t, err)
1097         m.AssertExpectations(t)
1098 }
1099
1100 func TestRemoveAllAndPublishKeysEventsWithIllegalCharacters(t *testing.T) {
1101         m, i := setup()
1102
1103         mKeysExpected := string("{namespace},*")
1104         mKeysReturn := []string{"{namespace},key1", "{namespace},key2"}
1105         mDelExpected := mKeysReturn
1106         expectedChannelAndEvent := []string{"{namespace},channel", "event"}
1107         m.On("Keys", mKeysExpected).Return(mKeysReturn, nil)
1108         m.AssertNotCalled(t, "DelMPub", expectedChannelAndEvent, mDelExpected)
1109         err := i.RemoveAllAndPublish([]string{"channel", "event___anotherEvent"})
1110         assert.NotNil(t, err)
1111         m.AssertExpectations(t)
1112
1113 }
1114
1115 func TestRemoveAllAndPublishNoChannels(t *testing.T) {
1116         m, i := setup()
1117
1118         mKeysExpected := string("{namespace},*")
1119         mKeysReturn := []string{"{namespace},key1", "{namespace},key2"}
1120         mDelExpected := mKeysReturn
1121         m.On("Keys", mKeysExpected).Return(mKeysReturn, nil)
1122         m.On("Del", mDelExpected).Return(nil)
1123         m.AssertNotCalled(t, "DelMPub", "", "", mDelExpected)
1124         err := i.RemoveAllAndPublish([]string{})
1125         assert.Nil(t, err)
1126         m.AssertExpectations(t)
1127 }
1128
1129 func TestRemoveAllAndPublishIncorrectChannel(t *testing.T) {
1130         m, i := setup()
1131
1132         mKeysExpected := string("{namespace},*")
1133         mKeysReturn := []string{"{namespace},key1", "{namespace},key2"}
1134         mDelExpected := mKeysReturn
1135         m.On("Keys", mKeysExpected).Return(mKeysReturn, nil)
1136         m.AssertNotCalled(t, "DelMPub", "", "", mDelExpected)
1137         err := i.RemoveAllAndPublish([]string{"channel", "event", "channel2"})
1138         assert.NotNil(t, err)
1139         m.AssertExpectations(t)
1140
1141 }
1142
1143 func TestAddMemberSuccessfully(t *testing.T) {
1144         m, i := setup()
1145
1146         groupExpected := string("{namespace},group")
1147         membersExpected := []interface{}{"member1", "member2"}
1148
1149         m.On("SAdd", groupExpected, membersExpected).Return(nil)
1150
1151         err := i.AddMember("group", "member1", "member2")
1152         assert.Nil(t, err)
1153         m.AssertExpectations(t)
1154 }
1155
1156 func TestAddMemberFail(t *testing.T) {
1157         m, i := setup()
1158
1159         groupExpected := string("{namespace},group")
1160         membersExpected := []interface{}{"member1", "member2"}
1161
1162         m.On("SAdd", groupExpected, membersExpected).Return(errors.New("Some error"))
1163
1164         err := i.AddMember("group", "member1", "member2")
1165         assert.NotNil(t, err)
1166         m.AssertExpectations(t)
1167 }
1168 func TestRemoveMemberSuccessfully(t *testing.T) {
1169         m, i := setup()
1170
1171         groupExpected := string("{namespace},group")
1172         membersExpected := []interface{}{"member1", "member2"}
1173
1174         m.On("SRem", groupExpected, membersExpected).Return(nil)
1175
1176         err := i.RemoveMember("group", "member1", "member2")
1177         assert.Nil(t, err)
1178         m.AssertExpectations(t)
1179 }
1180
1181 func TestRemoveMemberFail(t *testing.T) {
1182         m, i := setup()
1183
1184         groupExpected := string("{namespace},group")
1185         membersExpected := []interface{}{"member1", "member2"}
1186
1187         m.On("SRem", groupExpected, membersExpected).Return(errors.New("Some error"))
1188
1189         err := i.RemoveMember("group", "member1", "member2")
1190         assert.NotNil(t, err)
1191         m.AssertExpectations(t)
1192 }
1193
1194 func TestRemoveGroupSuccessfully(t *testing.T) {
1195         m, i := setup()
1196
1197         groupExpected := []string{"{namespace},group"}
1198
1199         m.On("Del", groupExpected).Return(nil)
1200
1201         err := i.RemoveGroup("group")
1202         assert.Nil(t, err)
1203         m.AssertExpectations(t)
1204 }
1205 func TestRemoveGroupFail(t *testing.T) {
1206         m, i := setup()
1207
1208         groupExpected := []string{"{namespace},group"}
1209
1210         m.On("Del", groupExpected).Return(errors.New("Some error"))
1211
1212         err := i.RemoveGroup("group")
1213         assert.NotNil(t, err)
1214         m.AssertExpectations(t)
1215 }
1216
1217 func TestGetMembersSuccessfully(t *testing.T) {
1218         m, i := setup()
1219
1220         groupExpected := "{namespace},group"
1221         returnExpected := []string{"member1", "member2"}
1222
1223         m.On("SMembers", groupExpected).Return(returnExpected, nil)
1224
1225         result, err := i.GetMembers("group")
1226         assert.Nil(t,err)
1227         assert.Equal(t, result, returnExpected)
1228         m.AssertExpectations(t)
1229 }
1230 func TestGetMembersFail(t *testing.T) {
1231         m, i := setup()
1232
1233         groupExpected := "{namespace},group"
1234         returnExpected := []string{"member1", "member2"}
1235
1236         m.On("SMembers", groupExpected).Return(returnExpected, errors.New("Some error"))
1237
1238         result, err := i.GetMembers("group")
1239         assert.NotNil(t,err)
1240         assert.Equal(t, []string{}, result)
1241         m.AssertExpectations(t)
1242 }
1243
1244 func TestIsMemberSuccessfullyIsMember(t *testing.T) {
1245         m, i := setup()
1246
1247         groupExpected := "{namespace},group"
1248         memberExpected := "member"
1249
1250         m.On("SIsMember", groupExpected, memberExpected).Return(true, nil)
1251
1252         result, err := i.IsMember("group", "member")
1253         assert.Nil(t, err)
1254         assert.True(t, result)
1255         m.AssertExpectations(t)
1256 }
1257 func TestIsMemberSuccessfullyIsNotMember(t *testing.T) {
1258         m, i := setup()
1259
1260         groupExpected := "{namespace},group"
1261         memberExpected := "member"
1262
1263         m.On("SIsMember", groupExpected, memberExpected).Return(false, nil)
1264
1265         result, err := i.IsMember("group", "member")
1266         assert.Nil(t, err)
1267         assert.False(t, result)
1268         m.AssertExpectations(t)
1269 }
1270 func TestIsMemberFailure(t *testing.T) {
1271         m, i := setup()
1272
1273         groupExpected := "{namespace},group"
1274         memberExpected := "member"
1275
1276         m.On("SIsMember", groupExpected, memberExpected).Return(true, errors.New("Some error"))
1277
1278         result, err := i.IsMember("group", "member")
1279         assert.NotNil(t, err)
1280         assert.False(t, result)
1281         m.AssertExpectations(t)
1282 }
1283
1284 func TestGroupSizeSuccessfully(t *testing.T) {
1285         m, i := setup()
1286
1287         var expectedSize int64
1288         expectedSize = 2
1289         groupExpected := "{namespace},group"
1290
1291         m.On("SCard", groupExpected).Return(expectedSize, nil)
1292
1293         result, err := i.GroupSize("group")
1294         assert.Nil(t, err)
1295         assert.Equal(t, expectedSize, result)
1296         m.AssertExpectations(t)
1297 }
1298 func TestGroupSizeFail(t *testing.T) {
1299         m, i := setup()
1300
1301         var expectedSize int64
1302         expectedSize = 2
1303         groupExpected := "{namespace},group"
1304
1305         m.On("SCard", groupExpected).Return(expectedSize, errors.New("Some error"))
1306
1307         result, err := i.GroupSize("group")
1308         assert.NotNil(t, err)
1309         assert.Equal(t, int64(0), result)
1310         m.AssertExpectations(t)
1311 }