From ca9602cd64e5a41b3bf941e65206fa8975bdd573 Mon Sep 17 00:00:00 2001 From: porosnicuadrian Date: Mon, 11 Oct 2021 17:29:21 +0300 Subject: [PATCH] Fixed tests in accounts --- accounts/accounts_test.go | 439 +++++++++++++++++++++++--------------- apis/account_test.go | 186 +++++----------- 2 files changed, 326 insertions(+), 299 deletions(-) diff --git a/accounts/accounts_test.go b/accounts/accounts_test.go index 1adc4789a..c470b04d9 100644 --- a/accounts/accounts_test.go +++ b/accounts/accounts_test.go @@ -794,8 +794,7 @@ func TestV1DebitAbstracts1(t *testing.T) { CostIncrements: []*utils.CostIncrement{ { Increment: utils.NewDecimal(int64(time.Second), 0), - FixedFee: utils.NewDecimal(0, 0), - RecurrentFee: utils.NewDecimal(0, 0), + RecurrentFee: utils.NewDecimal(1, 0), }, }, }, @@ -807,7 +806,7 @@ func TestV1DebitAbstracts1(t *testing.T) { }, }, Type: utils.MetaConcrete, - Units: utils.NewDecimal(213, 0), + Units: utils.NewDecimal(213, 0), // 213 - 27 }, }, } @@ -823,7 +822,7 @@ func TestV1DebitAbstracts1(t *testing.T) { utils.AccountField: "1004", }, APIOpts: map[string]interface{}{ - utils.Usage: "27s", + utils.MetaUsage: "27s", }, } reply := utils.EventCharges{} @@ -840,25 +839,66 @@ func TestV1DebitAbstracts1(t *testing.T) { } accPrf.Balances["AbstractBalance1"].Weights[0].FilterIDs = []string{} - /* - exEvCh := utils.EventCharges{ - Abstracts: utils.NewDecimal(int64(27*time.Second), 0), - } - if err := accnts.V1DebitAbstracts(context.Background(), ev, &reply); err != nil { - t.Error(err) - } else if !reflect.DeepEqual(exEvCh, reply) { - t.Errorf("Expected %+v \n, received %+v", utils.ToJSON(exEvCh), utils.ToJSON(reply)) - } - - - //now we'll check the debited account - accPrf.Balances["AbstractBalance1"].Units = &utils.Decimal{decimal.New(39999999973, 0)} - if debitedAcc, err := accnts.dm.GetAccount(context.Background(), accPrf.Tenant, accPrf.ID); err != nil { - t.Error(err) - } else if !reflect.DeepEqual(accPrf, debitedAcc) { - t.Errorf("Expected %+v \n, received %+v", utils.ToJSON(accPrf), utils.ToJSON(debitedAcc)) + exEvCh := utils.EventCharges{ + Abstracts: utils.NewDecimal(int64(27*time.Second), 0), + Concretes: utils.NewDecimal(27, 0), + Charges: []*utils.ChargeEntry{ + { + ChargingID: "CHARGE1", + CompressFactor: 1, + }, + }, + Accounting: map[string]*utils.AccountCharge{ + "CHARGE1": { + AccountID: "TestV1MaxAbstracts", + BalanceID: "AbstractBalance1", + Units: utils.NewDecimal(int64(27*time.Second), 0), + BalanceLimit: utils.NewDecimal(0, 0), + RatingID: "RATING1", + JoinedChargeIDs: []string{"JoinedCh1"}, + }, + "JoinedCh1": { + AccountID: "TestV1MaxAbstracts", + BalanceID: "ConcreteBalance2", + BalanceLimit: utils.NewDecimal(0, 0), + Units: utils.NewDecimal(27, 0), + }, + }, + UnitFactors: make(map[string]*utils.UnitFactor), + Rating: map[string]*utils.RateSInterval{ + "RATING1": { + Increments: []*utils.RateSIncrement{ + { + RateID: "41ded73", + CompressFactor: 1, + }, + }, + CompressFactor: 1, + }, + }, + Rates: make(map[string]*utils.IntervalRate), + Accounts: map[string]*utils.Account{ + "TestV1MaxAbstracts": accPrf, + }, + } + if err := accnts.V1DebitAbstracts(context.Background(), ev, &reply); err != nil { + t.Error(err) + } else { + exEvCh.Accounts["TestV1MaxAbstracts"].Balances["AbstractBalance1"].Units = utils.NewDecimal(int64(13*time.Second), 0) + exEvCh.Accounts["TestV1MaxAbstracts"].Balances["ConcreteBalance2"].Units = utils.NewDecimal(186, 0) + if !exEvCh.Equals(&reply) { + t.Errorf("Expected %+v \n, received %+v", utils.ToJSON(exEvCh), utils.ToJSON(reply)) } - */ + } + + //now we'll check the debited account + accPrf.Balances["AbstractBalance1"].Units = utils.NewDecimal(int64(13*time.Second), 0) + accPrf.Balances["ConcreteBalance2"].Units = utils.NewDecimal(186, 0) + if debitedAcc, err := accnts.dm.GetAccount(context.Background(), accPrf.Tenant, accPrf.ID); err != nil { + t.Error(err) + } else if !reflect.DeepEqual(accPrf, debitedAcc) { + t.Errorf("Expected %+v \n, received %+v", utils.ToJSON(accPrf), utils.ToJSON(debitedAcc)) + } } func TestV1MaxConcretes(t *testing.T) { @@ -889,12 +929,12 @@ func TestV1MaxConcretes(t *testing.T) { }, }, Type: utils.MetaAbstract, - Units: &utils.Decimal{decimal.New(int64(40*time.Second), 0)}, + Units: utils.NewDecimal(int64(40*time.Second), 0), CostIncrements: []*utils.CostIncrement{ { - Increment: &utils.Decimal{decimal.New(int64(time.Second), 0)}, - FixedFee: &utils.Decimal{decimal.New(0, 0)}, - RecurrentFee: &utils.Decimal{decimal.New(1, 0)}, + Increment: utils.NewDecimal(int64(time.Second), 0), + FixedFee: utils.NewDecimal(0, 0), + RecurrentFee: utils.NewDecimal(1, 0), }, }, }, @@ -906,12 +946,12 @@ func TestV1MaxConcretes(t *testing.T) { }, }, Type: utils.MetaConcrete, - Units: &utils.Decimal{decimal.New(int64(time.Minute), 0)}, + Units: utils.NewDecimal(int64(time.Second), 0), CostIncrements: []*utils.CostIncrement{ { - Increment: &utils.Decimal{decimal.New(int64(time.Second), 0)}, - FixedFee: &utils.Decimal{decimal.New(0, 0)}, - RecurrentFee: &utils.Decimal{decimal.New(1, 0)}, + Increment: utils.NewDecimal(int64(time.Second), 0), + FixedFee: utils.NewDecimal(0, 0), + RecurrentFee: utils.NewDecimal(1, 0), }, }, }, @@ -923,12 +963,12 @@ func TestV1MaxConcretes(t *testing.T) { }, }, Type: utils.MetaConcrete, - Units: &utils.Decimal{decimal.New(int64(30*time.Second), 0)}, + Units: utils.NewDecimal(int64(30*time.Second), 0), CostIncrements: []*utils.CostIncrement{ { - Increment: &utils.Decimal{decimal.New(int64(time.Second), 0)}, - FixedFee: &utils.Decimal{decimal.New(0, 0)}, - RecurrentFee: &utils.Decimal{decimal.New(1, 0)}, + Increment: utils.NewDecimal(int64(time.Second), 0), + FixedFee: utils.NewDecimal(0, 0), + RecurrentFee: utils.NewDecimal(1, 0), }, }, }, @@ -944,7 +984,9 @@ func TestV1MaxConcretes(t *testing.T) { Tenant: "cgrates.org", Event: map[string]interface{}{ utils.AccountField: "1004", - utils.Usage: "3m", + }, + APIOpts: map[string]interface{}{ + utils.MetaUsage: "3m", }, } reply := utils.EventCharges{} @@ -960,53 +1002,49 @@ func TestV1MaxConcretes(t *testing.T) { } accPrf.Balances["AbstractBalance1"].Weights[0].FilterIDs = []string{} - accPrf.Balances["ConcreteBalance1"].Units = utils.NewDecimal(0, 0) - accPrf.Balances["ConcreteBalance2"].Units = utils.NewDecimal(0, 0) - - /* - exEvCh := utils.EventCharges{ - Concretes: utils.NewDecimal(int64(time.Minute+30*time.Second), 0), - Charges: []*utils.ChargeEntry{ - { - ChargingID: "GENUUID1", - CompressFactor: 1, - }, - { - ChargingID: "GENUUID2", - CompressFactor: 1, - }, + exEvCh := utils.EventCharges{ + Concretes: utils.NewDecimal(int64(31*time.Second), 0), + Charges: []*utils.ChargeEntry{ + { + ChargingID: "GENUUID1", + CompressFactor: 1, }, - Accounting: map[string]*utils.AccountCharge{ - "GENUUID1": { - AccountID: "TestV1DebitAbstracts", - BalanceID: "ConcreteBalance1", - Units: utils.NewDecimal(int64(time.Minute), 0), - BalanceLimit: utils.NewDecimal(0, 0), - }, - "GENUUID2": { - AccountID: "TestV1DebitAbstracts", - BalanceID: "ConcreteBalance2", - Units: utils.NewDecimal(int64(30*time.Second), 0), - BalanceLimit: utils.NewDecimal(0, 0), - }, + { + ChargingID: "GENUUID2", + CompressFactor: 1, }, - UnitFactors: map[string]*utils.UnitFactor{}, - Rating: map[string]*utils.RateSInterval{}, - Rates: map[string]*utils.IntervalRate{}, - Accounts: map[string]*utils.Account{ - "TestV1DebitAbstracts": accPrf, + }, + Accounting: map[string]*utils.AccountCharge{ + "GENUUID1": { + AccountID: "TestV1DebitAbstracts", + BalanceID: "ConcreteBalance1", + Units: utils.NewDecimal(int64(time.Second), 0), + BalanceLimit: utils.NewDecimal(0, 0), }, + "GENUUID2": { + AccountID: "TestV1DebitAbstracts", + BalanceID: "ConcreteBalance2", + Units: utils.NewDecimal(int64(30*time.Second), 0), + BalanceLimit: utils.NewDecimal(0, 0), + }, + }, + UnitFactors: map[string]*utils.UnitFactor{}, + Rating: map[string]*utils.RateSInterval{}, + Rates: map[string]*utils.IntervalRate{}, + Accounts: map[string]*utils.Account{ + "TestV1DebitAbstracts": accPrf, + }, + } + if err := accnts.V1MaxConcretes(context.Background(), ev, &reply); err != nil { + t.Error(err) + } else { + exEvCh.Accounts["TestV1DebitAbstracts"].Balances["ConcreteBalance1"].Units = utils.NewDecimal(0, 0) + exEvCh.Accounts["TestV1DebitAbstracts"].Balances["ConcreteBalance2"].Units = utils.NewDecimal(0, 0) + if !exEvCh.Equals(&reply) { + //if !reflect.DeepEqual(exEvCh, reply) { + t.Errorf("Expected %+v \n, received %+v", utils.ToJSON(exEvCh), utils.ToJSON(reply)) } - if err := accnts.V1MaxConcretes(context.Background(), ev, &reply); err != nil { - t.Error(err) - } else { - exEvCh.Charges = reply.Charges - exEvCh.Accounting = reply.Accounting - if !reflect.DeepEqual(exEvCh, reply) { - t.Errorf("Expected %+v \n, received %+v", utils.ToJSON(exEvCh), utils.ToJSON(reply)) - } - } - */ + } } func TestV1DebitConcretes(t *testing.T) { @@ -1037,12 +1075,12 @@ func TestV1DebitConcretes(t *testing.T) { }, }, Type: utils.MetaAbstract, - Units: &utils.Decimal{decimal.New(int64(40*time.Second), 0)}, + Units: utils.NewDecimal(int64(40*time.Second), 0), CostIncrements: []*utils.CostIncrement{ { - Increment: &utils.Decimal{decimal.New(int64(time.Second), 0)}, - FixedFee: &utils.Decimal{decimal.New(0, 0)}, - RecurrentFee: &utils.Decimal{decimal.New(1, 0)}, + Increment: utils.NewDecimal(int64(time.Second), 0), + FixedFee: utils.NewDecimal(0, 0), + RecurrentFee: utils.NewDecimal(1, 0), }, }, }, @@ -1054,12 +1092,12 @@ func TestV1DebitConcretes(t *testing.T) { }, }, Type: utils.MetaConcrete, - Units: &utils.Decimal{decimal.New(int64(time.Minute), 0)}, + Units: utils.NewDecimal(int64(time.Minute), 0), CostIncrements: []*utils.CostIncrement{ { - Increment: &utils.Decimal{decimal.New(int64(time.Second), 0)}, - FixedFee: &utils.Decimal{decimal.New(0, 0)}, - RecurrentFee: &utils.Decimal{decimal.New(1, 0)}, + Increment: utils.NewDecimal(int64(time.Minute), 0), + FixedFee: utils.NewDecimal(0, 0), + RecurrentFee: utils.NewDecimal(1, 0), }, }, }, @@ -1071,12 +1109,12 @@ func TestV1DebitConcretes(t *testing.T) { }, }, Type: utils.MetaConcrete, - Units: &utils.Decimal{decimal.New(int64(30*time.Second), 0)}, + Units: utils.NewDecimal(int64(30*time.Second), 0), CostIncrements: []*utils.CostIncrement{ { - Increment: &utils.Decimal{decimal.New(int64(time.Second), 0)}, - FixedFee: &utils.Decimal{decimal.New(0, 0)}, - RecurrentFee: &utils.Decimal{decimal.New(1, 0)}, + Increment: utils.NewDecimal(int64(time.Minute), 0), + FixedFee: utils.NewDecimal(0, 0), + RecurrentFee: utils.NewDecimal(1, 0), }, }, }, @@ -1092,7 +1130,9 @@ func TestV1DebitConcretes(t *testing.T) { Tenant: "cgrates.org", Event: map[string]interface{}{ utils.AccountField: "1004", - utils.Usage: "3m", + }, + APIOpts: map[string]interface{}{ + utils.MetaUsage: "3m", }, } reply := utils.EventCharges{} @@ -1108,65 +1148,60 @@ func TestV1DebitConcretes(t *testing.T) { } accPrf.Balances["AbstractBalance1"].Weights[0].FilterIDs = []string{} - accPrf.Balances["ConcreteBalance1"].Units = utils.NewDecimal(0, 0) - accPrf.Balances["ConcreteBalance2"].Units = utils.NewDecimal(0, 0) - - /* - exEvCh := utils.EventCharges{ - Concretes: utils.NewDecimal(int64(time.Minute+30*time.Second), 0), - Charges: []*utils.ChargeEntry{ - { - ChargingID: "GENUUID1", - CompressFactor: 1, - }, - { - ChargingID: "GENUUID2", - CompressFactor: 1, - }, + exEvCh := utils.EventCharges{ + Concretes: utils.NewDecimal(int64(time.Minute+30*time.Second), 0), + Charges: []*utils.ChargeEntry{ + { + ChargingID: "GENUUID1", + CompressFactor: 1, }, - Accounting: map[string]*utils.AccountCharge{ - "GENUUID1": { - AccountID: "TestV1DebitAbstracts", - BalanceID: "ConcreteBalance1", - Units: utils.NewDecimal(60000000000, 0), - BalanceLimit: utils.NewDecimal(0, 0), - }, - "GENUUID2": { - AccountID: "TestV1DebitAbstracts", - BalanceID: "ConcreteBalance2", - Units: utils.NewDecimal(30000000000, 0), - BalanceLimit: utils.NewDecimal(0, 0), - }, + { + ChargingID: "GENUUID2", + CompressFactor: 1, }, - UnitFactors: map[string]*utils.UnitFactor{}, - Rating: map[string]*utils.RateSInterval{}, - Rates: map[string]*utils.IntervalRate{}, - Accounts: map[string]*utils.Account{ - "TestV1DebitAbstracts": accPrf, + }, + Accounting: map[string]*utils.AccountCharge{ + "GENUUID1": { + AccountID: "TestV1DebitAbstracts", + BalanceID: "ConcreteBalance1", + Units: utils.NewDecimal(60000000000, 0), + BalanceLimit: utils.NewDecimal(0, 0), }, + "GENUUID2": { + AccountID: "TestV1DebitAbstracts", + BalanceID: "ConcreteBalance2", + Units: utils.NewDecimal(30000000000, 0), + BalanceLimit: utils.NewDecimal(0, 0), + }, + }, + UnitFactors: map[string]*utils.UnitFactor{}, + Rating: map[string]*utils.RateSInterval{}, + Rates: map[string]*utils.IntervalRate{}, + Accounts: map[string]*utils.Account{ + "TestV1DebitAbstracts": accPrf, + }, + } + if err := accnts.V1DebitConcretes(context.Background(), args, &reply); err != nil { + t.Error(err) + } else { + exEvCh.Accounts["TestV1DebitAbstracts"].Balances["ConcreteBalance1"].Units = utils.NewDecimal(0, 0) + exEvCh.Accounts["TestV1DebitAbstracts"].Balances["ConcreteBalance2"].Units = utils.NewDecimal(0, 0) + if !exEvCh.Equals(&reply) { + //if !reflect.DeepEqual(exEvCh, reply) { + t.Errorf("Expected %+v \n, received %+v", utils.ToJSON(exEvCh), utils.ToJSON(reply)) } - if err := accnts.V1DebitConcretes(context.Background(), args, &reply); err != nil { - t.Error(err) - } else { - exEvCh.Accounting = reply.Accounting - exEvCh.Charges = reply.Charges - if !reflect.DeepEqual(exEvCh, reply) { - t.Errorf("Expected %+v \n, received %+v", utils.ToJSON(exEvCh), utils.ToJSON(reply)) - } - } - - //now we will check the debited account - rcv, err := accnts.dm.GetAccount(context.Background(), "cgrates.org", "TestV1DebitAbstracts") - if err != nil { - t.Error(err) - } - accPrf.Balances["ConcreteBalance1"].Units = &utils.Decimal{decimal.New(0, 0)} - accPrf.Balances["ConcreteBalance2"].Units = &utils.Decimal{decimal.New(0, 0)} - if !reflect.DeepEqual(rcv, accPrf) { - t.Errorf("Expected %+v, received %+v", utils.ToJSON(accPrf), utils.ToJSON(rcv)) - } - */ + } + //now we will check the debited account + rcv, err := accnts.dm.GetAccount(context.Background(), "cgrates.org", "TestV1DebitAbstracts") + if err != nil { + t.Error(err) + } + accPrf.Balances["ConcreteBalance1"].Units = &utils.Decimal{decimal.New(0, 0)} + accPrf.Balances["ConcreteBalance2"].Units = &utils.Decimal{decimal.New(0, 0)} + if !reflect.DeepEqual(rcv, accPrf) { + t.Errorf("Expected %+v, received %+v", utils.ToJSON(accPrf), utils.ToJSON(rcv)) + } } func TestMultipleAccountsErr(t *testing.T) { @@ -1899,7 +1934,6 @@ func TestV1DebitAbstractsEventCharges(t *testing.T) { */ } -/* func TestV1DebitAbstractsWithRecurrentFeeNegative(t *testing.T) { engine.Cache.Clear(nil) cfg := config.NewDefaultCGRConfig() @@ -1912,7 +1946,7 @@ func TestV1DebitAbstractsWithRecurrentFeeNegative(t *testing.T) { Tenant: "cgrates.org", ID: "TestV1DebitAbstractsWithRecurrentFeeNegative", Balances: map[string]*utils.Balance{ - "ab1": &utils.Balance{ + "ab1": { ID: "ab1", Type: utils.MetaAbstract, Weights: utils.DynamicWeights{ @@ -1927,7 +1961,7 @@ func TestV1DebitAbstractsWithRecurrentFeeNegative(t *testing.T) { }, Units: utils.NewDecimal(int64(40*time.Second), 0), }, - "cb1": &utils.Balance{ + "cb1": { ID: "cb1", Type: utils.MetaConcrete, CostIncrements: []*utils.CostIncrement{ @@ -1940,40 +1974,105 @@ func TestV1DebitAbstractsWithRecurrentFeeNegative(t *testing.T) { }, }, } - if err := dm.SetAccount(acnt, true); err != nil { + if err := dm.SetAccount(context.Background(), acnt, true); err != nil { t.Error(err) } - args := &utils.ArgsAccountsForEvent{ - CGREvent: &utils.CGREvent{ - ID: "TestV1DebitAbstractsWithRecurrentFeeNegative", - Tenant: "cgrates.org", - APIOpts: map[string]interface{}{ - utils.MetaUsage: "72h", - }, + args := &utils.CGREvent{ + ID: "TestV1DebitAbstractsWithRecurrentFeeNegative", + Tenant: "cgrates.org", + APIOpts: map[string]interface{}{ + utils.MetaUsage: "30s", }, } - expEvCh := &utils.ExtEventCharges{ - Abstracts: utils.Float64Pointer(259200000000000), - Concretes: utils.Float64Pointer(-259198), - Accounting: map[string]*utils.ExtAccountCharge{}, - UnitFactors: map[string]*utils.ExtUnitFactor{}, - Rating: map[string]*utils.ExtRateSInterval{}} - ev := &utils.ExtEventCharges{} - if err := accnts.V1DebitAbstracts(args, ev); err != nil { + expEvCh := &utils.EventCharges{ + Abstracts: utils.NewDecimal(int64(30*time.Second), 0), + Concretes: utils.NewDecimal(-28, 0), + Charges: []*utils.ChargeEntry{ + { + ChargingID: "CHARGE1", + CompressFactor: 1, + }, + { + ChargingID: "CHARGE2", + CompressFactor: 1, + }, + }, + Accounting: map[string]*utils.AccountCharge{ + "CHARGE1": { + AccountID: "TestV1DebitAbstractsWithRecurrentFeeNegative", + BalanceID: "ab1", + Units: utils.NewDecimal(int64(time.Second), 0), + BalanceLimit: utils.NewDecimal(0, 0), + RatingID: "RATING1", + JoinedChargeIDs: []string{"JOINED1"}, + }, + "JOINED1": { + AccountID: "TestV1DebitAbstractsWithRecurrentFeeNegative", + BalanceID: "cb1", + Units: utils.NewDecimal(1, 0), + BalanceLimit: utils.NewDecimal(0, 0), + }, + "CHARGE2": { + AccountID: "TestV1DebitAbstractsWithRecurrentFeeNegative", + BalanceID: utils.MetaTransAbstract, + Units: utils.NewDecimal(int64(29*time.Second), 0), + RatingID: "RATING2", + JoinedChargeIDs: []string{"JOINED2"}, + }, + "JOINED2": { + AccountID: "TestV1DebitAbstractsWithRecurrentFeeNegative", + BalanceID: "cb1", + Units: utils.NewDecimal(-29, 0), + BalanceLimit: utils.NewDecimal(0, 0), + }, + }, + UnitFactors: map[string]*utils.UnitFactor{}, + Rating: map[string]*utils.RateSInterval{ + "RATING1": { + Increments: []*utils.RateSIncrement{ + { + RateIntervalIndex: 0, + RateID: "5772dd3", + CompressFactor: 1, + }, + }, + CompressFactor: 1, + }, + "RATING2": { + Increments: []*utils.RateSIncrement{ + { + RateIntervalIndex: 0, + RateID: "75a070c", + CompressFactor: 1, + }, + }, + CompressFactor: 1, + }, + }, + Rates: map[string]*utils.IntervalRate{}, + Accounts: map[string]*utils.Account{ + "TestV1DebitAbstractsWithRecurrentFeeNegative": acnt, + }, + } + ev := &utils.EventCharges{} + if err := accnts.V1DebitAbstracts(context.Background(), args, ev); err != nil { t.Error(err) - } else if !reflect.DeepEqual(ev, expEvCh) { - t.Errorf("Expected %+v, received %+v", utils.ToJSON(expEvCh), utils.ToJSON(ev)) + } else { + expEvCh.Accounts["TestV1DebitAbstractsWithRecurrentFeeNegative"].Balances["ab1"].Units = utils.NewDecimal(int64(39*time.Second), 0) + expEvCh.Accounts["TestV1DebitAbstractsWithRecurrentFeeNegative"].Balances["cb1"].Units = utils.NewDecimal(29, 0) + if !ev.Equals(expEvCh) { + t.Errorf("Expected %+v \n, received %+v", utils.ToJSON(expEvCh), utils.ToJSON(ev)) + } } acnt.Balances["ab1"].Units = utils.NewDecimal(int64(39*time.Second), 0) - acnt.Balances["cb1"].Units = utils.NewDecimal(259199, 0) - if rcv, err := dm.GetAccount(acnt.Tenant, acnt.ID); err != nil { + acnt.Balances["cb1"].Units = utils.NewDecimal(29, 0) + if rcv, err := dm.GetAccount(context.Background(), acnt.Tenant, acnt.ID); err != nil { t.Error(err) } else if !reflect.DeepEqual(rcv, acnt) { - t.Errorf("Expected %+v,received %+v", utils.ToJSON(acnt), utils.ToJSON(rcv)) + t.Errorf("Expected %+v \n, received %+v", utils.ToJSON(acnt), utils.ToJSON(rcv)) } } -*/ func TestDebitAbstractsMaxDebitAbstractFromConcreteNoConcrBal(t *testing.T) { // this test will call maxDebitAbstractsFromConcretes but without any concreteBal and not calling rates diff --git a/apis/account_test.go b/apis/account_test.go index 8ad4051d5..c3929434a 100644 --- a/apis/account_test.go +++ b/apis/account_test.go @@ -1052,7 +1052,6 @@ func TestAccountAccountsForEvent(t *testing.T) { engine.Cache = cacheInit } -/* func TestAccountMaxAbstracts(t *testing.T) { cacheInit := engine.Cache cfg := config.NewDefaultCGRConfig() @@ -1079,7 +1078,8 @@ func TestAccountMaxAbstracts(t *testing.T) { }, CostIncrements: []*utils.APICostIncrement{ { - Increment: utils.Float64Pointer(0.1), + RecurrentFee: utils.Float64Pointer(0.1), + Increment: utils.Float64Pointer(0.1), }, }, Units: 0, @@ -1128,7 +1128,8 @@ func TestAccountMaxAbstracts(t *testing.T) { Units: utils.NewDecimal(0, 0), CostIncrements: []*utils.CostIncrement{ { - Increment: utils.NewDecimal(1, 1), + RecurrentFee: utils.NewDecimal(1, 1), + Increment: utils.NewDecimal(1, 1), }, }, }, @@ -1153,7 +1154,7 @@ func TestAccountMaxAbstracts(t *testing.T) { if !reflect.DeepEqual(expected, accSv1) { t.Errorf("\nExpected <%+v>, \nReceived <%+v>", utils.ToJSON(expected), utils.ToJSON(accSv1)) } - var rpEv utils.ExtEventCharges + var rpEv utils.EventCharges ev := &utils.CGREvent{ ID: "TestMatchingAccountsForEvent", Tenant: "cgrates.org", @@ -1166,15 +1167,7 @@ func TestAccountMaxAbstracts(t *testing.T) { if err != nil { t.Errorf("\nExpected <%+v>, \nReceived <%+v>", nil, err) } - var accKEy, rtID string - for key, val := range rpEv.Accounting { - accKEy = key - rtID = val.RatingID - } - var crgID string - for _, val := range rpEv.Charges { - crgID = val.ChargingID - } + expRating := &utils.ExtRateSInterval{ IntervalStart: nil, Increments: []*utils.ExtRateSIncrement{ @@ -1194,30 +1187,14 @@ func TestAccountMaxAbstracts(t *testing.T) { t.Errorf("\nExpected <%+v>, \nReceived <%+v>", utils.ToJSON(expRating), utils.ToJSON(val)) } } - rpEv.Rating = map[string]*utils.ExtRateSInterval{} - expEvAcc := &utils.ExtEventCharges{ - Abstracts: utils.Float64Pointer(0), - Charges: []*utils.ChargeEntry{ - { - ChargingID: crgID, - CompressFactor: 1, - }, - }, - Accounting: map[string]*utils.ExtAccountCharge{ - accKEy: { - AccountID: "test_ID1", - BalanceID: "VoiceBalance", - Units: utils.Float64Pointer(0), - BalanceLimit: utils.Float64Pointer(0), - UnitFactorID: "", - RatingID: rtID, - JoinedChargeIDs: nil, - }, - }, - UnitFactors: map[string]*utils.ExtUnitFactor{}, - Rating: map[string]*utils.ExtRateSInterval{}, - Rates: map[string]*utils.ExtIntervalRate{}, - Accounts: map[string]*utils.ExtAccount{ + rpEv.Rating = map[string]*utils.RateSInterval{} + expEvAcc := &utils.EventCharges{ + Abstracts: utils.NewDecimal(0, 0), + Accounting: map[string]*utils.AccountCharge{}, + UnitFactors: map[string]*utils.UnitFactor{}, + Rating: map[string]*utils.RateSInterval{}, + Rates: map[string]*utils.IntervalRate{}, + Accounts: map[string]*utils.Account{ "test_ID1": { Tenant: "cgrates.org", ID: "test_ID1", @@ -1227,7 +1204,7 @@ func TestAccountMaxAbstracts(t *testing.T) { Weight: 10, }, }, - Balances: map[string]*utils.ExtBalance{ + Balances: map[string]*utils.Balance{ "VoiceBalance": { ID: "VoiceBalance", Weights: utils.DynamicWeights{ @@ -1240,12 +1217,13 @@ func TestAccountMaxAbstracts(t *testing.T) { Opts: map[string]interface{}{ "Destination": 10, }, - CostIncrements: []*utils.ExtCostIncrement{ + CostIncrements: []*utils.CostIncrement{ { - Increment: utils.Float64Pointer(0.1), + RecurrentFee: utils.NewDecimal(1, 1), + Increment: utils.NewDecimal(1, 1), }, }, - Units: utils.Float64Pointer(0), + Units: utils.NewDecimal(0, 0), }, }, Opts: map[string]interface{}{}, @@ -1254,13 +1232,11 @@ func TestAccountMaxAbstracts(t *testing.T) { } eql := rpEv.Equals(expEvAcc) if eql != true { - t.Errorf("\nExpected <%+v>, \nReceived <%+v>", true, eql) + t.Errorf("\nExpected <%+v>, \nReceived <%+v>", utils.ToJSON(expEvAcc), utils.ToJSON(rpEv)) } engine.Cache = cacheInit } -*/ -/* func TestAccountDebitAbstracts(t *testing.T) { cacheInit := engine.Cache cfg := config.NewDefaultCGRConfig() @@ -1287,7 +1263,8 @@ func TestAccountDebitAbstracts(t *testing.T) { }, CostIncrements: []*utils.APICostIncrement{ { - Increment: utils.Float64Pointer(0.1), + RecurrentFee: utils.Float64Pointer(1), + Increment: utils.Float64Pointer(0.1), }, }, Units: 0, @@ -1363,7 +1340,7 @@ func TestAccountDebitAbstracts(t *testing.T) { if !reflect.DeepEqual(expected, accSv1) { t.Errorf("\nExpected <%+v>, \nReceived <%+v>", utils.ToJSON(expected), utils.ToJSON(accSv1)) } - var rpEv utils.ExtEventCharges + var rpEv utils.EventCharges ev := &utils.CGREvent{ ID: "TestMatchingAccountsForEvent", Tenant: "cgrates.org", @@ -1375,16 +1352,9 @@ func TestAccountDebitAbstracts(t *testing.T) { err = accSv1.DebitAbstracts(context.Background(), ev, &rpEv) if err != nil { t.Error(err) + } - var accKEy, rtID string - for key, val := range rpEv.Accounting { - accKEy = key - rtID = val.RatingID - } - var crgID string - for _, val := range rpEv.Charges { - crgID = val.ChargingID - } + expRating := &utils.ExtRateSInterval{ Increments: []*utils.ExtRateSIncrement{ { @@ -1401,30 +1371,14 @@ func TestAccountDebitAbstracts(t *testing.T) { t.Errorf("\nExpected <%+v>, \nReceived <%+v>", utils.ToJSON(expRating), utils.ToJSON(val)) } } - rpEv.Rating = map[string]*utils.ExtRateSInterval{} - expEvAcc := &utils.ExtEventCharges{ - Abstracts: utils.Float64Pointer(0), - Charges: []*utils.ChargeEntry{ - { - ChargingID: crgID, - CompressFactor: 1, - }, - }, - Accounting: map[string]*utils.ExtAccountCharge{ - accKEy: { - AccountID: "test_ID1", - BalanceID: "VoiceBalance", - Units: utils.Float64Pointer(0), - BalanceLimit: utils.Float64Pointer(0), - UnitFactorID: "", - RatingID: rtID, - JoinedChargeIDs: nil, - }, - }, - UnitFactors: map[string]*utils.ExtUnitFactor{}, - Rating: map[string]*utils.ExtRateSInterval{}, - Rates: map[string]*utils.ExtIntervalRate{}, - Accounts: map[string]*utils.ExtAccount{ + rpEv.Rating = map[string]*utils.RateSInterval{} + expEvAcc := &utils.EventCharges{ + Abstracts: utils.NewDecimal(0, 0), + Accounting: map[string]*utils.AccountCharge{}, + UnitFactors: map[string]*utils.UnitFactor{}, + Rating: map[string]*utils.RateSInterval{}, + Rates: map[string]*utils.IntervalRate{}, + Accounts: map[string]*utils.Account{ "test_ID1": { Tenant: "cgrates.org", ID: "test_ID1", @@ -1434,7 +1388,7 @@ func TestAccountDebitAbstracts(t *testing.T) { Weight: 10, }, }, - Balances: map[string]*utils.ExtBalance{ + Balances: map[string]*utils.Balance{ "VoiceBalance": { ID: "VoiceBalance", Weights: utils.DynamicWeights{ @@ -1447,13 +1401,13 @@ func TestAccountDebitAbstracts(t *testing.T) { Opts: map[string]interface{}{ "Destination": 10, }, - CostIncrements: []*utils.ExtCostIncrement{ + CostIncrements: []*utils.CostIncrement{ { - RecurrentFee: utils.Float64Pointer(1), - Increment: utils.Float64Pointer(0.1), + RecurrentFee: utils.NewDecimal(1, 0), + Increment: utils.NewDecimal(1, 1), }, }, - Units: utils.Float64Pointer(0), + Units: utils.NewDecimal(0, 0), }, }, Opts: map[string]interface{}{}, @@ -1466,9 +1420,7 @@ func TestAccountDebitAbstracts(t *testing.T) { } engine.Cache = cacheInit } -*/ -/* func TestAccountActionSetBalance(t *testing.T) { cacheInit := engine.Cache cfg := config.NewDefaultCGRConfig() @@ -1495,7 +1447,8 @@ func TestAccountActionSetBalance(t *testing.T) { }, CostIncrements: []*utils.APICostIncrement{ { - Increment: utils.Float64Pointer(0.1), + RecurrentFee: utils.Float64Pointer(0.1), + Increment: utils.Float64Pointer(0.1), }, }, Units: 0, @@ -1545,7 +1498,8 @@ func TestAccountActionSetBalance(t *testing.T) { }, CostIncrements: []*utils.CostIncrement{ { - Increment: utils.NewDecimal(1, 1), + RecurrentFee: utils.NewDecimal(1, 1), + Increment: utils.NewDecimal(1, 1), }, }, Units: utils.NewDecimal(0, 0), @@ -1570,7 +1524,7 @@ func TestAccountActionSetBalance(t *testing.T) { if !reflect.DeepEqual(expected, accSv1) { t.Errorf("\nExpected <%+v>, \nReceived <%+v>", utils.ToJSON(expected), utils.ToJSON(accSv1)) } - var rpEv utils.ExtEventCharges + var rpEv utils.EventCharges ev := &utils.CGREvent{ ID: "TestMatchingAccountsForEvent", Tenant: "cgrates.org", @@ -1583,24 +1537,14 @@ func TestAccountActionSetBalance(t *testing.T) { if err != nil { t.Errorf("\nExpected <%+v>, \nReceived <%+v>", nil, err) } - var accKEy, rtID string - for key, val := range rpEv.Accounting { - accKEy = key - rtID = val.RatingID - } - var crgID string - for _, val := range rpEv.Charges { - crgID = val.ChargingID - } + expRating := &utils.ExtRateSInterval{ IntervalStart: nil, Increments: []*utils.ExtRateSIncrement{ { - IncrementStart: nil, IntervalRateIndex: 0, RateID: "id_for_test", CompressFactor: 1, - Usage: nil, }, }, CompressFactor: 1, @@ -1611,30 +1555,14 @@ func TestAccountActionSetBalance(t *testing.T) { t.Errorf("\nExpected <%+v>, \nReceived <%+v>", expRating, val) } } - rpEv.Rating = map[string]*utils.ExtRateSInterval{} - expEvAcc := &utils.ExtEventCharges{ - Abstracts: utils.Float64Pointer(0), - Charges: []*utils.ChargeEntry{ - { - ChargingID: crgID, - CompressFactor: 1, - }, - }, - Accounting: map[string]*utils.ExtAccountCharge{ - accKEy: { - AccountID: "test_ID1", - BalanceID: "VoiceBalance", - Units: utils.Float64Pointer(0), - BalanceLimit: utils.Float64Pointer(0), - UnitFactorID: "", - RatingID: rtID, - JoinedChargeIDs: nil, - }, - }, - UnitFactors: map[string]*utils.ExtUnitFactor{}, - Rating: map[string]*utils.ExtRateSInterval{}, - Rates: map[string]*utils.ExtIntervalRate{}, - Accounts: map[string]*utils.ExtAccount{ + rpEv.Rating = map[string]*utils.RateSInterval{} + expEvAcc := &utils.EventCharges{ + Abstracts: utils.NewDecimal(0, 0), + Accounting: map[string]*utils.AccountCharge{}, + UnitFactors: map[string]*utils.UnitFactor{}, + Rating: map[string]*utils.RateSInterval{}, + Rates: map[string]*utils.IntervalRate{}, + Accounts: map[string]*utils.Account{ "test_ID1": { Tenant: "cgrates.org", ID: "test_ID1", @@ -1644,7 +1572,7 @@ func TestAccountActionSetBalance(t *testing.T) { Weight: 10, }, }, - Balances: map[string]*utils.ExtBalance{ + Balances: map[string]*utils.Balance{ "VoiceBalance": { ID: "VoiceBalance", Weights: utils.DynamicWeights{ @@ -1657,12 +1585,13 @@ func TestAccountActionSetBalance(t *testing.T) { Opts: map[string]interface{}{ "Destination": 10, }, - CostIncrements: []*utils.ExtCostIncrement{ + CostIncrements: []*utils.CostIncrement{ { - Increment: utils.Float64Pointer(0.1), + RecurrentFee: utils.NewDecimal(1, 1), + Increment: utils.NewDecimal(1, 1), }, }, - Units: utils.Float64Pointer(0), + Units: utils.NewDecimal(0, 0), }, }, Opts: map[string]interface{}{}, @@ -1675,7 +1604,6 @@ func TestAccountActionSetBalance(t *testing.T) { } engine.Cache = cacheInit } -*/ func TestAccountActionRemoveBalance(t *testing.T) { engine.Cache.Clear(nil)