uppal/cgrates
1
0
Fork 1
mirror of https://github.com/cgrates/cgrates.git synced 2026-02-25 09:08:45 +05:00
Code Issues Packages Projects Releases Wiki Activity

Improving coverage for unit tests

Browse Source
This commit is contained in:
gezimbll
2023-03-17 11:57:51 -04:00
committed by Dan Christian Bogos
parent 35091a5538
commit 39393aecb7
3 changed files with 408 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

72
engine/actions_test.go
View File

@@ -24,6 +24,7 @@ import (
"testing"
"time"
"github.com/cgrates/cgrates/config"
"github.com/cgrates/cgrates/utils"
"github.com/cgrates/rpcclient"
)
@@ -2585,6 +2586,77 @@ func TestCacheGetClonedActions(t *testing.T) {
}
}
func TestRemoveSessionCosts(t *testing.T) {
cfg, _ := config.NewDefaultCGRConfig()
db := NewInternalDB(nil, nil, true, cfg.DataDbCfg().Items)
tmpDM := dm
dm := NewDataManager(db, cfg.CacheCfg(), nil)
defer func() {
SetCdrStorage(cdrStorage)
SetDataStorage(tmpDM)
}()
aT := &ActionTiming{
ActionsID: "ACT_LOG",
}
SetDataStorage(dm)
SetCdrStorage(db)
fltrs := []*Filter{
{
Tenant: "cgrates.org",
ID: "FLTR_1",
Rules: []*FilterRule{
{
Element: utils.DynamicDataPrefix + utils.RunID,
Type: utils.MetaString,
Values: []string{"RunID"},
},
},
},
{
Tenant: "cgrates.org",
ID: "FLTR_2",
Rules: []*FilterRule{
{
Type: utils.MetaGreaterOrEqual,
Element: "~Usage",
Values: []string{"12s", "33s"},
},
},
},
}
for _, fltr := range fltrs {
dm.SetFilter(fltr)
}
acs := Actions{
{
ActionType: utils.MetaRemoveSessionCosts,
Balance: &BalanceFilter{
Type: utils.StringPointer(utils.MONETARY),
Value: &utils.ValueFormula{Static: 25},
DestinationIDs: utils.StringMapPointer(utils.NewStringMap("RET")),
Weight: utils.Float64Pointer(20)},
ExtraParameters: "FLTR_1;FLTR_2",
},
}
smCost := &SMCost{
RunID: "RunID",
Usage: 12 * time.Second,
CostDetails: &EventCost{
CGRID: "EventCost_CGRID",
Cost: utils.Float64Pointer(0.74),
},
}
if err := db.SetSMCost(smCost); err != nil {
t.Error(err)
}
if err := dm.SetActions("ACT_LOG", acs, utils.NonTransactional); err != nil {
t.Error(err)
}
if err := aT.Execute(nil, nil); err != nil {
t.Error(err)
}
}
// TestCdrLogAction
type RPCMock struct {
args *ArgV1ProcessEvent

156
engine/datamanager_test.go
View File

@@ -18,6 +18,8 @@ along with this program. If not, see <http://www.gnu.org/licenses/>
package engine
import (
"errors"
"reflect"
"testing"
"time"
@@ -187,3 +189,157 @@ func TestDmMatchFilterIndexFromKey(t *testing.T) {
}
//unifinished
}
func TestCacheDataFromDB(t *testing.T) {
cfg, _ := config.NewDefaultCGRConfig()
db := NewInternalDB(nil, nil, true, cfg.DataDbCfg().Items)
dm := NewDataManager(db, cfg.CacheCfg(), nil)
chgS := ChargerProfiles{
&ChargerProfile{
Tenant: "cgrates.org",
ID: "Charger1",
FilterIDs: []string{"*string:~*req.Account:1015", "*gt:~*req.Usage:10"},
ActivationInterval: &utils.ActivationInterval{
ActivationTime: time.Date(2014, 7, 29, 15, 0, 0, 0, time.UTC),
},
RunID: utils.MetaDefault,
AttributeIDs: []string{"*none"},
Weight: 20,
},
&ChargerProfile{
Tenant: "cgrates.com",
ID: "CHRG_1",
FilterIDs: []string{"*string:Account:1001"},
ActivationInterval: &utils.ActivationInterval{
ActivationTime: time.Date(2014, 7, 14, 14, 25, 0, 0, time.UTC),
ExpiryTime: time.Date(2014, 7, 14, 14, 25, 0, 0, time.UTC),
},
AttributeIDs: []string{"ATTR_1"},
Weight: 20,
},
}
for _, chg := range chgS {
if err := dm.SetChargerProfile(chg, true); err != nil {
t.Error(err)
}
}
if err := dm.CacheDataFromDB(utils.ChargerProfilePrefix, nil, false); err != nil {
t.Error(err)
}
}
func TestCacheDataFromDBFilterIndexes(t *testing.T) {
cfg, _ := config.NewDefaultCGRConfig()
db := NewInternalDB(nil, nil, true, cfg.DataDbCfg().Items)
dm := NewDataManager(db, cfg.CacheCfg(), nil)
fltr := &Filter{
Tenant: "cgrates.org",
ID: "FLTR_ATTR_1",
Rules: []*FilterRule{
{
Type: utils.MetaString,
Element: "~*req.Attribute",
Values: []string{"AttributeProfile1"},
},
{
Type: utils.MetaGreaterOrEqual,
Element: "~*req.UsageInterval",
Values: []string{(1 * time.Second).String()},
},
{
Type: utils.MetaGreaterOrEqual,
Element: "~*req." + utils.Weight,
Values: []string{"9.0"},
},
},
}
dm.SetFilter(fltr)
attr := &AttributeProfile{
Tenant: "cgrates.org",
ID: "ATTR_1001_SIMPLEAUTH",
FilterIDs: []string{"FLTR_ATTR_1"},
Contexts: []string{"simpleauth"},
Attributes: []*Attribute{
{
FilterIDs: []string{},
Path: utils.MetaReq + utils.NestingSep + "Password",
Type: utils.META_CONSTANT,
Value: config.NewRSRParsersMustCompile("CGRateS.org", true, utils.INFIELD_SEP),
},
},
Weight: 20.0,
}
dm.SetAttributeProfile(attr, true)
if err := dm.CacheDataFromDB(utils.AttributeFilterIndexes, nil, false); err != nil {
t.Error(err)
}
}
func TestFilterIndexesRmtRpl(t *testing.T) {
cfg, _ := config.NewDefaultCGRConfig()
Cache.Clear(nil)
cfg.DataDbCfg().Items[utils.MetaFilterIndexes].Remote = true
cfg.DataDbCfg().Items[utils.MetaFilterIndexes].Replicate = true
cfg.DataDbCfg().RplConns = []string{utils.ConcatenatedKey(utils.MetaInternal, utils.ReplicatorSv1)}
cfg.DataDbCfg().RmtConns = []string{utils.ConcatenatedKey(utils.MetaInternal, utils.ReplicatorSv1)}
defer func() {
cfg2, _ := config.NewDefaultCGRConfig()
config.SetCgrConfig(cfg2)
}()
db := NewInternalDB(nil, nil, true, cfg.DataDbCfg().Items)
expIndx := map[string]utils.StringMap{
"*string:Account:1001": {
"RL1": true,
},
"*string:Account:1002": {
"RL1": true,
"RL2": true,
},
}
clientConn := make(chan rpcclient.ClientConnector, 1)
clientConn <- clMock(func(m string, a, r interface{}) error {
if m == utils.ReplicatorSv1SetFilterIndexes {
setFltrIndxArg, concat := a.(*utils.SetFilterIndexesArg)
if !concat {
return errors.New("Can't convert interfacea")
}
if err := dm.DataDB().SetFilterIndexesDrv(setFltrIndxArg.CacheID, setFltrIndxArg.ItemIDPrefix, setFltrIndxArg.Indexes, false, utils.EmptyString); err == nil {
*r.(*string) = utils.OK
}
return nil
} else if m == utils.ReplicatorSv1GetFilterIndexes {
rpl := expIndx
*r.(*map[string]utils.StringMap) = rpl
return nil
}
return utils.ErrNotImplemented
})
connMgr := NewConnManager(cfg, map[string]chan rpcclient.ClientConnector{
utils.ConcatenatedKey(utils.MetaInternal, utils.ReplicatorSv1): clientConn,
})
dm := NewDataManager(db, cfg.CacheCfg(), connMgr)
idx := map[string]utils.StringMap{
"*string:Account:1001": {
"DSP1": true,
"DSP2": true,
},
"*suffix:*opts.Destination:+100": {
"Dsp1": true,
"Dsp2": true,
},
}
config.SetCgrConfig(cfg)
if err := dm.SetFilterIndexes(utils.CacheDispatcherProfiles, "cgrates.org", idx, false, utils.NonTransactional); err != nil {
t.Error(err)
}
if err := dm.RemoveFilterIndexes(utils.CacheDispatcherProfiles, "cgrates.org"); err != nil {
t.Error(err)
}
if rcvIdx, err := dm.GetFilterIndexes(utils.CacheResourceProfiles, "cgrates.org", utils.EmptyString, nil); err != nil {
t.Error(err)
} else if !reflect.DeepEqual(expIndx, rcvIdx) {
t.Errorf("Expected %+v,Received %+v", utils.ToJSON(expIndx), utils.ToJSON(idx))
}
}

180
engine/storage_test.go
View File

@@ -18,6 +18,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>
package engine
import (
"fmt"
"reflect"
"testing"
"time"
@@ -466,3 +467,182 @@ func TestTPThresholds(t *testing.T) {
t.Errorf("Expected %v,Received %v", utils.ToJSON(thresholds), utils.ToJSON(thds))
}
}
func TestTPFilters(t *testing.T) {
cfg, _ := config.NewDefaultCGRConfig()
db := NewInternalDB(nil, nil, false, cfg.StorDbCfg().Items)
tpFltr := []*utils.TPFilterProfile{
{
TPid: "TP1",
Tenant: "cgrates.org",
ID: "FLT_1",
Filters: []*utils.TPFilter{
{
Element: "Account",
Type: utils.MetaString,
Values: []string{"1001", "1002"},
},
{
Type: utils.MetaGreaterOrEqual,
Element: utils.DynamicDataPrefix + utils.MetaReq + utils.NestingSep + utils.Weight,
Values: []string{"15.0"},
},
},
},
{
TPid: "TP1",
Tenant: "cgrates.org",
ID: "FLT_2",
Filters: []*utils.TPFilter{
{
Type: utils.MetaPrefix,
Element: "~*req.Cost",
Values: []string{"10", "15", "210"},
},
},
},
}
if err := db.SetTPFilters(tpFltr); err != nil {
t.Error(err)
}
for i := range tpFltr {
if fltr, err := db.GetTPFilters("TP1", "cgrates.org", fmt.Sprintf("FLT_%d", i+1)); err != nil {
t.Error(err)
} else if !reflect.DeepEqual(fltr, tpFltr[i:i+1]) {
t.Errorf("Expected %v,Received %v", utils.ToJSON(tpFltr[i:i+1]), utils.ToJSON(fltr))
}
}
}
func TestTPAttributes(t *testing.T) {
cfg, _ := config.NewDefaultCGRConfig()
db := NewInternalDB(nil, nil, false, cfg.StorDbCfg().Items)
tpAttr := []*utils.TPAttributeProfile{
{
TPid: "TP1",
Tenant: "cgrates.org",
ID: "Attr1",
ActivationInterval: &utils.TPActivationInterval{
ActivationTime: "2019-07-29T15:00:00Z",
ExpiryTime: "",
},
Contexts: []string{"con1"},
Attributes: []*utils.TPAttribute{
{
Path: utils.MetaReq + utils.NestingSep + "FL1",
Value: "Al1",
FilterIDs: []string{},
},
},
Weight: 20,
},
{
TPid: "TP1",
Tenant: "cgrates.org",
ID: "Attr2",
Contexts: []string{"con1"},
ActivationInterval: &utils.TPActivationInterval{
ActivationTime: "2019-07-14T14:35:00Z",
ExpiryTime: "",
},
Attributes: []*utils.TPAttribute{
{
Path: utils.MetaReq + utils.NestingSep + "FL1",
Value: "Al1",
},
},
Weight: 20},
}
if err := db.SetTPAttributes(tpAttr); err != nil {
t.Error(err)
}
for i := range tpAttr {
if attr, err := db.GetTPAttributes("TP1", "cgrates.org", fmt.Sprintf("Attr%d", i+1)); err != nil {
t.Error(err)
} else if !reflect.DeepEqual(attr, tpAttr[i:i+1]) {
t.Errorf("Expected %v,Received %v", utils.ToJSON(tpAttr[i:i+1]), utils.ToJSON(attr))
}
}
}
func TestTPChargers(t *testing.T) {
cfg, _ := config.NewDefaultCGRConfig()
db := NewInternalDB(nil, nil, false, cfg.StorDbCfg().Items)
tpChrg := []*utils.TPChargerProfile{
{
TPid: "TP1",
Tenant: "cgrates.org",
ID: "Charger1",
RunID: "*rated",
ActivationInterval: &utils.TPActivationInterval{
ActivationTime: "2022-07-14T14:35:00Z",
ExpiryTime: "",
},
Weight: 20},
{
TPid: "TP1",
Tenant: "cgrates.org",
ID: "Charger2",
RunID: "*prepaid",
ActivationInterval: &utils.TPActivationInterval{
ActivationTime: "2022-08-14T14:35:00Z",
ExpiryTime: "",
},
Weight: 20,
},
}
if err := db.SetTPChargers(tpChrg); err != nil {
t.Error(err)
}
for i := range tpChrg {
if cpps, err := db.GetTPChargers("TP1", "cgrates.org", fmt.Sprintf("Charger%d", i+1)); err != nil {
t.Error(err)
} else if !reflect.DeepEqual(cpps, tpChrg[i:i+1]) {
t.Errorf("Expected %v,Received %v", utils.ToJSON(tpChrg[i:i+1]), utils.ToJSON(cpps))
}
}
}
func TestTPDispatcher(t *testing.T) {
cfg, _ := config.NewDefaultCGRConfig()
db := NewInternalDB(nil, nil, false, cfg.StorDbCfg().Items)
tpDsp := []*utils.TPDispatcherProfile{
{
TPid: "TP1",
Tenant: "cgrates.org",
ID: "Dsp1",
FilterIDs: []string{"*string:Account:1002"},
ActivationInterval: &utils.TPActivationInterval{
ActivationTime: "2021-07-29T15:00:00Z",
ExpiryTime: "",
},
Strategy: utils.MetaFirst,
Weight: 10,
}, {
TPid: "TP1",
Tenant: "cgrates.org",
ID: "Dsp2",
Subsystems: []string{"*any"},
FilterIDs: []string{},
Strategy: utils.MetaFirst,
ActivationInterval: &utils.TPActivationInterval{
ActivationTime: "2022-07-14T14:35:00Z",
ExpiryTime: "",
},
StrategyParams: []interface{}{},
Weight: 20,
},
}
if err := db.SetTPDispatcherProfiles(tpDsp); err != nil {
t.Error(err)
}
for i := range tpDsp {
if dpp, err := db.GetTPDispatcherProfiles("TP1", "cgrates.org", fmt.Sprintf("Dsp%d", i+1)); err != nil {
t.Error(err)
} else if !reflect.DeepEqual(dpp, tpDsp[i:i+1]) {
t.Errorf("Expected %v,Received %v", utils.ToJSON(tpDsp[i:i+1]), utils.ToJSON(dpp))
}
}
}