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 setup() (*mockDB, *sdlgo.SdlInstance) {
 108         m := new(mockDB)
 109         i := sdlgo.NewSdlInstance("namespace", m)
 110         return m, i
 111 }
 112
 113 func TestSubscribeChannel(t *testing.T) {
 114         m, i := setup()
 115
 116         expectedCB := func(channel string, events ...string) {}
 117         expectedChannels := []string{"{namespace},channel1", "{namespace},channel2"}
 118
 119         m.On("SubscribeChannelDB", mock.AnythingOfType("sdlgoredis.ChannelNotificationCb"), "{namespace},", "___", expectedChannels).Return()
 120         i.SubscribeChannel(expectedCB, "channel1", "channel2")
 121         m.AssertExpectations(t)
 122 }
 123
 124 func TestUnsubscribeChannel(t *testing.T) {
 125         m, i := setup()
 126
 127         expectedChannels := []string{"{namespace},channel1", "{namespace},channel2"}
 128
 129         m.On("UnsubscribeChannelDB", expectedChannels).Return()
 130         i.UnsubscribeChannel("channel1", "channel2")
 131         m.AssertExpectations(t)
 132 }
 133 func TestGetOneKey(t *testing.T) {
 134         m, i := setup()
 135
 136         mgetExpected := []string{"{namespace},key"}
 137         mReturn := []interface{}{"somevalue"}
 138         mReturnExpected := make(map[string]interface{})
 139         mReturnExpected["key"] = "somevalue"
 140
 141         m.On("MGet", mgetExpected).Return(mReturn, nil)
 142         retVal, err := i.Get([]string{"key"})
 143         assert.Nil(t, err)
 144         assert.Equal(t, mReturnExpected, retVal)
 145         m.AssertExpectations(t)
 146 }
 147
 148 func TestGetSeveralKeys(t *testing.T) {
 149         m, i := setup()
 150
 151         mgetExpected := []string{"{namespace},key1", "{namespace},key2", "{namespace},key3"}
 152         mReturn := []interface{}{"somevalue1", 2, "someothervalue"}
 153         mReturnExpected := make(map[string]interface{})
 154         mReturnExpected["key1"] = "somevalue1"
 155         mReturnExpected["key2"] = 2
 156         mReturnExpected["key3"] = "someothervalue"
 157
 158         m.On("MGet", mgetExpected).Return(mReturn, nil)
 159         retVal, err := i.Get([]string{"key1", "key2", "key3"})
 160         assert.Nil(t, err)
 161         assert.Equal(t, mReturnExpected, retVal)
 162         m.AssertExpectations(t)
 163 }
 164
 165 func TestGetSeveralKeysSomeFail(t *testing.T) {
 166         m, i := setup()
 167
 168         mgetExpected := []string{"{namespace},key1", "{namespace},key2", "{namespace},key3"}
 169         mReturn := []interface{}{"somevalue1", nil, "someothervalue"}
 170         mReturnExpected := make(map[string]interface{})
 171         mReturnExpected["key1"] = "somevalue1"
 172         mReturnExpected["key2"] = nil
 173         mReturnExpected["key3"] = "someothervalue"
 174
 175         m.On("MGet", mgetExpected).Return(mReturn, nil)
 176         retVal, err := i.Get([]string{"key1", "key2", "key3"})
 177         assert.Nil(t, err)
 178         assert.Equal(t, mReturnExpected, retVal)
 179         m.AssertExpectations(t)
 180 }
 181
 182 func TestGetKeyReturnError(t *testing.T) {
 183         m, i := setup()
 184
 185         mgetExpected := []string{"{namespace},key"}
 186         mReturn := []interface{}{nil}
 187         mReturnExpected := make(map[string]interface{})
 188
 189         m.On("MGet", mgetExpected).Return(mReturn, errors.New("Some error"))
 190         retVal, err := i.Get([]string{"key"})
 191         assert.NotNil(t, err)
 192         assert.Equal(t, mReturnExpected, retVal)
 193         m.AssertExpectations(t)
 194 }
 195
 196 func TestGetEmptyList(t *testing.T) {
 197         m, i := setup()
 198
 199         mgetExpected := []string{}
 200
 201         retval, err := i.Get([]string{})
 202         assert.Nil(t, err)
 203         assert.Len(t, retval, 0)
 204         m.AssertNotCalled(t, "MGet", mgetExpected)
 205 }
 206
 207 func TestWriteOneKey(t *testing.T) {
 208         m, i := setup()
 209
 210         msetExpected := []interface{}{"{namespace},key1", "data1"}
 211
 212         m.On("MSet", msetExpected).Return(nil)
 213         err := i.Set("key1", "data1")
 214         assert.Nil(t, err)
 215         m.AssertExpectations(t)
 216 }
 217
 218 func TestWriteByteSliceAsValue(t *testing.T) {
 219         m, i := setup()
 220
 221         msetExpected := []interface{}{"{namespace},key1", []byte{1, 2, 3, 4, 5}}
 222
 223         m.On("MSet", msetExpected).Return(nil)
 224         err := i.Set("key1", []byte{1, 2, 3, 4, 5})
 225         assert.Nil(t, err)
 226         m.AssertExpectations(t)
 227 }
 228
 229 func TestWriteByteSliceAsValueMixed(t *testing.T) {
 230         m, i := setup()
 231
 232         msetExpected := []interface{}{"{namespace},key1", []byte{1, 2, 3, 4, 5}, "{namespace},key2", "value2"}
 233
 234         m.On("MSet", msetExpected).Return(nil)
 235         err := i.Set("key1", []byte{1, 2, 3, 4, 5}, []string{"key2", "value2"})
 236         assert.Nil(t, err)
 237         m.AssertExpectations(t)
 238 }
 239
 240 func TestWriteByteArrayAsValue(t *testing.T) {
 241         m, i := setup()
 242
 243         msetExpected := []interface{}{"{namespace},key1", [5]byte{1, 2, 3, 4, 5}}
 244
 245         m.On("MSet", msetExpected).Return(nil)
 246         err := i.Set("key1", [5]byte{1, 2, 3, 4, 5})
 247         assert.Nil(t, err)
 248         m.AssertExpectations(t)
 249 }
 250
 251 func TestWriteMixed(t *testing.T) {
 252         m, i := setup()
 253
 254         msetExpected := []interface{}{"{namespace},key1", "data1", "{namespace},key2", "data2", "{namespace},key3", "data3"}
 255
 256         m.On("MSet", msetExpected).Return(nil)
 257         err := i.Set("key1", "data1", []string{"key2", "data2"}, [2]string{"key3", "data3"})
 258         assert.Nil(t, err)
 259         m.AssertExpectations(t)
 260 }
 261
 262 func TestWriteIncorrectMixed(t *testing.T) {
 263         m, i := setup()
 264
 265         msetExpected := []interface{}{"{namespace},key1", "data1", "{namespace},key2", "data2", "{namespace},key3", "data3"}
 266
 267         m.AssertNotCalled(t, "MSet", msetExpected)
 268         err := i.Set("key1", []string{"key2", "data2"}, [2]string{"key3", "data3"})
 269         assert.NotNil(t, err)
 270         m.AssertExpectations(t)
 271 }
 272 func TestWriteIncorrectPairs(t *testing.T) {
 273         m, i := setup()
 274
 275         msetExpected := []interface{}{}
 276
 277         m.AssertNotCalled(t, "MSet", msetExpected)
 278         err := i.Set("key")
 279         assert.NotNil(t, err)
 280         m.AssertExpectations(t)
 281 }
 282 func TestWriteSeveralKeysSlice(t *testing.T) {
 283         m, i := setup()
 284
 285         msetExpected := []interface{}{"{namespace},key1", "data1", "{namespace},key2", 22}
 286
 287         m.On("MSet", msetExpected).Return(nil)
 288         err := i.Set([]interface{}{"key1", "data1", "key2", 22})
 289         assert.Nil(t, err)
 290         m.AssertExpectations(t)
 291
 292 }
 293
 294 func TestWriteSeveralKeysIncorrectSlice(t *testing.T) {
 295         m, i := setup()
 296
 297         msetExpected := []interface{}{"{namespace},key1", "data1", "{namespace},key2", 22}
 298
 299         m.AssertNotCalled(t, "MSet", msetExpected)
 300         err := i.Set([]interface{}{"key1", "data1", "key2"})
 301         assert.NotNil(t, err)
 302         m.AssertExpectations(t)
 303
 304 }
 305
 306 func TestWriteSeveralKeysArray(t *testing.T) {
 307         m, i := setup()
 308
 309         msetExpected := []interface{}{"{namespace},key1", "data1", "{namespace},key2", "data2"}
 310
 311         m.On("MSet", msetExpected).Return(nil)
 312         err := i.Set([4]string{"key1", "data1", "key2", "data2"})
 313         assert.Nil(t, err)
 314         m.AssertExpectations(t)
 315 }
 316
 317 func TestWriteSeveralKeysIncorrectArray(t *testing.T) {
 318         m, i := setup()
 319
 320         msetExpected := []interface{}{}
 321
 322         m.AssertNotCalled(t, "MSet", msetExpected)
 323         err := i.Set([3]string{"key1", "data1", "key2"})
 324         assert.NotNil(t, err)
 325         m.AssertExpectations(t)
 326 }
 327
 328 func TestWriteFail(t *testing.T) {
 329         m, i := setup()
 330
 331         msetExpected := []interface{}{"{namespace},key1", "data1"}
 332
 333         m.On("MSet", msetExpected).Return(errors.New("Some error"))
 334         err := i.Set("key1", "data1")
 335         assert.NotNil(t, err)
 336         m.AssertExpectations(t)
 337 }
 338
 339 func TestWriteEmptyList(t *testing.T) {
 340         m, i := setup()
 341
 342         msetExpected := []interface{}{}
 343         err := i.Set()
 344         assert.Nil(t, err)
 345         m.AssertNotCalled(t, "MSet", msetExpected)
 346 }
 347
 348 func TestWriteAndPublishOneKeyOneChannel(t *testing.T) {
 349         m, i := setup()
 350
 351         expectedChannel := "{namespace},channel"
 352         expectedMessage := "event"
 353         expectedKeyVal := []interface{}{"{namespace},key1", "data1"}
 354
 355         m.On("MSetPub", expectedChannel, expectedMessage, expectedKeyVal).Return(nil)
 356         m.AssertNotCalled(t, "MSet", expectedKeyVal)
 357         err := i.SetAndPublish([]string{"channel", "event"}, "key1", "data1")
 358         assert.Nil(t, err)
 359         m.AssertExpectations(t)
 360 }
 361 func TestWriteAndPublishOneKeyOneChannelTwoEvents(t *testing.T) {
 362         m, i := setup()
 363
 364         expectedChannel := "{namespace},channel"
 365         expectedMessage := "event1___event2"
 366         expectedKeyVal := []interface{}{"{namespace},key1", "data1"}
 367
 368         m.On("MSetPub", expectedChannel, expectedMessage, expectedKeyVal).Return(nil)
 369         m.AssertNotCalled(t, "MSet", expectedKeyVal)
 370         err := i.SetAndPublish([]string{"channel", "event1", "channel", "event2"}, "key1", "data1")
 371         assert.Nil(t, err)
 372         m.AssertExpectations(t)
 373 }
 374
 375 func TestWriteAndPublishIncorrectChannelAndEvent(t *testing.T) {
 376         m, i := setup()
 377
 378         expectedChannel := "{namespace},channel"
 379         expectedMessage := "event1___event2"
 380         expectedKeyVal := []interface{}{"{namespace},key1", "data1"}
 381         m.AssertNotCalled(t, "MSetPub", expectedChannel, expectedMessage, expectedKeyVal)
 382         m.AssertNotCalled(t, "MSet", expectedKeyVal)
 383         err := i.SetAndPublish([]string{"channel", "event1", "channel"}, "key1", "data1")
 384         assert.NotNil(t, err)
 385         m.AssertExpectations(t)
 386 }
 387
 388 func TestWriteAndPublishNotAllowedCharactersInEvents(t *testing.T) {
 389         m, i := setup()
 390
 391         expectedChannel := "{namespace},channel"
 392         expectedMessage := "event1___event2"
 393         expectedKeyVal := []interface{}{"{namespace},key1", "data1"}
 394         m.AssertNotCalled(t, "MSetPub", expectedChannel, expectedMessage, expectedKeyVal)
 395         m.AssertNotCalled(t, "MSet", expectedKeyVal)
 396         err := i.SetAndPublish([]string{"channel", "event1___event2"}, "key1", "data1")
 397         assert.NotNil(t, err)
 398         m.AssertExpectations(t)
 399 }
 400
 401 func TestWriteAndPublishNoData(t *testing.T) {
 402         m, i := setup()
 403
 404         expectedChannel := "{namespace},channel"
 405         expectedMessage := "event"
 406         expectedKeyVal := []interface{}{"key"}
 407
 408         m.AssertNotCalled(t, "MSetPub", expectedChannel, expectedMessage, expectedKeyVal)
 409         m.AssertNotCalled(t, "MSet", expectedKeyVal)
 410         err := i.SetAndPublish([]string{"channel", "event"}, []interface{}{"key"})
 411         assert.NotNil(t, err)
 412         m.AssertExpectations(t)
 413 }
 414
 415 func TestWriteAndPublishNoChannelEvent(t *testing.T) {
 416         m, i := setup()
 417
 418         expectedKeyVal := []interface{}{"{namespace},key1", "data1"}
 419
 420         m.On("MSet", expectedKeyVal).Return(nil)
 421         m.AssertNotCalled(t, "MSetPub", "", "", expectedKeyVal)
 422         err := i.SetAndPublish([]string{}, "key1", "data1")
 423         assert.Nil(t, err)
 424         m.AssertExpectations(t)
 425
 426 }
 427
 428 func TestRemoveAndPublishSuccessfully(t *testing.T) {
 429         m, i := setup()
 430
 431         expectedChannel := "{namespace},channel"
 432         expectedEvent := "event"
 433         expectedKeys := []string{"{namespace},key1", "{namespace},key2"}
 434
 435         m.On("DelPub", expectedChannel, expectedEvent, expectedKeys).Return(nil)
 436         err := i.RemoveAndPublish([]string{"channel", "event"}, []string{"key1", "key2"})
 437         assert.Nil(t, err)
 438         m.AssertExpectations(t)
 439 }
 440 func TestRemoveAndPublishFail(t *testing.T) {
 441         m, i := setup()
 442
 443         expectedChannel := "{namespace},channel"
 444         expectedEvent := "event"
 445         expectedKeys := []string{"{namespace},key1", "{namespace},key2"}
 446
 447         m.On("DelPub", expectedChannel, expectedEvent, expectedKeys).Return(errors.New("Some error"))
 448         err := i.RemoveAndPublish([]string{"channel", "event"}, []string{"key1", "key2"})
 449         assert.NotNil(t, err)
 450         m.AssertExpectations(t)
 451 }
 452
 453 func TestRemoveAndPublishNoChannels(t *testing.T) {
 454         m, i := setup()
 455
 456         expectedKeys := []string{"{namespace},key1", "{namespace},key2"}
 457
 458         m.On("Del", expectedKeys).Return(nil)
 459         err := i.RemoveAndPublish([]string{}, []string{"key1", "key2"})
 460         assert.Nil(t, err)
 461         m.AssertExpectations(t)
 462 }
 463
 464 func TestRemoveAndPublishIncorrectChannel(t *testing.T) {
 465         m, i := setup()
 466
 467         notExpectedChannel := "{namespace},channel"
 468         notExpectedEvent := "event"
 469         notExpectedKeys := []string{"{namespace},key"}
 470
 471         m.AssertNotCalled(t, "DelPub", notExpectedChannel, notExpectedEvent, notExpectedKeys)
 472         m.AssertNotCalled(t, "Del", notExpectedKeys)
 473         err := i.RemoveAndPublish([]string{"channel", "event", "channel2"}, []string{})
 474         assert.Nil(t, err)
 475         m.AssertExpectations(t)
 476
 477 }
 478 func TestRemoveAndPublishNoKeys(t *testing.T) {
 479         m, i := setup()
 480
 481         notExpectedChannel := "{namespace},channel"
 482         notExpectedEvent := "event"
 483         notExpectedKeys := []string{"{namespace},key"}
 484
 485         m.AssertNotCalled(t, "DelPub", notExpectedChannel, notExpectedEvent, notExpectedKeys)
 486         m.AssertNotCalled(t, "Del", notExpectedKeys)
 487         err := i.RemoveAndPublish([]string{"channel", "event"}, []string{})
 488         assert.Nil(t, err)
 489         m.AssertExpectations(t)
 490 }
 491 func TestRemoveAndPublishNoChannelsError(t *testing.T) {
 492         m, i := setup()
 493
 494         expectedKeys := []string{"{namespace},key1", "{namespace},key2"}
 495
 496         m.On("Del", expectedKeys).Return(errors.New("Some error"))
 497         err := i.RemoveAndPublish([]string{}, []string{"key1", "key2"})
 498         assert.NotNil(t, err)
 499         m.AssertExpectations(t)
 500 }
 501 func TestRemoveSuccessfully(t *testing.T) {
 502         m, i := setup()
 503
 504         msetExpected := []string{"{namespace},key1", "{namespace},key2"}
 505         m.On("Del", msetExpected).Return(nil)
 506
 507         err := i.Remove([]string{"key1", "key2"})
 508         assert.Nil(t, err)
 509         m.AssertExpectations(t)
 510 }
 511
 512 func TestRemoveFail(t *testing.T) {
 513         m, i := setup()
 514
 515         msetExpected := []string{"{namespace},key"}
 516         m.On("Del", msetExpected).Return(errors.New("Some error"))
 517
 518         err := i.Remove([]string{"key"})
 519         assert.NotNil(t, err)
 520         m.AssertExpectations(t)
 521 }
 522
 523 func TestRemoveEmptyList(t *testing.T) {
 524         m, i := setup()
 525
 526         err := i.Remove([]string{})
 527         assert.Nil(t, err)
 528         m.AssertNotCalled(t, "Del", []string{})
 529 }
 530
 531 func TestGetAllSuccessfully(t *testing.T) {
 532         m, i := setup()
 533
 534         mKeysExpected := string("{namespace},*")
 535         mReturnExpected := []string{"{namespace},key1", "{namespace},key2"}
 536         expectedReturn := []string{"key1", "key2"}
 537         m.On("Keys", mKeysExpected).Return(mReturnExpected, nil)
 538         retVal, err := i.GetAll()
 539         assert.Nil(t, err)
 540         assert.Equal(t, expectedReturn, retVal)
 541         m.AssertExpectations(t)
 542 }
 543
 544 func TestGetAllFail(t *testing.T) {
 545         m, i := setup()
 546
 547         mKeysExpected := string("{namespace},*")
 548         mReturnExpected := []string{}
 549         m.On("Keys", mKeysExpected).Return(mReturnExpected, errors.New("some error"))
 550         retVal, err := i.GetAll()
 551         assert.NotNil(t, err)
 552         assert.Nil(t, retVal)
 553         assert.Equal(t, len(retVal), 0)
 554         m.AssertExpectations(t)
 555 }
 556
 557 func TestGetAllReturnEmpty(t *testing.T) {
 558         m, i := setup()
 559
 560         mKeysExpected := string("{namespace},*")
 561         var mReturnExpected []string = nil
 562         m.On("Keys", mKeysExpected).Return(mReturnExpected, nil)
 563         retVal, err := i.GetAll()
 564         assert.Nil(t, err)
 565         assert.Nil(t, retVal)
 566         assert.Equal(t, len(retVal), 0)
 567         m.AssertExpectations(t)
 568
 569 }
 570
 571 func TestRemoveAllSuccessfully(t *testing.T) {
 572         m, i := setup()
 573
 574         mKeysExpected := string("{namespace},*")
 575         mKeysReturn := []string{"{namespace},key1", "{namespace},key2"}
 576         mDelExpected := mKeysReturn
 577         m.On("Keys", mKeysExpected).Return(mKeysReturn, nil)
 578         m.On("Del", mDelExpected).Return(nil)
 579         err := i.RemoveAll()
 580         assert.Nil(t, err)
 581         m.AssertExpectations(t)
 582 }
 583
 584 func TestRemoveAllNoKeysFound(t *testing.T) {
 585         m, i := setup()
 586
 587         mKeysExpected := string("{namespace},*")
 588         var mKeysReturn []string = nil
 589         m.On("Keys", mKeysExpected).Return(mKeysReturn, nil)
 590         m.AssertNumberOfCalls(t, "Del", 0)
 591         err := i.RemoveAll()
 592         assert.Nil(t, err)
 593         m.AssertExpectations(t)
 594 }
 595
 596 func TestRemoveAllKeysReturnError(t *testing.T) {
 597         m, i := setup()
 598
 599         mKeysExpected := string("{namespace},*")
 600         var mKeysReturn []string = nil
 601         m.On("Keys", mKeysExpected).Return(mKeysReturn, errors.New("Some error"))
 602         m.AssertNumberOfCalls(t, "Del", 0)
 603         err := i.RemoveAll()
 604         assert.NotNil(t, err)
 605         m.AssertExpectations(t)
 606 }
 607
 608 func TestRemoveAllDelReturnError(t *testing.T) {
 609         m, i := setup()
 610
 611         mKeysExpected := string("{namespace},*")
 612         mKeysReturn := []string{"{namespace},key1", "{namespace},key2"}
 613         mDelExpected := mKeysReturn
 614         m.On("Keys", mKeysExpected).Return(mKeysReturn, nil)
 615         m.On("Del", mDelExpected).Return(errors.New("Some Error"))
 616         err := i.RemoveAll()
 617         assert.NotNil(t, err)
 618         m.AssertExpectations(t)
 619 }
 620
 621 func TestSetIfSuccessfullyOkStatus(t *testing.T) {
 622         m, i := setup()
 623
 624         mSetIEExpectedKey := string("{namespace},key1")
 625         mSetIEExpectedOldData := interface{}("olddata")
 626         mSetIEExpectedNewData := interface{}("newdata")
 627         m.On("SetIE", mSetIEExpectedKey, mSetIEExpectedOldData, mSetIEExpectedNewData).Return(true, nil)
 628         status, err := i.SetIf("key1", "olddata", "newdata")
 629         assert.Nil(t, err)
 630         assert.True(t, status)
 631         m.AssertExpectations(t)
 632 }
 633
 634 func TestSetIfSuccessfullyNOKStatus(t *testing.T) {
 635         m, i := setup()
 636
 637         mSetIEExpectedKey := string("{namespace},key1")
 638         mSetIEExpectedOldData := interface{}("olddata")
 639         mSetIEExpectedNewData := interface{}("newdata")
 640         m.On("SetIE", mSetIEExpectedKey, mSetIEExpectedOldData, mSetIEExpectedNewData).Return(false, nil)
 641         status, err := i.SetIf("key1", "olddata", "newdata")
 642         assert.Nil(t, err)
 643         assert.False(t, status)
 644         m.AssertExpectations(t)
 645 }
 646
 647 func TestSetIfFailure(t *testing.T) {
 648         m, i := setup()
 649
 650         mSetIEExpectedKey := string("{namespace},key1")
 651         mSetIEExpectedOldData := interface{}("olddata")
 652         mSetIEExpectedNewData := interface{}("newdata")
 653         m.On("SetIE", mSetIEExpectedKey, mSetIEExpectedOldData, mSetIEExpectedNewData).Return(false, errors.New("Some error"))
 654         status, err := i.SetIf("key1", "olddata", "newdata")
 655         assert.NotNil(t, err)
 656         assert.False(t, status)
 657         m.AssertExpectations(t)
 658 }
 659
 660 func TestSetIfAndPublishSuccessfully(t *testing.T) {
 661         m, i := setup()
 662
 663         expectedChannel := "{namespace},channel"
 664         expectedEvent := "event"
 665         expectedKey := "{namespace},key"
 666         expectedOldData := interface{}("olddata")
 667         expectedNewData := interface{}("newdata")
 668         m.On("SetIEPub", expectedChannel, expectedEvent, expectedKey, expectedOldData, expectedNewData).Return(true, nil)
 669         status, err := i.SetIfAndPublish([]string{"channel", "event"}, "key", "olddata", "newdata")
 670         assert.Nil(t, err)
 671         assert.True(t, status)
 672         m.AssertExpectations(t)
 673 }
 674
 675 func TestSetIfAndPublishIncorrectChannelAndEvent(t *testing.T) {
 676         m, i := setup()
 677
 678         expectedChannel := "{namespace},channel"
 679         expectedEvent := "event"
 680         expectedKey := "{namespace},key"
 681         expectedOldData := interface{}("olddata")
 682         expectedNewData := interface{}("newdata")
 683         m.AssertNotCalled(t, "SetIEPub", expectedChannel, expectedEvent, expectedKey, expectedOldData, expectedNewData)
 684         m.AssertNotCalled(t, "SetIE", expectedKey, expectedOldData, expectedNewData)
 685         status, err := i.SetIfAndPublish([]string{"channel", "event1", "channel"}, "key", "olddata", "newdata")
 686         assert.NotNil(t, err)
 687         assert.False(t, status)
 688         m.AssertExpectations(t)
 689 }
 690 func TestSetIfAndPublishNOKStatus(t *testing.T) {
 691         m, i := setup()
 692
 693         expectedChannel := "{namespace},channel"
 694         expectedEvent := "event"
 695         expectedKey := "{namespace},key"
 696         expectedOldData := interface{}("olddata")
 697         expectedNewData := interface{}("newdata")
 698         m.On("SetIEPub", expectedChannel, expectedEvent, expectedKey, expectedOldData, expectedNewData).Return(false, nil)
 699         status, err := i.SetIfAndPublish([]string{"channel", "event"}, "key", "olddata", "newdata")
 700         assert.Nil(t, err)
 701         assert.False(t, status)
 702         m.AssertExpectations(t)
 703 }
 704
 705 func TestSetIfAndPublishNoChannels(t *testing.T) {
 706         m, i := setup()
 707
 708         expectedKey := "{namespace},key"
 709         expectedOldData := interface{}("olddata")
 710         expectedNewData := interface{}("newdata")
 711         m.On("SetIE", expectedKey, expectedOldData, expectedNewData).Return(true, nil)
 712         status, err := i.SetIfAndPublish([]string{}, "key", "olddata", "newdata")
 713         assert.Nil(t, err)
 714         assert.True(t, status)
 715         m.AssertExpectations(t)
 716 }
 717
 718 func TestSetIfNotExistsAndPublishSuccessfully(t *testing.T) {
 719         m, i := setup()
 720
 721         expectedChannel := "{namespace},channel"
 722         expectedEvent := "event"
 723         expectedKey := "{namespace},key"
 724         expectedData := interface{}("data")
 725
 726         m.On("SetNXPub", expectedChannel, expectedEvent, expectedKey, expectedData).Return(true, nil)
 727         status, err := i.SetIfNotExistsAndPublish([]string{"channel", "event"}, "key", "data")
 728         assert.Nil(t, err)
 729         assert.True(t, status)
 730         m.AssertExpectations(t)
 731 }
 732
 733 func TestSetIfNotExistsAndPublishSeveralEvents(t *testing.T) {
 734         m, i := setup()
 735
 736         expectedChannel := "{namespace},channel"
 737         expectedEvent := "event1___event2"
 738         expectedKey := "{namespace},key"
 739         expectedData := interface{}("data")
 740
 741         m.On("SetNXPub", expectedChannel, expectedEvent, expectedKey, expectedData).Return(true, nil)
 742         status, err := i.SetIfNotExistsAndPublish([]string{"channel", "event1", "channel", "event2"}, "key", "data")
 743         assert.Nil(t, err)
 744         assert.True(t, status)
 745         m.AssertExpectations(t)
 746 }
 747
 748 func TestSetIfNotExistsAndPublishNoChannels(t *testing.T) {
 749         m, i := setup()
 750
 751         expectedKey := "{namespace},key"
 752         expectedData := interface{}("data")
 753
 754         m.On("SetNX", expectedKey, expectedData).Return(true, nil)
 755         status, err := i.SetIfNotExistsAndPublish([]string{}, "key", "data")
 756         assert.Nil(t, err)
 757         assert.True(t, status)
 758         m.AssertExpectations(t)
 759 }
 760
 761 func TestSetIfNotExistsAndPublishFail(t *testing.T) {
 762         m, i := setup()
 763
 764         expectedChannel := "{namespace},channel"
 765         expectedEvent := "event"
 766         expectedKey := "{namespace},key"
 767         expectedData := interface{}("data")
 768
 769         m.On("SetNXPub", expectedChannel, expectedEvent, expectedKey, expectedData).Return(false, nil)
 770         status, err := i.SetIfNotExistsAndPublish([]string{"channel", "event"}, "key", "data")
 771         assert.Nil(t, err)
 772         assert.False(t, status)
 773         m.AssertExpectations(t)
 774 }
 775
 776 func TestSetIfNotExistsAndPublishIncorrectChannels(t *testing.T) {
 777         m, i := setup()
 778
 779         expectedChannel := "{namespace},channel"
 780         expectedEvent := "event"
 781         expectedKey := "{namespace},key"
 782         expectedData := interface{}("data")
 783
 784         m.AssertNotCalled(t, "SetNXPub", expectedChannel, expectedEvent, expectedKey, expectedData)
 785         m.AssertNotCalled(t, "SetNX", expectedKey, expectedData)
 786         status, err := i.SetIfNotExistsAndPublish([]string{"channel", "event", "channel2"}, "key", "data")
 787         assert.NotNil(t, err)
 788         assert.False(t, status)
 789         m.AssertExpectations(t)
 790 }
 791
 792 func TestSetIfNotExistsAndPublishError(t *testing.T) {
 793         m, i := setup()
 794
 795         expectedChannel := "{namespace},channel"
 796         expectedEvent := "event"
 797         expectedKey := "{namespace},key"
 798         expectedData := interface{}("data")
 799
 800         m.On("SetNXPub", expectedChannel, expectedEvent, expectedKey, expectedData).Return(false, errors.New("Some error"))
 801         status, err := i.SetIfNotExistsAndPublish([]string{"channel", "event"}, "key", "data")
 802         assert.NotNil(t, err)
 803         assert.False(t, status)
 804         m.AssertExpectations(t)
 805 }
 806
 807 func TestSetIfNotExistsSuccessfullyOkStatus(t *testing.T) {
 808         m, i := setup()
 809
 810         mSetNXExpectedKey := string("{namespace},key1")
 811         mSetNXExpectedData := interface{}("data")
 812         m.On("SetNX", mSetNXExpectedKey, mSetNXExpectedData).Return(true, nil)
 813         status, err := i.SetIfNotExists("key1", "data")
 814         assert.Nil(t, err)
 815         assert.True(t, status)
 816         m.AssertExpectations(t)
 817 }
 818
 819 func TestSetIfNotExistsSuccessfullyNOKStatus(t *testing.T) {
 820         m, i := setup()
 821
 822         mSetNXExpectedKey := string("{namespace},key1")
 823         mSetNXExpectedData := interface{}("data")
 824         m.On("SetNX", mSetNXExpectedKey, mSetNXExpectedData).Return(false, nil)
 825         status, err := i.SetIfNotExists("key1", "data")
 826         assert.Nil(t, err)
 827         assert.False(t, status)
 828         m.AssertExpectations(t)
 829 }
 830
 831 func TestSetIfNotExistsFailure(t *testing.T) {
 832         m, i := setup()
 833
 834         mSetNXExpectedKey := string("{namespace},key1")
 835         mSetNXExpectedData := interface{}("data")
 836         m.On("SetNX", mSetNXExpectedKey, mSetNXExpectedData).Return(false, errors.New("Some error"))
 837         status, err := i.SetIfNotExists("key1", "data")
 838         assert.NotNil(t, err)
 839         assert.False(t, status)
 840         m.AssertExpectations(t)
 841 }
 842
 843 func TestRemoveIfAndPublishSuccessfully(t *testing.T) {
 844         m, i := setup()
 845
 846         expectedChannel := "{namespace},channel"
 847         expectedEvent := "event1___event2"
 848         expectedKey := "{namespace},key"
 849         expectedValue := interface{}("data")
 850
 851         m.On("DelIEPub", expectedChannel, expectedEvent, expectedKey, expectedValue).Return(true, nil)
 852         status, err := i.RemoveIfAndPublish([]string{"channel", "event1", "channel", "event2"}, "key", "data")
 853         assert.Nil(t, err)
 854         assert.True(t, status)
 855         m.AssertExpectations(t)
 856 }
 857
 858 func TestRemoveIfAndPublishNok(t *testing.T) {
 859         m, i := setup()
 860
 861         expectedChannel := "{namespace},channel"
 862         expectedEvent := "event1___event2"
 863         expectedKey := "{namespace},key"
 864         expectedValue := interface{}("data")
 865
 866         m.On("DelIEPub", expectedChannel, expectedEvent, expectedKey, expectedValue).Return(false, nil)
 867         status, err := i.RemoveIfAndPublish([]string{"channel", "event1", "channel", "event2"}, "key", "data")
 868         assert.Nil(t, err)
 869         assert.False(t, status)
 870         m.AssertExpectations(t)
 871 }
 872
 873 func TestRemoveIfAndPublishError(t *testing.T) {
 874         m, i := setup()
 875
 876         expectedChannel := "{namespace},channel"
 877         expectedEvent := "event1___event2"
 878         expectedKey := "{namespace},key"
 879         expectedValue := interface{}("data")
 880
 881         m.On("DelIEPub", expectedChannel, expectedEvent, expectedKey, expectedValue).Return(false, errors.New("Some error"))
 882         status, err := i.RemoveIfAndPublish([]string{"channel", "event1", "channel", "event2"}, "key", "data")
 883         assert.NotNil(t, err)
 884         assert.False(t, status)
 885         m.AssertExpectations(t)
 886 }
 887
 888 func TestRemoveIfAndPublishIncorrectChannel(t *testing.T) {
 889         m, i := setup()
 890
 891         expectedChannel := "{namespace},channel"
 892         expectedEvent := "event"
 893         expectedKey := "{namespace},key"
 894         expectedValue := interface{}("data")
 895
 896         m.AssertNotCalled(t, "DelIEPub", expectedChannel, expectedEvent, expectedKey, expectedValue)
 897         m.AssertNotCalled(t, "DelIE", expectedKey, expectedValue)
 898         status, err := i.RemoveIfAndPublish([]string{"channel", "event1", "channel"}, "key", "data")
 899         assert.NotNil(t, err)
 900         assert.False(t, status)
 901         m.AssertExpectations(t)
 902 }
 903
 904 func TestRemoveIfAndPublishNoChannels(t *testing.T) {
 905         m, i := setup()
 906
 907         expectedKey := "{namespace},key"
 908         expectedValue := interface{}("data")
 909
 910         m.On("DelIE", expectedKey, expectedValue).Return(true, nil)
 911         status, err := i.RemoveIfAndPublish([]string{}, "key", "data")
 912         assert.Nil(t, err)
 913         assert.True(t, status)
 914         m.AssertExpectations(t)
 915
 916 }
 917 func TestRemoveIfSuccessfullyOkStatus(t *testing.T) {
 918         m, i := setup()
 919
 920         mDelIEExpectedKey := string("{namespace},key1")
 921         mDelIEExpectedData := interface{}("data")
 922         m.On("DelIE", mDelIEExpectedKey, mDelIEExpectedData).Return(true, nil)
 923         status, err := i.RemoveIf("key1", "data")
 924         assert.Nil(t, err)
 925         assert.True(t, status)
 926         m.AssertExpectations(t)
 927 }
 928
 929 func TestRemoveIfSuccessfullyNOKStatus(t *testing.T) {
 930         m, i := setup()
 931
 932         mDelIEExpectedKey := string("{namespace},key1")
 933         mDelIEExpectedData := interface{}("data")
 934         m.On("DelIE", mDelIEExpectedKey, mDelIEExpectedData).Return(false, nil)
 935         status, err := i.RemoveIf("key1", "data")
 936         assert.Nil(t, err)
 937         assert.False(t, status)
 938         m.AssertExpectations(t)
 939 }
 940
 941 func TestRemoveIfFailure(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, errors.New("Some error"))
 947         status, err := i.RemoveIf("key1", "data")
 948         assert.NotNil(t, err)
 949         assert.False(t, status)
 950         m.AssertExpectations(t)
 951 }
 952
 953 func TestRemoveAllAndPublishSuccessfully(t *testing.T) {
 954         m, i := setup()
 955
 956         mKeysExpected := string("{namespace},*")
 957         mKeysReturn := []string{"{namespace},key1", "{namespace},key2"}
 958         mDelExpected := mKeysReturn
 959         expectedChannel := "{namespace},channel"
 960         expectedEvent := "event"
 961         m.On("Keys", mKeysExpected).Return(mKeysReturn, nil)
 962         m.On("DelPub", expectedChannel, expectedEvent, mDelExpected).Return(nil)
 963         err := i.RemoveAllAndPublish([]string{"channel", "event"})
 964         assert.Nil(t, err)
 965         m.AssertExpectations(t)
 966 }
 967
 968 func TestRemoveAllAndPublishKeysReturnError(t *testing.T) {
 969         m, i := setup()
 970
 971         mKeysExpected := string("{namespace},*")
 972         mKeysReturn := []string{"{namespace},key1", "{namespace},key2"}
 973         mDelExpected := mKeysReturn
 974         expectedChannel := "{namespace},channel"
 975         expectedEvent := "event"
 976         m.On("Keys", mKeysExpected).Return(mKeysReturn, errors.New("Some error"))
 977         m.AssertNotCalled(t, "DelPub", expectedChannel, expectedEvent, mDelExpected)
 978         err := i.RemoveAllAndPublish([]string{"channel", "event"})
 979         assert.NotNil(t, err)
 980         m.AssertExpectations(t)
 981 }
 982
 983 func TestRemoveAllAndPublishKeysDelReturnsError(t *testing.T) {
 984         m, i := setup()
 985
 986         mKeysExpected := string("{namespace},*")
 987         mKeysReturn := []string{"{namespace},key1", "{namespace},key2"}
 988         mDelExpected := mKeysReturn
 989         expectedChannel := "{namespace},channel"
 990         expectedEvent := "event"
 991         m.On("Keys", mKeysExpected).Return(mKeysReturn, nil)
 992         m.On("DelPub", expectedChannel, expectedEvent, mDelExpected).Return(errors.New("Some error"))
 993         err := i.RemoveAllAndPublish([]string{"channel", "event"})
 994         assert.NotNil(t, err)
 995         m.AssertExpectations(t)
 996 }
 997
 998 func TestRemoveAllAndPublishKeysEventsWithIllegalCharacters(t *testing.T) {
 999         m, i := setup()
1000
1001         mKeysExpected := string("{namespace},*")
1002         mKeysReturn := []string{"{namespace},key1", "{namespace},key2"}
1003         mDelExpected := mKeysReturn
1004         expectedChannel := "{namespace},channel"
1005         expectedEvent := "event"
1006         m.On("Keys", mKeysExpected).Return(mKeysReturn, nil)
1007         m.AssertNotCalled(t, "DelPub", expectedChannel, expectedEvent, mDelExpected)
1008         err := i.RemoveAllAndPublish([]string{"channel", "event___anotherEvent"})
1009         assert.NotNil(t, err)
1010         m.AssertExpectations(t)
1011
1012 }
1013
1014 func TestRemoveAllAndPublishNoChannels(t *testing.T) {
1015         m, i := setup()
1016
1017         mKeysExpected := string("{namespace},*")
1018         mKeysReturn := []string{"{namespace},key1", "{namespace},key2"}
1019         mDelExpected := mKeysReturn
1020         m.On("Keys", mKeysExpected).Return(mKeysReturn, nil)
1021         m.On("Del", mDelExpected).Return(nil)
1022         m.AssertNotCalled(t, "DelPub", "", "", mDelExpected)
1023         err := i.RemoveAllAndPublish([]string{})
1024         assert.Nil(t, err)
1025         m.AssertExpectations(t)
1026 }
1027
1028 func TestRemoveAllAndPublishIncorrectChannel(t *testing.T) {
1029         m, i := setup()
1030
1031         mKeysExpected := string("{namespace},*")
1032         mKeysReturn := []string{"{namespace},key1", "{namespace},key2"}
1033         mDelExpected := mKeysReturn
1034         m.On("Keys", mKeysExpected).Return(mKeysReturn, nil)
1035         m.AssertNotCalled(t, "DelPub", "", "", mDelExpected)
1036         err := i.RemoveAllAndPublish([]string{"channel", "event", "channel2"})
1037         assert.NotNil(t, err)
1038         m.AssertExpectations(t)
1039
1040 }