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 "gerrit.o-ran-sc.org/r/ric-plt/sdlgo/internal/sdlgoredis"
28 "github.com/stretchr/testify/assert"
29 "github.com/stretchr/testify/mock"
36 func (m *mockDB) SubscribeChannelDB(cb sdlgoredis.ChannelNotificationCb, channelPrefix, eventSeparator string, channels ...string) {
37 m.Called(cb, channelPrefix, eventSeparator, channels)
40 func (m *mockDB) UnsubscribeChannelDB(channels ...string) {
44 func (m *mockDB) MSet(pairs ...interface{}) error {
49 func (m *mockDB) MSetMPub(channelsAndEvents []string, pairs ...interface{}) error {
50 a := m.Called(channelsAndEvents, pairs)
54 func (m *mockDB) MGet(keys []string) ([]interface{}, error) {
56 return a.Get(0).([]interface{}), a.Error(1)
59 func (m *mockDB) CloseDB() error {
64 func (m *mockDB) Del(keys []string) error {
69 func (m *mockDB) DelMPub(channelsAndEvents []string, keys []string) error {
70 a := m.Called(channelsAndEvents, keys)
74 func (m *mockDB) Keys(pattern string) ([]string, error) {
75 a := m.Called(pattern)
76 return a.Get(0).([]string), a.Error(1)
79 func (m *mockDB) SetIE(key string, oldData, newData interface{}) (bool, error) {
80 a := m.Called(key, oldData, newData)
81 return a.Bool(0), a.Error(1)
84 func (m *mockDB) SetIEPub(channel, message, key string, oldData, newData interface{}) (bool, error) {
85 a := m.Called(channel, message, key, oldData, newData)
86 return a.Bool(0), a.Error(1)
89 func (m *mockDB) SetNX(key string, data interface{}, expiration time.Duration) (bool, error) {
90 a := m.Called(key, data, expiration)
91 return a.Bool(0), a.Error(1)
94 func (m *mockDB) SetNXPub(channel, message, key string, data interface{}) (bool, error) {
95 a := m.Called(channel, message, key, data)
96 return a.Bool(0), a.Error(1)
99 func (m *mockDB) DelIE(key string, data interface{}) (bool, error) {
100 a := m.Called(key, data)
101 return a.Bool(0), a.Error(1)
104 func (m *mockDB) DelIEPub(channel, message, key string, data interface{}) (bool, error) {
105 a := m.Called(channel, message, key, data)
106 return a.Bool(0), a.Error(1)
109 func (m *mockDB) SAdd(key string, data ...interface{}) error {
110 a := m.Called(key, data)
114 func (m *mockDB) SRem(key string, data ...interface{}) error {
115 a := m.Called(key, data)
118 func (m *mockDB) SMembers(key string) ([]string, error) {
120 return a.Get(0).([]string), a.Error(1)
123 func (m *mockDB) SIsMember(key string, data interface{}) (bool, error) {
124 a := m.Called(key, data)
125 return a.Bool(0), a.Error(1)
128 func (m *mockDB) SCard(key string) (int64, error) {
130 return a.Get(0).(int64), a.Error(1)
133 func (m *mockDB) PTTL(key string) (time.Duration, error) {
135 return a.Get(0).(time.Duration), a.Error(1)
138 func (m *mockDB) PExpireIE(key string, data interface{}, expiration time.Duration) error {
139 a := m.Called(key, data, expiration)
143 func setup() (*mockDB, *sdlgo.SdlInstance) {
145 i := sdlgo.NewSdlInstance("namespace", m)
149 func verifySliceInOrder(a, b []string) bool {
150 for i, v := range a {
153 for j, x := range b {
154 if j%2 == 0 && x == v && a[i+1] == b[j+1] {
168 func TestSubscribeChannel(t *testing.T) {
171 expectedCB := func(channel string, events ...string) {}
172 expectedChannels := []string{"{namespace},channel1", "{namespace},channel2"}
174 m.On("SubscribeChannelDB", mock.AnythingOfType("sdlgoredis.ChannelNotificationCb"), "{namespace},", "___", expectedChannels).Return()
175 i.SubscribeChannel(expectedCB, "channel1", "channel2")
176 m.AssertExpectations(t)
179 func TestUnsubscribeChannel(t *testing.T) {
182 expectedChannels := []string{"{namespace},channel1", "{namespace},channel2"}
184 m.On("UnsubscribeChannelDB", expectedChannels).Return()
185 i.UnsubscribeChannel("channel1", "channel2")
186 m.AssertExpectations(t)
188 func TestGetOneKey(t *testing.T) {
191 mgetExpected := []string{"{namespace},key"}
192 mReturn := []interface{}{"somevalue"}
193 mReturnExpected := make(map[string]interface{})
194 mReturnExpected["key"] = "somevalue"
196 m.On("MGet", mgetExpected).Return(mReturn, nil)
197 retVal, err := i.Get([]string{"key"})
199 assert.Equal(t, mReturnExpected, retVal)
200 m.AssertExpectations(t)
203 func TestGetSeveralKeys(t *testing.T) {
206 mgetExpected := []string{"{namespace},key1", "{namespace},key2", "{namespace},key3"}
207 mReturn := []interface{}{"somevalue1", 2, "someothervalue"}
208 mReturnExpected := make(map[string]interface{})
209 mReturnExpected["key1"] = "somevalue1"
210 mReturnExpected["key2"] = 2
211 mReturnExpected["key3"] = "someothervalue"
213 m.On("MGet", mgetExpected).Return(mReturn, nil)
214 retVal, err := i.Get([]string{"key1", "key2", "key3"})
216 assert.Equal(t, mReturnExpected, retVal)
217 m.AssertExpectations(t)
220 func TestGetSeveralKeysSomeFail(t *testing.T) {
223 mgetExpected := []string{"{namespace},key1", "{namespace},key2", "{namespace},key3"}
224 mReturn := []interface{}{"somevalue1", nil, "someothervalue"}
225 mReturnExpected := make(map[string]interface{})
226 mReturnExpected["key1"] = "somevalue1"
227 mReturnExpected["key2"] = nil
228 mReturnExpected["key3"] = "someothervalue"
230 m.On("MGet", mgetExpected).Return(mReturn, nil)
231 retVal, err := i.Get([]string{"key1", "key2", "key3"})
233 assert.Equal(t, mReturnExpected, retVal)
234 m.AssertExpectations(t)
237 func TestGetKeyReturnError(t *testing.T) {
240 mgetExpected := []string{"{namespace},key"}
241 mReturn := []interface{}{nil}
242 mReturnExpected := make(map[string]interface{})
244 m.On("MGet", mgetExpected).Return(mReturn, errors.New("Some error"))
245 retVal, err := i.Get([]string{"key"})
246 assert.NotNil(t, err)
247 assert.Equal(t, mReturnExpected, retVal)
248 m.AssertExpectations(t)
251 func TestGetEmptyList(t *testing.T) {
254 mgetExpected := []string{}
256 retval, err := i.Get([]string{})
258 assert.Len(t, retval, 0)
259 m.AssertNotCalled(t, "MGet", mgetExpected)
262 func TestWriteOneKey(t *testing.T) {
265 msetExpected := []interface{}{"{namespace},key1", "data1"}
267 m.On("MSet", msetExpected).Return(nil)
268 err := i.Set("key1", "data1")
270 m.AssertExpectations(t)
273 func TestWriteByteSliceAsValue(t *testing.T) {
276 msetExpected := []interface{}{"{namespace},key1", []byte{1, 2, 3, 4, 5}}
278 m.On("MSet", msetExpected).Return(nil)
279 err := i.Set("key1", []byte{1, 2, 3, 4, 5})
281 m.AssertExpectations(t)
284 func TestWriteByteSliceAsValueMixed(t *testing.T) {
287 msetExpected := []interface{}{"{namespace},key1", []byte{1, 2, 3, 4, 5}, "{namespace},key2", "value2"}
289 m.On("MSet", msetExpected).Return(nil)
290 err := i.Set("key1", []byte{1, 2, 3, 4, 5}, []string{"key2", "value2"})
292 m.AssertExpectations(t)
295 func TestWriteByteArrayAsValue(t *testing.T) {
298 msetExpected := []interface{}{"{namespace},key1", [5]byte{1, 2, 3, 4, 5}}
300 m.On("MSet", msetExpected).Return(nil)
301 err := i.Set("key1", [5]byte{1, 2, 3, 4, 5})
303 m.AssertExpectations(t)
306 func TestWriteMapAsInput(t *testing.T) {
309 setExpected := []interface{}{"{namespace},key1", "string123",
310 "{namespace},key22", 12,
311 "{namespace},key333", []byte{1, 2, 3, 4, 5}}
312 inputMap := map[string]interface{}{
315 "key333": []byte{1, 2, 3, 4, 5},
318 m.On("MSet", mock.MatchedBy(func(input []interface{}) bool {
319 for _, v := range input {
321 for _, x := range setExpected {
322 found = reflect.DeepEqual(x, v)
334 err := i.Set(inputMap)
336 m.AssertExpectations(t)
339 func TestWriteMixed(t *testing.T) {
342 msetExpected := []interface{}{"{namespace},key1", "data1", "{namespace},key2", "data2", "{namespace},key3", "data3"}
344 m.On("MSet", msetExpected).Return(nil)
345 err := i.Set("key1", "data1", []string{"key2", "data2"}, [2]string{"key3", "data3"})
347 m.AssertExpectations(t)
350 func TestWriteIncorrectMixed(t *testing.T) {
353 msetExpected := []interface{}{"{namespace},key1", "data1", "{namespace},key2", "data2", "{namespace},key3", "data3"}
355 m.AssertNotCalled(t, "MSet", msetExpected)
356 err := i.Set("key1", []string{"key2", "data2"}, [2]string{"key3", "data3"})
357 assert.NotNil(t, err)
358 m.AssertExpectations(t)
360 func TestWriteIncorrectPairs(t *testing.T) {
363 msetExpected := []interface{}{}
365 m.AssertNotCalled(t, "MSet", msetExpected)
367 assert.NotNil(t, err)
368 m.AssertExpectations(t)
370 func TestWriteSeveralKeysSlice(t *testing.T) {
373 msetExpected := []interface{}{"{namespace},key1", "data1", "{namespace},key2", 22}
375 m.On("MSet", msetExpected).Return(nil)
376 err := i.Set([]interface{}{"key1", "data1", "key2", 22})
378 m.AssertExpectations(t)
382 func TestWriteSeveralKeysIncorrectSlice(t *testing.T) {
385 msetExpected := []interface{}{"{namespace},key1", "data1", "{namespace},key2", 22}
387 m.AssertNotCalled(t, "MSet", msetExpected)
388 err := i.Set([]interface{}{"key1", "data1", "key2"})
389 assert.NotNil(t, err)
390 m.AssertExpectations(t)
394 func TestWriteSeveralKeysArray(t *testing.T) {
397 msetExpected := []interface{}{"{namespace},key1", "data1", "{namespace},key2", "data2"}
399 m.On("MSet", msetExpected).Return(nil)
400 err := i.Set([4]string{"key1", "data1", "key2", "data2"})
402 m.AssertExpectations(t)
405 func TestWriteSeveralKeysIncorrectArray(t *testing.T) {
408 msetExpected := []interface{}{}
410 m.AssertNotCalled(t, "MSet", msetExpected)
411 err := i.Set([3]string{"key1", "data1", "key2"})
412 assert.NotNil(t, err)
413 m.AssertExpectations(t)
416 func TestWriteFail(t *testing.T) {
419 msetExpected := []interface{}{"{namespace},key1", "data1"}
421 m.On("MSet", msetExpected).Return(errors.New("Some error"))
422 err := i.Set("key1", "data1")
423 assert.NotNil(t, err)
424 m.AssertExpectations(t)
427 func TestWriteEmptyList(t *testing.T) {
430 msetExpected := []interface{}{}
433 m.AssertNotCalled(t, "MSet", msetExpected)
436 func TestWriteAndPublishOneKeyOneChannel(t *testing.T) {
439 expectedChannelAndEvent := []string{"{namespace},channel", "event"}
440 expectedKeyVal := []interface{}{"{namespace},key1", "data1"}
442 m.On("MSetMPub", expectedChannelAndEvent, expectedKeyVal).Return(nil)
443 m.AssertNotCalled(t, "MSet", expectedKeyVal)
444 err := i.SetAndPublish([]string{"channel", "event"}, "key1", "data1")
446 m.AssertExpectations(t)
449 func TestWriteAndPublishSeveralChannelsAndEvents(t *testing.T) {
452 expectedChannelsAndEvents := []string{"{namespace},channel1", "event1___event2",
453 "{namespace},channel2", "event3___event4"}
454 expectedKeyVal := []interface{}{"{namespace},key", "data"}
456 verifyChannelAndEvent := func(input []string) bool {
457 return verifySliceInOrder(input, expectedChannelsAndEvents)
459 m.On("MSetMPub", mock.MatchedBy(verifyChannelAndEvent), expectedKeyVal).Return(nil)
460 m.AssertNotCalled(t, "MSet", expectedKeyVal)
461 err := i.SetAndPublish([]string{"channel1", "event1", "channel2", "event3", "channel1", "event2", "channel2", "event4"},
464 m.AssertExpectations(t)
467 func TestWriteAndPublishOneKeyOneChannelTwoEvents(t *testing.T) {
470 expectedChannelAndEvents := []string{"{namespace},channel", "event1___event2"}
471 expectedKeyVal := []interface{}{"{namespace},key1", "data1"}
473 m.On("MSetMPub", expectedChannelAndEvents, expectedKeyVal).Return(nil)
474 m.AssertNotCalled(t, "MSet", expectedKeyVal)
475 err := i.SetAndPublish([]string{"channel", "event1", "channel", "event2"}, "key1", "data1")
477 m.AssertExpectations(t)
480 func TestWriteAndPublishIncorrectChannelAndEvent(t *testing.T) {
483 expectedChannelAndEvent := []string{}
484 expectedKeyVal := []interface{}{"{namespace},key1", "data1"}
485 m.AssertNotCalled(t, "MSetMPub", expectedChannelAndEvent, expectedKeyVal)
486 m.AssertNotCalled(t, "MSet", expectedKeyVal)
487 err := i.SetAndPublish([]string{"channel", "event1", "channel"}, "key1", "data1")
488 assert.NotNil(t, err)
489 m.AssertExpectations(t)
492 func TestWriteAndPublishNotAllowedCharactersInEvents(t *testing.T) {
495 expectedChannelAndEvent := []string{}
496 expectedKeyVal := []interface{}{"{namespace},key1", "data1"}
497 m.AssertNotCalled(t, "MSetMPub", expectedChannelAndEvent, expectedKeyVal)
498 m.AssertNotCalled(t, "MSet", expectedKeyVal)
499 err := i.SetAndPublish([]string{"channel", "event1___event2"}, "key1", "data1")
500 assert.NotNil(t, err)
501 m.AssertExpectations(t)
504 func TestWriteAndPublishNoData(t *testing.T) {
507 expectedChannelAndEvent := []string{}
508 expectedKeyVal := []interface{}{"key"}
510 m.AssertNotCalled(t, "MSetMPub", expectedChannelAndEvent, expectedKeyVal)
511 m.AssertNotCalled(t, "MSet", expectedKeyVal)
512 err := i.SetAndPublish([]string{"channel", "event"}, []interface{}{"key"})
513 assert.NotNil(t, err)
514 m.AssertExpectations(t)
517 func TestWriteAndPublishNoChannelEvent(t *testing.T) {
520 expectedKeyVal := []interface{}{"{namespace},key1", "data1"}
522 m.On("MSet", expectedKeyVal).Return(nil)
523 m.AssertNotCalled(t, "MSetMPub", "", "", expectedKeyVal)
524 err := i.SetAndPublish([]string{}, "key1", "data1")
526 m.AssertExpectations(t)
530 func TestRemoveAndPublishSuccessfully(t *testing.T) {
533 expectedChannelAndEvent := []string{"{namespace},channel", "event"}
534 expectedKeys := []string{"{namespace},key1", "{namespace},key2"}
536 m.On("DelMPub", expectedChannelAndEvent, expectedKeys).Return(nil)
537 err := i.RemoveAndPublish([]string{"channel", "event"}, []string{"key1", "key2"})
539 m.AssertExpectations(t)
542 func TestRemoveAndPublishSeveralChannelsAndEventsSuccessfully(t *testing.T) {
545 expectedChannelAndEvent := []string{"{namespace},channel1", "event1___event2",
546 "{namespace},channel2", "event3___event4"}
547 expectedKeys := []string{"{namespace},key1", "{namespace},key2"}
549 verifyChannelAndEvent := func(input []string) bool {
550 return verifySliceInOrder(input, expectedChannelAndEvent)
552 m.On("DelMPub", mock.MatchedBy(verifyChannelAndEvent), expectedKeys).Return(nil)
553 err := i.RemoveAndPublish([]string{"channel1", "event1", "channel2", "event3",
554 "channel1", "event2", "channel2", "event4"},
555 []string{"key1", "key2"})
557 m.AssertExpectations(t)
559 func TestRemoveAndPublishFail(t *testing.T) {
562 expectedChannelAndEvent := []string{"{namespace},channel", "event"}
563 expectedKeys := []string{"{namespace},key1", "{namespace},key2"}
565 m.On("DelMPub", expectedChannelAndEvent, expectedKeys).Return(errors.New("Some error"))
566 err := i.RemoveAndPublish([]string{"channel", "event"}, []string{"key1", "key2"})
567 assert.NotNil(t, err)
568 m.AssertExpectations(t)
571 func TestRemoveAndPublishNoChannels(t *testing.T) {
574 expectedKeys := []string{"{namespace},key1", "{namespace},key2"}
576 m.On("Del", expectedKeys).Return(nil)
577 err := i.RemoveAndPublish([]string{}, []string{"key1", "key2"})
579 m.AssertExpectations(t)
582 func TestRemoveAndPublishIncorrectChannel(t *testing.T) {
585 notExpectedChannelAndEvent := []string{}
586 notExpectedKeys := []string{"{namespace},key"}
588 m.AssertNotCalled(t, "DelMPub", notExpectedChannelAndEvent, notExpectedKeys)
589 m.AssertNotCalled(t, "Del", notExpectedKeys)
590 err := i.RemoveAndPublish([]string{"channel", "event", "channel2"}, []string{})
592 m.AssertExpectations(t)
595 func TestRemoveAndPublishNoKeys(t *testing.T) {
598 notExpectedChannelAndEvent := []string{}
599 notExpectedKeys := []string{"{namespace},key"}
601 m.AssertNotCalled(t, "DelMPub", notExpectedChannelAndEvent, notExpectedKeys)
602 m.AssertNotCalled(t, "Del", notExpectedKeys)
603 err := i.RemoveAndPublish([]string{"channel", "event"}, []string{})
605 m.AssertExpectations(t)
607 func TestRemoveAndPublishNoChannelsError(t *testing.T) {
610 expectedKeys := []string{"{namespace},key1", "{namespace},key2"}
612 m.On("Del", expectedKeys).Return(errors.New("Some error"))
613 err := i.RemoveAndPublish([]string{}, []string{"key1", "key2"})
614 assert.NotNil(t, err)
615 m.AssertExpectations(t)
617 func TestRemoveSuccessfully(t *testing.T) {
620 msetExpected := []string{"{namespace},key1", "{namespace},key2"}
621 m.On("Del", msetExpected).Return(nil)
623 err := i.Remove([]string{"key1", "key2"})
625 m.AssertExpectations(t)
628 func TestRemoveFail(t *testing.T) {
631 msetExpected := []string{"{namespace},key"}
632 m.On("Del", msetExpected).Return(errors.New("Some error"))
634 err := i.Remove([]string{"key"})
635 assert.NotNil(t, err)
636 m.AssertExpectations(t)
639 func TestRemoveEmptyList(t *testing.T) {
642 err := i.Remove([]string{})
644 m.AssertNotCalled(t, "Del", []string{})
647 func TestGetAllSuccessfully(t *testing.T) {
650 mKeysExpected := string("{namespace},*")
651 mReturnExpected := []string{"{namespace},key1", "{namespace},key2"}
652 expectedReturn := []string{"key1", "key2"}
653 m.On("Keys", mKeysExpected).Return(mReturnExpected, nil)
654 retVal, err := i.GetAll()
656 assert.Equal(t, expectedReturn, retVal)
657 m.AssertExpectations(t)
660 func TestGetAllFail(t *testing.T) {
663 mKeysExpected := string("{namespace},*")
664 mReturnExpected := []string{}
665 m.On("Keys", mKeysExpected).Return(mReturnExpected, errors.New("some error"))
666 retVal, err := i.GetAll()
667 assert.NotNil(t, err)
668 assert.Nil(t, retVal)
669 assert.Equal(t, len(retVal), 0)
670 m.AssertExpectations(t)
673 func TestGetAllReturnEmpty(t *testing.T) {
676 mKeysExpected := string("{namespace},*")
677 var mReturnExpected []string = nil
678 m.On("Keys", mKeysExpected).Return(mReturnExpected, nil)
679 retVal, err := i.GetAll()
681 assert.Nil(t, retVal)
682 assert.Equal(t, len(retVal), 0)
683 m.AssertExpectations(t)
687 func TestRemoveAllSuccessfully(t *testing.T) {
690 mKeysExpected := string("{namespace},*")
691 mKeysReturn := []string{"{namespace},key1", "{namespace},key2"}
692 mDelExpected := mKeysReturn
693 m.On("Keys", mKeysExpected).Return(mKeysReturn, nil)
694 m.On("Del", mDelExpected).Return(nil)
697 m.AssertExpectations(t)
700 func TestRemoveAllNoKeysFound(t *testing.T) {
703 mKeysExpected := string("{namespace},*")
704 var mKeysReturn []string = nil
705 m.On("Keys", mKeysExpected).Return(mKeysReturn, nil)
706 m.AssertNumberOfCalls(t, "Del", 0)
709 m.AssertExpectations(t)
712 func TestRemoveAllKeysReturnError(t *testing.T) {
715 mKeysExpected := string("{namespace},*")
716 var mKeysReturn []string = nil
717 m.On("Keys", mKeysExpected).Return(mKeysReturn, errors.New("Some error"))
718 m.AssertNumberOfCalls(t, "Del", 0)
720 assert.NotNil(t, err)
721 m.AssertExpectations(t)
724 func TestRemoveAllDelReturnError(t *testing.T) {
727 mKeysExpected := string("{namespace},*")
728 mKeysReturn := []string{"{namespace},key1", "{namespace},key2"}
729 mDelExpected := mKeysReturn
730 m.On("Keys", mKeysExpected).Return(mKeysReturn, nil)
731 m.On("Del", mDelExpected).Return(errors.New("Some Error"))
733 assert.NotNil(t, err)
734 m.AssertExpectations(t)
737 func TestSetIfSuccessfullyOkStatus(t *testing.T) {
740 mSetIEExpectedKey := string("{namespace},key1")
741 mSetIEExpectedOldData := interface{}("olddata")
742 mSetIEExpectedNewData := interface{}("newdata")
743 m.On("SetIE", mSetIEExpectedKey, mSetIEExpectedOldData, mSetIEExpectedNewData).Return(true, nil)
744 status, err := i.SetIf("key1", "olddata", "newdata")
746 assert.True(t, status)
747 m.AssertExpectations(t)
750 func TestSetIfSuccessfullyNOKStatus(t *testing.T) {
753 mSetIEExpectedKey := string("{namespace},key1")
754 mSetIEExpectedOldData := interface{}("olddata")
755 mSetIEExpectedNewData := interface{}("newdata")
756 m.On("SetIE", mSetIEExpectedKey, mSetIEExpectedOldData, mSetIEExpectedNewData).Return(false, nil)
757 status, err := i.SetIf("key1", "olddata", "newdata")
759 assert.False(t, status)
760 m.AssertExpectations(t)
763 func TestSetIfFailure(t *testing.T) {
766 mSetIEExpectedKey := string("{namespace},key1")
767 mSetIEExpectedOldData := interface{}("olddata")
768 mSetIEExpectedNewData := interface{}("newdata")
769 m.On("SetIE", mSetIEExpectedKey, mSetIEExpectedOldData, mSetIEExpectedNewData).Return(false, errors.New("Some error"))
770 status, err := i.SetIf("key1", "olddata", "newdata")
771 assert.NotNil(t, err)
772 assert.False(t, status)
773 m.AssertExpectations(t)
776 func TestSetIfAndPublishSuccessfully(t *testing.T) {
779 expectedChannel := "{namespace},channel"
780 expectedEvent := "event"
781 expectedKey := "{namespace},key"
782 expectedOldData := interface{}("olddata")
783 expectedNewData := interface{}("newdata")
784 m.On("SetIEPub", expectedChannel, expectedEvent, expectedKey, expectedOldData, expectedNewData).Return(true, nil)
785 status, err := i.SetIfAndPublish([]string{"channel", "event"}, "key", "olddata", "newdata")
787 assert.True(t, status)
788 m.AssertExpectations(t)
791 func TestSetIfAndPublishIncorrectChannelAndEvent(t *testing.T) {
794 expectedChannel := "{namespace},channel"
795 expectedEvent := "event"
796 expectedKey := "{namespace},key"
797 expectedOldData := interface{}("olddata")
798 expectedNewData := interface{}("newdata")
799 m.AssertNotCalled(t, "SetIEPub", expectedChannel, expectedEvent, expectedKey, expectedOldData, expectedNewData)
800 m.AssertNotCalled(t, "SetIE", expectedKey, expectedOldData, expectedNewData)
801 status, err := i.SetIfAndPublish([]string{"channel", "event1", "channel"}, "key", "olddata", "newdata")
802 assert.NotNil(t, err)
803 assert.False(t, status)
804 m.AssertExpectations(t)
806 func TestSetIfAndPublishNOKStatus(t *testing.T) {
809 expectedChannel := "{namespace},channel"
810 expectedEvent := "event"
811 expectedKey := "{namespace},key"
812 expectedOldData := interface{}("olddata")
813 expectedNewData := interface{}("newdata")
814 m.On("SetIEPub", expectedChannel, expectedEvent, expectedKey, expectedOldData, expectedNewData).Return(false, nil)
815 status, err := i.SetIfAndPublish([]string{"channel", "event"}, "key", "olddata", "newdata")
817 assert.False(t, status)
818 m.AssertExpectations(t)
821 func TestSetIfAndPublishNoChannels(t *testing.T) {
824 expectedKey := "{namespace},key"
825 expectedOldData := interface{}("olddata")
826 expectedNewData := interface{}("newdata")
827 m.On("SetIE", expectedKey, expectedOldData, expectedNewData).Return(true, nil)
828 status, err := i.SetIfAndPublish([]string{}, "key", "olddata", "newdata")
830 assert.True(t, status)
831 m.AssertExpectations(t)
834 func TestSetIfNotExistsAndPublishSuccessfully(t *testing.T) {
837 expectedChannel := "{namespace},channel"
838 expectedEvent := "event"
839 expectedKey := "{namespace},key"
840 expectedData := interface{}("data")
842 m.On("SetNXPub", expectedChannel, expectedEvent, expectedKey, expectedData).Return(true, nil)
843 status, err := i.SetIfNotExistsAndPublish([]string{"channel", "event"}, "key", "data")
845 assert.True(t, status)
846 m.AssertExpectations(t)
849 func TestSetIfNotExistsAndPublishSeveralEvents(t *testing.T) {
852 expectedChannel := "{namespace},channel"
853 expectedEvent := "event1___event2"
854 expectedKey := "{namespace},key"
855 expectedData := interface{}("data")
857 m.On("SetNXPub", expectedChannel, expectedEvent, expectedKey, expectedData).Return(true, nil)
858 status, err := i.SetIfNotExistsAndPublish([]string{"channel", "event1", "channel", "event2"}, "key", "data")
860 assert.True(t, status)
861 m.AssertExpectations(t)
864 func TestSetIfNotExistsAndPublishNoChannels(t *testing.T) {
867 expectedKey := "{namespace},key"
868 expectedData := interface{}("data")
870 m.On("SetNX", expectedKey, expectedData, time.Duration(0)).Return(true, nil)
871 status, err := i.SetIfNotExistsAndPublish([]string{}, "key", "data")
873 assert.True(t, status)
874 m.AssertExpectations(t)
877 func TestSetIfNotExistsAndPublishFail(t *testing.T) {
880 expectedChannel := "{namespace},channel"
881 expectedEvent := "event"
882 expectedKey := "{namespace},key"
883 expectedData := interface{}("data")
885 m.On("SetNXPub", expectedChannel, expectedEvent, expectedKey, expectedData).Return(false, nil)
886 status, err := i.SetIfNotExistsAndPublish([]string{"channel", "event"}, "key", "data")
888 assert.False(t, status)
889 m.AssertExpectations(t)
892 func TestSetIfNotExistsAndPublishIncorrectChannels(t *testing.T) {
895 expectedChannel := "{namespace},channel"
896 expectedEvent := "event"
897 expectedKey := "{namespace},key"
898 expectedData := interface{}("data")
900 m.AssertNotCalled(t, "SetNXPub", expectedChannel, expectedEvent, expectedKey, expectedData)
901 m.AssertNotCalled(t, "SetNX", expectedKey, expectedData, 0)
902 status, err := i.SetIfNotExistsAndPublish([]string{"channel", "event", "channel2"}, "key", "data")
903 assert.NotNil(t, err)
904 assert.False(t, status)
905 m.AssertExpectations(t)
908 func TestSetIfNotExistsAndPublishError(t *testing.T) {
911 expectedChannel := "{namespace},channel"
912 expectedEvent := "event"
913 expectedKey := "{namespace},key"
914 expectedData := interface{}("data")
916 m.On("SetNXPub", expectedChannel, expectedEvent, expectedKey, expectedData).Return(false, errors.New("Some error"))
917 status, err := i.SetIfNotExistsAndPublish([]string{"channel", "event"}, "key", "data")
918 assert.NotNil(t, err)
919 assert.False(t, status)
920 m.AssertExpectations(t)
923 func TestSetIfNotExistsSuccessfullyOkStatus(t *testing.T) {
926 mSetNXExpectedKey := string("{namespace},key1")
927 mSetNXExpectedData := interface{}("data")
928 m.On("SetNX", mSetNXExpectedKey, mSetNXExpectedData, time.Duration(0)).Return(true, nil)
929 status, err := i.SetIfNotExists("key1", "data")
931 assert.True(t, status)
932 m.AssertExpectations(t)
935 func TestSetIfNotExistsSuccessfullyNOKStatus(t *testing.T) {
938 mSetNXExpectedKey := string("{namespace},key1")
939 mSetNXExpectedData := interface{}("data")
940 m.On("SetNX", mSetNXExpectedKey, mSetNXExpectedData, time.Duration(0)).Return(false, nil)
941 status, err := i.SetIfNotExists("key1", "data")
943 assert.False(t, status)
944 m.AssertExpectations(t)
947 func TestSetIfNotExistsFailure(t *testing.T) {
950 mSetNXExpectedKey := string("{namespace},key1")
951 mSetNXExpectedData := interface{}("data")
952 m.On("SetNX", mSetNXExpectedKey, mSetNXExpectedData, time.Duration(0)).Return(false, errors.New("Some error"))
953 status, err := i.SetIfNotExists("key1", "data")
954 assert.NotNil(t, err)
955 assert.False(t, status)
956 m.AssertExpectations(t)
959 func TestRemoveIfAndPublishSuccessfully(t *testing.T) {
962 expectedChannel := "{namespace},channel"
963 expectedEvent := "event1___event2"
964 expectedKey := "{namespace},key"
965 expectedValue := interface{}("data")
967 m.On("DelIEPub", expectedChannel, expectedEvent, expectedKey, expectedValue).Return(true, nil)
968 status, err := i.RemoveIfAndPublish([]string{"channel", "event1", "channel", "event2"}, "key", "data")
970 assert.True(t, status)
971 m.AssertExpectations(t)
974 func TestRemoveIfAndPublishNok(t *testing.T) {
977 expectedChannel := "{namespace},channel"
978 expectedEvent := "event1___event2"
979 expectedKey := "{namespace},key"
980 expectedValue := interface{}("data")
982 m.On("DelIEPub", expectedChannel, expectedEvent, expectedKey, expectedValue).Return(false, nil)
983 status, err := i.RemoveIfAndPublish([]string{"channel", "event1", "channel", "event2"}, "key", "data")
985 assert.False(t, status)
986 m.AssertExpectations(t)
989 func TestRemoveIfAndPublishError(t *testing.T) {
992 expectedChannel := "{namespace},channel"
993 expectedEvent := "event1___event2"
994 expectedKey := "{namespace},key"
995 expectedValue := interface{}("data")
997 m.On("DelIEPub", expectedChannel, expectedEvent, expectedKey, expectedValue).Return(false, errors.New("Some error"))
998 status, err := i.RemoveIfAndPublish([]string{"channel", "event1", "channel", "event2"}, "key", "data")
999 assert.NotNil(t, err)
1000 assert.False(t, status)
1001 m.AssertExpectations(t)
1004 func TestRemoveIfAndPublishIncorrectChannel(t *testing.T) {
1007 expectedChannel := "{namespace},channel"
1008 expectedEvent := "event"
1009 expectedKey := "{namespace},key"
1010 expectedValue := interface{}("data")
1012 m.AssertNotCalled(t, "DelIEPub", expectedChannel, expectedEvent, expectedKey, expectedValue)
1013 m.AssertNotCalled(t, "DelIE", expectedKey, expectedValue)
1014 status, err := i.RemoveIfAndPublish([]string{"channel", "event1", "channel"}, "key", "data")
1015 assert.NotNil(t, err)
1016 assert.False(t, status)
1017 m.AssertExpectations(t)
1020 func TestRemoveIfAndPublishNoChannels(t *testing.T) {
1023 expectedKey := "{namespace},key"
1024 expectedValue := interface{}("data")
1026 m.On("DelIE", expectedKey, expectedValue).Return(true, nil)
1027 status, err := i.RemoveIfAndPublish([]string{}, "key", "data")
1029 assert.True(t, status)
1030 m.AssertExpectations(t)
1033 func TestRemoveIfSuccessfullyOkStatus(t *testing.T) {
1036 mDelIEExpectedKey := string("{namespace},key1")
1037 mDelIEExpectedData := interface{}("data")
1038 m.On("DelIE", mDelIEExpectedKey, mDelIEExpectedData).Return(true, nil)
1039 status, err := i.RemoveIf("key1", "data")
1041 assert.True(t, status)
1042 m.AssertExpectations(t)
1045 func TestRemoveIfSuccessfullyNOKStatus(t *testing.T) {
1048 mDelIEExpectedKey := string("{namespace},key1")
1049 mDelIEExpectedData := interface{}("data")
1050 m.On("DelIE", mDelIEExpectedKey, mDelIEExpectedData).Return(false, nil)
1051 status, err := i.RemoveIf("key1", "data")
1053 assert.False(t, status)
1054 m.AssertExpectations(t)
1057 func TestRemoveIfFailure(t *testing.T) {
1060 mDelIEExpectedKey := string("{namespace},key1")
1061 mDelIEExpectedData := interface{}("data")
1062 m.On("DelIE", mDelIEExpectedKey, mDelIEExpectedData).Return(true, errors.New("Some error"))
1063 status, err := i.RemoveIf("key1", "data")
1064 assert.NotNil(t, err)
1065 assert.False(t, status)
1066 m.AssertExpectations(t)
1069 func TestRemoveAllAndPublishSuccessfully(t *testing.T) {
1072 mKeysExpected := string("{namespace},*")
1073 mKeysReturn := []string{"{namespace},key1", "{namespace},key2"}
1074 mDelExpected := mKeysReturn
1075 expectedChannelAndEvent := []string{"{namespace},channel", "event"}
1076 m.On("Keys", mKeysExpected).Return(mKeysReturn, nil)
1077 m.On("DelMPub", expectedChannelAndEvent, mDelExpected).Return(nil)
1078 err := i.RemoveAllAndPublish([]string{"channel", "event"})
1080 m.AssertExpectations(t)
1083 func TestRemoveAllAndPublishKeysReturnError(t *testing.T) {
1086 mKeysExpected := string("{namespace},*")
1087 mKeysReturn := []string{"{namespace},key1", "{namespace},key2"}
1088 mDelExpected := mKeysReturn
1089 expectedChannelAndEvent := []string{"{namespace},channel", "event"}
1090 m.On("Keys", mKeysExpected).Return(mKeysReturn, errors.New("Some error"))
1091 m.AssertNotCalled(t, "DelMPub", expectedChannelAndEvent, mDelExpected)
1092 err := i.RemoveAllAndPublish([]string{"channel", "event"})
1093 assert.NotNil(t, err)
1094 m.AssertExpectations(t)
1097 func TestRemoveAllAndPublishKeysDelReturnsError(t *testing.T) {
1100 mKeysExpected := string("{namespace},*")
1101 mKeysReturn := []string{"{namespace},key1", "{namespace},key2"}
1102 mDelExpected := mKeysReturn
1103 expectedChannelAndEvent := []string{"{namespace},channel", "event"}
1104 m.On("Keys", mKeysExpected).Return(mKeysReturn, nil)
1105 m.On("DelMPub", expectedChannelAndEvent, mDelExpected).Return(errors.New("Some error"))
1106 err := i.RemoveAllAndPublish([]string{"channel", "event"})
1107 assert.NotNil(t, err)
1108 m.AssertExpectations(t)
1111 func TestRemoveAllAndPublishKeysEventsWithIllegalCharacters(t *testing.T) {
1114 mKeysExpected := string("{namespace},*")
1115 mKeysReturn := []string{"{namespace},key1", "{namespace},key2"}
1116 mDelExpected := mKeysReturn
1117 expectedChannelAndEvent := []string{"{namespace},channel", "event"}
1118 m.On("Keys", mKeysExpected).Return(mKeysReturn, nil)
1119 m.AssertNotCalled(t, "DelMPub", expectedChannelAndEvent, mDelExpected)
1120 err := i.RemoveAllAndPublish([]string{"channel", "event___anotherEvent"})
1121 assert.NotNil(t, err)
1122 m.AssertExpectations(t)
1126 func TestRemoveAllAndPublishNoChannels(t *testing.T) {
1129 mKeysExpected := string("{namespace},*")
1130 mKeysReturn := []string{"{namespace},key1", "{namespace},key2"}
1131 mDelExpected := mKeysReturn
1132 m.On("Keys", mKeysExpected).Return(mKeysReturn, nil)
1133 m.On("Del", mDelExpected).Return(nil)
1134 m.AssertNotCalled(t, "DelMPub", "", "", mDelExpected)
1135 err := i.RemoveAllAndPublish([]string{})
1137 m.AssertExpectations(t)
1140 func TestRemoveAllAndPublishIncorrectChannel(t *testing.T) {
1143 mKeysExpected := string("{namespace},*")
1144 mKeysReturn := []string{"{namespace},key1", "{namespace},key2"}
1145 mDelExpected := mKeysReturn
1146 m.On("Keys", mKeysExpected).Return(mKeysReturn, nil)
1147 m.AssertNotCalled(t, "DelMPub", "", "", mDelExpected)
1148 err := i.RemoveAllAndPublish([]string{"channel", "event", "channel2"})
1149 assert.NotNil(t, err)
1150 m.AssertExpectations(t)
1154 func TestAddMemberSuccessfully(t *testing.T) {
1157 groupExpected := string("{namespace},group")
1158 membersExpected := []interface{}{"member1", "member2"}
1160 m.On("SAdd", groupExpected, membersExpected).Return(nil)
1162 err := i.AddMember("group", "member1", "member2")
1164 m.AssertExpectations(t)
1167 func TestAddMemberFail(t *testing.T) {
1170 groupExpected := string("{namespace},group")
1171 membersExpected := []interface{}{"member1", "member2"}
1173 m.On("SAdd", groupExpected, membersExpected).Return(errors.New("Some error"))
1175 err := i.AddMember("group", "member1", "member2")
1176 assert.NotNil(t, err)
1177 m.AssertExpectations(t)
1179 func TestRemoveMemberSuccessfully(t *testing.T) {
1182 groupExpected := string("{namespace},group")
1183 membersExpected := []interface{}{"member1", "member2"}
1185 m.On("SRem", groupExpected, membersExpected).Return(nil)
1187 err := i.RemoveMember("group", "member1", "member2")
1189 m.AssertExpectations(t)
1192 func TestRemoveMemberFail(t *testing.T) {
1195 groupExpected := string("{namespace},group")
1196 membersExpected := []interface{}{"member1", "member2"}
1198 m.On("SRem", groupExpected, membersExpected).Return(errors.New("Some error"))
1200 err := i.RemoveMember("group", "member1", "member2")
1201 assert.NotNil(t, err)
1202 m.AssertExpectations(t)
1205 func TestRemoveGroupSuccessfully(t *testing.T) {
1208 groupExpected := []string{"{namespace},group"}
1210 m.On("Del", groupExpected).Return(nil)
1212 err := i.RemoveGroup("group")
1214 m.AssertExpectations(t)
1216 func TestRemoveGroupFail(t *testing.T) {
1219 groupExpected := []string{"{namespace},group"}
1221 m.On("Del", groupExpected).Return(errors.New("Some error"))
1223 err := i.RemoveGroup("group")
1224 assert.NotNil(t, err)
1225 m.AssertExpectations(t)
1228 func TestGetMembersSuccessfully(t *testing.T) {
1231 groupExpected := "{namespace},group"
1232 returnExpected := []string{"member1", "member2"}
1234 m.On("SMembers", groupExpected).Return(returnExpected, nil)
1236 result, err := i.GetMembers("group")
1238 assert.Equal(t, result, returnExpected)
1239 m.AssertExpectations(t)
1241 func TestGetMembersFail(t *testing.T) {
1244 groupExpected := "{namespace},group"
1245 returnExpected := []string{"member1", "member2"}
1247 m.On("SMembers", groupExpected).Return(returnExpected, errors.New("Some error"))
1249 result, err := i.GetMembers("group")
1250 assert.NotNil(t, err)
1251 assert.Equal(t, []string{}, result)
1252 m.AssertExpectations(t)
1255 func TestIsMemberSuccessfullyIsMember(t *testing.T) {
1258 groupExpected := "{namespace},group"
1259 memberExpected := "member"
1261 m.On("SIsMember", groupExpected, memberExpected).Return(true, nil)
1263 result, err := i.IsMember("group", "member")
1265 assert.True(t, result)
1266 m.AssertExpectations(t)
1268 func TestIsMemberSuccessfullyIsNotMember(t *testing.T) {
1271 groupExpected := "{namespace},group"
1272 memberExpected := "member"
1274 m.On("SIsMember", groupExpected, memberExpected).Return(false, nil)
1276 result, err := i.IsMember("group", "member")
1278 assert.False(t, result)
1279 m.AssertExpectations(t)
1281 func TestIsMemberFailure(t *testing.T) {
1284 groupExpected := "{namespace},group"
1285 memberExpected := "member"
1287 m.On("SIsMember", groupExpected, memberExpected).Return(true, errors.New("Some error"))
1289 result, err := i.IsMember("group", "member")
1290 assert.NotNil(t, err)
1291 assert.False(t, result)
1292 m.AssertExpectations(t)
1295 func TestGroupSizeSuccessfully(t *testing.T) {
1298 var expectedSize int64
1300 groupExpected := "{namespace},group"
1302 m.On("SCard", groupExpected).Return(expectedSize, nil)
1304 result, err := i.GroupSize("group")
1306 assert.Equal(t, expectedSize, result)
1307 m.AssertExpectations(t)
1309 func TestGroupSizeFail(t *testing.T) {
1312 var expectedSize int64
1314 groupExpected := "{namespace},group"
1316 m.On("SCard", groupExpected).Return(expectedSize, errors.New("Some error"))
1318 result, err := i.GroupSize("group")
1319 assert.NotNil(t, err)
1320 assert.Equal(t, int64(0), result)
1321 m.AssertExpectations(t)
1324 func TestLockResourceSuccessfully(t *testing.T) {
1327 resourceExpected := "{namespace},resource"
1328 m.On("SetNX", resourceExpected, mock.Anything, time.Duration(1)).Return(true, nil)
1330 lock, err := i.LockResource("resource", time.Duration(1), &sdlgo.Options{})
1332 assert.NotNil(t, lock)
1333 m.AssertExpectations(t)
1336 func TestLockResourceFailure(t *testing.T) {
1339 resourceExpected := "{namespace},resource"
1340 m.On("SetNX", resourceExpected, mock.Anything, time.Duration(1)).Return(true, errors.New("Some error"))
1342 lock, err := i.LockResource("resource", time.Duration(1), &sdlgo.Options{})
1343 assert.NotNil(t, err)
1345 m.AssertExpectations(t)
1348 func TestLockResourceTrySeveralTimesSuccessfully(t *testing.T) {
1351 resourceExpected := "{namespace},resource"
1352 m.On("SetNX", resourceExpected, mock.Anything, time.Duration(1)).Return(false, nil).Once()
1353 m.On("SetNX", resourceExpected, mock.Anything, time.Duration(1)).Return(true, nil).Once()
1355 lock, err := i.LockResource("resource", time.Duration(1), &sdlgo.Options{
1359 assert.NotNil(t, lock)
1360 m.AssertExpectations(t)
1363 func TestLockResourceTrySeveralTimesFailure(t *testing.T) {
1366 resourceExpected := "{namespace},resource"
1367 m.On("SetNX", resourceExpected, mock.Anything, time.Duration(1)).Return(false, nil).Once()
1368 m.On("SetNX", resourceExpected, mock.Anything, time.Duration(1)).Return(true, errors.New("Some error")).Once()
1370 lock, err := i.LockResource("resource", time.Duration(1), &sdlgo.Options{
1373 assert.NotNil(t, err)
1375 m.AssertExpectations(t)
1378 func TestLockResourceTrySeveralTimesUnableToGetResource(t *testing.T) {
1381 resourceExpected := "{namespace},resource"
1382 m.On("SetNX", resourceExpected, mock.Anything, time.Duration(1)).Return(false, nil).Once()
1383 m.On("SetNX", resourceExpected, mock.Anything, time.Duration(1)).Return(false, nil).Once()
1385 lock, err := i.LockResource("resource", time.Duration(1), &sdlgo.Options{
1388 assert.NotNil(t, err)
1389 assert.EqualError(t, err, "Lock not obtained")
1391 m.AssertExpectations(t)
1394 func TestReleaseResourceSuccessfully(t *testing.T) {
1397 resourceExpected := "{namespace},resource"
1398 m.On("SetNX", resourceExpected, mock.Anything, time.Duration(1)).Return(true, nil).Once()
1399 m.On("DelIE", resourceExpected, mock.Anything).Return(true, nil).Once()
1401 lock, err := i.LockResource("resource", time.Duration(1), &sdlgo.Options{
1404 err2 := lock.ReleaseResource()
1406 assert.NotNil(t, lock)
1408 m.AssertExpectations(t)
1411 func TestReleaseResourceFailure(t *testing.T) {
1414 resourceExpected := "{namespace},resource"
1415 m.On("SetNX", resourceExpected, mock.Anything, time.Duration(1)).Return(true, nil).Once()
1416 m.On("DelIE", resourceExpected, mock.Anything).Return(true, errors.New("Some error")).Once()
1418 lock, err := i.LockResource("resource", time.Duration(1), &sdlgo.Options{
1421 err2 := lock.ReleaseResource()
1423 assert.NotNil(t, lock)
1424 assert.NotNil(t, err2)
1425 m.AssertExpectations(t)
1428 func TestReleaseResourceLockNotHeld(t *testing.T) {
1431 resourceExpected := "{namespace},resource"
1432 m.On("SetNX", resourceExpected, mock.Anything, time.Duration(1)).Return(true, nil).Once()
1433 m.On("DelIE", resourceExpected, mock.Anything).Return(false, nil).Once()
1435 lock, err := i.LockResource("resource", time.Duration(1), &sdlgo.Options{
1438 err2 := lock.ReleaseResource()
1440 assert.NotNil(t, lock)
1441 assert.NotNil(t, err2)
1442 assert.EqualError(t, err2, "Lock not held")
1443 m.AssertExpectations(t)
1446 func TestRefreshResourceSuccessfully(t *testing.T) {
1449 resourceExpected := "{namespace},resource"
1450 m.On("SetNX", resourceExpected, mock.Anything, time.Duration(1)).Return(true, nil).Once()
1451 m.On("PExpireIE", resourceExpected, mock.Anything, time.Duration(1)).Return(nil).Once()
1453 lock, err := i.LockResource("resource", time.Duration(1), &sdlgo.Options{
1456 err2 := lock.RefreshResource(time.Duration(1))
1458 assert.NotNil(t, lock)
1460 m.AssertExpectations(t)
1463 func TestRefreshResourceFailure(t *testing.T) {
1466 resourceExpected := "{namespace},resource"
1467 m.On("SetNX", resourceExpected, mock.Anything, time.Duration(1)).Return(true, nil).Once()
1468 m.On("PExpireIE", resourceExpected, mock.Anything, time.Duration(1)).Return(errors.New("Some error")).Once()
1470 lock, err := i.LockResource("resource", time.Duration(1), &sdlgo.Options{
1473 err2 := lock.RefreshResource(time.Duration(1))
1475 assert.NotNil(t, lock)
1476 assert.NotNil(t, err2)
1477 m.AssertExpectations(t)
1480 func TestCheckResourceSuccessfully(t *testing.T) {
1483 resourceExpected := "{namespace},resource"
1484 m.On("PTTL", resourceExpected).Return(time.Duration(1), nil)
1485 result, err := i.CheckResource("resource")
1487 assert.Equal(t, result, time.Duration(1))
1488 m.AssertExpectations(t)
1491 func TestCheckResourceFailure(t *testing.T) {
1494 resourceExpected := "{namespace},resource"
1495 m.On("PTTL", resourceExpected).Return(time.Duration(1), errors.New("Some error"))
1496 result, err := i.CheckResource("resource")
1497 assert.NotNil(t, err)
1498 assert.EqualError(t, err, "Some error")
1499 assert.Equal(t, result, time.Duration(0))
1500 m.AssertExpectations(t)
1503 func TestCheckResourceInvalidResource(t *testing.T) {
1506 resourceExpected := "{namespace},resource"
1507 m.On("PTTL", resourceExpected).Return(time.Duration(-1), nil)
1508 result, err := i.CheckResource("resource")
1509 assert.NotNil(t, err)
1510 assert.EqualError(t, err, "invalid resource given, no expiration time attached")
1511 assert.Equal(t, result, time.Duration(0))
1512 m.AssertExpectations(t)