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), channelPrefix, eventSeparator string, channels ...string) {
41 m.Called(cb, channelPrefix, eventSeparator, channels)
44 func (m *mockDB) UnsubscribeChannelDB(channels ...string) {
48 func (m *mockDB) MSet(pairs ...interface{}) error {
53 func (m *mockDB) MSetMPub(channelsAndEvents []string, pairs ...interface{}) error {
54 a := m.Called(channelsAndEvents, pairs)
58 func (m *mockDB) MGet(keys []string) ([]interface{}, error) {
60 return a.Get(0).([]interface{}), a.Error(1)
63 func (m *mockDB) CloseDB() error {
68 func (m *mockDB) Del(keys []string) error {
73 func (m *mockDB) DelMPub(channelsAndEvents []string, keys []string) error {
74 a := m.Called(channelsAndEvents, keys)
78 func (m *mockDB) Keys(pattern string) ([]string, error) {
79 a := m.Called(pattern)
80 return a.Get(0).([]string), a.Error(1)
83 func (m *mockDB) SetIE(key string, oldData, newData interface{}) (bool, error) {
84 a := m.Called(key, oldData, newData)
85 return a.Bool(0), a.Error(1)
88 func (m *mockDB) SetIEPub(channelsAndEvents []string, key string, oldData, newData interface{}) (bool, error) {
89 a := m.Called(channelsAndEvents, key, oldData, newData)
90 return a.Bool(0), a.Error(1)
93 func (m *mockDB) SetNX(key string, data interface{}, expiration time.Duration) (bool, error) {
94 a := m.Called(key, data, expiration)
95 return a.Bool(0), a.Error(1)
98 func (m *mockDB) SetNXPub(channelsAndEvents []string, key string, data interface{}) (bool, error) {
99 a := m.Called(channelsAndEvents, key, data)
100 return a.Bool(0), a.Error(1)
103 func (m *mockDB) DelIE(key string, data interface{}) (bool, error) {
104 a := m.Called(key, data)
105 return a.Bool(0), a.Error(1)
108 func (m *mockDB) DelIEPub(channelsAndEvents []string, key string, data interface{}) (bool, error) {
109 a := m.Called(channelsAndEvents, key, data)
110 return a.Bool(0), a.Error(1)
113 func (m *mockDB) SAdd(key string, data ...interface{}) error {
114 a := m.Called(key, data)
118 func (m *mockDB) SRem(key string, data ...interface{}) error {
119 a := m.Called(key, data)
122 func (m *mockDB) SMembers(key string) ([]string, error) {
124 return a.Get(0).([]string), a.Error(1)
127 func (m *mockDB) SIsMember(key string, data interface{}) (bool, error) {
128 a := m.Called(key, data)
129 return a.Bool(0), a.Error(1)
132 func (m *mockDB) SCard(key string) (int64, error) {
134 return a.Get(0).(int64), a.Error(1)
137 func (m *mockDB) PTTL(key string) (time.Duration, error) {
139 return a.Get(0).(time.Duration), a.Error(1)
142 func (m *mockDB) PExpireIE(key string, data interface{}, expiration time.Duration) error {
143 a := m.Called(key, data, expiration)
147 func setup() (*mockDB, *sdlgo.SdlInstance) {
149 i := sdlgo.NewSdlInstanceForTest("namespace", m)
153 func verifySliceInOrder(a, b []string) bool {
154 for i, v := range a {
157 for j, x := range b {
158 if j%2 == 0 && x == v && a[i+1] == b[j+1] {
172 func TestClose(t *testing.T) {
175 m.On("CloseDB").Return(nil)
178 m.AssertExpectations(t)
181 func TestCloseReturnError(t *testing.T) {
184 m.On("CloseDB").Return(errors.New("Some error"))
186 assert.NotNil(t, err)
187 m.AssertExpectations(t)
190 func TestSubscribeChannel(t *testing.T) {
193 expectedCB := func(channel string, events ...string) {}
194 expectedChannels := []string{"{namespace},channel1", "{namespace},channel2"}
196 m.On("SubscribeChannelDB", mock.AnythingOfType("func(string, ...string)"), "{namespace},", "___", expectedChannels).Return()
197 i.SubscribeChannel(expectedCB, "channel1", "channel2")
198 m.AssertExpectations(t)
201 func TestUnsubscribeChannel(t *testing.T) {
204 expectedChannels := []string{"{namespace},channel1", "{namespace},channel2"}
206 m.On("UnsubscribeChannelDB", expectedChannels).Return()
207 i.UnsubscribeChannel("channel1", "channel2")
208 m.AssertExpectations(t)
210 func TestGetOneKey(t *testing.T) {
213 mgetExpected := []string{"{namespace},key"}
214 mReturn := []interface{}{"somevalue"}
215 mReturnExpected := make(map[string]interface{})
216 mReturnExpected["key"] = "somevalue"
218 m.On("MGet", mgetExpected).Return(mReturn, nil)
219 retVal, err := i.Get([]string{"key"})
221 assert.Equal(t, mReturnExpected, retVal)
222 m.AssertExpectations(t)
225 func TestGetSeveralKeys(t *testing.T) {
228 mgetExpected := []string{"{namespace},key1", "{namespace},key2", "{namespace},key3"}
229 mReturn := []interface{}{"somevalue1", 2, "someothervalue"}
230 mReturnExpected := make(map[string]interface{})
231 mReturnExpected["key1"] = "somevalue1"
232 mReturnExpected["key2"] = 2
233 mReturnExpected["key3"] = "someothervalue"
235 m.On("MGet", mgetExpected).Return(mReturn, nil)
236 retVal, err := i.Get([]string{"key1", "key2", "key3"})
238 assert.Equal(t, mReturnExpected, retVal)
239 m.AssertExpectations(t)
242 func TestGetSeveralKeysSomeFail(t *testing.T) {
245 mgetExpected := []string{"{namespace},key1", "{namespace},key2", "{namespace},key3"}
246 mReturn := []interface{}{"somevalue1", nil, "someothervalue"}
247 mReturnExpected := make(map[string]interface{})
248 mReturnExpected["key1"] = "somevalue1"
249 mReturnExpected["key2"] = nil
250 mReturnExpected["key3"] = "someothervalue"
252 m.On("MGet", mgetExpected).Return(mReturn, nil)
253 retVal, err := i.Get([]string{"key1", "key2", "key3"})
255 assert.Equal(t, mReturnExpected, retVal)
256 m.AssertExpectations(t)
259 func TestGetKeyReturnError(t *testing.T) {
262 mgetExpected := []string{"{namespace},key"}
263 mReturn := []interface{}{nil}
264 mReturnExpected := make(map[string]interface{})
266 m.On("MGet", mgetExpected).Return(mReturn, errors.New("Some error"))
267 retVal, err := i.Get([]string{"key"})
268 assert.NotNil(t, err)
269 assert.Equal(t, mReturnExpected, retVal)
270 m.AssertExpectations(t)
273 func TestGetEmptyList(t *testing.T) {
276 mgetExpected := []string{}
278 retval, err := i.Get([]string{})
280 assert.Len(t, retval, 0)
281 m.AssertNotCalled(t, "MGet", mgetExpected)
284 func TestWriteOneKey(t *testing.T) {
287 msetExpected := []interface{}{"{namespace},key1", "data1"}
289 m.On("MSet", msetExpected).Return(nil)
290 err := i.Set("key1", "data1")
292 m.AssertExpectations(t)
295 func TestWriteByteSliceAsValue(t *testing.T) {
298 msetExpected := []interface{}{"{namespace},key1", []byte{1, 2, 3, 4, 5}}
300 m.On("MSet", msetExpected).Return(nil)
301 err := i.Set("key1", []byte{1, 2, 3, 4, 5})
303 m.AssertExpectations(t)
306 func TestWriteByteSliceAsValueMixed(t *testing.T) {
309 msetExpected := []interface{}{"{namespace},key1", []byte{1, 2, 3, 4, 5}, "{namespace},key2", "value2"}
311 m.On("MSet", msetExpected).Return(nil)
312 err := i.Set("key1", []byte{1, 2, 3, 4, 5}, []string{"key2", "value2"})
314 m.AssertExpectations(t)
317 func TestWriteByteArrayAsValue(t *testing.T) {
320 msetExpected := []interface{}{"{namespace},key1", [5]byte{1, 2, 3, 4, 5}}
322 m.On("MSet", msetExpected).Return(nil)
323 err := i.Set("key1", [5]byte{1, 2, 3, 4, 5})
325 m.AssertExpectations(t)
328 func TestWriteMapAsInput(t *testing.T) {
331 setExpected := []interface{}{"{namespace},key1", "string123",
332 "{namespace},key22", 12,
333 "{namespace},key333", []byte{1, 2, 3, 4, 5}}
334 inputMap := map[string]interface{}{
337 "key333": []byte{1, 2, 3, 4, 5},
340 m.On("MSet", mock.MatchedBy(func(input []interface{}) bool {
341 for _, v := range input {
343 for _, x := range setExpected {
344 found = reflect.DeepEqual(x, v)
356 err := i.Set(inputMap)
358 m.AssertExpectations(t)
361 func TestWriteMixed(t *testing.T) {
364 msetExpected := []interface{}{"{namespace},key1", "data1", "{namespace},key2", "data2", "{namespace},key3", "data3"}
366 m.On("MSet", msetExpected).Return(nil)
367 err := i.Set("key1", "data1", []string{"key2", "data2"}, [2]string{"key3", "data3"})
369 m.AssertExpectations(t)
372 func TestWriteIncorrectMixed(t *testing.T) {
375 msetExpected := []interface{}{"{namespace},key1", "data1", "{namespace},key2", "data2", "{namespace},key3", "data3"}
377 m.AssertNotCalled(t, "MSet", msetExpected)
378 err := i.Set("key1", []string{"key2", "data2"}, [2]string{"key3", "data3"})
379 assert.NotNil(t, err)
380 m.AssertExpectations(t)
382 func TestWriteIncorrectPairs(t *testing.T) {
385 msetExpected := []interface{}{}
387 m.AssertNotCalled(t, "MSet", msetExpected)
389 assert.NotNil(t, err)
390 m.AssertExpectations(t)
392 func TestWriteSeveralKeysSlice(t *testing.T) {
395 msetExpected := []interface{}{"{namespace},key1", "data1", "{namespace},key2", 22}
397 m.On("MSet", msetExpected).Return(nil)
398 err := i.Set([]interface{}{"key1", "data1", "key2", 22})
400 m.AssertExpectations(t)
404 func TestWriteSeveralKeysIncorrectSlice(t *testing.T) {
407 msetExpected := []interface{}{"{namespace},key1", "data1", "{namespace},key2", 22}
409 m.AssertNotCalled(t, "MSet", msetExpected)
410 err := i.Set([]interface{}{"key1", "data1", "key2"})
411 assert.NotNil(t, err)
412 m.AssertExpectations(t)
416 func TestWriteSeveralKeysArray(t *testing.T) {
419 msetExpected := []interface{}{"{namespace},key1", "data1", "{namespace},key2", "data2"}
421 m.On("MSet", msetExpected).Return(nil)
422 err := i.Set([4]string{"key1", "data1", "key2", "data2"})
424 m.AssertExpectations(t)
427 func TestWriteSeveralKeysIncorrectArray(t *testing.T) {
430 msetExpected := []interface{}{}
432 m.AssertNotCalled(t, "MSet", msetExpected)
433 err := i.Set([3]string{"key1", "data1", "key2"})
434 assert.NotNil(t, err)
435 m.AssertExpectations(t)
438 func TestWriteFail(t *testing.T) {
441 msetExpected := []interface{}{"{namespace},key1", "data1"}
443 m.On("MSet", msetExpected).Return(errors.New("Some error"))
444 err := i.Set("key1", "data1")
445 assert.NotNil(t, err)
446 m.AssertExpectations(t)
449 func TestWriteEmptyList(t *testing.T) {
452 msetExpected := []interface{}{}
455 m.AssertNotCalled(t, "MSet", msetExpected)
458 func TestWriteAndPublishOneKeyOneChannel(t *testing.T) {
461 expectedChannelAndEvent := []string{"{namespace},channel", "event"}
462 expectedKeyVal := []interface{}{"{namespace},key1", "data1"}
464 m.On("MSetMPub", expectedChannelAndEvent, expectedKeyVal).Return(nil)
465 m.AssertNotCalled(t, "MSet", expectedKeyVal)
466 err := i.SetAndPublish([]string{"channel", "event"}, "key1", "data1")
468 m.AssertExpectations(t)
471 func TestWriteAndPublishSeveralChannelsAndEvents(t *testing.T) {
474 expectedChannelsAndEvents := []string{"{namespace},channel1", "event1___event2",
475 "{namespace},channel2", "event3___event4"}
476 expectedKeyVal := []interface{}{"{namespace},key", "data"}
478 verifyChannelAndEvent := func(input []string) bool {
479 return verifySliceInOrder(input, expectedChannelsAndEvents)
481 m.On("MSetMPub", mock.MatchedBy(verifyChannelAndEvent), expectedKeyVal).Return(nil)
482 m.AssertNotCalled(t, "MSet", expectedKeyVal)
483 err := i.SetAndPublish([]string{"channel1", "event1", "channel2", "event3", "channel1", "event2", "channel2", "event4"},
486 m.AssertExpectations(t)
489 func TestWriteAndPublishOneKeyOneChannelTwoEvents(t *testing.T) {
492 expectedChannelAndEvents := []string{"{namespace},channel", "event1___event2"}
493 expectedKeyVal := []interface{}{"{namespace},key1", "data1"}
495 m.On("MSetMPub", expectedChannelAndEvents, expectedKeyVal).Return(nil)
496 m.AssertNotCalled(t, "MSet", expectedKeyVal)
497 err := i.SetAndPublish([]string{"channel", "event1", "channel", "event2"}, "key1", "data1")
499 m.AssertExpectations(t)
502 func TestWriteAndPublishIncorrectChannelAndEvent(t *testing.T) {
505 expectedChannelAndEvent := []string{}
506 expectedKeyVal := []interface{}{"{namespace},key1", "data1"}
507 m.AssertNotCalled(t, "MSetMPub", expectedChannelAndEvent, expectedKeyVal)
508 m.AssertNotCalled(t, "MSet", expectedKeyVal)
509 err := i.SetAndPublish([]string{"channel", "event1", "channel"}, "key1", "data1")
510 assert.NotNil(t, err)
511 m.AssertExpectations(t)
514 func TestWriteAndPublishNotAllowedCharactersInEvents(t *testing.T) {
517 expectedChannelAndEvent := []string{}
518 expectedKeyVal := []interface{}{"{namespace},key1", "data1"}
519 m.AssertNotCalled(t, "MSetMPub", expectedChannelAndEvent, expectedKeyVal)
520 m.AssertNotCalled(t, "MSet", expectedKeyVal)
521 err := i.SetAndPublish([]string{"channel", "event1___event2"}, "key1", "data1")
522 assert.NotNil(t, err)
523 m.AssertExpectations(t)
526 func TestWriteAndPublishNoData(t *testing.T) {
529 expectedChannelAndEvent := []string{}
530 expectedKeyVal := []interface{}{"key"}
532 m.AssertNotCalled(t, "MSetMPub", expectedChannelAndEvent, expectedKeyVal)
533 m.AssertNotCalled(t, "MSet", expectedKeyVal)
534 err := i.SetAndPublish([]string{"channel", "event"}, []interface{}{"key"})
535 assert.NotNil(t, err)
536 m.AssertExpectations(t)
539 func TestWriteAndPublishNoChannelEvent(t *testing.T) {
542 expectedKeyVal := []interface{}{"{namespace},key1", "data1"}
544 m.On("MSet", expectedKeyVal).Return(nil)
545 m.AssertNotCalled(t, "MSetMPub", "", "", expectedKeyVal)
546 err := i.SetAndPublish([]string{}, "key1", "data1")
548 m.AssertExpectations(t)
552 func TestRemoveAndPublishSuccessfully(t *testing.T) {
555 expectedChannelAndEvent := []string{"{namespace},channel", "event"}
556 expectedKeys := []string{"{namespace},key1", "{namespace},key2"}
558 m.On("DelMPub", expectedChannelAndEvent, expectedKeys).Return(nil)
559 err := i.RemoveAndPublish([]string{"channel", "event"}, []string{"key1", "key2"})
561 m.AssertExpectations(t)
564 func TestRemoveAndPublishSeveralChannelsAndEventsSuccessfully(t *testing.T) {
567 expectedChannelAndEvent := []string{"{namespace},channel1", "event1___event2",
568 "{namespace},channel2", "event3___event4"}
569 expectedKeys := []string{"{namespace},key1", "{namespace},key2"}
571 verifyChannelAndEvent := func(input []string) bool {
572 return verifySliceInOrder(input, expectedChannelAndEvent)
574 m.On("DelMPub", mock.MatchedBy(verifyChannelAndEvent), expectedKeys).Return(nil)
575 err := i.RemoveAndPublish([]string{"channel1", "event1", "channel2", "event3",
576 "channel1", "event2", "channel2", "event4"},
577 []string{"key1", "key2"})
579 m.AssertExpectations(t)
581 func TestRemoveAndPublishFail(t *testing.T) {
584 expectedChannelAndEvent := []string{"{namespace},channel", "event"}
585 expectedKeys := []string{"{namespace},key1", "{namespace},key2"}
587 m.On("DelMPub", expectedChannelAndEvent, expectedKeys).Return(errors.New("Some error"))
588 err := i.RemoveAndPublish([]string{"channel", "event"}, []string{"key1", "key2"})
589 assert.NotNil(t, err)
590 m.AssertExpectations(t)
593 func TestRemoveAndPublishNoChannels(t *testing.T) {
596 expectedKeys := []string{"{namespace},key1", "{namespace},key2"}
598 m.On("Del", expectedKeys).Return(nil)
599 err := i.RemoveAndPublish([]string{}, []string{"key1", "key2"})
601 m.AssertExpectations(t)
604 func TestRemoveAndPublishIncorrectChannel(t *testing.T) {
607 notExpectedChannelAndEvent := []string{}
608 notExpectedKeys := []string{"{namespace},key"}
610 m.AssertNotCalled(t, "DelMPub", notExpectedChannelAndEvent, notExpectedKeys)
611 m.AssertNotCalled(t, "Del", notExpectedKeys)
612 err := i.RemoveAndPublish([]string{"channel", "event", "channel2"}, []string{"key1", "key2"})
613 assert.NotNil(t, err)
614 m.AssertExpectations(t)
617 func TestRemoveAndPublishNoKeys(t *testing.T) {
620 notExpectedChannelAndEvent := []string{}
621 notExpectedKeys := []string{"{namespace},key"}
623 m.AssertNotCalled(t, "DelMPub", notExpectedChannelAndEvent, notExpectedKeys)
624 m.AssertNotCalled(t, "Del", notExpectedKeys)
625 err := i.RemoveAndPublish([]string{"channel", "event"}, []string{})
627 m.AssertExpectations(t)
629 func TestRemoveAndPublishNoChannelsError(t *testing.T) {
632 expectedKeys := []string{"{namespace},key1", "{namespace},key2"}
634 m.On("Del", expectedKeys).Return(errors.New("Some error"))
635 err := i.RemoveAndPublish([]string{}, []string{"key1", "key2"})
636 assert.NotNil(t, err)
637 m.AssertExpectations(t)
639 func TestRemoveSuccessfully(t *testing.T) {
642 msetExpected := []string{"{namespace},key1", "{namespace},key2"}
643 m.On("Del", msetExpected).Return(nil)
645 err := i.Remove([]string{"key1", "key2"})
647 m.AssertExpectations(t)
650 func TestRemoveFail(t *testing.T) {
653 msetExpected := []string{"{namespace},key"}
654 m.On("Del", msetExpected).Return(errors.New("Some error"))
656 err := i.Remove([]string{"key"})
657 assert.NotNil(t, err)
658 m.AssertExpectations(t)
661 func TestRemoveEmptyList(t *testing.T) {
664 err := i.Remove([]string{})
666 m.AssertNotCalled(t, "Del", []string{})
669 func TestGetAllSuccessfully(t *testing.T) {
672 mKeysExpected := string("{namespace},*")
673 mReturnExpected := []string{"{namespace},key1", "{namespace},key2"}
674 expectedReturn := []string{"key1", "key2"}
675 m.On("Keys", mKeysExpected).Return(mReturnExpected, nil)
676 retVal, err := i.GetAll()
678 assert.Equal(t, expectedReturn, retVal)
679 m.AssertExpectations(t)
682 func TestGetAllFail(t *testing.T) {
685 mKeysExpected := string("{namespace},*")
686 mReturnExpected := []string{}
687 m.On("Keys", mKeysExpected).Return(mReturnExpected, errors.New("some error"))
688 retVal, err := i.GetAll()
689 assert.NotNil(t, err)
690 assert.Nil(t, retVal)
691 assert.Equal(t, len(retVal), 0)
692 m.AssertExpectations(t)
695 func TestGetAllReturnEmpty(t *testing.T) {
698 mKeysExpected := string("{namespace},*")
699 var mReturnExpected []string = nil
700 m.On("Keys", mKeysExpected).Return(mReturnExpected, nil)
701 retVal, err := i.GetAll()
703 assert.Nil(t, retVal)
704 assert.Equal(t, len(retVal), 0)
705 m.AssertExpectations(t)
709 func TestRemoveAllSuccessfully(t *testing.T) {
712 mKeysExpected := string("{namespace},*")
713 mKeysReturn := []string{"{namespace},key1", "{namespace},key2"}
714 mDelExpected := mKeysReturn
715 m.On("Keys", mKeysExpected).Return(mKeysReturn, nil)
716 m.On("Del", mDelExpected).Return(nil)
719 m.AssertExpectations(t)
722 func TestRemoveAllNoKeysFound(t *testing.T) {
725 mKeysExpected := string("{namespace},*")
726 var mKeysReturn []string = nil
727 m.On("Keys", mKeysExpected).Return(mKeysReturn, nil)
728 m.AssertNumberOfCalls(t, "Del", 0)
731 m.AssertExpectations(t)
734 func TestRemoveAllKeysReturnError(t *testing.T) {
737 mKeysExpected := string("{namespace},*")
738 var mKeysReturn []string = nil
739 m.On("Keys", mKeysExpected).Return(mKeysReturn, errors.New("Some error"))
740 m.AssertNumberOfCalls(t, "Del", 0)
742 assert.NotNil(t, err)
743 m.AssertExpectations(t)
746 func TestRemoveAllDelReturnError(t *testing.T) {
749 mKeysExpected := string("{namespace},*")
750 mKeysReturn := []string{"{namespace},key1", "{namespace},key2"}
751 mDelExpected := mKeysReturn
752 m.On("Keys", mKeysExpected).Return(mKeysReturn, nil)
753 m.On("Del", mDelExpected).Return(errors.New("Some Error"))
755 assert.NotNil(t, err)
756 m.AssertExpectations(t)
759 func TestSetIfSuccessfullyOkStatus(t *testing.T) {
762 mSetIEExpectedKey := string("{namespace},key1")
763 mSetIEExpectedOldData := interface{}("olddata")
764 mSetIEExpectedNewData := interface{}("newdata")
765 m.On("SetIE", mSetIEExpectedKey, mSetIEExpectedOldData, mSetIEExpectedNewData).Return(true, nil)
766 status, err := i.SetIf("key1", "olddata", "newdata")
768 assert.True(t, status)
769 m.AssertExpectations(t)
772 func TestSetIfSuccessfullyNOKStatus(t *testing.T) {
775 mSetIEExpectedKey := string("{namespace},key1")
776 mSetIEExpectedOldData := interface{}("olddata")
777 mSetIEExpectedNewData := interface{}("newdata")
778 m.On("SetIE", mSetIEExpectedKey, mSetIEExpectedOldData, mSetIEExpectedNewData).Return(false, nil)
779 status, err := i.SetIf("key1", "olddata", "newdata")
781 assert.False(t, status)
782 m.AssertExpectations(t)
785 func TestSetIfFailure(t *testing.T) {
788 mSetIEExpectedKey := string("{namespace},key1")
789 mSetIEExpectedOldData := interface{}("olddata")
790 mSetIEExpectedNewData := interface{}("newdata")
791 m.On("SetIE", mSetIEExpectedKey, mSetIEExpectedOldData, mSetIEExpectedNewData).Return(false, errors.New("Some error"))
792 status, err := i.SetIf("key1", "olddata", "newdata")
793 assert.NotNil(t, err)
794 assert.False(t, status)
795 m.AssertExpectations(t)
798 func TestSetIfAndPublishSuccessfully(t *testing.T) {
801 expectedChannelAndEvent := []string{"{namespace},channel", "event"}
802 expectedKey := "{namespace},key"
803 expectedOldData := interface{}("olddata")
804 expectedNewData := interface{}("newdata")
805 m.On("SetIEPub", expectedChannelAndEvent, expectedKey, expectedOldData, expectedNewData).Return(true, nil)
806 status, err := i.SetIfAndPublish([]string{"channel", "event"}, "key", "olddata", "newdata")
808 assert.True(t, status)
809 m.AssertExpectations(t)
812 func TestSetIfAndPublishIncorrectChannelAndEvent(t *testing.T) {
815 expectedChannelAndEvent := []string{"{namespace},channel", "event"}
816 expectedKey := "{namespace},key"
817 expectedOldData := interface{}("olddata")
818 expectedNewData := interface{}("newdata")
819 m.AssertNotCalled(t, "SetIEPub", expectedChannelAndEvent, expectedKey, expectedOldData, expectedNewData)
820 m.AssertNotCalled(t, "SetIE", expectedKey, expectedOldData, expectedNewData)
821 status, err := i.SetIfAndPublish([]string{"channel", "event1", "channel"}, "key", "olddata", "newdata")
822 assert.NotNil(t, err)
823 assert.False(t, status)
824 m.AssertExpectations(t)
826 func TestSetIfAndPublishNOKStatus(t *testing.T) {
829 expectedChannelAndEvent := []string{"{namespace},channel", "event"}
830 expectedKey := "{namespace},key"
831 expectedOldData := interface{}("olddata")
832 expectedNewData := interface{}("newdata")
833 m.On("SetIEPub", expectedChannelAndEvent, expectedKey, expectedOldData, expectedNewData).Return(false, nil)
834 status, err := i.SetIfAndPublish([]string{"channel", "event"}, "key", "olddata", "newdata")
836 assert.False(t, status)
837 m.AssertExpectations(t)
840 func TestSetIfAndPublishNoChannels(t *testing.T) {
843 expectedKey := "{namespace},key"
844 expectedOldData := interface{}("olddata")
845 expectedNewData := interface{}("newdata")
846 m.On("SetIE", expectedKey, expectedOldData, expectedNewData).Return(true, nil)
847 status, err := i.SetIfAndPublish([]string{}, "key", "olddata", "newdata")
849 assert.True(t, status)
850 m.AssertExpectations(t)
853 func TestSetIfNotExistsAndPublishSuccessfully(t *testing.T) {
856 expectedChannelAndEvent := []string{"{namespace},channel", "event"}
857 expectedKey := "{namespace},key"
858 expectedData := interface{}("data")
860 m.On("SetNXPub", expectedChannelAndEvent, expectedKey, expectedData).Return(true, nil)
861 status, err := i.SetIfNotExistsAndPublish([]string{"channel", "event"}, "key", "data")
863 assert.True(t, status)
864 m.AssertExpectations(t)
867 func TestSetIfNotExistsAndPublishSeveralEvents(t *testing.T) {
870 expectedChannelAndEvent := []string{"{namespace},channel", "event1___event2"}
871 expectedKey := "{namespace},key"
872 expectedData := interface{}("data")
874 m.On("SetNXPub", expectedChannelAndEvent, expectedKey, expectedData).Return(true, nil)
875 status, err := i.SetIfNotExistsAndPublish([]string{"channel", "event1", "channel", "event2"}, "key", "data")
877 assert.True(t, status)
878 m.AssertExpectations(t)
881 func TestSetIfNotExistsAndPublishNoChannels(t *testing.T) {
884 expectedKey := "{namespace},key"
885 expectedData := interface{}("data")
887 m.On("SetNX", expectedKey, expectedData, time.Duration(0)).Return(true, nil)
888 status, err := i.SetIfNotExistsAndPublish([]string{}, "key", "data")
890 assert.True(t, status)
891 m.AssertExpectations(t)
894 func TestSetIfNotExistsAndPublishFail(t *testing.T) {
897 expectedChannelAndEvent := []string{"{namespace},channel", "event"}
898 expectedKey := "{namespace},key"
899 expectedData := interface{}("data")
901 m.On("SetNXPub", expectedChannelAndEvent, expectedKey, expectedData).Return(false, nil)
902 status, err := i.SetIfNotExistsAndPublish([]string{"channel", "event"}, "key", "data")
904 assert.False(t, status)
905 m.AssertExpectations(t)
908 func TestSetIfNotExistsAndPublishIncorrectChannels(t *testing.T) {
911 expectedChannelAndEvent := []string{"{namespace},channel", "event"}
912 expectedKey := "{namespace},key"
913 expectedData := interface{}("data")
915 m.AssertNotCalled(t, "SetNXPub", expectedChannelAndEvent, expectedKey, expectedData)
916 m.AssertNotCalled(t, "SetNX", expectedKey, expectedData, 0)
917 status, err := i.SetIfNotExistsAndPublish([]string{"channel", "event", "channel2"}, "key", "data")
918 assert.NotNil(t, err)
919 assert.False(t, status)
920 m.AssertExpectations(t)
923 func TestSetIfNotExistsAndPublishError(t *testing.T) {
926 expectedChannelAndEvent := []string{"{namespace},channel", "event"}
927 expectedKey := "{namespace},key"
928 expectedData := interface{}("data")
930 m.On("SetNXPub", expectedChannelAndEvent, expectedKey, expectedData).Return(false, errors.New("Some error"))
931 status, err := i.SetIfNotExistsAndPublish([]string{"channel", "event"}, "key", "data")
932 assert.NotNil(t, err)
933 assert.False(t, status)
934 m.AssertExpectations(t)
937 func TestSetIfNotExistsSuccessfullyOkStatus(t *testing.T) {
940 mSetNXExpectedKey := string("{namespace},key1")
941 mSetNXExpectedData := interface{}("data")
942 m.On("SetNX", mSetNXExpectedKey, mSetNXExpectedData, time.Duration(0)).Return(true, nil)
943 status, err := i.SetIfNotExists("key1", "data")
945 assert.True(t, status)
946 m.AssertExpectations(t)
949 func TestSetIfNotExistsSuccessfullyNOKStatus(t *testing.T) {
952 mSetNXExpectedKey := string("{namespace},key1")
953 mSetNXExpectedData := interface{}("data")
954 m.On("SetNX", mSetNXExpectedKey, mSetNXExpectedData, time.Duration(0)).Return(false, nil)
955 status, err := i.SetIfNotExists("key1", "data")
957 assert.False(t, status)
958 m.AssertExpectations(t)
961 func TestSetIfNotExistsFailure(t *testing.T) {
964 mSetNXExpectedKey := string("{namespace},key1")
965 mSetNXExpectedData := interface{}("data")
966 m.On("SetNX", mSetNXExpectedKey, mSetNXExpectedData, time.Duration(0)).Return(false, errors.New("Some error"))
967 status, err := i.SetIfNotExists("key1", "data")
968 assert.NotNil(t, err)
969 assert.False(t, status)
970 m.AssertExpectations(t)
973 func TestRemoveIfAndPublishSuccessfully(t *testing.T) {
976 expectedChannelAndEvent := []string{"{namespace},channel", "event1___event2"}
977 expectedKey := "{namespace},key"
978 expectedValue := interface{}("data")
980 m.On("DelIEPub", expectedChannelAndEvent, expectedKey, expectedValue).Return(true, nil)
981 status, err := i.RemoveIfAndPublish([]string{"channel", "event1", "channel", "event2"}, "key", "data")
983 assert.True(t, status)
984 m.AssertExpectations(t)
987 func TestRemoveIfAndPublishNok(t *testing.T) {
990 expectedChannelAndEvent := []string{"{namespace},channel", "event1___event2"}
991 expectedKey := "{namespace},key"
992 expectedValue := interface{}("data")
994 m.On("DelIEPub", expectedChannelAndEvent, expectedKey, expectedValue).Return(false, nil)
995 status, err := i.RemoveIfAndPublish([]string{"channel", "event1", "channel", "event2"}, "key", "data")
997 assert.False(t, status)
998 m.AssertExpectations(t)
1001 func TestRemoveIfAndPublishError(t *testing.T) {
1004 expectedChannelAndEvent := []string{"{namespace},channel", "event1___event2"}
1005 expectedKey := "{namespace},key"
1006 expectedValue := interface{}("data")
1008 m.On("DelIEPub", expectedChannelAndEvent, expectedKey, expectedValue).Return(false, errors.New("Some error"))
1009 status, err := i.RemoveIfAndPublish([]string{"channel", "event1", "channel", "event2"}, "key", "data")
1010 assert.NotNil(t, err)
1011 assert.False(t, status)
1012 m.AssertExpectations(t)
1015 func TestRemoveIfAndPublishIncorrectChannel(t *testing.T) {
1018 expectedChannelAndEvent := []string{"{namespace},channel", "event"}
1019 expectedKey := "{namespace},key"
1020 expectedValue := interface{}("data")
1022 m.AssertNotCalled(t, "DelIEPub", expectedChannelAndEvent, expectedKey, expectedValue)
1023 m.AssertNotCalled(t, "DelIE", expectedKey, expectedValue)
1024 status, err := i.RemoveIfAndPublish([]string{"channel", "event1", "channel"}, "key", "data")
1025 assert.NotNil(t, err)
1026 assert.False(t, status)
1027 m.AssertExpectations(t)
1030 func TestRemoveIfAndPublishNoChannels(t *testing.T) {
1033 expectedKey := "{namespace},key"
1034 expectedValue := interface{}("data")
1036 m.On("DelIE", expectedKey, expectedValue).Return(true, nil)
1037 status, err := i.RemoveIfAndPublish([]string{}, "key", "data")
1039 assert.True(t, status)
1040 m.AssertExpectations(t)
1043 func TestRemoveIfSuccessfullyOkStatus(t *testing.T) {
1046 mDelIEExpectedKey := string("{namespace},key1")
1047 mDelIEExpectedData := interface{}("data")
1048 m.On("DelIE", mDelIEExpectedKey, mDelIEExpectedData).Return(true, nil)
1049 status, err := i.RemoveIf("key1", "data")
1051 assert.True(t, status)
1052 m.AssertExpectations(t)
1055 func TestRemoveIfSuccessfullyNOKStatus(t *testing.T) {
1058 mDelIEExpectedKey := string("{namespace},key1")
1059 mDelIEExpectedData := interface{}("data")
1060 m.On("DelIE", mDelIEExpectedKey, mDelIEExpectedData).Return(false, nil)
1061 status, err := i.RemoveIf("key1", "data")
1063 assert.False(t, status)
1064 m.AssertExpectations(t)
1067 func TestRemoveIfFailure(t *testing.T) {
1070 mDelIEExpectedKey := string("{namespace},key1")
1071 mDelIEExpectedData := interface{}("data")
1072 m.On("DelIE", mDelIEExpectedKey, mDelIEExpectedData).Return(true, errors.New("Some error"))
1073 status, err := i.RemoveIf("key1", "data")
1074 assert.NotNil(t, err)
1075 assert.False(t, status)
1076 m.AssertExpectations(t)
1079 func TestRemoveAllAndPublishSuccessfully(t *testing.T) {
1082 mKeysExpected := string("{namespace},*")
1083 mKeysReturn := []string{"{namespace},key1", "{namespace},key2"}
1084 mDelExpected := mKeysReturn
1085 expectedChannelAndEvent := []string{"{namespace},channel", "event"}
1086 m.On("Keys", mKeysExpected).Return(mKeysReturn, nil)
1087 m.On("DelMPub", expectedChannelAndEvent, mDelExpected).Return(nil)
1088 err := i.RemoveAllAndPublish([]string{"channel", "event"})
1090 m.AssertExpectations(t)
1093 func TestRemoveAllAndPublishKeysReturnError(t *testing.T) {
1096 mKeysExpected := string("{namespace},*")
1097 mKeysReturn := []string{"{namespace},key1", "{namespace},key2"}
1098 mDelExpected := mKeysReturn
1099 expectedChannelAndEvent := []string{"{namespace},channel", "event"}
1100 m.On("Keys", mKeysExpected).Return(mKeysReturn, errors.New("Some error"))
1101 m.AssertNotCalled(t, "DelMPub", expectedChannelAndEvent, mDelExpected)
1102 err := i.RemoveAllAndPublish([]string{"channel", "event"})
1103 assert.NotNil(t, err)
1104 m.AssertExpectations(t)
1107 func TestRemoveAllAndPublishKeysDelReturnsError(t *testing.T) {
1110 mKeysExpected := string("{namespace},*")
1111 mKeysReturn := []string{"{namespace},key1", "{namespace},key2"}
1112 mDelExpected := mKeysReturn
1113 expectedChannelAndEvent := []string{"{namespace},channel", "event"}
1114 m.On("Keys", mKeysExpected).Return(mKeysReturn, nil)
1115 m.On("DelMPub", expectedChannelAndEvent, mDelExpected).Return(errors.New("Some error"))
1116 err := i.RemoveAllAndPublish([]string{"channel", "event"})
1117 assert.NotNil(t, err)
1118 m.AssertExpectations(t)
1121 func TestRemoveAllAndPublishKeysEventsWithIllegalCharacters(t *testing.T) {
1124 mKeysExpected := string("{namespace},*")
1125 mKeysReturn := []string{"{namespace},key1", "{namespace},key2"}
1126 mDelExpected := mKeysReturn
1127 expectedChannelAndEvent := []string{"{namespace},channel", "event"}
1128 m.On("Keys", mKeysExpected).Return(mKeysReturn, nil)
1129 m.AssertNotCalled(t, "DelMPub", expectedChannelAndEvent, mDelExpected)
1130 err := i.RemoveAllAndPublish([]string{"channel", "event___anotherEvent"})
1131 assert.NotNil(t, err)
1132 m.AssertExpectations(t)
1136 func TestRemoveAllAndPublishNoChannels(t *testing.T) {
1139 mKeysExpected := string("{namespace},*")
1140 mKeysReturn := []string{"{namespace},key1", "{namespace},key2"}
1141 mDelExpected := mKeysReturn
1142 m.On("Keys", mKeysExpected).Return(mKeysReturn, nil)
1143 m.On("Del", mDelExpected).Return(nil)
1144 m.AssertNotCalled(t, "DelMPub", "", "", mDelExpected)
1145 err := i.RemoveAllAndPublish([]string{})
1147 m.AssertExpectations(t)
1150 func TestRemoveAllAndPublishIncorrectChannel(t *testing.T) {
1153 mKeysExpected := string("{namespace},*")
1154 mKeysReturn := []string{"{namespace},key1", "{namespace},key2"}
1155 mDelExpected := mKeysReturn
1156 m.On("Keys", mKeysExpected).Return(mKeysReturn, nil)
1157 m.AssertNotCalled(t, "DelMPub", "", "", mDelExpected)
1158 err := i.RemoveAllAndPublish([]string{"channel", "event", "channel2"})
1159 assert.NotNil(t, err)
1160 m.AssertExpectations(t)
1164 func TestAddMemberSuccessfully(t *testing.T) {
1167 groupExpected := string("{namespace},group")
1168 membersExpected := []interface{}{"member1", "member2"}
1170 m.On("SAdd", groupExpected, membersExpected).Return(nil)
1172 err := i.AddMember("group", "member1", "member2")
1174 m.AssertExpectations(t)
1177 func TestAddMemberFail(t *testing.T) {
1180 groupExpected := string("{namespace},group")
1181 membersExpected := []interface{}{"member1", "member2"}
1183 m.On("SAdd", groupExpected, membersExpected).Return(errors.New("Some error"))
1185 err := i.AddMember("group", "member1", "member2")
1186 assert.NotNil(t, err)
1187 m.AssertExpectations(t)
1189 func TestRemoveMemberSuccessfully(t *testing.T) {
1192 groupExpected := string("{namespace},group")
1193 membersExpected := []interface{}{"member1", "member2"}
1195 m.On("SRem", groupExpected, membersExpected).Return(nil)
1197 err := i.RemoveMember("group", "member1", "member2")
1199 m.AssertExpectations(t)
1202 func TestRemoveMemberFail(t *testing.T) {
1205 groupExpected := string("{namespace},group")
1206 membersExpected := []interface{}{"member1", "member2"}
1208 m.On("SRem", groupExpected, membersExpected).Return(errors.New("Some error"))
1210 err := i.RemoveMember("group", "member1", "member2")
1211 assert.NotNil(t, err)
1212 m.AssertExpectations(t)
1215 func TestRemoveGroupSuccessfully(t *testing.T) {
1218 groupExpected := []string{"{namespace},group"}
1220 m.On("Del", groupExpected).Return(nil)
1222 err := i.RemoveGroup("group")
1224 m.AssertExpectations(t)
1226 func TestRemoveGroupFail(t *testing.T) {
1229 groupExpected := []string{"{namespace},group"}
1231 m.On("Del", groupExpected).Return(errors.New("Some error"))
1233 err := i.RemoveGroup("group")
1234 assert.NotNil(t, err)
1235 m.AssertExpectations(t)
1238 func TestGetMembersSuccessfully(t *testing.T) {
1241 groupExpected := "{namespace},group"
1242 returnExpected := []string{"member1", "member2"}
1244 m.On("SMembers", groupExpected).Return(returnExpected, nil)
1246 result, err := i.GetMembers("group")
1248 assert.Equal(t, result, returnExpected)
1249 m.AssertExpectations(t)
1251 func TestGetMembersFail(t *testing.T) {
1254 groupExpected := "{namespace},group"
1255 returnExpected := []string{"member1", "member2"}
1257 m.On("SMembers", groupExpected).Return(returnExpected, errors.New("Some error"))
1259 result, err := i.GetMembers("group")
1260 assert.NotNil(t, err)
1261 assert.Equal(t, []string{}, result)
1262 m.AssertExpectations(t)
1265 func TestIsMemberSuccessfullyIsMember(t *testing.T) {
1268 groupExpected := "{namespace},group"
1269 memberExpected := "member"
1271 m.On("SIsMember", groupExpected, memberExpected).Return(true, nil)
1273 result, err := i.IsMember("group", "member")
1275 assert.True(t, result)
1276 m.AssertExpectations(t)
1278 func TestIsMemberSuccessfullyIsNotMember(t *testing.T) {
1281 groupExpected := "{namespace},group"
1282 memberExpected := "member"
1284 m.On("SIsMember", groupExpected, memberExpected).Return(false, nil)
1286 result, err := i.IsMember("group", "member")
1288 assert.False(t, result)
1289 m.AssertExpectations(t)
1291 func TestIsMemberFailure(t *testing.T) {
1294 groupExpected := "{namespace},group"
1295 memberExpected := "member"
1297 m.On("SIsMember", groupExpected, memberExpected).Return(true, errors.New("Some error"))
1299 result, err := i.IsMember("group", "member")
1300 assert.NotNil(t, err)
1301 assert.False(t, result)
1302 m.AssertExpectations(t)
1305 func TestGroupSizeSuccessfully(t *testing.T) {
1308 var expectedSize int64
1310 groupExpected := "{namespace},group"
1312 m.On("SCard", groupExpected).Return(expectedSize, nil)
1314 result, err := i.GroupSize("group")
1316 assert.Equal(t, expectedSize, result)
1317 m.AssertExpectations(t)
1319 func TestGroupSizeFail(t *testing.T) {
1322 var expectedSize int64
1324 groupExpected := "{namespace},group"
1326 m.On("SCard", groupExpected).Return(expectedSize, errors.New("Some error"))
1328 result, err := i.GroupSize("group")
1329 assert.NotNil(t, err)
1330 assert.Equal(t, int64(0), result)
1331 m.AssertExpectations(t)
1334 func TestLockResourceSuccessfully(t *testing.T) {
1337 resourceExpected := "{namespace},resource"
1338 m.On("SetNX", resourceExpected, mock.Anything, time.Duration(1)).Return(true, nil)
1340 lock, err := i.LockResource("resource", time.Duration(1), &sdlgo.Options{})
1342 assert.NotNil(t, lock)
1343 m.AssertExpectations(t)
1346 func TestLockResourceFailure(t *testing.T) {
1349 resourceExpected := "{namespace},resource"
1350 m.On("SetNX", resourceExpected, mock.Anything, time.Duration(1)).Return(true, errors.New("Some error"))
1352 lock, err := i.LockResource("resource", time.Duration(1), &sdlgo.Options{})
1353 assert.NotNil(t, err)
1355 m.AssertExpectations(t)
1358 func TestLockResourceTrySeveralTimesSuccessfully(t *testing.T) {
1361 resourceExpected := "{namespace},resource"
1362 m.On("SetNX", resourceExpected, mock.Anything, time.Duration(1)).Return(false, nil).Once()
1363 m.On("SetNX", resourceExpected, mock.Anything, time.Duration(1)).Return(true, nil).Once()
1365 lock, err := i.LockResource("resource", time.Duration(1), &sdlgo.Options{
1369 assert.NotNil(t, lock)
1370 m.AssertExpectations(t)
1373 func TestLockResourceTrySeveralTimesFailure(t *testing.T) {
1376 resourceExpected := "{namespace},resource"
1377 m.On("SetNX", resourceExpected, mock.Anything, time.Duration(1)).Return(false, nil).Once()
1378 m.On("SetNX", resourceExpected, mock.Anything, time.Duration(1)).Return(true, errors.New("Some error")).Once()
1380 lock, err := i.LockResource("resource", time.Duration(1), &sdlgo.Options{
1383 assert.NotNil(t, err)
1385 m.AssertExpectations(t)
1388 func TestLockResourceTrySeveralTimesUnableToGetResource(t *testing.T) {
1391 resourceExpected := "{namespace},resource"
1392 m.On("SetNX", resourceExpected, mock.Anything, time.Duration(1)).Return(false, nil).Once()
1393 m.On("SetNX", resourceExpected, mock.Anything, time.Duration(1)).Return(false, nil).Once()
1395 lock, err := i.LockResource("resource", time.Duration(1), &sdlgo.Options{
1398 assert.NotNil(t, err)
1399 assert.EqualError(t, err, "Lock not obtained")
1401 m.AssertExpectations(t)
1404 func TestReleaseResourceSuccessfully(t *testing.T) {
1407 resourceExpected := "{namespace},resource"
1408 m.On("SetNX", resourceExpected, mock.Anything, time.Duration(1)).Return(true, nil).Once()
1409 m.On("DelIE", resourceExpected, mock.Anything).Return(true, nil).Once()
1411 lock, err := i.LockResource("resource", time.Duration(1), &sdlgo.Options{
1414 err2 := lock.ReleaseResource()
1416 assert.NotNil(t, lock)
1418 m.AssertExpectations(t)
1421 func TestReleaseResourceFailure(t *testing.T) {
1424 resourceExpected := "{namespace},resource"
1425 m.On("SetNX", resourceExpected, mock.Anything, time.Duration(1)).Return(true, nil).Once()
1426 m.On("DelIE", resourceExpected, mock.Anything).Return(true, errors.New("Some error")).Once()
1428 lock, err := i.LockResource("resource", time.Duration(1), &sdlgo.Options{
1431 err2 := lock.ReleaseResource()
1433 assert.NotNil(t, lock)
1434 assert.NotNil(t, err2)
1435 m.AssertExpectations(t)
1438 func TestReleaseResourceLockNotHeld(t *testing.T) {
1441 resourceExpected := "{namespace},resource"
1442 m.On("SetNX", resourceExpected, mock.Anything, time.Duration(1)).Return(true, nil).Once()
1443 m.On("DelIE", resourceExpected, mock.Anything).Return(false, nil).Once()
1445 lock, err := i.LockResource("resource", time.Duration(1), &sdlgo.Options{
1448 err2 := lock.ReleaseResource()
1450 assert.NotNil(t, lock)
1451 assert.NotNil(t, err2)
1452 assert.EqualError(t, err2, "Lock not held")
1453 m.AssertExpectations(t)
1456 func TestRefreshResourceSuccessfully(t *testing.T) {
1459 resourceExpected := "{namespace},resource"
1460 m.On("SetNX", resourceExpected, mock.Anything, time.Duration(1)).Return(true, nil).Once()
1461 m.On("PExpireIE", resourceExpected, mock.Anything, time.Duration(1)).Return(nil).Once()
1463 lock, err := i.LockResource("resource", time.Duration(1), &sdlgo.Options{
1466 err2 := lock.RefreshResource(time.Duration(1))
1468 assert.NotNil(t, lock)
1470 m.AssertExpectations(t)
1473 func TestRefreshResourceFailure(t *testing.T) {
1476 resourceExpected := "{namespace},resource"
1477 m.On("SetNX", resourceExpected, mock.Anything, time.Duration(1)).Return(true, nil).Once()
1478 m.On("PExpireIE", resourceExpected, mock.Anything, time.Duration(1)).Return(errors.New("Some error")).Once()
1480 lock, err := i.LockResource("resource", time.Duration(1), &sdlgo.Options{
1483 err2 := lock.RefreshResource(time.Duration(1))
1485 assert.NotNil(t, lock)
1486 assert.NotNil(t, err2)
1487 m.AssertExpectations(t)
1490 func TestCheckResourceSuccessfully(t *testing.T) {
1493 resourceExpected := "{namespace},resource"
1494 m.On("PTTL", resourceExpected).Return(time.Duration(1), nil)
1495 result, err := i.CheckResource("resource")
1497 assert.Equal(t, result, time.Duration(1))
1498 m.AssertExpectations(t)
1501 func TestCheckResourceFailure(t *testing.T) {
1504 resourceExpected := "{namespace},resource"
1505 m.On("PTTL", resourceExpected).Return(time.Duration(1), errors.New("Some error"))
1506 result, err := i.CheckResource("resource")
1507 assert.NotNil(t, err)
1508 assert.EqualError(t, err, "Some error")
1509 assert.Equal(t, result, time.Duration(0))
1510 m.AssertExpectations(t)
1513 func TestCheckResourceInvalidResource(t *testing.T) {
1516 resourceExpected := "{namespace},resource"
1517 m.On("PTTL", resourceExpected).Return(time.Duration(-1), nil)
1518 result, err := i.CheckResource("resource")
1519 assert.NotNil(t, err)
1520 assert.EqualError(t, err, "invalid resource given, no expiration time attached")
1521 assert.Equal(t, result, time.Duration(0))
1522 m.AssertExpectations(t)