uppal/cgrates
1
0
Fork 1
mirror of https://github.com/cgrates/cgrates.git synced 2026-02-11 18:16:24 +05:00
Code Issues Packages Projects Releases Wiki Activity

Add more cases for accounts

Browse Source
This commit is contained in:
TeoV
2021-02-10 17:11:29 +02:00
committed by Dan Christian Bogos
parent b62039f57f
commit adaad39c3b
2 changed files with 222 additions and 1 deletions
Download Patch File Download Diff File Expand all files Collapse all files

185
accounts/abstractbalance_test.go
View File

@@ -191,7 +191,7 @@ func TestABDebitUsage(t *testing.T) {
}
func TestABCost0(t *testing.T) {
func TestABCost0WithConcrete(t *testing.T) {
// consume units only from abstract balance
aB := &abstractBalance{
blnCfg: &utils.Balance{
@@ -350,3 +350,186 @@ func TestABCost0WithUnlimited(t *testing.T) {
t.Errorf("Unexpected units in abstract balance: %s", aB.blnCfg.Units)
}
}
func TestABCost0WithUnlimitedWithConcrete(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)
}
}
func TestABCost0WithLimit(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.MetaBalanceLimit: 30000000000.0,
},
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(time.Duration(30*time.Second)), 0)) != 0 {
t.Errorf("Unexpected units in abstract balance: %s", aB.blnCfg.Units)
}
}
func TestABCost0WithLimitWithConcrete(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.MetaBalanceLimit: 30000000000.0,
},
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(time.Duration(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)
}
}
func TestABCost0WithLimitExceed(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.MetaBalanceLimit: 30000000000.0,
},
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(50*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(time.Duration(30*time.Second)), 0)) != 0 {
t.Errorf("Unexpected units in abstract balance: %s", aB.blnCfg.Units)
}
}
func TestABCost0WithLimitExceedWithConcrete(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.MetaBalanceLimit: 30000000000.0,
},
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(50*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(time.Duration(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)
}
}

38
accounts/concretebalance_test.go
View File

@@ -416,3 +416,41 @@ func TestCBDebitWithUnitFactorWithFiltersWithLimit(t *testing.T) {
t.Errorf("balance remaining: %s", cb.blnCfg.Units)
}
}
func TestCBDebitWithMultipleUnitFactor(t *testing.T) {
cfg := config.NewDefaultCGRConfig()
data := engine.NewInternalDB(nil, nil, true)
dm := engine.NewDataManager(data, config.CgrConfig().CacheCfg(), nil)
filterS := engine.NewFilterS(cfg, nil, dm)
// debit 100 units from a balance ( the unit factor doesn't match )
cb := &concreteBalance{
blnCfg: &utils.Balance{
ID: "CB",
Type: utils.MetaConcrete,
UnitFactors: []*utils.UnitFactor{
&utils.UnitFactor{
FilterIDs: []string{"*string:~*req.CustomField:CustomValue"},
Factor: utils.NewDecimal(100, 0),
},
&utils.UnitFactor{
FilterIDs: []string{"*string:~*req.CustomField2:CustomValue2"},
Factor: utils.NewDecimal(50, 0),
},
},
Units: utils.NewDecimal(500, 0), // 500 Units
},
fltrS: filterS,
}
mp := utils.MapStorage{}
mp.Set([]string{utils.MetaReq}, map[string]interface{}{
"CustomField2": "CustomValue2",
})
if dbted, _, err := cb.debitUnits(utils.NewDecimal(3, 0),
"cgrates.org", mp); err != nil {
t.Error(err)
} else if dbted.Compare(utils.NewDecimal(3, 0)) != 0 {
t.Errorf("debited: %s", dbted)
} else if cb.blnCfg.Units.Cmp(decimal.New(350, 0)) != 0 {
t.Errorf("balance remaining: %s", cb.blnCfg.Units)
}
}