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.
25 "gerrit.o-ran-sc.org/r/ric-plt/sdlgo"
26 "gerrit.o-ran-sc.org/r/ric-plt/sdlgo/internal/sdlgoredis"
27 "github.com/stretchr/testify/assert"
28 "github.com/stretchr/testify/mock"
35 func (m *mockDB) SubscribeChannelDB(cb sdlgoredis.ChannelNotificationCb, channelPrefix, eventSeparator string, channels ...string) {
36 m.Called(cb, channelPrefix, eventSeparator, channels)
39 func (m *mockDB) UnsubscribeChannelDB(channels ...string) {
43 func (m *mockDB) MSet(pairs ...interface{}) error {
48 func (m *mockDB) MSetMPub(channelsAndEvents []string, pairs ...interface{}) error {
49 a := m.Called(channelsAndEvents, pairs)
53 func (m *mockDB) MGet(keys []string) ([]interface{}, error) {
55 return a.Get(0).([]interface{}), a.Error(1)
58 func (m *mockDB) CloseDB() error {
63 func (m *mockDB) Del(keys []string) error {
68 func (m *mockDB) DelMPub(channelsAndEvents []string, keys []string) error {
69 a := m.Called(channelsAndEvents, keys)
73 func (m *mockDB) Keys(pattern string) ([]string, error) {
74 a := m.Called(pattern)
75 return a.Get(0).([]string), a.Error(1)
78 func (m *mockDB) SetIE(key string, oldData, newData interface{}) (bool, error) {
79 a := m.Called(key, oldData, newData)
80 return a.Bool(0), a.Error(1)
83 func (m *mockDB) SetIEPub(channel, message, key string, oldData, newData interface{}) (bool, error) {
84 a := m.Called(channel, message, key, oldData, newData)
85 return a.Bool(0), a.Error(1)
88 func (m *mockDB) SetNX(key string, data interface{}) (bool, error) {
89 a := m.Called(key, data)
90 return a.Bool(0), a.Error(1)
93 func (m *mockDB) SetNXPub(channel, message, key string, data interface{}) (bool, error) {
94 a := m.Called(channel, message, key, data)
95 return a.Bool(0), a.Error(1)
98 func (m *mockDB) DelIE(key string, data interface{}) (bool, error) {
99 a := m.Called(key, data)
100 return a.Bool(0), a.Error(1)
103 func (m *mockDB) DelIEPub(channel, message, key string, data interface{}) (bool, error) {
104 a := m.Called(channel, message, key, data)
105 return a.Bool(0), a.Error(1)
108 func (m *mockDB) SAdd(key string, data ...interface{}) error {
109 a := m.Called(key, data)
113 func (m *mockDB) SRem(key string, data ...interface{}) error {
114 a := m.Called(key, data)
117 func (m *mockDB) SMembers(key string) ([]string, error) {
119 return a.Get(0).([]string), a.Error(1)
122 func (m *mockDB) SIsMember(key string, data interface{}) (bool, error) {
123 a := m.Called(key, data)
124 return a.Bool(0), a.Error(1)
127 func (m *mockDB) SCard(key string) (int64, error) {
129 return a.Get(0).(int64), a.Error(1)
132 func setup() (*mockDB, *sdlgo.SdlInstance) {
134 i := sdlgo.NewSdlInstance("namespace", m)
138 func verifySliceInOrder(a, b []string) bool {
139 for i, v := range a {
142 for j, x := range b {
143 if j%2 == 0 && x == v && a[i+1] == b[j+1] {
157 func TestSubscribeChannel(t *testing.T) {
160 expectedCB := func(channel string, events ...string) {}
161 expectedChannels := []string{"{namespace},channel1", "{namespace},channel2"}
163 m.On("SubscribeChannelDB", mock.AnythingOfType("sdlgoredis.ChannelNotificationCb"), "{namespace},", "___", expectedChannels).Return()
164 i.SubscribeChannel(expectedCB, "channel1", "channel2")
165 m.AssertExpectations(t)
168 func TestUnsubscribeChannel(t *testing.T) {
171 expectedChannels := []string{"{namespace},channel1", "{namespace},channel2"}
173 m.On("UnsubscribeChannelDB", expectedChannels).Return()
174 i.UnsubscribeChannel("channel1", "channel2")
175 m.AssertExpectations(t)
177 func TestGetOneKey(t *testing.T) {
180 mgetExpected := []string{"{namespace},key"}
181 mReturn := []interface{}{"somevalue"}
182 mReturnExpected := make(map[string]interface{})
183 mReturnExpected["key"] = "somevalue"
185 m.On("MGet", mgetExpected).Return(mReturn, nil)
186 retVal, err := i.Get([]string{"key"})
188 assert.Equal(t, mReturnExpected, retVal)
189 m.AssertExpectations(t)
192 func TestGetSeveralKeys(t *testing.T) {
195 mgetExpected := []string{"{namespace},key1", "{namespace},key2", "{namespace},key3"}
196 mReturn := []interface{}{"somevalue1", 2, "someothervalue"}
197 mReturnExpected := make(map[string]interface{})
198 mReturnExpected["key1"] = "somevalue1"
199 mReturnExpected["key2"] = 2
200 mReturnExpected["key3"] = "someothervalue"
202 m.On("MGet", mgetExpected).Return(mReturn, nil)
203 retVal, err := i.Get([]string{"key1", "key2", "key3"})
205 assert.Equal(t, mReturnExpected, retVal)
206 m.AssertExpectations(t)
209 func TestGetSeveralKeysSomeFail(t *testing.T) {
212 mgetExpected := []string{"{namespace},key1", "{namespace},key2", "{namespace},key3"}
213 mReturn := []interface{}{"somevalue1", nil, "someothervalue"}
214 mReturnExpected := make(map[string]interface{})
215 mReturnExpected["key1"] = "somevalue1"
216 mReturnExpected["key2"] = nil
217 mReturnExpected["key3"] = "someothervalue"
219 m.On("MGet", mgetExpected).Return(mReturn, nil)
220 retVal, err := i.Get([]string{"key1", "key2", "key3"})
222 assert.Equal(t, mReturnExpected, retVal)
223 m.AssertExpectations(t)
226 func TestGetKeyReturnError(t *testing.T) {
229 mgetExpected := []string{"{namespace},key"}
230 mReturn := []interface{}{nil}
231 mReturnExpected := make(map[string]interface{})
233 m.On("MGet", mgetExpected).Return(mReturn, errors.New("Some error"))
234 retVal, err := i.Get([]string{"key"})
235 assert.NotNil(t, err)
236 assert.Equal(t, mReturnExpected, retVal)
237 m.AssertExpectations(t)
240 func TestGetEmptyList(t *testing.T) {
243 mgetExpected := []string{}
245 retval, err := i.Get([]string{})
247 assert.Len(t, retval, 0)
248 m.AssertNotCalled(t, "MGet", mgetExpected)
251 func TestWriteOneKey(t *testing.T) {
254 msetExpected := []interface{}{"{namespace},key1", "data1"}
256 m.On("MSet", msetExpected).Return(nil)
257 err := i.Set("key1", "data1")
259 m.AssertExpectations(t)
262 func TestWriteByteSliceAsValue(t *testing.T) {
265 msetExpected := []interface{}{"{namespace},key1", []byte{1, 2, 3, 4, 5}}
267 m.On("MSet", msetExpected).Return(nil)
268 err := i.Set("key1", []byte{1, 2, 3, 4, 5})
270 m.AssertExpectations(t)
273 func TestWriteByteSliceAsValueMixed(t *testing.T) {
276 msetExpected := []interface{}{"{namespace},key1", []byte{1, 2, 3, 4, 5}, "{namespace},key2", "value2"}
278 m.On("MSet", msetExpected).Return(nil)
279 err := i.Set("key1", []byte{1, 2, 3, 4, 5}, []string{"key2", "value2"})
281 m.AssertExpectations(t)
284 func TestWriteByteArrayAsValue(t *testing.T) {
287 msetExpected := []interface{}{"{namespace},key1", [5]byte{1, 2, 3, 4, 5}}
289 m.On("MSet", msetExpected).Return(nil)
290 err := i.Set("key1", [5]byte{1, 2, 3, 4, 5})
292 m.AssertExpectations(t)
295 func TestWriteMapAsInput(t *testing.T){
298 setExpected := []interface{}{"{namespace},key1", "string123",
299 "{namespace},key22", 12,
300 "{namespace},key333", []byte{1,2,3,4,5}}
301 inputMap := map[string]interface{}{
304 "key333": []byte{1,2,3,4,5},
307 m.On("MSet", mock.MatchedBy(func(input []interface{}) bool {
308 for _, v := range input {
310 for _, x := range setExpected {
311 found = reflect.DeepEqual(x, v)
323 err := i.Set(inputMap)
325 m.AssertExpectations(t)
328 func TestWriteMixed(t *testing.T) {
331 msetExpected := []interface{}{"{namespace},key1", "data1", "{namespace},key2", "data2", "{namespace},key3", "data3"}
333 m.On("MSet", msetExpected).Return(nil)
334 err := i.Set("key1", "data1", []string{"key2", "data2"}, [2]string{"key3", "data3"})
336 m.AssertExpectations(t)
339 func TestWriteIncorrectMixed(t *testing.T) {
342 msetExpected := []interface{}{"{namespace},key1", "data1", "{namespace},key2", "data2", "{namespace},key3", "data3"}
344 m.AssertNotCalled(t, "MSet", msetExpected)
345 err := i.Set("key1", []string{"key2", "data2"}, [2]string{"key3", "data3"})
346 assert.NotNil(t, err)
347 m.AssertExpectations(t)
349 func TestWriteIncorrectPairs(t *testing.T) {
352 msetExpected := []interface{}{}
354 m.AssertNotCalled(t, "MSet", msetExpected)
356 assert.NotNil(t, err)
357 m.AssertExpectations(t)
359 func TestWriteSeveralKeysSlice(t *testing.T) {
362 msetExpected := []interface{}{"{namespace},key1", "data1", "{namespace},key2", 22}
364 m.On("MSet", msetExpected).Return(nil)
365 err := i.Set([]interface{}{"key1", "data1", "key2", 22})
367 m.AssertExpectations(t)
371 func TestWriteSeveralKeysIncorrectSlice(t *testing.T) {
374 msetExpected := []interface{}{"{namespace},key1", "data1", "{namespace},key2", 22}
376 m.AssertNotCalled(t, "MSet", msetExpected)
377 err := i.Set([]interface{}{"key1", "data1", "key2"})
378 assert.NotNil(t, err)
379 m.AssertExpectations(t)
383 func TestWriteSeveralKeysArray(t *testing.T) {
386 msetExpected := []interface{}{"{namespace},key1", "data1", "{namespace},key2", "data2"}
388 m.On("MSet", msetExpected).Return(nil)
389 err := i.Set([4]string{"key1", "data1", "key2", "data2"})
391 m.AssertExpectations(t)
394 func TestWriteSeveralKeysIncorrectArray(t *testing.T) {
397 msetExpected := []interface{}{}
399 m.AssertNotCalled(t, "MSet", msetExpected)
400 err := i.Set([3]string{"key1", "data1", "key2"})
401 assert.NotNil(t, err)
402 m.AssertExpectations(t)
405 func TestWriteFail(t *testing.T) {
408 msetExpected := []interface{}{"{namespace},key1", "data1"}
410 m.On("MSet", msetExpected).Return(errors.New("Some error"))
411 err := i.Set("key1", "data1")
412 assert.NotNil(t, err)
413 m.AssertExpectations(t)
416 func TestWriteEmptyList(t *testing.T) {
419 msetExpected := []interface{}{}
422 m.AssertNotCalled(t, "MSet", msetExpected)
425 func TestWriteAndPublishOneKeyOneChannel(t *testing.T) {
428 expectedChannelAndEvent := []string{"{namespace},channel", "event"}
429 expectedKeyVal := []interface{}{"{namespace},key1", "data1"}
431 m.On("MSetMPub", expectedChannelAndEvent, expectedKeyVal).Return(nil)
432 m.AssertNotCalled(t, "MSet", expectedKeyVal)
433 err := i.SetAndPublish([]string{"channel", "event"}, "key1", "data1")
435 m.AssertExpectations(t)
438 func TestWriteAndPublishSeveralChannelsAndEvents(t *testing.T) {
441 expectedChannelsAndEvents := []string{"{namespace},channel1", "event1___event2",
442 "{namespace},channel2", "event3___event4"}
443 expectedKeyVal := []interface{}{"{namespace},key", "data"}
445 verifyChannelAndEvent := func(input []string) bool {
446 return verifySliceInOrder(input, expectedChannelsAndEvents)
448 m.On("MSetMPub", mock.MatchedBy(verifyChannelAndEvent), expectedKeyVal).Return(nil)
449 m.AssertNotCalled(t, "MSet", expectedKeyVal)
450 err := i.SetAndPublish([]string{"channel1", "event1", "channel2", "event3", "channel1", "event2", "channel2", "event4"},
453 m.AssertExpectations(t)
456 func TestWriteAndPublishOneKeyOneChannelTwoEvents(t *testing.T) {
459 expectedChannelAndEvents := []string{"{namespace},channel", "event1___event2"}
460 expectedKeyVal := []interface{}{"{namespace},key1", "data1"}
462 m.On("MSetMPub", expectedChannelAndEvents, expectedKeyVal).Return(nil)
463 m.AssertNotCalled(t, "MSet", expectedKeyVal)
464 err := i.SetAndPublish([]string{"channel", "event1", "channel", "event2"}, "key1", "data1")
466 m.AssertExpectations(t)
469 func TestWriteAndPublishIncorrectChannelAndEvent(t *testing.T) {
472 expectedChannelAndEvent := []string{}
473 expectedKeyVal := []interface{}{"{namespace},key1", "data1"}
474 m.AssertNotCalled(t, "MSetMPub", expectedChannelAndEvent, expectedKeyVal)
475 m.AssertNotCalled(t, "MSet", expectedKeyVal)
476 err := i.SetAndPublish([]string{"channel", "event1", "channel"}, "key1", "data1")
477 assert.NotNil(t, err)
478 m.AssertExpectations(t)
481 func TestWriteAndPublishNotAllowedCharactersInEvents(t *testing.T) {
484 expectedChannelAndEvent := []string{}
485 expectedKeyVal := []interface{}{"{namespace},key1", "data1"}
486 m.AssertNotCalled(t, "MSetMPub", expectedChannelAndEvent, expectedKeyVal)
487 m.AssertNotCalled(t, "MSet", expectedKeyVal)
488 err := i.SetAndPublish([]string{"channel", "event1___event2"}, "key1", "data1")
489 assert.NotNil(t, err)
490 m.AssertExpectations(t)
493 func TestWriteAndPublishNoData(t *testing.T) {
496 expectedChannelAndEvent := []string{}
497 expectedKeyVal := []interface{}{"key"}
499 m.AssertNotCalled(t, "MSetMPub", expectedChannelAndEvent, expectedKeyVal)
500 m.AssertNotCalled(t, "MSet", expectedKeyVal)
501 err := i.SetAndPublish([]string{"channel", "event"}, []interface{}{"key"})
502 assert.NotNil(t, err)
503 m.AssertExpectations(t)
506 func TestWriteAndPublishNoChannelEvent(t *testing.T) {
509 expectedKeyVal := []interface{}{"{namespace},key1", "data1"}
511 m.On("MSet", expectedKeyVal).Return(nil)
512 m.AssertNotCalled(t, "MSetMPub", "", "", expectedKeyVal)
513 err := i.SetAndPublish([]string{}, "key1", "data1")
515 m.AssertExpectations(t)
519 func TestRemoveAndPublishSuccessfully(t *testing.T) {
522 expectedChannelAndEvent := []string{"{namespace},channel", "event"}
523 expectedKeys := []string{"{namespace},key1", "{namespace},key2"}
525 m.On("DelMPub", expectedChannelAndEvent, expectedKeys).Return(nil)
526 err := i.RemoveAndPublish([]string{"channel", "event"}, []string{"key1", "key2"})
528 m.AssertExpectations(t)
531 func TestRemoveAndPublishSeveralChannelsAndEventsSuccessfully(t *testing.T) {
534 expectedChannelAndEvent := []string{"{namespace},channel1", "event1___event2",
535 "{namespace},channel2", "event3___event4"}
536 expectedKeys := []string{"{namespace},key1", "{namespace},key2"}
538 verifyChannelAndEvent := func(input []string) bool {
539 return verifySliceInOrder(input, expectedChannelAndEvent)
541 m.On("DelMPub", mock.MatchedBy(verifyChannelAndEvent), expectedKeys).Return(nil)
542 err := i.RemoveAndPublish([]string{"channel1", "event1", "channel2", "event3",
543 "channel1", "event2", "channel2", "event4"},
544 []string{"key1", "key2"})
546 m.AssertExpectations(t)
548 func TestRemoveAndPublishFail(t *testing.T) {
551 expectedChannelAndEvent := []string{"{namespace},channel", "event"}
552 expectedKeys := []string{"{namespace},key1", "{namespace},key2"}
554 m.On("DelMPub", expectedChannelAndEvent, expectedKeys).Return(errors.New("Some error"))
555 err := i.RemoveAndPublish([]string{"channel", "event"}, []string{"key1", "key2"})
556 assert.NotNil(t, err)
557 m.AssertExpectations(t)
560 func TestRemoveAndPublishNoChannels(t *testing.T) {
563 expectedKeys := []string{"{namespace},key1", "{namespace},key2"}
565 m.On("Del", expectedKeys).Return(nil)
566 err := i.RemoveAndPublish([]string{}, []string{"key1", "key2"})
568 m.AssertExpectations(t)
571 func TestRemoveAndPublishIncorrectChannel(t *testing.T) {
574 notExpectedChannelAndEvent := []string{}
575 notExpectedKeys := []string{"{namespace},key"}
577 m.AssertNotCalled(t, "DelMPub", notExpectedChannelAndEvent, notExpectedKeys)
578 m.AssertNotCalled(t, "Del", notExpectedKeys)
579 err := i.RemoveAndPublish([]string{"channel", "event", "channel2"}, []string{})
581 m.AssertExpectations(t)
584 func TestRemoveAndPublishNoKeys(t *testing.T) {
587 notExpectedChannelAndEvent := []string{}
588 notExpectedKeys := []string{"{namespace},key"}
590 m.AssertNotCalled(t, "DelMPub", notExpectedChannelAndEvent, notExpectedKeys)
591 m.AssertNotCalled(t, "Del", notExpectedKeys)
592 err := i.RemoveAndPublish([]string{"channel", "event"}, []string{})
594 m.AssertExpectations(t)
596 func TestRemoveAndPublishNoChannelsError(t *testing.T) {
599 expectedKeys := []string{"{namespace},key1", "{namespace},key2"}
601 m.On("Del", expectedKeys).Return(errors.New("Some error"))
602 err := i.RemoveAndPublish([]string{}, []string{"key1", "key2"})
603 assert.NotNil(t, err)
604 m.AssertExpectations(t)
606 func TestRemoveSuccessfully(t *testing.T) {
609 msetExpected := []string{"{namespace},key1", "{namespace},key2"}
610 m.On("Del", msetExpected).Return(nil)
612 err := i.Remove([]string{"key1", "key2"})
614 m.AssertExpectations(t)
617 func TestRemoveFail(t *testing.T) {
620 msetExpected := []string{"{namespace},key"}
621 m.On("Del", msetExpected).Return(errors.New("Some error"))
623 err := i.Remove([]string{"key"})
624 assert.NotNil(t, err)
625 m.AssertExpectations(t)
628 func TestRemoveEmptyList(t *testing.T) {
631 err := i.Remove([]string{})
633 m.AssertNotCalled(t, "Del", []string{})
636 func TestGetAllSuccessfully(t *testing.T) {
639 mKeysExpected := string("{namespace},*")
640 mReturnExpected := []string{"{namespace},key1", "{namespace},key2"}
641 expectedReturn := []string{"key1", "key2"}
642 m.On("Keys", mKeysExpected).Return(mReturnExpected, nil)
643 retVal, err := i.GetAll()
645 assert.Equal(t, expectedReturn, retVal)
646 m.AssertExpectations(t)
649 func TestGetAllFail(t *testing.T) {
652 mKeysExpected := string("{namespace},*")
653 mReturnExpected := []string{}
654 m.On("Keys", mKeysExpected).Return(mReturnExpected, errors.New("some error"))
655 retVal, err := i.GetAll()
656 assert.NotNil(t, err)
657 assert.Nil(t, retVal)
658 assert.Equal(t, len(retVal), 0)
659 m.AssertExpectations(t)
662 func TestGetAllReturnEmpty(t *testing.T) {
665 mKeysExpected := string("{namespace},*")
666 var mReturnExpected []string = nil
667 m.On("Keys", mKeysExpected).Return(mReturnExpected, nil)
668 retVal, err := i.GetAll()
670 assert.Nil(t, retVal)
671 assert.Equal(t, len(retVal), 0)
672 m.AssertExpectations(t)
676 func TestRemoveAllSuccessfully(t *testing.T) {
679 mKeysExpected := string("{namespace},*")
680 mKeysReturn := []string{"{namespace},key1", "{namespace},key2"}
681 mDelExpected := mKeysReturn
682 m.On("Keys", mKeysExpected).Return(mKeysReturn, nil)
683 m.On("Del", mDelExpected).Return(nil)
686 m.AssertExpectations(t)
689 func TestRemoveAllNoKeysFound(t *testing.T) {
692 mKeysExpected := string("{namespace},*")
693 var mKeysReturn []string = nil
694 m.On("Keys", mKeysExpected).Return(mKeysReturn, nil)
695 m.AssertNumberOfCalls(t, "Del", 0)
698 m.AssertExpectations(t)
701 func TestRemoveAllKeysReturnError(t *testing.T) {
704 mKeysExpected := string("{namespace},*")
705 var mKeysReturn []string = nil
706 m.On("Keys", mKeysExpected).Return(mKeysReturn, errors.New("Some error"))
707 m.AssertNumberOfCalls(t, "Del", 0)
709 assert.NotNil(t, err)
710 m.AssertExpectations(t)
713 func TestRemoveAllDelReturnError(t *testing.T) {
716 mKeysExpected := string("{namespace},*")
717 mKeysReturn := []string{"{namespace},key1", "{namespace},key2"}
718 mDelExpected := mKeysReturn
719 m.On("Keys", mKeysExpected).Return(mKeysReturn, nil)
720 m.On("Del", mDelExpected).Return(errors.New("Some Error"))
722 assert.NotNil(t, err)
723 m.AssertExpectations(t)
726 func TestSetIfSuccessfullyOkStatus(t *testing.T) {
729 mSetIEExpectedKey := string("{namespace},key1")
730 mSetIEExpectedOldData := interface{}("olddata")
731 mSetIEExpectedNewData := interface{}("newdata")
732 m.On("SetIE", mSetIEExpectedKey, mSetIEExpectedOldData, mSetIEExpectedNewData).Return(true, nil)
733 status, err := i.SetIf("key1", "olddata", "newdata")
735 assert.True(t, status)
736 m.AssertExpectations(t)
739 func TestSetIfSuccessfullyNOKStatus(t *testing.T) {
742 mSetIEExpectedKey := string("{namespace},key1")
743 mSetIEExpectedOldData := interface{}("olddata")
744 mSetIEExpectedNewData := interface{}("newdata")
745 m.On("SetIE", mSetIEExpectedKey, mSetIEExpectedOldData, mSetIEExpectedNewData).Return(false, nil)
746 status, err := i.SetIf("key1", "olddata", "newdata")
748 assert.False(t, status)
749 m.AssertExpectations(t)
752 func TestSetIfFailure(t *testing.T) {
755 mSetIEExpectedKey := string("{namespace},key1")
756 mSetIEExpectedOldData := interface{}("olddata")
757 mSetIEExpectedNewData := interface{}("newdata")
758 m.On("SetIE", mSetIEExpectedKey, mSetIEExpectedOldData, mSetIEExpectedNewData).Return(false, errors.New("Some error"))
759 status, err := i.SetIf("key1", "olddata", "newdata")
760 assert.NotNil(t, err)
761 assert.False(t, status)
762 m.AssertExpectations(t)
765 func TestSetIfAndPublishSuccessfully(t *testing.T) {
768 expectedChannel := "{namespace},channel"
769 expectedEvent := "event"
770 expectedKey := "{namespace},key"
771 expectedOldData := interface{}("olddata")
772 expectedNewData := interface{}("newdata")
773 m.On("SetIEPub", expectedChannel, expectedEvent, expectedKey, expectedOldData, expectedNewData).Return(true, nil)
774 status, err := i.SetIfAndPublish([]string{"channel", "event"}, "key", "olddata", "newdata")
776 assert.True(t, status)
777 m.AssertExpectations(t)
780 func TestSetIfAndPublishIncorrectChannelAndEvent(t *testing.T) {
783 expectedChannel := "{namespace},channel"
784 expectedEvent := "event"
785 expectedKey := "{namespace},key"
786 expectedOldData := interface{}("olddata")
787 expectedNewData := interface{}("newdata")
788 m.AssertNotCalled(t, "SetIEPub", expectedChannel, expectedEvent, expectedKey, expectedOldData, expectedNewData)
789 m.AssertNotCalled(t, "SetIE", expectedKey, expectedOldData, expectedNewData)
790 status, err := i.SetIfAndPublish([]string{"channel", "event1", "channel"}, "key", "olddata", "newdata")
791 assert.NotNil(t, err)
792 assert.False(t, status)
793 m.AssertExpectations(t)
795 func TestSetIfAndPublishNOKStatus(t *testing.T) {
798 expectedChannel := "{namespace},channel"
799 expectedEvent := "event"
800 expectedKey := "{namespace},key"
801 expectedOldData := interface{}("olddata")
802 expectedNewData := interface{}("newdata")
803 m.On("SetIEPub", expectedChannel, expectedEvent, expectedKey, expectedOldData, expectedNewData).Return(false, nil)
804 status, err := i.SetIfAndPublish([]string{"channel", "event"}, "key", "olddata", "newdata")
806 assert.False(t, status)
807 m.AssertExpectations(t)
810 func TestSetIfAndPublishNoChannels(t *testing.T) {
813 expectedKey := "{namespace},key"
814 expectedOldData := interface{}("olddata")
815 expectedNewData := interface{}("newdata")
816 m.On("SetIE", expectedKey, expectedOldData, expectedNewData).Return(true, nil)
817 status, err := i.SetIfAndPublish([]string{}, "key", "olddata", "newdata")
819 assert.True(t, status)
820 m.AssertExpectations(t)
823 func TestSetIfNotExistsAndPublishSuccessfully(t *testing.T) {
826 expectedChannel := "{namespace},channel"
827 expectedEvent := "event"
828 expectedKey := "{namespace},key"
829 expectedData := interface{}("data")
831 m.On("SetNXPub", expectedChannel, expectedEvent, expectedKey, expectedData).Return(true, nil)
832 status, err := i.SetIfNotExistsAndPublish([]string{"channel", "event"}, "key", "data")
834 assert.True(t, status)
835 m.AssertExpectations(t)
838 func TestSetIfNotExistsAndPublishSeveralEvents(t *testing.T) {
841 expectedChannel := "{namespace},channel"
842 expectedEvent := "event1___event2"
843 expectedKey := "{namespace},key"
844 expectedData := interface{}("data")
846 m.On("SetNXPub", expectedChannel, expectedEvent, expectedKey, expectedData).Return(true, nil)
847 status, err := i.SetIfNotExistsAndPublish([]string{"channel", "event1", "channel", "event2"}, "key", "data")
849 assert.True(t, status)
850 m.AssertExpectations(t)
853 func TestSetIfNotExistsAndPublishNoChannels(t *testing.T) {
856 expectedKey := "{namespace},key"
857 expectedData := interface{}("data")
859 m.On("SetNX", expectedKey, expectedData).Return(true, nil)
860 status, err := i.SetIfNotExistsAndPublish([]string{}, "key", "data")
862 assert.True(t, status)
863 m.AssertExpectations(t)
866 func TestSetIfNotExistsAndPublishFail(t *testing.T) {
869 expectedChannel := "{namespace},channel"
870 expectedEvent := "event"
871 expectedKey := "{namespace},key"
872 expectedData := interface{}("data")
874 m.On("SetNXPub", expectedChannel, expectedEvent, expectedKey, expectedData).Return(false, nil)
875 status, err := i.SetIfNotExistsAndPublish([]string{"channel", "event"}, "key", "data")
877 assert.False(t, status)
878 m.AssertExpectations(t)
881 func TestSetIfNotExistsAndPublishIncorrectChannels(t *testing.T) {
884 expectedChannel := "{namespace},channel"
885 expectedEvent := "event"
886 expectedKey := "{namespace},key"
887 expectedData := interface{}("data")
889 m.AssertNotCalled(t, "SetNXPub", expectedChannel, expectedEvent, expectedKey, expectedData)
890 m.AssertNotCalled(t, "SetNX", expectedKey, expectedData)
891 status, err := i.SetIfNotExistsAndPublish([]string{"channel", "event", "channel2"}, "key", "data")
892 assert.NotNil(t, err)
893 assert.False(t, status)
894 m.AssertExpectations(t)
897 func TestSetIfNotExistsAndPublishError(t *testing.T) {
900 expectedChannel := "{namespace},channel"
901 expectedEvent := "event"
902 expectedKey := "{namespace},key"
903 expectedData := interface{}("data")
905 m.On("SetNXPub", expectedChannel, expectedEvent, expectedKey, expectedData).Return(false, errors.New("Some error"))
906 status, err := i.SetIfNotExistsAndPublish([]string{"channel", "event"}, "key", "data")
907 assert.NotNil(t, err)
908 assert.False(t, status)
909 m.AssertExpectations(t)
912 func TestSetIfNotExistsSuccessfullyOkStatus(t *testing.T) {
915 mSetNXExpectedKey := string("{namespace},key1")
916 mSetNXExpectedData := interface{}("data")
917 m.On("SetNX", mSetNXExpectedKey, mSetNXExpectedData).Return(true, nil)
918 status, err := i.SetIfNotExists("key1", "data")
920 assert.True(t, status)
921 m.AssertExpectations(t)
924 func TestSetIfNotExistsSuccessfullyNOKStatus(t *testing.T) {
927 mSetNXExpectedKey := string("{namespace},key1")
928 mSetNXExpectedData := interface{}("data")
929 m.On("SetNX", mSetNXExpectedKey, mSetNXExpectedData).Return(false, nil)
930 status, err := i.SetIfNotExists("key1", "data")
932 assert.False(t, status)
933 m.AssertExpectations(t)
936 func TestSetIfNotExistsFailure(t *testing.T) {
939 mSetNXExpectedKey := string("{namespace},key1")
940 mSetNXExpectedData := interface{}("data")
941 m.On("SetNX", mSetNXExpectedKey, mSetNXExpectedData).Return(false, errors.New("Some error"))
942 status, err := i.SetIfNotExists("key1", "data")
943 assert.NotNil(t, err)
944 assert.False(t, status)
945 m.AssertExpectations(t)
948 func TestRemoveIfAndPublishSuccessfully(t *testing.T) {
951 expectedChannel := "{namespace},channel"
952 expectedEvent := "event1___event2"
953 expectedKey := "{namespace},key"
954 expectedValue := interface{}("data")
956 m.On("DelIEPub", expectedChannel, expectedEvent, expectedKey, expectedValue).Return(true, nil)
957 status, err := i.RemoveIfAndPublish([]string{"channel", "event1", "channel", "event2"}, "key", "data")
959 assert.True(t, status)
960 m.AssertExpectations(t)
963 func TestRemoveIfAndPublishNok(t *testing.T) {
966 expectedChannel := "{namespace},channel"
967 expectedEvent := "event1___event2"
968 expectedKey := "{namespace},key"
969 expectedValue := interface{}("data")
971 m.On("DelIEPub", expectedChannel, expectedEvent, expectedKey, expectedValue).Return(false, nil)
972 status, err := i.RemoveIfAndPublish([]string{"channel", "event1", "channel", "event2"}, "key", "data")
974 assert.False(t, status)
975 m.AssertExpectations(t)
978 func TestRemoveIfAndPublishError(t *testing.T) {
981 expectedChannel := "{namespace},channel"
982 expectedEvent := "event1___event2"
983 expectedKey := "{namespace},key"
984 expectedValue := interface{}("data")
986 m.On("DelIEPub", expectedChannel, expectedEvent, expectedKey, expectedValue).Return(false, errors.New("Some error"))
987 status, err := i.RemoveIfAndPublish([]string{"channel", "event1", "channel", "event2"}, "key", "data")
988 assert.NotNil(t, err)
989 assert.False(t, status)
990 m.AssertExpectations(t)
993 func TestRemoveIfAndPublishIncorrectChannel(t *testing.T) {
996 expectedChannel := "{namespace},channel"
997 expectedEvent := "event"
998 expectedKey := "{namespace},key"
999 expectedValue := interface{}("data")
1001 m.AssertNotCalled(t, "DelIEPub", expectedChannel, expectedEvent, expectedKey, expectedValue)
1002 m.AssertNotCalled(t, "DelIE", expectedKey, expectedValue)
1003 status, err := i.RemoveIfAndPublish([]string{"channel", "event1", "channel"}, "key", "data")
1004 assert.NotNil(t, err)
1005 assert.False(t, status)
1006 m.AssertExpectations(t)
1009 func TestRemoveIfAndPublishNoChannels(t *testing.T) {
1012 expectedKey := "{namespace},key"
1013 expectedValue := interface{}("data")
1015 m.On("DelIE", expectedKey, expectedValue).Return(true, nil)
1016 status, err := i.RemoveIfAndPublish([]string{}, "key", "data")
1018 assert.True(t, status)
1019 m.AssertExpectations(t)
1022 func TestRemoveIfSuccessfullyOkStatus(t *testing.T) {
1025 mDelIEExpectedKey := string("{namespace},key1")
1026 mDelIEExpectedData := interface{}("data")
1027 m.On("DelIE", mDelIEExpectedKey, mDelIEExpectedData).Return(true, nil)
1028 status, err := i.RemoveIf("key1", "data")
1030 assert.True(t, status)
1031 m.AssertExpectations(t)
1034 func TestRemoveIfSuccessfullyNOKStatus(t *testing.T) {
1037 mDelIEExpectedKey := string("{namespace},key1")
1038 mDelIEExpectedData := interface{}("data")
1039 m.On("DelIE", mDelIEExpectedKey, mDelIEExpectedData).Return(false, nil)
1040 status, err := i.RemoveIf("key1", "data")
1042 assert.False(t, status)
1043 m.AssertExpectations(t)
1046 func TestRemoveIfFailure(t *testing.T) {
1049 mDelIEExpectedKey := string("{namespace},key1")
1050 mDelIEExpectedData := interface{}("data")
1051 m.On("DelIE", mDelIEExpectedKey, mDelIEExpectedData).Return(true, errors.New("Some error"))
1052 status, err := i.RemoveIf("key1", "data")
1053 assert.NotNil(t, err)
1054 assert.False(t, status)
1055 m.AssertExpectations(t)
1058 func TestRemoveAllAndPublishSuccessfully(t *testing.T) {
1061 mKeysExpected := string("{namespace},*")
1062 mKeysReturn := []string{"{namespace},key1", "{namespace},key2"}
1063 mDelExpected := mKeysReturn
1064 expectedChannelAndEvent := []string{"{namespace},channel", "event"}
1065 m.On("Keys", mKeysExpected).Return(mKeysReturn, nil)
1066 m.On("DelMPub", expectedChannelAndEvent, mDelExpected).Return(nil)
1067 err := i.RemoveAllAndPublish([]string{"channel", "event"})
1069 m.AssertExpectations(t)
1072 func TestRemoveAllAndPublishKeysReturnError(t *testing.T) {
1075 mKeysExpected := string("{namespace},*")
1076 mKeysReturn := []string{"{namespace},key1", "{namespace},key2"}
1077 mDelExpected := mKeysReturn
1078 expectedChannelAndEvent := []string{"{namespace},channel", "event" }
1079 m.On("Keys", mKeysExpected).Return(mKeysReturn, errors.New("Some error"))
1080 m.AssertNotCalled(t, "DelMPub", expectedChannelAndEvent, mDelExpected)
1081 err := i.RemoveAllAndPublish([]string{"channel", "event"})
1082 assert.NotNil(t, err)
1083 m.AssertExpectations(t)
1086 func TestRemoveAllAndPublishKeysDelReturnsError(t *testing.T) {
1089 mKeysExpected := string("{namespace},*")
1090 mKeysReturn := []string{"{namespace},key1", "{namespace},key2"}
1091 mDelExpected := mKeysReturn
1092 expectedChannelAndEvent := []string{"{namespace},channel", "event"}
1093 m.On("Keys", mKeysExpected).Return(mKeysReturn, nil)
1094 m.On("DelMPub", expectedChannelAndEvent, mDelExpected).Return(errors.New("Some error"))
1095 err := i.RemoveAllAndPublish([]string{"channel", "event"})
1096 assert.NotNil(t, err)
1097 m.AssertExpectations(t)
1100 func TestRemoveAllAndPublishKeysEventsWithIllegalCharacters(t *testing.T) {
1103 mKeysExpected := string("{namespace},*")
1104 mKeysReturn := []string{"{namespace},key1", "{namespace},key2"}
1105 mDelExpected := mKeysReturn
1106 expectedChannelAndEvent := []string{"{namespace},channel", "event"}
1107 m.On("Keys", mKeysExpected).Return(mKeysReturn, nil)
1108 m.AssertNotCalled(t, "DelMPub", expectedChannelAndEvent, mDelExpected)
1109 err := i.RemoveAllAndPublish([]string{"channel", "event___anotherEvent"})
1110 assert.NotNil(t, err)
1111 m.AssertExpectations(t)
1115 func TestRemoveAllAndPublishNoChannels(t *testing.T) {
1118 mKeysExpected := string("{namespace},*")
1119 mKeysReturn := []string{"{namespace},key1", "{namespace},key2"}
1120 mDelExpected := mKeysReturn
1121 m.On("Keys", mKeysExpected).Return(mKeysReturn, nil)
1122 m.On("Del", mDelExpected).Return(nil)
1123 m.AssertNotCalled(t, "DelMPub", "", "", mDelExpected)
1124 err := i.RemoveAllAndPublish([]string{})
1126 m.AssertExpectations(t)
1129 func TestRemoveAllAndPublishIncorrectChannel(t *testing.T) {
1132 mKeysExpected := string("{namespace},*")
1133 mKeysReturn := []string{"{namespace},key1", "{namespace},key2"}
1134 mDelExpected := mKeysReturn
1135 m.On("Keys", mKeysExpected).Return(mKeysReturn, nil)
1136 m.AssertNotCalled(t, "DelMPub", "", "", mDelExpected)
1137 err := i.RemoveAllAndPublish([]string{"channel", "event", "channel2"})
1138 assert.NotNil(t, err)
1139 m.AssertExpectations(t)
1143 func TestAddMemberSuccessfully(t *testing.T) {
1146 groupExpected := string("{namespace},group")
1147 membersExpected := []interface{}{"member1", "member2"}
1149 m.On("SAdd", groupExpected, membersExpected).Return(nil)
1151 err := i.AddMember("group", "member1", "member2")
1153 m.AssertExpectations(t)
1156 func TestAddMemberFail(t *testing.T) {
1159 groupExpected := string("{namespace},group")
1160 membersExpected := []interface{}{"member1", "member2"}
1162 m.On("SAdd", groupExpected, membersExpected).Return(errors.New("Some error"))
1164 err := i.AddMember("group", "member1", "member2")
1165 assert.NotNil(t, err)
1166 m.AssertExpectations(t)
1168 func TestRemoveMemberSuccessfully(t *testing.T) {
1171 groupExpected := string("{namespace},group")
1172 membersExpected := []interface{}{"member1", "member2"}
1174 m.On("SRem", groupExpected, membersExpected).Return(nil)
1176 err := i.RemoveMember("group", "member1", "member2")
1178 m.AssertExpectations(t)
1181 func TestRemoveMemberFail(t *testing.T) {
1184 groupExpected := string("{namespace},group")
1185 membersExpected := []interface{}{"member1", "member2"}
1187 m.On("SRem", groupExpected, membersExpected).Return(errors.New("Some error"))
1189 err := i.RemoveMember("group", "member1", "member2")
1190 assert.NotNil(t, err)
1191 m.AssertExpectations(t)
1194 func TestRemoveGroupSuccessfully(t *testing.T) {
1197 groupExpected := []string{"{namespace},group"}
1199 m.On("Del", groupExpected).Return(nil)
1201 err := i.RemoveGroup("group")
1203 m.AssertExpectations(t)
1205 func TestRemoveGroupFail(t *testing.T) {
1208 groupExpected := []string{"{namespace},group"}
1210 m.On("Del", groupExpected).Return(errors.New("Some error"))
1212 err := i.RemoveGroup("group")
1213 assert.NotNil(t, err)
1214 m.AssertExpectations(t)
1217 func TestGetMembersSuccessfully(t *testing.T) {
1220 groupExpected := "{namespace},group"
1221 returnExpected := []string{"member1", "member2"}
1223 m.On("SMembers", groupExpected).Return(returnExpected, nil)
1225 result, err := i.GetMembers("group")
1227 assert.Equal(t, result, returnExpected)
1228 m.AssertExpectations(t)
1230 func TestGetMembersFail(t *testing.T) {
1233 groupExpected := "{namespace},group"
1234 returnExpected := []string{"member1", "member2"}
1236 m.On("SMembers", groupExpected).Return(returnExpected, errors.New("Some error"))
1238 result, err := i.GetMembers("group")
1239 assert.NotNil(t,err)
1240 assert.Equal(t, []string{}, result)
1241 m.AssertExpectations(t)
1244 func TestIsMemberSuccessfullyIsMember(t *testing.T) {
1247 groupExpected := "{namespace},group"
1248 memberExpected := "member"
1250 m.On("SIsMember", groupExpected, memberExpected).Return(true, nil)
1252 result, err := i.IsMember("group", "member")
1254 assert.True(t, result)
1255 m.AssertExpectations(t)
1257 func TestIsMemberSuccessfullyIsNotMember(t *testing.T) {
1260 groupExpected := "{namespace},group"
1261 memberExpected := "member"
1263 m.On("SIsMember", groupExpected, memberExpected).Return(false, nil)
1265 result, err := i.IsMember("group", "member")
1267 assert.False(t, result)
1268 m.AssertExpectations(t)
1270 func TestIsMemberFailure(t *testing.T) {
1273 groupExpected := "{namespace},group"
1274 memberExpected := "member"
1276 m.On("SIsMember", groupExpected, memberExpected).Return(true, errors.New("Some error"))
1278 result, err := i.IsMember("group", "member")
1279 assert.NotNil(t, err)
1280 assert.False(t, result)
1281 m.AssertExpectations(t)
1284 func TestGroupSizeSuccessfully(t *testing.T) {
1287 var expectedSize int64
1289 groupExpected := "{namespace},group"
1291 m.On("SCard", groupExpected).Return(expectedSize, nil)
1293 result, err := i.GroupSize("group")
1295 assert.Equal(t, expectedSize, result)
1296 m.AssertExpectations(t)
1298 func TestGroupSizeFail(t *testing.T) {
1301 var expectedSize int64
1303 groupExpected := "{namespace},group"
1305 m.On("SCard", groupExpected).Return(expectedSize, errors.New("Some error"))
1307 result, err := i.GroupSize("group")
1308 assert.NotNil(t, err)
1309 assert.Equal(t, int64(0), result)
1310 m.AssertExpectations(t)