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 (m *mockDB) SAdd(key string, data ...interface{}) error {
108 a := m.Called(key, data)
112 func (m *mockDB) SRem(key string, data ...interface{}) error {
113 a := m.Called(key, data)
116 func (m *mockDB) SMembers(key string) ([]string, error) {
118 return a.Get(0).([]string), a.Error(1)
121 func (m *mockDB) SIsMember(key string, data interface{}) (bool, error) {
122 a := m.Called(key, data)
123 return a.Bool(0), a.Error(1)
126 func (m *mockDB) SCard(key string) (int64, error) {
128 return a.Get(0).(int64), a.Error(1)
131 func setup() (*mockDB, *sdlgo.SdlInstance) {
133 i := sdlgo.NewSdlInstance("namespace", m)
137 func TestSubscribeChannel(t *testing.T) {
140 expectedCB := func(channel string, events ...string) {}
141 expectedChannels := []string{"{namespace},channel1", "{namespace},channel2"}
143 m.On("SubscribeChannelDB", mock.AnythingOfType("sdlgoredis.ChannelNotificationCb"), "{namespace},", "___", expectedChannels).Return()
144 i.SubscribeChannel(expectedCB, "channel1", "channel2")
145 m.AssertExpectations(t)
148 func TestUnsubscribeChannel(t *testing.T) {
151 expectedChannels := []string{"{namespace},channel1", "{namespace},channel2"}
153 m.On("UnsubscribeChannelDB", expectedChannels).Return()
154 i.UnsubscribeChannel("channel1", "channel2")
155 m.AssertExpectations(t)
157 func TestGetOneKey(t *testing.T) {
160 mgetExpected := []string{"{namespace},key"}
161 mReturn := []interface{}{"somevalue"}
162 mReturnExpected := make(map[string]interface{})
163 mReturnExpected["key"] = "somevalue"
165 m.On("MGet", mgetExpected).Return(mReturn, nil)
166 retVal, err := i.Get([]string{"key"})
168 assert.Equal(t, mReturnExpected, retVal)
169 m.AssertExpectations(t)
172 func TestGetSeveralKeys(t *testing.T) {
175 mgetExpected := []string{"{namespace},key1", "{namespace},key2", "{namespace},key3"}
176 mReturn := []interface{}{"somevalue1", 2, "someothervalue"}
177 mReturnExpected := make(map[string]interface{})
178 mReturnExpected["key1"] = "somevalue1"
179 mReturnExpected["key2"] = 2
180 mReturnExpected["key3"] = "someothervalue"
182 m.On("MGet", mgetExpected).Return(mReturn, nil)
183 retVal, err := i.Get([]string{"key1", "key2", "key3"})
185 assert.Equal(t, mReturnExpected, retVal)
186 m.AssertExpectations(t)
189 func TestGetSeveralKeysSomeFail(t *testing.T) {
192 mgetExpected := []string{"{namespace},key1", "{namespace},key2", "{namespace},key3"}
193 mReturn := []interface{}{"somevalue1", nil, "someothervalue"}
194 mReturnExpected := make(map[string]interface{})
195 mReturnExpected["key1"] = "somevalue1"
196 mReturnExpected["key2"] = nil
197 mReturnExpected["key3"] = "someothervalue"
199 m.On("MGet", mgetExpected).Return(mReturn, nil)
200 retVal, err := i.Get([]string{"key1", "key2", "key3"})
202 assert.Equal(t, mReturnExpected, retVal)
203 m.AssertExpectations(t)
206 func TestGetKeyReturnError(t *testing.T) {
209 mgetExpected := []string{"{namespace},key"}
210 mReturn := []interface{}{nil}
211 mReturnExpected := make(map[string]interface{})
213 m.On("MGet", mgetExpected).Return(mReturn, errors.New("Some error"))
214 retVal, err := i.Get([]string{"key"})
215 assert.NotNil(t, err)
216 assert.Equal(t, mReturnExpected, retVal)
217 m.AssertExpectations(t)
220 func TestGetEmptyList(t *testing.T) {
223 mgetExpected := []string{}
225 retval, err := i.Get([]string{})
227 assert.Len(t, retval, 0)
228 m.AssertNotCalled(t, "MGet", mgetExpected)
231 func TestWriteOneKey(t *testing.T) {
234 msetExpected := []interface{}{"{namespace},key1", "data1"}
236 m.On("MSet", msetExpected).Return(nil)
237 err := i.Set("key1", "data1")
239 m.AssertExpectations(t)
242 func TestWriteByteSliceAsValue(t *testing.T) {
245 msetExpected := []interface{}{"{namespace},key1", []byte{1, 2, 3, 4, 5}}
247 m.On("MSet", msetExpected).Return(nil)
248 err := i.Set("key1", []byte{1, 2, 3, 4, 5})
250 m.AssertExpectations(t)
253 func TestWriteByteSliceAsValueMixed(t *testing.T) {
256 msetExpected := []interface{}{"{namespace},key1", []byte{1, 2, 3, 4, 5}, "{namespace},key2", "value2"}
258 m.On("MSet", msetExpected).Return(nil)
259 err := i.Set("key1", []byte{1, 2, 3, 4, 5}, []string{"key2", "value2"})
261 m.AssertExpectations(t)
264 func TestWriteByteArrayAsValue(t *testing.T) {
267 msetExpected := []interface{}{"{namespace},key1", [5]byte{1, 2, 3, 4, 5}}
269 m.On("MSet", msetExpected).Return(nil)
270 err := i.Set("key1", [5]byte{1, 2, 3, 4, 5})
272 m.AssertExpectations(t)
275 func TestWriteMixed(t *testing.T) {
278 msetExpected := []interface{}{"{namespace},key1", "data1", "{namespace},key2", "data2", "{namespace},key3", "data3"}
280 m.On("MSet", msetExpected).Return(nil)
281 err := i.Set("key1", "data1", []string{"key2", "data2"}, [2]string{"key3", "data3"})
283 m.AssertExpectations(t)
286 func TestWriteIncorrectMixed(t *testing.T) {
289 msetExpected := []interface{}{"{namespace},key1", "data1", "{namespace},key2", "data2", "{namespace},key3", "data3"}
291 m.AssertNotCalled(t, "MSet", msetExpected)
292 err := i.Set("key1", []string{"key2", "data2"}, [2]string{"key3", "data3"})
293 assert.NotNil(t, err)
294 m.AssertExpectations(t)
296 func TestWriteIncorrectPairs(t *testing.T) {
299 msetExpected := []interface{}{}
301 m.AssertNotCalled(t, "MSet", msetExpected)
303 assert.NotNil(t, err)
304 m.AssertExpectations(t)
306 func TestWriteSeveralKeysSlice(t *testing.T) {
309 msetExpected := []interface{}{"{namespace},key1", "data1", "{namespace},key2", 22}
311 m.On("MSet", msetExpected).Return(nil)
312 err := i.Set([]interface{}{"key1", "data1", "key2", 22})
314 m.AssertExpectations(t)
318 func TestWriteSeveralKeysIncorrectSlice(t *testing.T) {
321 msetExpected := []interface{}{"{namespace},key1", "data1", "{namespace},key2", 22}
323 m.AssertNotCalled(t, "MSet", msetExpected)
324 err := i.Set([]interface{}{"key1", "data1", "key2"})
325 assert.NotNil(t, err)
326 m.AssertExpectations(t)
330 func TestWriteSeveralKeysArray(t *testing.T) {
333 msetExpected := []interface{}{"{namespace},key1", "data1", "{namespace},key2", "data2"}
335 m.On("MSet", msetExpected).Return(nil)
336 err := i.Set([4]string{"key1", "data1", "key2", "data2"})
338 m.AssertExpectations(t)
341 func TestWriteSeveralKeysIncorrectArray(t *testing.T) {
344 msetExpected := []interface{}{}
346 m.AssertNotCalled(t, "MSet", msetExpected)
347 err := i.Set([3]string{"key1", "data1", "key2"})
348 assert.NotNil(t, err)
349 m.AssertExpectations(t)
352 func TestWriteFail(t *testing.T) {
355 msetExpected := []interface{}{"{namespace},key1", "data1"}
357 m.On("MSet", msetExpected).Return(errors.New("Some error"))
358 err := i.Set("key1", "data1")
359 assert.NotNil(t, err)
360 m.AssertExpectations(t)
363 func TestWriteEmptyList(t *testing.T) {
366 msetExpected := []interface{}{}
369 m.AssertNotCalled(t, "MSet", msetExpected)
372 func TestWriteAndPublishOneKeyOneChannel(t *testing.T) {
375 expectedChannel := "{namespace},channel"
376 expectedMessage := "event"
377 expectedKeyVal := []interface{}{"{namespace},key1", "data1"}
379 m.On("MSetPub", expectedChannel, expectedMessage, expectedKeyVal).Return(nil)
380 m.AssertNotCalled(t, "MSet", expectedKeyVal)
381 err := i.SetAndPublish([]string{"channel", "event"}, "key1", "data1")
383 m.AssertExpectations(t)
385 func TestWriteAndPublishOneKeyOneChannelTwoEvents(t *testing.T) {
388 expectedChannel := "{namespace},channel"
389 expectedMessage := "event1___event2"
390 expectedKeyVal := []interface{}{"{namespace},key1", "data1"}
392 m.On("MSetPub", expectedChannel, expectedMessage, expectedKeyVal).Return(nil)
393 m.AssertNotCalled(t, "MSet", expectedKeyVal)
394 err := i.SetAndPublish([]string{"channel", "event1", "channel", "event2"}, "key1", "data1")
396 m.AssertExpectations(t)
399 func TestWriteAndPublishIncorrectChannelAndEvent(t *testing.T) {
402 expectedChannel := "{namespace},channel"
403 expectedMessage := "event1___event2"
404 expectedKeyVal := []interface{}{"{namespace},key1", "data1"}
405 m.AssertNotCalled(t, "MSetPub", expectedChannel, expectedMessage, expectedKeyVal)
406 m.AssertNotCalled(t, "MSet", expectedKeyVal)
407 err := i.SetAndPublish([]string{"channel", "event1", "channel"}, "key1", "data1")
408 assert.NotNil(t, err)
409 m.AssertExpectations(t)
412 func TestWriteAndPublishNotAllowedCharactersInEvents(t *testing.T) {
415 expectedChannel := "{namespace},channel"
416 expectedMessage := "event1___event2"
417 expectedKeyVal := []interface{}{"{namespace},key1", "data1"}
418 m.AssertNotCalled(t, "MSetPub", expectedChannel, expectedMessage, expectedKeyVal)
419 m.AssertNotCalled(t, "MSet", expectedKeyVal)
420 err := i.SetAndPublish([]string{"channel", "event1___event2"}, "key1", "data1")
421 assert.NotNil(t, err)
422 m.AssertExpectations(t)
425 func TestWriteAndPublishNoData(t *testing.T) {
428 expectedChannel := "{namespace},channel"
429 expectedMessage := "event"
430 expectedKeyVal := []interface{}{"key"}
432 m.AssertNotCalled(t, "MSetPub", expectedChannel, expectedMessage, expectedKeyVal)
433 m.AssertNotCalled(t, "MSet", expectedKeyVal)
434 err := i.SetAndPublish([]string{"channel", "event"}, []interface{}{"key"})
435 assert.NotNil(t, err)
436 m.AssertExpectations(t)
439 func TestWriteAndPublishNoChannelEvent(t *testing.T) {
442 expectedKeyVal := []interface{}{"{namespace},key1", "data1"}
444 m.On("MSet", expectedKeyVal).Return(nil)
445 m.AssertNotCalled(t, "MSetPub", "", "", expectedKeyVal)
446 err := i.SetAndPublish([]string{}, "key1", "data1")
448 m.AssertExpectations(t)
452 func TestRemoveAndPublishSuccessfully(t *testing.T) {
455 expectedChannel := "{namespace},channel"
456 expectedEvent := "event"
457 expectedKeys := []string{"{namespace},key1", "{namespace},key2"}
459 m.On("DelPub", expectedChannel, expectedEvent, expectedKeys).Return(nil)
460 err := i.RemoveAndPublish([]string{"channel", "event"}, []string{"key1", "key2"})
462 m.AssertExpectations(t)
464 func TestRemoveAndPublishFail(t *testing.T) {
467 expectedChannel := "{namespace},channel"
468 expectedEvent := "event"
469 expectedKeys := []string{"{namespace},key1", "{namespace},key2"}
471 m.On("DelPub", expectedChannel, expectedEvent, expectedKeys).Return(errors.New("Some error"))
472 err := i.RemoveAndPublish([]string{"channel", "event"}, []string{"key1", "key2"})
473 assert.NotNil(t, err)
474 m.AssertExpectations(t)
477 func TestRemoveAndPublishNoChannels(t *testing.T) {
480 expectedKeys := []string{"{namespace},key1", "{namespace},key2"}
482 m.On("Del", expectedKeys).Return(nil)
483 err := i.RemoveAndPublish([]string{}, []string{"key1", "key2"})
485 m.AssertExpectations(t)
488 func TestRemoveAndPublishIncorrectChannel(t *testing.T) {
491 notExpectedChannel := "{namespace},channel"
492 notExpectedEvent := "event"
493 notExpectedKeys := []string{"{namespace},key"}
495 m.AssertNotCalled(t, "DelPub", notExpectedChannel, notExpectedEvent, notExpectedKeys)
496 m.AssertNotCalled(t, "Del", notExpectedKeys)
497 err := i.RemoveAndPublish([]string{"channel", "event", "channel2"}, []string{})
499 m.AssertExpectations(t)
502 func TestRemoveAndPublishNoKeys(t *testing.T) {
505 notExpectedChannel := "{namespace},channel"
506 notExpectedEvent := "event"
507 notExpectedKeys := []string{"{namespace},key"}
509 m.AssertNotCalled(t, "DelPub", notExpectedChannel, notExpectedEvent, notExpectedKeys)
510 m.AssertNotCalled(t, "Del", notExpectedKeys)
511 err := i.RemoveAndPublish([]string{"channel", "event"}, []string{})
513 m.AssertExpectations(t)
515 func TestRemoveAndPublishNoChannelsError(t *testing.T) {
518 expectedKeys := []string{"{namespace},key1", "{namespace},key2"}
520 m.On("Del", expectedKeys).Return(errors.New("Some error"))
521 err := i.RemoveAndPublish([]string{}, []string{"key1", "key2"})
522 assert.NotNil(t, err)
523 m.AssertExpectations(t)
525 func TestRemoveSuccessfully(t *testing.T) {
528 msetExpected := []string{"{namespace},key1", "{namespace},key2"}
529 m.On("Del", msetExpected).Return(nil)
531 err := i.Remove([]string{"key1", "key2"})
533 m.AssertExpectations(t)
536 func TestRemoveFail(t *testing.T) {
539 msetExpected := []string{"{namespace},key"}
540 m.On("Del", msetExpected).Return(errors.New("Some error"))
542 err := i.Remove([]string{"key"})
543 assert.NotNil(t, err)
544 m.AssertExpectations(t)
547 func TestRemoveEmptyList(t *testing.T) {
550 err := i.Remove([]string{})
552 m.AssertNotCalled(t, "Del", []string{})
555 func TestGetAllSuccessfully(t *testing.T) {
558 mKeysExpected := string("{namespace},*")
559 mReturnExpected := []string{"{namespace},key1", "{namespace},key2"}
560 expectedReturn := []string{"key1", "key2"}
561 m.On("Keys", mKeysExpected).Return(mReturnExpected, nil)
562 retVal, err := i.GetAll()
564 assert.Equal(t, expectedReturn, retVal)
565 m.AssertExpectations(t)
568 func TestGetAllFail(t *testing.T) {
571 mKeysExpected := string("{namespace},*")
572 mReturnExpected := []string{}
573 m.On("Keys", mKeysExpected).Return(mReturnExpected, errors.New("some error"))
574 retVal, err := i.GetAll()
575 assert.NotNil(t, err)
576 assert.Nil(t, retVal)
577 assert.Equal(t, len(retVal), 0)
578 m.AssertExpectations(t)
581 func TestGetAllReturnEmpty(t *testing.T) {
584 mKeysExpected := string("{namespace},*")
585 var mReturnExpected []string = nil
586 m.On("Keys", mKeysExpected).Return(mReturnExpected, nil)
587 retVal, err := i.GetAll()
589 assert.Nil(t, retVal)
590 assert.Equal(t, len(retVal), 0)
591 m.AssertExpectations(t)
595 func TestRemoveAllSuccessfully(t *testing.T) {
598 mKeysExpected := string("{namespace},*")
599 mKeysReturn := []string{"{namespace},key1", "{namespace},key2"}
600 mDelExpected := mKeysReturn
601 m.On("Keys", mKeysExpected).Return(mKeysReturn, nil)
602 m.On("Del", mDelExpected).Return(nil)
605 m.AssertExpectations(t)
608 func TestRemoveAllNoKeysFound(t *testing.T) {
611 mKeysExpected := string("{namespace},*")
612 var mKeysReturn []string = nil
613 m.On("Keys", mKeysExpected).Return(mKeysReturn, nil)
614 m.AssertNumberOfCalls(t, "Del", 0)
617 m.AssertExpectations(t)
620 func TestRemoveAllKeysReturnError(t *testing.T) {
623 mKeysExpected := string("{namespace},*")
624 var mKeysReturn []string = nil
625 m.On("Keys", mKeysExpected).Return(mKeysReturn, errors.New("Some error"))
626 m.AssertNumberOfCalls(t, "Del", 0)
628 assert.NotNil(t, err)
629 m.AssertExpectations(t)
632 func TestRemoveAllDelReturnError(t *testing.T) {
635 mKeysExpected := string("{namespace},*")
636 mKeysReturn := []string{"{namespace},key1", "{namespace},key2"}
637 mDelExpected := mKeysReturn
638 m.On("Keys", mKeysExpected).Return(mKeysReturn, nil)
639 m.On("Del", mDelExpected).Return(errors.New("Some Error"))
641 assert.NotNil(t, err)
642 m.AssertExpectations(t)
645 func TestSetIfSuccessfullyOkStatus(t *testing.T) {
648 mSetIEExpectedKey := string("{namespace},key1")
649 mSetIEExpectedOldData := interface{}("olddata")
650 mSetIEExpectedNewData := interface{}("newdata")
651 m.On("SetIE", mSetIEExpectedKey, mSetIEExpectedOldData, mSetIEExpectedNewData).Return(true, nil)
652 status, err := i.SetIf("key1", "olddata", "newdata")
654 assert.True(t, status)
655 m.AssertExpectations(t)
658 func TestSetIfSuccessfullyNOKStatus(t *testing.T) {
661 mSetIEExpectedKey := string("{namespace},key1")
662 mSetIEExpectedOldData := interface{}("olddata")
663 mSetIEExpectedNewData := interface{}("newdata")
664 m.On("SetIE", mSetIEExpectedKey, mSetIEExpectedOldData, mSetIEExpectedNewData).Return(false, nil)
665 status, err := i.SetIf("key1", "olddata", "newdata")
667 assert.False(t, status)
668 m.AssertExpectations(t)
671 func TestSetIfFailure(t *testing.T) {
674 mSetIEExpectedKey := string("{namespace},key1")
675 mSetIEExpectedOldData := interface{}("olddata")
676 mSetIEExpectedNewData := interface{}("newdata")
677 m.On("SetIE", mSetIEExpectedKey, mSetIEExpectedOldData, mSetIEExpectedNewData).Return(false, errors.New("Some error"))
678 status, err := i.SetIf("key1", "olddata", "newdata")
679 assert.NotNil(t, err)
680 assert.False(t, status)
681 m.AssertExpectations(t)
684 func TestSetIfAndPublishSuccessfully(t *testing.T) {
687 expectedChannel := "{namespace},channel"
688 expectedEvent := "event"
689 expectedKey := "{namespace},key"
690 expectedOldData := interface{}("olddata")
691 expectedNewData := interface{}("newdata")
692 m.On("SetIEPub", expectedChannel, expectedEvent, expectedKey, expectedOldData, expectedNewData).Return(true, nil)
693 status, err := i.SetIfAndPublish([]string{"channel", "event"}, "key", "olddata", "newdata")
695 assert.True(t, status)
696 m.AssertExpectations(t)
699 func TestSetIfAndPublishIncorrectChannelAndEvent(t *testing.T) {
702 expectedChannel := "{namespace},channel"
703 expectedEvent := "event"
704 expectedKey := "{namespace},key"
705 expectedOldData := interface{}("olddata")
706 expectedNewData := interface{}("newdata")
707 m.AssertNotCalled(t, "SetIEPub", expectedChannel, expectedEvent, expectedKey, expectedOldData, expectedNewData)
708 m.AssertNotCalled(t, "SetIE", expectedKey, expectedOldData, expectedNewData)
709 status, err := i.SetIfAndPublish([]string{"channel", "event1", "channel"}, "key", "olddata", "newdata")
710 assert.NotNil(t, err)
711 assert.False(t, status)
712 m.AssertExpectations(t)
714 func TestSetIfAndPublishNOKStatus(t *testing.T) {
717 expectedChannel := "{namespace},channel"
718 expectedEvent := "event"
719 expectedKey := "{namespace},key"
720 expectedOldData := interface{}("olddata")
721 expectedNewData := interface{}("newdata")
722 m.On("SetIEPub", expectedChannel, expectedEvent, expectedKey, expectedOldData, expectedNewData).Return(false, nil)
723 status, err := i.SetIfAndPublish([]string{"channel", "event"}, "key", "olddata", "newdata")
725 assert.False(t, status)
726 m.AssertExpectations(t)
729 func TestSetIfAndPublishNoChannels(t *testing.T) {
732 expectedKey := "{namespace},key"
733 expectedOldData := interface{}("olddata")
734 expectedNewData := interface{}("newdata")
735 m.On("SetIE", expectedKey, expectedOldData, expectedNewData).Return(true, nil)
736 status, err := i.SetIfAndPublish([]string{}, "key", "olddata", "newdata")
738 assert.True(t, status)
739 m.AssertExpectations(t)
742 func TestSetIfNotExistsAndPublishSuccessfully(t *testing.T) {
745 expectedChannel := "{namespace},channel"
746 expectedEvent := "event"
747 expectedKey := "{namespace},key"
748 expectedData := interface{}("data")
750 m.On("SetNXPub", expectedChannel, expectedEvent, expectedKey, expectedData).Return(true, nil)
751 status, err := i.SetIfNotExistsAndPublish([]string{"channel", "event"}, "key", "data")
753 assert.True(t, status)
754 m.AssertExpectations(t)
757 func TestSetIfNotExistsAndPublishSeveralEvents(t *testing.T) {
760 expectedChannel := "{namespace},channel"
761 expectedEvent := "event1___event2"
762 expectedKey := "{namespace},key"
763 expectedData := interface{}("data")
765 m.On("SetNXPub", expectedChannel, expectedEvent, expectedKey, expectedData).Return(true, nil)
766 status, err := i.SetIfNotExistsAndPublish([]string{"channel", "event1", "channel", "event2"}, "key", "data")
768 assert.True(t, status)
769 m.AssertExpectations(t)
772 func TestSetIfNotExistsAndPublishNoChannels(t *testing.T) {
775 expectedKey := "{namespace},key"
776 expectedData := interface{}("data")
778 m.On("SetNX", expectedKey, expectedData).Return(true, nil)
779 status, err := i.SetIfNotExistsAndPublish([]string{}, "key", "data")
781 assert.True(t, status)
782 m.AssertExpectations(t)
785 func TestSetIfNotExistsAndPublishFail(t *testing.T) {
788 expectedChannel := "{namespace},channel"
789 expectedEvent := "event"
790 expectedKey := "{namespace},key"
791 expectedData := interface{}("data")
793 m.On("SetNXPub", expectedChannel, expectedEvent, expectedKey, expectedData).Return(false, nil)
794 status, err := i.SetIfNotExistsAndPublish([]string{"channel", "event"}, "key", "data")
796 assert.False(t, status)
797 m.AssertExpectations(t)
800 func TestSetIfNotExistsAndPublishIncorrectChannels(t *testing.T) {
803 expectedChannel := "{namespace},channel"
804 expectedEvent := "event"
805 expectedKey := "{namespace},key"
806 expectedData := interface{}("data")
808 m.AssertNotCalled(t, "SetNXPub", expectedChannel, expectedEvent, expectedKey, expectedData)
809 m.AssertNotCalled(t, "SetNX", expectedKey, expectedData)
810 status, err := i.SetIfNotExistsAndPublish([]string{"channel", "event", "channel2"}, "key", "data")
811 assert.NotNil(t, err)
812 assert.False(t, status)
813 m.AssertExpectations(t)
816 func TestSetIfNotExistsAndPublishError(t *testing.T) {
819 expectedChannel := "{namespace},channel"
820 expectedEvent := "event"
821 expectedKey := "{namespace},key"
822 expectedData := interface{}("data")
824 m.On("SetNXPub", expectedChannel, expectedEvent, expectedKey, expectedData).Return(false, errors.New("Some error"))
825 status, err := i.SetIfNotExistsAndPublish([]string{"channel", "event"}, "key", "data")
826 assert.NotNil(t, err)
827 assert.False(t, status)
828 m.AssertExpectations(t)
831 func TestSetIfNotExistsSuccessfullyOkStatus(t *testing.T) {
834 mSetNXExpectedKey := string("{namespace},key1")
835 mSetNXExpectedData := interface{}("data")
836 m.On("SetNX", mSetNXExpectedKey, mSetNXExpectedData).Return(true, nil)
837 status, err := i.SetIfNotExists("key1", "data")
839 assert.True(t, status)
840 m.AssertExpectations(t)
843 func TestSetIfNotExistsSuccessfullyNOKStatus(t *testing.T) {
846 mSetNXExpectedKey := string("{namespace},key1")
847 mSetNXExpectedData := interface{}("data")
848 m.On("SetNX", mSetNXExpectedKey, mSetNXExpectedData).Return(false, nil)
849 status, err := i.SetIfNotExists("key1", "data")
851 assert.False(t, status)
852 m.AssertExpectations(t)
855 func TestSetIfNotExistsFailure(t *testing.T) {
858 mSetNXExpectedKey := string("{namespace},key1")
859 mSetNXExpectedData := interface{}("data")
860 m.On("SetNX", mSetNXExpectedKey, mSetNXExpectedData).Return(false, errors.New("Some error"))
861 status, err := i.SetIfNotExists("key1", "data")
862 assert.NotNil(t, err)
863 assert.False(t, status)
864 m.AssertExpectations(t)
867 func TestRemoveIfAndPublishSuccessfully(t *testing.T) {
870 expectedChannel := "{namespace},channel"
871 expectedEvent := "event1___event2"
872 expectedKey := "{namespace},key"
873 expectedValue := interface{}("data")
875 m.On("DelIEPub", expectedChannel, expectedEvent, expectedKey, expectedValue).Return(true, nil)
876 status, err := i.RemoveIfAndPublish([]string{"channel", "event1", "channel", "event2"}, "key", "data")
878 assert.True(t, status)
879 m.AssertExpectations(t)
882 func TestRemoveIfAndPublishNok(t *testing.T) {
885 expectedChannel := "{namespace},channel"
886 expectedEvent := "event1___event2"
887 expectedKey := "{namespace},key"
888 expectedValue := interface{}("data")
890 m.On("DelIEPub", expectedChannel, expectedEvent, expectedKey, expectedValue).Return(false, nil)
891 status, err := i.RemoveIfAndPublish([]string{"channel", "event1", "channel", "event2"}, "key", "data")
893 assert.False(t, status)
894 m.AssertExpectations(t)
897 func TestRemoveIfAndPublishError(t *testing.T) {
900 expectedChannel := "{namespace},channel"
901 expectedEvent := "event1___event2"
902 expectedKey := "{namespace},key"
903 expectedValue := interface{}("data")
905 m.On("DelIEPub", expectedChannel, expectedEvent, expectedKey, expectedValue).Return(false, errors.New("Some error"))
906 status, err := i.RemoveIfAndPublish([]string{"channel", "event1", "channel", "event2"}, "key", "data")
907 assert.NotNil(t, err)
908 assert.False(t, status)
909 m.AssertExpectations(t)
912 func TestRemoveIfAndPublishIncorrectChannel(t *testing.T) {
915 expectedChannel := "{namespace},channel"
916 expectedEvent := "event"
917 expectedKey := "{namespace},key"
918 expectedValue := interface{}("data")
920 m.AssertNotCalled(t, "DelIEPub", expectedChannel, expectedEvent, expectedKey, expectedValue)
921 m.AssertNotCalled(t, "DelIE", expectedKey, expectedValue)
922 status, err := i.RemoveIfAndPublish([]string{"channel", "event1", "channel"}, "key", "data")
923 assert.NotNil(t, err)
924 assert.False(t, status)
925 m.AssertExpectations(t)
928 func TestRemoveIfAndPublishNoChannels(t *testing.T) {
931 expectedKey := "{namespace},key"
932 expectedValue := interface{}("data")
934 m.On("DelIE", expectedKey, expectedValue).Return(true, nil)
935 status, err := i.RemoveIfAndPublish([]string{}, "key", "data")
937 assert.True(t, status)
938 m.AssertExpectations(t)
941 func TestRemoveIfSuccessfullyOkStatus(t *testing.T) {
944 mDelIEExpectedKey := string("{namespace},key1")
945 mDelIEExpectedData := interface{}("data")
946 m.On("DelIE", mDelIEExpectedKey, mDelIEExpectedData).Return(true, nil)
947 status, err := i.RemoveIf("key1", "data")
949 assert.True(t, status)
950 m.AssertExpectations(t)
953 func TestRemoveIfSuccessfullyNOKStatus(t *testing.T) {
956 mDelIEExpectedKey := string("{namespace},key1")
957 mDelIEExpectedData := interface{}("data")
958 m.On("DelIE", mDelIEExpectedKey, mDelIEExpectedData).Return(false, nil)
959 status, err := i.RemoveIf("key1", "data")
961 assert.False(t, status)
962 m.AssertExpectations(t)
965 func TestRemoveIfFailure(t *testing.T) {
968 mDelIEExpectedKey := string("{namespace},key1")
969 mDelIEExpectedData := interface{}("data")
970 m.On("DelIE", mDelIEExpectedKey, mDelIEExpectedData).Return(true, errors.New("Some error"))
971 status, err := i.RemoveIf("key1", "data")
972 assert.NotNil(t, err)
973 assert.False(t, status)
974 m.AssertExpectations(t)
977 func TestRemoveAllAndPublishSuccessfully(t *testing.T) {
980 mKeysExpected := string("{namespace},*")
981 mKeysReturn := []string{"{namespace},key1", "{namespace},key2"}
982 mDelExpected := mKeysReturn
983 expectedChannel := "{namespace},channel"
984 expectedEvent := "event"
985 m.On("Keys", mKeysExpected).Return(mKeysReturn, nil)
986 m.On("DelPub", expectedChannel, expectedEvent, mDelExpected).Return(nil)
987 err := i.RemoveAllAndPublish([]string{"channel", "event"})
989 m.AssertExpectations(t)
992 func TestRemoveAllAndPublishKeysReturnError(t *testing.T) {
995 mKeysExpected := string("{namespace},*")
996 mKeysReturn := []string{"{namespace},key1", "{namespace},key2"}
997 mDelExpected := mKeysReturn
998 expectedChannel := "{namespace},channel"
999 expectedEvent := "event"
1000 m.On("Keys", mKeysExpected).Return(mKeysReturn, errors.New("Some error"))
1001 m.AssertNotCalled(t, "DelPub", expectedChannel, expectedEvent, mDelExpected)
1002 err := i.RemoveAllAndPublish([]string{"channel", "event"})
1003 assert.NotNil(t, err)
1004 m.AssertExpectations(t)
1007 func TestRemoveAllAndPublishKeysDelReturnsError(t *testing.T) {
1010 mKeysExpected := string("{namespace},*")
1011 mKeysReturn := []string{"{namespace},key1", "{namespace},key2"}
1012 mDelExpected := mKeysReturn
1013 expectedChannel := "{namespace},channel"
1014 expectedEvent := "event"
1015 m.On("Keys", mKeysExpected).Return(mKeysReturn, nil)
1016 m.On("DelPub", expectedChannel, expectedEvent, mDelExpected).Return(errors.New("Some error"))
1017 err := i.RemoveAllAndPublish([]string{"channel", "event"})
1018 assert.NotNil(t, err)
1019 m.AssertExpectations(t)
1022 func TestRemoveAllAndPublishKeysEventsWithIllegalCharacters(t *testing.T) {
1025 mKeysExpected := string("{namespace},*")
1026 mKeysReturn := []string{"{namespace},key1", "{namespace},key2"}
1027 mDelExpected := mKeysReturn
1028 expectedChannel := "{namespace},channel"
1029 expectedEvent := "event"
1030 m.On("Keys", mKeysExpected).Return(mKeysReturn, nil)
1031 m.AssertNotCalled(t, "DelPub", expectedChannel, expectedEvent, mDelExpected)
1032 err := i.RemoveAllAndPublish([]string{"channel", "event___anotherEvent"})
1033 assert.NotNil(t, err)
1034 m.AssertExpectations(t)
1038 func TestRemoveAllAndPublishNoChannels(t *testing.T) {
1041 mKeysExpected := string("{namespace},*")
1042 mKeysReturn := []string{"{namespace},key1", "{namespace},key2"}
1043 mDelExpected := mKeysReturn
1044 m.On("Keys", mKeysExpected).Return(mKeysReturn, nil)
1045 m.On("Del", mDelExpected).Return(nil)
1046 m.AssertNotCalled(t, "DelPub", "", "", mDelExpected)
1047 err := i.RemoveAllAndPublish([]string{})
1049 m.AssertExpectations(t)
1052 func TestRemoveAllAndPublishIncorrectChannel(t *testing.T) {
1055 mKeysExpected := string("{namespace},*")
1056 mKeysReturn := []string{"{namespace},key1", "{namespace},key2"}
1057 mDelExpected := mKeysReturn
1058 m.On("Keys", mKeysExpected).Return(mKeysReturn, nil)
1059 m.AssertNotCalled(t, "DelPub", "", "", mDelExpected)
1060 err := i.RemoveAllAndPublish([]string{"channel", "event", "channel2"})
1061 assert.NotNil(t, err)
1062 m.AssertExpectations(t)
1066 func TestAddMemberSuccessfully(t *testing.T) {
1069 groupExpected := string("{namespace},group")
1070 membersExpected := []interface{}{"member1", "member2"}
1072 m.On("SAdd", groupExpected, membersExpected).Return(nil)
1074 err := i.AddMember("group", "member1", "member2")
1076 m.AssertExpectations(t)
1079 func TestAddMemberFail(t *testing.T) {
1082 groupExpected := string("{namespace},group")
1083 membersExpected := []interface{}{"member1", "member2"}
1085 m.On("SAdd", groupExpected, membersExpected).Return(errors.New("Some error"))
1087 err := i.AddMember("group", "member1", "member2")
1088 assert.NotNil(t, err)
1089 m.AssertExpectations(t)
1091 func TestRemoveMemberSuccessfully(t *testing.T) {
1094 groupExpected := string("{namespace},group")
1095 membersExpected := []interface{}{"member1", "member2"}
1097 m.On("SRem", groupExpected, membersExpected).Return(nil)
1099 err := i.RemoveMember("group", "member1", "member2")
1101 m.AssertExpectations(t)
1104 func TestRemoveMemberFail(t *testing.T) {
1107 groupExpected := string("{namespace},group")
1108 membersExpected := []interface{}{"member1", "member2"}
1110 m.On("SRem", groupExpected, membersExpected).Return(errors.New("Some error"))
1112 err := i.RemoveMember("group", "member1", "member2")
1113 assert.NotNil(t, err)
1114 m.AssertExpectations(t)
1117 func TestRemoveGroupSuccessfully(t *testing.T) {
1120 groupExpected := []string{"{namespace},group"}
1122 m.On("Del", groupExpected).Return(nil)
1124 err := i.RemoveGroup("group")
1126 m.AssertExpectations(t)
1128 func TestRemoveGroupFail(t *testing.T) {
1131 groupExpected := []string{"{namespace},group"}
1133 m.On("Del", groupExpected).Return(errors.New("Some error"))
1135 err := i.RemoveGroup("group")
1136 assert.NotNil(t, err)
1137 m.AssertExpectations(t)
1140 func TestGetMembersSuccessfully(t *testing.T) {
1143 groupExpected := "{namespace},group"
1144 returnExpected := []string{"member1", "member2"}
1146 m.On("SMembers", groupExpected).Return(returnExpected, nil)
1148 result, err := i.GetMembers("group")
1150 assert.Equal(t, result, returnExpected)
1151 m.AssertExpectations(t)
1153 func TestGetMembersFail(t *testing.T) {
1156 groupExpected := "{namespace},group"
1157 returnExpected := []string{"member1", "member2"}
1159 m.On("SMembers", groupExpected).Return(returnExpected, errors.New("Some error"))
1161 result, err := i.GetMembers("group")
1162 assert.NotNil(t,err)
1163 assert.Equal(t, []string{}, result)
1164 m.AssertExpectations(t)
1167 func TestIsMemberSuccessfullyIsMember(t *testing.T) {
1170 groupExpected := "{namespace},group"
1171 memberExpected := "member"
1173 m.On("SIsMember", groupExpected, memberExpected).Return(true, nil)
1175 result, err := i.IsMember("group", "member")
1177 assert.True(t, result)
1178 m.AssertExpectations(t)
1180 func TestIsMemberSuccessfullyIsNotMember(t *testing.T) {
1183 groupExpected := "{namespace},group"
1184 memberExpected := "member"
1186 m.On("SIsMember", groupExpected, memberExpected).Return(false, nil)
1188 result, err := i.IsMember("group", "member")
1190 assert.False(t, result)
1191 m.AssertExpectations(t)
1193 func TestIsMemberFailure(t *testing.T) {
1196 groupExpected := "{namespace},group"
1197 memberExpected := "member"
1199 m.On("SIsMember", groupExpected, memberExpected).Return(true, errors.New("Some error"))
1201 result, err := i.IsMember("group", "member")
1202 assert.NotNil(t, err)
1203 assert.False(t, result)
1204 m.AssertExpectations(t)
1207 func TestGroupSizeSuccessfully(t *testing.T) {
1210 var expectedSize int64
1212 groupExpected := "{namespace},group"
1214 m.On("SCard", groupExpected).Return(expectedSize, nil)
1216 result, err := i.GroupSize("group")
1218 assert.Equal(t, expectedSize, result)
1219 m.AssertExpectations(t)
1221 func TestGroupSizeFail(t *testing.T) {
1224 var expectedSize int64
1226 groupExpected := "{namespace},group"
1228 m.On("SCard", groupExpected).Return(expectedSize, errors.New("Some error"))
1230 result, err := i.GroupSize("group")
1231 assert.NotNil(t, err)
1232 assert.Equal(t, int64(0), result)
1233 m.AssertExpectations(t)