From c5abf600cfd88a3feee4c0e2ccb52700c6226908 Mon Sep 17 00:00:00 2001 From: gezimbll Date: Mon, 13 Mar 2023 12:04:05 -0400 Subject: [PATCH] Improving coverage tests at engine --- engine/calldesc_test.go | 26 +++++ engine/cdrs_test.go | 101 +++++++++++++++++++ engine/resources_test.go | 61 ++++++++++++ engine/responder_test.go | 205 +++++++++++++++++++++++++++++++++++++++ 4 files changed, 393 insertions(+) diff --git a/engine/calldesc_test.go b/engine/calldesc_test.go index cb9318772..f977d3bd3 100644 --- a/engine/calldesc_test.go +++ b/engine/calldesc_test.go @@ -2043,3 +2043,29 @@ func TestCDRefundIncrementspanic(t *testing.T) { t.Error("Error refunding money: ", utils.ToIJSON(ub.BalanceMap)) } } + +// func TestCallDescRefundRounding(t *testing.T) { +// cgrEv := &utils.CGREvent{ +// Tenant: "cgrates.org", +// ID: "Generated", +// Event: map[string]interface{}{ +// "Account": "acc1", +// "AnswerTime": time.Date(2015, 3, 23, 6, 0, 0, 0, time.UTC), +// "Category": "call", +// "Destination": "0723123113", +// "Subject": "acc1", +// "Tenant": "cgrates.org", +// "ToR": "", +// "Usage": time.Duration(30) * time.Minute, +// }, +// } +// cd, err := NewCallDescriptorFromCGREvent(cgrEv, "UTC") +// if err != nil { +// t.Error(err) +// } + +// if _, err := cd.RefundRounding(); err != nil { +// t.Error(err) +// } +// } +// unfinished diff --git a/engine/cdrs_test.go b/engine/cdrs_test.go index 4a0ddfe22..14e13c387 100644 --- a/engine/cdrs_test.go +++ b/engine/cdrs_test.go @@ -268,3 +268,104 @@ func TestCDRSRateExportCDRS(t *testing.T) { t.Errorf("Expected ok ,received %v", reply) } } + +func TestCDRSStoreSessionCost22(t *testing.T) { + cfg, _ := config.NewDefaultCGRConfig() + db := NewInternalDB(nil, nil, true, cfg.DataDbCfg().Items) + dm := NewDataManager(db, cfg.CacheCfg(), nil) + + cdrS := &CDRServer{ + cgrCfg: cfg, + cdrDb: db, + dm: dm, + } + cdr := &AttrCDRSStoreSMCost{ + Cost: &SMCost{ + CGRID: "test1", + RunID: utils.MetaDefault, + OriginID: "testV1CDRsRefundOutOfSessionCost", + CostSource: utils.MetaSessionS, + OriginHost: "", + Usage: time.Duration(3 * time.Minute), + CostDetails: &EventCost{ + CGRID: "test1", + RunID: utils.MetaDefault, + StartTime: time.Date(2017, 1, 9, 16, 18, 21, 0, time.UTC), + Usage: utils.DurationPointer(time.Duration(3 * time.Minute)), + Cost: utils.Float64Pointer(2.3), + Charges: []*ChargingInterval{ + { + RatingID: "c1a5ab9", + Increments: []*ChargingIncrement{ + { + Usage: time.Duration(2 * time.Minute), + Cost: 2.0, + AccountingID: "a012888", + CompressFactor: 1, + }, + { + Usage: time.Duration(1 * time.Second), + Cost: 0.005, + AccountingID: "44d6c02", + CompressFactor: 60, + }, + }, + CompressFactor: 1, + }, + }, + AccountSummary: &AccountSummary{ + Tenant: "cgrates.org", + ID: "testV1CDRsRefundOutOfSessionCost", + BalanceSummaries: []*BalanceSummary{ + { + UUID: "random", + Type: utils.MONETARY, + Value: 50, + }, + }, + AllowNegative: false, + Disabled: false, + }, + Rating: Rating{ + "c1a5ab9": &RatingUnit{ + ConnectFee: 0.1, + RoundingMethod: "*up", + RoundingDecimals: 5, + RatesID: "ec1a177", + RatingFiltersID: "43e77dc", + }, + }, + Accounting: Accounting{ + "a012888": &BalanceCharge{ + AccountID: "cgrates.org:testV1CDRsRefundOutOfSessionCost", + BalanceUUID: "random", + Units: 120.7, + }, + "44d6c02": &BalanceCharge{ + AccountID: "cgrates.org:testV1CDRsRefundOutOfSessionCost", + BalanceUUID: "random", + Units: 120.7, + }, + }, + Rates: ChargedRates{ + "ec1a177": RateGroups{ + &Rate{ + GroupIntervalStart: time.Duration(0), + Value: 0.01, + RateIncrement: time.Duration(1 * time.Minute), + RateUnit: time.Duration(1 * time.Second)}, + }, + }, + }, + }, + } + var reply string + if err := cdrS.V1StoreSessionCost(cdr, &reply); err != nil { + t.Error(err) + } else if reply != utils.OK { + t.Errorf("Expected ok,received %v", reply) + } + if _, err := cdrS.cdrDb.GetSMCosts(cdr.Cost.CGRID, cdr.Cost.RunID, "", cdr.Cost.OriginID); err != nil { + t.Error(err) + } +} diff --git a/engine/resources_test.go b/engine/resources_test.go index 487f90749..afbfec336 100644 --- a/engine/resources_test.go +++ b/engine/resources_test.go @@ -1350,3 +1350,64 @@ func TestResourcesRelease(t *testing.T) { t.Errorf("Expected OK,Received %v", reply) } } + +func TestResourceAuthorizeResources22(t *testing.T) { + Cache.Clear(nil) + cfg, _ := config.NewDefaultCGRConfig() + db := NewInternalDB(nil, nil, true, cfg.DataDbCfg().Items) + dm := NewDataManager(db, config.CgrConfig().CacheCfg(), nil) + cfg.ResourceSCfg().StoreInterval = 1 + cfg.ResourceSCfg().StringIndexedFields = nil + cfg.ResourceSCfg().PrefixIndexedFields = nil + rS, _ := NewResourceService(dm, cfg, + NewFilterS(cfg, nil, dm), nil) + args := utils.ArgRSv1ResourceUsage{ + CGREvent: &utils.CGREvent{ + Tenant: "cgrates.org", + ID: utils.UUIDSha1Prefix(), + Event: map[string]interface{}{ + utils.Account: "1001", + utils.Destination: "1002", + "Resource": "Resource1", + }, + }, + + UsageID: utils.UUIDSha1Prefix(), + ArgDispatcher: &utils.ArgDispatcher{ + APIKey: utils.StringPointer("res12345"), + }, + } + fltr := &Filter{ + Tenant: "cgrates.org", + ID: "FLTR_RES_1", + Rules: []*FilterRule{ + { + Type: utils.MetaString, + Element: "~*req.Resource", + Values: []string{"Resource1"}, + }, + }} + dm.SetFilter(fltr) + + resourse := &ResourceProfile{ + Tenant: "cgrates.org", + ID: "RES20", + FilterIDs: []string{"FLTR_RES_1"}, + UsageTTL: 10 * time.Second, + Limit: 10.00, + AllocationMessage: "AllocationMessage", + Weight: 20.00, + ThresholdIDs: []string{utils.META_NONE}, + } + dm.SetResourceProfile(resourse, true) + dm.SetResource(&Resource{Tenant: "cgrates.org", ID: "RES20"}) + var reply string + if err := rS.V1AuthorizeResources(args, &reply); err != nil { + t.Error(err) + } + var replyS Resource + if err := rS.V1GetResource(&utils.TenantID{Tenant: "cgrates.org", ID: "RES20"}, &replyS); err != nil { + t.Error(err) + } + +} diff --git a/engine/responder_test.go b/engine/responder_test.go index 20c2e3f2d..f8bd88521 100644 --- a/engine/responder_test.go +++ b/engine/responder_test.go @@ -538,6 +538,53 @@ func TestResponderGetCostOnRatingPlans(t *testing.T) { } } +func TestResponderRefundIncrements22(t *testing.T) { + cfg, _ := config.NewDefaultCGRConfig() + db := NewInternalDB(nil, nil, true, cfg.DataDbCfg().Items) + tmpDm := dm + dm := NewDataManager(db, cfg.CacheCfg(), nil) + defer func() { + SetDataStorage(tmpDm) + }() + tStart, _ := utils.ParseTimeDetectLayout("2018-08-07T17:30:00Z", utils.EmptyString) + tEnd, _ := utils.ParseTimeDetectLayout("2018-08-07T17:31:30Z", utils.EmptyString) + acc := &Account{ + ID: "cgrates.org:1001", + BalanceMap: map[string]Balances{ + utils.VOICE: { + &Balance{Value: 20 * float64(time.Second), + DestinationIDs: utils.NewStringMap("1002"), + Weight: 10, RatingSubject: "rif"}, + }}, + } + SetDataStorage(dm) + if err := dm.SetAccount(acc); err != nil { + t.Error(err) + } + rsponder.MaxComputedUsage[utils.VOICE] = 30 * time.Minute + cd := &CallDescriptorWithArgDispatcher{ + CallDescriptor: &CallDescriptor{ + Category: "call", + Tenant: "cgrates.org", + Subject: "1001", + Account: "1001", + Destination: "1002", + ToR: utils.VOICE, + DurationIndex: 20, + TimeStart: tStart, + TimeEnd: tEnd, + Increments: Increments{ + &Increment{Cost: 0, BalanceInfo: &DebitInfo{AccountID: acc.ID}}, + &Increment{Cost: 0, Duration: 3 * time.Second, BalanceInfo: &DebitInfo{AccountID: acc.ID}}, + }, + }, + } + + var reply Account + if err := rsponder.RefundIncrements(cd, &reply); err != nil { + t.Error(err) + } +} func TestResponderGetCost(t *testing.T) { tmpCache := Cache cfg, err := config.NewDefaultCGRConfig() @@ -667,3 +714,161 @@ func TestResponderDebit11(t *testing.T) { } } + +func TestResponderMaxDebit11(t *testing.T) { + cfg, _ := config.NewDefaultCGRConfig() + db := NewInternalDB(nil, nil, true, cfg.DataDbCfg().Items) + tmpDm := dm + dm := NewDataManager(db, cfg.CacheCfg(), nil) + defer func() { + SetDataStorage(tmpDm) + }() + + tStart, _ := utils.ParseTimeDetectLayout("2021-08-07T17:30:00Z", utils.EmptyString) + tEnd, _ := utils.ParseTimeDetectLayout("2021-08-07T17:31:30Z", utils.EmptyString) + cd := &CallDescriptorWithArgDispatcher{ + CallDescriptor: &CallDescriptor{ + Category: "call", + Tenant: "cgrates.org", + Subject: "1001", + Account: "1001", + Destination: "1002", + DurationIndex: 90, + TimeStart: tStart, + TimeEnd: tEnd, + ToR: utils.MONETARY, + }, + } + acc := &Account{ + ID: "cgrates.org:1001", + BalanceMap: map[string]Balances{ + utils.MONETARY: { + &Balance{Value: 11, Weight: 20, DestinationIDs: utils.NewStringMap("1002")}, + }}, + } + SetDataStorage(dm) + if err := dm.SetAccount(acc); err != nil { + t.Error(err) + } + dest := &Destination{ + Id: "DEST", + Prefixes: []string{ + "1002", "1003", "1004", + }, + } + dm.SetReverseDestination(dest, utils.NonTransactional) + rp := &RatingPlan{ + Id: "RP_1", + Ratings: map[string]*RIRate{ + "b531174": { + Rates: RateGroups{ + { + GroupIntervalStart: 0, + Value: 0.01, + RateIncrement: time.Second, + RateUnit: time.Second, + }, + }, + RoundingMethod: utils.ROUNDING_MIDDLE, + RoundingDecimals: 2, + }, + }, + Timings: map[string]*RITiming{ + "30eab301": { + Years: utils.Years{}, + Months: utils.Months{}, + MonthDays: utils.MonthDays{}, + WeekDays: utils.WeekDays{}, + StartTime: "00:00:00", + }, + }, + DestinationRates: map[string]RPRateList{ + "DEST": { + { + Rating: "b457f861", + Weight: 10, + }, + }, + }, + } + + if err := dm.SetRatingPlan(rp, utils.NonTransactional); err != nil { + t.Error(err) + } + rP := &RatingProfile{ + Id: utils.ConcatenatedKey(utils.META_OUT, cd.Tenant, "call", cd.Subject), + RatingPlanActivations: RatingPlanActivations{ + { + RatingPlanId: rp.Id, + ActivationTime: time.Date(2022, 12, 20, 8, 30, 0, 0, time.UTC), + }, + }, + } + if err := dm.SetRatingProfile(rP, utils.NonTransactional); err != nil { + t.Error(err) + } + var reply CallCost + if err := rsponder.MaxDebit(cd, &reply); err == nil { + t.Error(err) + } + +} + +func TestResponderRefundRounding33(t *testing.T) { + cfg, _ := config.NewDefaultCGRConfig() + db := NewInternalDB(nil, nil, true, cfg.DataDbCfg().Items) + tmpDm := dm + dm := NewDataManager(db, cfg.CacheCfg(), nil) + defer func() { + SetDataStorage(tmpDm) + }() + tStart, _ := utils.ParseTimeDetectLayout("2019-08-07T17:30:00Z", utils.EmptyString) + tEnd, _ := utils.ParseTimeDetectLayout("2019-08-07T17:31:30Z", utils.EmptyString) + cd := &CallDescriptorWithArgDispatcher{ + CallDescriptor: &CallDescriptor{ + Category: "call", + Tenant: "cgrates.org", + Subject: "1001", + Account: "1001", + Destination: "1002", + DurationIndex: 90, + TimeStart: tStart, + TimeEnd: tEnd, + Increments: Increments{ + &Increment{ + Duration: time.Minute, + Cost: 1, + BalanceInfo: &DebitInfo{ + Unit: &UnitInfo{UUID: "1", DestinationID: "1", Consumed: 2.3, ToR: utils.VOICE, RateInterval: &RateInterval{Rating: &RIRate{Rates: RateGroups{&Rate{GroupIntervalStart: 0, Value: 100, RateIncrement: 10 * time.Second, RateUnit: time.Second}}}}}, + Monetary: &MonetaryInfo{UUID: "2"}, + AccountID: "cgrates.org:1001"}, + }, + &Increment{ + Duration: time.Minute, + Cost: 1, + BalanceInfo: &DebitInfo{ + Unit: &UnitInfo{UUID: "1", DestinationID: "1", Consumed: 2.3, ToR: utils.VOICE, RateInterval: &RateInterval{Rating: &RIRate{Rates: RateGroups{&Rate{GroupIntervalStart: 0, Value: 100, RateIncrement: 10 * time.Second, RateUnit: time.Second}}}}}, + Monetary: &MonetaryInfo{UUID: "2"}, + AccountID: "cgrates.org:1001"}, + }, + }, + }, + } + acc := &Account{ + ID: "cgrates.org:1001", + BalanceMap: map[string]Balances{ + utils.VOICE: { + &Balance{Value: 20 * float64(time.Second), + DestinationIDs: utils.NewStringMap("1002"), + Weight: 10, RatingSubject: "rif"}, + }}, + } + if err := dm.SetAccount(acc); err != nil { + t.Error(err) + } + SetDataStorage(dm) + var reply Account + if rsponder.RefundRounding(cd, &reply); err != nil { + t.Error(err) + } +}