Merge pull request #1867 from adragusin/master

Updated IT tests in engine

apier/v2/lib_test.go

@@ -34,6 +34,7 @@ var (
 	encoding  = flag.String("rpc", utils.MetaJSON, "what encoding whould be uused for rpc comunication")
 	dbType    = flag.String("dbtype", utils.MetaInternal, "The type of DataBase (Internal/Mongo/mySql)")
 )
+
 func newRPCClient(cfg *config.ListenCfg) (c *rpc.Client, err error) {
 	switch *encoding {
 	case utils.MetaJSON:
@@ -43,4 +44,4 @@ func newRPCClient(cfg *config.ListenCfg) (c *rpc.Client, err error) {
 	default:
 		return nil, errors.New("UNSUPPORTED_RPC")
 	}
-}
+}

data/conf/samples/actions_internal/cgradmin.json

@@ -0,0 +1,57 @@
+{
+// CGRateS Configuration file
+//
+// Used for cgradmin
+// Starts rater, scheduler
+
+"general": {
+    "log_level": 7,
+},
+
+"listen": {
+	"rpc_json": ":2012",			// RPC JSON listening address
+	"rpc_gob": ":2013",			// RPC GOB listening address
+	"http": ":2080",				// HTTP listening address
+},
+
+"data_db": {
+	"db_type": "*internal",	
+},
+
+
+"stor_db": {
+	"db_type": "*internal",	
+},
+
+"rals": {
+	"enabled": true,						// enable Rater service: <true|false>
+},
+
+"schedulers": {
+	"enabled": true,						// start Scheduler service: <true|false>
+	"cdrs_conns": ["*internal"],
+},
+
+"cdrs": {
+	"enabled": true,						// start the CDR Server service:  <true|false>
+	"chargers_conns":["*localhost"],
+},
+
+"chargers": {
+	"enabled": true,
+},
+
+"users": {
+	"enabled": true,							// starts users service: <true|false>.
+},
+
+"thresholds": {
+	"enabled": true,
+	"store_interval": "-1",
+},
+
+"apier": {
+	"scheduler_conns": ["*internal"],
+},
+
+}

data/conf/samples/actions_internal_gob/cgradmin.json

@@ -0,0 +1,65 @@
+{
+// CGRateS Configuration file
+//
+// Used for cgradmin
+// Starts rater, scheduler
+
+"general": {
+    "log_level": 7,
+},
+
+"rpc_conns": {
+	"conn1": {
+		"strategy": "*first",
+		"conns": [{"address": "127.0.0.1:2013", "transport":"*gob"}],
+	},
+},
+
+"listen": {
+	"rpc_json": ":2012",			// RPC JSON listening address
+	"rpc_gob": ":2013",			// RPC GOB listening address
+	"http": ":2080",				// HTTP listening address
+},
+
+
+"data_db": {
+	"db_type": "*internal",	
+},
+
+
+"stor_db": {
+	"db_type": "*internal",	
+},
+
+"rals": {
+	"enabled": true,						// enable Rater service: <true|false>
+},
+
+"schedulers": {
+	"enabled": true,						// start Scheduler service: <true|false>
+	"cdrs_conns": ["conn1"],
+},
+
+"cdrs": {
+	"enabled": true,						// start the CDR Server service:  <true|false>
+	"chargers_conns":["conn1"],
+},
+
+"chargers": {
+	"enabled": true,
+},
+
+"users": {
+	"enabled": true,							// starts users service: <true|false>.
+},
+
+"thresholds": {
+	"enabled": true,
+	"store_interval": "-1",
+},
+
+"apier": {
+	"scheduler_conns": ["*internal"],
+},
+
+}

data/conf/samples/actions_mongo/cgradmin.json

@@ -0,0 +1,62 @@
+{
+// CGRateS Configuration file
+//
+// Used for cgradmin
+// Starts rater, scheduler
+
+"general": {
+    "log_level": 7,
+},
+
+"listen": {
+	"rpc_json": ":2012",			// RPC JSON listening address
+	"rpc_gob": ":2013",			// RPC GOB listening address
+	"http": ":2080",				// HTTP listening address
+},
+
+
+"data_db": {
+	"db_type": "mongo",
+	"db_name": "10",
+	"db_port": 27017,
+},
+
+
+"stor_db": {
+	"db_type": "mongo",
+	"db_name": "cgrates",
+	"db_port": 27017,
+},
+
+"rals": {
+	"enabled": true,						// enable Rater service: <true|false>
+},
+
+"schedulers": {
+	"enabled": true,						// start Scheduler service: <true|false>
+	"cdrs_conns": ["*internal"],
+},
+
+"cdrs": {
+	"enabled": true,						// start the CDR Server service:  <true|false>
+	"chargers_conns":["*localhost"],
+},
+
+"chargers": {
+	"enabled": true,
+},
+
+"users": {
+	"enabled": true,							// starts users service: <true|false>.
+},
+
+"thresholds": {
+	"enabled": true,
+	"store_interval": "1s",
+},
+
+"apier": {
+	"scheduler_conns": ["*internal"],
+},
+
+}

data/conf/samples/actions_mongo_gob/cgradmin.json

@@ -0,0 +1,66 @@
+{
+// CGRateS Configuration file
+//
+// Used for cgradmin
+// Starts rater, scheduler
+
+"general": {
+    "log_level": 7,
+},
+
+"rpc_conns": {
+	"conn1": {
+		"strategy": "*first",
+		"conns": [{"address": "127.0.0.1:2013", "transport":"*gob"}],
+	},
+},
+
+"data_db": {
+	"db_type": "mongo",
+	"db_name": "10",
+	"db_port": 27017,
+},
+
+
+"stor_db": {
+	"db_type": "mongo",
+	"db_name": "cgrates",
+	"db_port": 27017,
+},
+
+"stor_db": {
+	"db_password": "CGRateS.org",
+},
+
+"rals": {
+	"enabled": true,						// enable Rater service: <true|false>
+},
+
+"schedulers": {
+	"enabled": true,						// start Scheduler service: <true|false>
+	"cdrs_conns": ["conn1"],
+},
+
+"cdrs": {
+	"enabled": true,						// start the CDR Server service:  <true|false>
+	"chargers_conns":["conn1"],
+},
+
+"chargers": {
+	"enabled": true,
+},
+
+"users": {
+	"enabled": true,							// starts users service: <true|false>.
+},
+
+"thresholds": {
+	"enabled": true,
+	"store_interval": "1s",
+},
+
+"apier": {
+	"scheduler_conns": ["*internal"],
+},
+
+}

