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

improving coverage tests at engine

Browse Source
This commit is contained in:
gezimbll
2022-11-29 09:58:51 -05:00
committed by Dan Christian Bogos
parent 894cca43c9
commit 4b8f5c7c23
4 changed files with 342 additions and 2 deletions
Download Patch File Download Diff File Expand all files Collapse all files

139
engine/actions_test.go
View File

@@ -3244,3 +3244,142 @@ func TestEnableDisableAccountAction(t *testing.T) {
t.Errorf("expected %+v ,received %v", expErr, err)
}
}
func TestResetAccountCDRSuccesful(t *testing.T) {
cfg := config.NewDefaultCGRConfig()
idb := NewInternalDB(nil, nil, true, cfg.DataDbCfg().Items)
dm := NewDataManager(idb, cfg.CacheCfg(), nil)
fltrs := NewFilterS(cfg, nil, dm)
cdr := &CDR{
CGRID: "Cdr1",
OrderID: 123,
ToR: utils.MetaVoice,
OriginID: "OriginCDR1",
OriginHost: "192.168.1.1",
Source: "test",
RequestType: utils.MetaRated,
Category: "call",
Account: "1001",
Subject: "1001",
Destination: "+4986517174963",
RunID: utils.MetaDefault,
Usage: time.Duration(0),
ExtraFields: map[string]string{"field_extr1": "val_extr1", "fieldextr2": "valextr2"},
Cost: 1.01,
CostDetails: &EventCost{
CGRID: "ecId",
RunID: "ecRunId",
StartTime: time.Date(2022, 12, 1, 12, 0, 0, 0, time.UTC),
Usage: utils.DurationPointer(1 * time.Hour),
Cost: utils.Float64Pointer(12.1),
Charges: []*ChargingInterval{},
AccountSummary: &AccountSummary{
Tenant: "cgrates.org",
ID: "acc_Id",
BalanceSummaries: BalanceSummaries{
{
UUID: "uuid",
ID: "summary_id",
Type: "type",
Initial: 1,
Value: 12,
Disabled: true,
}, {},
},
AllowNegative: true,
Disabled: false,
},
Accounting: Accounting{},
RatingFilters: RatingFilters{},
Rates: ChargedRates{},
},
}
if err := idb.SetCDR(cdr, true); err != nil {
t.Error(err)
}
SetCdrStorage(idb)
var extraData interface{}
acc := &Account{
ID: "cgrates.org:1001",
BalanceMap: map[string]Balances{
utils.MetaMonetary: {
&Balance{Value: 20},
},
},
UnitCounters: UnitCounters{
utils.MetaMonetary: []*UnitCounter{
{
Counters: CounterFilters{
&CounterFilter{Value: 1},
},
},
},
},
}
a := &Action{
Id: "CDRLog1",
ActionType: utils.CDRLog,
ExtraParameters: "{\"BalanceID\":\"~*acnt.BalanceID\",\"ActionID\":\"~*act.ActionID\",\"BalanceValue\":\"~*acnt.BalanceValue\"}",
Weight: 50,
}
acs := Actions{
a,
&Action{
Id: "CdrDebit",
ActionType: "*debit",
Balance: &BalanceFilter{
ID: utils.StringPointer(utils.MetaDefault),
Value: &utils.ValueFormula{Static: 9.95},
Type: utils.StringPointer(utils.MetaMonetary),
Weight: utils.Float64Pointer(0),
},
Weight: float64(90),
balanceValue: 10,
},
}
if err = resetAccountCDR(acc, a, acs, fltrs, extraData); err != nil {
t.Error(err)
}
}
/*
func TestRemoveSessionCost(t *testing.T) {
cfg := config.NewDefaultCGRConfig()
db := NewInternalDB(nil, nil, true, cfg.DataDbCfg().Items)
dm := NewDataManager(db, cfg.CacheCfg(), nil)
fl := &Filter{
Tenant: config.CgrConfig().GeneralCfg().DefaultTenant,
ID: "BalanceID;",
Rules: []*FilterRule{
{
Type: "*string",
Element: "rules",
Values: []string{},
rsrValues: config.RSRParsers{},
rsrElement: &config.RSRParser{},
rsrFilters: utils.RSRFilters{},
negative: utils.BoolPointer(false),
}, {
Type: "*string",
Element: "rules",
Values: []string{},
rsrValues: config.RSRParsers{},
rsrElement: &config.RSRParser{},
rsrFilters: utils.RSRFilters{},
negative: utils.BoolPointer(false),
},
},
}
dm.SetFilter(fl, true)
SetDataStorage(dm)
action := &Action{
ExtraParameters: "{BalanceID;~*acnt.BalanceID;ActionID;~*act.ActionID;BalanceValue;~*acnt.BalanceValue}",
}
if err := removeSessionCosts(nil, action, nil, nil, nil); err != nil {
t.Error(err)
}
}
*/

