From b5397e61de06f31eb3bfeca86c653600f3f48f48 Mon Sep 17 00:00:00 2001 From: TeoV Date: Tue, 9 Feb 2021 18:24:58 +0200 Subject: [PATCH] Add simple cases tests for abstract and concrete balance --- accounts/abstractbalance_test.go | 150 +++++++++++++++++++++++++++++++ accounts/concretebalance_test.go | 64 +++++++++++++ 2 files changed, 214 insertions(+) diff --git a/accounts/abstractbalance_test.go b/accounts/abstractbalance_test.go index 78fc67eb1..79c4aa7b2 100644 --- a/accounts/abstractbalance_test.go +++ b/accounts/abstractbalance_test.go @@ -190,3 +190,153 @@ func TestABDebitUsage(t *testing.T) { } } + +func TestABCost0(t *testing.T) { + // consume units only from abstract balance + aB := &abstractBalance{ + blnCfg: &utils.Balance{ + ID: "AB_COST_0", + Type: utils.MetaAbstract, + Units: utils.NewDecimal(int64(time.Duration(60*time.Second)), 0), // 1 Minute + CostIncrements: []*utils.CostIncrement{ + { + Increment: utils.NewDecimal(int64(time.Duration(time.Second)), 0), + RecurrentFee: utils.NewDecimal(0, 0), + }, + }, + }, + cncrtBlncs: []*concreteBalance{ + { + blnCfg: &utils.Balance{ + ID: "CB", + Type: utils.MetaConcrete, + Units: utils.NewDecimal(10, 0), + }, + }, + }, + fltrS: new(engine.FilterS), + } + + if ec, err := aB.debitUsage(utils.NewDecimal(int64(30*time.Second), 0), + new(utils.CGREvent)); err != nil { + t.Error(err) + } else if ec.Usage.Cmp(decimal.New(int64(30*time.Second), 0)) != 0 { + t.Errorf("Unexpected debited units: %s", ec.Usage) + } else if aB.blnCfg.Units.Compare(utils.NewDecimal(int64(30*time.Second), 0)) != 0 { + t.Errorf("Unexpected units in abstract balance: %s", aB.blnCfg.Units) + } else if aB.cncrtBlncs[0].blnCfg.Units.Compare(utils.NewDecimal(10, 0)) != 0 { + t.Errorf("Unexpected units in concrete balance: %s", aB.cncrtBlncs[0].blnCfg.Units) + } +} + +/* +TODO: discuss about this test try to debit only from abstract balance with cost 0 +func TestABCost0WithoutConcrete(t *testing.T) { + // consume units only from abstract balance + aB := &abstractBalance{ + blnCfg: &utils.Balance{ + ID: "AB_COST_0", + Type: utils.MetaAbstract, + Units: utils.NewDecimal(int64(time.Duration(60*time.Second)), 0), // 1 Minute + CostIncrements: []*utils.CostIncrement{ + { + Increment: utils.NewDecimal(int64(time.Duration(time.Second)), 0), + RecurrentFee: utils.NewDecimal(0, 0), + }, + }, + }, + fltrS: new(engine.FilterS), + } + + if ec, err := aB.debitUsage(utils.NewDecimal(int64(30*time.Second), 0), + new(utils.CGREvent)); err != nil { + t.Error(err) + } else if ec.Usage.Cmp(decimal.New(int64(30*time.Second), 0)) != 0 { + t.Errorf("Unexpected debited units: %s", ec.Usage) + } else if aB.blnCfg.Units.Compare(utils.NewDecimal(int64(30*time.Second), 0)) != 0 { + t.Errorf("Unexpected units in abstract balance: %s", aB.blnCfg.Units) + } +} +*/ + +func TestABCost0Exceed(t *testing.T) { + // consume more units that has an abstract balance + aB := &abstractBalance{ + blnCfg: &utils.Balance{ + ID: "AB_COST_0", + Type: utils.MetaAbstract, + Units: utils.NewDecimal(int64(time.Duration(60*time.Second)), 0), // 1 Minute + CostIncrements: []*utils.CostIncrement{ + { + Increment: utils.NewDecimal(int64(time.Duration(time.Second)), 0), + RecurrentFee: utils.NewDecimal(0, 0), + }, + }, + }, + cncrtBlncs: []*concreteBalance{ + { + blnCfg: &utils.Balance{ + ID: "CB", + Type: utils.MetaConcrete, + Units: utils.NewDecimal(10, 0), + }, + }, + }, + fltrS: new(engine.FilterS), + } + + if ec, err := aB.debitUsage(utils.NewDecimal(int64(70*time.Second), 0), + new(utils.CGREvent)); err != nil { + t.Error(err) + } else if ec.Usage.Cmp(decimal.New(int64(60*time.Second), 0)) != 0 { + t.Errorf("Unexpected debited units: %s", ec.Usage) + } else if aB.blnCfg.Units.Compare(utils.NewDecimal(0, 0)) != 0 { + t.Errorf("Unexpected units in abstract balance: %s", aB.blnCfg.Units) + } else if aB.cncrtBlncs[0].blnCfg.Units.Compare(utils.NewDecimal(10, 0)) != 0 { + t.Errorf("Unexpected units in concrete balance: %s", aB.cncrtBlncs[0].blnCfg.Units) + } +} + +/* +TODO: discuss about this test try to debit usage from an abstract balance with Units -1 and unlimited options +func TestABCost0WithUnlimited(t *testing.T) { + // consume more units that has an abstract balance + aB := &abstractBalance{ + blnCfg: &utils.Balance{ + ID: "AB_COST_0", + Type: utils.MetaAbstract, + Units: utils.NewDecimal(int64(time.Duration(60*time.Second)), 0), // 1 Minute + Opts: map[string]interface{}{ + utils.MetaBalanceUnlimited: true, + }, + CostIncrements: []*utils.CostIncrement{ + { + Increment: utils.NewDecimal(int64(time.Duration(time.Second)), 0), + RecurrentFee: utils.NewDecimal(0, 0), + }, + }, + }, + cncrtBlncs: []*concreteBalance{ + { + blnCfg: &utils.Balance{ + ID: "CB", + Type: utils.MetaConcrete, + Units: utils.NewDecimal(10, 0), + }, + }, + }, + fltrS: new(engine.FilterS), + } + + if ec, err := aB.debitUsage(utils.NewDecimal(int64(80*time.Second), 0), + new(utils.CGREvent)); err != nil { + t.Error(err) + } else if ec.Usage.Cmp(decimal.New(int64(80*time.Second), 0)) != 0 { + t.Errorf("Unexpected debited units: %s", ec.Usage) + } else if aB.blnCfg.Units.Compare(utils.NewDecimal(-int64(time.Duration(20*time.Second)), 0)) != 0 { + t.Errorf("Unexpected units in abstract balance: %s", aB.blnCfg.Units) + } else if aB.cncrtBlncs[0].blnCfg.Units.Compare(utils.NewDecimal(10, 0)) != 0 { + t.Errorf("Unexpected units in concrete balance: %s", aB.cncrtBlncs[0].blnCfg.Units) + } +} +*/ diff --git a/accounts/concretebalance_test.go b/accounts/concretebalance_test.go index 160839182..71f7954e9 100644 --- a/accounts/concretebalance_test.go +++ b/accounts/concretebalance_test.go @@ -124,3 +124,67 @@ func TestCBDebitUnits(t *testing.T) { } } + +func TestCBSimpleDebit(t *testing.T) { + // debit 10 units from a concrete balance with 500 units + cb := &concreteBalance{ + blnCfg: &utils.Balance{ + ID: "CB", + Type: utils.MetaConcrete, + Units: utils.NewDecimal(500, 0), // 500 Units + }, + fltrS: new(engine.FilterS), + } + toDebit := utils.NewDecimal(10, 0) + if dbted, _, err := cb.debitUnits(toDebit, + "cgrates.org", utils.MapStorage{}); err != nil { + t.Error(err) + } else if dbted.Compare(toDebit) != 0 { + t.Errorf("debited: %s", dbted) + } else if cb.blnCfg.Units.Cmp(decimal.New(490, 0)) != 0 { + t.Errorf("balance remaining: %s", cb.blnCfg.Units) + } +} + +func TestCBDebitExceed(t *testing.T) { + // debit 510 units from a concrete balance with 500 units + cb := &concreteBalance{ + blnCfg: &utils.Balance{ + ID: "CB", + Type: utils.MetaConcrete, + Units: utils.NewDecimal(500, 0), // 500 Units + }, + fltrS: new(engine.FilterS), + } + if dbted, _, err := cb.debitUnits(utils.NewDecimal(510, 0), + "cgrates.org", utils.MapStorage{}); err != nil { + t.Error(err) + } else if dbted.Compare(utils.NewDecimal(500, 0)) != 0 { + t.Errorf("debited: %s", dbted) + } else if cb.blnCfg.Units.Cmp(decimal.New(0, 0)) != 0 { + t.Errorf("balance remaining: %s", cb.blnCfg.Units) + } +} + +func TestCBDebitUnlimited(t *testing.T) { + // debit 510 units from an unlimited concrete balance with 100 units + cb := &concreteBalance{ + blnCfg: &utils.Balance{ + ID: "CB", + Type: utils.MetaConcrete, + Opts: map[string]interface{}{ + utils.MetaBalanceUnlimited: true, + }, + Units: utils.NewDecimal(100, 0), + }, + fltrS: new(engine.FilterS), + } + if dbted, _, err := cb.debitUnits(utils.NewDecimal(510, 0), + "cgrates.org", utils.MapStorage{}); err != nil { + t.Error(err) + } else if dbted.Compare(utils.NewDecimal(510, 0)) != 0 { + t.Errorf("debited: %s", dbted) + } else if cb.blnCfg.Units.Cmp(decimal.New(-410, 0)) != 0 { + t.Errorf("balance remaining: %s", cb.blnCfg.Units) + } +}