Added encoding tests in migrator

2026-02-22 15:48:44 +05:00 · 2018-05-14 11:18:07 -04:00
parent 82ddc85c20
commit 961722a788
12 changed files with 1548 additions and 1159 deletions
--- a/data/conf/samples/tutmongojson/cgrates.json
+++ b/data/conf/samples/tutmongojson/cgrates.json
@@ -0,0 +1,69 @@
+{
+// CGRateS Configuration file
+
+
+"general": {
+	"log_level": 7,
+	"reply_timeout": "30s",
+	"dbdata_encoding": "json",
+},
+
+
+"listen": {
+	"rpc_json": ":2012",
+	"rpc_gob": ":2013",
+	"http": ":2080",
+},
+
+
+"data_db": {
+	"db_type": "mongo",
+	"db_name": "10",
+	"db_port": 27017,
+},
+
+
+"stor_db": {
+	"db_type": "mongo",
+	"db_port": 27017,
+},
+
+
+"cache":{
+	"destinations": {"limit": 10000, "ttl":"0s", "precache": true},
+	"reverse_destinations": {"limit": 10000, "ttl":"0s", "precache": true},
+	"rating_plans": {"limit": 10000, "ttl":"0s","precache": true},
+	"rating_profiles": {"limit": 10000, "ttl":"0s", "precache": true},
+	"lcr_rules": {"limit": 10000, "ttl":"0s", "precache": true},
+	"cdr_stats": {"limit": 10000, "ttl":"0s", "precache": true},
+	"actions": {"limit": 10000, "ttl":"0s", "precache": true},
+	"action_plans": {"limit": 10000, "ttl":"0s", "precache": true},
+	"account_action_plans": {"limit": 10000, "ttl":"0s", "precache": true},
+	"action_triggers": {"limit": 10000, "ttl":"0s", "precache": true},
+	"shared_groups": {"limit": 10000, "ttl":"0s", "precache": true},
+	"aliases": {"limit": 10000, "ttl":"0s", "precache": true},
+	"reverse_aliases": {"limit": 10000, "ttl":"0s", "precache": true},
+	"derived_chargers": {"limit": 10000, "ttl":"0s", "precache": true},
+	"resource_profiles": {"limit": 10000, "ttl":"0s", "precache": true},
+	"resources": {"limit": 10000, "ttl":"0s", "precache": true},
+	"statqueues": {"limit": 10000, "ttl":"0s", "precache": true},
+	"statqueue_profiles": {"limit": 10000, "ttl":"0s", "precache": true},
+	"thresholds": {"limit": 10000, "ttl":"0s", "precache": true},
+	"threshold_profiles": {"limit": 10000, "ttl":"0s", "precache": true},
+	"filters": {"limit": 10000, "ttl":"0s", "precache": true},
+	"supplier_profiles": {"limit": 10000, "ttl":"0s", "precache": true},
+	"attribute_profiles": {"limit": 10000, "ttl":"0s", "precache": true},
+	"resource_filter_indexes" :{"limit": 10000, "ttl":"0s"},
+	"resource_filter_revindexes" : {"limit": 10000, "ttl":"0s"},
+	"stat_filter_indexes" : {"limit": 10000, "ttl":"0s"},
+	"stat_filter_revindexes" : {"limit": 10000, "ttl":"0s"},
+	"threshold_filter_indexes" : {"limit": 10000, "ttl":"0s"},
+	"threshold_filter_revindexes" : {"limit": 10000, "ttl":"0s"},
+	"supplier_filter_indexes" : {"limit": 10000, "ttl":"0s"},
+	"supplier_filter_revindexes" :{"limit": 10000, "ttl":"0s"},
+	"attribute_filter_indexes" : {"limit": 10000, "ttl":"0s"},
+	"attribute_filter_revindexes" : {"limit": 10000, "ttl":"0s"},
+},
+
+
+}
--- a/data/conf/samples/tutmongomsgpack/cgrates.json
+++ b/data/conf/samples/tutmongomsgpack/cgrates.json
@@ -0,0 +1,69 @@
+{
+// CGRateS Configuration file
+
+
+"general": {
+	"log_level": 7,
+	"reply_timeout": "30s",
+	"dbdata_encoding": "msgpack",
+},
+
+
+"listen": {
+	"rpc_json": ":2012",
+	"rpc_gob": ":2013",
+	"http": ":2080",
+},
+
+
+"data_db": {
+	"db_type": "mongo",
+	"db_name": "11",
+	"db_port": 27017,
+},
+
+
+"stor_db": {
+	"db_type": "mongo",
+	"db_port": 27017,
+},
+
+
+"cache":{
+	"destinations": {"limit": 10000, "ttl":"0s", "precache": true},
+	"reverse_destinations": {"limit": 10000, "ttl":"0s", "precache": true},
+	"rating_plans": {"limit": 10000, "ttl":"0s","precache": true},
+	"rating_profiles": {"limit": 10000, "ttl":"0s", "precache": true},
+	"lcr_rules": {"limit": 10000, "ttl":"0s", "precache": true},
+	"cdr_stats": {"limit": 10000, "ttl":"0s", "precache": true},
+	"actions": {"limit": 10000, "ttl":"0s", "precache": true},
+	"action_plans": {"limit": 10000, "ttl":"0s", "precache": true},
+	"account_action_plans": {"limit": 10000, "ttl":"0s", "precache": true},
+	"action_triggers": {"limit": 10000, "ttl":"0s", "precache": true},
+	"shared_groups": {"limit": 10000, "ttl":"0s", "precache": true},
+	"aliases": {"limit": 10000, "ttl":"0s", "precache": true},
+	"reverse_aliases": {"limit": 10000, "ttl":"0s", "precache": true},
+	"derived_chargers": {"limit": 10000, "ttl":"0s", "precache": true},
+	"resource_profiles": {"limit": 10000, "ttl":"0s", "precache": true},
+	"resources": {"limit": 10000, "ttl":"0s", "precache": true},
+	"statqueues": {"limit": 10000, "ttl":"0s", "precache": true},
+	"statqueue_profiles": {"limit": 10000, "ttl":"0s", "precache": true},
+	"thresholds": {"limit": 10000, "ttl":"0s", "precache": true},
+	"threshold_profiles": {"limit": 10000, "ttl":"0s", "precache": true},
+	"filters": {"limit": 10000, "ttl":"0s", "precache": true},
+	"supplier_profiles": {"limit": 10000, "ttl":"0s", "precache": true},
+	"attribute_profiles": {"limit": 10000, "ttl":"0s", "precache": true},
+	"resource_filter_indexes" :{"limit": 10000, "ttl":"0s"},
+	"resource_filter_revindexes" : {"limit": 10000, "ttl":"0s"},
+	"stat_filter_indexes" : {"limit": 10000, "ttl":"0s"},
+	"stat_filter_revindexes" : {"limit": 10000, "ttl":"0s"},
+	"threshold_filter_indexes" : {"limit": 10000, "ttl":"0s"},
+	"threshold_filter_revindexes" : {"limit": 10000, "ttl":"0s"},
+	"supplier_filter_indexes" : {"limit": 10000, "ttl":"0s"},
+	"supplier_filter_revindexes" :{"limit": 10000, "ttl":"0s"},
+	"attribute_filter_indexes" : {"limit": 10000, "ttl":"0s"},
+	"attribute_filter_revindexes" : {"limit": 10000, "ttl":"0s"},
+},
+
+
+}
--- a/data/conf/samples/tutmysqljson/cgrates.json
+++ b/data/conf/samples/tutmysqljson/cgrates.json
@@ -0,0 +1,67 @@
+{
+// CGRateS Configuration file
+//
+
+
+"general": {
+	"log_level": 7,
+	"dbdata_encoding": "json",							// encoding used to store object data in strings: <msgpack|json>
+},
+
+
+"listen": {
+	"rpc_json": ":2012",
+	"rpc_gob": ":2013",
+	"http": ":2080",
+},
+
+"data_db": {								// database used to store runtime data (eg: accounts, cdr stats)
+	"db_type": "redis",						// data_db type: <redis|mongo>
+	"db_port": 6379, 						// data_db port to reach the database
+	"db_name": "10", 						// data_db database name to connect to
+	
+},
+
+"stor_db": {
+	"db_password": "CGRateS.org",
+},
+
+
+"cache":{
+	"destinations": {"limit": 10000, "ttl":"0s", "precache": true},
+	"reverse_destinations": {"limit": 10000, "ttl":"0s", "precache": true},
+	"rating_plans": {"limit": 10000, "ttl":"0s","precache": true},
+	"rating_profiles": {"limit": 10000, "ttl":"0s", "precache": true},
+	"lcr_rules": {"limit": 10000, "ttl":"0s", "precache": true},
+	"cdr_stats": {"limit": 10000, "ttl":"0s", "precache": true},
+	"actions": {"limit": 10000, "ttl":"0s", "precache": true},
+	"action_plans": {"limit": 10000, "ttl":"0s", "precache": true},
+	"account_action_plans": {"limit": 10000, "ttl":"0s", "precache": true},
+	"action_triggers": {"limit": 10000, "ttl":"0s", "precache": true},
+	"shared_groups": {"limit": 10000, "ttl":"0s", "precache": true},
+	"aliases": {"limit": 10000, "ttl":"0s", "precache": true},
+	"reverse_aliases": {"limit": 10000, "ttl":"0s", "precache": true},
+	"derived_chargers": {"limit": 10000, "ttl":"0s", "precache": true},
+	"resource_profiles": {"limit": 10000, "ttl":"0s", "precache": true},
+	"resources": {"limit": 10000, "ttl":"0s", "precache": true},
+	"statqueues": {"limit": 10000, "ttl":"0s", "precache": true},
+	"statqueue_profiles": {"limit": 10000, "ttl":"0s", "precache": true},
+	"thresholds": {"limit": 10000, "ttl":"0s", "precache": true},
+	"threshold_profiles": {"limit": 10000, "ttl":"0s", "precache": true},
+	"filters": {"limit": 10000, "ttl":"0s", "precache": true},
+	"supplier_profiles": {"limit": 10000, "ttl":"0s", "precache": true},
+	"attribute_profiles": {"limit": 10000, "ttl":"0s", "precache": true},
+	"resource_filter_indexes" :{"limit": 10000, "ttl":"0s"},
+	"resource_filter_revindexes" : {"limit": 10000, "ttl":"0s"},
+	"stat_filter_indexes" : {"limit": 10000, "ttl":"0s"},
+	"stat_filter_revindexes" : {"limit": 10000, "ttl":"0s"},
+	"threshold_filter_indexes" : {"limit": 10000, "ttl":"0s"},
+	"threshold_filter_revindexes" : {"limit": 10000, "ttl":"0s"},
+	"supplier_filter_indexes" : {"limit": 10000, "ttl":"0s"},
+	"supplier_filter_revindexes" :{"limit": 10000, "ttl":"0s"},
+	"attribute_filter_indexes" : {"limit": 10000, "ttl":"0s"},
+	"attribute_filter_revindexes" : {"limit": 10000, "ttl":"0s"},
+},
+
+
+}
--- a/data/conf/samples/tutmysqlmsgpack/cgrates.json
+++ b/data/conf/samples/tutmysqlmsgpack/cgrates.json
@@ -0,0 +1,67 @@
+{
+// CGRateS Configuration file
+//
+
+
+"general": {
+	"log_level": 7,
+	"dbdata_encoding": "msgpack",							// encoding used to store object data in strings: <msgpack|json>
+},
+
+
+"listen": {
+	"rpc_json": ":2012",
+	"rpc_gob": ":2013",
+	"http": ":2080",
+},
+
+"data_db": {								// database used to store runtime data (eg: accounts, cdr stats)
+	"db_type": "redis",						// data_db type: <redis|mongo>
+	"db_port": 6379, 						// data_db port to reach the database
+	"db_name": "11", 						// data_db database name to connect to
+	
+},
+
+"stor_db": {
+	"db_password": "CGRateS.org",
+},
+
+
+"cache":{
+	"destinations": {"limit": 10000, "ttl":"0s", "precache": true},
+	"reverse_destinations": {"limit": 10000, "ttl":"0s", "precache": true},
+	"rating_plans": {"limit": 10000, "ttl":"0s","precache": true},
+	"rating_profiles": {"limit": 10000, "ttl":"0s", "precache": true},
+	"lcr_rules": {"limit": 10000, "ttl":"0s", "precache": true},
+	"cdr_stats": {"limit": 10000, "ttl":"0s", "precache": true},
+	"actions": {"limit": 10000, "ttl":"0s", "precache": true},
+	"action_plans": {"limit": 10000, "ttl":"0s", "precache": true},
+	"account_action_plans": {"limit": 10000, "ttl":"0s", "precache": true},
+	"action_triggers": {"limit": 10000, "ttl":"0s", "precache": true},
+	"shared_groups": {"limit": 10000, "ttl":"0s", "precache": true},
+	"aliases": {"limit": 10000, "ttl":"0s", "precache": true},
+	"reverse_aliases": {"limit": 10000, "ttl":"0s", "precache": true},
+	"derived_chargers": {"limit": 10000, "ttl":"0s", "precache": true},
+	"resource_profiles": {"limit": 10000, "ttl":"0s", "precache": true},
+	"resources": {"limit": 10000, "ttl":"0s", "precache": true},
+	"statqueues": {"limit": 10000, "ttl":"0s", "precache": true},
+	"statqueue_profiles": {"limit": 10000, "ttl":"0s", "precache": true},
+	"thresholds": {"limit": 10000, "ttl":"0s", "precache": true},
+	"threshold_profiles": {"limit": 10000, "ttl":"0s", "precache": true},
+	"filters": {"limit": 10000, "ttl":"0s", "precache": true},
+	"supplier_profiles": {"limit": 10000, "ttl":"0s", "precache": true},
+	"attribute_profiles": {"limit": 10000, "ttl":"0s", "precache": true},
+	"resource_filter_indexes" :{"limit": 10000, "ttl":"0s"},
+	"resource_filter_revindexes" : {"limit": 10000, "ttl":"0s"},
+	"stat_filter_indexes" : {"limit": 10000, "ttl":"0s"},
+	"stat_filter_revindexes" : {"limit": 10000, "ttl":"0s"},
+	"threshold_filter_indexes" : {"limit": 10000, "ttl":"0s"},
+	"threshold_filter_revindexes" : {"limit": 10000, "ttl":"0s"},
+	"supplier_filter_indexes" : {"limit": 10000, "ttl":"0s"},
+	"supplier_filter_revindexes" :{"limit": 10000, "ttl":"0s"},
+	"attribute_filter_indexes" : {"limit": 10000, "ttl":"0s"},
+	"attribute_filter_revindexes" : {"limit": 10000, "ttl":"0s"},
+},
+
+
+}
--- a/migrator/accounts_it_test.go
+++ b/migrator/accounts_it_test.go
@@ -102,6 +102,42 @@ func TestAccountITMove(t *testing.T) {
 	}
 }

