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