Merge "RIC:1060: Change in PTL"

[ric-plt/sdlgo.git] / sdl_test.go

diff --git a/sdl_test.go b/sdl_test.go
index 944edaa..725552a 100644 (file)
--- a/sdl_test.go
+++ b/sdl_test.go
@@ -15,6 +15,11 @@
    limitations under the License.
 */
 
+/*
+ * This source code is part of the near-RT RIC (RAN Intelligent Controller)
+ * platform project (RICP).
+ */
+
 package sdlgo_test
 
 import (
@@ -32,12 +37,14 @@ type mockDB struct {
        mock.Mock
 }
 
-func (m *mockDB) SubscribeChannelDB(cb func(string, ...string), 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 {
@@ -80,8 +87,8 @@ func (m *mockDB) SetIE(key string, oldData, newData interface{}) (bool, 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)
 }
 
@@ -90,8 +97,8 @@ func (m *mockDB) SetNX(key string, data interface{}, expiration time.Duration) (
        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)
 }
 
@@ -100,8 +107,8 @@ func (m *mockDB) DelIE(key string, data interface{}) (bool, error) {
        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)
 }
 
@@ -164,14 +171,47 @@ func verifySliceInOrder(a, b []string) bool {
 
 }
 
+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("func(string, ...string)"), "{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)
 }
 
@@ -180,10 +220,25 @@ func TestUnsubscribeChannel(t *testing.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()
 
@@ -586,8 +641,8 @@ func TestRemoveAndPublishIncorrectChannel(t *testing.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)
 
 }
@@ -775,12 +830,11 @@ func TestSetIfFailure(t *testing.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)
@@ -790,12 +844,11 @@ func TestSetIfAndPublishSuccessfully(t *testing.T) {
 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)
@@ -805,12 +858,11 @@ func TestSetIfAndPublishIncorrectChannelAndEvent(t *testing.T) {
 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)
@@ -833,12 +885,11 @@ func TestSetIfAndPublishNoChannels(t *testing.T) {
 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)
@@ -848,12 +899,11 @@ func TestSetIfNotExistsAndPublishSuccessfully(t *testing.T) {
 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)
@@ -876,12 +926,11 @@ func TestSetIfNotExistsAndPublishNoChannels(t *testing.T) {
 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)
@@ -891,12 +940,11 @@ func TestSetIfNotExistsAndPublishFail(t *testing.T) {
 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, "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)
@@ -907,12 +955,11 @@ func TestSetIfNotExistsAndPublishIncorrectChannels(t *testing.T) {
 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)
@@ -958,12 +1005,11 @@ func TestSetIfNotExistsFailure(t *testing.T) {
 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)
@@ -973,12 +1019,11 @@ func TestRemoveIfAndPublishSuccessfully(t *testing.T) {
 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)
@@ -988,12 +1033,11 @@ func TestRemoveIfAndPublishNok(t *testing.T) {
 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)
@@ -1003,12 +1047,11 @@ func TestRemoveIfAndPublishError(t *testing.T) {
 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)