From 505709b26f77243059382bc80095692ad9d6060c Mon Sep 17 00:00:00 2001 From: gezimbll Date: Wed, 14 Dec 2022 10:55:02 -0500 Subject: [PATCH] Improving coverage at engine --- engine/actions_test.go | 33 ++++- engine/cdrs_test.go | 97 +++++++++++-- engine/datamanager_test.go | 274 ++++++++++++++++++++++++++++++++++- engine/dynamicdp_test.go | 12 +- engine/exportrequest_test.go | 114 ++++++--------- 5 files changed, 444 insertions(+), 86 deletions(-) diff --git a/engine/actions_test.go b/engine/actions_test.go index 14b22c211..db7fbded3 100644 --- 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 ,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) { diff --git a/engine/cdrs_test.go b/engine/cdrs_test.go index 2377085bf..418f9f341 100644 --- 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) } } diff --git a/engine/datamanager_test.go b/engine/datamanager_test.go index da0976264..3c68dcf09 100644 --- 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") + } +} diff --git a/engine/dynamicdp_test.go b/engine/dynamicdp_test.go index 041e777d2..9b30b0f11 100644 --- 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) + } } diff --git a/engine/exportrequest_test.go b/engine/exportrequest_test.go index 0ce1fcb8f..767dd88ea 100644 --- 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{