53
engine/caches_test.go
View File

@@ -819,3 +819,56 @@ func TestNewCacheS(t *testing.T) {
}
}
func TestCacheRemoveWithoutReplicate(t *testing.T) {
cfg := config.NewDefaultCGRConfig()
db := NewInternalDB(nil, nil, true, cfg.DataDbCfg().Items)
dm := NewDataManager(db, cfg.CacheCfg(), nil)
tscache := ltcache.NewTransCache(
map[string]*ltcache.CacheConfig{
"cacheId": {
MaxItems: 3,
TTL: time.Minute * 30,
StaticTTL: false,
OnEvicted: func(itmID string, value interface{}) {
},
}},
)
tscache.Set("cacheID", "itemId", "value", []string{"groupId"}, true, "tId")
chS := &CacheS{
cfg: cfg,
dm: dm,
tCache: tscache,
}
chS.RemoveWithoutReplicate("cacheID", "itemId", true, "tId")
if _, has := tscache.Get("cacheID", "itemId"); has {
t.Error("shouldn't exist")
}
}
func TestCacheRemoveGroup(t *testing.T) {
cfg := config.NewDefaultCGRConfig()
db := NewInternalDB(nil, nil, true, cfg.DataDbCfg().Items)
dm := NewDataManager(db, cfg.CacheCfg(), nil)
tscache := ltcache.NewTransCache(
map[string]*ltcache.CacheConfig{
"cacheId": {
MaxItems: 3,
TTL: time.Minute * 30,
StaticTTL: false,
OnEvicted: func(itmID string, value interface{}) {
},
}},
)
tscache.Set("cacheID", "itemId", "value", []string{"groupId"}, true, "tId")
chS := &CacheS{
cfg: cfg,
dm: dm,
tCache: tscache,
}
chS.RemoveGroup("cacheID", "groupId")
if _, has := tscache.Get("cacheID", "itemId"); has {
t.Error("shouldn't exist")
}
}

145
engine/cdrs_test.go
View File

