limitations under the License.
*/
+/*
+ * This source code is part of the near-RT RIC (RAN Intelligent Controller)
+ * platform project (RICP).
+ */
+
package sdlgo_test
import (
"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) {
+func (m *mockDB) SubscribeChannelDB(cb func(string, ...string), channelPrefix, eventSeparator string, channels ...string) {
m.Called(cb, channelPrefix, eventSeparator, channels)
}
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)
}
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)
}
func setup() (*mockDB, *sdlgo.SdlInstance) {
m := new(mockDB)
- i := sdlgo.NewSdlInstance("namespace", m)
+ i := sdlgo.NewSdlInstanceForTest("namespace", m)
return m, i
}
}
+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()
+ m.On("SubscribeChannelDB", mock.AnythingOfType("func(string, ...string)"), "{namespace},", "___", expectedChannels).Return()
i.SubscribeChannel(expectedCB, "channel1", "channel2")
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)
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, "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)
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)
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)