data/conf/samples/actions_mysql/cgradmin.json

@@ -0,0 +1,59 @@
+{
+// CGRateS Configuration file
+//
+// Used for cgradmin
+// Starts rater, scheduler
+
+"general": {
+    "log_level": 7,
+},
+
+"listen": {
+	"rpc_json": ":2012",			// RPC JSON listening address
+	"rpc_gob": ":2013",			// RPC GOB listening address
+	"http": ":2080",				// HTTP listening address
+},
+
+
+"data_db": {								
+	"db_type": "redis",						
+	"db_port": 6379, 						
+	"db_name": "10", 						
+},
+
+"stor_db": {
+	"db_password": "CGRateS.org",
+},
+
+"rals": {
+	"enabled": true,						// enable Rater service: <true|false>
+},
+
+"schedulers": {
+	"enabled": true,						// start Scheduler service: <true|false>
+	"cdrs_conns": ["*internal"],
+},
+
+"cdrs": {
+	"enabled": true,						// start the CDR Server service:  <true|false>
+	"chargers_conns":["*localhost"],
+},
+
+"chargers": {
+	"enabled": true,
+},
+
+"users": {
+	"enabled": true,							// starts users service: <true|false>.
+},
+
+"thresholds": {
+	"enabled": true,
+	"store_interval": "1s",
+},
+
+"apier": {
+	"scheduler_conns": ["*internal"],
+},
+
+}

data/conf/samples/actions_mysql_gob/cgradmin.json

@@ -0,0 +1,66 @@
+{
+// CGRateS Configuration file
+//
+// Used for cgradmin
+// Starts rater, scheduler
+
+"general": {
+    "log_level": 7,
+},
+
+"rpc_conns": {
+	"conn1": {
+		"strategy": "*first",
+		"conns": [{"address": "127.0.0.1:2013", "transport":"*gob"}],
+	},
+},
+
+"listen": {
+	"rpc_json": ":2012",			// RPC JSON listening address
+	"rpc_gob": ":2013",			// RPC GOB listening address
+	"http": ":2080",				// HTTP listening address
+},
+
+
+"data_db": {								
+	"db_type": "redis",						
+	"db_port": 6379, 						
+	"db_name": "10", 						
+},
+
+"stor_db": {
+	"db_password": "CGRateS.org",
+},
+
+"rals": {
+	"enabled": true,						// enable Rater service: <true|false>
+},
+
+"schedulers": {
+	"enabled": true,						// start Scheduler service: <true|false>
+	"cdrs_conns": ["conn1"],
+},
+
+"cdrs": {
+	"enabled": true,						// start the CDR Server service:  <true|false>
+	"chargers_conns":["conn1"],
+},
+
+"chargers": {
+	"enabled": true,
+},
+
+"users": {
+	"enabled": true,							// starts users service: <true|false>.
+},
+
+"thresholds": {
+	"enabled": true,
+	"store_interval": "1s",
+},
+
+"apier": {
+	"scheduler_conns": ["*internal"],
+},
+
+}

engine/actions2_it_test.go

@@ -51,26 +51,31 @@ var sTestsActions = []func(t *testing.T){
 	testActionsKillEngine,
 }
 
