2 Copyright (c) 2019 AT&T Intellectual Property.
3 Copyright (c) 2018-2019 Nokia.
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
9 http://www.apache.org/licenses/LICENSE-2.0
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.
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"
34 func (m *mockDB) SubscribeChannelDB(cb sdlgoredis.ChannelNotificationCb, channelPrefix, eventSeparator string, channels ...string) {
35 m.Called(cb, channelPrefix, eventSeparator, channels)
38 func (m *mockDB) UnsubscribeChannelDB(channels ...string) {
42 func (m *mockDB) MSet(pairs ...interface{}) error {
47 func (m *mockDB) MSetPub(ns, message string, pairs ...interface{}) error {
48 a := m.Called(ns, message, pairs)
52 func (m *mockDB) MGet(keys []string) ([]interface{}, error) {
54 return a.Get(0).([]interface{}), a.Error(1)
57 func (m *mockDB) CloseDB() error {
62 func (m *mockDB) Del(keys []string) error {
67 func (m *mockDB) DelPub(channel, message string, keys []string) error {
68 a := m.Called(channel, message, keys)
72 func (m *mockDB) Keys(pattern string) ([]string, error) {
73 a := m.Called(pattern)
74 return a.Get(0).([]string), a.Error(1)
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)
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)
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)
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)
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)
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)
107 func setup() (*mockDB, *sdlgo.SdlInstance) {
109 i := sdlgo.NewSdlInstance("namespace", m)
113 func TestSubscribeChannel(t *testing.T) {
116 expectedCB := func(channel string, events ...string) {}
117 expectedChannels := []string{"{namespace},channel1", "{namespace},channel2"}
119 m.On("SubscribeChannelDB", mock.AnythingOfType("sdlgoredis.ChannelNotificationCb"), "{namespace},", "___", expectedChannels).Return()
120 i.SubscribeChannel(expectedCB, "channel1", "channel2")
121 m.AssertExpectations(t)
124 func TestUnsubscribeChannel(t *testing.T) {
127 expectedChannels := []string{"{namespace},channel1", "{namespace},channel2"}
129 m.On("UnsubscribeChannelDB", expectedChannels).Return()
130 i.UnsubscribeChannel("channel1", "channel2")
131 m.AssertExpectations(t)
133 func TestGetOneKey(t *testing.T) {
136 mgetExpected := []string{"{namespace},key"}
137 mReturn := []interface{}{"somevalue"}
138 mReturnExpected := make(map[string]interface{})
139 mReturnExpected["key"] = "somevalue"
141 m.On("MGet", mgetExpected).Return(mReturn, nil)
142 retVal, err := i.Get([]string{"key"})
144 assert.Equal(t, mReturnExpected, retVal)
145 m.AssertExpectations(t)
148 func TestGetSeveralKeys(t *testing.T) {
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"
158 m.On("MGet", mgetExpected).Return(mReturn, nil)
159 retVal, err := i.Get([]string{"key1", "key2", "key3"})
161 assert.Equal(t, mReturnExpected, retVal)
162 m.AssertExpectations(t)
165 func TestGetSeveralKeysSomeFail(t *testing.T) {
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"
175 m.On("MGet", mgetExpected).Return(mReturn, nil)
176 retVal, err := i.Get([]string{"key1", "key2", "key3"})
178 assert.Equal(t, mReturnExpected, retVal)
179 m.AssertExpectations(t)
182 func TestGetKeyReturnError(t *testing.T) {
185 mgetExpected := []string{"{namespace},key"}
186 mReturn := []interface{}{nil}
187 mReturnExpected := make(map[string]interface{})
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)
196 func TestGetEmptyList(t *testing.T) {
199 mgetExpected := []string{}
201 retval, err := i.Get([]string{})
203 assert.Len(t, retval, 0)
204 m.AssertNotCalled(t, "MGet", mgetExpected)
207 func TestWriteOneKey(t *testing.T) {
210 msetExpected := []interface{}{"{namespace},key1", "data1"}
212 m.On("MSet", msetExpected).Return(nil)
213 err := i.Set("key1", "data1")
215 m.AssertExpectations(t)
218 func TestWriteMixed(t *testing.T) {
221 msetExpected := []interface{}{"{namespace},key1", "data1", "{namespace},key2", "data2", "{namespace},key3", "data3"}
223 m.On("MSet", msetExpected).Return(nil)
224 err := i.Set("key1", "data1", []string{"key2", "data2"}, [2]string{"key3", "data3"})
226 m.AssertExpectations(t)
229 func TestWriteIncorrectMixed(t *testing.T) {
232 msetExpected := []interface{}{"{namespace},key1", "data1", "{namespace},key2", "data2", "{namespace},key3", "data3"}
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)
239 func TestWriteIncorrectPairs(t *testing.T) {
242 msetExpected := []interface{}{}
244 m.AssertNotCalled(t, "MSet", msetExpected)
246 assert.NotNil(t, err)
247 m.AssertExpectations(t)
249 func TestWriteSeveralKeysSlice(t *testing.T) {
252 msetExpected := []interface{}{"{namespace},key1", "data1", "{namespace},key2", 22}
254 m.On("MSet", msetExpected).Return(nil)
255 err := i.Set([]interface{}{"key1", "data1", "key2", 22})
257 m.AssertExpectations(t)
261 func TestWriteSeveralKeysIncorrectSlice(t *testing.T) {
264 msetExpected := []interface{}{"{namespace},key1", "data1", "{namespace},key2", 22}
266 m.AssertNotCalled(t, "MSet", msetExpected)
267 err := i.Set([]interface{}{"key1", "data1", "key2"})
268 assert.NotNil(t, err)
269 m.AssertExpectations(t)
273 func TestWriteSeveralKeysArray(t *testing.T) {
276 msetExpected := []interface{}{"{namespace},key1", "data1", "{namespace},key2", "data2"}
278 m.On("MSet", msetExpected).Return(nil)
279 err := i.Set([4]string{"key1", "data1", "key2", "data2"})
281 m.AssertExpectations(t)
284 func TestWriteSeveralKeysIncorrectArray(t *testing.T) {
287 msetExpected := []interface{}{}
289 m.AssertNotCalled(t, "MSet", msetExpected)
290 err := i.Set([3]string{"key1", "data1", "key2"})
291 assert.NotNil(t, err)
292 m.AssertExpectations(t)
295 func TestWriteFail(t *testing.T) {
298 msetExpected := []interface{}{"{namespace},key1", "data1"}
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)
306 func TestWriteEmptyList(t *testing.T) {
309 msetExpected := []interface{}{}
312 m.AssertNotCalled(t, "MSet", msetExpected)
315 func TestWriteAndPublishOneKeyOneChannel(t *testing.T) {
318 expectedChannel := "{namespace},channel"
319 expectedMessage := "event"
320 expectedKeyVal := []interface{}{"{namespace},key1", "data1"}
322 m.On("MSetPub", expectedChannel, expectedMessage, expectedKeyVal).Return(nil)
323 m.AssertNotCalled(t, "MSet", expectedKeyVal)
324 err := i.SetAndPublish([]string{"channel", "event"}, "key1", "data1")
326 m.AssertExpectations(t)
328 func TestWriteAndPublishOneKeyOneChannelTwoEvents(t *testing.T) {
331 expectedChannel := "{namespace},channel"
332 expectedMessage := "event1___event2"
333 expectedKeyVal := []interface{}{"{namespace},key1", "data1"}
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")
339 m.AssertExpectations(t)
342 func TestWriteAndPublishIncorrectChannelAndEvent(t *testing.T) {
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)
355 func TestWriteAndPublishNotAllowedCharactersInEvents(t *testing.T) {
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)
368 func TestWriteAndPublishNoData(t *testing.T) {
371 expectedChannel := "{namespace},channel"
372 expectedMessage := "event"
373 expectedKeyVal := []interface{}{"key"}
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)
382 func TestWriteAndPublishNoChannelEvent(t *testing.T) {
385 expectedKeyVal := []interface{}{"{namespace},key1", "data1"}
387 m.On("MSet", expectedKeyVal).Return(nil)
388 m.AssertNotCalled(t, "MSetPub", "", "", expectedKeyVal)
389 err := i.SetAndPublish([]string{}, "key1", "data1")
391 m.AssertExpectations(t)
395 func TestRemoveAndPublishSuccessfully(t *testing.T) {
398 expectedChannel := "{namespace},channel"
399 expectedEvent := "event"
400 expectedKeys := []string{"{namespace},key1", "{namespace},key2"}
402 m.On("DelPub", expectedChannel, expectedEvent, expectedKeys).Return(nil)
403 err := i.RemoveAndPublish([]string{"channel", "event"}, []string{"key1", "key2"})
405 m.AssertExpectations(t)
407 func TestRemoveAndPublishFail(t *testing.T) {
410 expectedChannel := "{namespace},channel"
411 expectedEvent := "event"
412 expectedKeys := []string{"{namespace},key1", "{namespace},key2"}
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)
420 func TestRemoveAndPublishNoChannels(t *testing.T) {
423 expectedKeys := []string{"{namespace},key1", "{namespace},key2"}
425 m.On("Del", expectedKeys).Return(nil)
426 err := i.RemoveAndPublish([]string{}, []string{"key1", "key2"})
428 m.AssertExpectations(t)
431 func TestRemoveAndPublishIncorrectChannel(t *testing.T) {
434 notExpectedChannel := "{namespace},channel"
435 notExpectedEvent := "event"
436 notExpectedKeys := []string{"{namespace},key"}
438 m.AssertNotCalled(t, "DelPub", notExpectedChannel, notExpectedEvent, notExpectedKeys)
439 m.AssertNotCalled(t, "Del", notExpectedKeys)
440 err := i.RemoveAndPublish([]string{"channel", "event", "channel2"}, []string{})
442 m.AssertExpectations(t)
445 func TestRemoveAndPublishNoKeys(t *testing.T) {
448 notExpectedChannel := "{namespace},channel"
449 notExpectedEvent := "event"
450 notExpectedKeys := []string{"{namespace},key"}
452 m.AssertNotCalled(t, "DelPub", notExpectedChannel, notExpectedEvent, notExpectedKeys)
453 m.AssertNotCalled(t, "Del", notExpectedKeys)
454 err := i.RemoveAndPublish([]string{"channel", "event"}, []string{})
456 m.AssertExpectations(t)
458 func TestRemoveAndPublishNoChannelsError(t *testing.T) {
461 expectedKeys := []string{"{namespace},key1", "{namespace},key2"}
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)
468 func TestRemoveSuccessfully(t *testing.T) {
471 msetExpected := []string{"{namespace},key1", "{namespace},key2"}
472 m.On("Del", msetExpected).Return(nil)
474 err := i.Remove([]string{"key1", "key2"})
476 m.AssertExpectations(t)
479 func TestRemoveFail(t *testing.T) {
482 msetExpected := []string{"{namespace},key"}
483 m.On("Del", msetExpected).Return(errors.New("Some error"))
485 err := i.Remove([]string{"key"})
486 assert.NotNil(t, err)
487 m.AssertExpectations(t)
490 func TestRemoveEmptyList(t *testing.T) {
493 err := i.Remove([]string{})
495 m.AssertNotCalled(t, "Del", []string{})
498 func TestGetAllSuccessfully(t *testing.T) {
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()
507 assert.Equal(t, expectedReturn, retVal)
508 m.AssertExpectations(t)
511 func TestGetAllFail(t *testing.T) {
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)
524 func TestGetAllReturnEmpty(t *testing.T) {
527 mKeysExpected := string("{namespace},*")
528 var mReturnExpected []string = nil
529 m.On("Keys", mKeysExpected).Return(mReturnExpected, nil)
530 retVal, err := i.GetAll()
532 assert.Nil(t, retVal)
533 assert.Equal(t, len(retVal), 0)
534 m.AssertExpectations(t)
538 func TestRemoveAllSuccessfully(t *testing.T) {
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)
548 m.AssertExpectations(t)
551 func TestRemoveAllNoKeysFound(t *testing.T) {
554 mKeysExpected := string("{namespace},*")
555 var mKeysReturn []string = nil
556 m.On("Keys", mKeysExpected).Return(mKeysReturn, nil)
557 m.AssertNumberOfCalls(t, "Del", 0)
560 m.AssertExpectations(t)
563 func TestRemoveAllKeysReturnError(t *testing.T) {
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)
571 assert.NotNil(t, err)
572 m.AssertExpectations(t)
575 func TestRemoveAllDelReturnError(t *testing.T) {
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"))
584 assert.NotNil(t, err)
585 m.AssertExpectations(t)
588 func TestSetIfSuccessfullyOkStatus(t *testing.T) {
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")
597 assert.True(t, status)
598 m.AssertExpectations(t)
601 func TestSetIfSuccessfullyNOKStatus(t *testing.T) {
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")
610 assert.False(t, status)
611 m.AssertExpectations(t)
614 func TestSetIfFailure(t *testing.T) {
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)
627 func TestSetIfAndPublishSuccessfully(t *testing.T) {
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")
638 assert.True(t, status)
639 m.AssertExpectations(t)
642 func TestSetIfAndPublishIncorrectChannelAndEvent(t *testing.T) {
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)
657 func TestSetIfAndPublishNOKStatus(t *testing.T) {
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")
668 assert.False(t, status)
669 m.AssertExpectations(t)
672 func TestSetIfAndPublishNoChannels(t *testing.T) {
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")
681 assert.True(t, status)
682 m.AssertExpectations(t)
685 func TestSetIfNotExistsAndPublishSuccessfully(t *testing.T) {
688 expectedChannel := "{namespace},channel"
689 expectedEvent := "event"
690 expectedKey := "{namespace},key"
691 expectedData := interface{}("data")
693 m.On("SetNXPub", expectedChannel, expectedEvent, expectedKey, expectedData).Return(true, nil)
694 status, err := i.SetIfNotExistsAndPublish([]string{"channel", "event"}, "key", "data")
696 assert.True(t, status)
697 m.AssertExpectations(t)
700 func TestSetIfNotExistsAndPublishSeveralEvents(t *testing.T) {
703 expectedChannel := "{namespace},channel"
704 expectedEvent := "event1___event2"
705 expectedKey := "{namespace},key"
706 expectedData := interface{}("data")
708 m.On("SetNXPub", expectedChannel, expectedEvent, expectedKey, expectedData).Return(true, nil)
709 status, err := i.SetIfNotExistsAndPublish([]string{"channel", "event1", "channel", "event2"}, "key", "data")
711 assert.True(t, status)
712 m.AssertExpectations(t)
715 func TestSetIfNotExistsAndPublishNoChannels(t *testing.T) {
718 expectedKey := "{namespace},key"
719 expectedData := interface{}("data")
721 m.On("SetNX", expectedKey, expectedData).Return(true, nil)
722 status, err := i.SetIfNotExistsAndPublish([]string{}, "key", "data")
724 assert.True(t, status)
725 m.AssertExpectations(t)
728 func TestSetIfNotExistsAndPublishFail(t *testing.T) {
731 expectedChannel := "{namespace},channel"
732 expectedEvent := "event"
733 expectedKey := "{namespace},key"
734 expectedData := interface{}("data")
736 m.On("SetNXPub", expectedChannel, expectedEvent, expectedKey, expectedData).Return(false, nil)
737 status, err := i.SetIfNotExistsAndPublish([]string{"channel", "event"}, "key", "data")
739 assert.False(t, status)
740 m.AssertExpectations(t)
743 func TestSetIfNotExistsAndPublishIncorrectChannels(t *testing.T) {
746 expectedChannel := "{namespace},channel"
747 expectedEvent := "event"
748 expectedKey := "{namespace},key"
749 expectedData := interface{}("data")
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)
759 func TestSetIfNotExistsAndPublishError(t *testing.T) {
762 expectedChannel := "{namespace},channel"
763 expectedEvent := "event"
764 expectedKey := "{namespace},key"
765 expectedData := interface{}("data")
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)
774 func TestSetIfNotExistsSuccessfullyOkStatus(t *testing.T) {
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")
782 assert.True(t, status)
783 m.AssertExpectations(t)
786 func TestSetIfNotExistsSuccessfullyNOKStatus(t *testing.T) {
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")
794 assert.False(t, status)
795 m.AssertExpectations(t)
798 func TestSetIfNotExistsFailure(t *testing.T) {
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)
810 func TestRemoveIfAndPublishSuccessfully(t *testing.T) {
813 expectedChannel := "{namespace},channel"
814 expectedEvent := "event1___event2"
815 expectedKey := "{namespace},key"
816 expectedValue := interface{}("data")
818 m.On("DelIEPub", expectedChannel, expectedEvent, expectedKey, expectedValue).Return(true, nil)
819 status, err := i.RemoveIfAndPublish([]string{"channel", "event1", "channel", "event2"}, "key", "data")
821 assert.True(t, status)
822 m.AssertExpectations(t)
825 func TestRemoveIfAndPublishNok(t *testing.T) {
828 expectedChannel := "{namespace},channel"
829 expectedEvent := "event1___event2"
830 expectedKey := "{namespace},key"
831 expectedValue := interface{}("data")
833 m.On("DelIEPub", expectedChannel, expectedEvent, expectedKey, expectedValue).Return(false, nil)
834 status, err := i.RemoveIfAndPublish([]string{"channel", "event1", "channel", "event2"}, "key", "data")
836 assert.False(t, status)
837 m.AssertExpectations(t)
840 func TestRemoveIfAndPublishError(t *testing.T) {
843 expectedChannel := "{namespace},channel"
844 expectedEvent := "event1___event2"
845 expectedKey := "{namespace},key"
846 expectedValue := interface{}("data")
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)
855 func TestRemoveIfAndPublishIncorrectChannel(t *testing.T) {
858 expectedChannel := "{namespace},channel"
859 expectedEvent := "event"
860 expectedKey := "{namespace},key"
861 expectedValue := interface{}("data")
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)
871 func TestRemoveIfAndPublishNoChannels(t *testing.T) {
874 expectedKey := "{namespace},key"
875 expectedValue := interface{}("data")
877 m.On("DelIE", expectedKey, expectedValue).Return(true, nil)
878 status, err := i.RemoveIfAndPublish([]string{}, "key", "data")
880 assert.True(t, status)
881 m.AssertExpectations(t)
884 func TestRemoveIfSuccessfullyOkStatus(t *testing.T) {
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")
892 assert.True(t, status)
893 m.AssertExpectations(t)
896 func TestRemoveIfSuccessfullyNOKStatus(t *testing.T) {
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")
904 assert.False(t, status)
905 m.AssertExpectations(t)
908 func TestRemoveIfFailure(t *testing.T) {
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)
920 func TestRemoveAllAndPublishSuccessfully(t *testing.T) {
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"})
932 m.AssertExpectations(t)
935 func TestRemoveAllAndPublishKeysReturnError(t *testing.T) {
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)
950 func TestRemoveAllAndPublishKeysDelReturnsError(t *testing.T) {
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)
965 func TestRemoveAllAndPublishKeysEventsWithIllegalCharacters(t *testing.T) {
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)
981 func TestRemoveAllAndPublishNoChannels(t *testing.T) {
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{})
992 m.AssertExpectations(t)
995 func TestRemoveAllAndPublishIncorrectChannel(t *testing.T) {
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)