@@ -1273,9 +1273,9 @@ func TestV1RateCDRS(t *testing.T) {
Tenant: "cgrates.org",
APIOpts: map[string]interface{}{},
}
reply := utils.StringPointer("reply")
var reply string
if err := cdrS.V1RateCDRs(arg, reply); err == nil || err != utils.ErrNotFound {
if err := cdrS.V1RateCDRs(arg, &reply); err == nil || err != utils.ErrNotFound {
t.Error(err)
}
@@ -1533,3 +1533,144 @@ func TestV2StoreSessionCost2(t *testing.T) {
}
}
func TestV1RateCDRSSuccesful(t *testing.T) {
Cache.Clear(nil)
cfg := config.NewDefaultCGRConfig()
cfg.CdrsCfg().ChargerSConns = []string{utils.ConcatenatedKey(utils.MetaInternal, utils.ChargerSConnsCfg)}
db := NewInternalDB(nil, nil, true, cfg.DataDbCfg().Items)
dm := NewDataManager(db, cfg.CacheCfg(), nil)
cdrS := &CDRServer{
cgrCfg: cfg,
cdrDb: db,
dm: dm,
connMgr: connMgr,
}
cdr := &CDR{
CGRID: "Cdr1",
OrderID: 123,
ToR: utils.MetaVoice,
OriginID: "OriginCDR1",
OriginHost: "192.168.1.1",
Source: "test",
RequestType: utils.MetaRated,
Category: "call",
Account: "1001",
Subject: "1001",
Destination: "+4986517174963",
RunID: utils.MetaDefault,
Usage: time.Duration(0),
ExtraFields: map[string]string{"field_extr1": "val_extr1", "fieldextr2": "valextr2"},
Cost: 1.01,
}
if err := cdrS.cdrDb.SetCDR(cdr, true); err != nil {
t.Error(err)
}
arg := &ArgRateCDRs{
Flags: []string{utils.MetaStore, utils.MetaExport, utils.MetaThresholds, utils.MetaStats, utils.MetaChargers, utils.MetaAttributes},
RPCCDRsFilter: utils.RPCCDRsFilter{
CGRIDs: []string{"Cdr1"},
},
Tenant: "cgrates.org",
APIOpts: map[string]interface{}{},
}
var reply *string
if err := cdrS.V1RateCDRs(arg, reply); err == nil {
t.Error(err)
}
}
func TestCdrServerStoreSMCost(t *testing.T) {
cfg := config.NewDefaultCGRConfig()
cfg.CdrsCfg().ChargerSConns = []string{utils.ConcatenatedKey(utils.MetaInternal, utils.ChargerSConnsCfg)}
db := NewInternalDB(nil, nil, true, map[string]*config.ItemOpt{
utils.CacheSessionCostsTBL: {
Limit: 2,
TTL: 2 * time.Minute,
StaticTTL: true,
Remote: false,
Replicate: true,
},
})
dm := NewDataManager(db, cfg.CacheCfg(), nil)
cdrS := &CDRServer{
cgrCfg: cfg,
cdrDb: db,
dm: dm,
connMgr: connMgr,
}
smCost := &SMCost{
CGRID: "cgrid",
RunID: "runid",
OriginHost: "originhost",
OriginID: "origin",
CostSource: "cost",
Usage: 1 * time.Minute,
CostDetails: &EventCost{
CGRID: "ecId",
RunID: "ecRunId",
StartTime: time.Date(2022, 12, 1, 12, 0, 0, 0, time.UTC),
Usage: utils.DurationPointer(1 * time.Hour),
Cost: utils.Float64Pointer(12.1),
Charges: []*ChargingInterval{},
AccountSummary: &AccountSummary{},
Accounting: Accounting{},
RatingFilters: RatingFilters{},
Rates: ChargedRates{},
},
}
if err := cdrS.cdrDb.SetSMCost(smCost); err != nil {
t.Error(err)
}
}
func TestCdrSRateCDR(t *testing.T) {
cfg := config.NewDefaultCGRConfig()
cfg.CdrsCfg().ChargerSConns = []string{utils.ConcatenatedKey(utils.MetaInternal, utils.ChargerSConnsCfg)}
db := NewInternalDB(nil, nil, true, map[string]*config.ItemOpt{
utils.CacheSessionCostsTBL: {
Limit: 2,
TTL: 2 * time.Minute,
StaticTTL: true,
Remote: false,
Replicate: true,
},
})
dm := NewDataManager(db, cfg.CacheCfg(), nil)
cdrS := &CDRServer{
cgrCfg: cfg,
cdrDb: db,
dm: dm,
connMgr: connMgr,
}
smc := &SMCost{
CGRID: "cgrid",
RunID: "runid",
OriginHost: "originHost",
OriginID: "originID",
CostSource: "cost_source",
Usage: 2 * time.Minute,
CostDetails: &EventCost{},
}
cdrS.cdrDb.SetSMCost(smc)
cdrOpts := &CDRWithAPIOpts{
CDR: &CDR{
CGRID: "cgrId",
RunID: "runId",
OrderID: 222,
Usage: 4 * time.Second,
RequestType: utils.Prepaid,
ExtraFields: map[string]string{
utils.LastUsed: "extra",
utils.OriginIDPrefix: "prefix2",
},
},
}
if _, err := cdrS.rateCDR(cdrOpts); err == nil {
t.Error(err)
}
}

7
engine/dynamicdp_test.go
View File

@@ -47,5 +47,12 @@ func TestDynamicDpFieldAsInterface(t *testing.T) {
SetConnManager(connMgr)
if _, err := dDp.fieldAsInterface([]string{utils.MetaStats, "val", "val3"}); err == nil || err != utils.ErrNotFound {
t.Error(err)
} else if _, err := dDp.fieldAsInterface([]string{utils.MetaLibPhoneNumber, "+402552663", "val3"}); err != nil {
t.Error(err)
} else if _, err := dDp.fieldAsInterface([]string{utils.MetaLibPhoneNumber, "+402552663", "val3"}); err != nil {
t.Error(err)
} else if _, err := dDp.fieldAsInterface([]string{utils.MetaAsm, "+402552663", "val3"}); err == nil || err != utils.ErrNotFound {
t.Error(err)
}
}