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.
19 * This source code is part of the near-RT RIC (RAN Intelligent Controller)
20 * platform project (RICP).
31 "gerrit.o-ran-sc.org/r/ric-plt/sdlgo"
32 "github.com/stretchr/testify/assert"
33 "github.com/stretchr/testify/mock"
40 func (m *mockDB) SubscribeChannelDB(cb func(string, ...string), channels ...string) error {
41 a := m.Called(cb, channels)
45 func (m *mockDB) UnsubscribeChannelDB(channels ...string) error {
46 a := m.Called(channels)
50 func (m *mockDB) MSet(pairs ...interface{}) error {
55 func (m *mockDB) MSetMPub(channelsAndEvents []string, pairs ...interface{}) error {
56 a := m.Called(channelsAndEvents, pairs)
60 func (m *mockDB) MGet(keys []string) ([]interface{}, error) {
62 return a.Get(0).([]interface{}), a.Error(1)
65 func (m *mockDB) CloseDB() error {
70 func (m *mockDB) Del(keys []string) error {
75 func (m *mockDB) DelMPub(channelsAndEvents []string, keys []string) error {
76 a := m.Called(channelsAndEvents, keys)
80 func (m *mockDB) Keys(pattern string) ([]string, error) {
81 a := m.Called(pattern)
82 return a.Get(0).([]string), a.Error(1)
85 func (m *mockDB) SetIE(key string, oldData, newData interface{}) (bool, error) {
86 a := m.Called(key, oldData, newData)
87 return a.Bool(0), a.Error(1)
90 func (m *mockDB) SetIEPub(channelsAndEvents []string, key string, oldData, newData interface{}) (bool, error) {
91 a := m.Called(channelsAndEvents, key, oldData, newData)
92 return a.Bool(0), a.Error(1)
95 func (m *mockDB) SetNX(key string, data interface{}, expiration time.Duration) (bool, error) {
96 a := m.Called(key, data, expiration)
97 return a.Bool(0), a.Error(1)
100 func (m *mockDB) SetNXPub(channelsAndEvents []string, key string, data interface{}) (bool, error) {
101 a := m.Called(channelsAndEvents, key, data)
102 return a.Bool(0), a.Error(1)
105 func (m *mockDB) DelIE(key string, data interface{}) (bool, error) {
106 a := m.Called(key, data)
107 return a.Bool(0), a.Error(1)
110 func (m *mockDB) DelIEPub(channelsAndEvents []string, key string, data interface{}) (bool, error) {
111 a := m.Called(channelsAndEvents, key, data)
112 return a.Bool(0), a.Error(1)
115 func (m *mockDB) SAdd(key string, data ...interface{}) error {
116 a := m.Called(key, data)
120 func (m *mockDB) SRem(key string, data ...interface{}) error {
121 a := m.Called(key, data)
124 func (m *mockDB) SMembers(key string) ([]string, error) {
126 return a.Get(0).([]string), a.Error(1)
129 func (m *mockDB) SIsMember(key string, data interface{}) (bool, error) {
130 a := m.Called(key, data)
131 return a.Bool(0), a.Error(1)
134 func (m *mockDB) SCard(key string) (int64, error) {
136 return a.Get(0).(int64), a.Error(1)
139 func (m *mockDB) PTTL(key string) (time.Duration, error) {
141 return a.Get(0).(time.Duration), a.Error(1)
144 func (m *mockDB) PExpireIE(key string, data interface{}, expiration time.Duration) error {
145 a := m.Called(key, data, expiration)
149 func setup() (*mockDB, *sdlgo.SdlInstance) {
151 i := sdlgo.NewSdlInstanceForTest("namespace", m)
155 func verifySliceInOrder(a, b []string) bool {
156 for i, v := range a {
159 for j, x := range b {
160 if j%2 == 0 && x == v && a[i+1] == b[j+1] {
174 func TestClose(t *testing.T) {
177 m.On("CloseDB").Return(nil)
180 m.AssertExpectations(t)
183 func TestCloseReturnError(t *testing.T) {
186 m.On("CloseDB").Return(errors.New("Some error"))
188 assert.NotNil(t, err)
189 m.AssertExpectations(t)
192 func TestSubscribeChannel(t *testing.T) {
195 expectedCB := func(channel string, events ...string) {}
196 expectedChannels := []string{"{namespace},channel1", "{namespace},channel2"}
198 m.On("SubscribeChannelDB", mock.AnythingOfType("func(string, ...string)"), expectedChannels).Return(nil)
199 err := i.SubscribeChannel(expectedCB, "channel1", "channel2")
201 m.AssertExpectations(t)
204 func TestSubscribeChannelError(t *testing.T) {
205 mockedErr := errors.New("Some DB Backend Subscribe Error")
208 expectedCB := func(channel string, events ...string) {}
209 expectedChannels := []string{"{namespace},channel1", "{namespace},channel2"}
211 m.On("SubscribeChannelDB", mock.AnythingOfType("func(string, ...string)"), expectedChannels).Return(mockedErr)
212 err := i.SubscribeChannel(expectedCB, "channel1", "channel2")
213 assert.NotNil(t, err)
214 assert.Contains(t, err.Error(), mockedErr.Error())
215 m.AssertExpectations(t)
218 func TestUnsubscribeChannel(t *testing.T) {
221 expectedChannels := []string{"{namespace},channel1", "{namespace},channel2"}
223 m.On("UnsubscribeChannelDB", expectedChannels).Return(nil)
224 err := i.UnsubscribeChannel("channel1", "channel2")
226 m.AssertExpectations(t)
229 func TestUnsubscribeChannelError(t *testing.T) {
230 mockedErr := errors.New("Some DB Backend Unsubscribe Error")
233 expectedChannels := []string{"{namespace},channel1", "{namespace},channel2"}
235 m.On("UnsubscribeChannelDB", expectedChannels).Return(mockedErr)
236 err := i.UnsubscribeChannel("channel1", "channel2")
237 assert.NotNil(t, err)
238 assert.Contains(t, err.Error(), mockedErr.Error())
239 m.AssertExpectations(t)
242 func TestGetOneKey(t *testing.T) {
245 mgetExpected := []string{"{namespace},key"}
246 mReturn := []interface{}{"somevalue"}
247 mReturnExpected := make(map[string]interface{})
248 mReturnExpected["key"] = "somevalue"
250 m.On("MGet", mgetExpected).Return(mReturn, nil)
251 retVal, err := i.Get([]string{"key"})
253 assert.Equal(t, mReturnExpected, retVal)
254 m.AssertExpectations(t)
257 func TestGetSeveralKeys(t *testing.T) {
260 mgetExpected := []string{"{namespace},key1", "{namespace},key2", "{namespace},key3"}
261 mReturn := []interface{}{"somevalue1", 2, "someothervalue"}
262 mReturnExpected := make(map[string]interface{})
263 mReturnExpected["key1"] = "somevalue1"
264 mReturnExpected["key2"] = 2
265 mReturnExpected["key3"] = "someothervalue"
267 m.On("MGet", mgetExpected).Return(mReturn, nil)
268 retVal, err := i.Get([]string{"key1", "key2", "key3"})
270 assert.Equal(t, mReturnExpected, retVal)
271 m.AssertExpectations(t)
274 func TestGetSeveralKeysSomeFail(t *testing.T) {
277 mgetExpected := []string{"{namespace},key1", "{namespace},key2", "{namespace},key3"}
278 mReturn := []interface{}{"somevalue1", nil, "someothervalue"}
279 mReturnExpected := make(map[string]interface{})
280 mReturnExpected["key1"] = "somevalue1"
281 mReturnExpected["key2"] = nil
282 mReturnExpected["key3"] = "someothervalue"
284 m.On("MGet", mgetExpected).Return(mReturn, nil)
285 retVal, err := i.Get([]string{"key1", "key2", "key3"})
287 assert.Equal(t, mReturnExpected, retVal)
288 m.AssertExpectations(t)
291 func TestGetKeyReturnError(t *testing.T) {
294 mgetExpected := []string{"{namespace},key"}
295 mReturn := []interface{}{nil}
296 mReturnExpected := make(map[string]interface{})
298 m.On("MGet", mgetExpected).Return(mReturn, errors.New("Some error"))
299 retVal, err := i.Get([]string{"key"})
300 assert.NotNil(t, err)
301 assert.Equal(t, mReturnExpected, retVal)
302 m.AssertExpectations(t)
305 func TestGetEmptyList(t *testing.T) {
308 mgetExpected := []string{}
310 retval, err := i.Get([]string{})
312 assert.Len(t, retval, 0)
313 m.AssertNotCalled(t, "MGet", mgetExpected)
316 func TestWriteOneKey(t *testing.T) {
319 msetExpected := []interface{}{"{namespace},key1", "data1"}
321 m.On("MSet", msetExpected).Return(nil)
322 err := i.Set("key1", "data1")
324 m.AssertExpectations(t)
327 func TestWriteByteSliceAsValue(t *testing.T) {
330 msetExpected := []interface{}{"{namespace},key1", []byte{1, 2, 3, 4, 5}}
332 m.On("MSet", msetExpected).Return(nil)
333 err := i.Set("key1", []byte{1, 2, 3, 4, 5})
335 m.AssertExpectations(t)
338 func TestWriteByteSliceAsValueMixed(t *testing.T) {
341 msetExpected := []interface{}{"{namespace},key1", []byte{1, 2, 3, 4, 5}, "{namespace},key2", "value2"}
343 m.On("MSet", msetExpected).Return(nil)
344 err := i.Set("key1", []byte{1, 2, 3, 4, 5}, []string{"key2", "value2"})
346 m.AssertExpectations(t)
349 func TestWriteByteArrayAsValue(t *testing.T) {
352 msetExpected := []interface{}{"{namespace},key1", [5]byte{1, 2, 3, 4, 5}}
354 m.On("MSet", msetExpected).Return(nil)
355 err := i.Set("key1", [5]byte{1, 2, 3, 4, 5})
357 m.AssertExpectations(t)
360 func TestWriteMapAsInput(t *testing.T) {
363 setExpected := []interface{}{"{namespace},key1", "string123",
364 "{namespace},key22", 12,
365 "{namespace},key333", []byte{1, 2, 3, 4, 5}}
366 inputMap := map[string]interface{}{
369 "key333": []byte{1, 2, 3, 4, 5},
372 m.On("MSet", mock.MatchedBy(func(input []interface{}) bool {
373 for _, v := range input {
375 for _, x := range setExpected {
376 found = reflect.DeepEqual(x, v)
388 err := i.Set(inputMap)
390 m.AssertExpectations(t)
393 func TestWriteMixed(t *testing.T) {
396 msetExpected := []interface{}{"{namespace},key1", "data1", "{namespace},key2", "data2", "{namespace},key3", "data3"}
398 m.On("MSet", msetExpected).Return(nil)
399 err := i.Set("key1", "data1", []string{"key2", "data2"}, [2]string{"key3", "data3"})
401 m.AssertExpectations(t)
404 func TestWriteIncorrectMixed(t *testing.T) {
407 msetExpected := []interface{}{"{namespace},key1", "data1", "{namespace},key2", "data2", "{namespace},key3", "data3"}
409 m.AssertNotCalled(t, "MSet", msetExpected)
410 err := i.Set("key1", []string{"key2", "data2"}, [2]string{"key3", "data3"})
411 assert.NotNil(t, err)
412 m.AssertExpectations(t)
414 func TestWriteIncorrectPairs(t *testing.T) {
417 msetExpected := []interface{}{}
419 m.AssertNotCalled(t, "MSet", msetExpected)
421 assert.NotNil(t, err)
422 m.AssertExpectations(t)
424 func TestWriteSeveralKeysSlice(t *testing.T) {
427 msetExpected := []interface{}{"{namespace},key1", "data1", "{namespace},key2", 22}
429 m.On("MSet", msetExpected).Return(nil)
430 err := i.Set([]interface{}{"key1", "data1", "key2", 22})
432 m.AssertExpectations(t)
436 func TestWriteSeveralKeysIncorrectSlice(t *testing.T) {
439 msetExpected := []interface{}{"{namespace},key1", "data1", "{namespace},key2", 22}
441 m.AssertNotCalled(t, "MSet", msetExpected)
442 err := i.Set([]interface{}{"key1", "data1", "key2"})
443 assert.NotNil(t, err)
444 m.AssertExpectations(t)
448 func TestWriteSeveralKeysArray(t *testing.T) {
451 msetExpected := []interface{}{"{namespace},key1", "data1", "{namespace},key2", "data2"}
453 m.On("MSet", msetExpected).Return(nil)
454 err := i.Set([4]string{"key1", "data1", "key2", "data2"})
456 m.AssertExpectations(t)
459 func TestWriteSeveralKeysIncorrectArray(t *testing.T) {
462 msetExpected := []interface{}{}
464 m.AssertNotCalled(t, "MSet", msetExpected)
465 err := i.Set([3]string{"key1", "data1", "key2"})
466 assert.NotNil(t, err)
467 m.AssertExpectations(t)
470 func TestWriteFail(t *testing.T) {
473 msetExpected := []interface{}{"{namespace},key1", "data1"}
475 m.On("MSet", msetExpected).Return(errors.New("Some error"))
476 err := i.Set("key1", "data1")
477 assert.NotNil(t, err)
478 m.AssertExpectations(t)
481 func TestWriteEmptyList(t *testing.T) {
484 msetExpected := []interface{}{}
487 m.AssertNotCalled(t, "MSet", msetExpected)
490 func TestWriteAndPublishOneKeyOneChannel(t *testing.T) {
493 expectedChannelAndEvent := []string{"{namespace},channel", "event"}
494 expectedKeyVal := []interface{}{"{namespace},key1", "data1"}
496 m.On("MSetMPub", expectedChannelAndEvent, expectedKeyVal).Return(nil)
497 m.AssertNotCalled(t, "MSet", expectedKeyVal)
498 err := i.SetAndPublish([]string{"channel", "event"}, "key1", "data1")
500 m.AssertExpectations(t)
503 func TestWriteAndPublishSeveralChannelsAndEvents(t *testing.T) {
506 expectedChannelsAndEvents := []string{"{namespace},channel1", "event1___event2",
507 "{namespace},channel2", "event3___event4"}
508 expectedKeyVal := []interface{}{"{namespace},key", "data"}
510 verifyChannelAndEvent := func(input []string) bool {
511 return verifySliceInOrder(input, expectedChannelsAndEvents)
513 m.On("MSetMPub", mock.MatchedBy(verifyChannelAndEvent), expectedKeyVal).Return(nil)
514 m.AssertNotCalled(t, "MSet", expectedKeyVal)
515 err := i.SetAndPublish([]string{"channel1", "event1", "channel2", "event3", "channel1", "event2", "channel2", "event4"},
518 m.AssertExpectations(t)
521 func TestWriteAndPublishOneKeyOneChannelTwoEvents(t *testing.T) {
524 expectedChannelAndEvents := []string{"{namespace},channel", "event1___event2"}
525 expectedKeyVal := []interface{}{"{namespace},key1", "data1"}
527 m.On("MSetMPub", expectedChannelAndEvents, expectedKeyVal).Return(nil)
528 m.AssertNotCalled(t, "MSet", expectedKeyVal)
529 err := i.SetAndPublish([]string{"channel", "event1", "channel", "event2"}, "key1", "data1")
531 m.AssertExpectations(t)
534 func TestWriteAndPublishIncorrectChannelAndEvent(t *testing.T) {
537 expectedChannelAndEvent := []string{}
538 expectedKeyVal := []interface{}{"{namespace},key1", "data1"}
539 m.AssertNotCalled(t, "MSetMPub", expectedChannelAndEvent, expectedKeyVal)
540 m.AssertNotCalled(t, "MSet", expectedKeyVal)
541 err := i.SetAndPublish([]string{"channel", "event1", "channel"}, "key1", "data1")
542 assert.NotNil(t, err)
543 m.AssertExpectations(t)
546 func TestWriteAndPublishNotAllowedCharactersInEvents(t *testing.T) {
549 expectedChannelAndEvent := []string{}
550 expectedKeyVal := []interface{}{"{namespace},key1", "data1"}
551 m.AssertNotCalled(t, "MSetMPub", expectedChannelAndEvent, expectedKeyVal)
552 m.AssertNotCalled(t, "MSet", expectedKeyVal)
553 err := i.SetAndPublish([]string{"channel", "event1___event2"}, "key1", "data1")
554 assert.NotNil(t, err)
555 m.AssertExpectations(t)
558 func TestWriteAndPublishNoData(t *testing.T) {
561 expectedChannelAndEvent := []string{}
562 expectedKeyVal := []interface{}{"key"}
564 m.AssertNotCalled(t, "MSetMPub", expectedChannelAndEvent, expectedKeyVal)
565 m.AssertNotCalled(t, "MSet", expectedKeyVal)
566 err := i.SetAndPublish([]string{"channel", "event"}, []interface{}{"key"})
567 assert.NotNil(t, err)
568 m.AssertExpectations(t)
571 func TestWriteAndPublishNoChannelEvent(t *testing.T) {
574 expectedKeyVal := []interface{}{"{namespace},key1", "data1"}
576 m.On("MSet", expectedKeyVal).Return(nil)
577 m.AssertNotCalled(t, "MSetMPub", "", "", expectedKeyVal)
578 err := i.SetAndPublish([]string{}, "key1", "data1")
580 m.AssertExpectations(t)
584 func TestRemoveAndPublishSuccessfully(t *testing.T) {
587 expectedChannelAndEvent := []string{"{namespace},channel", "event"}
588 expectedKeys := []string{"{namespace},key1", "{namespace},key2"}
590 m.On("DelMPub", expectedChannelAndEvent, expectedKeys).Return(nil)
591 err := i.RemoveAndPublish([]string{"channel", "event"}, []string{"key1", "key2"})
593 m.AssertExpectations(t)
596 func TestRemoveAndPublishSeveralChannelsAndEventsSuccessfully(t *testing.T) {
599 expectedChannelAndEvent := []string{"{namespace},channel1", "event1___event2",
600 "{namespace},channel2", "event3___event4"}
601 expectedKeys := []string{"{namespace},key1", "{namespace},key2"}
603 verifyChannelAndEvent := func(input []string) bool {
604 return verifySliceInOrder(input, expectedChannelAndEvent)
606 m.On("DelMPub", mock.MatchedBy(verifyChannelAndEvent), expectedKeys).Return(nil)
607 err := i.RemoveAndPublish([]string{"channel1", "event1", "channel2", "event3",
608 "channel1", "event2", "channel2", "event4"},
609 []string{"key1", "key2"})
611 m.AssertExpectations(t)
613 func TestRemoveAndPublishFail(t *testing.T) {
616 expectedChannelAndEvent := []string{"{namespace},channel", "event"}
617 expectedKeys := []string{"{namespace},key1", "{namespace},key2"}
619 m.On("DelMPub", expectedChannelAndEvent, expectedKeys).Return(errors.New("Some error"))
620 err := i.RemoveAndPublish([]string{"channel", "event"}, []string{"key1", "key2"})
621 assert.NotNil(t, err)
622 m.AssertExpectations(t)
625 func TestRemoveAndPublishNoChannels(t *testing.T) {
628 expectedKeys := []string{"{namespace},key1", "{namespace},key2"}
630 m.On("Del", expectedKeys).Return(nil)
631 err := i.RemoveAndPublish([]string{}, []string{"key1", "key2"})
633 m.AssertExpectations(t)
636 func TestRemoveAndPublishIncorrectChannel(t *testing.T) {
639 notExpectedChannelAndEvent := []string{}
640 notExpectedKeys := []string{"{namespace},key"}
642 m.AssertNotCalled(t, "DelMPub", notExpectedChannelAndEvent, notExpectedKeys)
643 m.AssertNotCalled(t, "Del", notExpectedKeys)
644 err := i.RemoveAndPublish([]string{"channel", "event", "channel2"}, []string{"key1", "key2"})
645 assert.NotNil(t, err)
646 m.AssertExpectations(t)
649 func TestRemoveAndPublishNoKeys(t *testing.T) {
652 notExpectedChannelAndEvent := []string{}
653 notExpectedKeys := []string{"{namespace},key"}
655 m.AssertNotCalled(t, "DelMPub", notExpectedChannelAndEvent, notExpectedKeys)
656 m.AssertNotCalled(t, "Del", notExpectedKeys)
657 err := i.RemoveAndPublish([]string{"channel", "event"}, []string{})
659 m.AssertExpectations(t)
661 func TestRemoveAndPublishNoChannelsError(t *testing.T) {
664 expectedKeys := []string{"{namespace},key1", "{namespace},key2"}
666 m.On("Del", expectedKeys).Return(errors.New("Some error"))
667 err := i.RemoveAndPublish([]string{}, []string{"key1", "key2"})
668 assert.NotNil(t, err)
669 m.AssertExpectations(t)
671 func TestRemoveSuccessfully(t *testing.T) {
674 msetExpected := []string{"{namespace},key1", "{namespace},key2"}
675 m.On("Del", msetExpected).Return(nil)
677 err := i.Remove([]string{"key1", "key2"})
679 m.AssertExpectations(t)
682 func TestRemoveFail(t *testing.T) {
685 msetExpected := []string{"{namespace},key"}
686 m.On("Del", msetExpected).Return(errors.New("Some error"))
688 err := i.Remove([]string{"key"})
689 assert.NotNil(t, err)
690 m.AssertExpectations(t)
693 func TestRemoveEmptyList(t *testing.T) {
696 err := i.Remove([]string{})
698 m.AssertNotCalled(t, "Del", []string{})
701 func TestGetAllSuccessfully(t *testing.T) {
704 mKeysExpected := string("{namespace},*")
705 mReturnExpected := []string{"{namespace},key1", "{namespace},key2"}
706 expectedReturn := []string{"key1", "key2"}
707 m.On("Keys", mKeysExpected).Return(mReturnExpected, nil)
708 retVal, err := i.GetAll()
710 assert.Equal(t, expectedReturn, retVal)
711 m.AssertExpectations(t)
714 func TestGetAllFail(t *testing.T) {
717 mKeysExpected := string("{namespace},*")
718 mReturnExpected := []string{}
719 m.On("Keys", mKeysExpected).Return(mReturnExpected, errors.New("some error"))
720 retVal, err := i.GetAll()
721 assert.NotNil(t, err)
722 assert.Nil(t, retVal)
723 assert.Equal(t, len(retVal), 0)
724 m.AssertExpectations(t)
727 func TestGetAllReturnEmpty(t *testing.T) {
730 mKeysExpected := string("{namespace},*")
731 var mReturnExpected []string = nil
732 m.On("Keys", mKeysExpected).Return(mReturnExpected, nil)
733 retVal, err := i.GetAll()
735 assert.Nil(t, retVal)
736 assert.Equal(t, len(retVal), 0)
737 m.AssertExpectations(t)
741 func TestRemoveAllSuccessfully(t *testing.T) {
744 mKeysExpected := string("{namespace},*")
745 mKeysReturn := []string{"{namespace},key1", "{namespace},key2"}
746 mDelExpected := mKeysReturn
747 m.On("Keys", mKeysExpected).Return(mKeysReturn, nil)
748 m.On("Del", mDelExpected).Return(nil)
751 m.AssertExpectations(t)
754 func TestRemoveAllNoKeysFound(t *testing.T) {
757 mKeysExpected := string("{namespace},*")
758 var mKeysReturn []string = nil
759 m.On("Keys", mKeysExpected).Return(mKeysReturn, nil)
760 m.AssertNumberOfCalls(t, "Del", 0)
763 m.AssertExpectations(t)
766 func TestRemoveAllKeysReturnError(t *testing.T) {
769 mKeysExpected := string("{namespace},*")
770 var mKeysReturn []string = nil
771 m.On("Keys", mKeysExpected).Return(mKeysReturn, errors.New("Some error"))
772 m.AssertNumberOfCalls(t, "Del", 0)
774 assert.NotNil(t, err)
775 m.AssertExpectations(t)
778 func TestRemoveAllDelReturnError(t *testing.T) {
781 mKeysExpected := string("{namespace},*")
782 mKeysReturn := []string{"{namespace},key1", "{namespace},key2"}
783 mDelExpected := mKeysReturn
784 m.On("Keys", mKeysExpected).Return(mKeysReturn, nil)
785 m.On("Del", mDelExpected).Return(errors.New("Some Error"))
787 assert.NotNil(t, err)
788 m.AssertExpectations(t)
791 func TestSetIfSuccessfullyOkStatus(t *testing.T) {
794 mSetIEExpectedKey := string("{namespace},key1")
795 mSetIEExpectedOldData := interface{}("olddata")
796 mSetIEExpectedNewData := interface{}("newdata")
797 m.On("SetIE", mSetIEExpectedKey, mSetIEExpectedOldData, mSetIEExpectedNewData).Return(true, nil)
798 status, err := i.SetIf("key1", "olddata", "newdata")
800 assert.True(t, status)
801 m.AssertExpectations(t)
804 func TestSetIfSuccessfullyNOKStatus(t *testing.T) {
807 mSetIEExpectedKey := string("{namespace},key1")
808 mSetIEExpectedOldData := interface{}("olddata")
809 mSetIEExpectedNewData := interface{}("newdata")
810 m.On("SetIE", mSetIEExpectedKey, mSetIEExpectedOldData, mSetIEExpectedNewData).Return(false, nil)
811 status, err := i.SetIf("key1", "olddata", "newdata")
813 assert.False(t, status)
814 m.AssertExpectations(t)
817 func TestSetIfFailure(t *testing.T) {
820 mSetIEExpectedKey := string("{namespace},key1")
821 mSetIEExpectedOldData := interface{}("olddata")
822 mSetIEExpectedNewData := interface{}("newdata")
823 m.On("SetIE", mSetIEExpectedKey, mSetIEExpectedOldData, mSetIEExpectedNewData).Return(false, errors.New("Some error"))
824 status, err := i.SetIf("key1", "olddata", "newdata")
825 assert.NotNil(t, err)
826 assert.False(t, status)
827 m.AssertExpectations(t)
830 func TestSetIfAndPublishSuccessfully(t *testing.T) {
833 expectedChannelAndEvent := []string{"{namespace},channel", "event"}
834 expectedKey := "{namespace},key"
835 expectedOldData := interface{}("olddata")
836 expectedNewData := interface{}("newdata")
837 m.On("SetIEPub", expectedChannelAndEvent, expectedKey, expectedOldData, expectedNewData).Return(true, nil)
838 status, err := i.SetIfAndPublish([]string{"channel", "event"}, "key", "olddata", "newdata")
840 assert.True(t, status)
841 m.AssertExpectations(t)
844 func TestSetIfAndPublishIncorrectChannelAndEvent(t *testing.T) {
847 expectedChannelAndEvent := []string{"{namespace},channel", "event"}
848 expectedKey := "{namespace},key"
849 expectedOldData := interface{}("olddata")
850 expectedNewData := interface{}("newdata")
851 m.AssertNotCalled(t, "SetIEPub", expectedChannelAndEvent, expectedKey, expectedOldData, expectedNewData)
852 m.AssertNotCalled(t, "SetIE", expectedKey, expectedOldData, expectedNewData)
853 status, err := i.SetIfAndPublish([]string{"channel", "event1", "channel"}, "key", "olddata", "newdata")
854 assert.NotNil(t, err)
855 assert.False(t, status)
856 m.AssertExpectations(t)
858 func TestSetIfAndPublishNOKStatus(t *testing.T) {
861 expectedChannelAndEvent := []string{"{namespace},channel", "event"}
862 expectedKey := "{namespace},key"
863 expectedOldData := interface{}("olddata")
864 expectedNewData := interface{}("newdata")
865 m.On("SetIEPub", expectedChannelAndEvent, expectedKey, expectedOldData, expectedNewData).Return(false, nil)
866 status, err := i.SetIfAndPublish([]string{"channel", "event"}, "key", "olddata", "newdata")
868 assert.False(t, status)
869 m.AssertExpectations(t)
872 func TestSetIfAndPublishNoChannels(t *testing.T) {
875 expectedKey := "{namespace},key"
876 expectedOldData := interface{}("olddata")
877 expectedNewData := interface{}("newdata")
878 m.On("SetIE", expectedKey, expectedOldData, expectedNewData).Return(true, nil)
879 status, err := i.SetIfAndPublish([]string{}, "key", "olddata", "newdata")
881 assert.True(t, status)
882 m.AssertExpectations(t)
885 func TestSetIfNotExistsAndPublishSuccessfully(t *testing.T) {
888 expectedChannelAndEvent := []string{"{namespace},channel", "event"}
889 expectedKey := "{namespace},key"
890 expectedData := interface{}("data")
892 m.On("SetNXPub", expectedChannelAndEvent, expectedKey, expectedData).Return(true, nil)
893 status, err := i.SetIfNotExistsAndPublish([]string{"channel", "event"}, "key", "data")
895 assert.True(t, status)
896 m.AssertExpectations(t)
899 func TestSetIfNotExistsAndPublishSeveralEvents(t *testing.T) {
902 expectedChannelAndEvent := []string{"{namespace},channel", "event1___event2"}
903 expectedKey := "{namespace},key"
904 expectedData := interface{}("data")
906 m.On("SetNXPub", expectedChannelAndEvent, expectedKey, expectedData).Return(true, nil)
907 status, err := i.SetIfNotExistsAndPublish([]string{"channel", "event1", "channel", "event2"}, "key", "data")
909 assert.True(t, status)
910 m.AssertExpectations(t)
913 func TestSetIfNotExistsAndPublishNoChannels(t *testing.T) {
916 expectedKey := "{namespace},key"
917 expectedData := interface{}("data")
919 m.On("SetNX", expectedKey, expectedData, time.Duration(0)).Return(true, nil)
920 status, err := i.SetIfNotExistsAndPublish([]string{}, "key", "data")
922 assert.True(t, status)
923 m.AssertExpectations(t)
926 func TestSetIfNotExistsAndPublishFail(t *testing.T) {
929 expectedChannelAndEvent := []string{"{namespace},channel", "event"}
930 expectedKey := "{namespace},key"
931 expectedData := interface{}("data")
933 m.On("SetNXPub", expectedChannelAndEvent, expectedKey, expectedData).Return(false, nil)
934 status, err := i.SetIfNotExistsAndPublish([]string{"channel", "event"}, "key", "data")
936 assert.False(t, status)
937 m.AssertExpectations(t)
940 func TestSetIfNotExistsAndPublishIncorrectChannels(t *testing.T) {
943 expectedChannelAndEvent := []string{"{namespace},channel", "event"}
944 expectedKey := "{namespace},key"
945 expectedData := interface{}("data")
947 m.AssertNotCalled(t, "SetNXPub", expectedChannelAndEvent, expectedKey, expectedData)
948 m.AssertNotCalled(t, "SetNX", expectedKey, expectedData, 0)
949 status, err := i.SetIfNotExistsAndPublish([]string{"channel", "event", "channel2"}, "key", "data")
950 assert.NotNil(t, err)
951 assert.False(t, status)
952 m.AssertExpectations(t)
955 func TestSetIfNotExistsAndPublishError(t *testing.T) {
958 expectedChannelAndEvent := []string{"{namespace},channel", "event"}
959 expectedKey := "{namespace},key"
960 expectedData := interface{}("data")
962 m.On("SetNXPub", expectedChannelAndEvent, expectedKey, expectedData).Return(false, errors.New("Some error"))
963 status, err := i.SetIfNotExistsAndPublish([]string{"channel", "event"}, "key", "data")
964 assert.NotNil(t, err)
965 assert.False(t, status)
966 m.AssertExpectations(t)
969 func TestSetIfNotExistsSuccessfullyOkStatus(t *testing.T) {
972 mSetNXExpectedKey := string("{namespace},key1")
973 mSetNXExpectedData := interface{}("data")
974 m.On("SetNX", mSetNXExpectedKey, mSetNXExpectedData, time.Duration(0)).Return(true, nil)
975 status, err := i.SetIfNotExists("key1", "data")
977 assert.True(t, status)
978 m.AssertExpectations(t)
981 func TestSetIfNotExistsSuccessfullyNOKStatus(t *testing.T) {
984 mSetNXExpectedKey := string("{namespace},key1")
985 mSetNXExpectedData := interface{}("data")
986 m.On("SetNX", mSetNXExpectedKey, mSetNXExpectedData, time.Duration(0)).Return(false, nil)
987 status, err := i.SetIfNotExists("key1", "data")
989 assert.False(t, status)
990 m.AssertExpectations(t)
993 func TestSetIfNotExistsFailure(t *testing.T) {
996 mSetNXExpectedKey := string("{namespace},key1")
997 mSetNXExpectedData := interface{}("data")
998 m.On("SetNX", mSetNXExpectedKey, mSetNXExpectedData, time.Duration(0)).Return(false, errors.New("Some error"))
999 status, err := i.SetIfNotExists("key1", "data")
1000 assert.NotNil(t, err)
1001 assert.False(t, status)
1002 m.AssertExpectations(t)
1005 func TestRemoveIfAndPublishSuccessfully(t *testing.T) {
1008 expectedChannelAndEvent := []string{"{namespace},channel", "event1___event2"}
1009 expectedKey := "{namespace},key"
1010 expectedValue := interface{}("data")
1012 m.On("DelIEPub", expectedChannelAndEvent, expectedKey, expectedValue).Return(true, nil)
1013 status, err := i.RemoveIfAndPublish([]string{"channel", "event1", "channel", "event2"}, "key", "data")
1015 assert.True(t, status)
1016 m.AssertExpectations(t)
1019 func TestRemoveIfAndPublishNok(t *testing.T) {
1022 expectedChannelAndEvent := []string{"{namespace},channel", "event1___event2"}
1023 expectedKey := "{namespace},key"
1024 expectedValue := interface{}("data")
1026 m.On("DelIEPub", expectedChannelAndEvent, expectedKey, expectedValue).Return(false, nil)
1027 status, err := i.RemoveIfAndPublish([]string{"channel", "event1", "channel", "event2"}, "key", "data")
1029 assert.False(t, status)
1030 m.AssertExpectations(t)
1033 func TestRemoveIfAndPublishError(t *testing.T) {
1036 expectedChannelAndEvent := []string{"{namespace},channel", "event1___event2"}
1037 expectedKey := "{namespace},key"
1038 expectedValue := interface{}("data")
1040 m.On("DelIEPub", expectedChannelAndEvent, expectedKey, expectedValue).Return(false, errors.New("Some error"))
1041 status, err := i.RemoveIfAndPublish([]string{"channel", "event1", "channel", "event2"}, "key", "data")
1042 assert.NotNil(t, err)
1043 assert.False(t, status)
1044 m.AssertExpectations(t)
1047 func TestRemoveIfAndPublishIncorrectChannel(t *testing.T) {
1050 expectedChannelAndEvent := []string{"{namespace},channel", "event"}
1051 expectedKey := "{namespace},key"
1052 expectedValue := interface{}("data")
1054 m.AssertNotCalled(t, "DelIEPub", expectedChannelAndEvent, expectedKey, expectedValue)
1055 m.AssertNotCalled(t, "DelIE", expectedKey, expectedValue)
1056 status, err := i.RemoveIfAndPublish([]string{"channel", "event1", "channel"}, "key", "data")
1057 assert.NotNil(t, err)
1058 assert.False(t, status)
1059 m.AssertExpectations(t)
1062 func TestRemoveIfAndPublishNoChannels(t *testing.T) {
1065 expectedKey := "{namespace},key"
1066 expectedValue := interface{}("data")
1068 m.On("DelIE", expectedKey, expectedValue).Return(true, nil)
1069 status, err := i.RemoveIfAndPublish([]string{}, "key", "data")
1071 assert.True(t, status)
1072 m.AssertExpectations(t)
1075 func TestRemoveIfSuccessfullyOkStatus(t *testing.T) {
1078 mDelIEExpectedKey := string("{namespace},key1")
1079 mDelIEExpectedData := interface{}("data")
1080 m.On("DelIE", mDelIEExpectedKey, mDelIEExpectedData).Return(true, nil)
1081 status, err := i.RemoveIf("key1", "data")
1083 assert.True(t, status)
1084 m.AssertExpectations(t)
1087 func TestRemoveIfSuccessfullyNOKStatus(t *testing.T) {
1090 mDelIEExpectedKey := string("{namespace},key1")
1091 mDelIEExpectedData := interface{}("data")
1092 m.On("DelIE", mDelIEExpectedKey, mDelIEExpectedData).Return(false, nil)
1093 status, err := i.RemoveIf("key1", "data")
1095 assert.False(t, status)
1096 m.AssertExpectations(t)
1099 func TestRemoveIfFailure(t *testing.T) {
1102 mDelIEExpectedKey := string("{namespace},key1")
1103 mDelIEExpectedData := interface{}("data")
1104 m.On("DelIE", mDelIEExpectedKey, mDelIEExpectedData).Return(true, errors.New("Some error"))
1105 status, err := i.RemoveIf("key1", "data")
1106 assert.NotNil(t, err)
1107 assert.False(t, status)
1108 m.AssertExpectations(t)
1111 func TestRemoveAllAndPublishSuccessfully(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.On("DelMPub", expectedChannelAndEvent, mDelExpected).Return(nil)
1120 err := i.RemoveAllAndPublish([]string{"channel", "event"})
1122 m.AssertExpectations(t)
1125 func TestRemoveAllAndPublishKeysReturnError(t *testing.T) {
1128 mKeysExpected := string("{namespace},*")
1129 mKeysReturn := []string{"{namespace},key1", "{namespace},key2"}
1130 mDelExpected := mKeysReturn
1131 expectedChannelAndEvent := []string{"{namespace},channel", "event"}
1132 m.On("Keys", mKeysExpected).Return(mKeysReturn, errors.New("Some error"))
1133 m.AssertNotCalled(t, "DelMPub", expectedChannelAndEvent, mDelExpected)
1134 err := i.RemoveAllAndPublish([]string{"channel", "event"})
1135 assert.NotNil(t, err)
1136 m.AssertExpectations(t)
1139 func TestRemoveAllAndPublishKeysDelReturnsError(t *testing.T) {
1142 mKeysExpected := string("{namespace},*")
1143 mKeysReturn := []string{"{namespace},key1", "{namespace},key2"}
1144 mDelExpected := mKeysReturn
1145 expectedChannelAndEvent := []string{"{namespace},channel", "event"}
1146 m.On("Keys", mKeysExpected).Return(mKeysReturn, nil)
1147 m.On("DelMPub", expectedChannelAndEvent, mDelExpected).Return(errors.New("Some error"))
1148 err := i.RemoveAllAndPublish([]string{"channel", "event"})
1149 assert.NotNil(t, err)
1150 m.AssertExpectations(t)
1153 func TestRemoveAllAndPublishKeysEventsWithIllegalCharacters(t *testing.T) {
1156 mKeysExpected := string("{namespace},*")
1157 mKeysReturn := []string{"{namespace},key1", "{namespace},key2"}
1158 mDelExpected := mKeysReturn
1159 expectedChannelAndEvent := []string{"{namespace},channel", "event"}
1160 m.On("Keys", mKeysExpected).Return(mKeysReturn, nil)
1161 m.AssertNotCalled(t, "DelMPub", expectedChannelAndEvent, mDelExpected)
1162 err := i.RemoveAllAndPublish([]string{"channel", "event___anotherEvent"})
1163 assert.NotNil(t, err)
1164 m.AssertExpectations(t)
1168 func TestRemoveAllAndPublishNoChannels(t *testing.T) {
1171 mKeysExpected := string("{namespace},*")
1172 mKeysReturn := []string{"{namespace},key1", "{namespace},key2"}
1173 mDelExpected := mKeysReturn
1174 m.On("Keys", mKeysExpected).Return(mKeysReturn, nil)
1175 m.On("Del", mDelExpected).Return(nil)
1176 m.AssertNotCalled(t, "DelMPub", "", "", mDelExpected)
1177 err := i.RemoveAllAndPublish([]string{})
1179 m.AssertExpectations(t)
1182 func TestRemoveAllAndPublishIncorrectChannel(t *testing.T) {
1185 mKeysExpected := string("{namespace},*")
1186 mKeysReturn := []string{"{namespace},key1", "{namespace},key2"}
1187 mDelExpected := mKeysReturn
1188 m.On("Keys", mKeysExpected).Return(mKeysReturn, nil)
1189 m.AssertNotCalled(t, "DelMPub", "", "", mDelExpected)
1190 err := i.RemoveAllAndPublish([]string{"channel", "event", "channel2"})
1191 assert.NotNil(t, err)
1192 m.AssertExpectations(t)
1196 func TestAddMemberSuccessfully(t *testing.T) {
1199 groupExpected := string("{namespace},group")
1200 membersExpected := []interface{}{"member1", "member2"}
1202 m.On("SAdd", groupExpected, membersExpected).Return(nil)
1204 err := i.AddMember("group", "member1", "member2")
1206 m.AssertExpectations(t)
1209 func TestAddMemberFail(t *testing.T) {
1212 groupExpected := string("{namespace},group")
1213 membersExpected := []interface{}{"member1", "member2"}
1215 m.On("SAdd", groupExpected, membersExpected).Return(errors.New("Some error"))
1217 err := i.AddMember("group", "member1", "member2")
1218 assert.NotNil(t, err)
1219 m.AssertExpectations(t)
1221 func TestRemoveMemberSuccessfully(t *testing.T) {
1224 groupExpected := string("{namespace},group")
1225 membersExpected := []interface{}{"member1", "member2"}
1227 m.On("SRem", groupExpected, membersExpected).Return(nil)
1229 err := i.RemoveMember("group", "member1", "member2")
1231 m.AssertExpectations(t)
1234 func TestRemoveMemberFail(t *testing.T) {
1237 groupExpected := string("{namespace},group")
1238 membersExpected := []interface{}{"member1", "member2"}
1240 m.On("SRem", groupExpected, membersExpected).Return(errors.New("Some error"))
1242 err := i.RemoveMember("group", "member1", "member2")
1243 assert.NotNil(t, err)
1244 m.AssertExpectations(t)
1247 func TestRemoveGroupSuccessfully(t *testing.T) {
1250 groupExpected := []string{"{namespace},group"}
1252 m.On("Del", groupExpected).Return(nil)
1254 err := i.RemoveGroup("group")
1256 m.AssertExpectations(t)
1258 func TestRemoveGroupFail(t *testing.T) {
1261 groupExpected := []string{"{namespace},group"}
1263 m.On("Del", groupExpected).Return(errors.New("Some error"))
1265 err := i.RemoveGroup("group")
1266 assert.NotNil(t, err)
1267 m.AssertExpectations(t)
1270 func TestGetMembersSuccessfully(t *testing.T) {
1273 groupExpected := "{namespace},group"
1274 returnExpected := []string{"member1", "member2"}
1276 m.On("SMembers", groupExpected).Return(returnExpected, nil)
1278 result, err := i.GetMembers("group")
1280 assert.Equal(t, result, returnExpected)
1281 m.AssertExpectations(t)
1283 func TestGetMembersFail(t *testing.T) {
1286 groupExpected := "{namespace},group"
1287 returnExpected := []string{"member1", "member2"}
1289 m.On("SMembers", groupExpected).Return(returnExpected, errors.New("Some error"))
1291 result, err := i.GetMembers("group")
1292 assert.NotNil(t, err)
1293 assert.Equal(t, []string{}, result)
1294 m.AssertExpectations(t)
1297 func TestIsMemberSuccessfullyIsMember(t *testing.T) {
1300 groupExpected := "{namespace},group"
1301 memberExpected := "member"
1303 m.On("SIsMember", groupExpected, memberExpected).Return(true, nil)
1305 result, err := i.IsMember("group", "member")
1307 assert.True(t, result)
1308 m.AssertExpectations(t)
1310 func TestIsMemberSuccessfullyIsNotMember(t *testing.T) {
1313 groupExpected := "{namespace},group"
1314 memberExpected := "member"
1316 m.On("SIsMember", groupExpected, memberExpected).Return(false, nil)
1318 result, err := i.IsMember("group", "member")
1320 assert.False(t, result)
1321 m.AssertExpectations(t)
1323 func TestIsMemberFailure(t *testing.T) {
1326 groupExpected := "{namespace},group"
1327 memberExpected := "member"
1329 m.On("SIsMember", groupExpected, memberExpected).Return(true, errors.New("Some error"))
1331 result, err := i.IsMember("group", "member")
1332 assert.NotNil(t, err)
1333 assert.False(t, result)
1334 m.AssertExpectations(t)
1337 func TestGroupSizeSuccessfully(t *testing.T) {
1340 var expectedSize int64
1342 groupExpected := "{namespace},group"
1344 m.On("SCard", groupExpected).Return(expectedSize, nil)
1346 result, err := i.GroupSize("group")
1348 assert.Equal(t, expectedSize, result)
1349 m.AssertExpectations(t)
1351 func TestGroupSizeFail(t *testing.T) {
1354 var expectedSize int64
1356 groupExpected := "{namespace},group"
1358 m.On("SCard", groupExpected).Return(expectedSize, errors.New("Some error"))
1360 result, err := i.GroupSize("group")
1361 assert.NotNil(t, err)
1362 assert.Equal(t, int64(0), result)
1363 m.AssertExpectations(t)
1366 func TestLockResourceSuccessfully(t *testing.T) {
1369 resourceExpected := "{namespace},resource"
1370 m.On("SetNX", resourceExpected, mock.Anything, time.Duration(1)).Return(true, nil)
1372 lock, err := i.LockResource("resource", time.Duration(1), &sdlgo.Options{})
1374 assert.NotNil(t, lock)
1375 m.AssertExpectations(t)
1378 func TestLockResourceFailure(t *testing.T) {
1381 resourceExpected := "{namespace},resource"
1382 m.On("SetNX", resourceExpected, mock.Anything, time.Duration(1)).Return(true, errors.New("Some error"))
1384 lock, err := i.LockResource("resource", time.Duration(1), &sdlgo.Options{})
1385 assert.NotNil(t, err)
1387 m.AssertExpectations(t)
1390 func TestLockResourceTrySeveralTimesSuccessfully(t *testing.T) {
1393 resourceExpected := "{namespace},resource"
1394 m.On("SetNX", resourceExpected, mock.Anything, time.Duration(1)).Return(false, nil).Once()
1395 m.On("SetNX", resourceExpected, mock.Anything, time.Duration(1)).Return(true, nil).Once()
1397 lock, err := i.LockResource("resource", time.Duration(1), &sdlgo.Options{
1401 assert.NotNil(t, lock)
1402 m.AssertExpectations(t)
1405 func TestLockResourceTrySeveralTimesFailure(t *testing.T) {
1408 resourceExpected := "{namespace},resource"
1409 m.On("SetNX", resourceExpected, mock.Anything, time.Duration(1)).Return(false, nil).Once()
1410 m.On("SetNX", resourceExpected, mock.Anything, time.Duration(1)).Return(true, errors.New("Some error")).Once()
1412 lock, err := i.LockResource("resource", time.Duration(1), &sdlgo.Options{
1415 assert.NotNil(t, err)
1417 m.AssertExpectations(t)
1420 func TestLockResourceTrySeveralTimesUnableToGetResource(t *testing.T) {
1423 resourceExpected := "{namespace},resource"
1424 m.On("SetNX", resourceExpected, mock.Anything, time.Duration(1)).Return(false, nil).Once()
1425 m.On("SetNX", resourceExpected, mock.Anything, time.Duration(1)).Return(false, nil).Once()
1427 lock, err := i.LockResource("resource", time.Duration(1), &sdlgo.Options{
1430 assert.NotNil(t, err)
1431 assert.EqualError(t, err, "Lock not obtained")
1433 m.AssertExpectations(t)
1436 func TestReleaseResourceSuccessfully(t *testing.T) {
1439 resourceExpected := "{namespace},resource"
1440 m.On("SetNX", resourceExpected, mock.Anything, time.Duration(1)).Return(true, nil).Once()
1441 m.On("DelIE", resourceExpected, mock.Anything).Return(true, nil).Once()
1443 lock, err := i.LockResource("resource", time.Duration(1), &sdlgo.Options{
1446 err2 := lock.ReleaseResource()
1448 assert.NotNil(t, lock)
1450 m.AssertExpectations(t)
1453 func TestReleaseResourceFailure(t *testing.T) {
1456 resourceExpected := "{namespace},resource"
1457 m.On("SetNX", resourceExpected, mock.Anything, time.Duration(1)).Return(true, nil).Once()
1458 m.On("DelIE", resourceExpected, mock.Anything).Return(true, errors.New("Some error")).Once()
1460 lock, err := i.LockResource("resource", time.Duration(1), &sdlgo.Options{
1463 err2 := lock.ReleaseResource()
1465 assert.NotNil(t, lock)
1466 assert.NotNil(t, err2)
1467 m.AssertExpectations(t)
1470 func TestReleaseResourceLockNotHeld(t *testing.T) {
1473 resourceExpected := "{namespace},resource"
1474 m.On("SetNX", resourceExpected, mock.Anything, time.Duration(1)).Return(true, nil).Once()
1475 m.On("DelIE", resourceExpected, mock.Anything).Return(false, nil).Once()
1477 lock, err := i.LockResource("resource", time.Duration(1), &sdlgo.Options{
1480 err2 := lock.ReleaseResource()
1482 assert.NotNil(t, lock)
1483 assert.NotNil(t, err2)
1484 assert.EqualError(t, err2, "Lock not held")
1485 m.AssertExpectations(t)
1488 func TestRefreshResourceSuccessfully(t *testing.T) {
1491 resourceExpected := "{namespace},resource"
1492 m.On("SetNX", resourceExpected, mock.Anything, time.Duration(1)).Return(true, nil).Once()
1493 m.On("PExpireIE", resourceExpected, mock.Anything, time.Duration(1)).Return(nil).Once()
1495 lock, err := i.LockResource("resource", time.Duration(1), &sdlgo.Options{
1498 err2 := lock.RefreshResource(time.Duration(1))
1500 assert.NotNil(t, lock)
1502 m.AssertExpectations(t)
1505 func TestRefreshResourceFailure(t *testing.T) {
1508 resourceExpected := "{namespace},resource"
1509 m.On("SetNX", resourceExpected, mock.Anything, time.Duration(1)).Return(true, nil).Once()
1510 m.On("PExpireIE", resourceExpected, mock.Anything, time.Duration(1)).Return(errors.New("Some error")).Once()
1512 lock, err := i.LockResource("resource", time.Duration(1), &sdlgo.Options{
1515 err2 := lock.RefreshResource(time.Duration(1))
1517 assert.NotNil(t, lock)
1518 assert.NotNil(t, err2)
1519 m.AssertExpectations(t)
1522 func TestCheckResourceSuccessfully(t *testing.T) {
1525 resourceExpected := "{namespace},resource"
1526 m.On("PTTL", resourceExpected).Return(time.Duration(1), nil)
1527 result, err := i.CheckResource("resource")
1529 assert.Equal(t, result, time.Duration(1))
1530 m.AssertExpectations(t)
1533 func TestCheckResourceFailure(t *testing.T) {
1536 resourceExpected := "{namespace},resource"
1537 m.On("PTTL", resourceExpected).Return(time.Duration(1), errors.New("Some error"))
1538 result, err := i.CheckResource("resource")
1539 assert.NotNil(t, err)
1540 assert.EqualError(t, err, "Some error")
1541 assert.Equal(t, result, time.Duration(0))
1542 m.AssertExpectations(t)
1545 func TestCheckResourceInvalidResource(t *testing.T) {
1548 resourceExpected := "{namespace},resource"
1549 m.On("PTTL", resourceExpected).Return(time.Duration(-1), nil)
1550 result, err := i.CheckResource("resource")
1551 assert.NotNil(t, err)
1552 assert.EqualError(t, err, "invalid resource given, no expiration time attached")
1553 assert.Equal(t, result, time.Duration(0))
1554 m.AssertExpectations(t)