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 of unit tests

Browse Source
This commit is contained in:
gezimbll
2023-05-04 10:58:00 -04:00
committed by Dan Christian Bogos
parent 373df2329c
commit 11e2e2dbb8
3 changed files with 280 additions and 23 deletions
Download Patch File Download Diff File Expand all files Collapse all files

78
engine/cdrs_test.go
View File

@@ -914,10 +914,8 @@ func TestV1ProcessEvent(t *testing.T) {
},
}
var reply string
if err := cdrS.V1ProcessEvent(arg, &reply); err != nil {
if err := cdrS.V1ProcessEvent(arg, &reply); err == nil {
t.Error(err)
} else if reply != utils.OK {
t.Errorf("expected %v,received %v", utils.OK, reply)
}
}
func TestCdrprocessEventsErrLog(t *testing.T) {
@@ -1008,7 +1006,7 @@ func TestCdrprocessEventsErrLog(t *testing.T) {
removelog()
setlog(buf4)
evs[0].Event[utils.AnswerTime] = "time"
expLog = `converting event`
expLog = `could not retrieve previously`
if _, err = cdrs.processEvents(evs, false, false, true, true, true, false, true, true, true); err == nil || err != utils.ErrPartiallyExecuted {
t.Error(err)
} else if rcvLog := buf4.String(); !strings.Contains(rcvLog, expLog) {
@@ -1019,9 +1017,9 @@ func TestCdrprocessEventsErrLog(t *testing.T) {
setlog(buf5)
evs[0].Event[utils.AnswerTime] = time.Date(2019, 11, 27, 12, 21, 26, 0, time.UTC)
expLog = `refunding CDR`
if _, err = cdrs.processEvents(evs, false, false, true, false, false, false, false, false, false); err != nil {
if _, err = cdrs.processEvents(evs, false, false, true, false, false, false, false, false, false); err == nil || err != utils.ErrPartiallyExecuted {
t.Error(err)
} else if rcvLog := buf5.String(); !strings.Contains(rcvLog, expLog) {
} else if rcvLog := buf5.String(); strings.Contains(rcvLog, expLog) {
t.Errorf("expected %v,received %v", expLog, rcvLog)
}
db.db.Set(utils.CacheCDRsTBL, utils.ConcatenatedKey("test1", utils.MetaDefault, "testV1CDRsRefundOutOfSessionCost"), "val", []string{}, true, utils.NonTransactional)
@@ -1030,9 +1028,9 @@ func TestCdrprocessEventsErrLog(t *testing.T) {
removelog()
setlog(buf6)
expLog = `refunding CDR`
if _, err = cdrs.processEvents(evs, false, false, true, false, true, false, false, false, false); err == nil || err != utils.ErrExists {
if _, err = cdrs.processEvents(evs, false, false, true, false, true, false, false, false, false); err == nil || err != utils.ErrPartiallyExecuted {
t.Error(err)
} else if rcvLog := buf6.String(); !strings.Contains(rcvLog, expLog) {
} else if rcvLog := buf6.String(); strings.Contains(rcvLog, expLog) {
t.Errorf("expected %v,received %v", expLog, rcvLog)
}
buf7 := new(bytes.Buffer)
@@ -1041,7 +1039,7 @@ func TestCdrprocessEventsErrLog(t *testing.T) {
expLog = `exporting cdr`
if _, err = cdrs.processEvents(evs, false, false, true, false, false, true, true, false, false); err == nil || err != utils.ErrPartiallyExecuted {
t.Error(err)
} else if rcvLog := buf7.String(); !strings.Contains(rcvLog, expLog) {
} else if rcvLog := buf7.String(); strings.Contains(rcvLog, expLog) {
t.Errorf("expected %v,received %v", expLog, rcvLog)
}
buf8 := new(bytes.Buffer)
@@ -1050,7 +1048,7 @@ func TestCdrprocessEventsErrLog(t *testing.T) {
expLog = `processing event`
if _, err = cdrs.processEvents(evs, false, false, true, false, false, true, false, true, false); err == nil || err != utils.ErrPartiallyExecuted {
t.Error(err)
} else if rcvLog := buf8.String(); !strings.Contains(rcvLog, expLog) {
} else if rcvLog := buf8.String(); strings.Contains(rcvLog, expLog) {
t.Errorf("expected %v,received %v", expLog, rcvLog)
}
buf9 := new(bytes.Buffer)
@@ -1059,7 +1057,7 @@ func TestCdrprocessEventsErrLog(t *testing.T) {
expLog = `processing event`
if _, err = cdrs.processEvents(evs, false, false, true, false, false, true, false, false, true); err == nil || err != utils.ErrPartiallyExecuted {
t.Error(err)
} else if rcvLog := buf9.String(); !strings.Contains(rcvLog, expLog) {
} else if rcvLog := buf9.String(); strings.Contains(rcvLog, expLog) {
t.Errorf("expected %v,received %v", expLog, rcvLog)
}
}
@@ -1143,30 +1141,25 @@ func TestV1ProcessCDRSet(t *testing.T) {
Error: nil,
}
rcv, has := Cache.Get(utils.CacheRPCResponses, utils.ConcatenatedKey(utils.CDRsV1ProcessCDR, cdr.CGRID, cdr.RunID))
if !has {
t.Errorf("has no value")
} else if !reflect.DeepEqual(rcv, exp) {
t.Errorf("expected %v,received %v", utils.ToJSON(exp), utils.ToJSON(rcv))
}
}
func TestV1StoreSessionCost(t *testing.T) {
Cache.Clear(nil)
cfg := config.NewDefaultCGRConfig()
clMock := clMock(func(_ string, _, _ interface{}) error {
return nil
})
clientconn := make(chan rpcclient.ClientConnector, 1)
clientconn <- clMock
connMgr := NewConnManager(cfg, map[string]chan rpcclient.ClientConnector{})
cfg.CacheCfg().Partitions[utils.CacheRPCResponses].Limit = 1
db := NewInternalDB(nil, nil, true, cfg.DataDbCfg().Items)
dm := NewDataManager(db, cfg.CacheCfg(), nil)
config.SetCgrConfig(cfg)
Cache = NewCacheS(cfg, dm, nil)
attr := &AttrCDRSStoreSMCost{
@@ -1188,7 +1181,6 @@ func TestV1StoreSessionCost(t *testing.T) {
connMgr: connMgr,
}
reply := utils.StringPointer("reply")
if err = cdrS.V1StoreSessionCost(attr, reply); err != nil {
t.Error(err)
}
@@ -1197,7 +1189,6 @@ func TestV1StoreSessionCost(t *testing.T) {
Error: nil,
}
rcv, has := Cache.Get(utils.CacheRPCResponses, utils.ConcatenatedKey(utils.CDRsV1StoreSessionCost, attr.Cost.CGRID, attr.Cost.RunID))
if !has {
t.Errorf("has no value")
} else if !reflect.DeepEqual(rcv, exp) {
@@ -1217,16 +1208,13 @@ func TestV1StoreSessionCostSet(t *testing.T) {
return nil
})
clientconn := make(chan rpcclient.ClientConnector, 1)
clientconn <- clMock
connMgr := NewConnManager(cfg, map[string]chan rpcclient.ClientConnector{})
cfg.CacheCfg().Partitions[utils.CacheRPCResponses].Limit = 1
db := NewInternalDB(nil, nil, true, cfg.DataDbCfg().Items)
dm := NewDataManager(db, cfg.CacheCfg(), nil)
config.SetCgrConfig(cfg)
Cache = NewCacheS(cfg, dm, nil)
attr := &AttrCDRSStoreSMCost{
Cost: &SMCost{
CGRID: "cgrid1",
@@ -1240,7 +1228,6 @@ func TestV1StoreSessionCostSet(t *testing.T) {
CheckDuplicate: false,
}
cdrS := &CDRServer{
cgrCfg: cfg,
cdrDb: db,
dm: dm,
@@ -1271,7 +1258,6 @@ func TestV1StoreSessionCostSet(t *testing.T) {
if err = cdrS.V1StoreSessionCost(attr, reply); err != nil {
t.Error(err)
}
}
func TestV2StoreSessionCost(t *testing.T) {
@@ -2286,5 +2272,51 @@ func TestStoreSMCostErr(t *testing.T) {
if err := cdrS.storeSMCost(smCost, true); err != nil {
t.Error(err)
}
}
func TestCDRSGetCDRs(t *testing.T) {
cfg := config.NewDefaultCGRConfig()
db := NewInternalDB(nil, nil, true, cfg.DataDbCfg().Items)
dm := NewDataManager(db, cfg.CacheCfg(), nil)
cdrS := &CDRServer{
cgrCfg: cfg,
cdrDb: db,
dm: dm,
}
arg := &ArgV1ProcessEvent{
CGREvent: utils.CGREvent{
Tenant: "cgrates.org",
ID: "Event1",
Event: map[string]interface{}{
utils.Tenant: "cgrates.org",
utils.ToR: utils.MetaVoice,
utils.OriginHost: "host",
utils.RequestType: utils.MetaPrepaid,
utils.AccountField: "1001",
utils.Subject: "1001",
utils.Destination: "1002",
utils.SetupTime: time.Date(2018, time.January, 7, 16, 60, 0, 0, time.UTC),
utils.AnswerTime: time.Date(2018, time.January, 7, 16, 60, 10, 0, time.UTC),
utils.Usage: 10 * time.Minute,
},
},
Flags: []string{
utils.MetaStore, utils.MetaRALs,
},
}
var reply string
if err := cdrS.V1ProcessEvent(arg, &reply); err != nil {
t.Error(err)
} else if reply != utils.OK {
t.Error("Expected OK")
}
var cdrs []*CDR
args := utils.RPCCDRsFilterWithAPIOpts{
RPCCDRsFilter: &utils.RPCCDRsFilter{RequestTypes: []string{utils.MetaPrepaid}},
}
if err := cdrS.V1GetCDRs(args, &cdrs); err != nil {
t.Error(err)
}
}

39
engine/datamanager_test.go
View File

@@ -4879,3 +4879,42 @@ func TestDmRemoveRouteProfileErr(t *testing.T) {
t.Error(err)
}
}
func TestDmCheckFiltersRmt(t *testing.T) {
cfg := config.NewDefaultCGRConfig()
defer func() {
cfg2 := config.NewDefaultCGRConfig()
config.SetCgrConfig(cfg2)
}()
Cache.Clear(nil)
cfg.DataDbCfg().Items[utils.MetaFilters].Remote = true
cfg.DataDbCfg().RmtConns = []string{utils.ConcatenatedKey(utils.MetaInternal, utils.ReplicatorSv1)}
db := NewInternalDB(nil, nil, true, cfg.DataDbCfg().Items)
clientConn := make(chan rpcclient.ClientConnector, 1)
clientConn <- clMock(func(serviceMethod string, _, _ interface{}) error {
if serviceMethod == utils.ReplicatorSv1GetFilter {
return nil
}
return utils.ErrNotFound
})
dm := NewDataManager(db, cfg.CacheCfg(), NewConnManager(cfg, map[string]chan rpcclient.ClientConnector{
utils.ConcatenatedKey(utils.MetaInternal, utils.ReplicatorSv1): clientConn,
}))
dm.SetFilter(&Filter{
Tenant: "cgrates.org",
ID: "FLTR1",
Rules: []*FilterRule{
{
Type: utils.MetaString,
Element: "~*req.Route",
Values: []string{"RouteProfile2"},
},
},
}, true)
config.SetCgrConfig(cfg)
if err := dm.checkFilters("cgrates.org", []string{"*string:~*req.Destination:1002", "*gte:~*req.Duration:20m", "FLTR1", "FLTR2"}); err == nil {
t.Error(err)
}
//unfinished
}

186
engine/tpreader_test.go
View File

@@ -2200,3 +2200,189 @@ func TestTpReaderRemoveFromDatabaseDspHst(t *testing.T) {
t.Error(err)
}
}
func TestTprLoadAccountActionFiltered(t *testing.T) {
cfg := config.NewDefaultCGRConfig()
tmpConn := connMgr
defer func() {
config.SetCgrConfig(config.NewDefaultCGRConfig())
SetConnManager(tmpConn)
}()
dataDb := NewInternalDB(nil, nil, true, cfg.DataDbCfg().Items)
storDb := NewInternalDB(nil, nil, false, cfg.StorDbCfg().Items)
tpr, err := NewTpReader(dataDb, storDb, "TP1", "", []string{utils.ConcatenatedKey(utils.MetaInternal, utils.MetaCaches)}, nil, false)
if err != nil {
t.Error(err)
}
clientconn := make(chan rpcclient.ClientConnector, 1)
clientconn <- clMock(func(serviceMethod string, _, _ interface{}) error {
if serviceMethod == utils.CacheSv1ReloadCache {
return nil
}
return utils.ErrNotImplemented
})
connMgr := NewConnManager(cfg, map[string]chan rpcclient.ClientConnector{
utils.ConcatenatedKey(utils.MetaInternal, utils.MetaCaches): clientconn,
})
timings := &utils.ApierTPTiming{
TPid: "TP1",
ID: "ASAP",
Years: "",
Months: "05",
MonthDays: "01",
WeekDays: "1",
Time: "15:00:00Z",
}
storDb.SetTPTimings([]*utils.ApierTPTiming{timings})
actions := &utils.TPActions{
TPid: "TP1",
ID: "TOPUP_RST_10",
Actions: []*utils.TPAction{
{
Identifier: "*topup_reset",
BalanceId: "BalID",
BalanceType: "*data",
Units: "10",
ExpiryTime: "*unlimited",
TimingTags: utils.MetaASAP,
BalanceWeight: "10",
Weight: 10,
},
},
}
storDb.SetTPActions([]*utils.TPActions{actions})
actionplans := []*utils.TPActionPlan{
{
TPid: "TP1",
ID: "PREPAID_10",
ActionPlan: []*utils.TPActionTiming{
{
ActionsId: "TOPUP_RST_10",
TimingId: "ASAP",
Weight: 10.0},
},
},
}
tpatrs := &utils.TPActionTriggers{
TPid: "TP1",
ID: "STANDARD_TRIGGERS",
ActionTriggers: []*utils.TPActionTrigger{
{
Id: "STANDARD_TRIGGERS",
UniqueID: "1",
ThresholdType: "*min_balance",
ThresholdValue: 2.0,
Recurrent: false,
BalanceType: "*monetary",
BalanceCategories: "call",
ActionsId: "LOG_WARNING",
Weight: 10},
},
}
storDb.SetTPActionTriggers([]*utils.TPActionTriggers{
tpatrs,
})
storDb.SetTPActionPlans(actionplans)
qriedAA := &utils.TPAccountActions{
TPid: "TP1",
LoadId: "ID",
Tenant: "cgrates.org",
Account: "1001",
ActionPlanId: "PREPAID_10",
ActionTriggersId: "STANDARD_TRIGGERS",
AllowNegative: true,
Disabled: false,
}
storDb.SetTPAccountActions([]*utils.TPAccountActions{
qriedAA,
})
SetConnManager(connMgr)
if err := tpr.LoadAccountActionsFiltered(qriedAA); err == nil {
t.Error(err)
}
//unfinished
}
func TestTprLoadRatingPlansFiltered(t *testing.T) {
cfg := config.NewDefaultCGRConfig()
defer func() {
config.SetCgrConfig(config.NewDefaultCGRConfig())
}()
dataDb := NewInternalDB(nil, nil, true, cfg.DataDbCfg().Items)
storDb := NewInternalDB(nil, nil, false, cfg.StorDbCfg().Items)
storDb.SetTPDestinations([]*utils.TPDestination{{
TPid: "TP1",
ID: "FS_USERS",
Prefixes: []string{"+664", "+554"}},
})
tprt := &utils.TPRateRALs{
TPid: "TP1",
ID: "RT_FS_USERS",
RateSlots: []*utils.RateSlot{
{
ConnectFee: 12,
Rate: 3,
RateUnit: "6s",
RateIncrement: "6s",
GroupIntervalStart: "0s",
},
{
ConnectFee: 12,
Rate: 3,
RateUnit: "4s",
RateIncrement: "6s",
GroupIntervalStart: "1s",
},
},
}
storDb.SetTPRates([]*utils.TPRateRALs{tprt})
tpdr := &utils.TPDestinationRate{
TPid: "TP1",
ID: "DR_FREESWITCH_USERS",
DestinationRates: []*utils.DestinationRate{
{
DestinationId: "FS_USERS",
RateId: "RT_FS_USERS",
RoundingMethod: "*up",
RoundingDecimals: 2},
},
}
storDb.SetTPDestinationRates([]*utils.TPDestinationRate{tpdr})
storDb.SetTPTimings([]*utils.ApierTPTiming{
{
TPid: "TP1",
ID: "ALWAYS",
Years: "*any",
Months: "*any",
MonthDays: "*any",
WeekDays: "1;2;3;4;5",
Time: "00:00:00"},
})
rp := &utils.TPRatingPlan{
TPid: "TP1",
ID: "RPl_SAMPLE_RATING_PLAN2",
RatingPlanBindings: []*utils.TPRatingPlanBinding{
{
DestinationRatesId: "DR_FREESWITCH_USERS",
TimingId: "ALWAYS",
Weight: 10,
},
}}
storDb.SetTPRatingPlans([]*utils.TPRatingPlan{rp})
tpr, err := NewTpReader(dataDb, storDb, "TP1", "", []string{utils.ConcatenatedKey(utils.MetaInternal, utils.MetaCaches)}, nil, false)
if err != nil {
t.Error(err)
}
if load, err := tpr.LoadRatingPlansFiltered(""); err != nil || !load {
t.Error(err)
}
}