Updated integration tests

config/datadbcfg.go

@@ -94,9 +94,8 @@ func (dbcfg *DataDbCfg) loadFromJsonCfg(jsnDbCfg *DbJsonCfg) (err error) {
 			// if we have the connection internal we change the name so we can have internal rpc for each subsystem
 			if rplConn == utils.MetaInternal {
 				return fmt.Errorf("Replication connection ID needs to be different than *internal")
-			} else {
-				dbcfg.RplConns[idx] = rplConn
 			}
+			dbcfg.RplConns[idx] = rplConn
 		}
 	}
 	if jsnDbCfg.Items != nil {

config/stordbcfg.go

@@ -95,7 +95,6 @@ func (dbcfg *StorDbCfg) loadFromJsonCfg(jsnDbCfg *DbJsonCfg) (err error) {
 		dbcfg.SSLMode = *jsnDbCfg.Sslmode
 	}
 	if jsnDbCfg.Items != nil {
-		dbcfg.Items = make(map[string]*ItemOpt)
 		for kJsn, vJsn := range *jsnDbCfg.Items {
 			val := new(ItemOpt)
 			if err := val.loadFromJsonCfg(vJsn); err != nil {

config/stordbcfg_test.go

@@ -135,6 +135,7 @@ func TestStoreDbCfgloadFromJsonCfgPort(t *testing.T) {
 
 func TestStorDbCfgAsMapInterface(t *testing.T) {
 	var dbcfg StorDbCfg
+	dbcfg.Items = make(map[string]*ItemOpt)
 	cfgJSONStr := `{
 		"stor_db": {								
 			"db_type": "*mysql",					

engine/mapevent.go

@@ -257,6 +257,7 @@ func (me MapEvent) AsCDR(cfg *config.CGRConfig, tnt, tmz string) (cdr *CDR, err
 			if cdr.CostDetails, err = IfaceAsEventCost(v); err != nil {
 				return nil, err
 			}
+			cdr.CostDetails.initCache()
 		case utils.ExtraInfo:
 			cdr.ExtraInfo = utils.IfaceAsString(v)
 		case utils.OrderID:
@@ -265,11 +266,6 @@ func (me MapEvent) AsCDR(cfg *config.CGRConfig, tnt, tmz string) (cdr *CDR, err
 			}
 		}
 	}
-	if cdr.CostDetails == nil {
-		cdr.CostDetails = NewBareEventCost()
-	} else {
-		cdr.CostDetails.initCache()
-	}
 	if cfg != nil {
 		cdr.AddDefaults(cfg)
 	}

engine/mapevent_test.go

@@ -311,7 +311,7 @@ func TestMapEventAsMapString(t *testing.T) {
 
 func TestMapEventAsCDR(t *testing.T) {
 	me := NewMapEvent(nil)
-	expected := &CDR{Cost: -1.0, ExtraFields: make(map[string]string), CostDetails: NewBareEventCost()}
+	expected := &CDR{Cost: -1.0, ExtraFields: make(map[string]string)}
 	if rply, err := me.AsCDR(nil, utils.EmptyString, utils.EmptyString); err != nil {
 		t.Error(err)
 	} else if !reflect.DeepEqual(expected, rply) {
@@ -330,7 +330,6 @@ func TestMapEventAsCDR(t *testing.T) {
 		Tenant:      cfg.GeneralCfg().DefaultTenant,
 		Category:    cfg.GeneralCfg().DefaultCategory,
 		ExtraFields: make(map[string]string),
-		CostDetails: NewBareEventCost(),
 	}
 	if rply, err := me.AsCDR(cfg, utils.EmptyString, utils.EmptyString); err != nil {
 		t.Error(err)
@@ -372,8 +371,7 @@ func TestMapEventAsCDR(t *testing.T) {
 
 	me = MapEvent{"ExtraField1": 5, "ExtraField2": "extra"}
 	expected = &CDR{
-		Cost:        -1.0,
-		CostDetails: NewBareEventCost(),
+		Cost: -1.0,
 		ExtraFields: map[string]string{
 			"ExtraField1": "5",
 			"ExtraField2": "extra",
@@ -405,7 +403,6 @@ func TestMapEventAsCDR(t *testing.T) {
 		Tenant:      cfg.GeneralCfg().DefaultTenant,
 		Category:    cfg.GeneralCfg().DefaultCategory,
 		ExtraInfo:   "ACCOUNT_NOT_FOUND",
-		CostDetails: NewBareEventCost(),
 	}
 	if rply, err := me.AsCDR(cfg, utils.EmptyString, utils.EmptyString); err != nil {
 		t.Error(err)
@@ -449,8 +446,7 @@ func TestMapEventAsCDR(t *testing.T) {
 			"ExtraField1": "5",
 			"ExtraField2": "extra",
 		},
-		ExtraInfo:   "ACCOUNT_NOT_FOUND",
-		CostDetails: NewBareEventCost(),
+		ExtraInfo: "ACCOUNT_NOT_FOUND",
 	}
 	if rply, err := me.AsCDR(cfg, utils.EmptyString, utils.EmptyString); err != nil {
 		t.Error(err)

engine/safevent_test.go

@@ -625,7 +625,7 @@ func TestSafEventAsMapString(t *testing.T) {
 
 func TestSafEventAsCDR(t *testing.T) {
 	se := SafEvent{Me: NewMapEvent(nil)}
-	expected := &CDR{Cost: -1.0, ExtraFields: make(map[string]string), CostDetails: NewBareEventCost()}
+	expected := &CDR{Cost: -1.0, ExtraFields: make(map[string]string)}
 	if rply, err := se.AsCDR(nil, utils.EmptyString, utils.EmptyString); err != nil {
 		t.Error(err)
 	} else if !reflect.DeepEqual(expected, rply) {
@@ -644,7 +644,6 @@ func TestSafEventAsCDR(t *testing.T) {
 		Tenant:      cfg.GeneralCfg().DefaultTenant,
 		Category:    cfg.GeneralCfg().DefaultCategory,
 		ExtraFields: make(map[string]string),
-		CostDetails: NewBareEventCost(),
 	}
 	if rply, err := se.AsCDR(cfg, utils.EmptyString, utils.EmptyString); err != nil {
 		t.Error(err)
@@ -677,8 +676,7 @@ func TestSafEventAsCDR(t *testing.T) {
 	}
 	se = SafEvent{Me: MapEvent{"ExtraField1": 5, "ExtraField2": "extra"}}
 	expected = &CDR{
-		Cost:        -1.0,
-		CostDetails: NewBareEventCost(),
+		Cost: -1.0,
 		ExtraFields: map[string]string{
 			"ExtraField1": "5",
 			"ExtraField2": "extra",
@@ -708,7 +706,6 @@ func TestSafEventAsCDR(t *testing.T) {
 		RequestType: cfg.GeneralCfg().DefaultReqType,
 		Tenant:      cfg.GeneralCfg().DefaultTenant,
 		Category:    cfg.GeneralCfg().DefaultCategory,
-		CostDetails: NewBareEventCost(),
 	}
 	if rply, err := se.AsCDR(cfg, utils.EmptyString, utils.EmptyString); err != nil {
 		t.Error(err)
@@ -742,7 +739,6 @@ func TestSafEventAsCDR(t *testing.T) {
 		ToR:         utils.VOICE,
 		RequestType: cfg.GeneralCfg().DefaultReqType,
 		Category:    cfg.GeneralCfg().DefaultCategory,
-		CostDetails: NewBareEventCost(),
 	}
 	if rply, err := se.AsCDR(cfg, "itsyscom.com", utils.EmptyString); err != nil {
 		t.Error(err)

engine/storage_internal_datadb.go

@@ -34,158 +34,158 @@ import (
 func newInternalDBCfg(itemsCacheCfg map[string]*config.ItemOpt, isDataDB bool) map[string]*ltcache.CacheConfig {
 	if isDataDB {
 		return map[string]*ltcache.CacheConfig{
-			utils.CacheDestinations: &ltcache.CacheConfig{
+			utils.CacheDestinations: {
 				MaxItems:  itemsCacheCfg[utils.CacheDestinations].Limit,
 				TTL:       itemsCacheCfg[utils.CacheDestinations].TTL,
 				StaticTTL: itemsCacheCfg[utils.CacheDestinations].StaticTTL,
 			},
-			utils.CacheReverseDestinations: &ltcache.CacheConfig{
+			utils.CacheReverseDestinations: {
 				MaxItems:  itemsCacheCfg[utils.CacheReverseDestinations].Limit,
 				TTL:       itemsCacheCfg[utils.CacheReverseDestinations].TTL,
 				StaticTTL: itemsCacheCfg[utils.CacheReverseDestinations].StaticTTL,
 			},
-			utils.CacheActions: &ltcache.CacheConfig{
+			utils.CacheActions: {
 				MaxItems:  itemsCacheCfg[utils.CacheActions].Limit,
 				TTL:       itemsCacheCfg[utils.CacheActions].TTL,
 				StaticTTL: itemsCacheCfg[utils.CacheActions].StaticTTL,
 			},
-			utils.CacheActionPlans: &ltcache.CacheConfig{
+			utils.CacheActionPlans: {
 				MaxItems:  itemsCacheCfg[utils.CacheActionPlans].Limit,
 				TTL:       itemsCacheCfg[utils.CacheActionPlans].TTL,
 				StaticTTL: itemsCacheCfg[utils.CacheActionPlans].StaticTTL,
 			},
-			utils.CacheAccountActionPlans: &ltcache.CacheConfig{
+			utils.CacheAccountActionPlans: {
 				MaxItems:  itemsCacheCfg[utils.CacheAccountActionPlans].Limit,
 				TTL:       itemsCacheCfg[utils.CacheAccountActionPlans].TTL,
 				StaticTTL: itemsCacheCfg[utils.CacheAccountActionPlans].StaticTTL,
 			},
-			utils.CacheActionTriggers: &ltcache.CacheConfig{
+			utils.CacheActionTriggers: {
 				MaxItems:  itemsCacheCfg[utils.CacheActionTriggers].Limit,
 				TTL:       itemsCacheCfg[utils.CacheActionTriggers].TTL,
 				StaticTTL: itemsCacheCfg[utils.CacheActionTriggers].StaticTTL,
 			},
-			utils.CacheRatingPlans: &ltcache.CacheConfig{
+			utils.CacheRatingPlans: {
 				MaxItems:  itemsCacheCfg[utils.CacheRatingPlans].Limit,
 				TTL:       itemsCacheCfg[utils.CacheRatingPlans].TTL,
 				StaticTTL: itemsCacheCfg[utils.CacheRatingPlans].StaticTTL,
 			},
-			utils.CacheRatingProfiles: &ltcache.CacheConfig{
+			utils.CacheRatingProfiles: {
 				MaxItems:  itemsCacheCfg[utils.CacheRatingProfiles].Limit,
 				TTL:       itemsCacheCfg[utils.CacheRatingProfiles].TTL,
 				StaticTTL: itemsCacheCfg[utils.CacheRatingProfiles].StaticTTL,
 			},
-			utils.CacheAccounts: &ltcache.CacheConfig{
+			utils.CacheAccounts: {
 				MaxItems:  itemsCacheCfg[utils.CacheAccounts].Limit,
 				TTL:       itemsCacheCfg[utils.CacheAccounts].TTL,
 				StaticTTL: itemsCacheCfg[utils.CacheAccounts].StaticTTL,
 			},
-			utils.CacheSharedGroups: &ltcache.CacheConfig{
+			utils.CacheSharedGroups: {
 				MaxItems:  itemsCacheCfg[utils.CacheSharedGroups].Limit,
 				TTL:       itemsCacheCfg[utils.CacheSharedGroups].TTL,
 				StaticTTL: itemsCacheCfg[utils.CacheSharedGroups].StaticTTL,
 			},
 
-			utils.CacheTimings: &ltcache.CacheConfig{
+			utils.CacheTimings: {
 				MaxItems:  itemsCacheCfg[utils.CacheTimings].Limit,
 				TTL:       itemsCacheCfg[utils.CacheTimings].TTL,
 				StaticTTL: itemsCacheCfg[utils.CacheTimings].StaticTTL,
 			},
-			utils.CacheFilters: &ltcache.CacheConfig{
+			utils.CacheFilters: {
 				MaxItems:  itemsCacheCfg[utils.CacheFilters].Limit,
 				TTL:       itemsCacheCfg[utils.CacheFilters].TTL,
 				StaticTTL: itemsCacheCfg[utils.CacheFilters].StaticTTL,
 			},
-			utils.CacheResourceProfiles: &ltcache.CacheConfig{
+			utils.CacheResourceProfiles: {
 				MaxItems:  itemsCacheCfg[utils.CacheResourceProfiles].Limit,
 				TTL:       itemsCacheCfg[utils.CacheResourceProfiles].TTL,
 				StaticTTL: itemsCacheCfg[utils.CacheResourceProfiles].StaticTTL,
 			},
-			utils.CacheResourceFilterIndexes: &ltcache.CacheConfig{
+			utils.CacheResourceFilterIndexes: {
 				MaxItems:  itemsCacheCfg[utils.MetaFilterIndexes].Limit,
 				TTL:       itemsCacheCfg[utils.MetaFilterIndexes].TTL,
 				StaticTTL: itemsCacheCfg[utils.MetaFilterIndexes].StaticTTL,
 			},
-			utils.CacheResources: &ltcache.CacheConfig{
+			utils.CacheResources: {
 				MaxItems:  itemsCacheCfg[utils.CacheResources].Limit,
 				TTL:       itemsCacheCfg[utils.CacheResources].TTL,
 				StaticTTL: itemsCacheCfg[utils.CacheResources].StaticTTL,
 			},
-			utils.CacheStatFilterIndexes: &ltcache.CacheConfig{
+			utils.CacheStatFilterIndexes: {
 				MaxItems:  itemsCacheCfg[utils.MetaFilterIndexes].Limit,
 				TTL:       itemsCacheCfg[utils.MetaFilterIndexes].TTL,
 				StaticTTL: itemsCacheCfg[utils.MetaFilterIndexes].StaticTTL,
 			},
-			utils.CacheStatQueueProfiles: &ltcache.CacheConfig{
+			utils.CacheStatQueueProfiles: {
 				MaxItems:  itemsCacheCfg[utils.CacheStatQueueProfiles].Limit,
 				TTL:       itemsCacheCfg[utils.CacheStatQueueProfiles].TTL,
 				StaticTTL: itemsCacheCfg[utils.CacheStatQueueProfiles].StaticTTL,
 			},
-			utils.CacheStatQueues: &ltcache.CacheConfig{
+			utils.CacheStatQueues: {
 				MaxItems:  itemsCacheCfg[utils.CacheStatQueues].Limit,
 				TTL:       itemsCacheCfg[utils.CacheStatQueues].TTL,
 				StaticTTL: itemsCacheCfg[utils.CacheStatQueues].StaticTTL,
 			},
-			utils.CacheThresholdFilterIndexes: &ltcache.CacheConfig{
+			utils.CacheThresholdFilterIndexes: {
 				MaxItems:  itemsCacheCfg[utils.MetaFilterIndexes].Limit,
 				TTL:       itemsCacheCfg[utils.MetaFilterIndexes].TTL,
 				StaticTTL: itemsCacheCfg[utils.MetaFilterIndexes].StaticTTL,
 			},
-			utils.CacheThresholdProfiles: &ltcache.CacheConfig{
+			utils.CacheThresholdProfiles: {
 				MaxItems:  itemsCacheCfg[utils.CacheThresholdProfiles].Limit,
 				TTL:       itemsCacheCfg[utils.CacheThresholdProfiles].TTL,
 				StaticTTL: itemsCacheCfg[utils.CacheThresholdProfiles].StaticTTL,
 			},
-			utils.CacheThresholds: &ltcache.CacheConfig{
+			utils.CacheThresholds: {
 				MaxItems:  itemsCacheCfg[utils.CacheThresholds].Limit,
 				TTL:       itemsCacheCfg[utils.CacheThresholds].TTL,
 				StaticTTL: itemsCacheCfg[utils.CacheThresholds].StaticTTL,
 			},
-			utils.CacheSupplierFilterIndexes: &ltcache.CacheConfig{
+			utils.CacheSupplierFilterIndexes: {
 				MaxItems:  itemsCacheCfg[utils.MetaFilterIndexes].Limit,
 				TTL:       itemsCacheCfg[utils.MetaFilterIndexes].TTL,
 				StaticTTL: itemsCacheCfg[utils.MetaFilterIndexes].StaticTTL,
 			},
-			utils.CacheSupplierProfiles: &ltcache.CacheConfig{
+			utils.CacheSupplierProfiles: {
 				MaxItems:  itemsCacheCfg[utils.CacheSupplierProfiles].Limit,
 				TTL:       itemsCacheCfg[utils.CacheSupplierProfiles].TTL,
 				StaticTTL: itemsCacheCfg[utils.CacheSupplierProfiles].StaticTTL,
 			},
-			utils.CacheChargerFilterIndexes: &ltcache.CacheConfig{
+			utils.CacheChargerFilterIndexes: {
 				MaxItems:  itemsCacheCfg[utils.MetaFilterIndexes].Limit,
 				TTL:       itemsCacheCfg[utils.MetaFilterIndexes].TTL,
 				StaticTTL: itemsCacheCfg[utils.MetaFilterIndexes].StaticTTL,
 			},
-			utils.CacheChargerProfiles: &ltcache.CacheConfig{
+			utils.CacheChargerProfiles: {
 				MaxItems:  itemsCacheCfg[utils.CacheChargerProfiles].Limit,
 				TTL:       itemsCacheCfg[utils.CacheChargerProfiles].TTL,
 				StaticTTL: itemsCacheCfg[utils.CacheChargerProfiles].StaticTTL,
 			},
-			utils.CacheAttributeFilterIndexes: &ltcache.CacheConfig{
+			utils.CacheAttributeFilterIndexes: {
 				MaxItems:  itemsCacheCfg[utils.MetaFilterIndexes].Limit,
 				TTL:       itemsCacheCfg[utils.MetaFilterIndexes].TTL,
 				StaticTTL: itemsCacheCfg[utils.MetaFilterIndexes].StaticTTL,
 			},
-			utils.CacheAttributeProfiles: &ltcache.CacheConfig{
+			utils.CacheAttributeProfiles: {
 				MaxItems:  itemsCacheCfg[utils.CacheAttributeProfiles].Limit,
 				TTL:       itemsCacheCfg[utils.CacheAttributeProfiles].TTL,
 				StaticTTL: itemsCacheCfg[utils.CacheAttributeProfiles].StaticTTL,
 			},
-			utils.CacheDispatcherFilterIndexes: &ltcache.CacheConfig{
+			utils.CacheDispatcherFilterIndexes: {
 				MaxItems:  itemsCacheCfg[utils.MetaFilterIndexes].Limit,
 				TTL:       itemsCacheCfg[utils.MetaFilterIndexes].TTL,
 				StaticTTL: itemsCacheCfg[utils.MetaFilterIndexes].StaticTTL,
 			},
-			utils.CacheDispatcherProfiles: &ltcache.CacheConfig{
+			utils.CacheDispatcherProfiles: {
 				MaxItems:  itemsCacheCfg[utils.CacheDispatcherProfiles].Limit,
 				TTL:       itemsCacheCfg[utils.CacheDispatcherProfiles].TTL,
 				StaticTTL: itemsCacheCfg[utils.CacheDispatcherProfiles].StaticTTL,
 			},
-			utils.CacheDispatcherHosts: &ltcache.CacheConfig{
+			utils.CacheDispatcherHosts: {
 				MaxItems:  itemsCacheCfg[utils.CacheDispatcherHosts].Limit,
 				TTL:       itemsCacheCfg[utils.CacheDispatcherHosts].TTL,
 				StaticTTL: itemsCacheCfg[utils.CacheDispatcherHosts].StaticTTL,
 			},
-			utils.CacheLoadIDs: &ltcache.CacheConfig{
+			utils.CacheLoadIDs: {
 				MaxItems:  itemsCacheCfg[utils.CacheLoadIDs].Limit,
 				TTL:       itemsCacheCfg[utils.CacheLoadIDs].TTL,
 				StaticTTL: itemsCacheCfg[utils.CacheLoadIDs].StaticTTL,
@@ -193,117 +193,117 @@ func newInternalDBCfg(itemsCacheCfg map[string]*config.ItemOpt, isDataDB bool) m
 		}
 	} else {
 		return map[string]*ltcache.CacheConfig{
-			utils.TBLVersions: &ltcache.CacheConfig{
+			utils.TBLVersions: {
 				MaxItems:  itemsCacheCfg[utils.TBLVersions].Limit,
 				TTL:       itemsCacheCfg[utils.TBLVersions].TTL,
 				StaticTTL: itemsCacheCfg[utils.TBLVersions].StaticTTL,
 			},
-			utils.TBLTPTimings: &ltcache.CacheConfig{
+			utils.TBLTPTimings: {
 				MaxItems:  itemsCacheCfg[utils.TBLTPTimings].Limit,
 				TTL:       itemsCacheCfg[utils.TBLTPTimings].TTL,
 				StaticTTL: itemsCacheCfg[utils.TBLTPTimings].StaticTTL,
 			},
-			utils.TBLTPDestinations: &ltcache.CacheConfig{
+			utils.TBLTPDestinations: {
 				MaxItems:  itemsCacheCfg[utils.TBLTPDestinations].Limit,
 				TTL:       itemsCacheCfg[utils.TBLTPDestinations].TTL,
 				StaticTTL: itemsCacheCfg[utils.TBLTPDestinations].StaticTTL,
 			},
-			utils.TBLTPRates: &ltcache.CacheConfig{
+			utils.TBLTPRates: {
 				MaxItems:  itemsCacheCfg[utils.TBLTPRates].Limit,
 				TTL:       itemsCacheCfg[utils.TBLTPRates].TTL,
 				StaticTTL: itemsCacheCfg[utils.TBLTPRates].StaticTTL,
 			},
-			utils.TBLTPDestinationRates: &ltcache.CacheConfig{
+			utils.TBLTPDestinationRates: {
 				MaxItems:  itemsCacheCfg[utils.TBLTPDestinationRates].Limit,
 				TTL:       itemsCacheCfg[utils.TBLTPDestinationRates].TTL,
 				StaticTTL: itemsCacheCfg[utils.TBLTPDestinationRates].StaticTTL,
 			},
-			utils.TBLTPRatingPlans: &ltcache.CacheConfig{
+			utils.TBLTPRatingPlans: {
 				MaxItems:  itemsCacheCfg[utils.TBLTPRatingPlans].Limit,
 				TTL:       itemsCacheCfg[utils.TBLTPRatingPlans].TTL,
 				StaticTTL: itemsCacheCfg[utils.TBLTPRatingPlans].StaticTTL,
 			},
-			utils.TBLTPRateProfiles: &ltcache.CacheConfig{
+			utils.TBLTPRateProfiles: {
 				MaxItems:  itemsCacheCfg[utils.TBLTPRateProfiles].Limit,
 				TTL:       itemsCacheCfg[utils.TBLTPRateProfiles].TTL,
 				StaticTTL: itemsCacheCfg[utils.TBLTPRateProfiles].StaticTTL,
 			},
-			utils.TBLTPSharedGroups: &ltcache.CacheConfig{
+			utils.TBLTPSharedGroups: {
 				MaxItems:  itemsCacheCfg[utils.TBLTPSharedGroups].Limit,
 				TTL:       itemsCacheCfg[utils.TBLTPSharedGroups].TTL,
 				StaticTTL: itemsCacheCfg[utils.TBLTPSharedGroups].StaticTTL,
 			},
-			utils.TBLTPActions: &ltcache.CacheConfig{
+			utils.TBLTPActions: {
 				MaxItems:  itemsCacheCfg[utils.TBLTPActions].Limit,
 				TTL:       itemsCacheCfg[utils.TBLTPActions].TTL,
 				StaticTTL: itemsCacheCfg[utils.TBLTPActions].StaticTTL,
 			},
-			utils.TBLTPActionTriggers: &ltcache.CacheConfig{
+			utils.TBLTPActionTriggers: {
 				MaxItems:  itemsCacheCfg[utils.TBLTPActionTriggers].Limit,
 				TTL:       itemsCacheCfg[utils.TBLTPActionTriggers].TTL,
 				StaticTTL: itemsCacheCfg[utils.TBLTPActionTriggers].StaticTTL,
 			},
-			utils.TBLTPAccountActions: &ltcache.CacheConfig{
+			utils.TBLTPAccountActions: {
 				MaxItems:  itemsCacheCfg[utils.TBLTPAccountActions].Limit,
 				TTL:       itemsCacheCfg[utils.TBLTPAccountActions].TTL,
 				StaticTTL: itemsCacheCfg[utils.TBLTPAccountActions].StaticTTL,
 			},
-			utils.TBLTPResources: &ltcache.CacheConfig{
+			utils.TBLTPResources: {
 				MaxItems:  itemsCacheCfg[utils.TBLTPResources].Limit,
 				TTL:       itemsCacheCfg[utils.TBLTPResources].TTL,
 				StaticTTL: itemsCacheCfg[utils.TBLTPResources].StaticTTL,
 			},
-			utils.TBLTPStats: &ltcache.CacheConfig{
+			utils.TBLTPStats: {
 				MaxItems:  itemsCacheCfg[utils.TBLTPStats].Limit,
 				TTL:       itemsCacheCfg[utils.TBLTPStats].TTL,
 				StaticTTL: itemsCacheCfg[utils.TBLTPStats].StaticTTL,
 			},
-			utils.TBLTPThresholds: &ltcache.CacheConfig{
+			utils.TBLTPThresholds: {
 				MaxItems:  itemsCacheCfg[utils.TBLTPThresholds].Limit,
 				TTL:       itemsCacheCfg[utils.TBLTPThresholds].TTL,
 				StaticTTL: itemsCacheCfg[utils.TBLTPThresholds].StaticTTL,
 			},
-			utils.TBLTPFilters: &ltcache.CacheConfig{
+			utils.TBLTPFilters: {
 				MaxItems:  itemsCacheCfg[utils.TBLTPFilters].Limit,
 				TTL:       itemsCacheCfg[utils.TBLTPFilters].TTL,
 				StaticTTL: itemsCacheCfg[utils.TBLTPFilters].StaticTTL,
 			},
-			utils.SessionCostsTBL: &ltcache.CacheConfig{
+			utils.SessionCostsTBL: {
 				MaxItems:  itemsCacheCfg[utils.SessionCostsTBL].Limit,
 				TTL:       itemsCacheCfg[utils.SessionCostsTBL].TTL,
 				StaticTTL: itemsCacheCfg[utils.SessionCostsTBL].StaticTTL,
 			},
-			utils.TBLTPActionPlans: &ltcache.CacheConfig{
+			utils.TBLTPActionPlans: {
 				MaxItems:  itemsCacheCfg[utils.TBLTPActionPlans].Limit,
 				TTL:       itemsCacheCfg[utils.TBLTPActionPlans].TTL,
 				StaticTTL: itemsCacheCfg[utils.TBLTPActionPlans].StaticTTL,
 			},
-			utils.TBLTPSuppliers: &ltcache.CacheConfig{
+			utils.TBLTPSuppliers: {
 				MaxItems:  itemsCacheCfg[utils.TBLTPSuppliers].Limit,
 				TTL:       itemsCacheCfg[utils.TBLTPSuppliers].TTL,
 				StaticTTL: itemsCacheCfg[utils.TBLTPSuppliers].StaticTTL,
 			},
-			utils.TBLTPAttributes: &ltcache.CacheConfig{
+			utils.TBLTPAttributes: {
 				MaxItems:  itemsCacheCfg[utils.TBLTPAttributes].Limit,
 				TTL:       itemsCacheCfg[utils.TBLTPAttributes].TTL,
 				StaticTTL: itemsCacheCfg[utils.TBLTPAttributes].StaticTTL,
 			},
-			utils.TBLTPChargers: &ltcache.CacheConfig{
+			utils.TBLTPChargers: {
 				MaxItems:  itemsCacheCfg[utils.TBLTPChargers].Limit,
 				TTL:       itemsCacheCfg[utils.TBLTPChargers].TTL,
 				StaticTTL: itemsCacheCfg[utils.TBLTPChargers].StaticTTL,
 			},
-			utils.TBLTPDispatchers: &ltcache.CacheConfig{
+			utils.TBLTPDispatchers: {
 				MaxItems:  itemsCacheCfg[utils.TBLTPDispatchers].Limit,
 				TTL:       itemsCacheCfg[utils.TBLTPDispatchers].TTL,
 				StaticTTL: itemsCacheCfg[utils.TBLTPDispatchers].StaticTTL,
 			},
-			utils.TBLTPDispatcherHosts: &ltcache.CacheConfig{
+			utils.TBLTPDispatcherHosts: {
 				MaxItems:  itemsCacheCfg[utils.TBLTPDispatcherHosts].Limit,
 				TTL:       itemsCacheCfg[utils.TBLTPDispatcherHosts].TTL,
 				StaticTTL: itemsCacheCfg[utils.TBLTPDispatcherHosts].StaticTTL,
 			},
-			utils.CDRsTBL: &ltcache.CacheConfig{
+			utils.CDRsTBL: {
 				MaxItems:  itemsCacheCfg[utils.CDRsTBL].Limit,
 				TTL:       itemsCacheCfg[utils.CDRsTBL].TTL,
 				StaticTTL: itemsCacheCfg[utils.CDRsTBL].StaticTTL,
@@ -501,7 +501,7 @@ func (iDB *InternalDB) GetStorageType() string {
 }
 
 func (iDB *InternalDB) IsDBEmpty() (resp bool, err error) {
-	for cacheInstance, _ := range utils.CacheInstanceToPrefix {
+	for cacheInstance := range utils.CacheInstanceToPrefix {
 		if len(iDB.db.GetItemIDs(cacheInstance, utils.EmptyString)) != 0 {
 			return false, nil
 		}