Improving coverage at engine

2026-02-23 08:08:45 +05:00 · 2022-12-14 10:55:02 -05:00
parent 33635856c1
commit 505709b26f
5 changed files with 444 additions and 86 deletions
--- a/engine/actions_test.go
+++ b/engine/actions_test.go
@@ -2500,6 +2500,24 @@ func TestCgrRpcAction(t *testing.T) {
 	if trpcp.status != utils.OK {
 		t.Error("RPC not called!")
 	}
+	cfg := config.NewDefaultCGRConfig()
+	cfg.GeneralCfg().ReplyTimeout = 1000 * time.Millisecond
+	cfg.GeneralCfg().ConnectTimeout = 1000 * time.Millisecond
+	config.SetCgrConfig(cfg)
+	defer func() {
+		config.SetCgrConfig(config.NewDefaultCGRConfig())
+	}()
+	a = &Action{
+		ExtraParameters: `{"Address": "*json*localhost",
+	"Transport": "*gob",
+	"Method": "TestRPCParameters.Hopa",
+	"Attempts":1,
+	"Async" :false,
+	"Params": {"Name":"n", "Surname":"s", "Age":10.2}}`,
+	}
+	if err := cgrRPCAction(nil, a, nil, nil, nil); err == nil {
+		t.Error("error executing cgr action: ", err)
+	}
 }

 func TestValueFormulaDebit(t *testing.T) {
@@ -2822,6 +2840,10 @@ func BenchmarkUUID(b *testing.B) {

 func TestResetAccountCDR(t *testing.T) {
 	cfg := config.NewDefaultCGRConfig()
+	defer func() {
+		config.SetCgrConfig(config.NewDefaultCGRConfig())
+		SetCdrStorage(cdrStorage)
+	}()
 	idb := NewInternalDB(nil, nil, true, cfg.DataDbCfg().Items)
 	dm := NewDataManager(idb, cfg.CacheCfg(), nil)
 	fltrs := NewFilterS(cfg, nil, dm)
@@ -2867,9 +2889,14 @@ func TestResetAccountCDR(t *testing.T) {
 	}
 	if err := resetAccountCDR(nil, a, acs, fltrs, extraData); err == nil || err.Error() != "nil account" {
 		t.Errorf("expected <nil account> ,received <%+v>", err)
-	} else if err = resetAccountCDR(acc, a, acs, fltrs, extraData); err == nil {
+	} else if err = resetAccountCDR(acc, a, acs, fltrs, extraData); err == nil || err != utils.ErrNotFound {
 		t.Error(err)
 	}
+	SetCdrStorage(nil)
+	if err := resetAccountCDR(acc, a, acs, fltrs, extraData); err == nil || err.Error() != fmt.Sprintf("nil cdrStorage for %s action", utils.ToJSON(a)) {
+		t.Error(err)
+	}
+
 }

 func TestSetRecurrentAction(t *testing.T) {
@@ -3211,6 +3238,10 @@ func TestExportAction(t *testing.T) {
 		t.Errorf("received %v", err)
 	} else if err = export(nil, a, acs, nil, extraData); err != nil {
 		t.Errorf("received %v", err)
+	} else if err = export(nil, a, acs, nil, "test"); err != nil {
+		t.Error(err)
+	} else if err = export(nil, a, acs, nil, nil); err != nil {
+		t.Error(err)
 	}
 }
 func TestResetStatQueue(t *testing.T) {
--- a/engine/cdrs_test.go
+++ b/engine/cdrs_test.go
@@ -158,6 +158,8 @@ func TestCDRSV1ProcessEventNoTenant(t *testing.T) {

 	if err := cdrs.V1ProcessEvent(args, &reply); err != nil {
 		t.Error(err)
+	} else if reply != utils.OK {
+		t.Errorf("expected %v,received %v", utils.OK, reply)
 	}
 }

@@ -802,14 +804,18 @@ func TestV1ProcessEvent(t *testing.T) {
 	Cache.Clear(nil)
 	cfg := config.NewDefaultCGRConfig()
 	cfg.CdrsCfg().AttributeSConns = []string{utils.ConcatenatedKey(utils.MetaInternal, utils.AttributeSConnsCfg)}
+	cfg.CdrsCfg().ChargerSConns = []string{utils.ConcatenatedKey(utils.MetaInternal)}
 	cfg.CdrsCfg().StoreCdrs = true
-
 	db := NewInternalDB(nil, nil, true, cfg.DataDbCfg().Items)
 	dm := NewDataManager(db, cfg.CacheCfg(), nil)
-	ccMock := &ccMock{
+	clientconn := make(chan rpcclient.ClientConnector, 1)
+	clientconn <- &ccMock{
 		calls: map[string]func(args interface{}, reply interface{}) error{
 			utils.AttributeSv1ProcessEvent: func(args, reply interface{}) error {
-				rpl := &AttrSProcessEventReply{}
+				rpl := &AttrSProcessEventReply{
+					AlteredFields: []string{"*req.OfficeGroup"},
+					CGREvent:      &utils.CGREvent{},
+				}
 				*reply.(*AttrSProcessEventReply) = *rpl

 				return nil
@@ -819,9 +825,12 @@ func TestV1ProcessEvent(t *testing.T) {
 					{
 						ChargerSProfile:    "chrgs1",
 						AttributeSProfiles: []string{"attr1", "attr2"},
+						CGREvent:           &utils.CGREvent{},
 					}, {
-						ChargerSProfile:    "chrgs1",
+						ChargerSProfile: "chrgs1",
+
 						AttributeSProfiles: []string{"attr1", "attr2"},
+						CGREvent:           &utils.CGREvent{},
 					},
 				}
 				*reply.(*[]*ChrgSProcessEventReply) = rpl
@@ -829,9 +838,6 @@ func TestV1ProcessEvent(t *testing.T) {
 			},
 		},
 	}
-
-	clientconn := make(chan rpcclient.ClientConnector, 1)
-	clientconn <- ccMock
 	connMgr := NewConnManager(cfg, map[string]chan rpcclient.ClientConnector{
 		utils.ConcatenatedKey(utils.MetaInternal, utils.AttributeSConnsCfg): clientconn,
 	})
@@ -843,7 +849,7 @@ func TestV1ProcessEvent(t *testing.T) {
 		connMgr: connMgr,
 	}
 	arg := &ArgV1ProcessEvent{
-		Flags: []string{utils.MetaAttributes, utils.MetaExport, utils.MetaStore, utils.OptsThresholdS, utils.MetaThresholds, utils.MetaStats, utils.OptsChargerS, utils.MetaChargers, utils.OptsRALs, utils.MetaRALs, utils.OptsRerate, utils.MetaRerate, utils.OptsRefund, utils.MetaRefund},
+		Flags: []string{utils.MetaAttributes, utils.MetaStats, utils.MetaExport, utils.MetaStore, utils.OptsThresholdS, utils.MetaThresholds, utils.MetaStats, utils.OptsChargerS, utils.MetaChargers, utils.OptsRALs, utils.MetaRALs, utils.OptsRerate, utils.MetaRerate, utils.OptsRefund, utils.MetaRefund},
 		CGREvent: utils.CGREvent{
 			ID: "TestV1ProcessEventNoTenant",
 			Event: map[string]interface{}{
@@ -858,7 +864,8 @@ func TestV1ProcessEvent(t *testing.T) {
 			},
 		},
 	}
-	if err := cdrS.V1ProcessEvent(arg, utils.StringPointer("val")); err == nil || err != utils.ErrPartiallyExecuted {
+	var reply string
+	if err := cdrS.V1ProcessEvent(arg, &reply); err == nil || err != utils.ErrPartiallyExecuted {
 		t.Error(err)
 	}
 }
@@ -1643,8 +1650,15 @@ func TestCdrServerStoreSMCost(t *testing.T) {

 func TestCdrSRateCDR(t *testing.T) {
 	cfg := config.NewDefaultCGRConfig()
+	tmp := Cache
+	defer func() {
+		config.SetCgrConfig(config.NewDefaultCGRConfig())
+		Cache = tmp
+	}()
+	Cache.Clear(nil)
 	cfg.CdrsCfg().SMCostRetries = 1
 	cfg.CdrsCfg().ChargerSConns = []string{utils.ConcatenatedKey(utils.MetaInternal, utils.ChargerSConnsCfg)}
+	cfg.CdrsCfg().RaterConns = []string{utils.ConcatenatedKey(utils.MetaInternal, utils.MetaRALs)}
 	db := NewInternalDB(nil, nil, true, map[string]*config.ItemOpt{
 		utils.CacheSessionCostsTBL: {
 			Limit:     2,
@@ -1654,7 +1668,27 @@ func TestCdrSRateCDR(t *testing.T) {
 			Replicate: true,
 		},
 	})
-
+	clientConn := make(chan rpcclient.ClientConnector, 1)
+	clientConn <- &ccMock{
+		calls: map[string]func(args interface{}, reply interface{}) error{
+			utils.ResponderDebit: func(args, reply interface{}) error {
+				cc := &CallCost{
+					Category:    "generic",
+					Tenant:      "cgrates.org",
+					Subject:     "1001",
+					Account:     "1001",
+					Destination: "data",
+					ToR:         "*data",
+					Cost:        0,
+				}
+				*reply.(*CallCost) = *cc
+				return nil
+			},
+		},
+	}
+	connMgr := NewConnManager(cfg, map[string]chan rpcclient.ClientConnector{
+		utils.ConcatenatedKey(utils.MetaInternal, utils.MetaRALs): clientConn,
+	})
 	dm := NewDataManager(db, cfg.CacheCfg(), nil)
 	cdrS := &CDRServer{
 		cgrCfg:  cfg,
@@ -1697,7 +1731,48 @@ func TestCdrSRateCDR(t *testing.T) {
 			},
 		},
 	}
-	if _, err := cdrS.rateCDR(cdrOpts); err == nil {
+
+	if _, err := cdrS.rateCDR(cdrOpts); err != nil {
+		t.Error(err)
+	}
+
+	cdrOpts.ExtraFields = map[string]string{}
+	cdrOpts.Usage = 0
+	if _, err := cdrS.rateCDR(cdrOpts); err != nil {
+		t.Error(err)
+	}
+
+	cdrOpts.CostDetails = &EventCost{
+		CGRID:     "7636f3f1a06dffa038ba7900fb57f52d28830a24",
+		RunID:     utils.MetaDefault,
+		StartTime: time.Date(2018, 7, 27, 0, 59, 21, 0, time.UTC),
+		Usage:     utils.DurationPointer(2 * time.Second),
+		Charges: []*ChargingInterval{
+			{
+				RatingID: "cc68da4",
+				Increments: []*ChargingIncrement{
+					{
+						Usage:          102400,
+						AccountingID:   "0d87a64",
+						CompressFactor: 103,
+					},
+				},
+				CompressFactor: 1,
+			},
+		},
+		AccountSummary: &AccountSummary{
+			Tenant: "cgrates.org",
+			ID:     "dan",
+			BalanceSummaries: []*BalanceSummary{
+				{
+					UUID:  "9a767726-fe69-4940-b7bd-f43de9f0f8a5",
+					ID:    "addon_data",
+					Type:  utils.MetaData,
+					Value: 10726871040},
+			},
+		},
+	}
+	if _, err := cdrS.rateCDR(cdrOpts); err != nil {
 		t.Error(err)
 	}
 }
--- a/engine/datamanager_test.go
+++ b/engine/datamanager_test.go
@@ -40,7 +40,6 @@ func TestDmGetDestinationRemote(t *testing.T) {
 	cfg.DataDbCfg().RmtConns = []string{utils.ConcatenatedKey(utils.MetaInternal, utils.ReplicatorSv1)}
 	cfg.DataDbCfg().RmtConnID = "rmt"
 	cfg.GeneralCfg().NodeID = "node"
-
 	cfg.DataDbCfg().Items = map[string]*config.ItemOpt{
 		utils.CacheDestinations: {
 			Limit:   3,
@@ -662,7 +661,7 @@ func TestDmRemoveThreshold(t *testing.T) {
 		Cache = tmp
 		SetDataStorage(tmpDm)
 	}()
-	Cache.Clear(nil)
+
 	Cache.Clear(nil)
 	cfg.DataDbCfg().RplConns = []string{utils.ConcatenatedKey(utils.MetaInternal, utils.ReplicatorSv1)}
 	cfg.DataDbCfg().RplFiltered = true
@@ -707,3 +706,274 @@ func TestDmRemoveThreshold(t *testing.T) {
 		t.Error(err)
 	}
 }
+
+func TestDMReverseDestinationRemote(t *testing.T) {
+	cfg := config.NewDefaultCGRConfig()
+	tmpDm := dm
+	tmp := Cache
+	defer func() {
+		config.SetCgrConfig(config.NewDefaultCGRConfig())
+		Cache = tmp
+		SetDataStorage(tmpDm)
+	}()
+	Cache.Clear(nil)
+	cfg.DataDbCfg().RplConns = []string{utils.ConcatenatedKey(utils.MetaInternal, utils.ReplicatorSv1)}
+	cfg.DataDbCfg().RplFiltered = true
+	cfg.DataDbCfg().Items = map[string]*config.ItemOpt{
+		utils.CacheReverseDestinations: {
+			Limit:     3,
+			Replicate: true,
+			APIKey:    "key",
+			RouteID:   "route",
+		},
+	}
+	clientConn := make(chan rpcclient.ClientConnector, 1)
+	clientConn <- &ccMock{
+		calls: map[string]func(args interface{}, reply interface{}) error{
+			utils.ReplicatorSv1SetReverseDestination: func(args, reply interface{}) error {
+				dest, cancast := args.(Destination)
+				if !cancast {
+					return utils.ErrNotConvertible
+				}
+				dm.dataDB.SetReverseDestinationDrv(dest.Id, dest.Prefixes, utils.NonTransactional)
+				return nil
+			},
+		},
+	}
+	db := NewInternalDB(nil, nil, true, cfg.DataDbCfg().Items)
+	connMgr := NewConnManager(cfg, map[string]chan rpcclient.ClientConnector{
+		utils.ConcatenatedKey(utils.MetaInternal, utils.ReplicatorSv1): clientConn,
+	})
+	dm := NewDataManager(db, cfg.CacheCfg(), connMgr)
+	config.SetCgrConfig(cfg)
+	SetDataStorage(dm)
+	dest := &Destination{
+		Id: "nat", Prefixes: []string{"0257", "0256", "0723"},
+	}
+	if err := dm.SetReverseDestination(dest.Id, dest.Prefixes, utils.NonTransactional); err != nil {
+		t.Error(err)
+	}
+	exp := []string{"nat"}
+	for _, prf := range dest.Prefixes {
+		if val, err := dm.dataDB.GetReverseDestinationDrv(prf, utils.NonTransactional); err != nil {
+			t.Error(err)
+		} else if !reflect.DeepEqual(val, exp) {
+			t.Errorf("expected %v,received %v", exp, val)
+		}
+	}
+}
+
+func TestDMStatQueueRemote(t *testing.T) {
+	cfg := config.NewDefaultCGRConfig()
+	tmpDm := dm
+	tmp := Cache
+	defer func() {
+		config.SetCgrConfig(config.NewDefaultCGRConfig())
+		Cache = tmp
+		SetDataStorage(tmpDm)
+	}()
+	Cache.Clear(nil)
+	cfg.DataDbCfg().RplConns = []string{utils.ConcatenatedKey(utils.MetaInternal, utils.ReplicatorSv1)}
+	cfg.DataDbCfg().RplFiltered = true
+	cfg.DataDbCfg().Items = map[string]*config.ItemOpt{
+		utils.CacheStatQueues: {
+			Limit:     3,
+			Replicate: true,
+			APIKey:    "key",
+			RouteID:   "route",
+		},
+	}
+	clientConn := make(chan rpcclient.ClientConnector, 1)
+	clientConn <- &ccMock{
+		calls: map[string]func(args interface{}, reply interface{}) error{
+			utils.ReplicatorSv1SetStatQueue: func(args, reply interface{}) error {
+				sqApiOpts, cancast := args.(StatQueueWithAPIOpts)
+				if !cancast {
+					return utils.ErrNotConvertible
+				}
+				dm.dataDB.SetStatQueueDrv(nil, sqApiOpts.StatQueue)
+				return nil
+			},
+			utils.ReplicatorSv1RemoveStatQueue: func(args, reply interface{}) error {
+				tntIDApiOpts, cancast := args.(utils.TenantIDWithAPIOpts)
+				if !cancast {
+					return utils.ErrNotConvertible
+				}
+				dm.dataDB.RemStatQueueDrv(tntIDApiOpts.Tenant, tntIDApiOpts.ID)
+				return nil
+			},
+		},
+	}
+	db := NewInternalDB(nil, nil, true, cfg.DataDbCfg().Items)
+	connMgr := NewConnManager(cfg, map[string]chan rpcclient.ClientConnector{
+		utils.ConcatenatedKey(utils.MetaInternal, utils.ReplicatorSv1): clientConn,
+	})
+	dm := NewDataManager(db, cfg.CacheCfg(), connMgr)
+	config.SetCgrConfig(cfg)
+	SetDataStorage(dm)
+	sq := &StatQueue{
+		Tenant:  "cgrates.org",
+		ID:      "SQ1",
+		SQItems: []SQItem{},
+		SQMetrics: map[string]StatMetric{
+			utils.MetaTCD: &StatTCD{
+				Events: make(map[string]*DurationWithCompress),
+			},
+		},
+	}
+	if err := dm.SetStatQueue(sq); err != nil {
+		t.Error(err)
+	}
+	if val, err := dm.GetStatQueue(sq.Tenant, sq.ID, true, false, utils.NonTransactional); err != nil {
+		t.Error(err)
+	} else if !reflect.DeepEqual(val, sq) {
+		t.Errorf("expected %v,received %v", utils.ToJSON(sq), utils.ToJSON(val))
+	}
+	if err = dm.RemoveStatQueue(sq.Tenant, sq.ID); err != nil {
+		t.Error(err)
+	}
+	if _, has := db.db.Get(utils.CacheStatQueues, utils.ConcatenatedKey(sq.Tenant, sq.ID)); has {
+		t.Error("should been removed")
+	}
+}
+
+func TestDmTimingR(t *testing.T) {
+	cfg := config.NewDefaultCGRConfig()
+	tmpDm := dm
+	tmp := Cache
+	defer func() {
+		config.SetCgrConfig(config.NewDefaultCGRConfig())
+		Cache = tmp
+		SetDataStorage(tmpDm)
+	}()
+	Cache.Clear(nil)
+	cfg.DataDbCfg().RplConns = []string{utils.ConcatenatedKey(utils.MetaInternal, utils.ReplicatorSv1)}
+	cfg.DataDbCfg().RplFiltered = true
+	cfg.DataDbCfg().Items = map[string]*config.ItemOpt{
+		utils.CacheTimings: {
+			Limit:     3,
+			Replicate: true,
+			APIKey:    "key",
+			RouteID:   "route",
+		},
+	}
+	clientConn := make(chan rpcclient.ClientConnector, 1)
+	clientConn <- &ccMock{
+		calls: map[string]func(args interface{}, reply interface{}) error{
+			utils.ReplicatorSv1SetTiming: func(args, reply interface{}) error {
+				tpTimingApiOpts, cancast := args.(utils.TPTimingWithAPIOpts)
+				if !cancast {
+					return utils.ErrNotConvertible
+				}
+				dm.DataDB().SetTimingDrv(tpTimingApiOpts.TPTiming)
+				return nil
+			},
+			utils.ReplicatorSv1RemoveTiming: func(args, reply interface{}) error {
+				id, cancast := args.(string)
+				if !cancast {
+					return utils.ErrNotConvertible
+				}
+				dm.DataDB().RemoveTimingDrv(id)
+				return nil
+			},
+		},
+	}
+	db := NewInternalDB(nil, nil, true, cfg.DataDbCfg().Items)
+	connMgr := NewConnManager(cfg, map[string]chan rpcclient.ClientConnector{
+		utils.ConcatenatedKey(utils.MetaInternal, utils.ReplicatorSv1): clientConn,
+	})
+	dm := NewDataManager(db, cfg.CacheCfg(), connMgr)
+	config.SetCgrConfig(cfg)
+	SetDataStorage(dm)
+	tp := &utils.TPTiming{
+		ID:        "MIDNIGHT",
+		Years:     utils.Years{2020, 2019},
+		Months:    utils.Months{1, 2, 3, 4},
+		MonthDays: utils.MonthDays{5, 6, 7, 8},
+		WeekDays:  utils.WeekDays{0, 1, 2, 3},
+		StartTime: "00:00:00",
+		EndTime:   "00:00:01",
+	}
+	if err := dm.SetTiming(tp); err != nil {
+		t.Error(err)
+	}
+	if val, err := dm.GetTiming(tp.ID, false, utils.NonTransactional); err != nil {
+		t.Error(err)
+	} else if !reflect.DeepEqual(tp, val) {
+		t.Errorf("expected %v,received %v", utils.ToJSON(tp), utils.ToJSON(val))
+	}
+	if err = dm.RemoveTiming(tp.ID, utils.NonTransactional); err != nil {
+		t.Error(err)
+	}
+}
+
+func TestDMSetActionTriggers(t *testing.T) {
+	cfg := config.NewDefaultCGRConfig()
+	tmpDm := dm
+	tmp := Cache
+	defer func() {
+		config.SetCgrConfig(config.NewDefaultCGRConfig())
+		Cache = tmp
+		SetDataStorage(tmpDm)
+	}()
+	Cache.Clear(nil)
+	cfg.DataDbCfg().RplConns = []string{utils.ConcatenatedKey(utils.MetaInternal, utils.ReplicatorSv1)}
+	cfg.DataDbCfg().RplFiltered = true
+	cfg.DataDbCfg().Items = map[string]*config.ItemOpt{
+		utils.CacheActionTriggers: {
+			Limit:     3,
+			Replicate: true,
+			APIKey:    "key",
+			RouteID:   "route",
+		},
+	}
+	clientConn := make(chan rpcclient.ClientConnector, 1)
+	clientConn <- &ccMock{
+		calls: map[string]func(args interface{}, reply interface{}) error{
+			utils.ReplicatorSv1SetActionTriggers: func(args, reply interface{}) error {
+				setActTrgAOpts, cancast := args.(SetActionTriggersArgWithAPIOpts)
+				if !cancast {
+					return utils.ErrNotConvertible
+				}
+				dm.DataDB().SetActionTriggersDrv(setActTrgAOpts.Key, setActTrgAOpts.Attrs)
+				return nil
+			},
+			utils.ReplicatorSv1RemoveActionTriggers: func(args, reply interface{}) error {
+				strApiOpts, cancast := args.(utils.StringWithAPIOpts)
+				if !cancast {
+					return utils.ErrNotConvertible
+				}
+				dm.DataDB().RemoveActionTriggersDrv(strApiOpts.Arg)
+				return nil
+			},
+		},
+	}
+	db := NewInternalDB(nil, nil, true, cfg.DataDbCfg().Items)
+	connMgr := NewConnManager(cfg, map[string]chan rpcclient.ClientConnector{
+		utils.ConcatenatedKey(utils.MetaInternal, utils.ReplicatorSv1): clientConn,
+	})
+	dm := NewDataManager(db, cfg.CacheCfg(), connMgr)
+	config.SetCgrConfig(cfg)
+	SetDataStorage(dm)
+	attrs := ActionTriggers{
+		&ActionTrigger{
+			Balance: &BalanceFilter{
+				Type: utils.StringPointer(utils.MetaMonetary)},
+			ThresholdValue: 2, ThresholdType: utils.TriggerMaxEventCounter,
+			ActionsID: "TEST_ACTIONS"}}
+	if err := dm.SetActionTriggers("act_ID", attrs); err != nil {
+		t.Error(err)
+	}
+	if val, err := dm.GetActionTriggers("act_ID", false, utils.NonTransactional); err != nil {
+		t.Error(err)
+	} else if !reflect.DeepEqual(attrs, val) {
+		t.Errorf("expected %v,received %v", utils.ToJSON(attrs), utils.ToJSON(val))
+	}
+
+	if err = dm.RemoveActionTriggers("act_ID", utils.NonTransactional); err != nil {
+		t.Error(err)
+	}
+	if _, has := db.db.Get(utils.CacheActionTriggers, "act_ID"); has {
+		t.Error("should been removed")
+	}
+}
--- a/engine/dynamicdp_test.go
+++ b/engine/dynamicdp_test.go
@@ -72,8 +72,18 @@ func TestDpLibPhoneNumber(t *testing.T) {
 	if _, err := dDP.fieldAsInterface([]string{}); err == nil || err.Error() != fmt.Sprintf("invalid field path <%+v> for libphonenumberDP", []string{}) {
 		t.Error(err)
 	}
-	if _, err := dDP.fieldAsInterface([]string{"CountryCode"}); err != nil {
+	val, err := dDP.fieldAsInterface([]string{"CountryCode"})
+	if err != nil {
 		t.Error(err)
 	}
+	if err != nil {
+		t.Error(err)
+	}
+	exp := int32(355)
+	if nationalNumber, cancast := val.(int32); !cancast {
+		t.Error("can't convert")
+	} else if nationalNumber != exp {
+		t.Errorf("expected %v,received %v", exp, nationalNumber)
+	}

 }
--- a/engine/exportrequest_test.go
+++ b/engine/exportrequest_test.go
@@ -551,79 +551,51 @@ func TestExportRequestCompose(t *testing.T) {

 }

-// func TestExportRequestSetFields(t *testing.T) {
-// 	Cache.Clear(nil)
-// 	onm := utils.NewOrderedNavigableMap()
-// 	fullPath := &utils.FullPath{
-// 		PathSlice: []string{utils.MetaReq, utils.MetaTenant},
-// 		Path:      utils.MetaTenant,
-// 	}
-// 	val := &utils.DataLeaf{
-// 		Data: "value1",
-// 	}
-// 	onm.Append(fullPath, val)
-// 	cfg := config.NewDefaultCGRConfig()
-// 	cfg.DataDbCfg().Items = map[string]*config.ItemOpt{
-// 		utils.CacheFilters: {
-// 			Limit:     4,
-// 			TTL:       5,
-// 			StaticTTL: true,
-// 		},
-// 		utils.CacheUCH: {
-// 			Limit:     4,
-// 			TTL:       5,
-// 			StaticTTL: true,
-// 		},
-// 	}
-// 	cfg.FilterSCfg().ResourceSConns = []string{utils.ConcatenatedKey(utils.MetaInternal, utils.ResourceSConnsCfg)}
-// 	cfg.FilterSCfg().StatSConns = []string{utils.ConcatenatedKey(utils.MetaInternal, utils.StatSConnsCfg)}
-// 	cfg.FilterSCfg().ApierSConns = []string{utils.ConcatenatedKey(utils.MetaInternal, utils.ApierSConnsCfg)}
-// 	db := NewInternalDB(nil, nil, true, cfg.DataDbCfg().Items)
+func TestExportRequestSetFields(t *testing.T) {
+	Cache.Clear(nil)
+	onm := utils.NewOrderedNavigableMap()
+	fullPath := &utils.FullPath{
+		PathSlice: []string{utils.MetaReq, utils.MetaAccount},
+		Path:      utils.MetaReq + utils.MetaAccount,
+	}
+	val := &utils.DataLeaf{
+		Data: "value1",
+	}
+	onm.Append(fullPath, val)
+	cfg := config.NewDefaultCGRConfig()

-// 	dm := NewDataManager(db, config.CgrConfig().CacheCfg(), nil)
-// 	eeR := &ExportRequest{
-// 		inData: map[string]utils.DataStorage{
-// 			utils.MetaReq: utils.MapStorage{
-// 				"Account": "1001",
-// 				"Usage":   "10m",
-// 			},
-// 			utils.MetaOpts: utils.MapStorage{
-// 				"*opts": "val",
-// 			},
-// 		},
-// 		filterS: NewFilterS(cfg, nil, dm),
-// 		tnt:     "cgrates.org",
-// 		ExpData: map[string]*utils.OrderedNavigableMap{
-// 			utils.MetaReq: onm,
-// 		},
-// 	}
-// 	fctTemp := []*config.FCTemplate{
-// 		{
-// 			Type:       utils.MetaFiller,
-// 			Value:      config.NewRSRParsersMustCompile("*month_endTest", utils.InfieldSep),
-// 			Layout:     "“Mon Jan _2 15:04:05 2006”",
-// 			Timezone:   "Local",
-// 			MaskLen:    3,
-// 			MaskDestID: "dest1",
-// 			Filters:    []string{"filter1"},
-// 			Path:       "<*uch;*opts>",
-// 		},
-// 	}
+	db := NewInternalDB(nil, nil, true, cfg.DataDbCfg().Items)

-// 	Cache.Set(utils.CacheFilters, utils.ConcatenatedKey(eeR.tnt, fctTemp[0].Filters[0]), &Filter{
-// 		Tenant: "cgrates.org",
-// 		ID:     "FLTR_2",
-// 		Rules:  []*FilterRule{
-// 			// {
-// 			// 	Type:    utils.MetaPrefix,
-// 			// 	Element: utils.DynamicDataPrefix + utils.MetaReq + utils.NestingSep + utils.AccountField,
-// 			// 	Values:  []string{"1001"},
-// 			// },
-// 		}}, []string{}, true, utils.NonTransactional)
-// 	if err = eeR.SetFields(fctTemp); err != nil {
-// 		t.Error(err)
-// 	}
-// }
+	dm := NewDataManager(db, config.CgrConfig().CacheCfg(), nil)
+	eeR := &ExportRequest{
+		inData: map[string]utils.DataStorage{
+			utils.MetaReq: utils.MapStorage{
+				"Account": "1001",
+				"Usage":   "10m",
+			},
+			utils.MetaOpts: utils.MapStorage{
+				"*opts": "val",
+			},
+		},
+		filterS: NewFilterS(cfg, nil, dm),
+		tnt:     "cgrates.org",
+		ExpData: map[string]*utils.OrderedNavigableMap{
+			utils.MetaReq: onm,
+		},
+	}
+	fctTemp := []*config.FCTemplate{
+		{
+			Type:     utils.MetaComposed,
+			Value:    config.NewRSRParsersMustCompile("1003", utils.InfieldSep),
+			Timezone: "Local",
+			Path:     "<*uch;*opts>",
+		},
+	}
+
+	if err = eeR.SetFields(fctTemp); err == nil || err.Error() != fmt.Sprint("unsupported field prefix: <*uch*opts> when set field") {
+		t.Error(err)
+	}
+}

 func TestExportRequestFieldAsString(t *testing.T) {
 	inData := map[string]utils.DataStorage{