+func TestAccountITMoveEncoding(t *testing.T) {
+	var err error
+	accPathIn = path.Join(*dataDir, "conf", "samples", "tutmongojson")
+	accCfgIn, err = config.NewCGRConfigFromFolder(accPathIn)
+	if err != nil {
+		t.Fatal(err)
+	}
+	accPathOut = path.Join(*dataDir, "conf", "samples", "tutmongomsgpack")
+	accCfgOut, err = config.NewCGRConfigFromFolder(accPathOut)
+	if err != nil {
+		t.Fatal(err)
+	}
+	accAction = utils.Move
+	for _, stest := range sTestsAccIT {
+		t.Run("TestAccountITMove", stest)
+	}
+}
+
+func TestAccountITMoveEncoding2(t *testing.T) {
+	var err error
+	accPathIn = path.Join(*dataDir, "conf", "samples", "tutmysqljson")
+	accCfgIn, err = config.NewCGRConfigFromFolder(accPathIn)
+	if err != nil {
+		t.Fatal(err)
+	}
+	accPathOut = path.Join(*dataDir, "conf", "samples", "tutmysqlmsgpack")
+	accCfgOut, err = config.NewCGRConfigFromFolder(accPathOut)
+	if err != nil {
+		t.Fatal(err)
+	}
+	accAction = utils.Move
+	for _, stest := range sTestsAccIT {
+		t.Run("TestAccountITMove", stest)
+	}
+}
+
 func testAccITConnect(t *testing.T) {
 	dataDBIn, err := NewMigratorDataDB(accCfgIn.DataDbType,
 		accCfgIn.DataDbHost, accCfgIn.DataDbPort, accCfgIn.DataDbName,
--- a/migrator/action_it_test.go
+++ b/migrator/action_it_test.go
@@ -0,0 +1,251 @@
+// +build integration
+
+/*
+Real-time Online/Offline Charging System (OCS) for Telecom & ISP environments
+Copyright (C) ITsysCOM GmbH
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>
+*/
+
+package migrator
+
+import (
+	//"flag"
+	"log"
+	"path"
+	"reflect"
+	"testing"
+
+	"github.com/cgrates/cgrates/config"
+	"github.com/cgrates/cgrates/engine"
+	"github.com/cgrates/cgrates/utils"
+)
+
+var (
+	actPathIn   string
+	actPathOut  string
+	actCfgIn    *config.CGRConfig
+	actCfgOut   *config.CGRConfig
+	actMigrator *Migrator
+	actAction   string
+)
+
+var sTestsActIT = []func(t *testing.T){
+	testActITConnect,
+	testActITFlush,
+	testActITMigrateAndMove,
+}
+
+func TestActionITRedis(t *testing.T) {
+	var err error
+	actPathIn = path.Join(*dataDir, "conf", "samples", "tutmysql")
+	actCfgIn, err = config.NewCGRConfigFromFolder(actPathIn)
+	if err != nil {
+		t.Fatal(err)
+	}
+	actCfgOut, err = config.NewCGRConfigFromFolder(actPathIn)
+	if err != nil {
+		t.Fatal(err)
+	}
+	actAction = utils.Migrate
+	for _, stest := range sTestsActIT {
+		t.Run("TestActionITMigrateRedis", stest)
+	}
+}
+
+func TestActionITMongo(t *testing.T) {
+	var err error
+	actPathIn = path.Join(*dataDir, "conf", "samples", "tutmongo")
+	actCfgIn, err = config.NewCGRConfigFromFolder(actPathIn)
+	if err != nil {
+		t.Fatal(err)
+	}
+	actCfgOut, err = config.NewCGRConfigFromFolder(actPathIn)
+	if err != nil {
+		t.Fatal(err)
+	}
+	actAction = utils.Migrate
+	for _, stest := range sTestsActIT {
+		t.Run("TestActionITMigrateMongo", stest)
+	}
+}
+
+func TestActionITMove(t *testing.T) {
+	var err error
+	actPathIn = path.Join(*dataDir, "conf", "samples", "tutmongo")
+	actCfgIn, err = config.NewCGRConfigFromFolder(actPathIn)
+	if err != nil {
+		t.Fatal(err)
+	}
+	actPathOut = path.Join(*dataDir, "conf", "samples", "tutmysql")
+	actCfgOut, err = config.NewCGRConfigFromFolder(actPathOut)
+	if err != nil {
+		t.Fatal(err)
+	}
+	actAction = utils.Move
+	for _, stest := range sTestsActIT {
+		t.Run("TestActionITMove", stest)
+	}
+}
+
+func TestActionITMoveEncoding(t *testing.T) {
+	var err error
+	actPathIn = path.Join(*dataDir, "conf", "samples", "tutmongojson")
+	actCfgIn, err = config.NewCGRConfigFromFolder(actPathIn)
+	if err != nil {
+		t.Fatal(err)
+	}
+	actPathOut = path.Join(*dataDir, "conf", "samples", "tutmongomsgpack")
+	actCfgOut, err = config.NewCGRConfigFromFolder(actPathOut)
+	if err != nil {
+		t.Fatal(err)
+	}
+	actAction = utils.Move
+	for _, stest := range sTestsActIT {
+		t.Run("TestActionITMoveEncoding", stest)
+	}
+}
+
+func TestActionITMoveEncoding2(t *testing.T) {
+	var err error
+	actPathIn = path.Join(*dataDir, "conf", "samples", "tutmysqljson")
+	actCfgIn, err = config.NewCGRConfigFromFolder(actPathIn)
+	if err != nil {
+		t.Fatal(err)
+	}
+	actPathOut = path.Join(*dataDir, "conf", "samples", "tutmysqlmsgpack")
+	actCfgOut, err = config.NewCGRConfigFromFolder(actPathOut)
+	if err != nil {
+		t.Fatal(err)
+	}
+	actAction = utils.Move
+	for _, stest := range sTestsActIT {
+		t.Run("TestActionITMoveEncoding2", stest)
+	}
+}
+
+func testActITConnect(t *testing.T) {
+	dataDBIn, err := NewMigratorDataDB(actCfgIn.DataDbType,
+		actCfgIn.DataDbHost, actCfgIn.DataDbPort, actCfgIn.DataDbName,
+		actCfgIn.DataDbUser, actCfgIn.DataDbPass, actCfgIn.DBDataEncoding,
+		config.CgrConfig().CacheCfg(), *loadHistorySize)
+	if err != nil {
+		log.Fatal(err)
+	}
+	dataDBOut, err := NewMigratorDataDB(actCfgOut.DataDbType,
+		actCfgOut.DataDbHost, actCfgOut.DataDbPort, actCfgOut.DataDbName,
+		actCfgOut.DataDbUser, actCfgOut.DataDbPass, actCfgOut.DBDataEncoding,
+		config.CgrConfig().CacheCfg(), *loadHistorySize)
+	if err != nil {
+		log.Fatal(err)
+	}
+	actMigrator, err = NewMigrator(dataDBIn, dataDBOut,
+		nil, nil,
+		false, false, false)
+	if err != nil {
+		log.Fatal(err)
+	}
+}
+
+func testActITFlush(t *testing.T) {
+	actMigrator.dmOut.DataManager().DataDB().Flush("")
+	if err := engine.SetDBVersions(actMigrator.dmOut.DataManager().DataDB()); err != nil {
+		t.Error("Error  ", err.Error())
+	}
+}
+
+func testActITMigrateAndMove(t *testing.T) {
+	v1act := &v1Actions{
+		&v1Action{
+			Id:               "test",
+			ActionType:       "",
+			BalanceType:      "",
+			Direction:        "INBOUND",
+			ExtraParameters:  "",
+			ExpirationString: "",
+			Balance: &v1Balance{
+				Timings: []*engine.RITiming{
+					&engine.RITiming{
+						Years:     utils.Years{},
+						Months:    utils.Months{},
+						MonthDays: utils.MonthDays{},
+						WeekDays:  utils.WeekDays{},
+					},
+				},
+			},
+		},
+	}
+	act := &engine.Actions{
+		&engine.Action{
+			Id:               "test",
+			ActionType:       "",
+			ExtraParameters:  "",
+			ExpirationString: "",
+			Weight:           0.00,
+			Balance: &engine.BalanceFilter{
+				Timings: []*engine.RITiming{
+					&engine.RITiming{
+						Years:     utils.Years{},
+						Months:    utils.Months{},
+						MonthDays: utils.MonthDays{},
+						WeekDays:  utils.WeekDays{},
+					},
+				},
+			},
+		},
+	}
+	switch accAction {
+	case utils.Migrate:
+		err := actMigrator.dmIN.setV1Actions(v1act)
+		if err != nil {
+			t.Error("Error when setting v1 Actions ", err.Error())
+		}
+		currentVersion := engine.Versions{utils.StatS: 2, utils.Thresholds: 2, utils.Accounts: 2, utils.Actions: 1, utils.ActionTriggers: 2, utils.ActionPlans: 2, utils.SharedGroups: 2}
+		err = actMigrator.dmOut.DataManager().DataDB().SetVersions(currentVersion, false)
+		if err != nil {
+			t.Error("Error when setting version for Actions ", err.Error())
+		}
+		err, _ = actMigrator.Migrate([]string{utils.MetaActions})
+		if err != nil {
+			t.Error("Error when migrating Actions ", err.Error())
+		}
+		result, err := actMigrator.dmOut.DataManager().GetActions((*v1act)[0].Id, true, utils.NonTransactional)
+		if err != nil {
+			t.Error("Error when getting Actions ", err.Error())
+		}
+		if !reflect.DeepEqual(*act, result) {
+			t.Errorf("Expecting: %+v, received: %+v", *act, result)
+		}
+	case utils.Move:
+		if err := actMigrator.dmIN.DataManager().SetActions((*v1act)[0].Id, *act, utils.NonTransactional); err != nil {
+			t.Error("Error when setting ActionPlan ", err.Error())
+		}
+		currentVersion := engine.CurrentDataDBVersions()
+		err := actMigrator.dmOut.DataManager().DataDB().SetVersions(currentVersion, false)
+		if err != nil {
+			t.Error("Error when setting version for Actions ", err.Error())
+		}
+		err, _ = actMigrator.Migrate([]string{utils.MetaActions})
+		if err != nil {
+			t.Error("Error when migrating Actions ", err.Error())
+		}
+		result, err := actMigrator.dmOut.DataManager().GetActions((*v1act)[0].Id, true, utils.NonTransactional)
+		if err != nil {
+			t.Error("Error when getting Actions ", err.Error())
+		}
+		if !reflect.DeepEqual(*act, result) {
+			t.Errorf("Expecting: %+v, received: %+v", *act, result)
+		}
+	}
+}
--- a/migrator/action_plan_it_test.go
+++ b/migrator/action_plan_it_test.go
@@ -0,0 +1,244 @@
+// +build integration
+
+/*
+Real-time Online/Offline Charging System (OCS) for Telecom & ISP environments
+Copyright (C) ITsysCOM GmbH
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>
+*/
+
+package migrator
+
+import (
+	//"flag"
+	"log"
+	"path"
+	"reflect"
+	"testing"
+
+	"github.com/cgrates/cgrates/config"
+	"github.com/cgrates/cgrates/engine"
+	"github.com/cgrates/cgrates/utils"
+)
+
+var (
+	actPlnPathIn   string
+	actPlnPathOut  string
+	actPlnCfgIn    *config.CGRConfig
+	actPlnCfgOut   *config.CGRConfig
+	actPlnMigrator *Migrator
+	actActionPlan  string
+)
+
+var sTestsActPlnIT = []func(t *testing.T){
+	testActPlnITConnect,
+	testActPlnITFlush,
+	testActPlnITMigrateAndMove,
+}
+
+func TestActionPlanITRedis(t *testing.T) {
+	var err error
+	actPlnPathIn = path.Join(*dataDir, "conf", "samples", "tutmysql")
+	actPlnCfgIn, err = config.NewCGRConfigFromFolder(actPlnPathIn)
+	if err != nil {
+		t.Fatal(err)
+	}
+	actPlnCfgOut, err = config.NewCGRConfigFromFolder(actPlnPathIn)
+	if err != nil {
+		t.Fatal(err)
+	}
+	actActionPlan = utils.Migrate
+	for _, stest := range sTestsActPlnIT {
+		t.Run("TestActionPlanITMigrateRedis", stest)
+	}
+}
+
+func TestActionPlanITMongo(t *testing.T) {
+	var err error
+	actPlnPathIn = path.Join(*dataDir, "conf", "samples", "tutmongo")
+	actPlnCfgIn, err = config.NewCGRConfigFromFolder(actPlnPathIn)
+	if err != nil {
+		t.Fatal(err)
+	}
+	actPlnCfgOut, err = config.NewCGRConfigFromFolder(actPlnPathIn)
+	if err != nil {
+		t.Fatal(err)
+	}
+	actActionPlan = utils.Migrate
+	for _, stest := range sTestsActPlnIT {
+		t.Run("TestActionPlanITMigrateMongo", stest)
+	}
+}
+
+func TestActionPlanITMove(t *testing.T) {
+	var err error
+	actPlnPathIn = path.Join(*dataDir, "conf", "samples", "tutmongo")
+	actPlnCfgIn, err = config.NewCGRConfigFromFolder(actPlnPathIn)
+	if err != nil {
+		t.Fatal(err)
+	}
+	actPlnPathOut = path.Join(*dataDir, "conf", "samples", "tutmysql")
+	actPlnCfgOut, err = config.NewCGRConfigFromFolder(actPlnPathOut)
+	if err != nil {
+		t.Fatal(err)
+	}
+	actActionPlan = utils.Move
+	for _, stest := range sTestsActPlnIT {
+		t.Run("TestActionPlanITMove", stest)
+	}
+}
+
+func TestActionPlanITMoveEncoding(t *testing.T) {
+	var err error
+	actPlnPathIn = path.Join(*dataDir, "conf", "samples", "tutmongojson")
+	actPlnCfgIn, err = config.NewCGRConfigFromFolder(actPlnPathIn)
+	if err != nil {
+		t.Fatal(err)
+	}
+	actPlnPathOut = path.Join(*dataDir, "conf", "samples", "tutmongomsgpack")
+	actPlnCfgOut, err = config.NewCGRConfigFromFolder(actPlnPathOut)
+	if err != nil {
+		t.Fatal(err)
+	}
+	actActionPlan = utils.Move
+	for _, stest := range sTestsActPlnIT {
+		t.Run("TestActionPlanITMoveEncoding", stest)
+	}
+}
+
+func TestActionPlanITMoveEncoding2(t *testing.T) {
+	var err error
+	actPlnPathIn = path.Join(*dataDir, "conf", "samples", "tutmysqljson")
+	actPlnCfgIn, err = config.NewCGRConfigFromFolder(actPlnPathIn)
+	if err != nil {
+		t.Fatal(err)
+	}
+	actPlnPathOut = path.Join(*dataDir, "conf", "samples", "tutmysqlmsgpack")
+	actPlnCfgOut, err = config.NewCGRConfigFromFolder(actPlnPathOut)
+	if err != nil {
+		t.Fatal(err)
+	}
+	actActionPlan = utils.Move
+	for _, stest := range sTestsActPlnIT {
+		t.Run("TestActionPlanITMoveEncoding2", stest)
+	}
+}
+
+func testActPlnITConnect(t *testing.T) {
+	dataDBIn, err := NewMigratorDataDB(actPlnCfgIn.DataDbType,
+		actPlnCfgIn.DataDbHost, actPlnCfgIn.DataDbPort, actPlnCfgIn.DataDbName,
+		actPlnCfgIn.DataDbUser, actPlnCfgIn.DataDbPass, actPlnCfgIn.DBDataEncoding,
+		config.CgrConfig().CacheCfg(), *loadHistorySize)
+	if err != nil {
+		log.Fatal(err)
+	}
+	dataDBOut, err := NewMigratorDataDB(actPlnCfgOut.DataDbType,
+		actPlnCfgOut.DataDbHost, actPlnCfgOut.DataDbPort, actPlnCfgOut.DataDbName,
+		actPlnCfgOut.DataDbUser, actPlnCfgOut.DataDbPass, actPlnCfgOut.DBDataEncoding,
+		config.CgrConfig().CacheCfg(), *loadHistorySize)
+	if err != nil {
+		log.Fatal(err)
+	}
+	actPlnMigrator, err = NewMigrator(dataDBIn, dataDBOut,
+		nil, nil,
+		false, false, false)
+	if err != nil {
+		log.Fatal(err)
+	}
+}
+
+func testActPlnITFlush(t *testing.T) {
+	actPlnMigrator.dmOut.DataManager().DataDB().Flush("")
+	if err := engine.SetDBVersions(actPlnMigrator.dmOut.DataManager().DataDB()); err != nil {
+		t.Error("Error  ", err.Error())
+	}
+}
+
+func testActPlnITMigrateAndMove(t *testing.T) {
+	v1actPln := &v1ActionPlans{
+		&v1ActionPlan{
+			Id:         "test",
+			AccountIds: []string{"one"},
+			Timing: &engine.RateInterval{
+				Timing: &engine.RITiming{
+					Years:     utils.Years{},
+					Months:    utils.Months{},
+					MonthDays: utils.MonthDays{},
+					WeekDays:  utils.WeekDays{},
+				},
+			},
+		},
+	}
+
+	actPln := &engine.ActionPlan{
+		Id:         "test",
+		AccountIDs: utils.StringMap{"one": true},
+		ActionTimings: []*engine.ActionTiming{
+			&engine.ActionTiming{
+				Timing: &engine.RateInterval{
+					Timing: &engine.RITiming{
+						Years:     utils.Years{},
+						Months:    utils.Months{},
+						MonthDays: utils.MonthDays{},
+						WeekDays:  utils.WeekDays{},
+					},
+				},
+			},
+		},
+	}
+
+	switch accAction {
+	case utils.Migrate:
+		err := actPlnMigrator.dmIN.setV1ActionPlans(v1actPln)
+		if err != nil {
+			t.Error("Error when setting v1 ActionPlan ", err.Error())
+		}
+		currentVersion := engine.Versions{utils.StatS: 2, utils.Thresholds: 2, utils.Accounts: 2, utils.Actions: 2, utils.ActionTriggers: 2, utils.ActionPlans: 1, utils.SharedGroups: 2}
+		err = actPlnMigrator.dmOut.DataManager().DataDB().SetVersions(currentVersion, false)
+		if err != nil {
+			t.Error("Error when setting version for ActionPlan ", err.Error())
+		}
+		err, _ = actPlnMigrator.Migrate([]string{utils.AccountActionPlansPrefix})
+		if err != nil {
+			t.Error("Error when migrating ActionPlan ", err.Error())
+		}
+		result, err := actPlnMigrator.dmOut.DataManager().DataDB().GetActionPlan((*v1actPln)[0].Id, true, utils.NonTransactional)
+		if err != nil {
+			t.Error("Error when getting ActionPlan ", err.Error())
+		}
+		if !reflect.DeepEqual(*actPln, result) {
+			t.Errorf("Expecting: %+v, received: %+v", *actPln, result)
+		}
+	case utils.Move:
+		if err := actPlnMigrator.dmIN.DataManager().DataDB().SetActionPlan((*v1actPln)[0].Id, actPln, true, utils.NonTransactional); err != nil {
+			t.Error("Error when setting ActionPlan ", err.Error())
+		}
+		currentVersion := engine.CurrentDataDBVersions()
+		err := actPlnMigrator.dmOut.DataManager().DataDB().SetVersions(currentVersion, false)
+		if err != nil {
+			t.Error("Error when setting version for ActionPlan ", err.Error())
+		}
+		err, _ = actPlnMigrator.Migrate([]string{utils.MetaActions})
+		if err != nil {
+			t.Error("Error when migrating ActionPlan ", err.Error())
+		}
+		result, err := actPlnMigrator.dmOut.DataManager().DataDB().GetActionPlan((*v1actPln)[0].Id, true, utils.NonTransactional)
+		if err != nil {
+			t.Error("Error when getting ActionPlan ", err.Error())
+		}
+		if !reflect.DeepEqual(*actPln, result) {
+			t.Errorf("Expecting: %+v, received: %+v", *actPln, result)
+		}
+	}
+}
--- a/migrator/action_trigger_it_test.go
+++ b/migrator/action_trigger_it_test.go
@@ -0,0 +1,245 @@
+// +build integration
+
+/*
+Real-time Online/Offline Charging System (OCS) for Telecom & ISP environments
+Copyright (C) ITsysCOM GmbH
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>
+*/
+
+package migrator
+
+import (
+	//"flag"
+	"log"
+	"path"
+	"reflect"
+	"testing"
+	"time"
+
+	"github.com/cgrates/cgrates/config"
+	"github.com/cgrates/cgrates/engine"
+	"github.com/cgrates/cgrates/utils"
+)
+
+var (
+	actTrgPathIn     string
+	actTrgPathOut    string
+	actTrgCfgIn      *config.CGRConfig
+	actTrgCfgOut     *config.CGRConfig
+	actTrgMigrator   *Migrator
+	actActionTrigger string
+)
+
+var sTestsActTrgIT = []func(t *testing.T){
+	testActTrgITConnect,
+	testActTrgITFlush,
+	testActTrgITMigrateAndMove,
+}
+
+func TestActionTriggerITRedis(t *testing.T) {
+	var err error
+	actTrgPathIn = path.Join(*dataDir, "conf", "samples", "tutmysql")
+	actTrgCfgIn, err = config.NewCGRConfigFromFolder(actTrgPathIn)
+	if err != nil {
+		t.Fatal(err)
+	}
+	actTrgCfgOut, err = config.NewCGRConfigFromFolder(actTrgPathIn)
+	if err != nil {
+		t.Fatal(err)
+	}
+	actActionTrigger = utils.Migrate
+	for _, stest := range sTestsActTrgIT {
+		t.Run("TestActionTriggerITMigrateRedis", stest)
+	}
+}
+
+func TestActionTriggerITMongo(t *testing.T) {
+	var err error
+	actTrgPathIn = path.Join(*dataDir, "conf", "samples", "tutmongo")
+	actTrgCfgIn, err = config.NewCGRConfigFromFolder(actTrgPathIn)
+	if err != nil {
+		t.Fatal(err)
+	}
+	actTrgCfgOut, err = config.NewCGRConfigFromFolder(actTrgPathIn)
+	if err != nil {
+		t.Fatal(err)
+	}
+	actActionTrigger = utils.Migrate
+	for _, stest := range sTestsActTrgIT {
+		t.Run("TestActionTriggerITMigrateMongo", stest)
+	}
+}
+
+func TestActionTriggerITMove(t *testing.T) {
+	var err error
+	actTrgPathIn = path.Join(*dataDir, "conf", "samples", "tutmongo")
+	actTrgCfgIn, err = config.NewCGRConfigFromFolder(actTrgPathIn)
+	if err != nil {
+		t.Fatal(err)
+	}
+	actTrgPathOut = path.Join(*dataDir, "conf", "samples", "tutmysql")
+	actTrgCfgOut, err = config.NewCGRConfigFromFolder(actTrgPathOut)
+	if err != nil {
+		t.Fatal(err)
+	}
+	actActionTrigger = utils.Move
+	for _, stest := range sTestsActTrgIT {
+		t.Run("TestActionTriggerITMove", stest)
+	}
+}
+
+func TestActionTriggerITMoveEncoding(t *testing.T) {
+	var err error
+	actTrgPathIn = path.Join(*dataDir, "conf", "samples", "tutmongojson")
+	actTrgCfgIn, err = config.NewCGRConfigFromFolder(actTrgPathIn)
+	if err != nil {
+		t.Fatal(err)
+	}
+	actTrgPathOut = path.Join(*dataDir, "conf", "samples", "tutmongomsgpack")
+	actTrgCfgOut, err = config.NewCGRConfigFromFolder(actTrgPathOut)
+	if err != nil {
+		t.Fatal(err)
+	}
+	actActionTrigger = utils.Move
+	for _, stest := range sTestsActTrgIT {
+		t.Run("TestActionTriggerITMoveEncoding", stest)
+	}
+}
+
+func TestActionTriggerITMoveEncoding2(t *testing.T) {
+	var err error
+	actTrgPathIn = path.Join(*dataDir, "conf", "samples", "tutmysqljson")
+	actTrgCfgIn, err = config.NewCGRConfigFromFolder(actTrgPathIn)
+	if err != nil {
+		t.Fatal(err)
+	}
+	actTrgPathOut = path.Join(*dataDir, "conf", "samples", "tutmysqlmsgpack")
+	actTrgCfgOut, err = config.NewCGRConfigFromFolder(actTrgPathOut)
+	if err != nil {
+		t.Fatal(err)
+	}
+	actActionTrigger = utils.Move
+	for _, stest := range sTestsActTrgIT {
+		t.Run("TestActionTriggerITMoveEncoding2", stest)
+	}
+}
+
+func testActTrgITConnect(t *testing.T) {
+	dataDBIn, err := NewMigratorDataDB(actTrgCfgIn.DataDbType,
+		actTrgCfgIn.DataDbHost, actTrgCfgIn.DataDbPort, actTrgCfgIn.DataDbName,
+		actTrgCfgIn.DataDbUser, actTrgCfgIn.DataDbPass, actTrgCfgIn.DBDataEncoding,
+		config.CgrConfig().CacheCfg(), *loadHistorySize)
+	if err != nil {
+		log.Fatal(err)
+	}
+	dataDBOut, err := NewMigratorDataDB(actTrgCfgOut.DataDbType,
+		actTrgCfgOut.DataDbHost, actTrgCfgOut.DataDbPort, actTrgCfgOut.DataDbName,
+		actTrgCfgOut.DataDbUser, actTrgCfgOut.DataDbPass, actTrgCfgOut.DBDataEncoding,
+		config.CgrConfig().CacheCfg(), *loadHistorySize)
+	if err != nil {
+		log.Fatal(err)
+	}
+	actTrgMigrator, err = NewMigrator(dataDBIn, dataDBOut,
+		nil, nil,
+		false, false, false)
+	if err != nil {
+		log.Fatal(err)
+	}
+}
+
+func testActTrgITFlush(t *testing.T) {
+	actTrgMigrator.dmOut.DataManager().DataDB().Flush("")
+	if err := engine.SetDBVersions(actTrgMigrator.dmOut.DataManager().DataDB()); err != nil {
+		t.Error("Error  ", err.Error())
+	}
+}
+
+func testActTrgITMigrateAndMove(t *testing.T) {
+	tim := time.Date(2012, time.February, 27, 23, 59, 59, 0, time.UTC)
+	v1actTrg := &v1ActionTriggers{
+		&v1ActionTrigger{
+			Id:                    "Test",
+			BalanceType:           "*monetary",
+			BalanceDirection:      "*out",
+			ThresholdType:         "*max_balance",
+			ThresholdValue:        2,
+			ActionsId:             "TEST_ACTIONS",
+			Executed:              true,
+			BalanceExpirationDate: tim,
+		},
+	}
+	actTrg := engine.ActionTriggers{
+		&engine.ActionTrigger{
+			ID: "Test",
+			Balance: &engine.BalanceFilter{
+				Timings:        []*engine.RITiming{},
+				ExpirationDate: utils.TimePointer(tim),
+				Type:           utils.StringPointer(utils.MONETARY),
+				Directions:     utils.StringMapPointer(utils.NewStringMap(utils.OUT)),
+			},
+			ExpirationDate:    tim,
+			LastExecutionTime: tim,
+			ActivationDate:    tim,
+			ThresholdType:     utils.TRIGGER_MAX_BALANCE,
+			ThresholdValue:    2,
+			ActionsID:         "TEST_ACTIONS",
+			Executed:          true,
+		},
+	}
+
+	switch accAction {
+	case utils.Migrate:
+		err := actTrgMigrator.dmIN.setV1ActionTriggers(v1actTrg)
+		if err != nil {
+			t.Error("Error when setting v1 ActionTriggers ", err.Error())
+		}
+		currentVersion := engine.Versions{utils.StatS: 2, utils.Thresholds: 2, utils.Accounts: 2, utils.Actions: 2, utils.ActionTriggers: 1, utils.ActionPlans: 2, utils.SharedGroups: 2}
+		err = actTrgMigrator.dmOut.DataManager().DataDB().SetVersions(currentVersion, false)
+		if err != nil {
+			t.Error("Error when setting version for ActionTriggers ", err.Error())
+		}
+		err, _ = actTrgMigrator.Migrate([]string{utils.AccountActionPlansPrefix})
+		if err != nil {
+			t.Error("Error when migrating ActionTriggers ", err.Error())
+		}
+		result, err := actTrgMigrator.dmOut.DataManager().DataDB().GetActionTriggersDrv((*v1actTrg)[0].Id)
+		if err != nil {
+			t.Error("Error when getting ActionTriggers ", err.Error())
+		}
+		if !reflect.DeepEqual(&actTrg, result) {
+			t.Errorf("Expecting: %+v, received: %+v", &actTrg, result)
+		}
+	case utils.Move:
+		if err := actTrgMigrator.dmIN.DataManager().DataDB().SetActionTriggersDrv((*v1actTrg)[0].Id, actTrg); err != nil {
+			t.Error("Error when setting ActionTriggers ", err.Error())
+		}
+		currentVersion := engine.CurrentDataDBVersions()
+		err := actTrgMigrator.dmOut.DataManager().DataDB().SetVersions(currentVersion, false)
+		if err != nil {
+			t.Error("Error when setting version for ActionTriggers ", err.Error())
+		}
+		err, _ = actTrgMigrator.Migrate([]string{utils.MetaActionTriggers})
+		if err != nil {
+			t.Error("Error when migrating ActionTriggers ", err.Error())
+		}
+		result, err := actTrgMigrator.dmOut.DataManager().DataDB().GetActionTriggersDrv((*v1actTrg)[0].Id)
+		if err != nil {
+			t.Error("Error when getting ActionTriggers ", err.Error())
+		}
+		if !reflect.DeepEqual(&actTrg, result) {
+			t.Errorf("Expecting: %+v, received: %+v", &actTrg, result)
+		}
+	}
+}
--- a/migrator/migrator_it_test.go
+++ b/migrator/migrator_it_test.go
--- a/migrator/sharedgroup_it_test.go
+++ b/migrator/sharedgroup_it_test.go
@@ -0,0 +1,226 @@
+// +build integration
+
+/*
+Real-time Online/Offline Charging System (OCS) for Telecom & ISP environments
+Copyright (C) ITsysCOM GmbH
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>
+*/
+
+package migrator
+
+import (
+	"log"
+	"path"
+	"reflect"
+	"testing"
+
+	"github.com/cgrates/cgrates/config"
+	"github.com/cgrates/cgrates/engine"
+	"github.com/cgrates/cgrates/utils"
+)
+
+var (
+	shrGrpPathIn   string
+	shrGrpPathOut  string
+	shrGrpCfgIn    *config.CGRConfig
+	shrGrpCfgOut   *config.CGRConfig
+	shrGrpMigrator *Migrator
+	shrSharedGroup string
+)
+
+var sTestsShrGrpIT = []func(t *testing.T){
+	testShrGrpITConnect,
+	testShrGrpITFlush,
+	testShrGrpITMigrateAndMove,
+}
+
+func TestSharedGroupITRedis(t *testing.T) {
+	var err error
+	shrGrpPathIn = path.Join(*dataDir, "conf", "samples", "tutmysql")
+	shrGrpCfgIn, err = config.NewCGRConfigFromFolder(shrGrpPathIn)
+	if err != nil {
+		t.Fatal(err)
+	}
+	shrGrpCfgOut, err = config.NewCGRConfigFromFolder(shrGrpPathIn)
+	if err != nil {
+		t.Fatal(err)
+	}
+	shrSharedGroup = utils.Migrate
+	for _, stest := range sTestsShrGrpIT {
+		t.Run("TestSharedGroupITMigrateRedis", stest)
+	}
+}
+
+func TestSharedGroupITMongo(t *testing.T) {
+	var err error
+	shrGrpPathIn = path.Join(*dataDir, "conf", "samples", "tutmongo")
+	shrGrpCfgIn, err = config.NewCGRConfigFromFolder(shrGrpPathIn)
+	if err != nil {
+		t.Fatal(err)
+	}
+	shrGrpCfgOut, err = config.NewCGRConfigFromFolder(shrGrpPathIn)
+	if err != nil {
+		t.Fatal(err)
+	}
+	shrSharedGroup = utils.Migrate
+	for _, stest := range sTestsShrGrpIT {
+		t.Run("TestSharedGroupITMigrateMongo", stest)
+	}
+}
+
+func TestSharedGroupITMove(t *testing.T) {
+	var err error
+	shrGrpPathIn = path.Join(*dataDir, "conf", "samples", "tutmongo")
+	shrGrpCfgIn, err = config.NewCGRConfigFromFolder(shrGrpPathIn)
+	if err != nil {
+		t.Fatal(err)
+	}
+	shrGrpPathOut = path.Join(*dataDir, "conf", "samples", "tutmysql")
+	shrGrpCfgOut, err = config.NewCGRConfigFromFolder(shrGrpPathOut)
+	if err != nil {
+		t.Fatal(err)
+	}
+	shrSharedGroup = utils.Move
+	for _, stest := range sTestsShrGrpIT {
+		t.Run("TestSharedGroupITMove", stest)
+	}
+}
+
+func TestSharedGroupITMoveEncoding(t *testing.T) {
+	var err error
+	shrGrpPathIn = path.Join(*dataDir, "conf", "samples", "tutmongojson")
+	shrGrpCfgIn, err = config.NewCGRConfigFromFolder(shrGrpPathIn)
+	if err != nil {
+		t.Fatal(err)
+	}
+	shrGrpPathOut = path.Join(*dataDir, "conf", "samples", "tutmongomsgpack")
+	shrGrpCfgOut, err = config.NewCGRConfigFromFolder(shrGrpPathOut)
+	if err != nil {
+		t.Fatal(err)
+	}
+	shrSharedGroup = utils.Move
+	for _, stest := range sTestsShrGrpIT {
+		t.Run("TestSharedGroupITMoveEncoding", stest)
+	}
+}
+
+func TestSharedGroupITMoveEncoding2(t *testing.T) {
+	var err error
+	shrGrpPathIn = path.Join(*dataDir, "conf", "samples", "tutmysqljson")
+	shrGrpCfgIn, err = config.NewCGRConfigFromFolder(shrGrpPathIn)
+	if err != nil {
+		t.Fatal(err)
+	}
+	shrGrpPathOut = path.Join(*dataDir, "conf", "samples", "tutmysqlmsgpack")
+	shrGrpCfgOut, err = config.NewCGRConfigFromFolder(shrGrpPathOut)
+	if err != nil {
+		t.Fatal(err)
+	}
+	shrSharedGroup = utils.Move
+	for _, stest := range sTestsShrGrpIT {
+		t.Run("TestSharedGroupITMoveEncoding2", stest)
+	}
+}
+
+func testShrGrpITConnect(t *testing.T) {
+	dataDBIn, err := NewMigratorDataDB(shrGrpCfgIn.DataDbType,
+		shrGrpCfgIn.DataDbHost, shrGrpCfgIn.DataDbPort, shrGrpCfgIn.DataDbName,
+		shrGrpCfgIn.DataDbUser, shrGrpCfgIn.DataDbPass, shrGrpCfgIn.DBDataEncoding,
+		config.CgrConfig().CacheCfg(), *loadHistorySize)
+	if err != nil {
+		log.Fatal(err)
+	}
+	dataDBOut, err := NewMigratorDataDB(shrGrpCfgOut.DataDbType,
+		shrGrpCfgOut.DataDbHost, shrGrpCfgOut.DataDbPort, shrGrpCfgOut.DataDbName,
+		shrGrpCfgOut.DataDbUser, shrGrpCfgOut.DataDbPass, shrGrpCfgOut.DBDataEncoding,
+		config.CgrConfig().CacheCfg(), *loadHistorySize)
+	if err != nil {
+		log.Fatal(err)
+	}
+	shrGrpMigrator, err = NewMigrator(dataDBIn, dataDBOut,
+		nil, nil,
+		false, false, false)
+	if err != nil {
+		log.Fatal(err)
+	}
+}
+
+func testShrGrpITFlush(t *testing.T) {
+	shrGrpMigrator.dmOut.DataManager().DataDB().Flush("")
+	if err := engine.SetDBVersions(shrGrpMigrator.dmOut.DataManager().DataDB()); err != nil {
+		t.Error("Error  ", err.Error())
+	}
+}
+
+func testShrGrpITMigrateAndMove(t *testing.T) {
+	v1shrGrp := &v1SharedGroup{
+		Id: "Test",
+		AccountParameters: map[string]*engine.SharingParameters{
+			"test": &engine.SharingParameters{Strategy: "*highest"},
+		},
+		MemberIds: []string{"1", "2", "3"},
+	}
+	shrGrp := &engine.SharedGroup{
+		Id: "Test",
+		AccountParameters: map[string]*engine.SharingParameters{
+			"test": &engine.SharingParameters{Strategy: "*highest"},
+		},
+		MemberIds: utils.NewStringMap("1", "2", "3"),
+	}
+
+	switch accAction {
+	case utils.Migrate:
+		err := shrGrpMigrator.dmIN.setV1SharedGroup(v1shrGrp)
+		if err != nil {
+			t.Error("Error when setting v1 SharedGroup ", err.Error())
+		}
+		currentVersion := engine.Versions{utils.StatS: 2, utils.Thresholds: 2, utils.Accounts: 2, utils.Actions: 2, utils.ActionTriggers: 2, utils.ActionPlans: 2, utils.SharedGroups: 1}
+		err = shrGrpMigrator.dmOut.DataManager().DataDB().SetVersions(currentVersion, false)
+		if err != nil {
+			t.Error("Error when setting version for SharedGroup ", err.Error())
+		}
+		err, _ = shrGrpMigrator.Migrate([]string{utils.MetaSharedGroups})
+		if err != nil {
+			t.Error("Error when migrating SharedGroup ", err.Error())
+		}
+		result, err := shrGrpMigrator.dmOut.DataManager().DataDB().GetSharedGroupDrv(v1shrGrp.Id)
+		if err != nil {
+			t.Error("Error when getting SharedGroup ", err.Error())
+		}
+		if !reflect.DeepEqual(&shrGrp, result) {
+			t.Errorf("Expecting: %+v, received: %+v", &shrGrp, result)
+		}
+	case utils.Move:
+		if err := shrGrpMigrator.dmIN.DataManager().DataDB().SetSharedGroupDrv(shrGrp); err != nil {
+			t.Error("Error when setting SharedGroup ", err.Error())
+		}
+		currentVersion := engine.CurrentDataDBVersions()
+		err := shrGrpMigrator.dmOut.DataManager().DataDB().SetVersions(currentVersion, false)
+		if err != nil {
+			t.Error("Error when setting version for SharedGroup ", err.Error())
+		}
+		err, _ = shrGrpMigrator.Migrate([]string{utils.MetaSharedGroups})
+		if err != nil {
+			t.Error("Error when migrating SharedGroup ", err.Error())
+		}
+		result, err := shrGrpMigrator.dmOut.DataManager().DataDB().GetSharedGroupDrv(v1shrGrp.Id)
+		if err != nil {
+			t.Error("Error when getting SharedGroup ", err.Error())
+		}
+		if !reflect.DeepEqual(&shrGrp, result) {
+			t.Errorf("Expecting: %+v, received: %+v", &shrGrp, result)
+		}
+	}
+}
--- a/migrator/stats_it_test.go
+++ b/migrator/stats_it_test.go
@@ -20,7 +20,6 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>

 package migrator

-/*
 import (
 	"log"
 	"path"
@@ -102,38 +101,31 @@ func TestStatsQueueITMove(t *testing.T) {
 }

 func testStsITConnect(t *testing.T) {
-	dataDBIn, err := engine.ConfigureDataStorage(stsCfgIn.DataDbType,
+	dataDBIn, err := NewMigratorDataDB(stsCfgIn.DataDbType,
 		stsCfgIn.DataDbHost, stsCfgIn.DataDbPort, stsCfgIn.DataDbName,
 		stsCfgIn.DataDbUser, stsCfgIn.DataDbPass, stsCfgIn.DBDataEncoding,
 		config.CgrConfig().CacheCfg(), *loadHistorySize)
 	if err != nil {
 		log.Fatal(err)
 	}
-	dataDBOut, err := engine.ConfigureDataStorage(stsCfgOut.DataDbType,
+	dataDBOut, err := NewMigratorDataDB(stsCfgOut.DataDbType,
 		stsCfgOut.DataDbHost, stsCfgOut.DataDbPort, stsCfgOut.DataDbName,
 		stsCfgOut.DataDbUser, stsCfgOut.DataDbPass, stsCfgOut.DBDataEncoding,
 		config.CgrConfig().CacheCfg(), *loadHistorySize)
 	if err != nil {
 		log.Fatal(err)
 	}
-	oldDataDB, err := ConfigureV1DataStorage(stsCfgIn.DataDbType,
-		stsCfgIn.DataDbHost, stsCfgIn.DataDbPort, stsCfgIn.DataDbName,
-		stsCfgIn.DataDbUser, stsCfgIn.DataDbPass, stsCfgIn.DBDataEncoding)
-	if err != nil {
-		log.Fatal(err)
-	}
-	stsMigrator, err = NewMigrator(dataDBIn, dataDBOut, stsCfgIn.DataDbType,
-		stsCfgIn.DBDataEncoding, nil, nil, stsCfgIn.StorDBType, oldDataDB,
-		stsCfgIn.DataDbType, stsCfgIn.DBDataEncoding, nil, stsCfgIn.StorDBType,
-		false, false, false, false, false)
+	stsMigrator, err = NewMigrator(dataDBIn, dataDBOut,
+		nil, nil,
+		false, false, false)
 	if err != nil {
 		log.Fatal(err)
 	}
 }

 func testStsITFlush(t *testing.T) {
-	stsMigrator.dmOut.DataDB().Flush("")
-	if err := engine.SetDBVersions(stsMigrator.dmOut.DataDB()); err != nil {
+	stsMigrator.dmOut.DataManager().DataDB().Flush("")
+	if err := engine.SetDBVersions(stsMigrator.dmOut.DataManager().DataDB()); err != nil {
 		t.Error("Error  ", err.Error())
 	}
 }
@@ -237,7 +229,7 @@ func testStsITMigrateAndMove(t *testing.T) {
 	}
 	switch stsAction {
 	case utils.Migrate:
-		err := stsMigrator.oldDataDB.setV1Stats(v1Sts)
+		err := stsMigrator.dmIN.setV1Stats(v1Sts)
 		if err != nil {
 			t.Error("Error when setting v1Stat ", err.Error())
 		}
@@ -249,7 +241,7 @@ func testStsITMigrateAndMove(t *testing.T) {
 			utils.ActionTriggers: 2,
 			utils.ActionPlans:    2,
 			utils.SharedGroups:   2}
-		err = stsMigrator.dmOut.DataDB().SetVersions(currentVersion, false)
+		err = stsMigrator.dmOut.DataManager().DataDB().SetVersions(currentVersion, false)
 		if err != nil {
 			t.Error("Error when setting version for stats ", err.Error())
 		}
@@ -258,8 +250,7 @@ func testStsITMigrateAndMove(t *testing.T) {
 			t.Error("Error when migrating Stats ", err.Error())
 		}

-		result, err := stsMigrator.dmOut.GetStatQueueProfile("cgrates.org",
-			v1Sts.Id, true, utils.NonTransactional)
+		result, err := stsMigrator.dmOut.DataManager().DataDB().GetStatQueueProfileDrv("cgrates.org", v1Sts.Id)
 		if err != nil {
 			t.Error("Error when getting Stats ", err.Error())
 		}
@@ -267,8 +258,7 @@ func testStsITMigrateAndMove(t *testing.T) {
 			t.Errorf("Expecting: %+v, received: %+v", sqp, result)
 		}

-		result1, err := stsMigrator.dmOut.GetFilter("cgrates.org",
-			v1Sts.Id, true, utils.NonTransactional)
+		result1, err := stsMigrator.dmOut.DataManager().DataDB().GetFilterDrv("cgrates.org", v1Sts.Id)
 		if err != nil {
 			t.Error("Error when getting Stats ", err.Error())
 		}
@@ -278,7 +268,7 @@ func testStsITMigrateAndMove(t *testing.T) {
 			t.Errorf("Expecting: %+v, received: %+v", len(filter.Rules), len(result1.Rules))
 		}

-		result2, err := stsMigrator.dmOut.GetStatQueue("cgrates.org", sq.ID, true, utils.NonTransactional)
+		result2, err := stsMigrator.dmOut.DataManager().GetStatQueue("cgrates.org", sq.ID, true, utils.NonTransactional)
 		if err != nil {
 			t.Error("Error when getting Stats ", err.Error())
 		}
@@ -287,14 +277,14 @@ func testStsITMigrateAndMove(t *testing.T) {
 		}

 	case utils.Move:
-		if err := stsMigrator.dmIN.SetStatQueueProfile(sqp, true); err != nil {
+		if err := stsMigrator.dmIN.DataManager().DataDB().SetStatQueueProfileDrv(sqp); err != nil {
 			t.Error("Error when setting Stats ", err.Error())
 		}
-		if err := stsMigrator.dmIN.SetStatQueue(sq); err != nil {
+		if err := stsMigrator.dmIN.DataManager().SetStatQueue(sq); err != nil {
 			t.Error("Error when setting Stats ", err.Error())
 		}
 		currentVersion := engine.CurrentDataDBVersions()
-		err := stsMigrator.dmOut.DataDB().SetVersions(currentVersion, false)
+		err := stsMigrator.dmOut.DataManager().DataDB().SetVersions(currentVersion, false)
 		if err != nil {
 			t.Error("Error when setting version for stats ", err.Error())
 		}
@@ -302,11 +292,11 @@ func testStsITMigrateAndMove(t *testing.T) {
 		if err != nil {
 			t.Error("Error when migrating Stats ", err.Error())
 		}
-		result, err := stsMigrator.dmOut.GetStatQueueProfile(sqp.Tenant, sqp.ID, true, utils.NonTransactional)
+		result, err := stsMigrator.dmOut.DataManager().DataDB().GetStatQueueProfileDrv(sqp.Tenant, sqp.ID)
 		if err != nil {
 			t.Error("Error when getting Stats ", err.Error())
 		}
-		result1, err := stsMigrator.dmOut.GetStatQueue(sq.Tenant, sq.ID, true, utils.NonTransactional)
+		result1, err := stsMigrator.dmOut.DataManager().GetStatQueue(sq.Tenant, sq.ID, true, utils.NonTransactional)
 		if err != nil {
 			t.Error("Error when getting Stats ", err.Error())
 		}
@@ -319,4 +309,3 @@ func testStsITMigrateAndMove(t *testing.T) {
 	}

 }
-*/
--- a/migrator/thresholds_it_test.go
+++ b/migrator/thresholds_it_test.go
@@ -0,0 +1,257 @@
+// +build integration
+
+/*
+Real-time Online/Offline Charging System (OCS) for Telecom & ISP environments
+Copyright (C) ITsysCOM GmbH
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>
+*/
+
+package migrator
+
+import (
+	"log"
+	"path"
+	"reflect"
+	"testing"
+	"time"
+
+	"github.com/cgrates/cgrates/config"
+	"github.com/cgrates/cgrates/engine"
+	"github.com/cgrates/cgrates/utils"
+)
+
+var (
+	trsPathIn     string
+	trsPathOut    string
+	trsCfgIn      *config.CGRConfig
+	trsCfgOut     *config.CGRConfig
+	trsMigrator   *Migrator
+	trsThresholds string
+)
+
+var sTestsTrsIT = []func(t *testing.T){
+	testTrsITConnect,
+	testTrsITFlush,
+	testTrsITMigrateAndMove,
+}
+
+func TestThresholdsITRedis(t *testing.T) {
+	var err error
+	trsPathIn = path.Join(*dataDir, "conf", "samples", "tutmysql")
+	trsCfgIn, err = config.NewCGRConfigFromFolder(trsPathIn)
+	if err != nil {
+		t.Fatal(err)
+	}
+	trsCfgOut, err = config.NewCGRConfigFromFolder(trsPathIn)
+	if err != nil {
+		t.Fatal(err)
+	}
+	trsThresholds = utils.Migrate
+	for _, stest := range sTestsTrsIT {
+		t.Run("TestThresholdsITMigrateRedis", stest)
+	}
+}
+
+func TestThresholdsITMongo(t *testing.T) {
+	var err error
+	trsPathIn = path.Join(*dataDir, "conf", "samples", "tutmongo")
+	trsCfgIn, err = config.NewCGRConfigFromFolder(trsPathIn)
+	if err != nil {
+		t.Fatal(err)
+	}
+	trsCfgOut, err = config.NewCGRConfigFromFolder(trsPathIn)
+	if err != nil {
+		t.Fatal(err)
+	}
+	trsThresholds = utils.Migrate
+	for _, stest := range sTestsTrsIT {
+		t.Run("TestThresholdsITMigrateMongo", stest)
+	}
+}
+
+func TestThresholdsITMove(t *testing.T) {
+	var err error
+	trsPathIn = path.Join(*dataDir, "conf", "samples", "tutmongo")
+	trsCfgIn, err = config.NewCGRConfigFromFolder(trsPathIn)
+	if err != nil {
+		t.Fatal(err)
+	}
+	trsPathOut = path.Join(*dataDir, "conf", "samples", "tutmysql")
+	trsCfgOut, err = config.NewCGRConfigFromFolder(trsPathOut)
+	if err != nil {
+		t.Fatal(err)
+	}
+	trsThresholds = utils.Move
+	for _, stest := range sTestsTrsIT {
+		t.Run("TestThresholdsITMove", stest)
+	}
+}
+
+func TestThresholdsITMoveEncoding(t *testing.T) {
+	var err error
+	trsPathIn = path.Join(*dataDir, "conf", "samples", "tutmongojson")
+	trsCfgIn, err = config.NewCGRConfigFromFolder(trsPathIn)
+	if err != nil {
+		t.Fatal(err)
+	}
+	trsPathOut = path.Join(*dataDir, "conf", "samples", "tutmongomsgpack")
+	trsCfgOut, err = config.NewCGRConfigFromFolder(trsPathOut)
+	if err != nil {
+		t.Fatal(err)
+	}
+	trsThresholds = utils.Move
+	for _, stest := range sTestsTrsIT {
+		t.Run("TestThresholdsITMoveEncoding", stest)
+	}
+}
+
+func TestThresholdsITMoveEncoding2(t *testing.T) {
+	var err error
+	trsPathIn = path.Join(*dataDir, "conf", "samples", "tutmysqljson")
+	trsCfgIn, err = config.NewCGRConfigFromFolder(trsPathIn)
+	if err != nil {
+		t.Fatal(err)
+	}
+	trsPathOut = path.Join(*dataDir, "conf", "samples", "tutmysqlmsgpack")
+	trsCfgOut, err = config.NewCGRConfigFromFolder(trsPathOut)
+	if err != nil {
+		t.Fatal(err)
+	}
+	trsThresholds = utils.Move
+	for _, stest := range sTestsTrsIT {
+		t.Run("TestThresholdsITMoveEncoding2", stest)
+	}
+}
+
+func testTrsITConnect(t *testing.T) {
+	dataDBIn, err := NewMigratorDataDB(trsCfgIn.DataDbType,
+		trsCfgIn.DataDbHost, trsCfgIn.DataDbPort, trsCfgIn.DataDbName,
+		trsCfgIn.DataDbUser, trsCfgIn.DataDbPass, trsCfgIn.DBDataEncoding,
+		config.CgrConfig().CacheCfg(), *loadHistorySize)
+	if err != nil {
+		log.Fatal(err)
+	}
+	dataDBOut, err := NewMigratorDataDB(trsCfgOut.DataDbType,
+		trsCfgOut.DataDbHost, trsCfgOut.DataDbPort, trsCfgOut.DataDbName,
+		trsCfgOut.DataDbUser, trsCfgOut.DataDbPass, trsCfgOut.DBDataEncoding,
+		config.CgrConfig().CacheCfg(), *loadHistorySize)
+	if err != nil {
+		log.Fatal(err)
+	}
+	trsMigrator, err = NewMigrator(dataDBIn, dataDBOut,
+		nil, nil,
+		false, false, false)
+	if err != nil {
+		log.Fatal(err)
+	}
+}
+
+func testTrsITFlush(t *testing.T) {
+	trsMigrator.dmOut.DataManager().DataDB().Flush("")
+	if err := engine.SetDBVersions(trsMigrator.dmOut.DataManager().DataDB()); err != nil {
+		t.Error("Error  ", err.Error())
+	}
+}
+
+func testTrsITMigrateAndMove(t *testing.T) {
+	tim := time.Date(2012, time.February, 27, 23, 59, 59, 0, time.UTC)
+	var filters []*engine.FilterRule
+	v1trs := &v2ActionTrigger{
+		ID:             "test2",              // original csv tag
+		UniqueID:       "testUUID",           // individual id
+		ThresholdType:  "*min_event_counter", //*min_event_counter, *max_event_counter, *min_balance_counter, *max_balance_counter, *min_balance, *max_balance, *balance_expired
+		ThresholdValue: 5.32,
+		Recurrent:      false,                          // reset excuted flag each run
+		MinSleep:       time.Duration(5) * time.Second, // Minimum duration between two executions in case of recurrent triggers
+		ExpirationDate: time.Now(),
+		ActivationDate: time.Now(),
+		Balance: &engine.BalanceFilter{
+			ID:             utils.StringPointer("TESTZ"),
+			Timings:        []*engine.RITiming{},
+			ExpirationDate: utils.TimePointer(tim),
+			Type:           utils.StringPointer(utils.MONETARY),
+			Directions:     utils.StringMapPointer(utils.NewStringMap(utils.OUT)),
+		},
+		Weight:            0,
+		ActionsID:         "Action1",
+		MinQueuedItems:    10, // Trigger actions only if this number is hit (stats only)
+		Executed:          false,
+		LastExecutionTime: time.Now(),
+	}
+	x, err := engine.NewFilterRule(engine.MetaRSR, "Directions", v1trs.Balance.Directions.Slice())
+	if err != nil {
+		t.Error("Error when creating new NewFilterRule", err.Error())
+	}
+	filters = append(filters, x)
+
+	filter := &engine.Filter{Tenant: config.CgrConfig().DefaultTenant, ID: *v1trs.Balance.ID, Rules: filters}
+
+	tresProf := &engine.ThresholdProfile{
+		ID:                 v1trs.ID,
+		Tenant:             config.CgrConfig().DefaultTenant,
+		FilterIDs:          []string{filter.ID},
+		Blocker:            false,
+		Weight:             v1trs.Weight,
+		ActivationInterval: &utils.ActivationInterval{v1trs.ExpirationDate, v1trs.ActivationDate},
+		MinSleep:           v1trs.MinSleep,
+	}
+	tres := &engine.Threshold{
+		Tenant: config.CgrConfig().DefaultTenant,
+		ID:     v1trs.ID,
+	}
+	switch accAction {
+	case utils.Migrate:
+		err := trsMigrator.dmIN.setV2ActionTrigger(v1trs)
+		if err != nil {
+			t.Error("Error when setting v1 Thresholds ", err.Error())
+		}
+		currentVersion := engine.Versions{utils.StatS: 2, utils.Thresholds: 1, utils.Accounts: 2, utils.Actions: 2, utils.ActionTriggers: 2, utils.ActionPlans: 2, utils.SharedGroups: 2}
+		err = trsMigrator.dmOut.DataManager().DataDB().SetVersions(currentVersion, false)
+		if err != nil {
+			t.Error("Error when setting version for Thresholds ", err.Error())
+		}
+		err, _ = trsMigrator.Migrate([]string{utils.MetaThresholds})
+		if err != nil {
+			t.Error("Error when migrating Thresholds ", err.Error())
+		}
+		result, err := trsMigrator.dmOut.DataManager().DataDB().GetThresholdDrv(tresProf.Tenant, tresProf.ID)
+		if err != nil {
+			t.Error("Error when getting Thresholds ", err.Error())
+		}
+		if !reflect.DeepEqual(&tres, result) {
+			t.Errorf("Expecting: %+v, received: %+v", &tres, result)
+		}
+	case utils.Move:
+		if err := trsMigrator.dmIN.DataManager().DataDB().SetThresholdDrv(tres); err != nil {
+			t.Error("Error when setting Thresholds ", err.Error())
+		}
+		currentVersion := engine.CurrentDataDBVersions()
+		err := trsMigrator.dmOut.DataManager().DataDB().SetVersions(currentVersion, false)
+		if err != nil {
+			t.Error("Error when setting version for Thresholds ", err.Error())
+		}
+		err, _ = trsMigrator.Migrate([]string{utils.MetaSharedGroups})
+		if err != nil {
+			t.Error("Error when migrating Thresholds ", err.Error())
+		}
+		result, err := trsMigrator.dmOut.DataManager().DataDB().GetThresholdDrv(tresProf.Tenant, tresProf.ID)
+		if err != nil {
+			t.Error("Error when getting Thresholds ", err.Error())
+		}
+		if !reflect.DeepEqual(&tres, result) {
+			t.Errorf("Expecting: %+v, received: %+v", &tres, result)
+		}
+	}
+}