From f626bdde2d0de987954da824ead8e0175f4bb86b Mon Sep 17 00:00:00 2001 From: gezimbll Date: Tue, 10 Jan 2023 10:47:25 -0500 Subject: [PATCH] Improving coverage at engine --- engine/cdrs_test.go | 2 +- engine/datamanager_test.go | 305 +++++++++++++++++++++++++++++++------ engine/routes_test.go | 266 +++++++++++++++++++++++++++----- engine/tpreader_test.go | 21 --- 4 files changed, 485 insertions(+), 109 deletions(-) diff --git a/engine/cdrs_test.go b/engine/cdrs_test.go index ddd82eb0b..b28c25f4b 100644 --- a/engine/cdrs_test.go +++ b/engine/cdrs_test.go @@ -2171,7 +2171,7 @@ func TestCDRServerListenAndServe2(t *testing.T) { } stopChan := make(chan struct{}, 1) go func() { - time.Sleep(20 * time.Millisecond) + time.Sleep(40 * time.Millisecond) stopChan <- struct{}{} }() diff --git a/engine/datamanager_test.go b/engine/datamanager_test.go index e03d1705f..d62044054 100644 --- a/engine/datamanager_test.go +++ b/engine/datamanager_test.go @@ -219,14 +219,15 @@ func TestDMGetThresholdRemote(t *testing.T) { }() Cache.Clear(nil) cfg.DataDbCfg().RmtConns = []string{utils.ConcatenatedKey(utils.MetaInternal, utils.ReplicatorSv1)} - cfg.DataDbCfg().RmtConnID = "rmt" - cfg.GeneralCfg().NodeID = "node" + cfg.CacheCfg().Partitions[utils.CacheThresholds].Replicate = true + cfg.CacheCfg().ReplicationConns = []string{utils.ConcatenatedKey(utils.MetaInternal, utils.MetaCaches)} cfg.DataDbCfg().Items = map[string]*config.ItemOpt{ utils.CacheThresholds: { - Limit: 3, - Remote: true, - APIKey: "key", - RouteID: "route", + Limit: 3, + Remote: true, + APIKey: "key", + RouteID: "route", + Replicate: true, }, } clientConn := make(chan rpcclient.ClientConnector, 1) @@ -241,11 +242,16 @@ func TestDMGetThresholdRemote(t *testing.T) { *reply.(**Threshold) = rpl return nil }, + utils.CacheSv1ReplicateSet: func(args, reply interface{}) error { + + return errors.New("Can't Replicate") + }, }, } db := NewInternalDB(nil, nil, true, cfg.DataDbCfg().Items) connMgr := NewConnManager(cfg, map[string]chan rpcclient.ClientConnector{ utils.ConcatenatedKey(utils.MetaInternal, utils.ReplicatorSv1): clientConn, + utils.ConcatenatedKey(utils.MetaInternal, utils.MetaCaches): clientConn, }) dm := NewDataManager(db, cfg.CacheCfg(), connMgr) config.SetCgrConfig(cfg) @@ -260,7 +266,65 @@ func TestDMGetThresholdRemote(t *testing.T) { } else if !reflect.DeepEqual(exp, val) { t.Errorf("expected %+v,received %+v", utils.ToJSON(exp), utils.ToJSON(val)) } + Cache.Set(utils.CacheThresholds, utils.ConcatenatedKey("cgrates.org", "THD_ACNT_1001"), nil, []string{}, false, utils.NonTransactional) + if _, err := dm.GetThreshold("cgrates.org", "THD_ACNT_1001", true, true, utils.NonTransactional); err != nil { + t.Error(err) + } + SetConnManager(connMgr) + Cache = NewCacheS(cfg, dm, nil) + if _, err := dm.GetThreshold("cgrates", "id2", false, true, utils.NonTransactional); err == nil || err.Error() != "Can't Replicate" { + t.Error(err) + } } + +func TestDMGetThresholdRemoteErr(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().RmtConns = []string{utils.ConcatenatedKey(utils.MetaInternal, utils.ReplicatorSv1)} + cfg.CacheCfg().Partitions[utils.CacheThresholds].Replicate = true + cfg.CacheCfg().ReplicationConns = []string{utils.ConcatenatedKey(utils.MetaInternal, utils.MetaCaches)} + cfg.DataDbCfg().Items = map[string]*config.ItemOpt{ + utils.CacheThresholds: { + Limit: 3, + Remote: true, + APIKey: "key", + RouteID: "route", + Replicate: true, + }, + } + clientConn := make(chan rpcclient.ClientConnector, 1) + clientConn <- &ccMock{ + calls: map[string]func(args interface{}, reply interface{}) error{ + utils.ReplicatorSv1GetThreshold: func(args, reply interface{}) error { + return utils.ErrNotFound + }, + utils.CacheSv1ReplicateSet: func(args, reply interface{}) error { + return errors.New("Can't Replicate") + }, + }, + } + db := NewInternalDB(nil, nil, true, cfg.DataDbCfg().Items) + connMgr := NewConnManager(cfg, map[string]chan rpcclient.ClientConnector{ + utils.ConcatenatedKey(utils.MetaInternal, utils.ReplicatorSv1): clientConn, + utils.ConcatenatedKey(utils.MetaInternal, utils.MetaCaches): clientConn, + }) + dm := NewDataManager(db, cfg.CacheCfg(), connMgr) + config.SetCgrConfig(cfg) + SetDataStorage(dm) + SetConnManager(connMgr) + Cache = NewCacheS(cfg, dm, nil) + if _, err := dm.GetThreshold("cgrates", "id2", false, true, utils.NonTransactional); err == nil || err.Error() != "Can't Replicate" { + t.Error(err) + } +} + func TestDMGetThresholdProfileRemote(t *testing.T) { cfg := config.NewDefaultCGRConfig() tmpDm := dm @@ -272,15 +336,15 @@ func TestDMGetThresholdProfileRemote(t *testing.T) { }() Cache.Clear(nil) cfg.DataDbCfg().RmtConns = []string{utils.ConcatenatedKey(utils.MetaInternal, utils.ReplicatorSv1)} - cfg.DataDbCfg().RmtConnID = "rmt" - cfg.GeneralCfg().NodeID = "node" - + cfg.CacheCfg().Partitions[utils.CacheThresholdProfiles].Replicate = true + cfg.CacheCfg().ReplicationConns = []string{utils.ConcatenatedKey(utils.MetaInternal, utils.MetaCaches)} cfg.DataDbCfg().Items = map[string]*config.ItemOpt{ utils.CacheThresholdProfiles: { - Limit: 3, - Remote: true, - APIKey: "key", - RouteID: "route", + Limit: 3, + Remote: true, + APIKey: "key", + RouteID: "route", + Replicate: true, }, } clientConn := make(chan rpcclient.ClientConnector, 1) @@ -294,11 +358,16 @@ func TestDMGetThresholdProfileRemote(t *testing.T) { *reply.(**ThresholdProfile) = rpl return nil }, + utils.CacheSv1ReplicateSet: func(args, reply interface{}) error { + + return errors.New("Can't Replicate") + }, }, } db := NewInternalDB(nil, nil, true, cfg.DataDbCfg().Items) connMgr := NewConnManager(cfg, map[string]chan rpcclient.ClientConnector{ utils.ConcatenatedKey(utils.MetaInternal, utils.ReplicatorSv1): clientConn, + utils.ConcatenatedKey(utils.MetaInternal, utils.MetaCaches): clientConn, }) dm := NewDataManager(db, cfg.CacheCfg(), connMgr) config.SetCgrConfig(cfg) @@ -312,6 +381,62 @@ func TestDMGetThresholdProfileRemote(t *testing.T) { } else if !reflect.DeepEqual(exp, val) { t.Errorf("expected %+v,received %+v", utils.ToJSON(exp), utils.ToJSON(val)) } + Cache = NewCacheS(cfg, dm, nil) + SetConnManager(connMgr) + if _, err := dm.GetThresholdProfile("cgrates", "id2", false, true, utils.NonTransactional); err == nil || err.Error() != "Can't Replicate" { + t.Error(err) + } +} +func TestDMGetThresholdProfileRemoteErr(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().RmtConns = []string{utils.ConcatenatedKey(utils.MetaInternal, utils.ReplicatorSv1)} + cfg.CacheCfg().Partitions[utils.CacheThresholdProfiles].Replicate = true + cfg.CacheCfg().ReplicationConns = []string{utils.ConcatenatedKey(utils.MetaInternal, utils.MetaCaches)} + cfg.DataDbCfg().Items = map[string]*config.ItemOpt{ + utils.CacheThresholdProfiles: { + Limit: 3, + Remote: true, + APIKey: "key", + RouteID: "route", + Replicate: true, + }, + } + clientConn := make(chan rpcclient.ClientConnector, 1) + clientConn <- &ccMock{ + calls: map[string]func(args interface{}, reply interface{}) error{ + utils.ReplicatorSv1GetThresholdProfile: func(args, reply interface{}) error { + return utils.ErrNotFound + }, + utils.CacheSv1ReplicateSet: func(args, reply interface{}) error { + return errors.New("Can't Replicate") + }, + }, + } + db := NewInternalDB(nil, nil, true, cfg.DataDbCfg().Items) + connMgr := NewConnManager(cfg, map[string]chan rpcclient.ClientConnector{ + utils.ConcatenatedKey(utils.MetaInternal, utils.ReplicatorSv1): clientConn, + utils.ConcatenatedKey(utils.MetaInternal, utils.MetaCaches): clientConn, + }) + dm := NewDataManager(db, cfg.CacheCfg(), connMgr) + config.SetCgrConfig(cfg) + SetDataStorage(dm) + SetConnManager(connMgr) + Cache = NewCacheS(cfg, dm, nil) + if _, err := dm.GetThresholdProfile("cgrates", "id2", false, true, utils.NonTransactional); err == nil || err.Error() != "Can't Replicate" { + t.Error(err) + } + var dm2 *DataManager + if _, err := dm2.GetThresholdProfile("cgrates", "id2", false, true, utils.NonTransactional); err == nil || err != utils.ErrNoDatabaseConn { + t.Error(err) + } } func TestDMGetStatQueue(t *testing.T) { @@ -1736,6 +1861,8 @@ func TestGetActionTriggers(t *testing.T) { Cache.Clear(nil) cfg.DataDbCfg().RmtConns = []string{utils.ConcatenatedKey(utils.MetaInternal, utils.ReplicatorSv1)} cfg.DataDbCfg().RplFiltered = true + cfg.CacheCfg().ReplicationConns = []string{utils.ConcatenatedKey(utils.MetaInternal, utils.MetaCaches)} + cfg.CacheCfg().Partitions[utils.CacheActionTriggers].Replicate = true cfg.DataDbCfg().Items = map[string]*config.ItemOpt{ utils.CacheActionTriggers: { Limit: 3, @@ -1762,11 +1889,16 @@ func TestGetActionTriggers(t *testing.T) { *reply.(*ActionTriggers) = aT return nil }, + utils.CacheSv1ReplicateSet: func(args, reply interface{}) error { + + return errors.New("Can't Replicate") + }, }, } db := NewInternalDB(nil, nil, true, cfg.DataDbCfg().Items) connMgr := NewConnManager(cfg, map[string]chan rpcclient.ClientConnector{ utils.ConcatenatedKey(utils.MetaInternal, utils.ReplicatorSv1): clientConn, + utils.ConcatenatedKey(utils.MetaInternal, utils.MetaCaches): clientConn, }) dm := NewDataManager(db, cfg.CacheCfg(), connMgr) config.SetCgrConfig(cfg) @@ -1777,6 +1909,12 @@ func TestGetActionTriggers(t *testing.T) { } else if !reflect.DeepEqual(val, aT) { t.Errorf("Expected %v,Received %v", utils.ToJSON(aT), utils.ToJSON(val)) } + SetConnManager(connMgr) + Cache = NewCacheS(cfg, dm, nil) + if _, err := dm.GetActionTriggers(aT[0].ID, false, utils.NonTransactional); err == nil { + t.Error(err) + } + } func TestGetActionTriggersErr(t *testing.T) { @@ -1834,7 +1972,8 @@ func TestGetActionTriggersErr(t *testing.T) { t.Error(err) } SetConnManager(connMgr1) - if _, err := dm.GetActionTriggers(aT[0].ID, true, utils.NonTransactional); err == nil || err != utils.ErrNotFound { + Cache = NewCacheS(cfg, dm, nil) + if _, err := dm.GetActionTriggers(aT[0].ID, true, utils.NonTransactional); err == nil || err.Error() != "Can't Replicate" { t.Error(err) } var dm2 *DataManager @@ -3271,7 +3410,7 @@ func TestDMRatingProfile(t *testing.T) { // dataDB := NewInternalDB(nil, nil, true, cfg.DataDbCfg().Items) // dm := NewDataManager(dataDB, cfg.CacheCfg(), nil) // oldFlt := &Filter{ -// Tenant: cfg.GeneralCfg().DefaultTenant, +// Tenant: "cgrates.org", // ID: "DISPATCHER_FLTR1", // Rules: []*FilterRule{{Type: utils.MetaString, Element: "~*req.Destination", Values: []string{"ACC1", "ACC2", "~*req.Account"}}}, // } @@ -3283,7 +3422,7 @@ func TestDMRatingProfile(t *testing.T) { // } // disp := &DispatcherProfile{ -// Tenant: cfg.GeneralCfg().DefaultTenant, +// Tenant: "cgrates.org", // ID: "Dsp", // Subsystems: []string{"*any"}, // FilterIDs: []string{"DISPATCHER_FLTR1"}, @@ -3303,14 +3442,14 @@ func TestDMRatingProfile(t *testing.T) { // }, // }, // } -// if err := dm.SetDispatcherHost(disp.); err != nil { +// if err := dm.SetDispatcherProfile(disp, true); err != nil { // t.Error(err) // } // expindx := map[string]utils.StringSet{ // "*string:*req.Destination": {"Dsp": {}}, // } -// if getidx, err := dm.GetIndexes(utils.CacheDispatcherFilterIndexes, cfg.GeneralCfg().DefaultTenant, utils.EmptyString, true, true); err != nil { +// if getidx, err := dm.GetIndexes(utils.CacheDispatcherFilterIndexes, "cgrates.org", utils.EmptyString, true, true); err != nil { // t.Error(err) // } else if !reflect.DeepEqual(expindx, getidx) { // t.Errorf("Expected %v, Received %v", utils.ToJSON(expindx), utils.ToJSON(getidx)) @@ -3762,49 +3901,125 @@ func TestDMAttributeProfile(t *testing.T) { } } -func TestUpdateFilterResourceIndex(t *testing.T) { +func TestUpdateFilterResourceIndexErr(t *testing.T) { tmp := Cache - tmpDm := dm defer func() { Cache = tmp - dm = tmpDm - config.SetCgrConfig(config.NewDefaultCGRConfig()) }() Cache.Clear(nil) cfg := config.NewDefaultCGRConfig() dataDB := NewInternalDB(nil, nil, true, cfg.DataDbCfg().Items) dm := NewDataManager(dataDB, cfg.CacheCfg(), nil) + dm.dataDB = &DataDBMock{ + GetIndexesDrvF: func(idxItmType, tntCtx, idxKey string) (indexes map[string]utils.StringSet, err error) { + return map[string]utils.StringSet{ + utils.CacheResourceFilterIndexes: { + "ATTR_TEST": {}, + }, + }, nil + }, + } oldFlt := &Filter{ Tenant: "cgrates.org", ID: "RSC_FLTR1", Rules: []*FilterRule{{Type: utils.MetaString, Element: "~*req.Destination", Values: []string{"ACC1", "ACC2", "~*req.Account"}}}, } - if err := oldFlt.Compile(); err != nil { - t.Error(err) + newFlt := &Filter{ + Tenant: "cgrates.org", + ID: "RSC_FLTR1", + Rules: []*FilterRule{ + { + Element: "~*req.Account", + Type: utils.MetaString, + Values: []string{"1001", "1002"}, + }, + }} + if err := UpdateFilterIndex(dm, oldFlt, newFlt); err != utils.ErrNotImplemented { + t.Errorf("Expected error <%v>, Received error <%v>", utils.ErrNotImplemented, err) } - if err := dm.SetFilter(oldFlt, true); err != nil { - t.Error(err) - } - - rs := &ResourceProfile{ - Tenant: "cgrates.org", - ID: "RES_ULTIMITED", - FilterIDs: []string{"RSC_FLTR1"}, - ActivationInterval: &utils.ActivationInterval{ - ActivationTime: time.Date(2014, 7, 14, 14, 25, 0, 0, time.UTC), +} +func TestUpdateFilterRouteIndexErr(t *testing.T) { + tmp := Cache + defer func() { + Cache = tmp + }() + Cache.Clear(nil) + cfg := config.NewDefaultCGRConfig() + dataDB := NewInternalDB(nil, nil, true, cfg.DataDbCfg().Items) + dm := NewDataManager(dataDB, cfg.CacheCfg(), nil) + dm.dataDB = &DataDBMock{ + GetIndexesDrvF: func(idxItmType, tntCtx, idxKey string) (indexes map[string]utils.StringSet, err error) { + return map[string]utils.StringSet{ + utils.CacheRouteFilterIndexes: { + "ATTR_TEST": {}, + }, + }, nil }, } - if err := dm.SetResourceProfile(rs, true); err != nil { - t.Error(err) + oldFlt := &Filter{ + Tenant: "cgrates.org", + ID: "FLTR_SUPP_2", + Rules: []*FilterRule{{ + Type: utils.MetaString, + Element: "~*req.Route", + Values: []string{"RouteProfile2"}, + }}, } - expindx := map[string]utils.StringSet{ - "*string:*req.Destination:ACC1": {"RES_ULTIMITED": {}}, - "*string:*req.Destination:ACC2": {"RES_ULTIMITED": {}}, + newFlt := &Filter{ + Tenant: "cgrates.org", + ID: "FLTR_SUPP_2", + Rules: []*FilterRule{ + { + Type: utils.MetaGreaterOrEqual, + Element: "~*req.PddInterval", + Values: []string{(time.Second).String()}, + }, + }} + if err := UpdateFilterIndex(dm, oldFlt, newFlt); err != utils.ErrNotImplemented { + t.Errorf("Expected error <%v>, Received error <%v>", utils.ErrNotImplemented, err) + } +} + +func TestUpdateFilterChargersIndexErr(t *testing.T) { + tmp := Cache + defer func() { + Cache = tmp + }() + Cache.Clear(nil) + cfg := config.NewDefaultCGRConfig() + dataDB := NewInternalDB(nil, nil, true, cfg.DataDbCfg().Items) + dm := NewDataManager(dataDB, cfg.CacheCfg(), nil) + dm.dataDB = &DataDBMock{ + GetIndexesDrvF: func(idxItmType, tntCtx, idxKey string) (indexes map[string]utils.StringSet, err error) { + return map[string]utils.StringSet{ + utils.CacheChargerFilterIndexes: { + "ATTR_TEST": {}, + }, + }, nil + }, + } + oldFlt := &Filter{ + Tenant: "cgrates.org", + ID: "FLTR_CP_2", + Rules: []*FilterRule{ + { + Type: utils.MetaString, + Element: "~*req.Charger", + Values: []string{"ChargerProfile2"}, + }, + }} + + newFlt := &Filter{ + Tenant: "cgrates.org", + ID: "FLTR_CP_2", + Rules: []*FilterRule{ + { + Type: utils.MetaGreaterOrEqual, + Element: utils.DynamicDataPrefix + utils.MetaReq + utils.NestingSep + utils.Weight, + Values: []string{"200.00"}, + }, + }} + if err := UpdateFilterIndex(dm, oldFlt, newFlt); err != utils.ErrNotImplemented { + t.Errorf("Expected error <%v>, Received error <%v>", utils.ErrNotImplemented, err) } - if getidx, err := dm.GetIndexes(utils.CacheResourceFilterIndexes, "cgrates.org", utils.EmptyString, true, true); err != nil { - t.Error(err) - } else if !reflect.DeepEqual(expindx, getidx) { - t.Errorf("Expected %v, Received %v", utils.ToJSON(expindx), utils.ToJSON(getidx)) - } - } diff --git a/engine/routes_test.go b/engine/routes_test.go index 0bddd6d15..d6b2d5128 100644 --- a/engine/routes_test.go +++ b/engine/routes_test.go @@ -1023,11 +1023,7 @@ func TestRouteServiceV1GetRoutes(t *testing.T) { utils.AttributeSv1ProcessEvent: func(args, reply interface{}) error { rpl := &AttrSProcessEventReply{ AlteredFields: []string{"testcase"}, - CGREvent: &utils.CGREvent{ - Event: map[string]interface{}{ - "testcase": 1, - }, - }, + CGREvent: testRoutesArgs[1], } *reply.(*AttrSProcessEventReply) = *rpl return nil @@ -1048,54 +1044,32 @@ func TestRouteServiceV1GetRoutes(t *testing.T) { rpS := NewRouteService(dmSPP, &FilterS{dm: dmSPP, cfg: cfg, connMgr: nil}, cfg, connMgr) args := &utils.CGREvent{ ID: "CGREvent1", - Tenant: "cgrates.orgs", + Tenant: "cgrates.org", Time: utils.TimePointer(time.Date(2022, 12, 1, 20, 0, 0, 0, time.UTC)), Event: map[string]interface{}{ "testcase": 1, }, } - reply := &SortedRoutesList{ - { - ProfileID: "RouteProfile1", - Sorting: utils.MetaWeight, + expErr := fmt.Sprintf("MANDATORY_IE_MISSING: [%v]", utils.CGREventString) + var reply SortedRoutesList + if err := rpS.V1GetRoutes(nil, &reply); err == nil || err.Error() != expErr { + t.Errorf("Expected <%v>,Received <%v>", expErr, err.Error()) + } + expS := SortedRoutesList{ + {ProfileID: "RouteProfile1", + Sorting: "*weight", Routes: []*SortedRoute{ { - RouteID: "route1", - sortingDataF64: map[string]float64{ - utils.Weight: 10.0, - }, - SortingData: map[string]interface{}{ - utils.Weight: 10.0, - }, + RouteID: "route2", RouteParameters: "param1", + SortingData: map[string]interface{}{"Weight": 10}, }, }, - }, - { - ProfileID: "RouteProfile2", - Sorting: utils.MetaWeight, - Routes: []*SortedRoute{ - { - RouteID: "route1", - sortingDataF64: map[string]float64{ - utils.Weight: 10.0, - }, - SortingData: map[string]interface{}{ - utils.Weight: 10.0, - }, - RouteParameters: "param1", - }, - }, - }, - } - if err := rpS.V1GetRoutes(nil, reply); err == nil { - t.Error(err) - } else if err = rpS.V1GetRoutes(args, reply); err == nil { - t.Error(err) - } - - if err := rpS.V1GetRoutesList(args, &[]string{}); err == nil || err != utils.ErrNotFound { + }} + if err = rpS.V1GetRoutes(args, &reply); err != nil { t.Error(err) + } else if !reflect.DeepEqual(reply[0].ProfileID, expS[0].ProfileID) { + t.Errorf("Expected %v,Received %v", utils.ToJSON(expS), utils.ToJSON(reply)) } } @@ -1806,3 +1780,211 @@ func TestNewOptsGetRoutes(t *testing.T) { t.Error(err) } } + +func TestRSStatMetricsLogg(t *testing.T) { + utils.Logger.SetLogLevel(4) + utils.Logger.SetSyslog(nil) + cfg := config.NewDefaultCGRConfig() + buf := new(bytes.Buffer) + log.SetOutput(buf) + defer func() { + utils.Logger.SetLogLevel(0) + log.SetOutput(os.Stderr) + config.SetCgrConfig(config.NewDefaultCGRConfig()) + }() + cfg.RouteSCfg().StatSConns = []string{utils.ConcatenatedKey(utils.MetaInternal, utils.MetaStats)} + db := NewInternalDB(nil, nil, true, cfg.DataDbCfg().Items) + dm := NewDataManager(db, cfg.CacheCfg(), nil) + clientConn := make(chan rpcclient.ClientConnector, 1) + clientConn <- &ccMock{ + calls: map[string]func(args interface{}, reply interface{}) error{ + utils.StatSv1GetQueueFloatMetrics: func(args, reply interface{}) error { + return errors.New("Can't get StatMetrics") + }, + }, + } + connMgr := NewConnManager(cfg, map[string]chan rpcclient.ClientConnector{ + utils.ConcatenatedKey(utils.MetaInternal, utils.MetaStats): clientConn, + }) + statIds := []string{"STATS_VENDOR_1:*sum#1"} + rps := NewRouteService(dm, nil, cfg, connMgr) + expLog := ` getting statMetrics for stat : ` + if _, err := rps.statMetrics(statIds, "cgrates.org"); err == nil || err.Error() != "Can't get StatMetrics" { + t.Error(err) + } else if rcvLog := buf.String(); !strings.Contains(rcvLog, expLog) { + t.Errorf("Logger %v doesn't contain %v", rcvLog, expLog) + } +} + +func TestRSStatMetricsForLoadDistributionLogg(t *testing.T) { + utils.Logger.SetLogLevel(4) + utils.Logger.SetSyslog(nil) + cfg := config.NewDefaultCGRConfig() + buf := new(bytes.Buffer) + log.SetOutput(buf) + defer func() { + utils.Logger.SetLogLevel(0) + log.SetOutput(os.Stderr) + config.SetCgrConfig(config.NewDefaultCGRConfig()) + }() + cfg.RouteSCfg().StatSConns = []string{utils.ConcatenatedKey(utils.MetaInternal, utils.MetaStats)} + db := NewInternalDB(nil, nil, true, cfg.DataDbCfg().Items) + dm := NewDataManager(db, cfg.CacheCfg(), nil) + clientConn := make(chan rpcclient.ClientConnector, 1) + clientConn <- &ccMock{ + calls: map[string]func(args interface{}, reply interface{}) error{ + utils.StatSv1GetQueueFloatMetrics: func(args, reply interface{}) error { + return errors.New("Can't get StatMetrics") + }, + }, + } + connMgr := NewConnManager(cfg, map[string]chan rpcclient.ClientConnector{ + utils.ConcatenatedKey(utils.MetaInternal, utils.MetaStats): clientConn, + }) + statIds := []string{"STATS_VENDOR_1:*sum#1"} + rps := NewRouteService(dm, nil, cfg, connMgr) + expLog := `getting statMetrics for stat : ` + if _, err := rps.statMetricsForLoadDistribution(statIds, "cgrates.org"); err == nil || !strings.Contains(err.Error(), utils.ErrNotFound.Error()) { + t.Error(err) + } else if rcvLog := buf.String(); !strings.Contains(rcvLog, expLog) { + t.Errorf("Logger %v doesn't contain %v", rcvLog, expLog) + } +} + +func TestResourceUsage(t *testing.T) { + utils.Logger.SetLogLevel(4) + utils.Logger.SetSyslog(nil) + cfg := config.NewDefaultCGRConfig() + buf := new(bytes.Buffer) + log.SetOutput(buf) + defer func() { + utils.Logger.SetLogLevel(0) + log.SetOutput(os.Stderr) + config.SetCgrConfig(config.NewDefaultCGRConfig()) + }() + cfg.RouteSCfg().ResourceSConns = []string{utils.ConcatenatedKey(utils.MetaInternal, utils.MetaResources)} + resIds := []string{"RL1"} + clientConn := make(chan rpcclient.ClientConnector, 1) + clientConn <- &ccMock{ + calls: map[string]func(args interface{}, reply interface{}) error{ + utils.ResourceSv1GetResource: func(args, reply interface{}) error { + return errors.New("Can't get Resources") + }, + }, + } + connMgr := NewConnManager(cfg, map[string]chan rpcclient.ClientConnector{ + utils.ConcatenatedKey(utils.MetaInternal, utils.MetaResources): clientConn, + }) + rps := NewRouteService(dm, nil, cfg, connMgr) + expLog := `getting resource for ID :` + if _, err := rps.resourceUsage(resIds, "cgrates.org"); err == nil || err.Error() != "Can't get Resources" { + t.Error(err) + } else if rcvLog := buf.String(); !strings.Contains(rcvLog, expLog) { + t.Errorf("Logger %v doesn't contain %v", rcvLog, expLog) + } +} + +func TestRSLazyCheckRule(t *testing.T) { + cfg := config.NewDefaultCGRConfig() + defer func() { + config.SetCgrConfig(config.NewDefaultCGRConfig()) + }() + rps := NewRouteService(dm, nil, cfg, nil) + ev := &utils.CGREvent{ + Tenant: "cgrates.org", + ID: "SqProcessEvent", + Event: map[string]interface{}{ + utils.AccountField: "1001", + }, + APIOpts: map[string]interface{}{ + utils.OptsStatsProfileIDs: []string{"SQ1"}, + }, + } + extraOpts := &optsGetRoutes{ + ignoreErrors: true, + maxCost: 12.1, + paginator: &utils.Paginator{ + Limit: utils.IntPointer(4), + Offset: utils.IntPointer(2), + }, + } + route := &Route{ + ID: "route1", + FilterIDs: []string{"FLTR_ACNT"}, + + Weight: 10, + Blocker: true, + RouteParameters: "param1", + lazyCheckRules: []*FilterRule{ + { + Element: "~*req.Account", + Type: utils.MetaString, + Values: []string{"1001", "1002"}, + rsrElement: config.NewRSRParserMustCompile(utils.DynamicDataPrefix + utils.MetaReq + utils.NestingSep + utils.ToR), + }, + }, + } + if _, _, err := rps.populateSortingData(ev, route, extraOpts); err != nil { + t.Error(err) + } +} + +func TestRSPopulateSortingDataResourceErr(t *testing.T) { + utils.Logger.SetLogLevel(4) + utils.Logger.SetSyslog(nil) + cfg := config.NewDefaultCGRConfig() + buf := new(bytes.Buffer) + log.SetOutput(buf) + defer func() { + utils.Logger.SetLogLevel(0) + log.SetOutput(os.Stderr) + config.SetCgrConfig(config.NewDefaultCGRConfig()) + }() + cfg.RouteSCfg().ResourceSConns = []string{utils.ConcatenatedKey(utils.MetaInternal, utils.MetaResources)} + clientConn := make(chan rpcclient.ClientConnector, 1) + clientConn <- &ccMock{ + calls: map[string]func(args interface{}, reply interface{}) error{ + utils.ResourceSv1GetResource: func(args, reply interface{}) error { + return errors.New("No Resources") + }, + }, + } + connMgr := NewConnManager(cfg, map[string]chan rpcclient.ClientConnector{ + utils.ConcatenatedKey(utils.MetaInternal, utils.MetaResources): clientConn, + }) + rps := NewRouteService(dm, nil, cfg, connMgr) + ev := &utils.CGREvent{ + Tenant: "cgrates.org", + ID: "SqProcessEvent", + Event: map[string]interface{}{ + utils.AccountField: "1001", + }, + APIOpts: map[string]interface{}{ + utils.OptsStatsProfileIDs: []string{"SQ1"}, + }, + } + extraOpts := &optsGetRoutes{ + ignoreErrors: true, + maxCost: 12.1, + paginator: &utils.Paginator{ + Limit: utils.IntPointer(4), + Offset: utils.IntPointer(2), + }, + } + route := &Route{ + ID: "route1", + ResourceIDs: []string{"ResourceSupplier1", "Resource2Supplier1"}, + Weight: 20, + Blocker: false, + } + expLog := ` ignoring route with ID:` + if _, _, err := rps.populateSortingData(ev, route, extraOpts); err != nil { + t.Error(err) + } else if rcvLog := buf.String(); !strings.Contains(rcvLog, expLog) { + t.Errorf("Logger %v doesn't contain %v", rcvLog, expLog) + } + extraOpts.ignoreErrors = false + if _, _, err := rps.populateSortingData(ev, route, extraOpts); err == nil { + t.Error(err) + } +} diff --git a/engine/tpreader_test.go b/engine/tpreader_test.go index d1617ea9b..40f23c5c0 100644 --- a/engine/tpreader_test.go +++ b/engine/tpreader_test.go @@ -1912,13 +1912,6 @@ func TestLoadRatingPlansFiltered(t *testing.T) { RateIncrement: "6s", GroupIntervalStart: "0s", }, - { - ConnectFee: 12, - Rate: 3, - RateUnit: "4s", - RateIncrement: "6s", - GroupIntervalStart: "1s", - }, }, }, RoundingDecimals: 4}, @@ -1958,13 +1951,6 @@ func TestLoadRatingPlansFiltered(t *testing.T) { RateIncrement: "6s", GroupIntervalStart: "0s", }, - { - ConnectFee: 12, - Rate: 3, - RateUnit: "4s", - RateIncrement: "6s", - GroupIntervalStart: "1s", - }, }, }, []string{}, true, utils.NonTransactional) db.db.Set(utils.CacheTBLTPRates, "*prf:TEST_RATE12", &utils.TPRateRALs{ @@ -1978,13 +1964,6 @@ func TestLoadRatingPlansFiltered(t *testing.T) { RateIncrement: "6s", GroupIntervalStart: "0s", }, - { - ConnectFee: 12, - Rate: 3, - RateUnit: "4s", - RateIncrement: "6s", - GroupIntervalStart: "1s", - }, }, }, []string{}, true, utils.NonTransactional) if _, err := tpr.LoadRatingPlansFiltered("def"); err == nil {