From 68b06d573a1e5327e6d52c5a949534054ebcbbdf Mon Sep 17 00:00:00 2001 From: gezimbll Date: Tue, 4 Apr 2023 11:01:51 -0400 Subject: [PATCH] Improving Unit Test Coverage for Engine --- engine/balances_test.go | 67 ++++++++++++++++++++++++ engine/cdrs_test.go | 102 +++++++++++++++++++++++++++++++++++++ engine/datamanager_test.go | 29 +++++++++++ engine/responder_test.go | 59 +++++++++++++++++++++ engine/storage_test.go | 7 +-- 5 files changed, 261 insertions(+), 3 deletions(-) diff --git a/engine/balances_test.go b/engine/balances_test.go index ca8dbf5c2..a7828b8bc 100644 --- a/engine/balances_test.go +++ b/engine/balances_test.go @@ -368,3 +368,70 @@ func TestBalancesSaveDirtyBalances(t *testing.T) { t.Error(err) } } + +func TestBalancePublish(t *testing.T) { + cfg, _ := config.NewDefaultCGRConfig() + tmpDm := dm + tmpConn := connMgr + defer func() { + cfg2, _ := config.NewDefaultCGRConfig() + config.SetCgrConfig(cfg2) + SetDataStorage(tmpDm) + SetConnManager(tmpConn) + }() + cfg.RalsCfg().StatSConns = []string{utils.ConcatenatedKey(utils.MetaInternal, utils.MetaStats)} + cfg.RalsCfg().ThresholdSConns = []string{utils.ConcatenatedKey(utils.MetaInternal, utils.MetaThresholds)} + db := NewInternalDB(nil, nil, true, cfg.DataDbCfg().Items) + dm := NewDataManager(db, cfg.CacheCfg(), nil) + clientConn := make(chan rpcclient.ClientConnector, 1) + clientConn <- clMock(func(serviceMethod string, _, _ interface{}) error { + if serviceMethod == utils.StatSv1ProcessEvent { + + return nil + } else if serviceMethod == utils.ThresholdSv1ProcessEvent { + + return nil + } + return utils.ErrNotImplemented + }) + connMgr := NewConnManager(cfg, map[string]chan rpcclient.ClientConnector{ + utils.ConcatenatedKey(utils.MetaInternal, utils.MetaStats): clientConn, + utils.ConcatenatedKey(utils.MetaInternal, utils.MetaThresholds): clientConn, + }) + SetConnManager(connMgr) + at := &ActionTrigger{ + UniqueID: "TestTR5", + ThresholdType: utils.TRIGGER_MAX_BALANCE, + Balance: &BalanceFilter{ + Type: utils.StringPointer(utils.VOICE), + Weight: utils.Float64Pointer(10), + }, + ActionsID: "ACT_1", + } + ub := &Account{ + ID: "cgrates.org:1001", + BalanceMap: map[string]Balances{ + utils.VOICE: { + { + Value: 10, + DestinationIDs: utils.NewStringMap("DEST"), + }, + }, + }, + } + dm.SetActions("ACT_1", Actions{ + &Action{ + ActionType: utils.MetaPublishBalance, + Balance: &BalanceFilter{ + Type: utils.StringPointer(utils.VOICE), + Value: &utils.ValueFormula{Static: 15}, + }, + }, + }, utils.NonTransactional) + config.SetCgrConfig(cfg) + SetDataStorage(dm) + if err := at.Execute(ub); err != nil { + t.Error(err) + } + +} diff --git a/engine/cdrs_test.go b/engine/cdrs_test.go index d8ed47b01..401e22069 100644 --- a/engine/cdrs_test.go +++ b/engine/cdrs_test.go @@ -447,3 +447,105 @@ func TestCDRSRateCDRs(t *testing.T) { t.Errorf("Expected 1,Received %d", cnt) } } + +func TestCDRSRateCDRSucces(t *testing.T) { + cfg, _ := config.NewDefaultCGRConfig() + db := NewInternalDB(nil, nil, true, cfg.DataDbCfg().Items) + dm := NewDataManager(db, cfg.CacheCfg(), nil) + cfg.CdrsCfg().SMCostRetries = 0 + cfg.CdrsCfg().RaterConns = []string{utils.ConcatenatedKey(utils.MetaInternal, utils.MetaRALs)} + clientConn := make(chan rpcclient.ClientConnector, 1) + clientConn <- clMock(func(serviceMethod string, _, reply interface{}) error { + if serviceMethod == utils.ResponderDebit { + rpl := CallCost{ + Destination: "1002", + Timespans: []*TimeSpan{ + { + TimeStart: time.Date(2018, 8, 24, 16, 00, 26, 0, time.UTC), + TimeEnd: time.Date(2018, 8, 24, 16, 00, 36, 0, time.UTC), + ratingInfo: &RatingInfo{}, + DurationIndex: 0, + RateInterval: &RateInterval{ + Rating: &RIRate{ + Rates: RateGroups{ + &Rate{GroupIntervalStart: 0, + Value: 100, + RateIncrement: 1, + RateUnit: time.Nanosecond}}}}, + }, + }, + ToR: utils.SMS, + } + *reply.(*CallCost) = rpl + return nil + } + return utils.ErrNotImplemented + }) + connMgr := NewConnManager(cfg, map[string]chan rpcclient.ClientConnector{ + utils.ConcatenatedKey(utils.MetaInternal, utils.MetaRALs): clientConn, + }) + cdrS := &CDRServer{ + cgrCfg: cfg, + cdrDb: db, + dm: dm, + connMgr: connMgr, + } + cdr := &CDRWithArgDispatcher{ + CDR: &CDR{CGRID: "Cdr1", + OrderID: 101, + ToR: utils.VOICE, + OriginID: "OriginCDR1", + OriginHost: "192.168.1.1", + Source: "test", + RequestType: utils.META_PREPAID, + Tenant: "cgrates.org", + Category: "call", + Account: "1001", + Subject: "1001", + Destination: "1002", + SetupTime: time.Date(2018, 8, 24, 16, 00, 00, 0, time.UTC), + AnswerTime: time.Date(2018, 8, 24, 16, 00, 26, 0, time.UTC), + RunID: utils.MetaDefault, + Usage: time.Duration(10) * time.Second, + ExtraFields: map[string]string{"ExtraHeader1": "ExtraVal1", "ExtraHeader2": "ExtraVal2"}, + Cost: 1.01}, + } + if _, err := cdrS.rateCDR(cdr); err != nil { + t.Error(err) + } +} + +func TestV2StoreSessionCost(t *testing.T) { + cfg, _ := config.NewDefaultCGRConfig() + cfg.CacheCfg()[utils.CacheRPCResponses].Limit = 1 + Cache.Clear(nil) + db := NewInternalDB(nil, nil, true, cfg.DataDbCfg().Items) + dm := NewDataManager(db, cfg.CacheCfg(), nil) + cdrS := &CDRServer{ + cgrCfg: cfg, + dm: dm, + cdrDb: db, + guard: guardian.Guardian, + } + args := &ArgsV2CDRSStoreSMCost{ + CheckDuplicate: true, + Cost: &V2SMCost{ + CGRID: "testRPCMethodsCdrsStoreSessionCost", + RunID: utils.MetaDefault, + OriginHost: "", + OriginID: "testdatagrp_grp1", + CostSource: "SMR", + Usage: 1536, + CostDetails: &EventCost{ + AccountSummary: &AccountSummary{}, + }, + }, + } + Cache.Set(utils.CacheRPCResponses, utils.ConcatenatedKey(utils.CDRsV1StoreSessionCost, args.Cost.CGRID, args.Cost.RunID), + &utils.CachedRPCResponse{Result: utils.OK, Error: nil}, + nil, true, utils.NonTransactional) + var reply string + if err := cdrS.V2StoreSessionCost(args, &reply); err != nil { + t.Error(err) + } +} diff --git a/engine/datamanager_test.go b/engine/datamanager_test.go index 8f61ce9ab..5ad7790a7 100644 --- a/engine/datamanager_test.go +++ b/engine/datamanager_test.go @@ -859,3 +859,32 @@ func TestActionTriggerRplRmt(t *testing.T) { t.Errorf("Expected %v,Receive %v", attrs, vals) } } + +func TestDMRemoveAttributeProfile(t *testing.T) { + cfg, _ := config.NewDefaultCGRConfig() + db := NewInternalDB(nil, nil, true, cfg.DataDbCfg().Items) + dm := NewDataManager(db, cfg.CacheCfg(), nil) + attrPrf := &AttributeProfile{ + Tenant: "cgrates.org", + ID: "ATTR_1", + FilterIDs: []string{"*string:~*req.Account:1007"}, + Contexts: []string{utils.MetaSessionS, utils.MetaCDRs}, + ActivationInterval: &utils.ActivationInterval{ + ActivationTime: time.Date(2014, 1, 14, 0, 0, 0, 0, time.UTC)}, + Attributes: []*Attribute{ + { + Path: utils.MetaReq + utils.NestingSep + utils.Account, + Value: config.NewRSRParsersMustCompile("1001", true, utils.INFIELD_SEP), + }, + { + Path: utils.MetaReq + utils.NestingSep + utils.Subject, + Value: config.NewRSRParsersMustCompile("1001", true, utils.INFIELD_SEP), + }, + }, + Weight: 10.0, + } + dm.SetAttributeProfile(attrPrf, true) + if err := dm.RemoveAttributeProfile("cgrates.org", "ATTR_1", utils.NonTransactional, true); err != nil { + t.Error(err) + } +} diff --git a/engine/responder_test.go b/engine/responder_test.go index d57e5c550..af2d9615a 100644 --- a/engine/responder_test.go +++ b/engine/responder_test.go @@ -1072,3 +1072,62 @@ func TestResponderRounding(t *testing.T) { t.Error(utils.ToJSON(reply)) } } + +func TestResponderDebitCached(t *testing.T) { + cfg, _ := config.NewDefaultCGRConfig() + defer func() { + cfg2, _ := config.NewDefaultCGRConfig() + config.SetCgrConfig(cfg2) + }() + cfg.CacheCfg()[utils.CacheRPCResponses].Limit = 2 + Cache.Clear(nil) + tStart, _ := utils.ParseTimeDetectLayout("2022-08-07T17:30:00Z", utils.EmptyString) + tEnd, _ := utils.ParseTimeDetectLayout("2022-08-07T17:31:30Z", utils.EmptyString) + cd := &CallDescriptorWithArgDispatcher{ + CallDescriptor: &CallDescriptor{ + CgrID: "test", + Category: "call", + Tenant: "cgrates.org", + Subject: "1001", + Account: "1001", + ToR: utils.VOICE, + Destination: "1002", + TimeStart: tStart, + DurationIndex: 10 * time.Second, + TimeEnd: tEnd, + }, + } + cc := &CallCost{ + Cost: 1.23, + Destination: "1002", + Timespans: []*TimeSpan{ + { + TimeStart: time.Date(2022, 8, 7, 17, 30, 0, 0, time.UTC), + TimeEnd: time.Date(2022, 8, 7, 17, 31, 30, 0, time.UTC), + DurationIndex: 0, + RateInterval: &RateInterval{ + Rating: &RIRate{ + Rates: RateGroups{ + &Rate{ + GroupIntervalStart: 0, + Value: 100, + RateIncrement: 10 * time.Second, + RateUnit: time.Second, + }, + }, + }, + }, + }, + }, + ToR: utils.VOICE, + } + Cache.Set(utils.CacheRPCResponses, utils.ConcatenatedKey(utils.ResponderDebit, cd.CgrID), + &utils.CachedRPCResponse{Result: cc, Error: nil}, + nil, true, utils.NonTransactional) + config.SetCgrConfig(cfg) + var reply CallCost + if err := rsponder.Debit(cd, &reply); err == nil { + t.Error(err) + } + +} diff --git a/engine/storage_test.go b/engine/storage_test.go index 4e0878fd3..1240ccf18 100644 --- a/engine/storage_test.go +++ b/engine/storage_test.go @@ -1039,15 +1039,16 @@ func TestTprReloadCache(t *testing.T) { } return utils.ErrNotImplemented }) - connMgr := NewConnManager(cfg, map[string]chan rpcclient.ClientConnector{ + connMgr2 := NewConnManager(cfg, map[string]chan rpcclient.ClientConnector{ utils.ConcatenatedKey(utils.MetaInternal, utils.MetaCaches): clientConn, }) - SetConnManager(connMgr) + SetConnManager(connMgr2) tpr, err := NewTpReader(dataDb, storDb, "TEST_TP", "UTC", []string{utils.ConcatenatedKey(utils.MetaInternal, utils.MetaCaches)}, nil) if err != nil { t.Error(err) } + tpr.dm.SetLoadIDs(map[string]int64{utils.CacheChargerProfiles: time.Now().UnixNano(), utils.CacheDispatcherProfiles: time.Now().UnixNano()}) dests := []*utils.TPDestination{ { TPid: "TEST_TP", @@ -1128,7 +1129,7 @@ func TestTpRLoadAll(t *testing.T) { }, } rates := []*utils.TPRate{ - &utils.TPRate{ + { TPid: tpId, ID: "RATE1", RateSlots: []*utils.RateSlot{