Coveraget tests

2026-02-23 16:18:44 +05:00 · 2022-03-24 17:32:17 +02:00
parent d9bb5bca7a
commit 51b495695b
16 changed files with 760 additions and 421 deletions
--- a/apis/replicator_test.go
+++ b/apis/replicator_test.go
@@ -0,0 +1,292 @@
+/*
+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 apis
+
+import (
+	"reflect"
+	"testing"
+
+	"github.com/cgrates/birpc/context"
+	"github.com/cgrates/cgrates/config"
+	"github.com/cgrates/cgrates/engine"
+	"github.com/cgrates/cgrates/utils"
+)
+
+func TestNewReplicatorSv1(t *testing.T) {
+	cfg := config.NewDefaultCGRConfig()
+	data := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
+	dm := engine.NewDataManager(data, cfg.CacheCfg(), nil)
+	v1 := &AdminSv1{
+		cfg:     cfg,
+		dm:      dm,
+		connMgr: engine.NewConnManager(cfg),
+		ping:    struct{}{},
+	}
+	rcv := NewReplicatorSv1(dm, v1)
+	exp := &ReplicatorSv1{
+		dm: dm,
+		v1: v1,
+	}
+	if !reflect.DeepEqual(rcv, exp) {
+		t.Errorf("Expected %v\n but received %v", exp, rcv)
+	}
+}
+
+func TestReplicatorGetAccount(t *testing.T) {
+	cfg := config.NewDefaultCGRConfig()
+	data := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
+	dm := engine.NewDataManager(data, cfg.CacheCfg(), nil)
+	v1 := &AdminSv1{
+		cfg:     cfg,
+		dm:      dm,
+		connMgr: engine.NewConnManager(cfg),
+		ping:    struct{}{},
+	}
+
+	var reply utils.Account
+	rp := NewReplicatorSv1(dm, v1)
+	acc := &utils.Account{
+		Tenant: "cgrates.org",
+		ID:     "Account_simple",
+		Opts:   map[string]interface{}{},
+		Balances: map[string]*utils.Balance{
+			"VoiceBalance": {
+				ID:        "VoiceBalance",
+				FilterIDs: []string{"*string:~*req.Account:1001"},
+				Weights: utils.DynamicWeights{
+					{
+						Weight: 12,
+					},
+				},
+				Type: "*abstract",
+				Opts: map[string]interface{}{
+					"Destination": "10",
+				},
+				Units: utils.NewDecimal(0, 0),
+			},
+		},
+		Weights: utils.DynamicWeights{
+			{
+				Weight: 10,
+			},
+		},
+	}
+	rp.dm.SetAccount(context.Background(), acc, false)
+	tntID := &utils.TenantIDWithAPIOpts{
+		TenantID: utils.NewTenantID("cgrates.org:Account_simple"),
+	}
+
+	if err := rp.GetAccount(context.Background(), tntID, &reply); err != nil {
+		t.Error(err)
+	}
+	if !reflect.DeepEqual(acc, &reply) {
+		t.Errorf("Expected %v\n but received %v", acc, reply)
+	}
+}
+
+func TestReplicatorGetStatQueue(t *testing.T) {
+	cfg := config.NewDefaultCGRConfig()
+	data := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
+	dm := engine.NewDataManager(data, cfg.CacheCfg(), nil)
+	v1 := &AdminSv1{
+		cfg:     cfg,
+		dm:      dm,
+		connMgr: engine.NewConnManager(cfg),
+		ping:    struct{}{},
+	}
+
+	var reply engine.StatQueue
+	rp := NewReplicatorSv1(dm, v1)
+
+	stq := &engine.StatQueue{
+		Tenant: "cgrates.org",
+		ID:     "sq1",
+		SQMetrics: map[string]engine.StatMetric{
+			utils.MetaACD: engine.NewACD(0, "", nil),
+			utils.MetaTCD: engine.NewTCD(0, "", nil),
+		},
+	}
+	rp.dm.SetStatQueue(context.Background(), stq)
+	tntID := &utils.TenantIDWithAPIOpts{
+		TenantID: utils.NewTenantID("cgrates.org:sq1"),
+	}
+
+	if err := rp.GetStatQueue(context.Background(), tntID, &reply); err != nil {
+		t.Error(err)
+	}
+	if !reflect.DeepEqual(stq, &reply) {
+		t.Errorf("Expected %v\n but received %v", stq, reply)
+	}
+}
+
+func TestReplicatorGetFilter(t *testing.T) {
+	cfg := config.NewDefaultCGRConfig()
+	data := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
+	dm := engine.NewDataManager(data, cfg.CacheCfg(), nil)
+	v1 := &AdminSv1{
+		cfg:     cfg,
+		dm:      dm,
+		connMgr: engine.NewConnManager(cfg),
+		ping:    struct{}{},
+	}
+
+	var reply engine.Filter
+	rp := NewReplicatorSv1(dm, v1)
+
+	fltr := &engine.Filter{
+		Tenant: utils.CGRateSorg,
+		ID:     "fltr_for_prf",
+		Rules: []*engine.FilterRule{
+			{
+				Type:    utils.MetaString,
+				Element: "~*req.Subject",
+				Values:  []string{"1004", "6774", "22312"},
+			},
+			{
+				Type:    utils.MetaString,
+				Element: "~*opts.Subsystems",
+				Values:  []string{"*attributes"},
+			},
+			{
+				Type:    utils.MetaPrefix,
+				Element: "~*req.Destinations",
+				Values:  []string{"+0775", "+442"},
+			},
+			{
+				Type:    utils.MetaExists,
+				Element: "~*req.NumberOfEvents",
+			},
+		},
+	}
+	rp.dm.SetFilter(context.Background(), fltr, false)
+	tntID := &utils.TenantIDWithAPIOpts{
+		TenantID: utils.NewTenantID("cgrates.org:fltr_for_prf"),
+	}
+
+	if err := rp.GetFilter(context.Background(), tntID, &reply); err != nil {
+		t.Error(err)
+	}
+	if !reflect.DeepEqual(fltr, &reply) {
+		t.Errorf("Expected %v\n but received %v", fltr, reply)
+	}
+}
+
+func TestReplicatorGetThreshold(t *testing.T) {
+	cfg := config.NewDefaultCGRConfig()
+	data := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
+	dm := engine.NewDataManager(data, cfg.CacheCfg(), nil)
+	v1 := &AdminSv1{
+		cfg:     cfg,
+		dm:      dm,
+		connMgr: engine.NewConnManager(cfg),
+		ping:    struct{}{},
+	}
+
+	var reply engine.Threshold
+	rp := NewReplicatorSv1(dm, v1)
+
+	thd := &engine.Threshold{
+		Tenant: "cgrates.org",
+		ID:     "THD_2",
+		Hits:   0,
+	}
+	rp.dm.SetThreshold(context.Background(), thd)
+	tntID := &utils.TenantIDWithAPIOpts{
+		TenantID: utils.NewTenantID("cgrates.org:THD_2"),
+	}
+
+	if err := rp.GetThreshold(context.Background(), tntID, &reply); err != nil {
+		t.Error(err)
+	}
+	if !reflect.DeepEqual(thd, &reply) {
+		t.Errorf("Expected %v\n but received %v", thd, reply)
+	}
+}
+
+func TestReplicatorGetThresholdProfile(t *testing.T) {
+	cfg := config.NewDefaultCGRConfig()
+	data := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
+	dm := engine.NewDataManager(data, cfg.CacheCfg(), nil)
+	v1 := &AdminSv1{
+		cfg:     cfg,
+		dm:      dm,
+		connMgr: engine.NewConnManager(cfg),
+		ping:    struct{}{},
+	}
+
+	var reply engine.ThresholdProfile
+	rp := NewReplicatorSv1(dm, v1)
+
+	thd := &engine.ThresholdProfile{
+		Tenant:           "cgrates.org",
+		ID:               "THD_2",
+		FilterIDs:        []string{"*string:~*req.Account:1001"},
+		ActionProfileIDs: []string{"actPrfID"},
+		MaxHits:          7,
+		MinHits:          0,
+		Weights: utils.DynamicWeights{
+			{
+				Weight: 20,
+			},
+		},
+		Async: true,
+	}
+	rp.dm.SetThresholdProfile(context.Background(), thd, false)
+	tntID := &utils.TenantIDWithAPIOpts{
+		TenantID: utils.NewTenantID("cgrates.org:THD_2"),
+	}
+
+	if err := rp.GetThresholdProfile(context.Background(), tntID, &reply); err != nil {
+		t.Error(err)
+	}
+	if !reflect.DeepEqual(thd, &reply) {
+		t.Errorf("Expected %v\n but received %v", thd, reply)
+	}
+}
+
+func TestReplicatorGetResource(t *testing.T) {
+	cfg := config.NewDefaultCGRConfig()
+	data := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
+	dm := engine.NewDataManager(data, cfg.CacheCfg(), nil)
+	v1 := &AdminSv1{
+		cfg:     cfg,
+		dm:      dm,
+		connMgr: engine.NewConnManager(cfg),
+		ping:    struct{}{},
+	}
+
+	var reply engine.Resource
+	rp := NewReplicatorSv1(dm, v1)
+	rsc := &engine.Resource{
+		Tenant: "cgrates.org",
+		ID:     "ResGroup2",
+		Usages: make(map[string]*engine.ResourceUsage),
+	}
+	rp.dm.SetResource(context.Background(), rsc)
+	tntID := &utils.TenantIDWithAPIOpts{
+		TenantID: utils.NewTenantID("cgrates.org:ResGroup2"),
+	}
+
+	if err := rp.GetResource(context.Background(), tntID, &reply); err != nil {
+		t.Error(err)
+	}
+	if !reflect.DeepEqual(rsc, &reply) {
+		t.Errorf("Expected %v\n but received %v", rsc, reply)
+	}
+}
--- a/engine/libindex_health_test.go
+++ b/engine/libindex_health_test.go
@@ -25,22 +25,32 @@ import (

 	"github.com/cgrates/birpc/context"
 	"github.com/cgrates/cgrates/config"
+	"github.com/cgrates/cgrates/utils"
 	"github.com/cgrates/ltcache"
 )

 func TestGetFltrIdxHealthForRateRates(t *testing.T) {
 	cfg := config.NewDefaultCGRConfig()
-	connMng := NewConnManager(cfg)
-	dataDB, err := NewDataDBConn(cfg.DataDbCfg().Type,
-		cfg.DataDbCfg().Host, cfg.DataDbCfg().Port,
-		cfg.DataDbCfg().Name, cfg.DataDbCfg().User,
-		cfg.DataDbCfg().Password, cfg.GeneralCfg().DBDataEncoding,
-		cfg.DataDbCfg().Opts, cfg.DataDbCfg().Items)
-	if err != nil {
-		t.Error(err)
+	data := NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
+	dm := NewDataManager(data, cfg.CacheCfg(), nil)
+	rt := &utils.RateProfile{
+		Tenant:          utils.CGRateSorg,
+		ID:              "TEST_RATE_TEST",
+		FilterIDs:       []string{"*string:~*req.Account:dan"},
+		MaxCostStrategy: "*free",
+		Rates: map[string]*utils.Rate{
+			"RT_WEEK": {
+				ID:              "RT_WEEK",
+				ActivationTimes: "* * * * 1-5",
+				IntervalRates: []*utils.IntervalRate{
+					{
+						IntervalStart: utils.NewDecimal(0, 0),
+					},
+				},
+			},
+		},
 	}
-	defer dataDB.Close()
-	dm := NewDataManager(dataDB, config.CgrConfig().CacheCfg(), connMng)
+	dm.SetRateProfileRates(context.Background(), rt, false)
 	rply, err := GetFltrIdxHealthForRateRates(context.Background(), dm, ltcache.NewCache(50, 60*time.Second, true, nil),
 		ltcache.NewCache(40, 30*time.Second, false, nil),
 		ltcache.NewCache(20, 20*time.Second, true, nil))
@@ -49,9 +59,7 @@ func TestGetFltrIdxHealthForRateRates(t *testing.T) {
 	}
 	exp := &FilterIHReply{
 		MissingObjects: nil,
-		MissingIndexes: map[string][]string{
-			"cgrates.org:TEST_RATE_TEST:*none:*any:*any": {"RT_WEEK"},
-		},
+		MissingIndexes: map[string][]string{},
 		BrokenIndexes:  make(map[string][]string),
 		MissingFilters: make(map[string][]string),
 	}
--- a/engine/libindex_test.go
+++ b/engine/libindex_test.go
@@ -51,17 +51,23 @@ func TestSplitFilterIndexesWrongFormat(t *testing.T) {

 func TestComputeIndexes(t *testing.T) {
 	cfg := config.NewDefaultCGRConfig()
-	connMng := NewConnManager(cfg)
-	dataDB, err := NewDataDBConn(cfg.DataDbCfg().Type,
-		cfg.DataDbCfg().Host, cfg.DataDbCfg().Port,
-		cfg.DataDbCfg().Name, cfg.DataDbCfg().User,
-		cfg.DataDbCfg().Password, cfg.GeneralCfg().DBDataEncoding,
-		cfg.DataDbCfg().Opts, cfg.DataDbCfg().Items)
-	if err != nil {
-		t.Error(err)
+	data := NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
+	dm := NewDataManager(data, cfg.CacheCfg(), nil)
+	thd := &ThresholdProfile{
+		Tenant:           "cgrates.org",
+		ID:               "THD_2",
+		FilterIDs:        []string{"*string:~*req.Account:1001"},
+		ActionProfileIDs: []string{"actPrfID"},
+		MaxHits:          7,
+		MinHits:          0,
+		Weights: utils.DynamicWeights{
+			{
+				Weight: 20,
+			},
+		},
+		Async: true,
 	}
-	defer dataDB.Close()
-	dm := NewDataManager(dataDB, config.CgrConfig().CacheCfg(), connMng)
+	dm.SetThresholdProfile(context.Background(), thd, false)
 	transactionID := utils.GenUUID()
 	indexes, err := ComputeIndexes(context.Background(), dm, "cgrates.org", utils.EmptyString, utils.CacheThresholdFilterIndexes,
 		nil, transactionID, func(tnt, id, grp string) (*[]string, error) {
@@ -83,17 +89,23 @@ func TestComputeIndexes(t *testing.T) {

 func TestComputeIndexesIDsNotNil(t *testing.T) {
 	cfg := config.NewDefaultCGRConfig()
-	connMng := NewConnManager(cfg)
-	dataDB, err := NewDataDBConn(cfg.DataDbCfg().Type,
-		cfg.DataDbCfg().Host, cfg.DataDbCfg().Port,
-		cfg.DataDbCfg().Name, cfg.DataDbCfg().User,
-		cfg.DataDbCfg().Password, cfg.GeneralCfg().DBDataEncoding,
-		cfg.DataDbCfg().Opts, cfg.DataDbCfg().Items)
-	if err != nil {
-		t.Error(err)
+	data := NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
+	dm := NewDataManager(data, cfg.CacheCfg(), nil)
+	thd := &ThresholdProfile{
+		Tenant:           "cgrates.org",
+		ID:               "THD_2",
+		FilterIDs:        []string{"*string:~*req.Account:1001"},
+		ActionProfileIDs: []string{"actPrfID"},
+		MaxHits:          7,
+		MinHits:          0,
+		Weights: utils.DynamicWeights{
+			{
+				Weight: 20,
+			},
+		},
+		Async: true,
 	}
-	defer dataDB.Close()
-	dm := NewDataManager(dataDB, config.CgrConfig().CacheCfg(), connMng)
+	dm.SetThresholdProfile(context.Background(), thd, false)
 	transactionID := utils.GenUUID()
 	_, err = ComputeIndexes(context.Background(), dm, "cgrates.org", utils.EmptyString, utils.CacheThresholdFilterIndexes,
 		&[]string{utils.CacheThresholdFilterIndexes, utils.CacheAccountsFilterIndexes}, transactionID, func(tnt, id, grp string) (*[]string, error) {
@@ -110,17 +122,24 @@ func TestComputeIndexesIDsNotNil(t *testing.T) {

 func TestRemoveIndexFiltersItem(t *testing.T) {
 	cfg := config.NewDefaultCGRConfig()
-	connMng := NewConnManager(cfg)
-	dataDB, err := NewDataDBConn(cfg.DataDbCfg().Type,
-		cfg.DataDbCfg().Host, cfg.DataDbCfg().Port,
-		cfg.DataDbCfg().Name, cfg.DataDbCfg().User,
-		cfg.DataDbCfg().Password, cfg.GeneralCfg().DBDataEncoding,
-		cfg.DataDbCfg().Opts, cfg.DataDbCfg().Items)
-	if err != nil {
-		t.Error(err)
+	data := NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
+	dm := NewDataManager(data, cfg.CacheCfg(), nil)
+	thd := &ThresholdProfile{
+		Tenant:           "cgrates.org",
+		ID:               "THD_2",
+		FilterIDs:        []string{"*string:~*req.Account:1001"},
+		ActionProfileIDs: []string{"actPrfID"},
+		MaxHits:          7,
+		MinHits:          0,
+		Weights: utils.DynamicWeights{
+			{
+				Weight: 20,
+			},
+		},
+		Async: true,
 	}
-	defer dataDB.Close()
-	dm := NewDataManager(dataDB, config.CgrConfig().CacheCfg(), connMng)
+	dm.SetThresholdProfile(context.Background(), thd, false)
+	// dm := NewDataManager(dataDB, config.CgrConfig().CacheCfg(), connMng)
 	if err := removeIndexFiltersItem(context.Background(), dm, utils.CacheThresholdFilterIndexes, "cgrates.org", "", []string{"account"}); err != nil {
 		t.Error(err)
 	}
@@ -128,19 +147,26 @@ func TestRemoveIndexFiltersItem(t *testing.T) {

 func TestRemoveFilterIndexesForFilter(t *testing.T) {
 	cfg := config.NewDefaultCGRConfig()
-	connMng := NewConnManager(cfg)
-	dataDB, err := NewDataDBConn(cfg.DataDbCfg().Type,
-		cfg.DataDbCfg().Host, cfg.DataDbCfg().Port,
-		cfg.DataDbCfg().Name, cfg.DataDbCfg().User,
-		cfg.DataDbCfg().Password, cfg.GeneralCfg().DBDataEncoding,
-		cfg.DataDbCfg().Opts, cfg.DataDbCfg().Items)
-	if err != nil {
-		t.Error(err)
+	data := NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
+	dm := NewDataManager(data, cfg.CacheCfg(), nil)
+	thd := &ThresholdProfile{
+		Tenant:           "cgrates.org",
+		ID:               "THD_2",
+		FilterIDs:        []string{"*string:~*req.Account:1001"},
+		ActionProfileIDs: []string{"actPrfID"},
+		MaxHits:          7,
+		MinHits:          0,
+		Weights: utils.DynamicWeights{
+			{
+				Weight: 20,
+			},
+		},
+		Async: true,
 	}
-	defer dataDB.Close()
+	dm.SetThresholdProfile(context.Background(), thd, false)
 	exp := make(utils.StringSet)
 	exp.Add(utils.ConcatenatedKey("cgrates.org", "*string:*req.Account:1001"))
-	dm := NewDataManager(dataDB, config.CgrConfig().CacheCfg(), connMng)
+	// dm := NewDataManager(dataDB, config.CgrConfig().CacheCfg(), connMng)
 	if err := removeFilterIndexesForFilter(context.Background(), dm, utils.CacheThresholdFilterIndexes, "cgrates.org", []string{""}, exp); err != nil {
 		t.Error(err)
 	}
--- a/tpes/tpe_accounts_test.go
+++ b/tpes/tpe_accounts_test.go
@@ -76,17 +76,19 @@ func TestTPEnewTPAccounts(t *testing.T) {
 func TestTPEExportItemsAccount(t *testing.T) {
 	wrtr := new(bytes.Buffer)
 	cfg := config.NewDefaultCGRConfig()
-	connMng := engine.NewConnManager(cfg)
-	dataDB, err := engine.NewDataDBConn(cfg.DataDbCfg().Type,
-		cfg.DataDbCfg().Host, cfg.DataDbCfg().Port,
-		cfg.DataDbCfg().Name, cfg.DataDbCfg().User,
-		cfg.DataDbCfg().Password, cfg.GeneralCfg().DBDataEncoding,
-		cfg.DataDbCfg().Opts, cfg.DataDbCfg().Items)
-	if err != nil {
-		t.Error(err)
-	}
-	defer dataDB.Close()
-	dm := engine.NewDataManager(dataDB, config.CgrConfig().CacheCfg(), connMng)
+	// connMng := engine.NewConnManager(cfg)
+	// dataDB, err := engine.NewDataDBConn(cfg.DataDbCfg().Type,
+	// 	cfg.DataDbCfg().Host, cfg.DataDbCfg().Port,
+	// 	cfg.DataDbCfg().Name, cfg.DataDbCfg().User,
+	// 	cfg.DataDbCfg().Password, cfg.GeneralCfg().DBDataEncoding,
+	// 	cfg.DataDbCfg().Opts, cfg.DataDbCfg().Items)
+	// if err != nil {
+	// 	t.Error(err)
+	// }
+	// defer dataDB.Close()
+	// dm := engine.NewDataManager(dataDB, config.CgrConfig().CacheCfg(), connMng)
+	data := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
+	dm := engine.NewDataManager(data, cfg.CacheCfg(), nil)
 	tpAcc := TPAccounts{
 		dm: dm,
 	}
@@ -117,7 +119,7 @@ func TestTPEExportItemsAccount(t *testing.T) {
 		},
 	}
 	tpAcc.dm.SetAccount(context.Background(), acc, false)
-	err = tpAcc.exportItems(context.Background(), wrtr, "cgrates.org", []string{"Account_simple"})
+	err := tpAcc.exportItems(context.Background(), wrtr, "cgrates.org", []string{"Account_simple"})
 	if err != nil {
 		t.Errorf("Expected nil\n but received %v", err)
 	}
@@ -215,17 +217,8 @@ func TestTPEExportItemsAccountNoDbConn(t *testing.T) {
 func TestTPEExportItemsAccountIDNotFound(t *testing.T) {
 	wrtr := new(bytes.Buffer)
 	cfg := config.NewDefaultCGRConfig()
-	connMng := engine.NewConnManager(cfg)
-	dataDB, err := engine.NewDataDBConn(cfg.DataDbCfg().Type,
-		cfg.DataDbCfg().Host, cfg.DataDbCfg().Port,
-		cfg.DataDbCfg().Name, cfg.DataDbCfg().User,
-		cfg.DataDbCfg().Password, cfg.GeneralCfg().DBDataEncoding,
-		cfg.DataDbCfg().Opts, cfg.DataDbCfg().Items)
-	if err != nil {
-		t.Error(err)
-	}
-	defer dataDB.Close()
-	dm := engine.NewDataManager(dataDB, config.CgrConfig().CacheCfg(), connMng)
+	data := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
+	dm := engine.NewDataManager(data, cfg.CacheCfg(), nil)
 	tpAcc := TPAccounts{
 		dm: dm,
 	}
@@ -256,7 +249,7 @@ func TestTPEExportItemsAccountIDNotFound(t *testing.T) {
 		},
 	}
 	tpAcc.dm.SetAccount(context.Background(), acc, false)
-	err = tpAcc.exportItems(context.Background(), wrtr, "cgrates.net", []string{"Account_simple"})
+	err := tpAcc.exportItems(context.Background(), wrtr, "cgrates.net", []string{"Account_simple"})
 	errExpect := "<NOT_FOUND> cannot find Account with id: <Account_simple>"
 	if err.Error() != errExpect {
 		t.Errorf("Expected %v\n but received %v", errExpect, err)
--- a/tpes/tpe_actions_test.go
+++ b/tpes/tpe_actions_test.go
@@ -74,17 +74,8 @@ func TestTPEnewTPActions(t *testing.T) {
 func TestTPEExportItemsActions(t *testing.T) {
 	wrtr := new(bytes.Buffer)
 	cfg := config.NewDefaultCGRConfig()
-	connMng := engine.NewConnManager(cfg)
-	dataDB, err := engine.NewDataDBConn(cfg.DataDbCfg().Type,
-		cfg.DataDbCfg().Host, cfg.DataDbCfg().Port,
-		cfg.DataDbCfg().Name, cfg.DataDbCfg().User,
-		cfg.DataDbCfg().Password, cfg.GeneralCfg().DBDataEncoding,
-		cfg.DataDbCfg().Opts, cfg.DataDbCfg().Items)
-	if err != nil {
-		t.Error(err)
-	}
-	defer dataDB.Close()
-	dm := engine.NewDataManager(dataDB, config.CgrConfig().CacheCfg(), connMng)
+	data := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
+	dm := engine.NewDataManager(data, cfg.CacheCfg(), nil)
 	tpAct := TPActions{
 		dm: dm,
 	}
@@ -113,7 +104,7 @@ func TestTPEExportItemsActions(t *testing.T) {
 		},
 	}
 	tpAct.dm.SetActionProfile(context.Background(), act, false)
-	err = tpAct.exportItems(context.Background(), wrtr, "cgrates.org", []string{"SET_BAL"})
+	err := tpAct.exportItems(context.Background(), wrtr, "cgrates.org", []string{"SET_BAL"})
 	if err != nil {
 		t.Errorf("Expected nil\n but received %v", err)
 	}
@@ -122,23 +113,14 @@ func TestTPEExportItemsActions(t *testing.T) {
 func TestTPEExportItemsActionsEmpty(t *testing.T) {
 	wrtr := new(bytes.Buffer)
 	cfg := config.NewDefaultCGRConfig()
-	connMng := engine.NewConnManager(cfg)
-	dataDB, err := engine.NewDataDBConn(cfg.DataDbCfg().Type,
-		cfg.DataDbCfg().Host, cfg.DataDbCfg().Port,
-		cfg.DataDbCfg().Name, cfg.DataDbCfg().User,
-		cfg.DataDbCfg().Password, cfg.GeneralCfg().DBDataEncoding,
-		cfg.DataDbCfg().Opts, cfg.DataDbCfg().Items)
-	if err != nil {
-		t.Error(err)
-	}
-	defer dataDB.Close()
-	dm := engine.NewDataManager(dataDB, config.CgrConfig().CacheCfg(), connMng)
+	data := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
+	dm := engine.NewDataManager(data, cfg.CacheCfg(), nil)
 	tpAct := TPActions{
 		dm: dm,
 	}
 	act := &engine.ActionProfile{}
 	tpAct.dm.SetActionProfile(context.Background(), act, false)
-	err = tpAct.exportItems(context.Background(), wrtr, "cgrates.org", []string{})
+	err := tpAct.exportItems(context.Background(), wrtr, "cgrates.org", []string{})
 	if err != nil {
 		t.Errorf("Expected nil\n but received %v", err)
 	}
@@ -184,17 +166,8 @@ func TestTPEExportItemsActionsNoDbConn(t *testing.T) {
 func TestTPEExportItemsActionsIDNotFound(t *testing.T) {
 	wrtr := new(bytes.Buffer)
 	cfg := config.NewDefaultCGRConfig()
-	connMng := engine.NewConnManager(cfg)
-	dataDB, err := engine.NewDataDBConn(cfg.DataDbCfg().Type,
-		cfg.DataDbCfg().Host, cfg.DataDbCfg().Port,
-		cfg.DataDbCfg().Name, cfg.DataDbCfg().User,
-		cfg.DataDbCfg().Password, cfg.GeneralCfg().DBDataEncoding,
-		cfg.DataDbCfg().Opts, cfg.DataDbCfg().Items)
-	if err != nil {
-		t.Error(err)
-	}
-	defer dataDB.Close()
-	dm := engine.NewDataManager(dataDB, config.CgrConfig().CacheCfg(), connMng)
+	data := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
+	dm := engine.NewDataManager(data, cfg.CacheCfg(), nil)
 	tpAct := TPActions{
 		dm: dm,
 	}
@@ -223,7 +196,7 @@ func TestTPEExportItemsActionsIDNotFound(t *testing.T) {
 		},
 	}
 	tpAct.dm.SetActionProfile(context.Background(), act, false)
-	err = tpAct.exportItems(context.Background(), wrtr, "cgrates.org", []string{"UNSET_BAL"})
+	err := tpAct.exportItems(context.Background(), wrtr, "cgrates.org", []string{"UNSET_BAL"})
 	errExpect := "<NOT_FOUND> cannot find Actions id: <UNSET_BAL>"
 	if err.Error() != errExpect {
 		t.Errorf("Expected %v\n but received %v", errExpect, err)
--- a/tpes/tpe_attributes_test.go
+++ b/tpes/tpe_attributes_test.go
@@ -72,17 +72,8 @@ func TestTPEnewTPAttributes(t *testing.T) {
 func TestTPEExportItemsAttributes(t *testing.T) {
 	wrtr := new(bytes.Buffer)
 	cfg := config.NewDefaultCGRConfig()
-	connMng := engine.NewConnManager(cfg)
-	dataDB, err := engine.NewDataDBConn(cfg.DataDbCfg().Type,
-		cfg.DataDbCfg().Host, cfg.DataDbCfg().Port,
-		cfg.DataDbCfg().Name, cfg.DataDbCfg().User,
-		cfg.DataDbCfg().Password, cfg.GeneralCfg().DBDataEncoding,
-		cfg.DataDbCfg().Opts, cfg.DataDbCfg().Items)
-	if err != nil {
-		t.Error(err)
-	}
-	defer dataDB.Close()
-	dm := engine.NewDataManager(dataDB, config.CgrConfig().CacheCfg(), connMng)
+	data := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
+	dm := engine.NewDataManager(data, cfg.CacheCfg(), nil)
 	tpAttr := TPAttributes{
 		dm: dm,
 	}
@@ -109,7 +100,7 @@ func TestTPEExportItemsAttributes(t *testing.T) {
 		},
 	}
 	tpAttr.dm.SetAttributeProfile(context.Background(), attr, false)
-	err = tpAttr.exportItems(context.Background(), wrtr, "cgrates.org", []string{"TEST_ATTRIBUTES_TEST"})
+	err := tpAttr.exportItems(context.Background(), wrtr, "cgrates.org", []string{"TEST_ATTRIBUTES_TEST"})
 	if err != nil {
 		t.Errorf("Expected nil\n but received %v", err)
 	}
@@ -153,17 +144,8 @@ func TestTPEExportItemsAttributesNoDbConn(t *testing.T) {
 func TestTPEExportItemsAttributesIDNotFound(t *testing.T) {
 	wrtr := new(bytes.Buffer)
 	cfg := config.NewDefaultCGRConfig()
-	connMng := engine.NewConnManager(cfg)
-	dataDB, err := engine.NewDataDBConn(cfg.DataDbCfg().Type,
-		cfg.DataDbCfg().Host, cfg.DataDbCfg().Port,
-		cfg.DataDbCfg().Name, cfg.DataDbCfg().User,
-		cfg.DataDbCfg().Password, cfg.GeneralCfg().DBDataEncoding,
-		cfg.DataDbCfg().Opts, cfg.DataDbCfg().Items)
-	if err != nil {
-		t.Error(err)
-	}
-	defer dataDB.Close()
-	dm := engine.NewDataManager(dataDB, config.CgrConfig().CacheCfg(), connMng)
+	data := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
+	dm := engine.NewDataManager(data, cfg.CacheCfg(), nil)
 	tpAct := TPAttributes{
 		dm: dm,
 	}
@@ -190,7 +172,7 @@ func TestTPEExportItemsAttributesIDNotFound(t *testing.T) {
 		},
 	}
 	tpAct.dm.SetAttributeProfile(context.Background(), attr, false)
-	err = tpAct.exportItems(context.Background(), wrtr, "cgrates.org", []string{"TEST_ATTRIBUTES"})
+	err := tpAct.exportItems(context.Background(), wrtr, "cgrates.org", []string{"TEST_ATTRIBUTES"})
 	errExpect := "<NOT_FOUND> cannot find AttributeProfile with id: <TEST_ATTRIBUTES>"
 	if err.Error() != errExpect {
 		t.Errorf("Expected %v\n but received %v", errExpect, err)
--- a/tpes/tpe_chargers_test.go
+++ b/tpes/tpe_chargers_test.go
@@ -61,17 +61,8 @@ func TestTPEnewTPChargers(t *testing.T) {
 func TestTPEExportItemsChargers(t *testing.T) {
 	wrtr := new(bytes.Buffer)
 	cfg := config.NewDefaultCGRConfig()
-	connMng := engine.NewConnManager(cfg)
-	dataDB, err := engine.NewDataDBConn(cfg.DataDbCfg().Type,
-		cfg.DataDbCfg().Host, cfg.DataDbCfg().Port,
-		cfg.DataDbCfg().Name, cfg.DataDbCfg().User,
-		cfg.DataDbCfg().Password, cfg.GeneralCfg().DBDataEncoding,
-		cfg.DataDbCfg().Opts, cfg.DataDbCfg().Items)
-	if err != nil {
-		t.Error(err)
-	}
-	defer dataDB.Close()
-	dm := engine.NewDataManager(dataDB, config.CgrConfig().CacheCfg(), connMng)
+	data := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
+	dm := engine.NewDataManager(data, cfg.CacheCfg(), nil)
 	tpChgr := TPChargers{
 		dm: dm,
 	}
@@ -87,7 +78,7 @@ func TestTPEExportItemsChargers(t *testing.T) {
 		},
 	}
 	tpChgr.dm.SetChargerProfile(context.Background(), chgr, false)
-	err = tpChgr.exportItems(context.Background(), wrtr, "cgrates.org", []string{"Chargers1"})
+	err := tpChgr.exportItems(context.Background(), wrtr, "cgrates.org", []string{"Chargers1"})
 	if err != nil {
 		t.Errorf("Expected nil\n but received %v", err)
 	}
@@ -120,17 +111,8 @@ func TestTPEExportItemsChargersNoDbConn(t *testing.T) {
 func TestTPEExportItemsChargersIDNotFound(t *testing.T) {
 	wrtr := new(bytes.Buffer)
 	cfg := config.NewDefaultCGRConfig()
-	connMng := engine.NewConnManager(cfg)
-	dataDB, err := engine.NewDataDBConn(cfg.DataDbCfg().Type,
-		cfg.DataDbCfg().Host, cfg.DataDbCfg().Port,
-		cfg.DataDbCfg().Name, cfg.DataDbCfg().User,
-		cfg.DataDbCfg().Password, cfg.GeneralCfg().DBDataEncoding,
-		cfg.DataDbCfg().Opts, cfg.DataDbCfg().Items)
-	if err != nil {
-		t.Error(err)
-	}
-	defer dataDB.Close()
-	dm := engine.NewDataManager(dataDB, config.CgrConfig().CacheCfg(), connMng)
+	data := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
+	dm := engine.NewDataManager(data, cfg.CacheCfg(), nil)
 	tpChgr := TPChargers{
 		dm: dm,
 	}
@@ -146,7 +128,7 @@ func TestTPEExportItemsChargersIDNotFound(t *testing.T) {
 		},
 	}
 	tpChgr.dm.SetChargerProfile(context.Background(), chgr, false)
-	err = tpChgr.exportItems(context.Background(), wrtr, "cgrates.org", []string{"Chargers2"})
+	err := tpChgr.exportItems(context.Background(), wrtr, "cgrates.org", []string{"Chargers2"})
 	errExpect := "<NOT_FOUND> cannot find ChargerProfile with id: <Chargers2>"
 	if err.Error() != errExpect {
 		t.Errorf("Expected %v\n but received %v", errExpect, err)
--- a/tpes/tpe_dispatcher_hosts_test.go
+++ b/tpes/tpe_dispatcher_hosts_test.go
@@ -62,17 +62,8 @@ func TestTPEnewTPDispatchersHost(t *testing.T) {
 func TestTPEExportItemsDispatchersHost(t *testing.T) {
 	wrtr := new(bytes.Buffer)
 	cfg := config.NewDefaultCGRConfig()
-	connMng := engine.NewConnManager(cfg)
-	dataDB, err := engine.NewDataDBConn(cfg.DataDbCfg().Type,
-		cfg.DataDbCfg().Host, cfg.DataDbCfg().Port,
-		cfg.DataDbCfg().Name, cfg.DataDbCfg().User,
-		cfg.DataDbCfg().Password, cfg.GeneralCfg().DBDataEncoding,
-		cfg.DataDbCfg().Opts, cfg.DataDbCfg().Items)
-	if err != nil {
-		t.Error(err)
-	}
-	defer dataDB.Close()
-	dm := engine.NewDataManager(dataDB, config.CgrConfig().CacheCfg(), connMng)
+	data := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
+	dm := engine.NewDataManager(data, cfg.CacheCfg(), nil)
 	tpDsph := TPDispatcherHosts{
 		dm: dm,
 	}
@@ -88,7 +79,7 @@ func TestTPEExportItemsDispatchersHost(t *testing.T) {
 		},
 	}
 	tpDsph.dm.SetDispatcherHost(context.Background(), dsph)
-	err = tpDsph.exportItems(context.Background(), wrtr, "cgrates.org", []string{"DSH1"})
+	err := tpDsph.exportItems(context.Background(), wrtr, "cgrates.org", []string{"DSH1"})
 	if err != nil {
 		t.Errorf("Expected nil\n but received %v", err)
 	}
@@ -121,17 +112,8 @@ func TestTPEExportItemsDispatcherHostsNoDbConn(t *testing.T) {
 func TestTPEExportItemsDispatchersIDNotFoundHost(t *testing.T) {
 	wrtr := new(bytes.Buffer)
 	cfg := config.NewDefaultCGRConfig()
-	connMng := engine.NewConnManager(cfg)
-	dataDB, err := engine.NewDataDBConn(cfg.DataDbCfg().Type,
-		cfg.DataDbCfg().Host, cfg.DataDbCfg().Port,
-		cfg.DataDbCfg().Name, cfg.DataDbCfg().User,
-		cfg.DataDbCfg().Password, cfg.GeneralCfg().DBDataEncoding,
-		cfg.DataDbCfg().Opts, cfg.DataDbCfg().Items)
-	if err != nil {
-		t.Error(err)
-	}
-	defer dataDB.Close()
-	dm := engine.NewDataManager(dataDB, config.CgrConfig().CacheCfg(), connMng)
+	data := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
+	dm := engine.NewDataManager(data, cfg.CacheCfg(), nil)
 	tpDsph := TPDispatcherHosts{
 		dm: dm,
 	}
@@ -147,7 +129,7 @@ func TestTPEExportItemsDispatchersIDNotFoundHost(t *testing.T) {
 		},
 	}
 	tpDsph.dm.SetDispatcherHost(context.Background(), dsph)
-	err = tpDsph.exportItems(context.Background(), wrtr, "cgrates.org", []string{"DSH2"})
+	err := tpDsph.exportItems(context.Background(), wrtr, "cgrates.org", []string{"DSH2"})
 	errExpect := "<NOT_FOUND> cannot find DispatcherHost with id: <DSH2>"
 	if err.Error() != errExpect {
 		t.Errorf("Expected %v\n but received %v", errExpect, err)
--- a/tpes/tpe_dispatchers_test.go
+++ b/tpes/tpe_dispatchers_test.go
@@ -69,17 +69,8 @@ func TestTPEnewTPDispatchers(t *testing.T) {
 func TestTPEExportItemsDispatchers(t *testing.T) {
 	wrtr := new(bytes.Buffer)
 	cfg := config.NewDefaultCGRConfig()
-	connMng := engine.NewConnManager(cfg)
-	dataDB, err := engine.NewDataDBConn(cfg.DataDbCfg().Type,
-		cfg.DataDbCfg().Host, cfg.DataDbCfg().Port,
-		cfg.DataDbCfg().Name, cfg.DataDbCfg().User,
-		cfg.DataDbCfg().Password, cfg.GeneralCfg().DBDataEncoding,
-		cfg.DataDbCfg().Opts, cfg.DataDbCfg().Items)
-	if err != nil {
-		t.Error(err)
-	}
-	defer dataDB.Close()
-	dm := engine.NewDataManager(dataDB, config.CgrConfig().CacheCfg(), connMng)
+	data := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
+	dm := engine.NewDataManager(data, cfg.CacheCfg(), nil)
 	tpDsp := TPDispatchers{
 		dm: dm,
 	}
@@ -103,7 +94,7 @@ func TestTPEExportItemsDispatchers(t *testing.T) {
 		},
 	}
 	tpDsp.dm.SetDispatcherProfile(context.Background(), dsp, false)
-	err = tpDsp.exportItems(context.Background(), wrtr, "cgrates.org", []string{"Dsp1"})
+	err := tpDsp.exportItems(context.Background(), wrtr, "cgrates.org", []string{"Dsp1"})
 	if err != nil {
 		t.Errorf("Expected nil\n but received %v", err)
 	}
@@ -144,17 +135,8 @@ func TestTPEExportItemsDispatchersNoDbConn(t *testing.T) {
 func TestTPEExportItemsDispatchersIDNotFound(t *testing.T) {
 	wrtr := new(bytes.Buffer)
 	cfg := config.NewDefaultCGRConfig()
-	connMng := engine.NewConnManager(cfg)
-	dataDB, err := engine.NewDataDBConn(cfg.DataDbCfg().Type,
-		cfg.DataDbCfg().Host, cfg.DataDbCfg().Port,
-		cfg.DataDbCfg().Name, cfg.DataDbCfg().User,
-		cfg.DataDbCfg().Password, cfg.GeneralCfg().DBDataEncoding,
-		cfg.DataDbCfg().Opts, cfg.DataDbCfg().Items)
-	if err != nil {
-		t.Error(err)
-	}
-	defer dataDB.Close()
-	dm := engine.NewDataManager(dataDB, config.CgrConfig().CacheCfg(), connMng)
+	data := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
+	dm := engine.NewDataManager(data, cfg.CacheCfg(), nil)
 	tpDsp := TPDispatchers{
 		dm: dm,
 	}
@@ -178,7 +160,7 @@ func TestTPEExportItemsDispatchersIDNotFound(t *testing.T) {
 		},
 	}
 	tpDsp.dm.SetDispatcherProfile(context.Background(), dsp, false)
-	err = tpDsp.exportItems(context.Background(), wrtr, "cgrates.org", []string{"Dsp2"})
+	err := tpDsp.exportItems(context.Background(), wrtr, "cgrates.org", []string{"Dsp2"})
 	errExpect := "<NOT_FOUND> cannot find DispatcherProfile with id: <Dsp2>"
 	if err.Error() != errExpect {
 		t.Errorf("Expected %v\n but received %v", errExpect, err)
--- a/tpes/tpe_filters_test.go
+++ b/tpes/tpe_filters_test.go
@@ -75,17 +75,8 @@ func TestTPEnewTPFilters(t *testing.T) {
 func TestTPEExportItemsFilters(t *testing.T) {
 	wrtr := new(bytes.Buffer)
 	cfg := config.NewDefaultCGRConfig()
-	connMng := engine.NewConnManager(cfg)
-	dataDB, err := engine.NewDataDBConn(cfg.DataDbCfg().Type,
-		cfg.DataDbCfg().Host, cfg.DataDbCfg().Port,
-		cfg.DataDbCfg().Name, cfg.DataDbCfg().User,
-		cfg.DataDbCfg().Password, cfg.GeneralCfg().DBDataEncoding,
-		cfg.DataDbCfg().Opts, cfg.DataDbCfg().Items)
-	if err != nil {
-		t.Error(err)
-	}
-	defer dataDB.Close()
-	dm := engine.NewDataManager(dataDB, config.CgrConfig().CacheCfg(), connMng)
+	data := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
+	dm := engine.NewDataManager(data, cfg.CacheCfg(), nil)
 	tpFltr := TPFilters{
 		dm: dm,
 	}
@@ -115,7 +106,7 @@ func TestTPEExportItemsFilters(t *testing.T) {
 		},
 	}
 	tpFltr.dm.SetFilter(context.Background(), fltr, false)
-	err = tpFltr.exportItems(context.Background(), wrtr, "cgrates.org", []string{"fltr_for_prf"})
+	err := tpFltr.exportItems(context.Background(), wrtr, "cgrates.org", []string{"fltr_for_prf"})
 	if err != nil {
 		t.Errorf("Expected nil\n but received %v", err)
 	}
@@ -162,17 +153,8 @@ func TestTPEExportItemsFiltersNoDbConn(t *testing.T) {
 func TestTPEExportItemsFiltersIDNotFound(t *testing.T) {
 	wrtr := new(bytes.Buffer)
 	cfg := config.NewDefaultCGRConfig()
-	connMng := engine.NewConnManager(cfg)
-	dataDB, err := engine.NewDataDBConn(cfg.DataDbCfg().Type,
-		cfg.DataDbCfg().Host, cfg.DataDbCfg().Port,
-		cfg.DataDbCfg().Name, cfg.DataDbCfg().User,
-		cfg.DataDbCfg().Password, cfg.GeneralCfg().DBDataEncoding,
-		cfg.DataDbCfg().Opts, cfg.DataDbCfg().Items)
-	if err != nil {
-		t.Error(err)
-	}
-	defer dataDB.Close()
-	dm := engine.NewDataManager(dataDB, config.CgrConfig().CacheCfg(), connMng)
+	data := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
+	dm := engine.NewDataManager(data, cfg.CacheCfg(), nil)
 	tpFltr := TPFilters{
 		dm: dm,
 	}
@@ -202,7 +184,7 @@ func TestTPEExportItemsFiltersIDNotFound(t *testing.T) {
 		},
 	}
 	tpFltr.dm.SetFilter(context.Background(), fltr, false)
-	err = tpFltr.exportItems(context.Background(), wrtr, "cgrates.org", []string{"fltr_not_for_prf"})
+	err := tpFltr.exportItems(context.Background(), wrtr, "cgrates.org", []string{"fltr_not_for_prf"})
 	errExpect := "<NOT_FOUND> cannot find Filters with id: <fltr_not_for_prf>"
 	if err.Error() != errExpect {
 		t.Errorf("Expected %v\n but received %v", errExpect, err)
--- a/tpes/tpe_rates_test.go
+++ b/tpes/tpe_rates_test.go
@@ -77,17 +77,8 @@ func TestTPEnewTPRates(t *testing.T) {
 func TestTPEExportItemsRates(t *testing.T) {
 	wrtr := new(bytes.Buffer)
 	cfg := config.NewDefaultCGRConfig()
-	connMng := engine.NewConnManager(cfg)
-	dataDB, err := engine.NewDataDBConn(cfg.DataDbCfg().Type,
-		cfg.DataDbCfg().Host, cfg.DataDbCfg().Port,
-		cfg.DataDbCfg().Name, cfg.DataDbCfg().User,
-		cfg.DataDbCfg().Password, cfg.GeneralCfg().DBDataEncoding,
-		cfg.DataDbCfg().Opts, cfg.DataDbCfg().Items)
-	if err != nil {
-		t.Error(err)
-	}
-	defer dataDB.Close()
-	dm := engine.NewDataManager(dataDB, config.CgrConfig().CacheCfg(), connMng)
+	data := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
+	dm := engine.NewDataManager(data, cfg.CacheCfg(), nil)
 	tpRt := TPRates{
 		dm: dm,
 	}
@@ -119,7 +110,7 @@ func TestTPEExportItemsRates(t *testing.T) {
 		},
 	}
 	tpRt.dm.SetRateProfile(context.Background(), rt, false, false)
-	err = tpRt.exportItems(context.Background(), wrtr, "cgrates.org", []string{"TEST_RATE_TEST"})
+	err := tpRt.exportItems(context.Background(), wrtr, "cgrates.org", []string{"TEST_RATE_TEST"})
 	if err != nil {
 		t.Errorf("Expected nil\n but received %v", err)
 	}
@@ -168,17 +159,8 @@ func TestTPEExportItemsRatesNoDbConn(t *testing.T) {
 func TestTPEExportItemsRatesIDNotFound(t *testing.T) {
 	wrtr := new(bytes.Buffer)
 	cfg := config.NewDefaultCGRConfig()
-	connMng := engine.NewConnManager(cfg)
-	dataDB, err := engine.NewDataDBConn(cfg.DataDbCfg().Type,
-		cfg.DataDbCfg().Host, cfg.DataDbCfg().Port,
-		cfg.DataDbCfg().Name, cfg.DataDbCfg().User,
-		cfg.DataDbCfg().Password, cfg.GeneralCfg().DBDataEncoding,
-		cfg.DataDbCfg().Opts, cfg.DataDbCfg().Items)
-	if err != nil {
-		t.Error(err)
-	}
-	defer dataDB.Close()
-	dm := engine.NewDataManager(dataDB, config.CgrConfig().CacheCfg(), connMng)
+	data := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
+	dm := engine.NewDataManager(data, cfg.CacheCfg(), nil)
 	tpRt := TPRates{
 		dm: dm,
 	}
@@ -210,7 +192,7 @@ func TestTPEExportItemsRatesIDNotFound(t *testing.T) {
 		},
 	}
 	tpRt.dm.SetRateProfileRates(context.Background(), rt, false)
-	err = tpRt.exportItems(context.Background(), wrtr, "cgrates.org", []string{"TEST_RATE"})
+	err := tpRt.exportItems(context.Background(), wrtr, "cgrates.org", []string{"TEST_RATE"})
 	errExpect := "<NOT_FOUND> cannot find RateProfile with id: <TEST_RATE>"
 	if err.Error() != errExpect {
 		t.Errorf("Expected %v\n but received %v", errExpect, err)
--- a/tpes/tpe_resources_test.go
+++ b/tpes/tpe_resources_test.go
@@ -62,17 +62,8 @@ func TestTPEnewTPResources(t *testing.T) {
 func TestTPEExportItemsResources(t *testing.T) {
 	wrtr := new(bytes.Buffer)
 	cfg := config.NewDefaultCGRConfig()
-	connMng := engine.NewConnManager(cfg)
-	dataDB, err := engine.NewDataDBConn(cfg.DataDbCfg().Type,
-		cfg.DataDbCfg().Host, cfg.DataDbCfg().Port,
-		cfg.DataDbCfg().Name, cfg.DataDbCfg().User,
-		cfg.DataDbCfg().Password, cfg.GeneralCfg().DBDataEncoding,
-		cfg.DataDbCfg().Opts, cfg.DataDbCfg().Items)
-	if err != nil {
-		t.Error(err)
-	}
-	defer dataDB.Close()
-	dm := engine.NewDataManager(dataDB, config.CgrConfig().CacheCfg(), connMng)
+	data := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
+	dm := engine.NewDataManager(data, cfg.CacheCfg(), nil)
 	tpRsc := TPResources{
 		dm: dm,
 	}
@@ -89,7 +80,7 @@ func TestTPEExportItemsResources(t *testing.T) {
 		ThresholdIDs: []string{utils.MetaNone},
 	}
 	tpRsc.dm.SetResourceProfile(context.Background(), rsc, false)
-	err = tpRsc.exportItems(context.Background(), wrtr, "cgrates.org", []string{"ResGroup1"})
+	err := tpRsc.exportItems(context.Background(), wrtr, "cgrates.org", []string{"ResGroup1"})
 	if err != nil {
 		t.Errorf("Expected nil\n but received %v", err)
 	}
@@ -123,17 +114,8 @@ func TestTPEExportItemsResourcesNoDbConn(t *testing.T) {
 func TestTPEExportItemsResourcesIDNotFound(t *testing.T) {
 	wrtr := new(bytes.Buffer)
 	cfg := config.NewDefaultCGRConfig()
-	connMng := engine.NewConnManager(cfg)
-	dataDB, err := engine.NewDataDBConn(cfg.DataDbCfg().Type,
-		cfg.DataDbCfg().Host, cfg.DataDbCfg().Port,
-		cfg.DataDbCfg().Name, cfg.DataDbCfg().User,
-		cfg.DataDbCfg().Password, cfg.GeneralCfg().DBDataEncoding,
-		cfg.DataDbCfg().Opts, cfg.DataDbCfg().Items)
-	if err != nil {
-		t.Error(err)
-	}
-	defer dataDB.Close()
-	dm := engine.NewDataManager(dataDB, config.CgrConfig().CacheCfg(), connMng)
+	data := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
+	dm := engine.NewDataManager(data, cfg.CacheCfg(), nil)
 	tpRsc := TPResources{
 		dm: dm,
 	}
@@ -150,7 +132,7 @@ func TestTPEExportItemsResourcesIDNotFound(t *testing.T) {
 		ThresholdIDs: []string{utils.MetaNone},
 	}
 	tpRsc.dm.SetResourceProfile(context.Background(), rsc, false)
-	err = tpRsc.exportItems(context.Background(), wrtr, "cgrates.org", []string{"ResGroup2"})
+	err := tpRsc.exportItems(context.Background(), wrtr, "cgrates.org", []string{"ResGroup2"})
 	errExpect := "<NOT_FOUND> cannot find ResourceProfile with id: <ResGroup2>"
 	if err.Error() != errExpect {
 		t.Errorf("Expected %v\n but received %v", errExpect, err)
--- a/tpes/tpe_routes_test.go
+++ b/tpes/tpe_routes_test.go
@@ -71,17 +71,8 @@ func TestTPEnewTPRoutes(t *testing.T) {
 func TestTPEExportRoutes(t *testing.T) {
 	wrtr := new(bytes.Buffer)
 	cfg := config.NewDefaultCGRConfig()
-	connMng := engine.NewConnManager(cfg)
-	dataDB, err := engine.NewDataDBConn(cfg.DataDbCfg().Type,
-		cfg.DataDbCfg().Host, cfg.DataDbCfg().Port,
-		cfg.DataDbCfg().Name, cfg.DataDbCfg().User,
-		cfg.DataDbCfg().Password, cfg.GeneralCfg().DBDataEncoding,
-		cfg.DataDbCfg().Opts, cfg.DataDbCfg().Items)
-	if err != nil {
-		t.Error(err)
-	}
-	defer dataDB.Close()
-	dm := engine.NewDataManager(dataDB, config.CgrConfig().CacheCfg(), connMng)
+	data := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
+	dm := engine.NewDataManager(data, cfg.CacheCfg(), nil)
 	tpRte := TPRoutes{
 		dm: dm,
 	}
@@ -107,7 +98,7 @@ func TestTPEExportRoutes(t *testing.T) {
 		},
 	}
 	tpRte.dm.SetRouteProfile(context.Background(), rte, false)
-	err = tpRte.exportItems(context.Background(), wrtr, "cgrates.org", []string{"ROUTE_2003"})
+	err := tpRte.exportItems(context.Background(), wrtr, "cgrates.org", []string{"ROUTE_2003"})
 	if err != nil {
 		t.Errorf("Expected nil\n but received %v", err)
 	}
@@ -150,17 +141,8 @@ func TestTPEExportItemsRoutesNoDbConn(t *testing.T) {
 func TestTPEExportItemsRoutesIDNotFound(t *testing.T) {
 	wrtr := new(bytes.Buffer)
 	cfg := config.NewDefaultCGRConfig()
-	connMng := engine.NewConnManager(cfg)
-	dataDB, err := engine.NewDataDBConn(cfg.DataDbCfg().Type,
-		cfg.DataDbCfg().Host, cfg.DataDbCfg().Port,
-		cfg.DataDbCfg().Name, cfg.DataDbCfg().User,
-		cfg.DataDbCfg().Password, cfg.GeneralCfg().DBDataEncoding,
-		cfg.DataDbCfg().Opts, cfg.DataDbCfg().Items)
-	if err != nil {
-		t.Error(err)
-	}
-	defer dataDB.Close()
-	dm := engine.NewDataManager(dataDB, config.CgrConfig().CacheCfg(), connMng)
+	data := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
+	dm := engine.NewDataManager(data, cfg.CacheCfg(), nil)
 	tpRte := TPRoutes{
 		dm: dm,
 	}
@@ -186,7 +168,7 @@ func TestTPEExportItemsRoutesIDNotFound(t *testing.T) {
 		},
 	}
 	tpRte.dm.SetRouteProfile(context.Background(), rte, false)
-	err = tpRte.exportItems(context.Background(), wrtr, "cgrates.org", []string{"ROUTE_2004"})
+	err := tpRte.exportItems(context.Background(), wrtr, "cgrates.org", []string{"ROUTE_2004"})
 	errExpect := "<NOT_FOUND> cannot find RouteProfile with id: <ROUTE_2004>"
 	if err.Error() != errExpect {
 		t.Errorf("Expected %v\n but received %v", errExpect, err)
--- a/tpes/tpe_stats_test.go
+++ b/tpes/tpe_stats_test.go
@@ -78,17 +78,8 @@ func TestTPEnewTPStats(t *testing.T) {
 func TestTPEExportStats(t *testing.T) {
 	wrtr := new(bytes.Buffer)
 	cfg := config.NewDefaultCGRConfig()
-	connMng := engine.NewConnManager(cfg)
-	dataDB, err := engine.NewDataDBConn(cfg.DataDbCfg().Type,
-		cfg.DataDbCfg().Host, cfg.DataDbCfg().Port,
-		cfg.DataDbCfg().Name, cfg.DataDbCfg().User,
-		cfg.DataDbCfg().Password, cfg.GeneralCfg().DBDataEncoding,
-		cfg.DataDbCfg().Opts, cfg.DataDbCfg().Items)
-	if err != nil {
-		t.Error(err)
-	}
-	defer dataDB.Close()
-	dm := engine.NewDataManager(dataDB, config.CgrConfig().CacheCfg(), connMng)
+	data := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
+	dm := engine.NewDataManager(data, cfg.CacheCfg(), nil)
 	tpStq := TPStats{
 		dm: dm,
 	}
@@ -121,7 +112,7 @@ func TestTPEExportStats(t *testing.T) {
 		ThresholdIDs: []string{utils.MetaNone},
 	}
 	tpStq.dm.SetStatQueueProfile(context.Background(), stq, false)
-	err = tpStq.exportItems(context.Background(), wrtr, "cgrates.org", []string{"SQ_2"})
+	err := tpStq.exportItems(context.Background(), wrtr, "cgrates.org", []string{"SQ_2"})
 	if err != nil {
 		t.Errorf("Expected nil\n but received %v", err)
 	}
@@ -171,17 +162,8 @@ func TestTPEExportItemsStatsNoDbConn(t *testing.T) {
 func TestTPEExportItemsStatsIDNotFound(t *testing.T) {
 	wrtr := new(bytes.Buffer)
 	cfg := config.NewDefaultCGRConfig()
-	connMng := engine.NewConnManager(cfg)
-	dataDB, err := engine.NewDataDBConn(cfg.DataDbCfg().Type,
-		cfg.DataDbCfg().Host, cfg.DataDbCfg().Port,
-		cfg.DataDbCfg().Name, cfg.DataDbCfg().User,
-		cfg.DataDbCfg().Password, cfg.GeneralCfg().DBDataEncoding,
-		cfg.DataDbCfg().Opts, cfg.DataDbCfg().Items)
-	if err != nil {
-		t.Error(err)
-	}
-	defer dataDB.Close()
-	dm := engine.NewDataManager(dataDB, config.CgrConfig().CacheCfg(), connMng)
+	data := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
+	dm := engine.NewDataManager(data, cfg.CacheCfg(), nil)
 	tpStq := TPStats{
 		dm: dm,
 	}
@@ -214,7 +196,7 @@ func TestTPEExportItemsStatsIDNotFound(t *testing.T) {
 		ThresholdIDs: []string{utils.MetaNone},
 	}
 	tpStq.dm.SetStatQueueProfile(context.Background(), stq, false)
-	err = tpStq.exportItems(context.Background(), wrtr, "cgrates.org", []string{"SQ_3"})
+	err := tpStq.exportItems(context.Background(), wrtr, "cgrates.org", []string{"SQ_3"})
 	errExpect := "<NOT_FOUND> cannot find StatQueueProfile with id: <SQ_3>"
 	if err.Error() != errExpect {
 		t.Errorf("Expected %v\n but received %v", errExpect, err)
--- a/tpes/tpe_thresholds_test.go
+++ b/tpes/tpe_thresholds_test.go
@@ -64,17 +64,8 @@ func TestTPEnewTPThresholds(t *testing.T) {
 func TestTPEExportThresholds(t *testing.T) {
 	wrtr := new(bytes.Buffer)
 	cfg := config.NewDefaultCGRConfig()
-	connMng := engine.NewConnManager(cfg)
-	dataDB, err := engine.NewDataDBConn(cfg.DataDbCfg().Type,
-		cfg.DataDbCfg().Host, cfg.DataDbCfg().Port,
-		cfg.DataDbCfg().Name, cfg.DataDbCfg().User,
-		cfg.DataDbCfg().Password, cfg.GeneralCfg().DBDataEncoding,
-		cfg.DataDbCfg().Opts, cfg.DataDbCfg().Items)
-	if err != nil {
-		t.Error(err)
-	}
-	defer dataDB.Close()
-	dm := engine.NewDataManager(dataDB, config.CgrConfig().CacheCfg(), connMng)
+	data := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
+	dm := engine.NewDataManager(data, cfg.CacheCfg(), nil)
 	tpThd := TPThresholds{
 		dm: dm,
 	}
@@ -93,7 +84,7 @@ func TestTPEExportThresholds(t *testing.T) {
 		Async: true,
 	}
 	tpThd.dm.SetThresholdProfile(context.Background(), thd, false)
-	err = tpThd.exportItems(context.Background(), wrtr, "cgrates.org", []string{"THD_2"})
+	err := tpThd.exportItems(context.Background(), wrtr, "cgrates.org", []string{"THD_2"})
 	if err != nil {
 		t.Errorf("Expected nil\n but received %v", err)
 	}
@@ -129,17 +120,8 @@ func TestTPEExportItemsThresholdsNoDbConn(t *testing.T) {
 func TestTPEExportItemsThresholdsIDNotFound(t *testing.T) {
 	wrtr := new(bytes.Buffer)
 	cfg := config.NewDefaultCGRConfig()
-	connMng := engine.NewConnManager(cfg)
-	dataDB, err := engine.NewDataDBConn(cfg.DataDbCfg().Type,
-		cfg.DataDbCfg().Host, cfg.DataDbCfg().Port,
-		cfg.DataDbCfg().Name, cfg.DataDbCfg().User,
-		cfg.DataDbCfg().Password, cfg.GeneralCfg().DBDataEncoding,
-		cfg.DataDbCfg().Opts, cfg.DataDbCfg().Items)
-	if err != nil {
-		t.Error(err)
-	}
-	defer dataDB.Close()
-	dm := engine.NewDataManager(dataDB, config.CgrConfig().CacheCfg(), connMng)
+	data := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
+	dm := engine.NewDataManager(data, cfg.CacheCfg(), nil)
 	tpThd := TPThresholds{
 		dm: dm,
 	}
@@ -158,7 +140,7 @@ func TestTPEExportItemsThresholdsIDNotFound(t *testing.T) {
 		Async: true,
 	}
 	tpThd.dm.SetThresholdProfile(context.Background(), thd, false)
-	err = tpThd.exportItems(context.Background(), wrtr, "cgrates.org", []string{"THD_3"})
+	err := tpThd.exportItems(context.Background(), wrtr, "cgrates.org", []string{"THD_3"})
 	errExpect := "<NOT_FOUND> cannot find ThresholdProfile with id: <THD_3>"
 	if err.Error() != errExpect {
 		t.Errorf("Expected %v\n but received %v", errExpect, err)
--- a/tpes/tpes_test.go
+++ b/tpes/tpes_test.go
@@ -21,6 +21,7 @@ package tpes
 import (
 	"reflect"
 	"testing"
+	"time"

 	"github.com/cgrates/birpc/context"
 	"github.com/cgrates/cgrates/config"
@@ -31,16 +32,8 @@ import (
 func TestNewTPeS(t *testing.T) {
 	cfg := config.NewDefaultCGRConfig()
 	connMng := engine.NewConnManager(cfg)
-	dataDB, err := engine.NewDataDBConn(cfg.DataDbCfg().Type,
-		cfg.DataDbCfg().Host, cfg.DataDbCfg().Port,
-		cfg.DataDbCfg().Name, cfg.DataDbCfg().User,
-		cfg.DataDbCfg().Password, cfg.GeneralCfg().DBDataEncoding,
-		cfg.DataDbCfg().Opts, cfg.DataDbCfg().Items)
-	if err != nil {
-		t.Error(err)
-	}
-	defer dataDB.Close()
-	dm := engine.NewDataManager(dataDB, config.CgrConfig().CacheCfg(), connMng)
+	data := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
+	dm := engine.NewDataManager(data, cfg.CacheCfg(), nil)
 	tpExporterTypes.Add("not_valid")
 	// utils.Logger, err = utils.NewLogger(utils.MetaStdLog, utils.EmptyString, 6)
 	// if err != nil {
@@ -59,19 +52,33 @@ func TestNewTPeS(t *testing.T) {

 func TestGetTariffPlansKeys(t *testing.T) {
 	cfg := config.NewDefaultCGRConfig()
-	connMng := engine.NewConnManager(cfg)
-	dataDB, err := engine.NewDataDBConn(cfg.DataDbCfg().Type,
-		cfg.DataDbCfg().Host, cfg.DataDbCfg().Port,
-		cfg.DataDbCfg().Name, cfg.DataDbCfg().User,
-		cfg.DataDbCfg().Password, cfg.GeneralCfg().DBDataEncoding,
-		cfg.DataDbCfg().Opts, cfg.DataDbCfg().Items)
-	if err != nil {
-		t.Error(err)
-	}
-	defer dataDB.Close()
-	dm := engine.NewDataManager(dataDB, config.CgrConfig().CacheCfg(), connMng)
+	data := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
+	dm := engine.NewDataManager(data, cfg.CacheCfg(), nil)

 	//Attributes
+	attr := &engine.AttributeProfile{
+		Tenant:    utils.CGRateSorg,
+		ID:        "TEST_ATTRIBUTES_TEST",
+		FilterIDs: []string{"*string:~*req.Account:1002", "*exists:~*opts.*usage:"},
+		Attributes: []*engine.Attribute{
+			{
+				Path:  utils.AccountField,
+				Type:  utils.MetaConstant,
+				Value: nil,
+			},
+			{
+				Path:  "*tenant",
+				Type:  utils.MetaConstant,
+				Value: nil,
+			},
+		},
+		Weights: utils.DynamicWeights{
+			{
+				Weight: 20,
+			},
+		},
+	}
+	dm.SetAttributeProfile(context.Background(), attr, false)
 	rcv, _ := getTariffPlansKeys(context.Background(), dm, "cgrates.org", utils.MetaAttributes)
 	exp := []string{"TEST_ATTRIBUTES_TEST"}
 	if !reflect.DeepEqual(rcv, exp) {
@@ -79,6 +86,31 @@ func TestGetTariffPlansKeys(t *testing.T) {
 	}

 	//Actions
+	act := &engine.ActionProfile{
+		Tenant: "cgrates.org",
+		ID:     "SET_BAL",
+		FilterIDs: []string{
+			"*string:~*req.Account:1001"},
+		Weights: utils.DynamicWeights{
+			{
+				Weight: 10,
+			},
+		},
+		Targets:  map[string]utils.StringSet{utils.MetaAccounts: {"1001": {}}},
+		Schedule: utils.MetaASAP,
+		Actions: []*engine.APAction{
+			{
+				ID:   "SET_BAL",
+				Type: utils.MetaSetBalance,
+				Diktats: []*engine.APDiktat{
+					{
+						Path:  "MONETARY",
+						Value: "10",
+					}},
+			},
+		},
+	}
+	dm.SetActionProfile(context.Background(), act, false)
 	rcv, _ = getTariffPlansKeys(context.Background(), dm, "cgrates.org", utils.MetaActions)
 	exp = []string{"SET_BAL"}
 	if !reflect.DeepEqual(rcv, exp) {
@@ -86,13 +118,52 @@ func TestGetTariffPlansKeys(t *testing.T) {
 	}

 	//Accounts
+	acc := &utils.Account{
+		Tenant: "cgrates.org",
+		ID:     "Account_simple",
+		Opts:   map[string]interface{}{},
+		Balances: map[string]*utils.Balance{
+			"VoiceBalance": {
+				ID:        "VoiceBalance",
+				FilterIDs: []string{"*string:~*req.Account:1001"},
+				Weights: utils.DynamicWeights{
+					{
+						Weight: 12,
+					},
+				},
+				Type: "*abstract",
+				Opts: map[string]interface{}{
+					"Destination": "10",
+				},
+				Units: utils.NewDecimal(0, 0),
+			},
+		},
+		Weights: utils.DynamicWeights{
+			{
+				Weight: 10,
+			},
+		},
+	}
+	dm.SetAccount(context.Background(), acc, false)
 	rcv, _ = getTariffPlansKeys(context.Background(), dm, "cgrates.org", utils.MetaAccounts)
-	exp = []string{"Account_simple", "Account_complicated"}
+	exp = []string{"Account_simple"}
 	if !reflect.DeepEqual(rcv, exp) {
 		t.Errorf("Expected %v\n but received %v", exp, rcv)
 	}

 	//Chargers
+	chgr := &engine.ChargerProfile{
+		Tenant:       "cgrates.org",
+		ID:           "Chargers1",
+		RunID:        utils.MetaDefault,
+		AttributeIDs: []string{"*none"},
+		Weights: utils.DynamicWeights{
+			{
+				Weight: 20,
+			},
+		},
+	}
+	dm.SetChargerProfile(context.Background(), chgr, false)
 	rcv, _ = getTariffPlansKeys(context.Background(), dm, "cgrates.org", utils.MetaChargers)
 	exp = []string{"Chargers1"}
 	if !reflect.DeepEqual(rcv, exp) {
@@ -100,6 +171,32 @@ func TestGetTariffPlansKeys(t *testing.T) {
 	}

 	//Filters
+	fltr := &engine.Filter{
+		Tenant: utils.CGRateSorg,
+		ID:     "fltr_for_prf",
+		Rules: []*engine.FilterRule{
+			{
+				Type:    utils.MetaString,
+				Element: "~*req.Subject",
+				Values:  []string{"1004", "6774", "22312"},
+			},
+			{
+				Type:    utils.MetaString,
+				Element: "~*opts.Subsystems",
+				Values:  []string{"*attributes"},
+			},
+			{
+				Type:    utils.MetaPrefix,
+				Element: "~*req.Destinations",
+				Values:  []string{"+0775", "+442"},
+			},
+			{
+				Type:    utils.MetaExists,
+				Element: "~*req.NumberOfEvents",
+			},
+		},
+	}
+	dm.SetFilter(context.Background(), fltr, false)
 	rcv, _ = getTariffPlansKeys(context.Background(), dm, "cgrates.org", utils.MetaFilters)
 	exp = []string{"fltr_for_prf"}
 	if !reflect.DeepEqual(rcv, exp) {
@@ -107,13 +204,54 @@ func TestGetTariffPlansKeys(t *testing.T) {
 	}

 	//Rates
+	rt := &utils.RateProfile{
+		Tenant:    utils.CGRateSorg,
+		ID:        "TEST_RATE_TEST",
+		FilterIDs: []string{"*string:~*req.Account:dan"},
+		Weights: utils.DynamicWeights{
+			{
+				Weight: 10,
+			},
+		},
+		MaxCostStrategy: "*free",
+		Rates: map[string]*utils.Rate{
+			"RT_WEEK": {
+				ID: "RT_WEEK",
+				Weights: utils.DynamicWeights{
+					{
+						Weight: 0,
+					},
+				},
+				ActivationTimes: "* * * * 1-5",
+				IntervalRates: []*utils.IntervalRate{
+					{
+						IntervalStart: utils.NewDecimal(0, 0),
+					},
+				},
+			},
+		},
+	}
+	dm.SetRateProfileRates(context.Background(), rt, false)
 	rcv, _ = getTariffPlansKeys(context.Background(), dm, "cgrates.org", utils.MetaRateS)
-	exp = []string{"TEST_RATE_TEST"}
+	exp = []string{}
 	if !reflect.DeepEqual(rcv, exp) {
 		t.Errorf("Expected %v\n but received %v", exp, rcv)
 	}

 	//Resources
+	rsc := &engine.ResourceProfile{
+		Tenant:            "cgrates.org",
+		ID:                "ResGroup1",
+		FilterIDs:         []string{"*string:~*req.Account:1001"},
+		Limit:             10,
+		AllocationMessage: "Approved",
+		Weights: utils.DynamicWeights{
+			{
+				Weight: 20,
+			}},
+		ThresholdIDs: []string{utils.MetaNone},
+	}
+	dm.SetResourceProfile(context.Background(), rsc, false)
 	rcv, _ = getTariffPlansKeys(context.Background(), dm, "cgrates.org", utils.MetaResources)
 	exp = []string{"ResGroup1"}
 	if !reflect.DeepEqual(rcv, exp) {
@@ -121,6 +259,28 @@ func TestGetTariffPlansKeys(t *testing.T) {
 	}

 	//Routes
+	rte := &engine.RouteProfile{
+		ID:     "ROUTE_2003",
+		Tenant: "cgrates.org",
+		Weights: utils.DynamicWeights{
+			{
+				Weight: 10,
+			},
+		},
+		Sorting:           utils.MetaWeight,
+		SortingParameters: []string{},
+		Routes: []*engine.Route{
+			{
+				ID: "route1",
+				Weights: utils.DynamicWeights{
+					{
+						Weight: 20,
+					},
+				},
+			},
+		},
+	}
+	dm.SetRouteProfile(context.Background(), rte, false)
 	rcv, _ = getTariffPlansKeys(context.Background(), dm, "cgrates.org", utils.MetaRoutes)
 	exp = []string{"ROUTE_2003"}
 	if !reflect.DeepEqual(rcv, exp) {
@@ -128,6 +288,35 @@ func TestGetTariffPlansKeys(t *testing.T) {
 	}

 	//Stats
+	stq := &engine.StatQueueProfile{
+		Tenant: "cgrates.org",
+		ID:     "SQ_2",
+		Weights: utils.DynamicWeights{
+			{
+				Weight: 20,
+			},
+		},
+		QueueLength: 14,
+		Metrics: []*engine.MetricWithFilters{
+			{
+				MetricID: utils.MetaASR,
+			},
+			{
+				MetricID: utils.MetaTCD,
+			},
+			{
+				MetricID: utils.MetaPDD,
+			},
+			{
+				MetricID: utils.MetaTCC,
+			},
+			{
+				MetricID: utils.MetaTCD,
+			},
+		},
+		ThresholdIDs: []string{utils.MetaNone},
+	}
+	dm.SetStatQueueProfile(context.Background(), stq, false)
 	rcv, _ = getTariffPlansKeys(context.Background(), dm, "cgrates.org", utils.MetaStats)
 	exp = []string{"SQ_2"}
 	if !reflect.DeepEqual(rcv, exp) {
@@ -135,6 +324,21 @@ func TestGetTariffPlansKeys(t *testing.T) {
 	}

 	//Thresholds
+	thd := &engine.ThresholdProfile{
+		Tenant:           "cgrates.org",
+		ID:               "THD_2",
+		FilterIDs:        []string{"*string:~*req.Account:1001"},
+		ActionProfileIDs: []string{"actPrfID"},
+		MaxHits:          7,
+		MinHits:          0,
+		Weights: utils.DynamicWeights{
+			{
+				Weight: 20,
+			},
+		},
+		Async: true,
+	}
+	dm.SetThresholdProfile(context.Background(), thd, false)
 	rcv, _ = getTariffPlansKeys(context.Background(), dm, "cgrates.org", utils.MetaThresholds)
 	exp = []string{"THD_2"}
 	if !reflect.DeepEqual(rcv, exp) {
@@ -142,13 +346,45 @@ func TestGetTariffPlansKeys(t *testing.T) {
 	}

 	//Dispatchers
+	dsp := &engine.DispatcherProfile{
+		Tenant:    "cgrates.org",
+		ID:        "Dsp1",
+		FilterIDs: []string{"*string:~*req.Account:1001", "*ai:~*req.AnswerTime:2014-07-14T14:25:00Z"},
+		Strategy:  utils.MetaFirst,
+		StrategyParams: map[string]interface{}{
+			utils.MetaDefaultRatio: "false",
+		},
+		Weight: 20,
+		Hosts: engine.DispatcherHostProfiles{
+			{
+				ID:        "C1",
+				FilterIDs: []string{},
+				Weight:    10,
+				Params:    map[string]interface{}{"0": "192.168.54.203"},
+				Blocker:   false,
+			},
+		},
+	}
+	dm.SetDispatcherProfile(context.Background(), dsp, false)
 	rcv, _ = getTariffPlansKeys(context.Background(), dm, "cgrates.org", utils.MetaDispatchers)
 	exp = []string{"Dsp1"}
 	if !reflect.DeepEqual(rcv, exp) {
 		t.Errorf("Expected %v\n but received %v", exp, rcv)
 	}

-	//Dispatchers
+	//DispatcherHosts
+	dsph := &engine.DispatcherHost{
+		Tenant: "cgrates.org",
+		RemoteHost: &config.RemoteHost{
+			ID:              "DSH1",
+			Address:         "*internal",
+			ConnectAttempts: 1,
+			Reconnects:      3,
+			ConnectTimeout:  time.Minute,
+			ReplyTimeout:    2 * time.Minute,
+		},
+	}
+	dm.SetDispatcherHost(context.Background(), dsph)
 	rcv, _ = getTariffPlansKeys(context.Background(), dm, "cgrates.org", utils.MetaDispatcherHosts)
 	exp = []string{"DSH1"}
 	if !reflect.DeepEqual(rcv, exp) {
@@ -156,7 +392,7 @@ func TestGetTariffPlansKeys(t *testing.T) {
 	}

 	//Unsupported
-	_, err = getTariffPlansKeys(context.Background(), dm, "cgrates.org", "not_valid")
+	_, err := getTariffPlansKeys(context.Background(), dm, "cgrates.org", "not_valid")
 	errExpect := "Unsuported exporter type"
 	if err.Error() != errExpect {
 		t.Errorf("Expected %v\n but received %v", errExpect, err.Error())
@@ -166,16 +402,31 @@ func TestGetTariffPlansKeys(t *testing.T) {
 func TestV1ExportTariffPlan(t *testing.T) {
 	cfg := config.NewDefaultCGRConfig()
 	connMng := engine.NewConnManager(cfg)
-	dataDB, err := engine.NewDataDBConn(cfg.DataDbCfg().Type,
-		cfg.DataDbCfg().Host, cfg.DataDbCfg().Port,
-		cfg.DataDbCfg().Name, cfg.DataDbCfg().User,
-		cfg.DataDbCfg().Password, cfg.GeneralCfg().DBDataEncoding,
-		cfg.DataDbCfg().Opts, cfg.DataDbCfg().Items)
-	if err != nil {
-		t.Error(err)
+	data := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
+	dm := engine.NewDataManager(data, cfg.CacheCfg(), nil)
+	attr := &engine.AttributeProfile{
+		Tenant:    utils.CGRateSorg,
+		ID:        "TEST_ATTRIBUTES_TEST",
+		FilterIDs: []string{"*string:~*req.Account:1002", "*exists:~*opts.*usage:"},
+		Attributes: []*engine.Attribute{
+			{
+				Path:  utils.AccountField,
+				Type:  utils.MetaConstant,
+				Value: nil,
+			},
+			{
+				Path:  "*tenant",
+				Type:  utils.MetaConstant,
+				Value: nil,
+			},
+		},
+		Weights: utils.DynamicWeights{
+			{
+				Weight: 20,
+			},
+		},
 	}
-	defer dataDB.Close()
-	dm := engine.NewDataManager(dataDB, config.CgrConfig().CacheCfg(), connMng)
+	dm.SetAttributeProfile(context.Background(), attr, false)
 	tpE := NewTPeS(cfg, dm, connMng)
 	var reply []byte
 	args := &ArgsExportTP{
@@ -184,7 +435,7 @@ func TestV1ExportTariffPlan(t *testing.T) {
 			utils.MetaAttributes: {"TEST_ATTRIBUTES_TEST"},
 		},
 	}
-	err = tpE.V1ExportTariffPlan(context.Background(), args, &reply)
+	err := tpE.V1ExportTariffPlan(context.Background(), args, &reply)
 	if err != nil {
 		t.Error(err)
 	}
@@ -193,23 +444,15 @@ func TestV1ExportTariffPlan(t *testing.T) {
 func TestV1ExportTariffPlanZeroExp(t *testing.T) {
 	cfg := config.NewDefaultCGRConfig()
 	connMng := engine.NewConnManager(cfg)
-	dataDB, err := engine.NewDataDBConn(cfg.DataDbCfg().Type,
-		cfg.DataDbCfg().Host, cfg.DataDbCfg().Port,
-		cfg.DataDbCfg().Name, cfg.DataDbCfg().User,
-		cfg.DataDbCfg().Password, cfg.GeneralCfg().DBDataEncoding,
-		cfg.DataDbCfg().Opts, cfg.DataDbCfg().Items)
-	if err != nil {
-		t.Error(err)
-	}
-	defer dataDB.Close()
-	dm := engine.NewDataManager(dataDB, config.CgrConfig().CacheCfg(), connMng)
+	data := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
+	dm := engine.NewDataManager(data, cfg.CacheCfg(), nil)
 	tpE := NewTPeS(cfg, dm, connMng)
 	var reply []byte
 	args := &ArgsExportTP{
 		Tenant:      utils.EmptyString,
 		ExportItems: map[string][]string{},
 	}
-	err = tpE.V1ExportTariffPlan(context.Background(), args, &reply)
+	err := tpE.V1ExportTariffPlan(context.Background(), args, &reply)
 	if err != nil {
 		t.Error(err)
 	}
@@ -218,16 +461,8 @@ func TestV1ExportTariffPlanZeroExp(t *testing.T) {
 func TestV1ExportTariffPlanZeroIDs(t *testing.T) {
 	cfg := config.NewDefaultCGRConfig()
 	connMng := engine.NewConnManager(cfg)
-	dataDB, err := engine.NewDataDBConn(cfg.DataDbCfg().Type,
-		cfg.DataDbCfg().Host, cfg.DataDbCfg().Port,
-		cfg.DataDbCfg().Name, cfg.DataDbCfg().User,
-		cfg.DataDbCfg().Password, cfg.GeneralCfg().DBDataEncoding,
-		cfg.DataDbCfg().Opts, cfg.DataDbCfg().Items)
-	if err != nil {
-		t.Error(err)
-	}
-	defer dataDB.Close()
-	dm := engine.NewDataManager(dataDB, config.CgrConfig().CacheCfg(), connMng)
+	data := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
+	dm := engine.NewDataManager(data, cfg.CacheCfg(), nil)
 	tpE := NewTPeS(cfg, dm, connMng)
 	var reply []byte
 	args := &ArgsExportTP{
@@ -236,7 +471,7 @@ func TestV1ExportTariffPlanZeroIDs(t *testing.T) {
 			utils.MetaAttributes: {},
 		},
 	}
-	err = tpE.V1ExportTariffPlan(context.Background(), args, &reply)
+	err := tpE.V1ExportTariffPlan(context.Background(), args, &reply)
 	if err != nil {
 		t.Error(err)
 	}
@@ -245,16 +480,8 @@ func TestV1ExportTariffPlanZeroIDs(t *testing.T) {
 func TestV1ExportTariffPlanInvalidExpType(t *testing.T) {
 	cfg := config.NewDefaultCGRConfig()
 	connMng := engine.NewConnManager(cfg)
-	dataDB, err := engine.NewDataDBConn(cfg.DataDbCfg().Type,
-		cfg.DataDbCfg().Host, cfg.DataDbCfg().Port,
-		cfg.DataDbCfg().Name, cfg.DataDbCfg().User,
-		cfg.DataDbCfg().Password, cfg.GeneralCfg().DBDataEncoding,
-		cfg.DataDbCfg().Opts, cfg.DataDbCfg().Items)
-	if err != nil {
-		t.Error(err)
-	}
-	defer dataDB.Close()
-	dm := engine.NewDataManager(dataDB, config.CgrConfig().CacheCfg(), connMng)
+	data := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
+	dm := engine.NewDataManager(data, cfg.CacheCfg(), nil)
 	tpE := NewTPeS(cfg, dm, connMng)
 	var reply []byte
 	args := &ArgsExportTP{
@@ -263,7 +490,7 @@ func TestV1ExportTariffPlanInvalidExpType(t *testing.T) {
 			"not_valid": {},
 		},
 	}
-	err = tpE.V1ExportTariffPlan(context.Background(), args, &reply)
+	err := tpE.V1ExportTariffPlan(context.Background(), args, &reply)
 	errExp := "UNSUPPORTED_TPEXPORTER_TYPE:not_valid"
 	if err.Error() != errExp {
 		t.Errorf("Expected %v\n but received %v", errExp, err.Error())