/*
   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) CloseDB() 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)
}