limitations under the License.
*/
+/*
+ * This source code is part of the near-RT RIC (RAN Intelligent Controller)
+ * platform project (RICP).
+ */
+
package sdlgo_test
import (
"errors"
- "testing"
"reflect"
+ "testing"
+ "time"
"gerrit.o-ran-sc.org/r/ric-plt/sdlgo"
- "gerrit.o-ran-sc.org/r/ric-plt/sdlgo/internal/sdlgoredis"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/mock"
)
mock.Mock
}
-func (m *mockDB) SubscribeChannelDB(cb sdlgoredis.ChannelNotificationCb, channelPrefix, eventSeparator string, channels ...string) {
- m.Called(cb, channelPrefix, eventSeparator, channels)
+func (m *mockDB) SubscribeChannelDB(cb func(string, ...string), channels ...string) error {
+ a := m.Called(cb, channels)
+ return a.Error(0)
}
-func (m *mockDB) UnsubscribeChannelDB(channels ...string) {
- m.Called(channels)
+func (m *mockDB) UnsubscribeChannelDB(channels ...string) error {
+ a := m.Called(channels)
+ return a.Error(0)
}
func (m *mockDB) MSet(pairs ...interface{}) error {
return a.Bool(0), a.Error(1)
}
-func (m *mockDB) SetIEPub(channel, message, key string, oldData, newData interface{}) (bool, error) {
- a := m.Called(channel, message, key, oldData, newData)
+func (m *mockDB) SetIEPub(channelsAndEvents []string, key string, oldData, newData interface{}) (bool, error) {
+ a := m.Called(channelsAndEvents, key, oldData, newData)
return a.Bool(0), a.Error(1)
}
-func (m *mockDB) SetNX(key string, data interface{}) (bool, error) {
- a := m.Called(key, data)
+func (m *mockDB) SetNX(key string, data interface{}, expiration time.Duration) (bool, error) {
+ a := m.Called(key, data, expiration)
return a.Bool(0), a.Error(1)
}
-func (m *mockDB) SetNXPub(channel, message, key string, data interface{}) (bool, error) {
- a := m.Called(channel, message, key, data)
+func (m *mockDB) SetNXPub(channelsAndEvents []string, key string, data interface{}) (bool, error) {
+ a := m.Called(channelsAndEvents, key, data)
return a.Bool(0), a.Error(1)
}
return a.Bool(0), a.Error(1)
}
-func (m *mockDB) DelIEPub(channel, message, key string, data interface{}) (bool, error) {
- a := m.Called(channel, message, key, data)
+func (m *mockDB) DelIEPub(channelsAndEvents []string, key string, data interface{}) (bool, error) {
+ a := m.Called(channelsAndEvents, key, data)
return a.Bool(0), a.Error(1)
}
return a.Get(0).(int64), a.Error(1)
}
+func (m *mockDB) PTTL(key string) (time.Duration, error) {
+ a := m.Called(key)
+ return a.Get(0).(time.Duration), a.Error(1)
+}
+
+func (m *mockDB) PExpireIE(key string, data interface{}, expiration time.Duration) error {
+ a := m.Called(key, data, expiration)
+ return a.Error(0)
+}
+
func setup() (*mockDB, *sdlgo.SdlInstance) {
m := new(mockDB)
- i := sdlgo.NewSdlInstance("namespace", m)
+ i := sdlgo.NewSdlInstanceForTest("namespace", m)
return m, i
}
func verifySliceInOrder(a, b []string) bool {
- for i, v := range a {
- found := false
- if i%2 == 0 {
- for j, x := range b {
- if j%2 == 0 && x == v && a[i+1] == b[j+1] {
- found = true
- break
- }
- }
- if !found {
- return false
+ for i, v := range a {
+ found := false
+ if i%2 == 0 {
+ for j, x := range b {
+ if j%2 == 0 && x == v && a[i+1] == b[j+1] {
+ found = true
+ break
}
}
+ if !found {
+ return false
+ }
}
- return true
+ }
+ return true
}
+func TestClose(t *testing.T) {
+ m, i := setup()
+
+ m.On("CloseDB").Return(nil)
+ err := i.Close()
+ assert.Nil(t, err)
+ m.AssertExpectations(t)
+}
+
+func TestCloseReturnError(t *testing.T) {
+ m, i := setup()
+
+ m.On("CloseDB").Return(errors.New("Some error"))
+ err := i.Close()
+ assert.NotNil(t, err)
+ m.AssertExpectations(t)
+}
+
func TestSubscribeChannel(t *testing.T) {
m, i := setup()
expectedCB := func(channel string, events ...string) {}
expectedChannels := []string{"{namespace},channel1", "{namespace},channel2"}
- m.On("SubscribeChannelDB", mock.AnythingOfType("sdlgoredis.ChannelNotificationCb"), "{namespace},", "___", expectedChannels).Return()
- i.SubscribeChannel(expectedCB, "channel1", "channel2")
+ m.On("SubscribeChannelDB", mock.AnythingOfType("func(string, ...string)"), expectedChannels).Return(nil)
+ err := i.SubscribeChannel(expectedCB, "channel1", "channel2")
+ assert.Nil(t, err)
+ m.AssertExpectations(t)
+}
+
+func TestSubscribeChannelError(t *testing.T) {
+ mockedErr := errors.New("Some DB Backend Subscribe Error")
+ m, i := setup()
+
+ expectedCB := func(channel string, events ...string) {}
+ expectedChannels := []string{"{namespace},channel1", "{namespace},channel2"}
+
+ m.On("SubscribeChannelDB", mock.AnythingOfType("func(string, ...string)"), expectedChannels).Return(mockedErr)
+ err := i.SubscribeChannel(expectedCB, "channel1", "channel2")
+ assert.NotNil(t, err)
+ assert.Contains(t, err.Error(), mockedErr.Error())
m.AssertExpectations(t)
}
expectedChannels := []string{"{namespace},channel1", "{namespace},channel2"}
- m.On("UnsubscribeChannelDB", expectedChannels).Return()
- i.UnsubscribeChannel("channel1", "channel2")
+ m.On("UnsubscribeChannelDB", expectedChannels).Return(nil)
+ err := i.UnsubscribeChannel("channel1", "channel2")
+ assert.Nil(t, err)
+ m.AssertExpectations(t)
+}
+
+func TestUnsubscribeChannelError(t *testing.T) {
+ mockedErr := errors.New("Some DB Backend Unsubscribe Error")
+ m, i := setup()
+
+ expectedChannels := []string{"{namespace},channel1", "{namespace},channel2"}
+
+ m.On("UnsubscribeChannelDB", expectedChannels).Return(mockedErr)
+ err := i.UnsubscribeChannel("channel1", "channel2")
+ assert.NotNil(t, err)
+ assert.Contains(t, err.Error(), mockedErr.Error())
m.AssertExpectations(t)
}
+
func TestGetOneKey(t *testing.T) {
m, i := setup()
m.AssertExpectations(t)
}
-func TestWriteMapAsInput(t *testing.T){
+func TestWriteMapAsInput(t *testing.T) {
m, i := setup()
setExpected := []interface{}{"{namespace},key1", "string123",
- "{namespace},key22", 12,
- "{namespace},key333", []byte{1,2,3,4,5}}
+ "{namespace},key22", 12,
+ "{namespace},key333", []byte{1, 2, 3, 4, 5}}
inputMap := map[string]interface{}{
- "key1": "string123",
- "key22": 12,
- "key333": []byte{1,2,3,4,5},
+ "key1": "string123",
+ "key22": 12,
+ "key333": []byte{1, 2, 3, 4, 5},
}
m.On("MSet", mock.MatchedBy(func(input []interface{}) bool {
}
}
return true
- })).Return(nil)
+ })).Return(nil)
err := i.Set(inputMap)
assert.Nil(t, err)
}
func TestWriteAndPublishSeveralChannelsAndEvents(t *testing.T) {
- m , i := setup()
+ m, i := setup()
- expectedChannelsAndEvents := []string{"{namespace},channel1", "event1___event2",
- "{namespace},channel2", "event3___event4"}
+ expectedChannelsAndEvents := []string{"{namespace},channel1", "event1___event2",
+ "{namespace},channel2", "event3___event4"}
expectedKeyVal := []interface{}{"{namespace},key", "data"}
verifyChannelAndEvent := func(input []string) bool {
m.On("MSetMPub", mock.MatchedBy(verifyChannelAndEvent), expectedKeyVal).Return(nil)
m.AssertNotCalled(t, "MSet", expectedKeyVal)
err := i.SetAndPublish([]string{"channel1", "event1", "channel2", "event3", "channel1", "event2", "channel2", "event4"},
- "key", "data")
+ "key", "data")
assert.Nil(t, err)
m.AssertExpectations(t)
}
m, i := setup()
expectedChannelAndEvent := []string{"{namespace},channel1", "event1___event2",
- "{namespace},channel2", "event3___event4"}
+ "{namespace},channel2", "event3___event4"}
expectedKeys := []string{"{namespace},key1", "{namespace},key2"}
verifyChannelAndEvent := func(input []string) bool {
}
m.On("DelMPub", mock.MatchedBy(verifyChannelAndEvent), expectedKeys).Return(nil)
err := i.RemoveAndPublish([]string{"channel1", "event1", "channel2", "event3",
- "channel1", "event2", "channel2", "event4"},
- []string{"key1", "key2"})
+ "channel1", "event2", "channel2", "event4"},
+ []string{"key1", "key2"})
assert.Nil(t, err)
m.AssertExpectations(t)
}
m.AssertNotCalled(t, "DelMPub", notExpectedChannelAndEvent, notExpectedKeys)
m.AssertNotCalled(t, "Del", notExpectedKeys)
- err := i.RemoveAndPublish([]string{"channel", "event", "channel2"}, []string{})
- assert.Nil(t, err)
+ err := i.RemoveAndPublish([]string{"channel", "event", "channel2"}, []string{"key1", "key2"})
+ assert.NotNil(t, err)
m.AssertExpectations(t)
}
func TestSetIfAndPublishSuccessfully(t *testing.T) {
m, i := setup()
- expectedChannel := "{namespace},channel"
- expectedEvent := "event"
+ expectedChannelAndEvent := []string{"{namespace},channel", "event"}
expectedKey := "{namespace},key"
expectedOldData := interface{}("olddata")
expectedNewData := interface{}("newdata")
- m.On("SetIEPub", expectedChannel, expectedEvent, expectedKey, expectedOldData, expectedNewData).Return(true, nil)
+ m.On("SetIEPub", expectedChannelAndEvent, expectedKey, expectedOldData, expectedNewData).Return(true, nil)
status, err := i.SetIfAndPublish([]string{"channel", "event"}, "key", "olddata", "newdata")
assert.Nil(t, err)
assert.True(t, status)
func TestSetIfAndPublishIncorrectChannelAndEvent(t *testing.T) {
m, i := setup()
- expectedChannel := "{namespace},channel"
- expectedEvent := "event"
+ expectedChannelAndEvent := []string{"{namespace},channel", "event"}
expectedKey := "{namespace},key"
expectedOldData := interface{}("olddata")
expectedNewData := interface{}("newdata")
- m.AssertNotCalled(t, "SetIEPub", expectedChannel, expectedEvent, expectedKey, expectedOldData, expectedNewData)
+ m.AssertNotCalled(t, "SetIEPub", expectedChannelAndEvent, expectedKey, expectedOldData, expectedNewData)
m.AssertNotCalled(t, "SetIE", expectedKey, expectedOldData, expectedNewData)
status, err := i.SetIfAndPublish([]string{"channel", "event1", "channel"}, "key", "olddata", "newdata")
assert.NotNil(t, err)
func TestSetIfAndPublishNOKStatus(t *testing.T) {
m, i := setup()
- expectedChannel := "{namespace},channel"
- expectedEvent := "event"
+ expectedChannelAndEvent := []string{"{namespace},channel", "event"}
expectedKey := "{namespace},key"
expectedOldData := interface{}("olddata")
expectedNewData := interface{}("newdata")
- m.On("SetIEPub", expectedChannel, expectedEvent, expectedKey, expectedOldData, expectedNewData).Return(false, nil)
+ m.On("SetIEPub", expectedChannelAndEvent, expectedKey, expectedOldData, expectedNewData).Return(false, nil)
status, err := i.SetIfAndPublish([]string{"channel", "event"}, "key", "olddata", "newdata")
assert.Nil(t, err)
assert.False(t, status)
func TestSetIfNotExistsAndPublishSuccessfully(t *testing.T) {
m, i := setup()
- expectedChannel := "{namespace},channel"
- expectedEvent := "event"
+ expectedChannelAndEvent := []string{"{namespace},channel", "event"}
expectedKey := "{namespace},key"
expectedData := interface{}("data")
- m.On("SetNXPub", expectedChannel, expectedEvent, expectedKey, expectedData).Return(true, nil)
+ m.On("SetNXPub", expectedChannelAndEvent, expectedKey, expectedData).Return(true, nil)
status, err := i.SetIfNotExistsAndPublish([]string{"channel", "event"}, "key", "data")
assert.Nil(t, err)
assert.True(t, status)
func TestSetIfNotExistsAndPublishSeveralEvents(t *testing.T) {
m, i := setup()
- expectedChannel := "{namespace},channel"
- expectedEvent := "event1___event2"
+ expectedChannelAndEvent := []string{"{namespace},channel", "event1___event2"}
expectedKey := "{namespace},key"
expectedData := interface{}("data")
- m.On("SetNXPub", expectedChannel, expectedEvent, expectedKey, expectedData).Return(true, nil)
+ m.On("SetNXPub", expectedChannelAndEvent, expectedKey, expectedData).Return(true, nil)
status, err := i.SetIfNotExistsAndPublish([]string{"channel", "event1", "channel", "event2"}, "key", "data")
assert.Nil(t, err)
assert.True(t, status)
expectedKey := "{namespace},key"
expectedData := interface{}("data")
- m.On("SetNX", expectedKey, expectedData).Return(true, nil)
+ m.On("SetNX", expectedKey, expectedData, time.Duration(0)).Return(true, nil)
status, err := i.SetIfNotExistsAndPublish([]string{}, "key", "data")
assert.Nil(t, err)
assert.True(t, status)
func TestSetIfNotExistsAndPublishFail(t *testing.T) {
m, i := setup()
- expectedChannel := "{namespace},channel"
- expectedEvent := "event"
+ expectedChannelAndEvent := []string{"{namespace},channel", "event"}
expectedKey := "{namespace},key"
expectedData := interface{}("data")
- m.On("SetNXPub", expectedChannel, expectedEvent, expectedKey, expectedData).Return(false, nil)
+ m.On("SetNXPub", expectedChannelAndEvent, expectedKey, expectedData).Return(false, nil)
status, err := i.SetIfNotExistsAndPublish([]string{"channel", "event"}, "key", "data")
assert.Nil(t, err)
assert.False(t, status)
func TestSetIfNotExistsAndPublishIncorrectChannels(t *testing.T) {
m, i := setup()
- expectedChannel := "{namespace},channel"
- expectedEvent := "event"
+ expectedChannelAndEvent := []string{"{namespace},channel", "event"}
expectedKey := "{namespace},key"
expectedData := interface{}("data")
- m.AssertNotCalled(t, "SetNXPub", expectedChannel, expectedEvent, expectedKey, expectedData)
- m.AssertNotCalled(t, "SetNX", expectedKey, expectedData)
+ m.AssertNotCalled(t, "SetNXPub", expectedChannelAndEvent, expectedKey, expectedData)
+ m.AssertNotCalled(t, "SetNX", expectedKey, expectedData, 0)
status, err := i.SetIfNotExistsAndPublish([]string{"channel", "event", "channel2"}, "key", "data")
assert.NotNil(t, err)
assert.False(t, status)
func TestSetIfNotExistsAndPublishError(t *testing.T) {
m, i := setup()
- expectedChannel := "{namespace},channel"
- expectedEvent := "event"
+ expectedChannelAndEvent := []string{"{namespace},channel", "event"}
expectedKey := "{namespace},key"
expectedData := interface{}("data")
- m.On("SetNXPub", expectedChannel, expectedEvent, expectedKey, expectedData).Return(false, errors.New("Some error"))
+ m.On("SetNXPub", expectedChannelAndEvent, expectedKey, expectedData).Return(false, errors.New("Some error"))
status, err := i.SetIfNotExistsAndPublish([]string{"channel", "event"}, "key", "data")
assert.NotNil(t, err)
assert.False(t, status)
mSetNXExpectedKey := string("{namespace},key1")
mSetNXExpectedData := interface{}("data")
- m.On("SetNX", mSetNXExpectedKey, mSetNXExpectedData).Return(true, nil)
+ m.On("SetNX", mSetNXExpectedKey, mSetNXExpectedData, time.Duration(0)).Return(true, nil)
status, err := i.SetIfNotExists("key1", "data")
assert.Nil(t, err)
assert.True(t, status)
mSetNXExpectedKey := string("{namespace},key1")
mSetNXExpectedData := interface{}("data")
- m.On("SetNX", mSetNXExpectedKey, mSetNXExpectedData).Return(false, nil)
+ m.On("SetNX", mSetNXExpectedKey, mSetNXExpectedData, time.Duration(0)).Return(false, nil)
status, err := i.SetIfNotExists("key1", "data")
assert.Nil(t, err)
assert.False(t, status)
mSetNXExpectedKey := string("{namespace},key1")
mSetNXExpectedData := interface{}("data")
- m.On("SetNX", mSetNXExpectedKey, mSetNXExpectedData).Return(false, errors.New("Some error"))
+ m.On("SetNX", mSetNXExpectedKey, mSetNXExpectedData, time.Duration(0)).Return(false, errors.New("Some error"))
status, err := i.SetIfNotExists("key1", "data")
assert.NotNil(t, err)
assert.False(t, status)
func TestRemoveIfAndPublishSuccessfully(t *testing.T) {
m, i := setup()
- expectedChannel := "{namespace},channel"
- expectedEvent := "event1___event2"
+ expectedChannelAndEvent := []string{"{namespace},channel", "event1___event2"}
expectedKey := "{namespace},key"
expectedValue := interface{}("data")
- m.On("DelIEPub", expectedChannel, expectedEvent, expectedKey, expectedValue).Return(true, nil)
+ m.On("DelIEPub", expectedChannelAndEvent, expectedKey, expectedValue).Return(true, nil)
status, err := i.RemoveIfAndPublish([]string{"channel", "event1", "channel", "event2"}, "key", "data")
assert.Nil(t, err)
assert.True(t, status)
func TestRemoveIfAndPublishNok(t *testing.T) {
m, i := setup()
- expectedChannel := "{namespace},channel"
- expectedEvent := "event1___event2"
+ expectedChannelAndEvent := []string{"{namespace},channel", "event1___event2"}
expectedKey := "{namespace},key"
expectedValue := interface{}("data")
- m.On("DelIEPub", expectedChannel, expectedEvent, expectedKey, expectedValue).Return(false, nil)
+ m.On("DelIEPub", expectedChannelAndEvent, expectedKey, expectedValue).Return(false, nil)
status, err := i.RemoveIfAndPublish([]string{"channel", "event1", "channel", "event2"}, "key", "data")
assert.Nil(t, err)
assert.False(t, status)
func TestRemoveIfAndPublishError(t *testing.T) {
m, i := setup()
- expectedChannel := "{namespace},channel"
- expectedEvent := "event1___event2"
+ expectedChannelAndEvent := []string{"{namespace},channel", "event1___event2"}
expectedKey := "{namespace},key"
expectedValue := interface{}("data")
- m.On("DelIEPub", expectedChannel, expectedEvent, expectedKey, expectedValue).Return(false, errors.New("Some error"))
+ m.On("DelIEPub", expectedChannelAndEvent, expectedKey, expectedValue).Return(false, errors.New("Some error"))
status, err := i.RemoveIfAndPublish([]string{"channel", "event1", "channel", "event2"}, "key", "data")
assert.NotNil(t, err)
assert.False(t, status)
func TestRemoveIfAndPublishIncorrectChannel(t *testing.T) {
m, i := setup()
- expectedChannel := "{namespace},channel"
- expectedEvent := "event"
+ expectedChannelAndEvent := []string{"{namespace},channel", "event"}
expectedKey := "{namespace},key"
expectedValue := interface{}("data")
- m.AssertNotCalled(t, "DelIEPub", expectedChannel, expectedEvent, expectedKey, expectedValue)
+ m.AssertNotCalled(t, "DelIEPub", expectedChannelAndEvent, expectedKey, expectedValue)
m.AssertNotCalled(t, "DelIE", expectedKey, expectedValue)
status, err := i.RemoveIfAndPublish([]string{"channel", "event1", "channel"}, "key", "data")
assert.NotNil(t, err)
mKeysExpected := string("{namespace},*")
mKeysReturn := []string{"{namespace},key1", "{namespace},key2"}
mDelExpected := mKeysReturn
- expectedChannelAndEvent := []string{"{namespace},channel", "event" }
+ expectedChannelAndEvent := []string{"{namespace},channel", "event"}
m.On("Keys", mKeysExpected).Return(mKeysReturn, errors.New("Some error"))
m.AssertNotCalled(t, "DelMPub", expectedChannelAndEvent, mDelExpected)
err := i.RemoveAllAndPublish([]string{"channel", "event"})
m.On("SMembers", groupExpected).Return(returnExpected, nil)
result, err := i.GetMembers("group")
- assert.Nil(t,err)
+ assert.Nil(t, err)
assert.Equal(t, result, returnExpected)
m.AssertExpectations(t)
}
m.On("SMembers", groupExpected).Return(returnExpected, errors.New("Some error"))
result, err := i.GetMembers("group")
- assert.NotNil(t,err)
+ assert.NotNil(t, err)
assert.Equal(t, []string{}, result)
m.AssertExpectations(t)
}
assert.NotNil(t, err)
assert.Equal(t, int64(0), result)
m.AssertExpectations(t)
-}
\ No newline at end of file
+}
+
+func TestLockResourceSuccessfully(t *testing.T) {
+ m, i := setup()
+
+ resourceExpected := "{namespace},resource"
+ m.On("SetNX", resourceExpected, mock.Anything, time.Duration(1)).Return(true, nil)
+
+ lock, err := i.LockResource("resource", time.Duration(1), &sdlgo.Options{})
+ assert.Nil(t, err)
+ assert.NotNil(t, lock)
+ m.AssertExpectations(t)
+}
+
+func TestLockResourceFailure(t *testing.T) {
+ m, i := setup()
+
+ resourceExpected := "{namespace},resource"
+ m.On("SetNX", resourceExpected, mock.Anything, time.Duration(1)).Return(true, errors.New("Some error"))
+
+ lock, err := i.LockResource("resource", time.Duration(1), &sdlgo.Options{})
+ assert.NotNil(t, err)
+ assert.Nil(t, lock)
+ m.AssertExpectations(t)
+}
+
+func TestLockResourceTrySeveralTimesSuccessfully(t *testing.T) {
+ m, i := setup()
+
+ resourceExpected := "{namespace},resource"
+ m.On("SetNX", resourceExpected, mock.Anything, time.Duration(1)).Return(false, nil).Once()
+ m.On("SetNX", resourceExpected, mock.Anything, time.Duration(1)).Return(true, nil).Once()
+
+ lock, err := i.LockResource("resource", time.Duration(1), &sdlgo.Options{
+ RetryCount: 2,
+ })
+ assert.Nil(t, err)
+ assert.NotNil(t, lock)
+ m.AssertExpectations(t)
+}
+
+func TestLockResourceTrySeveralTimesFailure(t *testing.T) {
+ m, i := setup()
+
+ resourceExpected := "{namespace},resource"
+ m.On("SetNX", resourceExpected, mock.Anything, time.Duration(1)).Return(false, nil).Once()
+ m.On("SetNX", resourceExpected, mock.Anything, time.Duration(1)).Return(true, errors.New("Some error")).Once()
+
+ lock, err := i.LockResource("resource", time.Duration(1), &sdlgo.Options{
+ RetryCount: 2,
+ })
+ assert.NotNil(t, err)
+ assert.Nil(t, lock)
+ m.AssertExpectations(t)
+}
+
+func TestLockResourceTrySeveralTimesUnableToGetResource(t *testing.T) {
+ m, i := setup()
+
+ resourceExpected := "{namespace},resource"
+ m.On("SetNX", resourceExpected, mock.Anything, time.Duration(1)).Return(false, nil).Once()
+ m.On("SetNX", resourceExpected, mock.Anything, time.Duration(1)).Return(false, nil).Once()
+
+ lock, err := i.LockResource("resource", time.Duration(1), &sdlgo.Options{
+ RetryCount: 1,
+ })
+ assert.NotNil(t, err)
+ assert.EqualError(t, err, "Lock not obtained")
+ assert.Nil(t, lock)
+ m.AssertExpectations(t)
+}
+
+func TestReleaseResourceSuccessfully(t *testing.T) {
+ m, i := setup()
+
+ resourceExpected := "{namespace},resource"
+ m.On("SetNX", resourceExpected, mock.Anything, time.Duration(1)).Return(true, nil).Once()
+ m.On("DelIE", resourceExpected, mock.Anything).Return(true, nil).Once()
+
+ lock, err := i.LockResource("resource", time.Duration(1), &sdlgo.Options{
+ RetryCount: 1,
+ })
+ err2 := lock.ReleaseResource()
+ assert.Nil(t, err)
+ assert.NotNil(t, lock)
+ assert.Nil(t, err2)
+ m.AssertExpectations(t)
+}
+
+func TestReleaseResourceFailure(t *testing.T) {
+ m, i := setup()
+
+ resourceExpected := "{namespace},resource"
+ m.On("SetNX", resourceExpected, mock.Anything, time.Duration(1)).Return(true, nil).Once()
+ m.On("DelIE", resourceExpected, mock.Anything).Return(true, errors.New("Some error")).Once()
+
+ lock, err := i.LockResource("resource", time.Duration(1), &sdlgo.Options{
+ RetryCount: 1,
+ })
+ err2 := lock.ReleaseResource()
+ assert.Nil(t, err)
+ assert.NotNil(t, lock)
+ assert.NotNil(t, err2)
+ m.AssertExpectations(t)
+}
+
+func TestReleaseResourceLockNotHeld(t *testing.T) {
+ m, i := setup()
+
+ resourceExpected := "{namespace},resource"
+ m.On("SetNX", resourceExpected, mock.Anything, time.Duration(1)).Return(true, nil).Once()
+ m.On("DelIE", resourceExpected, mock.Anything).Return(false, nil).Once()
+
+ lock, err := i.LockResource("resource", time.Duration(1), &sdlgo.Options{
+ RetryCount: 1,
+ })
+ err2 := lock.ReleaseResource()
+ assert.Nil(t, err)
+ assert.NotNil(t, lock)
+ assert.NotNil(t, err2)
+ assert.EqualError(t, err2, "Lock not held")
+ m.AssertExpectations(t)
+}
+
+func TestRefreshResourceSuccessfully(t *testing.T) {
+ m, i := setup()
+
+ resourceExpected := "{namespace},resource"
+ m.On("SetNX", resourceExpected, mock.Anything, time.Duration(1)).Return(true, nil).Once()
+ m.On("PExpireIE", resourceExpected, mock.Anything, time.Duration(1)).Return(nil).Once()
+
+ lock, err := i.LockResource("resource", time.Duration(1), &sdlgo.Options{
+ RetryCount: 1,
+ })
+ err2 := lock.RefreshResource(time.Duration(1))
+ assert.Nil(t, err)
+ assert.NotNil(t, lock)
+ assert.Nil(t, err2)
+ m.AssertExpectations(t)
+}
+
+func TestRefreshResourceFailure(t *testing.T) {
+ m, i := setup()
+
+ resourceExpected := "{namespace},resource"
+ m.On("SetNX", resourceExpected, mock.Anything, time.Duration(1)).Return(true, nil).Once()
+ m.On("PExpireIE", resourceExpected, mock.Anything, time.Duration(1)).Return(errors.New("Some error")).Once()
+
+ lock, err := i.LockResource("resource", time.Duration(1), &sdlgo.Options{
+ RetryCount: 1,
+ })
+ err2 := lock.RefreshResource(time.Duration(1))
+ assert.Nil(t, err)
+ assert.NotNil(t, lock)
+ assert.NotNil(t, err2)
+ m.AssertExpectations(t)
+}
+
+func TestCheckResourceSuccessfully(t *testing.T) {
+ m, i := setup()
+
+ resourceExpected := "{namespace},resource"
+ m.On("PTTL", resourceExpected).Return(time.Duration(1), nil)
+ result, err := i.CheckResource("resource")
+ assert.Nil(t, err)
+ assert.Equal(t, result, time.Duration(1))
+ m.AssertExpectations(t)
+}
+
+func TestCheckResourceFailure(t *testing.T) {
+ m, i := setup()
+
+ resourceExpected := "{namespace},resource"
+ m.On("PTTL", resourceExpected).Return(time.Duration(1), errors.New("Some error"))
+ result, err := i.CheckResource("resource")
+ assert.NotNil(t, err)
+ assert.EqualError(t, err, "Some error")
+ assert.Equal(t, result, time.Duration(0))
+ m.AssertExpectations(t)
+}
+
+func TestCheckResourceInvalidResource(t *testing.T) {
+ m, i := setup()
+
+ resourceExpected := "{namespace},resource"
+ m.On("PTTL", resourceExpected).Return(time.Duration(-1), nil)
+ result, err := i.CheckResource("resource")
+ assert.NotNil(t, err)
+ assert.EqualError(t, err, "invalid resource given, no expiration time attached")
+ assert.Equal(t, result, time.Duration(0))
+ m.AssertExpectations(t)
+}
Code Review / ric-plt / sdlgo.git / blobdiff