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.
26 "gerrit.o-ran-sc.org/r/ric-plt/sdlgo"
27 "github.com/stretchr/testify/assert"
28 "github.com/stretchr/testify/mock"
35 func (m *mockDB) SubscribeChannelDB(cb func(string, ...string), 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{}, expiration time.Duration) (bool, error) {
89 a := m.Called(key, data, expiration)
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 (m *mockDB) PTTL(key string) (time.Duration, error) {
134 return a.Get(0).(time.Duration), a.Error(1)
137 func (m *mockDB) PExpireIE(key string, data interface{}, expiration time.Duration) error {
138 a := m.Called(key, data, expiration)
142 func setup() (*mockDB, *sdlgo.SdlInstance) {
144 i := sdlgo.NewSdlInstanceForTest("namespace", m)
148 func verifySliceInOrder(a, b []string) bool {
149 for i, v := range a {
152 for j, x := range b {
153 if j%2 == 0 && x == v && a[i+1] == b[j+1] {
167 func TestSubscribeChannel(t *testing.T) {
170 expectedCB := func(channel string, events ...string) {}
171 expectedChannels := []string{"{namespace},channel1", "{namespace},channel2"}
173 m.On("SubscribeChannelDB", mock.AnythingOfType("func(string, ...string)"), "{namespace},", "___", expectedChannels).Return()
174 i.SubscribeChannel(expectedCB, "channel1", "channel2")
175 m.AssertExpectations(t)
178 func TestUnsubscribeChannel(t *testing.T) {
181 expectedChannels := []string{"{namespace},channel1", "{namespace},channel2"}
183 m.On("UnsubscribeChannelDB", expectedChannels).Return()
184 i.UnsubscribeChannel("channel1", "channel2")
185 m.AssertExpectations(t)
187 func TestGetOneKey(t *testing.T) {
190 mgetExpected := []string{"{namespace},key"}
191 mReturn := []interface{}{"somevalue"}
192 mReturnExpected := make(map[string]interface{})
193 mReturnExpected["key"] = "somevalue"
195 m.On("MGet", mgetExpected).Return(mReturn, nil)
196 retVal, err := i.Get([]string{"key"})
198 assert.Equal(t, mReturnExpected, retVal)
199 m.AssertExpectations(t)
202 func TestGetSeveralKeys(t *testing.T) {
205 mgetExpected := []string{"{namespace},key1", "{namespace},key2", "{namespace},key3"}
206 mReturn := []interface{}{"somevalue1", 2, "someothervalue"}
207 mReturnExpected := make(map[string]interface{})
208 mReturnExpected["key1"] = "somevalue1"
209 mReturnExpected["key2"] = 2
210 mReturnExpected["key3"] = "someothervalue"
212 m.On("MGet", mgetExpected).Return(mReturn, nil)
213 retVal, err := i.Get([]string{"key1", "key2", "key3"})
215 assert.Equal(t, mReturnExpected, retVal)
216 m.AssertExpectations(t)
219 func TestGetSeveralKeysSomeFail(t *testing.T) {
222 mgetExpected := []string{"{namespace},key1", "{namespace},key2", "{namespace},key3"}
223 mReturn := []interface{}{"somevalue1", nil, "someothervalue"}
224 mReturnExpected := make(map[string]interface{})
225 mReturnExpected["key1"] = "somevalue1"
226 mReturnExpected["key2"] = nil
227 mReturnExpected["key3"] = "someothervalue"
229 m.On("MGet", mgetExpected).Return(mReturn, nil)
230 retVal, err := i.Get([]string{"key1", "key2", "key3"})
232 assert.Equal(t, mReturnExpected, retVal)
233 m.AssertExpectations(t)
236 func TestGetKeyReturnError(t *testing.T) {
239 mgetExpected := []string{"{namespace},key"}
240 mReturn := []interface{}{nil}
241 mReturnExpected := make(map[string]interface{})
243 m.On("MGet", mgetExpected).Return(mReturn, errors.New("Some error"))
244 retVal, err := i.Get([]string{"key"})
245 assert.NotNil(t, err)
246 assert.Equal(t, mReturnExpected, retVal)
247 m.AssertExpectations(t)
250 func TestGetEmptyList(t *testing.T) {
253 mgetExpected := []string{}
255 retval, err := i.Get([]string{})
257 assert.Len(t, retval, 0)
258 m.AssertNotCalled(t, "MGet", mgetExpected)
261 func TestWriteOneKey(t *testing.T) {
264 msetExpected := []interface{}{"{namespace},key1", "data1"}
266 m.On("MSet", msetExpected).Return(nil)
267 err := i.Set("key1", "data1")
269 m.AssertExpectations(t)
272 func TestWriteByteSliceAsValue(t *testing.T) {
275 msetExpected := []interface{}{"{namespace},key1", []byte{1, 2, 3, 4, 5}}
277 m.On("MSet", msetExpected).Return(nil)
278 err := i.Set("key1", []byte{1, 2, 3, 4, 5})
280 m.AssertExpectations(t)
283 func TestWriteByteSliceAsValueMixed(t *testing.T) {
286 msetExpected := []interface{}{"{namespace},key1", []byte{1, 2, 3, 4, 5}, "{namespace},key2", "value2"}
288 m.On("MSet", msetExpected).Return(nil)
289 err := i.Set("key1", []byte{1, 2, 3, 4, 5}, []string{"key2", "value2"})
291 m.AssertExpectations(t)
294 func TestWriteByteArrayAsValue(t *testing.T) {
297 msetExpected := []interface{}{"{namespace},key1", [5]byte{1, 2, 3, 4, 5}}
299 m.On("MSet", msetExpected).Return(nil)
300 err := i.Set("key1", [5]byte{1, 2, 3, 4, 5})
302 m.AssertExpectations(t)
305 func TestWriteMapAsInput(t *testing.T) {
308 setExpected := []interface{}{"{namespace},key1", "string123",
309 "{namespace},key22", 12,
310 "{namespace},key333", []byte{1, 2, 3, 4, 5}}
311 inputMap := map[string]interface{}{
314 "key333": []byte{1, 2, 3, 4, 5},
317 m.On("MSet", mock.MatchedBy(func(input []interface{}) bool {
318 for _, v := range input {
320 for _, x := range setExpected {
321 found = reflect.DeepEqual(x, v)
333 err := i.Set(inputMap)
335 m.AssertExpectations(t)
338 func TestWriteMixed(t *testing.T) {
341 msetExpected := []interface{}{"{namespace},key1", "data1", "{namespace},key2", "data2", "{namespace},key3", "data3"}
343 m.On("MSet", msetExpected).Return(nil)
344 err := i.Set("key1", "data1", []string{"key2", "data2"}, [2]string{"key3", "data3"})
346 m.AssertExpectations(t)
349 func TestWriteIncorrectMixed(t *testing.T) {
352 msetExpected := []interface{}{"{namespace},key1", "data1", "{namespace},key2", "data2", "{namespace},key3", "data3"}
354 m.AssertNotCalled(t, "MSet", msetExpected)
355 err := i.Set("key1", []string{"key2", "data2"}, [2]string{"key3", "data3"})
356 assert.NotNil(t, err)
357 m.AssertExpectations(t)
359 func TestWriteIncorrectPairs(t *testing.T) {
362 msetExpected := []interface{}{}
364 m.AssertNotCalled(t, "MSet", msetExpected)
366 assert.NotNil(t, err)
367 m.AssertExpectations(t)
369 func TestWriteSeveralKeysSlice(t *testing.T) {
372 msetExpected := []interface{}{"{namespace},key1", "data1", "{namespace},key2", 22}
374 m.On("MSet", msetExpected).Return(nil)
375 err := i.Set([]interface{}{"key1", "data1", "key2", 22})
377 m.AssertExpectations(t)
381 func TestWriteSeveralKeysIncorrectSlice(t *testing.T) {
384 msetExpected := []interface{}{"{namespace},key1", "data1", "{namespace},key2", 22}
386 m.AssertNotCalled(t, "MSet", msetExpected)
387 err := i.Set([]interface{}{"key1", "data1", "key2"})
388 assert.NotNil(t, err)
389 m.AssertExpectations(t)
393 func TestWriteSeveralKeysArray(t *testing.T) {
396 msetExpected := []interface{}{"{namespace},key1", "data1", "{namespace},key2", "data2"}
398 m.On("MSet", msetExpected).Return(nil)
399 err := i.Set([4]string{"key1", "data1", "key2", "data2"})
401 m.AssertExpectations(t)
404 func TestWriteSeveralKeysIncorrectArray(t *testing.T) {
407 msetExpected := []interface{}{}
409 m.AssertNotCalled(t, "MSet", msetExpected)
410 err := i.Set([3]string{"key1", "data1", "key2"})
411 assert.NotNil(t, err)
412 m.AssertExpectations(t)
415 func TestWriteFail(t *testing.T) {
418 msetExpected := []interface{}{"{namespace},key1", "data1"}
420 m.On("MSet", msetExpected).Return(errors.New("Some error"))
421 err := i.Set("key1", "data1")
422 assert.NotNil(t, err)
423 m.AssertExpectations(t)
426 func TestWriteEmptyList(t *testing.T) {
429 msetExpected := []interface{}{}
432 m.AssertNotCalled(t, "MSet", msetExpected)
435 func TestWriteAndPublishOneKeyOneChannel(t *testing.T) {
438 expectedChannelAndEvent := []string{"{namespace},channel", "event"}
439 expectedKeyVal := []interface{}{"{namespace},key1", "data1"}
441 m.On("MSetMPub", expectedChannelAndEvent, expectedKeyVal).Return(nil)
442 m.AssertNotCalled(t, "MSet", expectedKeyVal)
443 err := i.SetAndPublish([]string{"channel", "event"}, "key1", "data1")
445 m.AssertExpectations(t)
448 func TestWriteAndPublishSeveralChannelsAndEvents(t *testing.T) {
451 expectedChannelsAndEvents := []string{"{namespace},channel1", "event1___event2",
452 "{namespace},channel2", "event3___event4"}
453 expectedKeyVal := []interface{}{"{namespace},key", "data"}
455 verifyChannelAndEvent := func(input []string) bool {
456 return verifySliceInOrder(input, expectedChannelsAndEvents)
458 m.On("MSetMPub", mock.MatchedBy(verifyChannelAndEvent), expectedKeyVal).Return(nil)
459 m.AssertNotCalled(t, "MSet", expectedKeyVal)
460 err := i.SetAndPublish([]string{"channel1", "event1", "channel2", "event3", "channel1", "event2", "channel2", "event4"},
463 m.AssertExpectations(t)
466 func TestWriteAndPublishOneKeyOneChannelTwoEvents(t *testing.T) {
469 expectedChannelAndEvents := []string{"{namespace},channel", "event1___event2"}
470 expectedKeyVal := []interface{}{"{namespace},key1", "data1"}
472 m.On("MSetMPub", expectedChannelAndEvents, expectedKeyVal).Return(nil)
473 m.AssertNotCalled(t, "MSet", expectedKeyVal)
474 err := i.SetAndPublish([]string{"channel", "event1", "channel", "event2"}, "key1", "data1")
476 m.AssertExpectations(t)
479 func TestWriteAndPublishIncorrectChannelAndEvent(t *testing.T) {
482 expectedChannelAndEvent := []string{}
483 expectedKeyVal := []interface{}{"{namespace},key1", "data1"}
484 m.AssertNotCalled(t, "MSetMPub", expectedChannelAndEvent, expectedKeyVal)
485 m.AssertNotCalled(t, "MSet", expectedKeyVal)
486 err := i.SetAndPublish([]string{"channel", "event1", "channel"}, "key1", "data1")
487 assert.NotNil(t, err)
488 m.AssertExpectations(t)
491 func TestWriteAndPublishNotAllowedCharactersInEvents(t *testing.T) {
494 expectedChannelAndEvent := []string{}
495 expectedKeyVal := []interface{}{"{namespace},key1", "data1"}
496 m.AssertNotCalled(t, "MSetMPub", expectedChannelAndEvent, expectedKeyVal)
497 m.AssertNotCalled(t, "MSet", expectedKeyVal)
498 err := i.SetAndPublish([]string{"channel", "event1___event2"}, "key1", "data1")
499 assert.NotNil(t, err)
500 m.AssertExpectations(t)
503 func TestWriteAndPublishNoData(t *testing.T) {
506 expectedChannelAndEvent := []string{}
507 expectedKeyVal := []interface{}{"key"}
509 m.AssertNotCalled(t, "MSetMPub", expectedChannelAndEvent, expectedKeyVal)
510 m.AssertNotCalled(t, "MSet", expectedKeyVal)
511 err := i.SetAndPublish([]string{"channel", "event"}, []interface{}{"key"})
512 assert.NotNil(t, err)
513 m.AssertExpectations(t)
516 func TestWriteAndPublishNoChannelEvent(t *testing.T) {
519 expectedKeyVal := []interface{}{"{namespace},key1", "data1"}
521 m.On("MSet", expectedKeyVal).Return(nil)
522 m.AssertNotCalled(t, "MSetMPub", "", "", expectedKeyVal)
523 err := i.SetAndPublish([]string{}, "key1", "data1")
525 m.AssertExpectations(t)
529 func TestRemoveAndPublishSuccessfully(t *testing.T) {
532 expectedChannelAndEvent := []string{"{namespace},channel", "event"}
533 expectedKeys := []string{"{namespace},key1", "{namespace},key2"}
535 m.On("DelMPub", expectedChannelAndEvent, expectedKeys).Return(nil)
536 err := i.RemoveAndPublish([]string{"channel", "event"}, []string{"key1", "key2"})
538 m.AssertExpectations(t)
541 func TestRemoveAndPublishSeveralChannelsAndEventsSuccessfully(t *testing.T) {
544 expectedChannelAndEvent := []string{"{namespace},channel1", "event1___event2",
545 "{namespace},channel2", "event3___event4"}
546 expectedKeys := []string{"{namespace},key1", "{namespace},key2"}
548 verifyChannelAndEvent := func(input []string) bool {
549 return verifySliceInOrder(input, expectedChannelAndEvent)
551 m.On("DelMPub", mock.MatchedBy(verifyChannelAndEvent), expectedKeys).Return(nil)
552 err := i.RemoveAndPublish([]string{"channel1", "event1", "channel2", "event3",
553 "channel1", "event2", "channel2", "event4"},
554 []string{"key1", "key2"})
556 m.AssertExpectations(t)
558 func TestRemoveAndPublishFail(t *testing.T) {
561 expectedChannelAndEvent := []string{"{namespace},channel", "event"}
562 expectedKeys := []string{"{namespace},key1", "{namespace},key2"}
564 m.On("DelMPub", expectedChannelAndEvent, expectedKeys).Return(errors.New("Some error"))
565 err := i.RemoveAndPublish([]string{"channel", "event"}, []string{"key1", "key2"})
566 assert.NotNil(t, err)
567 m.AssertExpectations(t)
570 func TestRemoveAndPublishNoChannels(t *testing.T) {
573 expectedKeys := []string{"{namespace},key1", "{namespace},key2"}
575 m.On("Del", expectedKeys).Return(nil)
576 err := i.RemoveAndPublish([]string{}, []string{"key1", "key2"})
578 m.AssertExpectations(t)
581 func TestRemoveAndPublishIncorrectChannel(t *testing.T) {
584 notExpectedChannelAndEvent := []string{}
585 notExpectedKeys := []string{"{namespace},key"}
587 m.AssertNotCalled(t, "DelMPub", notExpectedChannelAndEvent, notExpectedKeys)
588 m.AssertNotCalled(t, "Del", notExpectedKeys)
589 err := i.RemoveAndPublish([]string{"channel", "event", "channel2"}, []string{})
591 m.AssertExpectations(t)
594 func TestRemoveAndPublishNoKeys(t *testing.T) {
597 notExpectedChannelAndEvent := []string{}
598 notExpectedKeys := []string{"{namespace},key"}
600 m.AssertNotCalled(t, "DelMPub", notExpectedChannelAndEvent, notExpectedKeys)
601 m.AssertNotCalled(t, "Del", notExpectedKeys)
602 err := i.RemoveAndPublish([]string{"channel", "event"}, []string{})
604 m.AssertExpectations(t)
606 func TestRemoveAndPublishNoChannelsError(t *testing.T) {
609 expectedKeys := []string{"{namespace},key1", "{namespace},key2"}
611 m.On("Del", expectedKeys).Return(errors.New("Some error"))
612 err := i.RemoveAndPublish([]string{}, []string{"key1", "key2"})
613 assert.NotNil(t, err)
614 m.AssertExpectations(t)
616 func TestRemoveSuccessfully(t *testing.T) {
619 msetExpected := []string{"{namespace},key1", "{namespace},key2"}
620 m.On("Del", msetExpected).Return(nil)
622 err := i.Remove([]string{"key1", "key2"})
624 m.AssertExpectations(t)
627 func TestRemoveFail(t *testing.T) {
630 msetExpected := []string{"{namespace},key"}
631 m.On("Del", msetExpected).Return(errors.New("Some error"))
633 err := i.Remove([]string{"key"})
634 assert.NotNil(t, err)
635 m.AssertExpectations(t)
638 func TestRemoveEmptyList(t *testing.T) {
641 err := i.Remove([]string{})
643 m.AssertNotCalled(t, "Del", []string{})
646 func TestGetAllSuccessfully(t *testing.T) {
649 mKeysExpected := string("{namespace},*")
650 mReturnExpected := []string{"{namespace},key1", "{namespace},key2"}
651 expectedReturn := []string{"key1", "key2"}
652 m.On("Keys", mKeysExpected).Return(mReturnExpected, nil)
653 retVal, err := i.GetAll()
655 assert.Equal(t, expectedReturn, retVal)
656 m.AssertExpectations(t)
659 func TestGetAllFail(t *testing.T) {
662 mKeysExpected := string("{namespace},*")
663 mReturnExpected := []string{}
664 m.On("Keys", mKeysExpected).Return(mReturnExpected, errors.New("some error"))
665 retVal, err := i.GetAll()
666 assert.NotNil(t, err)
667 assert.Nil(t, retVal)
668 assert.Equal(t, len(retVal), 0)
669 m.AssertExpectations(t)
672 func TestGetAllReturnEmpty(t *testing.T) {
675 mKeysExpected := string("{namespace},*")
676 var mReturnExpected []string = nil
677 m.On("Keys", mKeysExpected).Return(mReturnExpected, nil)
678 retVal, err := i.GetAll()
680 assert.Nil(t, retVal)
681 assert.Equal(t, len(retVal), 0)
682 m.AssertExpectations(t)
686 func TestRemoveAllSuccessfully(t *testing.T) {
689 mKeysExpected := string("{namespace},*")
690 mKeysReturn := []string{"{namespace},key1", "{namespace},key2"}
691 mDelExpected := mKeysReturn
692 m.On("Keys", mKeysExpected).Return(mKeysReturn, nil)
693 m.On("Del", mDelExpected).Return(nil)
696 m.AssertExpectations(t)
699 func TestRemoveAllNoKeysFound(t *testing.T) {
702 mKeysExpected := string("{namespace},*")
703 var mKeysReturn []string = nil
704 m.On("Keys", mKeysExpected).Return(mKeysReturn, nil)
705 m.AssertNumberOfCalls(t, "Del", 0)
708 m.AssertExpectations(t)
711 func TestRemoveAllKeysReturnError(t *testing.T) {
714 mKeysExpected := string("{namespace},*")
715 var mKeysReturn []string = nil
716 m.On("Keys", mKeysExpected).Return(mKeysReturn, errors.New("Some error"))
717 m.AssertNumberOfCalls(t, "Del", 0)
719 assert.NotNil(t, err)
720 m.AssertExpectations(t)
723 func TestRemoveAllDelReturnError(t *testing.T) {
726 mKeysExpected := string("{namespace},*")
727 mKeysReturn := []string{"{namespace},key1", "{namespace},key2"}
728 mDelExpected := mKeysReturn
729 m.On("Keys", mKeysExpected).Return(mKeysReturn, nil)
730 m.On("Del", mDelExpected).Return(errors.New("Some Error"))
732 assert.NotNil(t, err)
733 m.AssertExpectations(t)
736 func TestSetIfSuccessfullyOkStatus(t *testing.T) {
739 mSetIEExpectedKey := string("{namespace},key1")
740 mSetIEExpectedOldData := interface{}("olddata")
741 mSetIEExpectedNewData := interface{}("newdata")
742 m.On("SetIE", mSetIEExpectedKey, mSetIEExpectedOldData, mSetIEExpectedNewData).Return(true, nil)
743 status, err := i.SetIf("key1", "olddata", "newdata")
745 assert.True(t, status)
746 m.AssertExpectations(t)
749 func TestSetIfSuccessfullyNOKStatus(t *testing.T) {
752 mSetIEExpectedKey := string("{namespace},key1")
753 mSetIEExpectedOldData := interface{}("olddata")
754 mSetIEExpectedNewData := interface{}("newdata")
755 m.On("SetIE", mSetIEExpectedKey, mSetIEExpectedOldData, mSetIEExpectedNewData).Return(false, nil)
756 status, err := i.SetIf("key1", "olddata", "newdata")
758 assert.False(t, status)
759 m.AssertExpectations(t)
762 func TestSetIfFailure(t *testing.T) {
765 mSetIEExpectedKey := string("{namespace},key1")
766 mSetIEExpectedOldData := interface{}("olddata")
767 mSetIEExpectedNewData := interface{}("newdata")
768 m.On("SetIE", mSetIEExpectedKey, mSetIEExpectedOldData, mSetIEExpectedNewData).Return(false, errors.New("Some error"))
769 status, err := i.SetIf("key1", "olddata", "newdata")
770 assert.NotNil(t, err)
771 assert.False(t, status)
772 m.AssertExpectations(t)
775 func TestSetIfAndPublishSuccessfully(t *testing.T) {
778 expectedChannel := "{namespace},channel"
779 expectedEvent := "event"
780 expectedKey := "{namespace},key"
781 expectedOldData := interface{}("olddata")
782 expectedNewData := interface{}("newdata")
783 m.On("SetIEPub", expectedChannel, expectedEvent, expectedKey, expectedOldData, expectedNewData).Return(true, nil)
784 status, err := i.SetIfAndPublish([]string{"channel", "event"}, "key", "olddata", "newdata")
786 assert.True(t, status)
787 m.AssertExpectations(t)
790 func TestSetIfAndPublishIncorrectChannelAndEvent(t *testing.T) {
793 expectedChannel := "{namespace},channel"
794 expectedEvent := "event"
795 expectedKey := "{namespace},key"
796 expectedOldData := interface{}("olddata")
797 expectedNewData := interface{}("newdata")
798 m.AssertNotCalled(t, "SetIEPub", expectedChannel, expectedEvent, expectedKey, expectedOldData, expectedNewData)
799 m.AssertNotCalled(t, "SetIE", expectedKey, expectedOldData, expectedNewData)
800 status, err := i.SetIfAndPublish([]string{"channel", "event1", "channel"}, "key", "olddata", "newdata")
801 assert.NotNil(t, err)
802 assert.False(t, status)
803 m.AssertExpectations(t)
805 func TestSetIfAndPublishNOKStatus(t *testing.T) {
808 expectedChannel := "{namespace},channel"
809 expectedEvent := "event"
810 expectedKey := "{namespace},key"
811 expectedOldData := interface{}("olddata")
812 expectedNewData := interface{}("newdata")
813 m.On("SetIEPub", expectedChannel, expectedEvent, expectedKey, expectedOldData, expectedNewData).Return(false, nil)
814 status, err := i.SetIfAndPublish([]string{"channel", "event"}, "key", "olddata", "newdata")
816 assert.False(t, status)
817 m.AssertExpectations(t)
820 func TestSetIfAndPublishNoChannels(t *testing.T) {
823 expectedKey := "{namespace},key"
824 expectedOldData := interface{}("olddata")
825 expectedNewData := interface{}("newdata")
826 m.On("SetIE", expectedKey, expectedOldData, expectedNewData).Return(true, nil)
827 status, err := i.SetIfAndPublish([]string{}, "key", "olddata", "newdata")
829 assert.True(t, status)
830 m.AssertExpectations(t)
833 func TestSetIfNotExistsAndPublishSuccessfully(t *testing.T) {
836 expectedChannel := "{namespace},channel"
837 expectedEvent := "event"
838 expectedKey := "{namespace},key"
839 expectedData := interface{}("data")
841 m.On("SetNXPub", expectedChannel, expectedEvent, expectedKey, expectedData).Return(true, nil)
842 status, err := i.SetIfNotExistsAndPublish([]string{"channel", "event"}, "key", "data")
844 assert.True(t, status)
845 m.AssertExpectations(t)
848 func TestSetIfNotExistsAndPublishSeveralEvents(t *testing.T) {
851 expectedChannel := "{namespace},channel"
852 expectedEvent := "event1___event2"
853 expectedKey := "{namespace},key"
854 expectedData := interface{}("data")
856 m.On("SetNXPub", expectedChannel, expectedEvent, expectedKey, expectedData).Return(true, nil)
857 status, err := i.SetIfNotExistsAndPublish([]string{"channel", "event1", "channel", "event2"}, "key", "data")
859 assert.True(t, status)
860 m.AssertExpectations(t)
863 func TestSetIfNotExistsAndPublishNoChannels(t *testing.T) {
866 expectedKey := "{namespace},key"
867 expectedData := interface{}("data")
869 m.On("SetNX", expectedKey, expectedData, time.Duration(0)).Return(true, nil)
870 status, err := i.SetIfNotExistsAndPublish([]string{}, "key", "data")
872 assert.True(t, status)
873 m.AssertExpectations(t)
876 func TestSetIfNotExistsAndPublishFail(t *testing.T) {
879 expectedChannel := "{namespace},channel"
880 expectedEvent := "event"
881 expectedKey := "{namespace},key"
882 expectedData := interface{}("data")
884 m.On("SetNXPub", expectedChannel, expectedEvent, expectedKey, expectedData).Return(false, nil)
885 status, err := i.SetIfNotExistsAndPublish([]string{"channel", "event"}, "key", "data")
887 assert.False(t, status)
888 m.AssertExpectations(t)
891 func TestSetIfNotExistsAndPublishIncorrectChannels(t *testing.T) {
894 expectedChannel := "{namespace},channel"
895 expectedEvent := "event"
896 expectedKey := "{namespace},key"
897 expectedData := interface{}("data")
899 m.AssertNotCalled(t, "SetNXPub", expectedChannel, expectedEvent, expectedKey, expectedData)
900 m.AssertNotCalled(t, "SetNX", expectedKey, expectedData, 0)
901 status, err := i.SetIfNotExistsAndPublish([]string{"channel", "event", "channel2"}, "key", "data")
902 assert.NotNil(t, err)
903 assert.False(t, status)
904 m.AssertExpectations(t)
907 func TestSetIfNotExistsAndPublishError(t *testing.T) {
910 expectedChannel := "{namespace},channel"
911 expectedEvent := "event"
912 expectedKey := "{namespace},key"
913 expectedData := interface{}("data")
915 m.On("SetNXPub", expectedChannel, expectedEvent, expectedKey, expectedData).Return(false, errors.New("Some error"))
916 status, err := i.SetIfNotExistsAndPublish([]string{"channel", "event"}, "key", "data")
917 assert.NotNil(t, err)
918 assert.False(t, status)
919 m.AssertExpectations(t)
922 func TestSetIfNotExistsSuccessfullyOkStatus(t *testing.T) {
925 mSetNXExpectedKey := string("{namespace},key1")
926 mSetNXExpectedData := interface{}("data")
927 m.On("SetNX", mSetNXExpectedKey, mSetNXExpectedData, time.Duration(0)).Return(true, nil)
928 status, err := i.SetIfNotExists("key1", "data")
930 assert.True(t, status)
931 m.AssertExpectations(t)
934 func TestSetIfNotExistsSuccessfullyNOKStatus(t *testing.T) {
937 mSetNXExpectedKey := string("{namespace},key1")
938 mSetNXExpectedData := interface{}("data")
939 m.On("SetNX", mSetNXExpectedKey, mSetNXExpectedData, time.Duration(0)).Return(false, nil)
940 status, err := i.SetIfNotExists("key1", "data")
942 assert.False(t, status)
943 m.AssertExpectations(t)
946 func TestSetIfNotExistsFailure(t *testing.T) {
949 mSetNXExpectedKey := string("{namespace},key1")
950 mSetNXExpectedData := interface{}("data")
951 m.On("SetNX", mSetNXExpectedKey, mSetNXExpectedData, time.Duration(0)).Return(false, errors.New("Some error"))
952 status, err := i.SetIfNotExists("key1", "data")
953 assert.NotNil(t, err)
954 assert.False(t, status)
955 m.AssertExpectations(t)
958 func TestRemoveIfAndPublishSuccessfully(t *testing.T) {
961 expectedChannel := "{namespace},channel"
962 expectedEvent := "event1___event2"
963 expectedKey := "{namespace},key"
964 expectedValue := interface{}("data")
966 m.On("DelIEPub", expectedChannel, expectedEvent, expectedKey, expectedValue).Return(true, nil)
967 status, err := i.RemoveIfAndPublish([]string{"channel", "event1", "channel", "event2"}, "key", "data")
969 assert.True(t, status)
970 m.AssertExpectations(t)
973 func TestRemoveIfAndPublishNok(t *testing.T) {
976 expectedChannel := "{namespace},channel"
977 expectedEvent := "event1___event2"
978 expectedKey := "{namespace},key"
979 expectedValue := interface{}("data")
981 m.On("DelIEPub", expectedChannel, expectedEvent, expectedKey, expectedValue).Return(false, nil)
982 status, err := i.RemoveIfAndPublish([]string{"channel", "event1", "channel", "event2"}, "key", "data")
984 assert.False(t, status)
985 m.AssertExpectations(t)
988 func TestRemoveIfAndPublishError(t *testing.T) {
991 expectedChannel := "{namespace},channel"
992 expectedEvent := "event1___event2"
993 expectedKey := "{namespace},key"
994 expectedValue := interface{}("data")
996 m.On("DelIEPub", expectedChannel, expectedEvent, expectedKey, expectedValue).Return(false, errors.New("Some error"))
997 status, err := i.RemoveIfAndPublish([]string{"channel", "event1", "channel", "event2"}, "key", "data")
998 assert.NotNil(t, err)
999 assert.False(t, status)
1000 m.AssertExpectations(t)
1003 func TestRemoveIfAndPublishIncorrectChannel(t *testing.T) {
1006 expectedChannel := "{namespace},channel"
1007 expectedEvent := "event"
1008 expectedKey := "{namespace},key"
1009 expectedValue := interface{}("data")
1011 m.AssertNotCalled(t, "DelIEPub", expectedChannel, expectedEvent, expectedKey, expectedValue)
1012 m.AssertNotCalled(t, "DelIE", expectedKey, expectedValue)
1013 status, err := i.RemoveIfAndPublish([]string{"channel", "event1", "channel"}, "key", "data")
1014 assert.NotNil(t, err)
1015 assert.False(t, status)
1016 m.AssertExpectations(t)
1019 func TestRemoveIfAndPublishNoChannels(t *testing.T) {
1022 expectedKey := "{namespace},key"
1023 expectedValue := interface{}("data")
1025 m.On("DelIE", expectedKey, expectedValue).Return(true, nil)
1026 status, err := i.RemoveIfAndPublish([]string{}, "key", "data")
1028 assert.True(t, status)
1029 m.AssertExpectations(t)
1032 func TestRemoveIfSuccessfullyOkStatus(t *testing.T) {
1035 mDelIEExpectedKey := string("{namespace},key1")
1036 mDelIEExpectedData := interface{}("data")
1037 m.On("DelIE", mDelIEExpectedKey, mDelIEExpectedData).Return(true, nil)
1038 status, err := i.RemoveIf("key1", "data")
1040 assert.True(t, status)
1041 m.AssertExpectations(t)
1044 func TestRemoveIfSuccessfullyNOKStatus(t *testing.T) {
1047 mDelIEExpectedKey := string("{namespace},key1")
1048 mDelIEExpectedData := interface{}("data")
1049 m.On("DelIE", mDelIEExpectedKey, mDelIEExpectedData).Return(false, nil)
1050 status, err := i.RemoveIf("key1", "data")
1052 assert.False(t, status)
1053 m.AssertExpectations(t)
1056 func TestRemoveIfFailure(t *testing.T) {
1059 mDelIEExpectedKey := string("{namespace},key1")
1060 mDelIEExpectedData := interface{}("data")
1061 m.On("DelIE", mDelIEExpectedKey, mDelIEExpectedData).Return(true, errors.New("Some error"))
1062 status, err := i.RemoveIf("key1", "data")
1063 assert.NotNil(t, err)
1064 assert.False(t, status)
1065 m.AssertExpectations(t)
1068 func TestRemoveAllAndPublishSuccessfully(t *testing.T) {
1071 mKeysExpected := string("{namespace},*")
1072 mKeysReturn := []string{"{namespace},key1", "{namespace},key2"}
1073 mDelExpected := mKeysReturn
1074 expectedChannelAndEvent := []string{"{namespace},channel", "event"}
1075 m.On("Keys", mKeysExpected).Return(mKeysReturn, nil)
1076 m.On("DelMPub", expectedChannelAndEvent, mDelExpected).Return(nil)
1077 err := i.RemoveAllAndPublish([]string{"channel", "event"})
1079 m.AssertExpectations(t)
1082 func TestRemoveAllAndPublishKeysReturnError(t *testing.T) {
1085 mKeysExpected := string("{namespace},*")
1086 mKeysReturn := []string{"{namespace},key1", "{namespace},key2"}
1087 mDelExpected := mKeysReturn
1088 expectedChannelAndEvent := []string{"{namespace},channel", "event"}
1089 m.On("Keys", mKeysExpected).Return(mKeysReturn, errors.New("Some error"))
1090 m.AssertNotCalled(t, "DelMPub", expectedChannelAndEvent, mDelExpected)
1091 err := i.RemoveAllAndPublish([]string{"channel", "event"})
1092 assert.NotNil(t, err)
1093 m.AssertExpectations(t)
1096 func TestRemoveAllAndPublishKeysDelReturnsError(t *testing.T) {
1099 mKeysExpected := string("{namespace},*")
1100 mKeysReturn := []string{"{namespace},key1", "{namespace},key2"}
1101 mDelExpected := mKeysReturn
1102 expectedChannelAndEvent := []string{"{namespace},channel", "event"}
1103 m.On("Keys", mKeysExpected).Return(mKeysReturn, nil)
1104 m.On("DelMPub", expectedChannelAndEvent, mDelExpected).Return(errors.New("Some error"))
1105 err := i.RemoveAllAndPublish([]string{"channel", "event"})
1106 assert.NotNil(t, err)
1107 m.AssertExpectations(t)
1110 func TestRemoveAllAndPublishKeysEventsWithIllegalCharacters(t *testing.T) {
1113 mKeysExpected := string("{namespace},*")
1114 mKeysReturn := []string{"{namespace},key1", "{namespace},key2"}
1115 mDelExpected := mKeysReturn
1116 expectedChannelAndEvent := []string{"{namespace},channel", "event"}
1117 m.On("Keys", mKeysExpected).Return(mKeysReturn, nil)
1118 m.AssertNotCalled(t, "DelMPub", expectedChannelAndEvent, mDelExpected)
1119 err := i.RemoveAllAndPublish([]string{"channel", "event___anotherEvent"})
1120 assert.NotNil(t, err)
1121 m.AssertExpectations(t)
1125 func TestRemoveAllAndPublishNoChannels(t *testing.T) {
1128 mKeysExpected := string("{namespace},*")
1129 mKeysReturn := []string{"{namespace},key1", "{namespace},key2"}
1130 mDelExpected := mKeysReturn
1131 m.On("Keys", mKeysExpected).Return(mKeysReturn, nil)
1132 m.On("Del", mDelExpected).Return(nil)
1133 m.AssertNotCalled(t, "DelMPub", "", "", mDelExpected)
1134 err := i.RemoveAllAndPublish([]string{})
1136 m.AssertExpectations(t)
1139 func TestRemoveAllAndPublishIncorrectChannel(t *testing.T) {
1142 mKeysExpected := string("{namespace},*")
1143 mKeysReturn := []string{"{namespace},key1", "{namespace},key2"}
1144 mDelExpected := mKeysReturn
1145 m.On("Keys", mKeysExpected).Return(mKeysReturn, nil)
1146 m.AssertNotCalled(t, "DelMPub", "", "", mDelExpected)
1147 err := i.RemoveAllAndPublish([]string{"channel", "event", "channel2"})
1148 assert.NotNil(t, err)
1149 m.AssertExpectations(t)
1153 func TestAddMemberSuccessfully(t *testing.T) {
1156 groupExpected := string("{namespace},group")
1157 membersExpected := []interface{}{"member1", "member2"}
1159 m.On("SAdd", groupExpected, membersExpected).Return(nil)
1161 err := i.AddMember("group", "member1", "member2")
1163 m.AssertExpectations(t)
1166 func TestAddMemberFail(t *testing.T) {
1169 groupExpected := string("{namespace},group")
1170 membersExpected := []interface{}{"member1", "member2"}
1172 m.On("SAdd", groupExpected, membersExpected).Return(errors.New("Some error"))
1174 err := i.AddMember("group", "member1", "member2")
1175 assert.NotNil(t, err)
1176 m.AssertExpectations(t)
1178 func TestRemoveMemberSuccessfully(t *testing.T) {
1181 groupExpected := string("{namespace},group")
1182 membersExpected := []interface{}{"member1", "member2"}
1184 m.On("SRem", groupExpected, membersExpected).Return(nil)
1186 err := i.RemoveMember("group", "member1", "member2")
1188 m.AssertExpectations(t)
1191 func TestRemoveMemberFail(t *testing.T) {
1194 groupExpected := string("{namespace},group")
1195 membersExpected := []interface{}{"member1", "member2"}
1197 m.On("SRem", groupExpected, membersExpected).Return(errors.New("Some error"))
1199 err := i.RemoveMember("group", "member1", "member2")
1200 assert.NotNil(t, err)
1201 m.AssertExpectations(t)
1204 func TestRemoveGroupSuccessfully(t *testing.T) {
1207 groupExpected := []string{"{namespace},group"}
1209 m.On("Del", groupExpected).Return(nil)
1211 err := i.RemoveGroup("group")
1213 m.AssertExpectations(t)
1215 func TestRemoveGroupFail(t *testing.T) {
1218 groupExpected := []string{"{namespace},group"}
1220 m.On("Del", groupExpected).Return(errors.New("Some error"))
1222 err := i.RemoveGroup("group")
1223 assert.NotNil(t, err)
1224 m.AssertExpectations(t)
1227 func TestGetMembersSuccessfully(t *testing.T) {
1230 groupExpected := "{namespace},group"
1231 returnExpected := []string{"member1", "member2"}
1233 m.On("SMembers", groupExpected).Return(returnExpected, nil)
1235 result, err := i.GetMembers("group")
1237 assert.Equal(t, result, returnExpected)
1238 m.AssertExpectations(t)
1240 func TestGetMembersFail(t *testing.T) {
1243 groupExpected := "{namespace},group"
1244 returnExpected := []string{"member1", "member2"}
1246 m.On("SMembers", groupExpected).Return(returnExpected, errors.New("Some error"))
1248 result, err := i.GetMembers("group")
1249 assert.NotNil(t, err)
1250 assert.Equal(t, []string{}, result)
1251 m.AssertExpectations(t)
1254 func TestIsMemberSuccessfullyIsMember(t *testing.T) {
1257 groupExpected := "{namespace},group"
1258 memberExpected := "member"
1260 m.On("SIsMember", groupExpected, memberExpected).Return(true, nil)
1262 result, err := i.IsMember("group", "member")
1264 assert.True(t, result)
1265 m.AssertExpectations(t)
1267 func TestIsMemberSuccessfullyIsNotMember(t *testing.T) {
1270 groupExpected := "{namespace},group"
1271 memberExpected := "member"
1273 m.On("SIsMember", groupExpected, memberExpected).Return(false, nil)
1275 result, err := i.IsMember("group", "member")
1277 assert.False(t, result)
1278 m.AssertExpectations(t)
1280 func TestIsMemberFailure(t *testing.T) {
1283 groupExpected := "{namespace},group"
1284 memberExpected := "member"
1286 m.On("SIsMember", groupExpected, memberExpected).Return(true, errors.New("Some error"))
1288 result, err := i.IsMember("group", "member")
1289 assert.NotNil(t, err)
1290 assert.False(t, result)
1291 m.AssertExpectations(t)
1294 func TestGroupSizeSuccessfully(t *testing.T) {
1297 var expectedSize int64
1299 groupExpected := "{namespace},group"
1301 m.On("SCard", groupExpected).Return(expectedSize, nil)
1303 result, err := i.GroupSize("group")
1305 assert.Equal(t, expectedSize, result)
1306 m.AssertExpectations(t)
1308 func TestGroupSizeFail(t *testing.T) {
1311 var expectedSize int64
1313 groupExpected := "{namespace},group"
1315 m.On("SCard", groupExpected).Return(expectedSize, errors.New("Some error"))
1317 result, err := i.GroupSize("group")
1318 assert.NotNil(t, err)
1319 assert.Equal(t, int64(0), result)
1320 m.AssertExpectations(t)
1323 func TestLockResourceSuccessfully(t *testing.T) {
1326 resourceExpected := "{namespace},resource"
1327 m.On("SetNX", resourceExpected, mock.Anything, time.Duration(1)).Return(true, nil)
1329 lock, err := i.LockResource("resource", time.Duration(1), &sdlgo.Options{})
1331 assert.NotNil(t, lock)
1332 m.AssertExpectations(t)
1335 func TestLockResourceFailure(t *testing.T) {
1338 resourceExpected := "{namespace},resource"
1339 m.On("SetNX", resourceExpected, mock.Anything, time.Duration(1)).Return(true, errors.New("Some error"))
1341 lock, err := i.LockResource("resource", time.Duration(1), &sdlgo.Options{})
1342 assert.NotNil(t, err)
1344 m.AssertExpectations(t)
1347 func TestLockResourceTrySeveralTimesSuccessfully(t *testing.T) {
1350 resourceExpected := "{namespace},resource"
1351 m.On("SetNX", resourceExpected, mock.Anything, time.Duration(1)).Return(false, nil).Once()
1352 m.On("SetNX", resourceExpected, mock.Anything, time.Duration(1)).Return(true, nil).Once()
1354 lock, err := i.LockResource("resource", time.Duration(1), &sdlgo.Options{
1358 assert.NotNil(t, lock)
1359 m.AssertExpectations(t)
1362 func TestLockResourceTrySeveralTimesFailure(t *testing.T) {
1365 resourceExpected := "{namespace},resource"
1366 m.On("SetNX", resourceExpected, mock.Anything, time.Duration(1)).Return(false, nil).Once()
1367 m.On("SetNX", resourceExpected, mock.Anything, time.Duration(1)).Return(true, errors.New("Some error")).Once()
1369 lock, err := i.LockResource("resource", time.Duration(1), &sdlgo.Options{
1372 assert.NotNil(t, err)
1374 m.AssertExpectations(t)
1377 func TestLockResourceTrySeveralTimesUnableToGetResource(t *testing.T) {
1380 resourceExpected := "{namespace},resource"
1381 m.On("SetNX", resourceExpected, mock.Anything, time.Duration(1)).Return(false, nil).Once()
1382 m.On("SetNX", resourceExpected, mock.Anything, time.Duration(1)).Return(false, nil).Once()
1384 lock, err := i.LockResource("resource", time.Duration(1), &sdlgo.Options{
1387 assert.NotNil(t, err)
1388 assert.EqualError(t, err, "Lock not obtained")
1390 m.AssertExpectations(t)
1393 func TestReleaseResourceSuccessfully(t *testing.T) {
1396 resourceExpected := "{namespace},resource"
1397 m.On("SetNX", resourceExpected, mock.Anything, time.Duration(1)).Return(true, nil).Once()
1398 m.On("DelIE", resourceExpected, mock.Anything).Return(true, nil).Once()
1400 lock, err := i.LockResource("resource", time.Duration(1), &sdlgo.Options{
1403 err2 := lock.ReleaseResource()
1405 assert.NotNil(t, lock)
1407 m.AssertExpectations(t)
1410 func TestReleaseResourceFailure(t *testing.T) {
1413 resourceExpected := "{namespace},resource"
1414 m.On("SetNX", resourceExpected, mock.Anything, time.Duration(1)).Return(true, nil).Once()
1415 m.On("DelIE", resourceExpected, mock.Anything).Return(true, errors.New("Some error")).Once()
1417 lock, err := i.LockResource("resource", time.Duration(1), &sdlgo.Options{
1420 err2 := lock.ReleaseResource()
1422 assert.NotNil(t, lock)
1423 assert.NotNil(t, err2)
1424 m.AssertExpectations(t)
1427 func TestReleaseResourceLockNotHeld(t *testing.T) {
1430 resourceExpected := "{namespace},resource"
1431 m.On("SetNX", resourceExpected, mock.Anything, time.Duration(1)).Return(true, nil).Once()
1432 m.On("DelIE", resourceExpected, mock.Anything).Return(false, nil).Once()
1434 lock, err := i.LockResource("resource", time.Duration(1), &sdlgo.Options{
1437 err2 := lock.ReleaseResource()
1439 assert.NotNil(t, lock)
1440 assert.NotNil(t, err2)
1441 assert.EqualError(t, err2, "Lock not held")
1442 m.AssertExpectations(t)
1445 func TestRefreshResourceSuccessfully(t *testing.T) {
1448 resourceExpected := "{namespace},resource"
1449 m.On("SetNX", resourceExpected, mock.Anything, time.Duration(1)).Return(true, nil).Once()
1450 m.On("PExpireIE", resourceExpected, mock.Anything, time.Duration(1)).Return(nil).Once()
1452 lock, err := i.LockResource("resource", time.Duration(1), &sdlgo.Options{
1455 err2 := lock.RefreshResource(time.Duration(1))
1457 assert.NotNil(t, lock)
1459 m.AssertExpectations(t)
1462 func TestRefreshResourceFailure(t *testing.T) {
1465 resourceExpected := "{namespace},resource"
1466 m.On("SetNX", resourceExpected, mock.Anything, time.Duration(1)).Return(true, nil).Once()
1467 m.On("PExpireIE", resourceExpected, mock.Anything, time.Duration(1)).Return(errors.New("Some error")).Once()
1469 lock, err := i.LockResource("resource", time.Duration(1), &sdlgo.Options{
1472 err2 := lock.RefreshResource(time.Duration(1))
1474 assert.NotNil(t, lock)
1475 assert.NotNil(t, err2)
1476 m.AssertExpectations(t)
1479 func TestCheckResourceSuccessfully(t *testing.T) {
1482 resourceExpected := "{namespace},resource"
1483 m.On("PTTL", resourceExpected).Return(time.Duration(1), nil)
1484 result, err := i.CheckResource("resource")
1486 assert.Equal(t, result, time.Duration(1))
1487 m.AssertExpectations(t)
1490 func TestCheckResourceFailure(t *testing.T) {
1493 resourceExpected := "{namespace},resource"
1494 m.On("PTTL", resourceExpected).Return(time.Duration(1), errors.New("Some error"))
1495 result, err := i.CheckResource("resource")
1496 assert.NotNil(t, err)
1497 assert.EqualError(t, err, "Some error")
1498 assert.Equal(t, result, time.Duration(0))
1499 m.AssertExpectations(t)
1502 func TestCheckResourceInvalidResource(t *testing.T) {
1505 resourceExpected := "{namespace},resource"
1506 m.On("PTTL", resourceExpected).Return(time.Duration(-1), nil)
1507 result, err := i.CheckResource("resource")
1508 assert.NotNil(t, err)
1509 assert.EqualError(t, err, "invalid resource given, no expiration time attached")
1510 assert.Equal(t, result, time.Duration(0))
1511 m.AssertExpectations(t)