pkg/control/sdl_restSubsDb_test.go - oransc/ric-plt/submgr - Gitiles

 /*
    ==================================================================================
   Copyright (c) 2019 AT&T Intellectual Property.
   Copyright (c) 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 control

 import (
 	"encoding/json"
 	"fmt"
 	"reflect"
 	"strings"
 	"sync"
 	"testing"

 	"github.com/segmentio/ksuid"
 	"github.com/stretchr/testify/assert"
 )

 var sdlRestShouldReturnError bool = false

 const sdlRestTestErrorString string = "Test sdl REST returned error on purpose"

 type RestSubsDbMock struct {
 	restSubsDb             map[string]string // Store information as a string like real db does.
 	restSubscriptions      map[string]*RESTSubscription
 	lastAllocatedRestSubId string
 	restSubIdsInDb         []string
 	marshalLock            sync.Mutex
 }

 var restSubsDbMock *RestSubsDbMock

 func CreateRestSubsDbMock() *RestSubsDbMock {
 	fmt.Println("Test CreateRestSubsDbMock()")
 	restSubsDbMock = new(RestSubsDbMock)
 	restSubsDbMock.ResetTestSettings()
 	restSubsDbMock.lastAllocatedRestSubId = ""
 	return restSubsDbMock
 }

 func (m *RestSubsDbMock) ResetTestSettings() {
 	m.restSubsDb = make(map[string]string)
 	m.restSubscriptions = make(map[string]*RESTSubscription)
 }

 func (m *RestSubsDbMock) AllocNextRestSubId() string {
 	m.lastAllocatedRestSubId = ksuid.New().String()
 	return m.lastAllocatedRestSubId
 }

 func (m *RestSubsDbMock) GetLastAllocatedRestSubId() string {
 	return m.lastAllocatedRestSubId
 }

 func (m *RestSubsDbMock) AddRestSubIdsInDb(restSubId string) {
 	m.restSubIdsInDb = append(m.restSubIdsInDb, restSubId)
 }

 func (m *RestSubsDbMock) DeleteRestSubIdsFromDb(restSubId string) {
 	newrestSubIdsInDb := []string{}
 	for _, i := range m.restSubIdsInDb {
 		if i != restSubId {
 			newrestSubIdsInDb = append(newrestSubIdsInDb, i)
 		}
 	}
 	m.restSubIdsInDb = newrestSubIdsInDb
 }

 func (m *RestSubsDbMock) EmptyRestSubIdsFromDb() {
 	m.restSubIdsInDb = nil
 }

 func CreateRESTSubscription(t *testing.T) *RESTSubscription {
 	t.Log("TEST: Creating REST subscription")

 	restSubscription := &RESTSubscription{}
 	restSubscription.xAppServiceName = "localhost"
 	restSubscription.xAppRmrEndPoint = "localhost:13560"
 	restSubscription.Meid = "RAN_NAME_1"
 	restSubscription.SubReqOngoing = true
 	restSubscription.SubDelReqOngoing = false
 	restSubscription.xAppIdToE2Id = make(map[int64]int64)
 	restSubscription.lastReqMd5sum = "856e9546f6f7b65b13a86956f2e16f6a"
 	return restSubscription
 }

 func PrintRESTSubscriptionData(t *testing.T, restSubs *RESTSubscription) {
 	t.Log("TEST: RESTSubscription data")
 	t.Logf("TEST: restSubs.xAppServiceName = %v", restSubs.xAppServiceName)
 	t.Logf("TEST: restSubs.xAppRmrEndPoint = %v", restSubs.xAppRmrEndPoint)
 	t.Logf("TEST: restSubs.Meid = %v", restSubs.Meid)
 	t.Logf("TEST: restSubs.InstanceIds = %v", restSubs.InstanceIds)
 	t.Logf("TEST: restSubs.xAppIdToE2Id = %v", restSubs.xAppIdToE2Id)
 	t.Logf("TEST: restSubs.SubReqOngoing = %v", restSubs.SubReqOngoing)
 	t.Logf("TEST: restSubs.SubDelReqOngoing = %v", restSubs.SubDelReqOngoing)
 }

 func TestWriteRESTSubscriptionToSdl(t *testing.T) {

 	// Write one subscription
 	restSubId := restSubsDbMock.AllocNextRestSubId()
 	restSubs := CreateRESTSubscription(t)
 	PrintRESTSubscriptionData(t, restSubs)
 	t.Logf("TEST: Writing subId = %v\n", restSubId)
 	err := mainCtrl.c.WriteRESTSubscriptionToSdl(restSubId, restSubs)
 	if err != nil {
 		t.Errorf("TEST: %s", err.Error())
 	}
 	restSubsDbMock.AddRestSubIdsInDb(restSubId)
 	verifyRESTKeyCount(t, 1)
 }

 func verifyRESTKeyCount(t *testing.T, expectedCount int) {

 	count, err := mainCtrl.c.GetRESTKeyCount()
 	if err != nil {
 		t.Errorf("TEST: %s", err.Error())
 	} else {
 		assert.Equal(t, expectedCount, count)
 	}
 }

 func TestReadRESTSubscriptionFromSdl(t *testing.T) {

 	restSubId := restSubsDbMock.GetLastAllocatedRestSubId()
 	t.Logf("Reading restSubId = %v\n", restSubId)
 	restSubs, err := mainCtrl.c.ReadRESTSubscriptionFromSdl(restSubId)
 	if err != nil {
 		t.Errorf("TEST: %s", err.Error())
 		return
 	}
 	PrintRESTSubscriptionData(t, restSubs)
 	assert.Equal(t, restSubsDbMock.restSubscriptions[restSubId], restSubs)
 }

 func TestRemoveRESTSubscriptionFromSdl(t *testing.T) {

 	restSubId := restSubsDbMock.GetLastAllocatedRestSubId()
 	err := mainCtrl.c.RemoveRESTSubscriptionFromSdl(restSubId)
 	if err != nil {
 		t.Errorf("TEST: %s", err.Error())
 		return
 	}
 	delete(restSubsDbMock.restSubscriptions, restSubId)
 	t.Logf("TEST: REST subscription removed from db. subId = %v", restSubId)
 	restSubsDbMock.DeleteRestSubIdsFromDb(restSubId)
 }

 func TestReadNotExistingRESTSubscriptionFromSdl(t *testing.T) {

 	restSubId := ""
 	restSubs, err := mainCtrl.c.ReadRESTSubscriptionFromSdl(restSubId)
 	if err != nil {
 		t.Logf("TEST: REST subscription not found from db. restSubId = %v", restSubId)
 		return
 	}
 	t.Errorf("TEST: REST subscription read from db. %v", restSubs)
 	PrintRESTSubscriptionData(t, restSubs)
 }

 func TestReadNotExistingRESTSubscriptionFromSdl2(t *testing.T) {

 	restSubId := "NotExistingSubsId"
 	restSubs, err := mainCtrl.c.ReadRESTSubscriptionFromSdl(restSubId)
 	if err != nil {
 		t.Logf("TEST: REST subscription not found from db. restSubId = %v", restSubId)
 		return
 	}
 	t.Errorf("TEST: REST subscription read from db. %v", restSubs)
 	PrintRESTSubscriptionData(t, restSubs)
 }

 func TestRemoveNotExistingRESTSubscriptionFromSdl(t *testing.T) {

 	restSubId := ""
 	err := mainCtrl.c.RemoveRESTSubscriptionFromSdl(restSubId)
 	if err != nil {
 		t.Logf("TEST: %s", err.Error())
 		return
 	}
 	t.Logf("TEST: REST subscription removed from db. subId = %v", restSubId)
 }

 func TestWriteRESTSubscriptionsToSdl(t *testing.T) {

 	// Write 1st subscription
 	restSubId := restSubsDbMock.AllocNextRestSubId()
 	t.Logf("TEST: Writing restSubId = %v\n", restSubId)
 	restSubs := CreateRESTSubscription(t)
 	PrintRESTSubscriptionData(t, restSubs)
 	err := mainCtrl.c.WriteRESTSubscriptionToSdl(restSubId, restSubs)
 	if err != nil {
 		t.Errorf("TEST: %s", err.Error())
 		return
 	}
 	restSubsDbMock.AddRestSubIdsInDb(restSubId)
 	t.Logf("TEST: REST subscription written in db = %v", restSubs)

 	// Write 2nd subscription
 	restSubId = restSubsDbMock.AllocNextRestSubId()
 	t.Logf("TEST:Writing restSubId = %v\n", restSubId)
 	restSubs = CreateRESTSubscription(t)
 	PrintRESTSubscriptionData(t, restSubs)
 	err = mainCtrl.c.WriteRESTSubscriptionToSdl(restSubId, restSubs)
 	if err != nil {
 		t.Errorf("TEST: %s", err.Error())
 		return
 	}
 	restSubsDbMock.AddRestSubIdsInDb(restSubId)
 	t.Logf("TEST: REST subscription written in db = %v", restSubs)

 	// Write 3rd subscription
 	restSubId = restSubsDbMock.AllocNextRestSubId()
 	t.Logf("TEST: Writing restSubId = %v\n", restSubId)
 	restSubs = CreateRESTSubscription(t)
 	PrintRESTSubscriptionData(t, restSubs)
 	err = mainCtrl.c.WriteRESTSubscriptionToSdl(restSubId, restSubs)
 	if err != nil {
 		t.Errorf("TEST: %s", err.Error())
 		return
 	}
 	restSubsDbMock.AddRestSubIdsInDb(restSubId)
 	t.Logf("TEST: REST subscription written in db = %v", restSubs)
 }

 func TestReadRESTSubscriptionsFromSdl(t *testing.T) {

 	for _, restSubId := range restSubsDbMock.restSubIdsInDb {
 		restSubs, err := mainCtrl.c.ReadRESTSubscriptionFromSdl(restSubId)
 		if err != nil {
 			t.Errorf("TEST: %s", err.Error())
 			return
 		}
 		PrintRESTSubscriptionData(t, restSubs)
 	}
 }

 func TestReadAllRESTSubscriptionsFromSdl(t *testing.T) {

 	register, err := mainCtrl.c.ReadAllRESTSubscriptionsFromSdl()
 	if err != nil {
 		t.Errorf("TEST: %s", err.Error())
 		return
 	}

 	for _, restSubs := range register {
 		PrintRESTSubscriptionData(t, restSubs)
 	}

 	assert.Equal(t, len(register), 3)
 }

 func TestRemoveAllRESTSubscriptionsFromSdl(t *testing.T) {

 	err := mainCtrl.c.RemoveAllRESTSubscriptionsFromSdl()
 	if err != nil {
 		t.Errorf("TEST: %s", err.Error())
 		return
 	}
 	t.Log("TEST: All subscription removed from db")
 	restSubsDbMock.EmptyRestSubIdsFromDb()
 }

 func TestReadAllRESTSubscriptionsFromSdl2(t *testing.T) {

 	register, err := mainCtrl.c.ReadAllRESTSubscriptionsFromSdl()
 	if err != nil {
 		t.Errorf("TEST: %s", err.Error())
 		return
 	}
 	for _, restSubs := range restSubsDbMock.restSubscriptions {
 		PrintRESTSubscriptionData(t, restSubs)
 	}
 	assert.Equal(t, len(register), 0)
 }

 func TestWriteRESTSubscriptionToSdlFail(t *testing.T) {

 	// Try to write one subscription.
 	// Test db should return test error string
 	MakeNextSdlRestCallFail()
 	restsubId := restSubsDbMock.AllocNextRestSubId()
 	restSubs := CreateRESTSubscription(t)
 	PrintRESTSubscriptionData(t, restSubs)
 	t.Logf("TEST: Writing subId = %v\n", restsubId)
 	err := mainCtrl.c.WriteRESTSubscriptionToSdl(restsubId, restSubs)
 	if err != nil {
 		if !strings.Contains(fmt.Sprintf("%s", err), sdlRestTestErrorString) {
 			t.Errorf("TEST: %s", err.Error())
 		}
 	} else {
 		t.Errorf("TEST: This test case should return error")
 	}
 }

 func TestReadRESTSubscriptionFromSdlFail(t *testing.T) {

 	// Try to read one subscription.
 	// Test db should return test error string
 	MakeNextSdlRestCallFail()
 	restSubId := restSubsDbMock.GetLastAllocatedRestSubId()
 	t.Logf("Reading restSubId = %v\n", restSubId)
 	restSubs, err := mainCtrl.c.ReadRESTSubscriptionFromSdl(restSubId)
 	if err != nil {
 		if !strings.Contains(fmt.Sprintf("%s", err), sdlRestTestErrorString) {
 			t.Errorf("TEST: %s", err.Error())
 		}
 		return
 	} else {
 		t.Errorf("TEST: This test case should return error")
 	}
 	PrintRESTSubscriptionData(t, restSubs)
 }

 func TestRemoveRESTSubscriptionFromSdlFail(t *testing.T) {

 	// Try to remove one subscription.
 	// Test db should return test error string
 	MakeNextSdlRestCallFail()
 	restSubId := restSubsDbMock.GetLastAllocatedRestSubId()
 	err := mainCtrl.c.RemoveRESTSubscriptionFromSdl(restSubId)
 	if err != nil {
 		if !strings.Contains(fmt.Sprintf("%s", err), sdlRestTestErrorString) {
 			t.Errorf("TEST: %s", err.Error())
 		}
 		return
 	} else {
 		t.Errorf("TEST: This test case should return error")
 	}
 	t.Logf("TEST: subscription removed from db. subId = %v", restSubId)
 }

 func TestReadAllRESTSubscriptionsFromSdlFail(t *testing.T) {

 	// Try to read all subscriptions.
 	// Test db should return test error string
 	MakeNextSdlRestCallFail()
 	register, err := mainCtrl.c.ReadAllRESTSubscriptionsFromSdl()
 	if err != nil {
 		if !strings.Contains(fmt.Sprintf("%s", err), sdlRestTestErrorString) {
 			t.Errorf("TEST: %s", err.Error())
 		}
 		return
 	} else {
 		t.Errorf("TEST: This test case should return error")
 	}

 	for _, restSubs := range register {
 		PrintRESTSubscriptionData(t, restSubs)
 	}
 }

 func TestRemoveAllRESTSubscriptionsFromSdlFail(t *testing.T) {

 	// Try to remove all subscriptions.
 	// Test db should return test error string
 	MakeNextSdlRestCallFail()
 	err := mainCtrl.c.RemoveAllRESTSubscriptionsFromSdl()
 	if err != nil {
 		if !strings.Contains(fmt.Sprintf("%s", err), sdlRestTestErrorString) {
 			t.Errorf("TEST: %s", err.Error())
 		}
 		return
 	} else {
 		t.Errorf("TEST: This test case should return error")
 	}
 	t.Log("TEST: All subscription removed from db")
 }

 func (m *RestSubsDbMock) Set(ns string, pairs ...interface{}) error {
 	var key string
 	var val string

 	m.marshalLock.Lock()
 	defer m.marshalLock.Unlock()

 	if ns != restSubSdlNs {
 		return fmt.Errorf("Unexpected namespace '%s' error\n", ns)
 	}

 	if sdlRestShouldReturnError == true {
 		return GetSdlRestError()
 	}

 	for _, v := range pairs {
 		reflectType := reflect.TypeOf(v)
 		switch reflectType.Kind() {
 		case reflect.Slice:
 			val = fmt.Sprintf("%s", v.([]uint8))
 		default:
 			switch v.(type) {
 			case string:
 				key = v.(string)
 			default:
 				return fmt.Errorf("Set() error: Unexpected type\n")
 			}
 		}
 	}

 	if key != "" {
 		m.restSubsDb[key] = val
 		restSubId := key
 		restSubscriptionInfo := &RESTSubscriptionInfo{}
 		err := json.Unmarshal([]byte(val), restSubscriptionInfo)
 		if err != nil {
 			return fmt.Errorf("Set() json.unmarshal error: %s\n", err.Error())
 		}

 		restSubs := mainCtrl.c.CreateRESTSubscription(restSubscriptionInfo, &val)
 		m.restSubscriptions[restSubId] = restSubs
 	} else {
 		return fmt.Errorf("Set() error: key == ''\n")
 	}
 	return nil
 }

 func (m *RestSubsDbMock) Get(ns string, keys []string) (map[string]interface{}, error) {
 	retMap := make(map[string]interface{})

 	if ns != restSubSdlNs {
 		return nil, fmt.Errorf("Unexpected namespace '%s' error\n", ns)
 	}

 	if len(keys) == 0 {
 		return nil, fmt.Errorf("Get() error: len(key) == 0\n")
 	}

 	if sdlRestShouldReturnError == true {
 		return nil, GetSdlRestError()
 	}

 	for _, key := range keys {
 		if key != "" {
 			retMap[key] = m.restSubsDb[key]
 		} else {
 			return nil, fmt.Errorf("Get() error: key == ''\n")
 		}
 	}
 	return retMap, nil
 }

 func (m *RestSubsDbMock) GetAll(ns string) ([]string, error) {

 	if ns != restSubSdlNs {
 		return nil, fmt.Errorf("Unexpected namespace '%s' error\n", ns)
 	}

 	if sdlRestShouldReturnError == true {
 		return nil, GetSdlRestError()
 	}

 	keys := []string{}
 	for key, _ := range m.restSubsDb {
 		keys = append(keys, key)
 	}
 	return keys, nil
 }

 func (m *RestSubsDbMock) Remove(ns string, keys []string) error {

 	if ns != restSubSdlNs {
 		return fmt.Errorf("Unexpected namespace '%s' error\n", ns)
 	}

 	if len(keys) == 0 {
 		return fmt.Errorf("Remove() error: len(key) == 0\n")
 	}

 	if sdlRestShouldReturnError == true {
 		return GetSdlRestError()
 	}

 	restSubId := keys[0]
 	delete(m.restSubsDb, restSubId)
 	delete(m.restSubscriptions, restSubId)
 	return nil
 }

 func (m *RestSubsDbMock) RemoveAll(ns string) error {

 	if ns != restSubSdlNs {
 		return fmt.Errorf("Unexpected namespace '%s' error\n", ns)
 	}

 	for key := range m.restSubsDb {

 		restSubId := key
 		delete(m.restSubsDb, restSubId)
 		delete(m.restSubscriptions, restSubId)
 	}

 	if sdlRestShouldReturnError == true {
 		return GetSdlRestError()
 	}

 	return nil
 }

 func MakeNextSdlRestCallFail() {
 	sdlRestShouldReturnError = true
 }

 func GetSdlRestError() error {
 	sdlRestShouldReturnError = false
 	return fmt.Errorf(sdlRestTestErrorString)
 }
	/*
	==================================================================================
	Copyright (c) 2019 AT&T Intellectual Property.
	Copyright (c) 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 control

	import (
	"encoding/json"
	"fmt"
	"reflect"
	"strings"
	"sync"
	"testing"

	"github.com/segmentio/ksuid"
	"github.com/stretchr/testify/assert"
	)

	var sdlRestShouldReturnError bool = false

	const sdlRestTestErrorString string = "Test sdl REST returned error on purpose"

	type RestSubsDbMock struct {
	restSubsDb map[string]string // Store information as a string like real db does.
	restSubscriptions map[string]*RESTSubscription
	lastAllocatedRestSubId string
	restSubIdsInDb []string
	marshalLock sync.Mutex
	}

	var restSubsDbMock *RestSubsDbMock

	func CreateRestSubsDbMock() *RestSubsDbMock {
	fmt.Println("Test CreateRestSubsDbMock()")
	restSubsDbMock = new(RestSubsDbMock)
	restSubsDbMock.ResetTestSettings()
	restSubsDbMock.lastAllocatedRestSubId = ""
	return restSubsDbMock
	}

	func (m *RestSubsDbMock) ResetTestSettings() {
	m.restSubsDb = make(map[string]string)
	m.restSubscriptions = make(map[string]*RESTSubscription)
	}

	func (m *RestSubsDbMock) AllocNextRestSubId() string {
	m.lastAllocatedRestSubId = ksuid.New().String()
	return m.lastAllocatedRestSubId
	}

	func (m *RestSubsDbMock) GetLastAllocatedRestSubId() string {
	return m.lastAllocatedRestSubId
	}

	func (m *RestSubsDbMock) AddRestSubIdsInDb(restSubId string) {
	m.restSubIdsInDb = append(m.restSubIdsInDb, restSubId)
	}

	func (m *RestSubsDbMock) DeleteRestSubIdsFromDb(restSubId string) {
	newrestSubIdsInDb := []string{}
	for _, i := range m.restSubIdsInDb {
	if i != restSubId {
	newrestSubIdsInDb = append(newrestSubIdsInDb, i)
	}
	}
	m.restSubIdsInDb = newrestSubIdsInDb
	}

	func (m *RestSubsDbMock) EmptyRestSubIdsFromDb() {
	m.restSubIdsInDb = nil
	}

	func CreateRESTSubscription(t testing.T) RESTSubscription {
	t.Log("TEST: Creating REST subscription")

	restSubscription := &RESTSubscription{}
	restSubscription.xAppServiceName = "localhost"
	restSubscription.xAppRmrEndPoint = "localhost:13560"
	restSubscription.Meid = "RAN_NAME_1"
	restSubscription.SubReqOngoing = true
	restSubscription.SubDelReqOngoing = false
	restSubscription.xAppIdToE2Id = make(map[int64]int64)
	restSubscription.lastReqMd5sum = "856e9546f6f7b65b13a86956f2e16f6a"
	return restSubscription
	}

	func PrintRESTSubscriptionData(t testing.T, restSubs RESTSubscription) {
	t.Log("TEST: RESTSubscription data")
	t.Logf("TEST: restSubs.xAppServiceName = %v", restSubs.xAppServiceName)
	t.Logf("TEST: restSubs.xAppRmrEndPoint = %v", restSubs.xAppRmrEndPoint)
	t.Logf("TEST: restSubs.Meid = %v", restSubs.Meid)
	t.Logf("TEST: restSubs.InstanceIds = %v", restSubs.InstanceIds)
	t.Logf("TEST: restSubs.xAppIdToE2Id = %v", restSubs.xAppIdToE2Id)
	t.Logf("TEST: restSubs.SubReqOngoing = %v", restSubs.SubReqOngoing)
	t.Logf("TEST: restSubs.SubDelReqOngoing = %v", restSubs.SubDelReqOngoing)
	}

	func TestWriteRESTSubscriptionToSdl(t *testing.T) {

	// Write one subscription
	restSubId := restSubsDbMock.AllocNextRestSubId()
	restSubs := CreateRESTSubscription(t)
	PrintRESTSubscriptionData(t, restSubs)
	t.Logf("TEST: Writing subId = %v\n", restSubId)
	err := mainCtrl.c.WriteRESTSubscriptionToSdl(restSubId, restSubs)
	if err != nil {
	t.Errorf("TEST: %s", err.Error())
	}
	restSubsDbMock.AddRestSubIdsInDb(restSubId)
	verifyRESTKeyCount(t, 1)
	}

	func verifyRESTKeyCount(t *testing.T, expectedCount int) {

	count, err := mainCtrl.c.GetRESTKeyCount()
	if err != nil {
	t.Errorf("TEST: %s", err.Error())
	} else {
	assert.Equal(t, expectedCount, count)
	}
	}

	func TestReadRESTSubscriptionFromSdl(t *testing.T) {

	restSubId := restSubsDbMock.GetLastAllocatedRestSubId()
	t.Logf("Reading restSubId = %v\n", restSubId)
	restSubs, err := mainCtrl.c.ReadRESTSubscriptionFromSdl(restSubId)
	if err != nil {
	t.Errorf("TEST: %s", err.Error())
	return
	}
	PrintRESTSubscriptionData(t, restSubs)
	assert.Equal(t, restSubsDbMock.restSubscriptions[restSubId], restSubs)
	}

	func TestRemoveRESTSubscriptionFromSdl(t *testing.T) {

	restSubId := restSubsDbMock.GetLastAllocatedRestSubId()
	err := mainCtrl.c.RemoveRESTSubscriptionFromSdl(restSubId)
	if err != nil {
	t.Errorf("TEST: %s", err.Error())
	return
	}
	delete(restSubsDbMock.restSubscriptions, restSubId)
	t.Logf("TEST: REST subscription removed from db. subId = %v", restSubId)
	restSubsDbMock.DeleteRestSubIdsFromDb(restSubId)
	}

	func TestReadNotExistingRESTSubscriptionFromSdl(t *testing.T) {

	restSubId := ""
	restSubs, err := mainCtrl.c.ReadRESTSubscriptionFromSdl(restSubId)
	if err != nil {
	t.Logf("TEST: REST subscription not found from db. restSubId = %v", restSubId)
	return
	}
	t.Errorf("TEST: REST subscription read from db. %v", restSubs)
	PrintRESTSubscriptionData(t, restSubs)
	}

	func TestReadNotExistingRESTSubscriptionFromSdl2(t *testing.T) {

	restSubId := "NotExistingSubsId"
	restSubs, err := mainCtrl.c.ReadRESTSubscriptionFromSdl(restSubId)
	if err != nil {
	t.Logf("TEST: REST subscription not found from db. restSubId = %v", restSubId)
	return
	}
	t.Errorf("TEST: REST subscription read from db. %v", restSubs)
	PrintRESTSubscriptionData(t, restSubs)
	}

	func TestRemoveNotExistingRESTSubscriptionFromSdl(t *testing.T) {

	restSubId := ""
	err := mainCtrl.c.RemoveRESTSubscriptionFromSdl(restSubId)
	if err != nil {
	t.Logf("TEST: %s", err.Error())
	return
	}
	t.Logf("TEST: REST subscription removed from db. subId = %v", restSubId)
	}

	func TestWriteRESTSubscriptionsToSdl(t *testing.T) {

	// Write 1st subscription
	restSubId := restSubsDbMock.AllocNextRestSubId()
	t.Logf("TEST: Writing restSubId = %v\n", restSubId)
	restSubs := CreateRESTSubscription(t)
	PrintRESTSubscriptionData(t, restSubs)
	err := mainCtrl.c.WriteRESTSubscriptionToSdl(restSubId, restSubs)
	if err != nil {
	t.Errorf("TEST: %s", err.Error())
	return
	}
	restSubsDbMock.AddRestSubIdsInDb(restSubId)
	t.Logf("TEST: REST subscription written in db = %v", restSubs)

	// Write 2nd subscription
	restSubId = restSubsDbMock.AllocNextRestSubId()
	t.Logf("TEST:Writing restSubId = %v\n", restSubId)
	restSubs = CreateRESTSubscription(t)
	PrintRESTSubscriptionData(t, restSubs)
	err = mainCtrl.c.WriteRESTSubscriptionToSdl(restSubId, restSubs)
	if err != nil {
	t.Errorf("TEST: %s", err.Error())
	return
	}
	restSubsDbMock.AddRestSubIdsInDb(restSubId)
	t.Logf("TEST: REST subscription written in db = %v", restSubs)

	// Write 3rd subscription
	restSubId = restSubsDbMock.AllocNextRestSubId()
	t.Logf("TEST: Writing restSubId = %v\n", restSubId)
	restSubs = CreateRESTSubscription(t)
	PrintRESTSubscriptionData(t, restSubs)
	err = mainCtrl.c.WriteRESTSubscriptionToSdl(restSubId, restSubs)
	if err != nil {
	t.Errorf("TEST: %s", err.Error())
	return
	}
	restSubsDbMock.AddRestSubIdsInDb(restSubId)
	t.Logf("TEST: REST subscription written in db = %v", restSubs)
	}

	func TestReadRESTSubscriptionsFromSdl(t *testing.T) {

	for _, restSubId := range restSubsDbMock.restSubIdsInDb {
	restSubs, err := mainCtrl.c.ReadRESTSubscriptionFromSdl(restSubId)
	if err != nil {
	t.Errorf("TEST: %s", err.Error())
	return
	}
	PrintRESTSubscriptionData(t, restSubs)
	}
	}

	func TestReadAllRESTSubscriptionsFromSdl(t *testing.T) {

	register, err := mainCtrl.c.ReadAllRESTSubscriptionsFromSdl()
	if err != nil {
	t.Errorf("TEST: %s", err.Error())
	return
	}

	for _, restSubs := range register {
	PrintRESTSubscriptionData(t, restSubs)
	}

	assert.Equal(t, len(register), 3)
	}

	func TestRemoveAllRESTSubscriptionsFromSdl(t *testing.T) {

	err := mainCtrl.c.RemoveAllRESTSubscriptionsFromSdl()
	if err != nil {
	t.Errorf("TEST: %s", err.Error())
	return
	}
	t.Log("TEST: All subscription removed from db")
	restSubsDbMock.EmptyRestSubIdsFromDb()
	}

	func TestReadAllRESTSubscriptionsFromSdl2(t *testing.T) {

	register, err := mainCtrl.c.ReadAllRESTSubscriptionsFromSdl()
	if err != nil {
	t.Errorf("TEST: %s", err.Error())
	return
	}
	for _, restSubs := range restSubsDbMock.restSubscriptions {
	PrintRESTSubscriptionData(t, restSubs)
	}
	assert.Equal(t, len(register), 0)
	}

	func TestWriteRESTSubscriptionToSdlFail(t *testing.T) {

	// Try to write one subscription.
	// Test db should return test error string
	MakeNextSdlRestCallFail()
	restsubId := restSubsDbMock.AllocNextRestSubId()
	restSubs := CreateRESTSubscription(t)
	PrintRESTSubscriptionData(t, restSubs)
	t.Logf("TEST: Writing subId = %v\n", restsubId)
	err := mainCtrl.c.WriteRESTSubscriptionToSdl(restsubId, restSubs)
	if err != nil {
	if !strings.Contains(fmt.Sprintf("%s", err), sdlRestTestErrorString) {
	t.Errorf("TEST: %s", err.Error())
	}
	} else {
	t.Errorf("TEST: This test case should return error")
	}
	}

	func TestReadRESTSubscriptionFromSdlFail(t *testing.T) {

	// Try to read one subscription.
	// Test db should return test error string
	MakeNextSdlRestCallFail()
	restSubId := restSubsDbMock.GetLastAllocatedRestSubId()
	t.Logf("Reading restSubId = %v\n", restSubId)
	restSubs, err := mainCtrl.c.ReadRESTSubscriptionFromSdl(restSubId)
	if err != nil {
	if !strings.Contains(fmt.Sprintf("%s", err), sdlRestTestErrorString) {
	t.Errorf("TEST: %s", err.Error())
	}
	return
	} else {
	t.Errorf("TEST: This test case should return error")
	}
	PrintRESTSubscriptionData(t, restSubs)
	}

	func TestRemoveRESTSubscriptionFromSdlFail(t *testing.T) {

	// Try to remove one subscription.
	// Test db should return test error string
	MakeNextSdlRestCallFail()
	restSubId := restSubsDbMock.GetLastAllocatedRestSubId()
	err := mainCtrl.c.RemoveRESTSubscriptionFromSdl(restSubId)
	if err != nil {
	if !strings.Contains(fmt.Sprintf("%s", err), sdlRestTestErrorString) {
	t.Errorf("TEST: %s", err.Error())
	}
	return
	} else {
	t.Errorf("TEST: This test case should return error")
	}
	t.Logf("TEST: subscription removed from db. subId = %v", restSubId)
	}

	func TestReadAllRESTSubscriptionsFromSdlFail(t *testing.T) {

	// Try to read all subscriptions.
	// Test db should return test error string
	MakeNextSdlRestCallFail()
	register, err := mainCtrl.c.ReadAllRESTSubscriptionsFromSdl()
	if err != nil {
	if !strings.Contains(fmt.Sprintf("%s", err), sdlRestTestErrorString) {
	t.Errorf("TEST: %s", err.Error())
	}
	return
	} else {
	t.Errorf("TEST: This test case should return error")
	}

	for _, restSubs := range register {
	PrintRESTSubscriptionData(t, restSubs)
	}
	}

	func TestRemoveAllRESTSubscriptionsFromSdlFail(t *testing.T) {

	// Try to remove all subscriptions.
	// Test db should return test error string
	MakeNextSdlRestCallFail()
	err := mainCtrl.c.RemoveAllRESTSubscriptionsFromSdl()
	if err != nil {
	if !strings.Contains(fmt.Sprintf("%s", err), sdlRestTestErrorString) {
	t.Errorf("TEST: %s", err.Error())
	}
	return
	} else {
	t.Errorf("TEST: This test case should return error")
	}
	t.Log("TEST: All subscription removed from db")
	}

	func (m *RestSubsDbMock) Set(ns string, pairs ...interface{}) error {
	var key string
	var val string

	m.marshalLock.Lock()
	defer m.marshalLock.Unlock()

	if ns != restSubSdlNs {
	return fmt.Errorf("Unexpected namespace '%s' error\n", ns)
	}

	if sdlRestShouldReturnError == true {
	return GetSdlRestError()
	}

	for _, v := range pairs {
	reflectType := reflect.TypeOf(v)
	switch reflectType.Kind() {
	case reflect.Slice:
	val = fmt.Sprintf("%s", v.([]uint8))
	default:
	switch v.(type) {
	case string:
	key = v.(string)
	default:
	return fmt.Errorf("Set() error: Unexpected type\n")
	}
	}
	}

	if key != "" {
	m.restSubsDb[key] = val
	restSubId := key
	restSubscriptionInfo := &RESTSubscriptionInfo{}
	err := json.Unmarshal([]byte(val), restSubscriptionInfo)
	if err != nil {
	return fmt.Errorf("Set() json.unmarshal error: %s\n", err.Error())
	}

	restSubs := mainCtrl.c.CreateRESTSubscription(restSubscriptionInfo, &val)
	m.restSubscriptions[restSubId] = restSubs
	} else {
	return fmt.Errorf("Set() error: key == ''\n")
	}
	return nil
	}

	func (m *RestSubsDbMock) Get(ns string, keys []string) (map[string]interface{}, error) {
	retMap := make(map[string]interface{})

	if ns != restSubSdlNs {
	return nil, fmt.Errorf("Unexpected namespace '%s' error\n", ns)
	}

	if len(keys) == 0 {
	return nil, fmt.Errorf("Get() error: len(key) == 0\n")
	}

	if sdlRestShouldReturnError == true {
	return nil, GetSdlRestError()
	}

	for _, key := range keys {
	if key != "" {
	retMap[key] = m.restSubsDb[key]
	} else {
	return nil, fmt.Errorf("Get() error: key == ''\n")
	}
	}
	return retMap, nil
	}

	func (m *RestSubsDbMock) GetAll(ns string) ([]string, error) {

	if ns != restSubSdlNs {
	return nil, fmt.Errorf("Unexpected namespace '%s' error\n", ns)
	}

	if sdlRestShouldReturnError == true {
	return nil, GetSdlRestError()
	}

	keys := []string{}
	for key, _ := range m.restSubsDb {
	keys = append(keys, key)
	}
	return keys, nil
	}

	func (m *RestSubsDbMock) Remove(ns string, keys []string) error {

	if ns != restSubSdlNs {
	return fmt.Errorf("Unexpected namespace '%s' error\n", ns)
	}

	if len(keys) == 0 {
	return fmt.Errorf("Remove() error: len(key) == 0\n")
	}

	if sdlRestShouldReturnError == true {
	return GetSdlRestError()
	}

	restSubId := keys[0]
	delete(m.restSubsDb, restSubId)
	delete(m.restSubscriptions, restSubId)
	return nil
	}

	func (m *RestSubsDbMock) RemoveAll(ns string) error {

	if ns != restSubSdlNs {
	return fmt.Errorf("Unexpected namespace '%s' error\n", ns)
	}

	for key := range m.restSubsDb {

	restSubId := key
	delete(m.restSubsDb, restSubId)
	delete(m.restSubscriptions, restSubId)
	}

	if sdlRestShouldReturnError == true {
	return GetSdlRestError()
	}

	return nil
	}

	func MakeNextSdlRestCallFail() {
	sdlRestShouldReturnError = true
	}

	func GetSdlRestError() error {
	sdlRestShouldReturnError = false
	return fmt.Errorf(sdlRestTestErrorString)
	}