From 2dccdb2162ca97bbaad6dec5465bd4114efa74b7 Mon Sep 17 00:00:00 2001 From: porosnicuadrian Date: Mon, 26 Jul 2021 15:24:41 +0300 Subject: [PATCH] Updated Equals method + tests --- accounts/accounts_test.go | 50 +++++++++++---------- actions/actions_test.go | 4 ++ rates/librates_test.go | 1 - utils/cgrevent_test.go | 2 +- utils/eventcharges.go | 87 +++++++++++++++++++----------------- utils/eventcharges_test.go | 20 ++++----- utils/librates.go | 91 +++++++++++--------------------------- 7 files changed, 114 insertions(+), 141 deletions(-) diff --git a/accounts/accounts_test.go b/accounts/accounts_test.go index e67ba7b5c..63033307d 100644 --- a/accounts/accounts_test.go +++ b/accounts/accounts_test.go @@ -372,30 +372,32 @@ func TestAccountsDebitGetUsage(t *testing.T) { evChExp := &utils.EventCharges{ Abstracts: utils.NewDecimal(89, 0), - Concretes: utils.NewDecimal(1484,1), + Concretes: utils.NewDecimal(1484, 1), Charges: []*utils.ChargeEntry{ { - ChargingID: "CHARGING1", + ChargingID: "CHARGING1", CompressFactor: 1, }, }, Accounting: map[string]*utils.AccountCharge{ "CHARGING1": { - AccountID: "TestAccountsDebitGetUsage", - BalanceID: "*transabstract", - Units: utils.NewDecimal(89,0), - RatingID: "RATING1", + AccountID: "TestAccountsDebitGetUsage", + BalanceID: "*transabstract", + Units: utils.NewDecimal(89, 0), + RatingID: "RATING1", JoinedChargeIDs: []string{"JND_CHRG1", "JND_CHRG2"}, }, "JND_CHRG1": { AccountID: "TestAccountsDebitGetUsage", BalanceID: "ConcreteBal1", - Units: utils.NewDecimal(592,1), + BalanceLimit: utils.NewDecimal(0, 0), + Units: utils.NewDecimal(592, 1), }, "JND_CHRG2": { AccountID: "TestAccountsDebitGetUsage", BalanceID: "ConcreteBal1", - Units: utils.NewDecimal(892,1), + BalanceLimit: utils.NewDecimal(0, 0), + Units: utils.NewDecimal(892, 1), }, }, Rating: map[string]*utils.RateSInterval{ @@ -411,7 +413,7 @@ func TestAccountsDebitGetUsage(t *testing.T) { }, }, UnitFactors: map[string]*utils.UnitFactor{}, - Rates: map[string]*utils.IntervalRate{}, + Rates: map[string]*utils.IntervalRate{}, Accounts: map[string]*utils.Account{ "TestAccountsDebitGetUsage": accntsPrf[0].Account, }, @@ -425,30 +427,30 @@ func TestAccountsDebitGetUsage(t *testing.T) { utils.Destination: "+445643", }, APIOpts: map[string]interface{}{ - utils.OptsRatesUsage: "2s", + utils.OptsRatesUsage: "2s", }, } if rcv, err := accnts.accountsDebit(context.Background(), accntsPrf, cgrEvent, false, false); err != nil { t.Error(err) - } else if rcv.Equals(evChExp) { + } else if !rcv.Equals(evChExp) { t.Errorf("Expected %v, \n received %v", utils.ToJSON(evChExp), utils.ToJSON(rcv)) } /* - // get usage from *usage - delete(cgrEvent.APIOpts, utils.OptsRatesUsage) - cgrEvent.APIOpts = map[string]interface{}{ - utils.MetaUsage: "2s", - } - if rcv, err := accnts.accountsDebit(context.Background(), accntsPrf, - cgrEvent, false, false); err != nil { - t.Error(err) - } else if rcv.Equals(evChExp) { - t.Errorf("Expected %v, \n received %v", utils.ToJSON(evChExp), utils.ToJSON(rcv)) - } + // get usage from *usage + delete(cgrEvent.APIOpts, utils.OptsRatesUsage) + cgrEvent.APIOpts = map[string]interface{}{ + utils.MetaUsage: "2s", + } + if rcv, err := accnts.accountsDebit(context.Background(), accntsPrf, + cgrEvent, false, false); err != nil { + t.Error(err) + } else if rcv.Equals(evChExp) { + t.Errorf("Expected %v, \n received %v", utils.ToJSON(evChExp), utils.ToJSON(rcv)) + } - */ + */ } func TestAccountsDebit(t *testing.T) { @@ -505,7 +507,7 @@ func TestAccountsDebit(t *testing.T) { utils.AccountField: "1004", }, APIOpts: map[string]interface{}{ - utils.OptsRatesUsage: "not_time_format", + utils.OptsRatesUsage: "not_time_format", }, } diff --git a/actions/actions_test.go b/actions/actions_test.go index e0143804c..39e3fede5 100644 --- a/actions/actions_test.go +++ b/actions/actions_test.go @@ -522,6 +522,10 @@ func (dbM *dataDBMockError) SetActionProfileDrv(*context.Context, *engine.Action return utils.ErrNoDatabaseConn } +func (dbM *dataDBMockError) GetIndexesDrv(ctx *context.Context, idxItmType, tntCtx, idxKey string) (indexes map[string]utils.StringSet, err error) { + return nil, nil +} + func TestLogActionExecute(t *testing.T) { evNM := utils.MapStorage{ utils.MetaReq: map[string]interface{}{ diff --git a/rates/librates_test.go b/rates/librates_test.go index f161b278f..a78f57f76 100644 --- a/rates/librates_test.go +++ b/rates/librates_test.go @@ -1973,7 +1973,6 @@ func TestComputeRateSIntervals(t *testing.T) { for idx, val := range rtIvls { if !val.Equals(eRtIvls[idx], cstRts, expCstRts) { t.Errorf("expecting: %+v \n,received: %+v", utils.ToJSON(expCstRts), utils.ToJSON(cstRts)) - t.Fatalf("expecting: %+v \n,received: %+v", utils.ToJSON(eRtIvls), utils.ToJSON(rtIvls)) } } } diff --git a/utils/cgrevent_test.go b/utils/cgrevent_test.go index 3518226ca..83ed46859 100644 --- a/utils/cgrevent_test.go +++ b/utils/cgrevent_test.go @@ -360,7 +360,7 @@ func TestCGREventOptAsDuration(t *testing.T) { if err != nil { t.Errorf("\nExpected: <%+v>, \nReceived: <%+v>", nil, err) } - expected := decimal.New(int64(30 * time.Nanosecond), 0) + expected := decimal.New(int64(30*time.Nanosecond), 0) if !reflect.DeepEqual(received, expected) { t.Errorf("\nExpected: <%+v>, \nReceived: <%+v>", expected, received) diff --git a/utils/eventcharges.go b/utils/eventcharges.go index c2952edaf..def4ea83c 100644 --- a/utils/eventcharges.go +++ b/utils/eventcharges.go @@ -101,12 +101,6 @@ func (cE *ChargeEntry) CompressEquals(chEn *ChargeEntry) bool { return cE.ChargingID == chEn.ChargingID } -// Equals return the equality between two ChargeEntry -func (cE *ChargeEntry) Equals(chEn *ChargeEntry) (eq bool) { - return cE.ChargingID == chEn.ChargingID && - cE.CompressFactor == chEn.CompressFactor -} - // SyncIDs will repopulate Accounting, UnitFactors and Rating IDs if they equal the references in ec func (ec *EventCharges) SyncIDs(eCs ...*EventCharges) { for _, nEc := range eCs { @@ -258,16 +252,19 @@ func (eEc *ExtEventCharges) Equals(exCh *ExtEventCharges) (eq bool) { len(eEc.Accounts) != len(exCh.Accounts)) { return } - for idx, val := range exCh.Charges { - if ok := val.Equals(exCh.Charges[idx]); !ok { - return + /* + for idx, val := range exCh.Charges { + if ok := val.Equals(exCh.Charges[idx], eEc.Accounting, exCh.Accounting); !ok { + return + } } - } - for key, val := range eEc.Accounting { - if ok := val.Equals(exCh.Accounting[key]); !ok { - return + for key, val := range eEc.Accounting { + if ok := val.Equals(exCh.Accounting[key]); !ok { + return + } } - } + + */ for key, val := range eEc.UnitFactors { if ok := val.Equals(exCh.UnitFactors[key]); !ok { return @@ -316,23 +313,11 @@ func (eC *EventCharges) Equals(evCh *EventCharges) (eq bool) { len(eC.Accounts) != len(evCh.Accounts)) { return } - for idx, val := range eC.Charges { - if ok := val.Equals(evCh.Charges[idx]); !ok { - return - } - } - for key, val := range eC.Accounting { - if ok := val.Equals(evCh.Accounting[key]); !ok { - return - } - } - for key, val := range eC.UnitFactors { - if ok := val.Equals(evCh.UnitFactors[key]); !ok { - return - } - } - for key, val := range eC.Rating { - if ok := val.Equals(evCh.Rating[key], eC.Rates, evCh.Rates); !ok { + for idx, ch1 := range eC.Charges { + if ch2 := evCh.Charges[idx]; ch1.CompressFactor != ch2.CompressFactor || + !equalsAccounting(eC.Accounting[ch1.ChargingID], evCh.Accounting[ch2.ChargingID], + eC.Accounting, evCh.Accounting, eC.UnitFactors, evCh.UnitFactors, + eC.Rating, evCh.Rating, eC.Rates, evCh.Rates) { return } } @@ -344,6 +329,28 @@ func (eC *EventCharges) Equals(evCh *EventCharges) (eq bool) { return true } +func equalsAccounting(acc1, acc2 *AccountCharge, + accM1, accM2 map[string]*AccountCharge, + uf1, uf2 map[string]*UnitFactor, + rat1, rat2 map[string]*RateSInterval, + rts1, rts2 map[string]*IntervalRate) (_ bool) { + if !acc1.equals(acc2) || + (uf1 != nil && uf2 != nil && + acc1.UnitFactorID != EmptyString && acc2.UnitFactorID != EmptyString && + !uf1[acc1.UnitFactorID].Equals(uf2[acc2.UnitFactorID])) || + !rat1[acc1.RatingID].Equals(rat2[acc2.RatingID], rts1, rts2) { + return + } + for idx, jc1 := range acc1.JoinedChargeIDs { + jc2 := acc2.JoinedChargeIDs[idx] + if !equalsAccounting(accM1[jc1], accM2[jc2], accM1, accM2, + uf1, uf2, rat1, rat2, rts1, rts2) { + return + } + } + return true +} + // unitFactorID returns the ID of the matching UnitFactor within ec.UnitFactors func (ec *EventCharges) unitFactorID(uF *UnitFactor) (ufID string) { for ecUfID, ecUf := range ec.UnitFactors { @@ -367,7 +374,7 @@ func (ec *EventCharges) ratingID(rIl *RateSInterval, nIrRef map[string]*Interval // accountChargeID returns the ID of the matching AccountCharge within ec.Accounting func (ec *EventCharges) accountChargeID(ac *AccountCharge) (acID string) { for ecID, ecAc := range ec.Accounting { - if ecAc.Equals(ac) { + if ecAc.equals(ac) { return ecID } } @@ -486,7 +493,10 @@ func (eAc *ExtAccountCharge) Equals(extAc *ExtAccountCharge) (eq bool) { } // Equals compares two AccountCharges -func (ac *AccountCharge) Equals(nAc *AccountCharge) (eq bool) { +func (ac *AccountCharge) equals(nAc *AccountCharge) (eq bool) { + if ac == nil && nAc == nil { + return true + } if (ac.AttributeIDs == nil && nAc.AttributeIDs != nil || ac.AttributeIDs != nil && nAc.AttributeIDs == nil || len(ac.AttributeIDs) != len(nAc.AttributeIDs)) || @@ -494,9 +504,9 @@ func (ac *AccountCharge) Equals(nAc *AccountCharge) (eq bool) { ac.JoinedChargeIDs != nil && nAc.JoinedChargeIDs == nil || len(ac.JoinedChargeIDs) != len(nAc.JoinedChargeIDs) || (ac.AccountID != nAc.AccountID || - ac.BalanceID != nAc.BalanceID || - ac.UnitFactorID != nAc.UnitFactorID || - ac.RatingID != nAc.RatingID) || + ac.BalanceID != nAc.BalanceID) || + ((len(ac.UnitFactorID) == 0) != (len(nAc.UnitFactorID) == 0)) || + ((len(ac.RatingID) == 0) != (len(nAc.RatingID) == 0)) || (ac.Units == nil && nAc.Units != nil || ac.Units != nil && nAc.Units == nil || (ac.Units != nil && nAc.Units != nil && @@ -512,10 +522,5 @@ func (ac *AccountCharge) Equals(nAc *AccountCharge) (eq bool) { return } } - for i := range ac.JoinedChargeIDs { - if ac.JoinedChargeIDs[i] != nAc.JoinedChargeIDs[i] { - return - } - } return true } diff --git a/utils/eventcharges_test.go b/utils/eventcharges_test.go index 577ac88f5..22a68fe14 100644 --- a/utils/eventcharges_test.go +++ b/utils/eventcharges_test.go @@ -27,12 +27,13 @@ import ( "github.com/ericlagergren/decimal" ) -/* func TestECNewEventCharges(t *testing.T) { expected := &EventCharges{ Accounting: make(map[string]*AccountCharge), UnitFactors: make(map[string]*UnitFactor), Rating: make(map[string]*RateSInterval), + Rates: make(map[string]*IntervalRate), + Accounts: make(map[string]*Account), } received := NewEventCharges() @@ -40,7 +41,6 @@ func TestECNewEventCharges(t *testing.T) { t.Errorf("\nExpected: <%+v>, \nReceived: <%+v>", expected, received) } } -*/ func TestECMergeAbstractsEmpty(t *testing.T) { ec1 := &EventCharges{ @@ -602,14 +602,14 @@ func TestEventChargesEquals(t *testing.T) { }, }, Accounting: map[string]*AccountCharge{ - "GENUUID_GHOST1": { + "THIS_GENUUID1": { AccountID: "TestEventChargesEquals", BalanceID: "CONCRETE1", Units: NewDecimal(8, 1), BalanceLimit: NewDecimal(200, 0), UnitFactorID: "GENUUID_FACTOR1", }, - "GENUUID3": { + "GENUUID1": { AccountID: "TestEventChargesEquals", BalanceID: "ABSTRACT2", BalanceLimit: NewDecimal(0, 0), @@ -779,14 +779,14 @@ func TestEventChargesEquals(t *testing.T) { }, }, Accounting: map[string]*AccountCharge{ - "GENUUID_GHOST1": { + "THIS_GENUUID1": { AccountID: "TestEventChargesEquals", BalanceID: "CONCRETE1", Units: NewDecimal(8, 1), BalanceLimit: NewDecimal(200, 0), UnitFactorID: "GENUUID_FACTOR1", }, - "GENUUID3": { + "GENUUID1": { AccountID: "TestEventChargesEquals", BalanceID: "ABSTRACT2", BalanceLimit: NewDecimal(0, 0), @@ -962,14 +962,14 @@ func TestEqualsExtEventCharges(t *testing.T) { }, }, Accounting: map[string]*AccountCharge{ - "GENUUID_GHOST1": { + "THIS_GENUUID1": { AccountID: "TestEventChargesEquals", BalanceID: "CONCRETE1", Units: NewDecimal(8, 1), BalanceLimit: NewDecimal(200, 0), UnitFactorID: "GENUUID_FACTOR1", }, - "GENUUID3": { + "GENUUID1": { AccountID: "TestEventChargesEquals", BalanceID: "ABSTRACT2", BalanceLimit: NewDecimal(0, 0), @@ -1145,14 +1145,14 @@ func TestEqualsExtEventCharges(t *testing.T) { }, }, Accounting: map[string]*ExtAccountCharge{ - "GENUUID_GHOST1": { + "THIS_GENUUID1": { AccountID: "TestEventChargesEquals", BalanceID: "CONCRETE1", Units: Float64Pointer(0.8), BalanceLimit: Float64Pointer(200), UnitFactorID: "GENUUID_FACTOR1", }, - "GENUUID3": { + "GENUUID1": { AccountID: "TestEventChargesEquals", BalanceID: "ABSTRACT2", BalanceLimit: Float64Pointer(0), diff --git a/utils/librates.go b/utils/librates.go index ad4c35302..112a9c115 100644 --- a/utils/librates.go +++ b/utils/librates.go @@ -116,43 +116,6 @@ func (eRt *ExtRate) Equals(extRT *ExtRate) (eq bool) { return true } -// Equals returns the equality between two Rate -func (rT *Rate) Equals(rte *Rate) (eq bool) { - if (rT.ID != rte.ID || - rT.ActivationTimes != rte.ActivationTimes || - rT.Blocker != rte.Blocker) || - (rT.FilterIDs == nil && rte.FilterIDs != nil || - rT.FilterIDs != nil && rte.FilterIDs == nil) || - (rT.Weights == nil && rte.Weights != nil || - rT.Weights != nil && rte.Weights == nil || - len(rT.Weights) != len(rte.Weights)) || - (rT.IntervalRates == nil && rte.IntervalRates != nil || - rT.IntervalRates != nil && rte.IntervalRates == nil || - len(rT.IntervalRates) != len(rte.IntervalRates)) { - return - } - for idx, val := range rT.FilterIDs { - if val != rte.FilterIDs[idx] { - return - } - } - if rT.Weights != nil && rte.Weights != nil { - for idx, val := range rT.Weights { - if ok := val.Equals(rte.Weights[idx]); !ok { - return - } - } - } - if rT.IntervalRates != nil && rte.IntervalRates != nil { - for idx, val := range rT.IntervalRates { - if ok := val.Equals(rte.IntervalRates[idx]); !ok { - return - } - } - } - return true -} - // AsExtRate converts Rate to ExtRate func (rT *Rate) AsExtRate() (eRt *ExtRate, err error) { eRt = &ExtRate{ @@ -265,8 +228,16 @@ func (eIr *ExtIntervalRate) Equals(extIr *ExtIntervalRate) (eq bool) { // Equals returns the equality between two IntervalRate func (iR *IntervalRate) Equals(inRt *IntervalRate) (eq bool) { - if ((iR != nil || inRt != nil) && - (iR == nil || inRt == nil)) || + if iR == nil && inRt == nil { + return true + } + if iR == nil && inRt != nil || + iR != nil && inRt == nil { + return + } + + return !(//((iR != nil) != (inRt != nil)) || + // (iR == nil || inRt == nil) || (iR.RecurrentFee == nil && inRt.RecurrentFee != nil) || (iR.RecurrentFee != nil && inRt.RecurrentFee == nil) || (iR.FixedFee == nil && inRt.FixedFee != nil) || @@ -276,30 +247,17 @@ func (iR *IntervalRate) Equals(inRt *IntervalRate) (eq bool) { (iR.Unit == nil && inRt.Unit != nil) || (iR.Unit != nil && inRt.Unit == nil) || (iR.IntervalStart == nil && inRt.IntervalStart != nil) || - (iR.IntervalStart != nil && inRt.IntervalStart == nil) { - return - } - if iR.RecurrentFee != nil && inRt.RecurrentFee != nil && - iR.RecurrentFee.Compare(inRt.RecurrentFee) != 0 { - return - } - if iR.FixedFee != nil && inRt.FixedFee != nil && - iR.FixedFee.Compare(inRt.FixedFee) != 0 { - return - } - if iR.Increment != nil && inRt.Increment != nil && - iR.Increment.Compare(inRt.Increment) != 0 { - return - } - if iR.Unit != nil && inRt.Unit != nil && - iR.Unit.Compare(inRt.Unit) != 0 { - return - } - if iR.IntervalStart != nil && inRt.IntervalStart != nil && - iR.IntervalStart.Compare(inRt.IntervalStart) != 0 { - return - } - return true + (iR.IntervalStart != nil && inRt.IntervalStart == nil) || + (iR.RecurrentFee != nil && inRt.RecurrentFee != nil && + iR.RecurrentFee.Compare(inRt.RecurrentFee) != 0) || + (iR.FixedFee != nil && inRt.FixedFee != nil && + iR.FixedFee.Compare(inRt.FixedFee) != 0) || + (iR.Increment != nil && inRt.Increment != nil && + iR.Increment.Compare(inRt.Increment) != 0) || + (iR.Unit != nil && inRt.Unit != nil && + iR.Unit.Compare(inRt.Unit) != 0) || + (iR.IntervalStart != nil && inRt.IntervalStart != nil && + iR.IntervalStart.Compare(inRt.IntervalStart) != 0)) } func (rt *Rate) Compile() (err error) { @@ -492,6 +450,9 @@ func (eRI *ExtRateSIncrement) Equals(extRI *ExtRateSIncrement, exInRt, exInRtRef // Equals compares two RateSIntervals func (rIl *RateSInterval) Equals(nRil *RateSInterval, rIlRef, nRilRef map[string]*IntervalRate) (eq bool) { + if rIl == nil && nRil == nil { + return true + } if rIl.IntervalStart == nil && nRil.IntervalStart != nil || rIl.IntervalStart != nil && nRil.IntervalStart == nil || (rIl.IntervalStart != nil && nRil.IntervalStart != nil && @@ -524,7 +485,9 @@ func (rI *RateSIncrement) Equals(rtIn *RateSIncrement, rIRef, rtInRef map[string rI.IncrementStart.Compare(rtIn.IncrementStart) != 0)) || rI.CompressFactor != rtIn.CompressFactor || rI.RateIntervalIndex != rtIn.RateIntervalIndex || - !rIRef[rI.RateID].Equals(rtInRef[rtIn.RateID])) + (rIRef != nil && rtInRef != nil && + rI.RateID != EmptyString && rtIn.RateID != EmptyString && + !rIRef[rI.RateID].Equals(rtInRef[rtIn.RateID]))) } // RateProfileCost is the cost returned by RateS at cost queries