X-Git-Url: https://gerrit.o-ran-sc.org/r/gitweb?a=blobdiff_plain;f=sdl_test.go;fp=sdl_test.go;h=75ee3213f959f066bf651085643c86bb3cf66552;hb=7c17df52f1e8004e68bcc2d339be5d1347625aa6;hp=0000000000000000000000000000000000000000;hpb=12c8b626d9627db989920f65a5b80622ed037b2f;p=ric-plt%2Fsdlgo.git

diff --git a/sdl_test.go b/sdl_test.go
new file mode 100644
index 0000000..75ee321
--- /dev/null
+++ b/sdl_test.go
@@ -0,0 +1,435 @@
+/*
+   Copyright (c) 2019 AT&T Intellectual Property.
+   Copyright (c) 2018-2019 Nokia.
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+*/
+
+package sdlgo_test
+
+import (
+	"errors"
+	"testing"
+
+	"gerrit.oran-osc.org/r/ric-plt/sdlgo"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/mock"
+)
+
+type mockDB struct {
+	mock.Mock
+}
+
+func (m *mockDB) MSet(pairs ...interface{}) error {
+	a := m.Called(pairs)
+	return a.Error(0)
+}
+
+func (m *mockDB) MGet(keys []string) ([]interface{}, error) {
+	a := m.Called(keys)
+	return a.Get(0).([]interface{}), a.Error(1)
+}
+
+func (m *mockDB) Close() error {
+	a := m.Called()
+	return a.Error(0)
+}
+
+func (m *mockDB) Del(keys []string) error {
+	a := m.Called(keys)
+	return a.Error(0)
+}
+
+func (m *mockDB) Keys(pattern string) ([]string, error) {
+	a := m.Called(pattern)
+	return a.Get(0).([]string), a.Error(1)
+}
+
+func (m *mockDB) SetIE(key string, oldData, newData interface{}) (bool, error) {
+	a := m.Called(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)
+	return a.Bool(0), a.Error(1)
+}
+
+func (m *mockDB) DelIE(key string, data interface{}) (bool, error) {
+	a := m.Called(key, data)
+	return a.Bool(0), a.Error(1)
+}
+
+func setup() (*mockDB, *sdlgo.SdlInstance) {
+	m := new(mockDB)
+	i := sdlgo.NewSdlInstance("namespace", m)
+	return m, i
+}
+
+func TestGetOneKey(t *testing.T) {
+	m, i := setup()
+
+	mgetExpected := []string{"{namespace},key"}
+	mReturn := []interface{}{"somevalue"}
+	mReturnExpected := make(map[string]interface{})
+	mReturnExpected["key"] = "somevalue"
+
+	m.On("MGet", mgetExpected).Return(mReturn, nil)
+	retVal, err := i.Get([]string{"key"})
+	assert.Nil(t, err)
+	assert.Equal(t, mReturnExpected, retVal)
+	m.AssertExpectations(t)
+}
+
+func TestGetSeveralKeys(t *testing.T) {
+	m, i := setup()
+
+	mgetExpected := []string{"{namespace},key1", "{namespace},key2", "{namespace},key3"}
+	mReturn := []interface{}{"somevalue1", 2, "someothervalue"}
+	mReturnExpected := make(map[string]interface{})
+	mReturnExpected["key1"] = "somevalue1"
+	mReturnExpected["key2"] = 2
+	mReturnExpected["key3"] = "someothervalue"
+
+	m.On("MGet", mgetExpected).Return(mReturn, nil)
+	retVal, err := i.Get([]string{"key1", "key2", "key3"})
+	assert.Nil(t, err)
+	assert.Equal(t, mReturnExpected, retVal)
+	m.AssertExpectations(t)
+}
+
+func TestGetSeveralKeysSomeFail(t *testing.T) {
+	m, i := setup()
+
+	mgetExpected := []string{"{namespace},key1", "{namespace},key2", "{namespace},key3"}
+	mReturn := []interface{}{"somevalue1", nil, "someothervalue"}
+	mReturnExpected := make(map[string]interface{})
+	mReturnExpected["key1"] = "somevalue1"
+	mReturnExpected["key2"] = nil
+	mReturnExpected["key3"] = "someothervalue"
+
+	m.On("MGet", mgetExpected).Return(mReturn, nil)
+	retVal, err := i.Get([]string{"key1", "key2", "key3"})
+	assert.Nil(t, err)
+	assert.Equal(t, mReturnExpected, retVal)
+	m.AssertExpectations(t)
+}
+
+func TestGetKeyReturnError(t *testing.T) {
+	m, i := setup()
+
+	mgetExpected := []string{"{namespace},key"}
+	mReturn := []interface{}{nil}
+	mReturnExpected := make(map[string]interface{})
+
+	m.On("MGet", mgetExpected).Return(mReturn, errors.New("Some error"))
+	retVal, err := i.Get([]string{"key"})
+	assert.NotNil(t, err)
+	assert.Equal(t, mReturnExpected, retVal)
+	m.AssertExpectations(t)
+}
+
+func TestGetEmptyList(t *testing.T) {
+	m, i := setup()
+
+	mgetExpected := []string{}
+
+	retval, err := i.Get([]string{})
+	assert.Nil(t, err)
+	assert.Len(t, retval, 0)
+	m.AssertNotCalled(t, "MGet", mgetExpected)
+}
+
+func TestWriteOneKey(t *testing.T) {
+	m, i := setup()
+
+	msetExpected := []interface{}{"{namespace},key1", "data1"}
+
+	m.On("MSet", msetExpected).Return(nil)
+	err := i.Set("key1", "data1")
+	assert.Nil(t, err)
+	m.AssertExpectations(t)
+}
+
+func TestWriteSeveralKeysSlice(t *testing.T) {
+	m, i := setup()
+
+	msetExpected := []interface{}{"{namespace},key1", "data1", "{namespace},key2", 22}
+
+	m.On("MSet", msetExpected).Return(nil)
+	err := i.Set([]interface{}{"key1", "data1", "key2", 22})
+	assert.Nil(t, err)
+	m.AssertExpectations(t)
+
+}
+
+func TestWriteSeveralKeysArray(t *testing.T) {
+	m, i := setup()
+
+	msetExpected := []interface{}{"{namespace},key1", "data1", "{namespace},key2", "data2"}
+
+	m.On("MSet", msetExpected).Return(nil)
+	err := i.Set([4]string{"key1", "data1", "key2", "data2"})
+	assert.Nil(t, err)
+	m.AssertExpectations(t)
+}
+
+func TestWriteFail(t *testing.T) {
+	m, i := setup()
+
+	msetExpected := []interface{}{"{namespace},key1", "data1"}
+
+	m.On("MSet", msetExpected).Return(errors.New("Some error"))
+	err := i.Set("key1", "data1")
+	assert.NotNil(t, err)
+	m.AssertExpectations(t)
+}
+
+func TestWriteEmptyList(t *testing.T) {
+	m, i := setup()
+
+	msetExpected := []interface{}{}
+	err := i.Set()
+	assert.Nil(t, err)
+	m.AssertNotCalled(t, "MSet", msetExpected)
+}
+
+func TestRemoveSuccessfully(t *testing.T) {
+	m, i := setup()
+
+	msetExpected := []string{"{namespace},key1", "{namespace},key2"}
+	m.On("Del", msetExpected).Return(nil)
+
+	err := i.Remove([]string{"key1", "key2"})
+	assert.Nil(t, err)
+	m.AssertExpectations(t)
+}
+
+func TestRemoveFail(t *testing.T) {
+	m, i := setup()
+
+	msetExpected := []string{"{namespace},key"}
+	m.On("Del", msetExpected).Return(errors.New("Some error"))
+
+	err := i.Remove([]string{"key"})
+	assert.NotNil(t, err)
+	m.AssertExpectations(t)
+}
+
+func TestRemoveEmptyList(t *testing.T) {
+	m, i := setup()
+
+	err := i.Remove([]string{})
+	assert.Nil(t, err)
+	m.AssertNotCalled(t, "Del", []string{})
+}
+
+func TestGetAllSuccessfully(t *testing.T) {
+	m, i := setup()
+
+	mKeysExpected := string("{namespace},*")
+	mReturnExpected := []string{"{namespace},key1", "{namespace},key2"}
+	expectedReturn := []string{"key1", "key2"}
+	m.On("Keys", mKeysExpected).Return(mReturnExpected, nil)
+	retVal, err := i.GetAll()
+	assert.Nil(t, err)
+	assert.Equal(t, expectedReturn, retVal)
+	m.AssertExpectations(t)
+}
+
+func TestGetAllFail(t *testing.T) {
+	m, i := setup()
+
+	mKeysExpected := string("{namespace},*")
+	mReturnExpected := []string{}
+	m.On("Keys", mKeysExpected).Return(mReturnExpected, errors.New("some error"))
+	retVal, err := i.GetAll()
+	assert.NotNil(t, err)
+	assert.Nil(t, retVal)
+	assert.Equal(t, len(retVal), 0)
+	m.AssertExpectations(t)
+}
+
+func TestGetAllReturnEmpty(t *testing.T) {
+	m, i := setup()
+
+	mKeysExpected := string("{namespace},*")
+	var mReturnExpected []string = nil
+	m.On("Keys", mKeysExpected).Return(mReturnExpected, nil)
+	retVal, err := i.GetAll()
+	assert.Nil(t, err)
+	assert.Nil(t, retVal)
+	assert.Equal(t, len(retVal), 0)
+	m.AssertExpectations(t)
+
+}
+
+func TestRemoveAllSuccessfully(t *testing.T) {
+	m, i := setup()
+
+	mKeysExpected := string("{namespace},*")
+	mKeysReturn := []string{"{namespace},key1", "{namespace},key2"}
+	mDelExpected := mKeysReturn
+	m.On("Keys", mKeysExpected).Return(mKeysReturn, nil)
+	m.On("Del", mDelExpected).Return(nil)
+	err := i.RemoveAll()
+	assert.Nil(t, err)
+	m.AssertExpectations(t)
+}
+
+func TestRemoveAllNoKeysFound(t *testing.T) {
+	m, i := setup()
+
+	mKeysExpected := string("{namespace},*")
+	var mKeysReturn []string = nil
+	m.On("Keys", mKeysExpected).Return(mKeysReturn, nil)
+	m.AssertNumberOfCalls(t, "Del", 0)
+	err := i.RemoveAll()
+	assert.Nil(t, err)
+	m.AssertExpectations(t)
+}
+
+func TestRemoveAllKeysReturnError(t *testing.T) {
+	m, i := setup()
+
+	mKeysExpected := string("{namespace},*")
+	var mKeysReturn []string = nil
+	m.On("Keys", mKeysExpected).Return(mKeysReturn, errors.New("Some error"))
+	m.AssertNumberOfCalls(t, "Del", 0)
+	err := i.RemoveAll()
+	assert.NotNil(t, err)
+	m.AssertExpectations(t)
+}
+
+func TestRemoveAllDelReturnError(t *testing.T) {
+	m, i := setup()
+
+	mKeysExpected := string("{namespace},*")
+	mKeysReturn := []string{"{namespace},key1", "{namespace},key2"}
+	mDelExpected := mKeysReturn
+	m.On("Keys", mKeysExpected).Return(mKeysReturn, nil)
+	m.On("Del", mDelExpected).Return(errors.New("Some Error"))
+	err := i.RemoveAll()
+	assert.NotNil(t, err)
+	m.AssertExpectations(t)
+}
+
+func TestSetIfSuccessfullyOkStatus(t *testing.T) {
+	m, i := setup()
+
+	mSetIEExpectedKey := string("{namespace},key1")
+	mSetIEExpectedOldData := interface{}("olddata")
+	mSetIEExpectedNewData := interface{}("newdata")
+	m.On("SetIE", mSetIEExpectedKey, mSetIEExpectedOldData, mSetIEExpectedNewData).Return(true, nil)
+	status, err := i.SetIf("key1", "olddata", "newdata")
+	assert.Nil(t, err)
+	assert.True(t, status)
+	m.AssertExpectations(t)
+}
+
+func TestSetIfSuccessfullyNOKStatus(t *testing.T) {
+	m, i := setup()
+
+	mSetIEExpectedKey := string("{namespace},key1")
+	mSetIEExpectedOldData := interface{}("olddata")
+	mSetIEExpectedNewData := interface{}("newdata")
+	m.On("SetIE", mSetIEExpectedKey, mSetIEExpectedOldData, mSetIEExpectedNewData).Return(false, nil)
+	status, err := i.SetIf("key1", "olddata", "newdata")
+	assert.Nil(t, err)
+	assert.False(t, status)
+	m.AssertExpectations(t)
+}
+
+func TestSetIfFailure(t *testing.T) {
+	m, i := setup()
+
+	mSetIEExpectedKey := string("{namespace},key1")
+	mSetIEExpectedOldData := interface{}("olddata")
+	mSetIEExpectedNewData := interface{}("newdata")
+	m.On("SetIE", mSetIEExpectedKey, mSetIEExpectedOldData, mSetIEExpectedNewData).Return(true, errors.New("Some error"))
+	status, err := i.SetIf("key1", "olddata", "newdata")
+	assert.NotNil(t, err)
+	assert.False(t, status)
+	m.AssertExpectations(t)
+}
+
+func TestSetIfNotExistsSuccessfullyOkStatus(t *testing.T) {
+	m, i := setup()
+
+	mSetNXExpectedKey := string("{namespace},key1")
+	mSetNXExpectedData := interface{}("data")
+	m.On("SetNX", mSetNXExpectedKey, mSetNXExpectedData).Return(true, nil)
+	status, err := i.SetIfNotExists("key1", "data")
+	assert.Nil(t, err)
+	assert.True(t, status)
+	m.AssertExpectations(t)
+}
+
+func TestSetIfNotExistsSuccessfullyNOKStatus(t *testing.T) {
+	m, i := setup()
+
+	mSetNXExpectedKey := string("{namespace},key1")
+	mSetNXExpectedData := interface{}("data")
+	m.On("SetNX", mSetNXExpectedKey, mSetNXExpectedData).Return(false, nil)
+	status, err := i.SetIfNotExists("key1", "data")
+	assert.Nil(t, err)
+	assert.False(t, status)
+	m.AssertExpectations(t)
+}
+
+func TestSetIfNotExistsFailure(t *testing.T) {
+	m, i := setup()
+
+	mSetNXExpectedKey := string("{namespace},key1")
+	mSetNXExpectedData := interface{}("data")
+	m.On("SetNX", mSetNXExpectedKey, mSetNXExpectedData).Return(true, errors.New("Some error"))
+	status, err := i.SetIfNotExists("key1", "data")
+	assert.NotNil(t, err)
+	assert.False(t, status)
+	m.AssertExpectations(t)
+}
+func TestRemoveIfSuccessfullyOkStatus(t *testing.T) {
+	m, i := setup()
+
+	mDelIEExpectedKey := string("{namespace},key1")
+	mDelIEExpectedData := interface{}("data")
+	m.On("DelIE", mDelIEExpectedKey, mDelIEExpectedData).Return(true, nil)
+	status, err := i.RemoveIf("key1", "data")
+	assert.Nil(t, err)
+	assert.True(t, status)
+	m.AssertExpectations(t)
+}
+
+func TestRemoveIfSuccessfullyNOKStatus(t *testing.T) {
+	m, i := setup()
+
+	mDelIEExpectedKey := string("{namespace},key1")
+	mDelIEExpectedData := interface{}("data")
+	m.On("DelIE", mDelIEExpectedKey, mDelIEExpectedData).Return(false, nil)
+	status, err := i.RemoveIf("key1", "data")
+	assert.Nil(t, err)
+	assert.False(t, status)
+	m.AssertExpectations(t)
+}
+
+func TestRemoveIfFailure(t *testing.T) {
+	m, i := setup()
+
+	mDelIEExpectedKey := string("{namespace},key1")
+	mDelIEExpectedData := interface{}("data")
+	m.On("DelIE", mDelIEExpectedKey, mDelIEExpectedData).Return(true, errors.New("Some error"))
+	status, err := i.RemoveIf("key1", "data")
+	assert.NotNil(t, err)
+	assert.False(t, status)
+	m.AssertExpectations(t)
+}