-func TestActionsITRemoveSMCostRedis(t *testing.T) {
-	actsCfgDir = "actions"
-	for _, stest := range sTestsActions {
-		t.Run("TestsActionsITRedis", stest)
+func TestActionsITRemoveSMCost(t *testing.T) {
+	switch *dbType {
+	case utils.MetaInternal:
+		t.SkipNow()
+	case utils.MetaSQL:
+		actsCfgDir = "actions_mysql"
+	case utils.MetaMongo:
+		actsCfgDir = "cdrsv2mongo"
+	case utils.MetaPostgres:
+		t.SkipNow()
+	default:
+		t.Fatal("Unknown Database type")
+	}
+	if *encoding == utils.MetaGOB {
+		actsCfgDir += "_gob"
 	}
-}
 
-func TestActionsITRemoveSMCostMongo(t *testing.T) {
-	actsCfgDir = "cdrsv2mongo"
 	for _, stest := range sTestsActions {
-		t.Run("TestsActionsITMongo", stest)
+		t.Run(actsCfgDir, stest)
 	}
 }
 
 func testActionsInitCfg(t *testing.T) {
 	var err error
 	actsCfgPath = path.Join(*dataDir, "conf", "samples", actsCfgDir)
-	if *encoding == utils.MetaGOB {
-		actsCfgPath = path.Join(*dataDir, "conf", "samples", actsCfgDir+"_gob")
-	}
 	actsCfg, err = config.NewCGRConfigFromPath(actsCfgPath)
 	if err != nil {
 		t.Error(err)
@@ -78,7 +83,10 @@ func testActionsInitCfg(t *testing.T) {
 }
 
 func testActionsInitCdrsStore(t *testing.T) {
-	if actsCfgDir == "actions" {
+	switch *dbType {
+	case utils.MetaInternal:
+		actsCdrStore = NewInternalDB(actsCfg.StorDbCfg().StringIndexedFields, actsCfg.StorDbCfg().PrefixIndexedFields, true, actsCfg.StorDbCfg().Items)
+	case utils.MetaSQL:
 		if actsCdrStore, err = NewMySQLStorage(actsCfg.StorDbCfg().Host,
 			actsCfg.StorDbCfg().Port, actsCfg.StorDbCfg().Name,
 			actsCfg.StorDbCfg().User, actsCfg.StorDbCfg().Password,
@@ -86,13 +94,17 @@ func testActionsInitCdrsStore(t *testing.T) {
 			actsCfg.StorDbCfg().ConnMaxLifetime); err != nil {
 			t.Fatal("Could not connect to mysql", err.Error())
 		}
-	} else if actsCfgDir == "cdrsv2mongo" {
+	case utils.MetaMongo:
 		if actsCdrStore, err = NewMongoStorage(actsCfg.StorDbCfg().Host,
 			actsCfg.StorDbCfg().Port, actsCfg.StorDbCfg().Name,
 			actsCfg.StorDbCfg().User, actsCfg.StorDbCfg().Password,
 			utils.StorDB, nil, false); err != nil {
 			t.Fatal("Could not connect to mongo", err.Error())
 		}
+	case utils.MetaPostgres:
+		t.SkipNow()
+	default:
+		t.Fatal("Unknown Database type")
 	}
 }
 
@@ -155,7 +167,7 @@ func testActionsSetSMCosts(t *testing.T) {
 		}
 	}
 	// READ
-	if rcv, err := actsCdrStore.GetSMCosts("", "", "", ""); err != nil {
+	if rcv, err := actsCdrStore.GetSMCosts(utils.EmptyString, utils.EmptyString, utils.EmptyString, utils.EmptyString); err != nil {
 		t.Fatal(err)
 	} else if len(rcv) != 3 {
 		t.Errorf("Expected 3 results received %v ", len(rcv))
@@ -188,7 +200,7 @@ func testActionsExecuteRemoveSMCos1(t *testing.T) {
 	}
 
 	// READ
-	if rcv, err := actsCdrStore.GetSMCosts("", "", "", ""); err != nil {
+	if rcv, err := actsCdrStore.GetSMCosts(utils.EmptyString, utils.EmptyString, utils.EmptyString, utils.EmptyString); err != nil {
 		t.Error(err)
 	} else if len(rcv) != 2 {
 		t.Errorf("Expected 2 result received %v ", len(rcv))
@@ -221,7 +233,7 @@ func testActionsExecuteRemoveSMCos2(t *testing.T) {
 	}
 
 	// READ
-	if _, err := actsCdrStore.GetSMCosts("", "", "", ""); err != utils.ErrNotFound {
+	if _, err := actsCdrStore.GetSMCosts(utils.EmptyString, utils.EmptyString, utils.EmptyString, utils.EmptyString); err != utils.ErrNotFound {
 		t.Error(err)
 	}
 }

engine/actions_it_test.go

@@ -55,22 +55,21 @@ var (
 )
 
 func TestActionsit(t *testing.T) {
-	// switch *dbType {
-	// case utils.MetaInternal:
-	// 	actionsConfigDIR = "tutinternal"
-	// case utils.MetaSQL:
-	// 	actionsConfigDIR = "actions"
-	// case utils.MetaMongo:
-	// 	actionsConfigDIR = "tutmongo"
-	// case utils.MetaPostgres:
-	// 	t.SkipNow()
-	// default:
-	// 	t.Fatal("Unknown Database type")
-	// }
-	// if *encoding == utils.MetaGOB {
-	// 	actionsConfigDIR += "_gob"
-	// }
-	actionsConfigDIR = "actions"
+	switch *dbType {
+	case utils.MetaInternal:
+		actionsConfigDIR = "actions_internal"
+	case utils.MetaSQL:
+		actionsConfigDIR = "actions_mysql"
+	case utils.MetaMongo:
+		actionsConfigDIR = "actions_mongo"
+	case utils.MetaPostgres:
+		t.SkipNow()
+	default:
+		t.Fatal("Unknown Database type")
+	}
+	if *encoding == utils.MetaGOB {
+		actionsConfigDIR += "_gob"
+	}
 
 	for _, stest := range sTestsActionsit {
 		t.Run(actionsConfigDIR, stest)
@@ -78,9 +77,7 @@ func TestActionsit(t *testing.T) {
 }
 
 func testActionsitInitCfg(t *testing.T) {
-	if *encoding == utils.MetaGOB {
-		actsLclCfgPath = path.Join(*dataDir, "conf", "samples", actionsConfigDIR)
-	}
+	actsLclCfgPath = path.Join(*dataDir, "conf", "samples", actionsConfigDIR)
 	// Init config first
 	var err error
 	actsLclCfg, err = config.NewCGRConfigFromPath(actsLclCfgPath)

engine/actions_test.go

@@ -28,8 +28,8 @@ import (
 	"github.com/cgrates/rpcclient"
 )
 
-var err error
 var (
+	err error
 	//referenceDate = time.Date(2013, 7, 10, 10, 30, 0, 0, time.Local)
 	//referenceDate = time.Date(2013, 12, 31, 23, 59, 59, 0, time.Local)
 	//referenceDate = time.Date(2011, 1, 1, 0, 0, 0, 1, time.Local)

engine/cdr_it_test.go

@@ -29,7 +29,6 @@ import (
 
 // Sample HttpJsonPost, more for usage purposes
 func TestHttpJsonPost(t *testing.T) {
-
 	cdrOut := &ExternalCDR{CGRID: utils.Sha1("dsafdsaf", time.Date(2013, 11, 7, 8, 42, 20, 0, time.UTC).String()), OrderID: 123,
 		ToR: utils.VOICE, OriginID: "dsafdsaf", OriginHost: "192.168.1.1",
 		Source: utils.UNIT_TEST, RequestType: utils.META_RATED, Tenant: "cgrates.org",

engine/datamanager_it_test.go

@@ -32,49 +32,58 @@ import (
 )
 
 var (
-	dm2 *DataManager
+	dm2              *DataManager
+	dataMngConfigDIR string
+
+	sTestsDMit = []func(t *testing.T){
+		testDMitDataFlush,
+		testDMitCRUDStatQueue,
+	}
 )
 
-var sTestsDMit = []func(t *testing.T){
-	testDMitDataFlush,
-}
-
-func TestDMitRedis(t *testing.T) {
+func TestDMitinitDB(t *testing.T) {
 	cfg, _ := config.NewDefaultCGRConfig()
-	dataDB, err := NewRedisStorage(
-		fmt.Sprintf("%s:%s", cfg.DataDbCfg().DataDbHost, cfg.DataDbCfg().DataDbPort),
-		4, cfg.DataDbCfg().DataDbPass, cfg.GeneralCfg().DBDataEncoding,
-		utils.REDIS_MAX_CONNS, "")
-	if err != nil {
-		t.Fatal("Could not connect to Redis", err.Error())
-	}
-	dm2 = NewDataManager(dataDB, config.CgrConfig().CacheCfg(), nil)
-	for _, stest := range sTestsDMit {
-		t.Run("TestDMitRedis", stest)
-	}
-}
+	var dataDB DataDB
+	var err error
 
-func TestDMitMongo(t *testing.T) {
-	cdrsMongoCfgPath := path.Join(*dataDir, "conf", "samples", "cdrsv2mongo")
-	mgoITCfg, err := config.NewCGRConfigFromPath(cdrsMongoCfgPath)
-	if err != nil {
-		t.Fatal(err)
-	}
-	dataDB, err := NewMongoStorage(mgoITCfg.StorDbCfg().Host,
-		mgoITCfg.StorDbCfg().Port, mgoITCfg.StorDbCfg().Name,
-		mgoITCfg.StorDbCfg().User, mgoITCfg.StorDbCfg().Password,
-		utils.StorDB, nil, false)
-	if err != nil {
-		t.Fatal("Could not connect to Mongo", err.Error())
+	switch *dbType {
+	case utils.MetaInternal:
+		t.SkipNow()
+	case utils.MetaSQL:
+		dataDB, err = NewRedisStorage(
+			fmt.Sprintf("%s:%s", cfg.DataDbCfg().DataDbHost, cfg.DataDbCfg().DataDbPort),
+			4, cfg.DataDbCfg().DataDbPass, cfg.GeneralCfg().DBDataEncoding,
+			utils.REDIS_MAX_CONNS, "")
+		if err != nil {
+			t.Fatal("Could not connect to Redis", err.Error())
+		}
+	case utils.MetaMongo:
+		cdrsMongoCfgPath := path.Join(*dataDir, "conf", "samples", "tutmongo")
+		mgoITCfg, err := config.NewCGRConfigFromPath(cdrsMongoCfgPath)
+		if err != nil {
+			t.Fatal(err)
+		}
+		dataDB, err = NewMongoStorage(mgoITCfg.StorDbCfg().Host,
+			mgoITCfg.StorDbCfg().Port, mgoITCfg.StorDbCfg().Name,
+			mgoITCfg.StorDbCfg().User, mgoITCfg.StorDbCfg().Password,
+			utils.StorDB, nil, false)
+		if err != nil {
+			t.Fatal("Could not connect to Mongo", err.Error())
+		}
+	case utils.MetaPostgres:
+		t.SkipNow()
+	default:
+		t.Fatal("Unknown Database type")
 	}
 	dm2 = NewDataManager(dataDB, config.CgrConfig().CacheCfg(), nil)
+
 	for _, stest := range sTestsDMit {
-		t.Run("TestDMitMongo", stest)
+		t.Run(*dbType, stest)
 	}
 }
 
 func testDMitDataFlush(t *testing.T) {
-	if err := dm2.dataDB.Flush(""); err != nil {
+	if err := dm2.dataDB.Flush(utils.EmptyString); err != nil {
 		t.Error(err)
 	}
 	Cache.Clear(nil)
@@ -102,7 +111,7 @@ func testDMitCRUDStatQueue(t *testing.T) {
 			},
 		},
 	}
-	if _, rcvErr := dm2.GetStatQueue(sq.Tenant, sq.ID, true, false, ""); rcvErr != utils.ErrNotFound {
+	if _, rcvErr := dm2.GetStatQueue(sq.Tenant, sq.ID, true, false, utils.EmptyString); rcvErr != utils.ErrNotFound {
 		t.Error(rcvErr)
 	}
 	if _, ok := Cache.Get(utils.CacheStatQueues, sq.TenantID()); ok != false {
@@ -114,7 +123,7 @@ func testDMitCRUDStatQueue(t *testing.T) {
 	if _, ok := Cache.Get(utils.CacheStatQueues, sq.TenantID()); ok != false {
 		t.Error("should not be in cache")
 	}
-	if rcv, err := dm2.GetStatQueue(sq.Tenant, sq.ID, true, false, ""); err != nil {
+	if rcv, err := dm2.GetStatQueue(sq.Tenant, sq.ID, true, true, utils.EmptyString); err != nil {
 		t.Error(err)
 	} else if !reflect.DeepEqual(sq, rcv) {
 		t.Errorf("expecting: %v, received: %v", sq, rcv)
@@ -122,13 +131,14 @@ func testDMitCRUDStatQueue(t *testing.T) {
 	if _, ok := Cache.Get(utils.CacheStatQueues, sq.TenantID()); ok != true {
 		t.Error("should be in cache")
 	}
-	if err := dm2.RemoveStatQueue(sq.Tenant, sq.ID, ""); err != nil {
+	if err := dm2.RemoveStatQueue(sq.Tenant, sq.ID, utils.EmptyString); err != nil {
 		t.Error(err)
 	}
+	Cache.Clear(nil)
 	if _, ok := Cache.Get(utils.CacheStatQueues, sq.TenantID()); ok != false {
 		t.Error("should not be in cache")
 	}
-	if _, rcvErr := dm2.GetStatQueue(sq.Tenant, sq.ID, true, false, ""); rcvErr != utils.ErrNotFound {
+	if _, rcvErr := dm2.GetStatQueue(sq.Tenant, sq.ID, true, false, utils.EmptyString); rcvErr != utils.ErrNotFound {
 		t.Error(rcvErr)
 	}
 }

engine/filterindexer_it_test.go

@@ -63,47 +63,44 @@ var sTests = []func(t *testing.T){
 	testITTestIndexingMetaNot,
 }
 
-func TestFilterIndexerITRedis(t *testing.T) {
-	cfg, _ := config.NewDefaultCGRConfig()
-	redisDB, err := NewRedisStorage(
-		fmt.Sprintf("%s:%s", cfg.DataDbCfg().DataDbHost, cfg.DataDbCfg().DataDbPort),
-		4, cfg.DataDbCfg().DataDbPass, cfg.GeneralCfg().DBDataEncoding,
-		utils.REDIS_MAX_CONNS, "")
-	if err != nil {
-		t.Fatal("Could not connect to Redis", err.Error())
-	}
-	cfgDBName = cfg.DataDbCfg().DataDbName
-	dataManager = NewDataManager(redisDB, config.CgrConfig().CacheCfg(), nil)
-	for _, stest := range sTests {
-		t.Run("TestITRedis", stest)
-	}
-}
-
-func TestFilterIndexerITMongo(t *testing.T) {
-	cdrsMongoCfgPath := path.Join(*dataDir, "conf", "samples", "tutmongo")
-	mgoITCfg, err := config.NewCGRConfigFromPath(cdrsMongoCfgPath)
-	if err != nil {
-		t.Fatal(err)
-	}
-	mongoDB, err := NewMongoStorage(mgoITCfg.StorDbCfg().Host,
-		mgoITCfg.StorDbCfg().Port, mgoITCfg.StorDbCfg().Name,
-		mgoITCfg.StorDbCfg().User, mgoITCfg.StorDbCfg().Password,
-		utils.StorDB, nil, false)
-	if err != nil {
-		t.Fatal(err)
-	}
-	cfgDBName = mgoITCfg.StorDbCfg().Name
-	dataManager = NewDataManager(mongoDB, config.CgrConfig().CacheCfg(), nil)
-	for _, stest := range sTests {
-		t.Run("TestITMongo", stest)
-	}
-}
-
-func TestFilterIndexerITInternal(t *testing.T) {
-	dataManager = NewDataManager(NewInternalDB(nil, nil, true, config.CgrConfig().DataDbCfg().Items),
+func TestFilterIndexerIT(t *testing.T) {
+	switch *dbType {
+	case utils.MetaInternal:
+		dataManager = NewDataManager(NewInternalDB(nil, nil, true, config.CgrConfig().DataDbCfg().Items),
 		config.CgrConfig().CacheCfg(), nil)
+	case utils.MetaSQL:
+		cfg, _ := config.NewDefaultCGRConfig()
+		redisDB, err := NewRedisStorage(
+			fmt.Sprintf("%s:%s", cfg.DataDbCfg().DataDbHost, cfg.DataDbCfg().DataDbPort),
+			4, cfg.DataDbCfg().DataDbPass, cfg.GeneralCfg().DBDataEncoding,
+			utils.REDIS_MAX_CONNS, "")
+		if err != nil {
+			t.Fatal("Could not connect to Redis", err.Error())
+		}
+		cfgDBName = cfg.DataDbCfg().DataDbName
+		dataManager = NewDataManager(redisDB, config.CgrConfig().CacheCfg(), nil)
+	case utils.MetaMongo:
+		cdrsMongoCfgPath := path.Join(*dataDir, "conf", "samples", "tutmongo")
+		mgoITCfg, err := config.NewCGRConfigFromPath(cdrsMongoCfgPath)
+		if err != nil {
+			t.Fatal(err)
+		}
+		mongoDB, err := NewMongoStorage(mgoITCfg.StorDbCfg().Host,
+			mgoITCfg.StorDbCfg().Port, mgoITCfg.StorDbCfg().Name,
+			mgoITCfg.StorDbCfg().User, mgoITCfg.StorDbCfg().Password,
+			utils.StorDB, nil, false)
+		if err != nil {
+			t.Fatal(err)
+		}
+		cfgDBName = mgoITCfg.StorDbCfg().Name
+		dataManager = NewDataManager(mongoDB, config.CgrConfig().CacheCfg(), nil)
+	case utils.MetaPostgres:
+		t.SkipNow()
+	default:
+		t.Fatal("Unknown Database type")
+	}
 	for _, stest := range sTests {
-		t.Run("TestITInternal", stest)
+		t.Run(*dbType, stest)
 	}
 }
 

engine/onstor_it_test.go

@@ -36,94 +36,92 @@ var (
 	onStor     *DataManager
 	onStorCfg  string
 	sleepDelay time.Duration
+
+	// subtests to be executed for each confDIR
+	sTestsOnStorIT = []func(t *testing.T){
+		testOnStorITFlush,
+		testOnStorITIsDBEmpty,
+		testOnStorITCacheDestinations,
+		testOnStorITCacheReverseDestinations,
+		testOnStorITCacheActionPlan,
+		testOnStorITCacheAccountActionPlans,
+
+		// ToDo: test cache flush for a prefix
+		// ToDo: testOnStorITLoadAccountingCache
+		testOnStorITHasData,
+		testOnStorITPushPop,
+		testOnStorITRatingPlan,
+		testOnStorITRatingProfile,
+		testOnStorITCRUDDestinations,
+		testOnStorITCRUDReverseDestinations,
+		testOnStorITActions,
+		testOnStorITSharedGroup,
+		testOnStorITCRUDActionPlan,
+		testOnStorITCRUDAccountActionPlans,
+		testOnStorITCRUDAccount,
+		testOnStorITResource,
+		testOnStorITResourceProfile,
+		testOnStorITTiming,
+		//testOnStorITCRUDHistory,
+		testOnStorITCRUDStructVersion,
+		testOnStorITStatQueueProfile,
+		testOnStorITStatQueue,
+		testOnStorITThresholdProfile,
+		testOnStorITThreshold,
+		testOnStorITFilter,
+		testOnStorITSupplierProfile,
+		testOnStorITAttributeProfile,
+		testOnStorITFlush,
+		testOnStorITIsDBEmpty,
+		testOnStorITTestAttributeSubstituteIface,
+		testOnStorITChargerProfile,
+		testOnStorITDispatcherProfile,
+
+		//testOnStorITCacheActionTriggers,
+		//testOnStorITCRUDActionTriggers,
+	}
 )
 
-// subtests to be executed for each confDIR
-var sTestsOnStorIT = []func(t *testing.T){
-	testOnStorITFlush,
-	testOnStorITIsDBEmpty,
-	testOnStorITCacheDestinations,
-	testOnStorITCacheReverseDestinations,
-	testOnStorITCacheActionPlan,
-	testOnStorITCacheAccountActionPlans,
-
-	// ToDo: test cache flush for a prefix
-	// ToDo: testOnStorITLoadAccountingCache
-	testOnStorITHasData,
-	testOnStorITPushPop,
-	testOnStorITRatingPlan,
-	testOnStorITRatingProfile,
-	testOnStorITCRUDDestinations,
-	testOnStorITCRUDReverseDestinations,
-	testOnStorITActions,
-	testOnStorITSharedGroup,
-	testOnStorITCRUDActionPlan,
-	testOnStorITCRUDAccountActionPlans,
-	testOnStorITCRUDAccount,
-	testOnStorITResource,
-	testOnStorITResourceProfile,
-	testOnStorITTiming,
-	//testOnStorITCRUDHistory,
-	testOnStorITCRUDStructVersion,
-	testOnStorITStatQueueProfile,
-	testOnStorITStatQueue,
-	testOnStorITThresholdProfile,
-	testOnStorITThreshold,
-	testOnStorITFilter,
-	testOnStorITSupplierProfile,
-	testOnStorITAttributeProfile,
-	testOnStorITFlush,
-	testOnStorITIsDBEmpty,
-	testOnStorITTestAttributeSubstituteIface,
-	testOnStorITChargerProfile,
-	testOnStorITDispatcherProfile,
-
-	//testOnStorITCacheActionTriggers,
-	//testOnStorITCRUDActionTriggers,
-}
-
-func TestOnStorITRedis(t *testing.T) {
-	cfg, _ := config.NewDefaultCGRConfig()
-	rdsITdb, err = NewRedisStorage(
-		fmt.Sprintf("%s:%s", cfg.DataDbCfg().DataDbHost, cfg.DataDbCfg().DataDbPort),
-		4, cfg.DataDbCfg().DataDbPass, cfg.GeneralCfg().DBDataEncoding,
-		utils.REDIS_MAX_CONNS, "")
-	if err != nil {
-		t.Fatal("Could not connect to Redis", err.Error())
+func TestOnStorIT(t *testing.T) {
+	switch *dbType {
+	case utils.MetaInternal:
+		sleepDelay = 10 * time.Millisecond
+		onStor = NewDataManager(NewInternalDB(nil, nil, true, config.CgrConfig().DataDbCfg().Items),
+			config.CgrConfig().CacheCfg(), nil)
+	case utils.MetaSQL:
+		cfg, _ := config.NewDefaultCGRConfig()
+		rdsITdb, err = NewRedisStorage(
+			fmt.Sprintf("%s:%s", cfg.DataDbCfg().DataDbHost, cfg.DataDbCfg().DataDbPort),
+			4, cfg.DataDbCfg().DataDbPass, cfg.GeneralCfg().DBDataEncoding,
+			utils.REDIS_MAX_CONNS, "")
+		if err != nil {
+			t.Fatal("Could not connect to Redis", err.Error())
+		}
+		onStorCfg = cfg.DataDbCfg().DataDbName
+		onStor = NewDataManager(rdsITdb, config.CgrConfig().CacheCfg(), nil)
+	case utils.MetaMongo:
+		sleepDelay = 500 * time.Millisecond
+		cdrsMongoCfgPath := path.Join(*dataDir, "conf", "samples", "cdrsv2mongo")
+		mgoITCfg, err := config.NewCGRConfigFromPath(cdrsMongoCfgPath)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if mgoITdb, err = NewMongoStorage(mgoITCfg.StorDbCfg().Host,
+			mgoITCfg.StorDbCfg().Port, mgoITCfg.StorDbCfg().Name,
+			mgoITCfg.StorDbCfg().User, mgoITCfg.StorDbCfg().Password,
+			utils.StorDB, nil, false); err != nil {
+			t.Fatal(err)
+		}
+		onStorCfg = mgoITCfg.StorDbCfg().Name
+		onStor = NewDataManager(mgoITdb, config.CgrConfig().CacheCfg(), nil)
+	case utils.MetaPostgres:
+		t.SkipNow()
+	default:
+		t.Fatal("Unknown Database type")
 	}
-	onStorCfg = cfg.DataDbCfg().DataDbName
-	onStor = NewDataManager(rdsITdb, config.CgrConfig().CacheCfg(), nil)
+
 	for _, stest := range sTestsOnStorIT {
-		t.Run("TestOnStorITRedis", stest)
-	}
-}
-
-func TestOnStorITMongo(t *testing.T) {
-	sleepDelay = 500 * time.Millisecond
-	cdrsMongoCfgPath := path.Join(*dataDir, "conf", "samples", "cdrsv2mongo")
-	mgoITCfg, err := config.NewCGRConfigFromPath(cdrsMongoCfgPath)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if mgoITdb, err = NewMongoStorage(mgoITCfg.StorDbCfg().Host,
-		mgoITCfg.StorDbCfg().Port, mgoITCfg.StorDbCfg().Name,
-		mgoITCfg.StorDbCfg().User, mgoITCfg.StorDbCfg().Password,
-		utils.StorDB, nil, false); err != nil {
-		t.Fatal(err)
-	}
-	onStorCfg = mgoITCfg.StorDbCfg().Name
-	onStor = NewDataManager(mgoITdb, config.CgrConfig().CacheCfg(), nil)
-	for _, stest := range sTestsOnStorIT {
-		t.Run("TestOnStorITMongo", stest)
-	}
-}
-
-func TestOnStorITInternal(t *testing.T) {
-	sleepDelay = 10 * time.Millisecond
-	onStor = NewDataManager(NewInternalDB(nil, nil, true, config.CgrConfig().DataDbCfg().Items),
-		config.CgrConfig().CacheCfg(), nil)
-	for _, stest := range sTestsOnStorIT {
-		t.Run("TestOnStorITInternal", stest)
+		t.Run(*dbType, stest)
 	}
 }
 

engine/storage_cdrs_it_test.go

@@ -31,56 +31,22 @@ import (
 	"github.com/cgrates/cgrates/utils"
 )
 
-func TestITCDRsMySQL(t *testing.T) {
-	cfg, err := config.NewCGRConfigFromPath(path.Join(*dataDir, "conf", "samples", "storage", "mysql"))
-	if err != nil {
-		t.Error(err)
+func TestITCDRs(t *testing.T) {
+	var cdrsConfigDIR string
+	switch *dbType {
+	case utils.MetaInternal:
+		cdrsConfigDIR = "internal"
+	case utils.MetaSQL:
+		cdrsConfigDIR = "mysql"
+	case utils.MetaMongo:
+		cdrsConfigDIR = "mongo"
+	case utils.MetaPostgres:
+		cdrsConfigDIR = "postgres"
+	default:
+		t.Fatal("Unknown Database type")
 	}
-	if err := testGetCDRs(cfg); err != nil {
-		t.Error(err)
-	}
-	if err := testSetCDR(cfg); err != nil {
-		t.Error(err)
-	}
-	if err := testSMCosts(cfg); err != nil {
-		t.Error(err)
-	}
-}
 
-func TestITCDRsPSQL(t *testing.T) {
-	cfg, err := config.NewCGRConfigFromPath(path.Join(*dataDir, "conf", "samples", "storage", "postgres"))
-	if err != nil {
-		t.Error(err)
-	}
-	if err := testGetCDRs(cfg); err != nil {
-		t.Error(err)
-	}
-	if err := testSetCDR(cfg); err != nil {
-		t.Error(err)
-	}
-	if err := testSMCosts(cfg); err != nil {
-		t.Error(err)
-	}
-}
-
-func TestITCDRsMongo(t *testing.T) {
-	cfg, err := config.NewCGRConfigFromPath(path.Join(*dataDir, "conf", "samples", "storage", "mongo"))
-	if err != nil {
-		t.Error(err)
-	}
-	if err := testGetCDRs(cfg); err != nil {
-		t.Error(err)
-	}
-	if err := testSetCDR(cfg); err != nil {
-		t.Error(err)
-	}
-	if err := testSMCosts(cfg); err != nil {
-		t.Error(err)
-	}
-}
-
-func TestITCDRsInternal(t *testing.T) {
-	cfg, err := config.NewCGRConfigFromPath(path.Join(*dataDir, "conf", "samples", "storage", "internal"))
+	cfg, err := config.NewCGRConfigFromPath(path.Join(*dataDir, "conf", "samples", "storage", cdrsConfigDIR))
 	if err != nil {
 		t.Error(err)
 	}

engine/stordb_it_test.go

@@ -59,78 +59,57 @@ var sTestsStorDBit = []func(t *testing.T){
 	testStorDBitCRUDSMCosts2,
 }
 
-func TestStorDBitMySQL(t *testing.T) {
-	if cfg, err = config.NewCGRConfigFromPath(path.Join(*dataDir, "conf", "samples", "storage", "mysql")); err != nil {
-		t.Fatal(err)
-	}
-	if storDB, err = NewMySQLStorage(cfg.StorDbCfg().Host,
-		cfg.StorDbCfg().Port, cfg.StorDbCfg().Name,
-		cfg.StorDbCfg().User, cfg.StorDbCfg().Password,
-		cfg.StorDbCfg().MaxOpenConns, cfg.StorDbCfg().MaxIdleConns,
-		cfg.StorDbCfg().ConnMaxLifetime); err != nil {
-		t.Fatal(err)
-	}
-	for _, stest := range sTestsStorDBit {
-		stestFullName := runtime.FuncForPC(reflect.ValueOf(stest).Pointer()).Name()
-		split := strings.Split(stestFullName, ".")
-		stestName := split[len(split)-1]
-		t.Run(stestName, stest)
-	}
-}
-
-func TestStorDBitPostgresSQL(t *testing.T) {
-	if cfg, err = config.NewCGRConfigFromPath(path.Join(*dataDir, "conf", "samples", "storage", "postgres")); err != nil {
-		t.Fatal(err)
-	}
-	if storDB, err = NewPostgresStorage(cfg.StorDbCfg().Host,
-		cfg.StorDbCfg().Port, cfg.StorDbCfg().Name,
-		cfg.StorDbCfg().User, cfg.StorDbCfg().Password,
-		cfg.StorDbCfg().SSLMode, cfg.StorDbCfg().MaxOpenConns,
-		cfg.StorDbCfg().MaxIdleConns, cfg.StorDbCfg().ConnMaxLifetime); err != nil {
-		t.Fatal(err)
-	}
-	for _, stest := range sTestsStorDBit {
-		stestFullName := runtime.FuncForPC(reflect.ValueOf(stest).Pointer()).Name()
-		split := strings.Split(stestFullName, ".")
-		stestName := split[len(split)-1]
-		t.Run(stestName, stest)
-	}
-}
-
-func TestStorDBitMongo(t *testing.T) {
-	if cfg, err = config.NewCGRConfigFromPath(path.Join(*dataDir, "conf", "samples", "storage", "mongo")); err != nil {
-		t.Fatal(err)
-	}
-	if storDB, err = NewMongoStorage(cfg.StorDbCfg().Host,
-		cfg.StorDbCfg().Port, cfg.StorDbCfg().Name,
-		cfg.StorDbCfg().User, cfg.StorDbCfg().Password,
-		utils.StorDB, cfg.StorDbCfg().StringIndexedFields, false); err != nil {
-		t.Fatal(err)
-	}
-	for _, stest := range sTestsStorDBit {
-		stestFullName := runtime.FuncForPC(reflect.ValueOf(stest).Pointer()).Name()
-		split := strings.Split(stestFullName, ".")
-		stestName := split[len(split)-1]
-		// Fixme: Implement mongo needed versions methods
-		if stestName != "testStorDBitCRUDVersions" {
-			stestName := split[len(split)-1]
-			t.Run(stestName, stest)
+func TestStorDBit(t *testing.T) {
+	//var stestName string
+	switch *dbType {
+	case utils.MetaInternal:
+		if cfg, err = config.NewDefaultCGRConfig(); err != nil {
+			t.Error(err)
 		}
+		config.SetCgrConfig(cfg)
+		storDB = NewInternalDB(nil, nil, false, cfg.StorDbCfg().Items)
+	case utils.MetaSQL:
+		if cfg, err = config.NewCGRConfigFromPath(path.Join(*dataDir, "conf", "samples", "storage", "mysql")); err != nil {
+			t.Fatal(err)
+		}
+		if storDB, err = NewMySQLStorage(cfg.StorDbCfg().Host,
+			cfg.StorDbCfg().Port, cfg.StorDbCfg().Name,
+			cfg.StorDbCfg().User, cfg.StorDbCfg().Password,
+			cfg.StorDbCfg().MaxOpenConns, cfg.StorDbCfg().MaxIdleConns,
+			cfg.StorDbCfg().ConnMaxLifetime); err != nil {
+			t.Fatal(err)
+		}
+	case utils.MetaMongo:
+		if cfg, err = config.NewCGRConfigFromPath(path.Join(*dataDir, "conf", "samples", "storage", "mongo")); err != nil {
+			t.Fatal(err)
+		}
+		if storDB, err = NewMongoStorage(cfg.StorDbCfg().Host,
+			cfg.StorDbCfg().Port, cfg.StorDbCfg().Name,
+			cfg.StorDbCfg().User, cfg.StorDbCfg().Password,
+			utils.StorDB, cfg.StorDbCfg().StringIndexedFields, false); err != nil {
+			t.Fatal(err)
+		}
+	case utils.MetaPostgres:
+		if cfg, err = config.NewCGRConfigFromPath(path.Join(*dataDir, "conf", "samples", "storage", "postgres")); err != nil {
+			t.Fatal(err)
+		}
+		if storDB, err = NewPostgresStorage(cfg.StorDbCfg().Host,
+			cfg.StorDbCfg().Port, cfg.StorDbCfg().Name,
+			cfg.StorDbCfg().User, cfg.StorDbCfg().Password,
+			cfg.StorDbCfg().SSLMode, cfg.StorDbCfg().MaxOpenConns,
+			cfg.StorDbCfg().MaxIdleConns, cfg.StorDbCfg().ConnMaxLifetime); err != nil {
+			t.Fatal(err)
+		}
+	default:
+		t.Fatal("Unknown Database type")
 	}
-}
 
-func TestStorDBitInternalDB(t *testing.T) {
-	if cfg, err = config.NewDefaultCGRConfig(); err != nil {
-		t.Error(err)
-	}
-	config.SetCgrConfig(cfg)
-	storDB = NewInternalDB(nil, nil, false, cfg.StorDbCfg().Items)
 	for _, stest := range sTestsStorDBit {
 		stestFullName := runtime.FuncForPC(reflect.ValueOf(stest).Pointer()).Name()
 		split := strings.Split(stestFullName, ".")
 		stestName := split[len(split)-1]
 		// Fixme: Implement mongo needed versions methods
-		if stestName != "testStorDBitCRUDVersions" {
+		if (*dbType == utils.MetaMongo || *dbType == utils.MetaInternal) && stestName != "testStorDBitCRUDVersions" {
 			stestName := split[len(split)-1]
 			t.Run(stestName, stest)
 		}

engine/versions_it_test.go

@@ -29,52 +29,45 @@ import (
 )
 
 var (
-	storageDb Storage
-	dm3       *DataManager
-	dbtype    string
+	storageDb         Storage
+	dm3               *DataManager
+	versionsConfigDIR string
+
+	sTestsITVersions = []func(t *testing.T){
+		testInitConfig,
+		testInitDataDB,
+		testVersionsFlush,
+		testVersion,
+		testVersionsFlush,
+	}
 )
 
-var sTestsITVersions = []func(t *testing.T){
-	testVersionsFlush,
-	testVersion,
-	testVersionsFlush,
-}
+func TestVersionsIT(t *testing.T) {
+	switch *dbType {
+	case utils.MetaInternal:
+		t.SkipNow()
+	case utils.MetaSQL:
+		versionsConfigDIR = "tutmysql"
+	case utils.MetaMongo:
+		versionsConfigDIR = "tutmongo"
+	case utils.MetaPostgres:
+		versionsConfigDIR = "storage/postgres"
+	default:
+		t.Fatal("Unknown Database type")
+	}
 
-func TestVersionsITMongo(t *testing.T) {
-	var err error
-	if cfg, err = config.NewCGRConfigFromPath(path.Join(*dataDir, "conf", "samples", "tutmongo")); err != nil {
-		t.Fatal(err)
-	}
-	dbConn, err := NewDataDBConn(cfg.DataDbCfg().DataDbType,
-		cfg.DataDbCfg().DataDbHost, cfg.DataDbCfg().DataDbPort,
-		cfg.DataDbCfg().DataDbName, cfg.DataDbCfg().DataDbUser,
-		cfg.DataDbCfg().DataDbPass, cfg.GeneralCfg().DBDataEncoding,
-		"", cfg.DataDbCfg().Items)
-	if err != nil {
-		log.Fatal(err)
-	}
-	dm3 = NewDataManager(dbConn, cfg.CacheCfg(), nil)
-	storageDb, err = NewStorDBConn(cfg.StorDbCfg().Type,
-		cfg.StorDbCfg().Host, cfg.StorDbCfg().Port,
-		cfg.StorDbCfg().Name, cfg.StorDbCfg().User,
-		cfg.StorDbCfg().Password, cfg.StorDbCfg().SSLMode,
-		cfg.StorDbCfg().MaxOpenConns, cfg.StorDbCfg().MaxIdleConns,
-		cfg.StorDbCfg().ConnMaxLifetime, cfg.StorDbCfg().StringIndexedFields,
-		cfg.StorDbCfg().PrefixIndexedFields, cfg.StorDbCfg().Items)
-	if err != nil {
-		log.Fatal(err)
-	}
-	dbtype = utils.MONGO
 	for _, stest := range sTestsITVersions {
-		t.Run("TestVersionsITMongo", stest)
+		t.Run(versionsConfigDIR, stest)
 	}
 }
 
-func TestVersionsITRedisMYSQL(t *testing.T) {
-	var err error
-	if cfg, err = config.NewCGRConfigFromPath(path.Join(*dataDir, "conf", "samples", "tutmysql")); err != nil {
+func testInitConfig(t *testing.T) {
+	if cfg, err = config.NewCGRConfigFromPath(path.Join(*dataDir, "conf", "samples", versionsConfigDIR)); err != nil {
 		t.Fatal(err)
 	}
+}
+
+func testInitDataDB(t *testing.T) {
 	dbConn, err := NewDataDBConn(cfg.DataDbCfg().DataDbType,
 		cfg.DataDbCfg().DataDbHost, cfg.DataDbCfg().DataDbPort,
 		cfg.DataDbCfg().DataDbName, cfg.DataDbCfg().DataDbUser,
@@ -95,41 +88,6 @@ func TestVersionsITRedisMYSQL(t *testing.T) {
 	if err != nil {
 		log.Fatal(err)
 	}
-	dbtype = utils.REDIS
-	for _, stest := range sTestsITVersions {
-		t.Run("TestVersionsITRedis", stest)
-	}
-}
-
-func TestVersionsITRedisPostgres(t *testing.T) {
-	var err error
-	if cfg, err = config.NewCGRConfigFromPath(path.Join(*dataDir, "conf", "samples", "storage", "postgres")); err != nil {
-		t.Fatal(err)
-	}
-	dbConn, err := NewDataDBConn(cfg.DataDbCfg().DataDbType,
-		cfg.DataDbCfg().DataDbHost, cfg.DataDbCfg().DataDbPort,
-		cfg.DataDbCfg().DataDbName, cfg.DataDbCfg().DataDbUser,
-		cfg.DataDbCfg().DataDbPass, cfg.GeneralCfg().DBDataEncoding,
-		"", cfg.DataDbCfg().Items)
-	if err != nil {
-		log.Fatal(err)
-	}
-	dm3 = NewDataManager(dbConn, cfg.CacheCfg(), nil)
-	storageDb, err = NewStorDBConn(cfg.StorDbCfg().Type,
-		cfg.StorDbCfg().Host, cfg.StorDbCfg().Port,
-		cfg.StorDbCfg().Name, cfg.StorDbCfg().User,
-		cfg.StorDbCfg().Password, cfg.StorDbCfg().SSLMode,
-		cfg.StorDbCfg().MaxOpenConns, cfg.StorDbCfg().MaxIdleConns,
-		cfg.StorDbCfg().ConnMaxLifetime, cfg.StorDbCfg().StringIndexedFields,
-		cfg.StorDbCfg().PrefixIndexedFields, cfg.StorDbCfg().Items)
-	if err != nil {
-		log.Fatal(err)
-	}
-
-	dbtype = utils.REDIS
-	for _, stest := range sTestsITVersions {
-		t.Run("TestMigratorITPostgres", stest)
-	}
 }
 
 func testVersionsFlush(t *testing.T) {

services/dispatchers_it_test.go

@@ -70,7 +70,7 @@ func TestDispatcherSReload(t *testing.T) {
 	}
 	var reply string
 	if err = cfg.V1ReloadConfigFromPath(&config.ConfigReloadWithArgDispatcher{
-		Path:    path.Join("/usr", "share", "cgrates", "conf", "samples", "dispatchers", "dispatchers_mysql"),
+		Path: path.Join("/usr", "share", "cgrates", "conf", "samples", "dispatchers", "dispatchers_mysql"),
 
 		Section: config.DispatcherSJson,
 	}, &reply); err != nil {