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