uppal/cgrates
1
0
Fork 1
mirror of https://github.com/cgrates/cgrates.git synced 2026-02-14 20:59:53 +05:00
Code Issues Packages Projects Releases Wiki Activity

Added tests for FieldAsInterface methods

Browse Source
This commit is contained in:
Trial97
2021-12-10 14:02:43 +02:00
committed by Dan Christian Bogos
parent 0e363e7104
commit 1a61335b62
13 changed files with 1364 additions and 51 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
engine/actionprofile.go
View File

@@ -290,6 +290,9 @@ func (ap *ActionProfile) FieldAsInterface(fldPath []string) (_ interface{}, err
default:
return nil, utils.ErrNotFound
case utils.Actions:
if idxStr == nil {
return nil, utils.ErrNotFound
}
var idx int
if idx, err = strconv.Atoi(*idxStr); err != nil {
return
@@ -318,6 +321,15 @@ func (a *APAction) FieldAsString(fldPath []string) (_ string, err error) {
func (cp *APAction) FieldAsInterface(fldPath []string) (_ interface{}, err error) {
switch len(fldPath) {
default:
if fld, idxStr := utils.GetPathIndexString(fldPath[0]); fld == utils.Opts {
path := fldPath[1:]
if idxStr != nil {
path = append([]string{*idxStr}, path...)
}
return utils.MapStorage(cp.Opts).FieldAsInterface(path)
}
fallthrough
case 0:
return nil, utils.ErrNotFound
case 1:
switch fldPath[0] {

272
engine/actionprofile_test.go
View File

@@ -246,3 +246,275 @@ func TestActionProfileSet(t *testing.T) {
t.Errorf("Expected %v \n but received \n %v", utils.ToJSON(exp), utils.ToJSON(ap))
}
}
func TestActionProfileFieldAsInterface(t *testing.T) {
ap := ActionProfile{
Tenant: "cgrates.org",
ID: "ID",
FilterIDs: []string{"fltr1", "*string:~*req.Account:1001"},
Schedule: utils.MetaNow,
Weight: 10,
Targets: map[string]utils.StringSet{
utils.MetaAccounts: utils.NewStringSet([]string{"1001", "1002"}),
utils.MetaThresholds: utils.NewStringSet([]string{"TH1", "TH2"}),
},
Actions: []*APAction{{
ID: "acc1",
Type: "val1",
FilterIDs: []string{"fltr1"},
Blocker: true,
TTL: 10,
Opts: map[string]interface{}{
"opt0": "val1",
"opt1": "val1",
"opt2": "val1",
"opt3": utils.MapStorage{"opt4": "val1"},
},
Diktats: []*APDiktat{{
Path: "path",
Value: "val1",
}},
}},
}
if _, err := ap.FieldAsInterface(nil); err != utils.ErrNotFound {
t.Fatal(err)
}
if _, err := ap.FieldAsInterface([]string{"field"}); err != utils.ErrNotFound {
t.Fatal(err)
}
if _, err := ap.FieldAsInterface([]string{"field", ""}); err != utils.ErrNotFound {
t.Fatal(err)
}
if val, err := ap.FieldAsInterface([]string{utils.Tenant}); err != nil {
t.Fatal(err)
} else if exp := "cgrates.org"; exp != val {
t.Errorf("Expected %v \n but received \n %v", utils.ToJSON(exp), utils.ToJSON(val))
}
if val, err := ap.FieldAsInterface([]string{utils.ID}); err != nil {
t.Fatal(err)
} else if exp := utils.ID; exp != val {
t.Errorf("Expected %v \n but received \n %v", utils.ToJSON(exp), utils.ToJSON(val))
}
if val, err := ap.FieldAsInterface([]string{utils.FilterIDs}); err != nil {
t.Fatal(err)
} else if exp := ap.FilterIDs; !reflect.DeepEqual(exp, val) {
t.Errorf("Expected %v \n but received \n %v", utils.ToJSON(exp), utils.ToJSON(val))
}
if val, err := ap.FieldAsInterface([]string{utils.FilterIDs + "[0]"}); err != nil {
t.Fatal(err)
} else if exp := ap.FilterIDs[0]; exp != val {
t.Errorf("Expected %v \n but received \n %v", utils.ToJSON(exp), utils.ToJSON(val))
}
if val, err := ap.FieldAsInterface([]string{utils.Weight}); err != nil {
t.Fatal(err)
} else if exp := ap.Weight; !reflect.DeepEqual(exp, val) {
t.Errorf("Expected %v \n but received \n %v", utils.ToJSON(exp), utils.ToJSON(val))
}
if val, err := ap.FieldAsInterface([]string{utils.Actions}); err != nil {
t.Fatal(err)
} else if exp := ap.Actions; !reflect.DeepEqual(exp, val) {
t.Errorf("Expected %v \n but received \n %v", utils.ToJSON(exp), utils.ToJSON(val))
}
if val, err := ap.FieldAsInterface([]string{utils.Schedule}); err != nil {
t.Fatal(err)
} else if exp := ap.Schedule; !reflect.DeepEqual(exp, val) {
t.Errorf("Expected %v \n but received \n %v", utils.ToJSON(exp), utils.ToJSON(val))
}
if val, err := ap.FieldAsInterface([]string{utils.Targets}); err != nil {
t.Fatal(err)
} else if exp := ap.Targets; !reflect.DeepEqual(exp, val) {
t.Errorf("Expected %v \n but received \n %v", utils.ToJSON(exp), utils.ToJSON(val))
}
if val, err := ap.FieldAsInterface([]string{utils.Actions + "[0]"}); err != nil {
t.Fatal(err)
} else if exp := ap.Actions[0]; !reflect.DeepEqual(exp, val) {
t.Errorf("Expected %v \n but received \n %v", utils.ToJSON(exp), utils.ToJSON(val))
}
if val, err := ap.FieldAsInterface([]string{utils.Targets + "[*accounts]"}); err != nil {
t.Fatal(err)
} else if exp := ap.Targets[utils.MetaAccounts]; !reflect.DeepEqual(exp, val) {
t.Errorf("Expected %v \n but received \n %v", utils.ToJSON(exp), utils.ToJSON(val))
}
expErrMsg := `strconv.Atoi: parsing "a": invalid syntax`
if _, err := ap.FieldAsInterface([]string{utils.FilterIDs + "[a]"}); err == nil || err.Error() != expErrMsg {
t.Errorf("Expeceted: %v, received: %v", expErrMsg, err)
}
if _, err := ap.FieldAsInterface([]string{utils.Actions + "[a]"}); err == nil || err.Error() != expErrMsg {
t.Errorf("Expeceted: %v, received: %v", expErrMsg, err)
}
if _, err := ap.FieldAsInterface([]string{utils.Actions + "[a]", "a"}); err == nil || err.Error() != expErrMsg {
t.Errorf("Expeceted: %v, received: %v", expErrMsg, err)
}
if _, err := ap.FieldAsInterface([]string{utils.Actions, ""}); err != utils.ErrNotFound {
t.Fatal(err)
}
if _, err := ap.FieldAsInterface([]string{utils.Actions + "[4]", "a"}); err != utils.ErrNotFound {
t.Fatal(err)
}
if _, err := ap.FieldAsInterface([]string{utils.Targets + "[4]", "a"}); err != utils.ErrNotFound {
t.Fatal(err)
}
if val, err := ap.FieldAsInterface([]string{utils.Targets + "[*accounts]", "1001"}); err != nil {
t.Fatal(err)
} else if exp := ap.Targets[utils.MetaAccounts]["1001"]; !reflect.DeepEqual(exp, val) {
t.Errorf("Expected %v \n but received \n %v", utils.ToJSON(exp), utils.ToJSON(val))
}
if _, err := ap.FieldAsInterface([]string{utils.Actions + "[0]", "a"}); err != utils.ErrNotFound {
t.Fatal(err)
}
if val, err := ap.FieldAsInterface([]string{utils.Actions + "[0]", utils.Blocker}); err != nil {
t.Fatal(err)
} else if exp := ap.Actions[0].Blocker; !reflect.DeepEqual(exp, val) {
t.Errorf("Expected %v \n but received \n %v", utils.ToJSON(exp), utils.ToJSON(val))
}
if val, err := ap.FieldAsInterface([]string{utils.Actions + "[0]", utils.ID}); err != nil {
t.Fatal(err)
} else if exp := ap.Actions[0].ID; !reflect.DeepEqual(exp, val) {
t.Errorf("Expected %v \n but received \n %v", utils.ToJSON(exp), utils.ToJSON(val))
}
if val, err := ap.FieldAsInterface([]string{utils.Actions + "[0]", utils.FilterIDs}); err != nil {
t.Fatal(err)
} else if exp := ap.Actions[0].FilterIDs; !reflect.DeepEqual(exp, val) {
t.Errorf("Expected %v \n but received \n %v", utils.ToJSON(exp), utils.ToJSON(val))
}
if val, err := ap.FieldAsInterface([]string{utils.Actions + "[0]", utils.TTL}); err != nil {
t.Fatal(err)
} else if exp := ap.Actions[0].TTL; !reflect.DeepEqual(exp, val) {
t.Errorf("Expected %v \n but received \n %v", utils.ToJSON(exp), utils.ToJSON(val))
}
if val, err := ap.FieldAsInterface([]string{utils.Actions + "[0]", utils.Diktats}); err != nil {
t.Fatal(err)
} else if exp := ap.Actions[0].Diktats; !reflect.DeepEqual(exp, val) {
t.Errorf("Expected %v \n but received \n %v", utils.ToJSON(exp), utils.ToJSON(val))
}
if val, err := ap.FieldAsInterface([]string{utils.Actions + "[0]", utils.Type}); err != nil {
t.Fatal(err)
} else if exp := ap.Actions[0].Type; !reflect.DeepEqual(exp, val) {
t.Errorf("Expected %v \n but received \n %v", utils.ToJSON(exp), utils.ToJSON(val))
}
if val, err := ap.FieldAsInterface([]string{utils.Actions + "[0]", utils.Opts}); err != nil {
t.Fatal(err)
} else if exp := ap.Actions[0].Opts; !reflect.DeepEqual(exp, val) {
t.Errorf("Expected %v \n but received \n %v", utils.ToJSON(exp), utils.ToJSON(val))
}
if _, err := ap.FieldAsInterface([]string{utils.Actions + "[0]", utils.Opts + "[0]"}); err != utils.ErrNotFound {
t.Fatal(err)
}
if val, err := ap.FieldAsInterface([]string{utils.Actions + "[0]", utils.FilterIDs + "[0]"}); err != nil {
t.Fatal(err)
} else if exp := ap.Actions[0].FilterIDs[0]; !reflect.DeepEqual(exp, val) {
t.Errorf("Expected %v \n but received \n %v", utils.ToJSON(exp), utils.ToJSON(val))
}
if val, err := ap.FieldAsInterface([]string{utils.Actions + "[0]", utils.Diktats + "[0]"}); err != nil {
t.Fatal(err)
} else if exp := ap.Actions[0].Diktats[0]; !reflect.DeepEqual(exp, val) {
t.Errorf("Expected %v \n but received \n %v", utils.ToJSON(exp), utils.ToJSON(val))
}
if _, err := ap.FieldAsInterface([]string{utils.Actions + "[0]", utils.FilterIDs + "[a]"}); err == nil || err.Error() != expErrMsg {
t.Errorf("Expeceted: %v, received: %v", expErrMsg, err)
}
if _, err := ap.FieldAsInterface([]string{utils.Actions + "[0]", utils.Diktats + "[a]"}); err == nil || err.Error() != expErrMsg {
t.Errorf("Expeceted: %v, received: %v", expErrMsg, err)
}
if _, err := ap.FieldAsInterface([]string{utils.Actions + "[0]", utils.Opts + "0"}); err != utils.ErrNotFound {
t.Fatal(err)
}
if _, err := ap.FieldAsInterface([]string{utils.Actions + "[0]", utils.Opts + "0", "0"}); err != utils.ErrNotFound {
t.Fatal(err)
}
if _, err := ap.FieldAsInterface([]string{utils.Actions + "[0]", utils.Opts + "[0]", ""}); err != utils.ErrNotFound {
t.Fatal(err)
}
if _, err := ap.FieldAsInterface([]string{utils.Actions + "[0]", utils.Opts + "[0]", "", ""}); err != utils.ErrNotFound {
t.Fatal(err)
}
if _, err := ap.FieldAsInterface([]string{utils.Actions + "[0]", "" + "[0]", "", ""}); err != utils.ErrNotFound {
t.Fatal(err)
}
if _, err := ap.FieldAsInterface([]string{utils.Actions + "[0]", utils.Diktats, "0"}); err != utils.ErrNotFound {
t.Fatal(err)
}
if _, err := ap.FieldAsInterface([]string{utils.Actions + "[0]", utils.Diktats + "[4]", "0"}); err != utils.ErrNotFound {
t.Fatal(err)
}
if _, err := ap.FieldAsInterface([]string{utils.Actions + "[0]", utils.Diktats + "[0]", "0"}); err != utils.ErrNotFound {
t.Fatal(err)
}
if _, err := ap.FieldAsInterface([]string{utils.Actions + "[0]", utils.Diktats + "[a]", "0"}); err == nil || err.Error() != expErrMsg {
t.Errorf("Expeceted: %v, received: %v", expErrMsg, err)
}
if val, err := ap.FieldAsInterface([]string{utils.Actions + "[0]", utils.Diktats + "[0]", utils.Path}); err != nil {
t.Fatal(err)
} else if exp := ap.Actions[0].Diktats[0].Path; !reflect.DeepEqual(exp, val) {
t.Errorf("Expected %v \n but received \n %v", utils.ToJSON(exp), utils.ToJSON(val))
}
if val, err := ap.FieldAsInterface([]string{utils.Actions + "[0]", utils.Diktats + "[0]", utils.Value}); err != nil {
t.Fatal(err)
} else if exp := ap.Actions[0].Diktats[0].Value; !reflect.DeepEqual(exp, val) {
t.Errorf("Expected %v \n but received \n %v", utils.ToJSON(exp), utils.ToJSON(val))
}
if _, err := ap.FieldAsString([]string{""}); err != utils.ErrNotFound {
t.Fatal(err)
}
if val, err := ap.FieldAsString([]string{utils.Tenant}); err != nil {
t.Fatal(err)
} else if exp := "cgrates.org"; exp != val {
t.Errorf("Expected %v \n but received \n %v", utils.ToJSON(exp), utils.ToJSON(val))
}
if val, exp := ap.String(), utils.ToJSON(ap); exp != val {
t.Errorf("Expected %v \n but received \n %v", utils.ToJSON(exp), utils.ToJSON(val))
}
if _, err := ap.Actions[0].FieldAsString([]string{""}); err != utils.ErrNotFound {
t.Fatal(err)
}
if val, err := ap.Actions[0].FieldAsString([]string{utils.ID}); err != nil {
t.Fatal(err)
} else if exp := "acc1"; exp != val {
t.Errorf("Expected %v \n but received \n %v", utils.ToJSON(exp), utils.ToJSON(val))
}
if val, exp := ap.Actions[0].String(), utils.ToJSON(ap.Actions[0]); exp != val {
t.Errorf("Expected %v \n but received \n %v", utils.ToJSON(exp), utils.ToJSON(val))
}
if _, err := ap.Actions[0].Diktats[0].FieldAsString([]string{"", ""}); err != utils.ErrNotFound {
t.Fatal(err)
}
if val, err := ap.Actions[0].Diktats[0].FieldAsString([]string{utils.Path}); err != nil {
t.Fatal(err)
} else if exp := "path"; exp != val {
t.Errorf("Expected %v \n but received \n %v", utils.ToJSON(exp), utils.ToJSON(val))
}
if val, exp := ap.Actions[0].Diktats[0].String(), utils.ToJSON(ap.Actions[0].Diktats[0]); exp != val {
t.Errorf("Expected %v \n but received \n %v", utils.ToJSON(exp), utils.ToJSON(val))
}
}
func TestActionProfileMerge(t *testing.T) {
acc := &ActionProfile{
Targets: make(map[string]utils.StringSet),
}
exp := &ActionProfile{
Tenant: "cgrates.org",
ID: "ID",
FilterIDs: []string{"fltr1"},
Weight: 65,
Schedule: "* * * * *",
Targets: map[string]utils.StringSet{utils.MetaAccounts: {"1001": {}}},
Actions: []*APAction{{}},
}
if acc.Merge(&ActionProfile{
Tenant: "cgrates.org",
ID: "ID",
FilterIDs: []string{"fltr1"},
Weight: 65,
Schedule: "* * * * *",
Targets: map[string]utils.StringSet{utils.MetaAccounts: {"1001": {}}},
Actions: []*APAction{{}},
}); !reflect.DeepEqual(exp, acc) {
t.Errorf("Expected %v \n but received \n %v", utils.ToJSON(exp), utils.ToJSON(acc))
}
}

341
engine/dispatcherprfl_test.go
View File

@@ -437,3 +437,344 @@ func TestDispatcherHostSet(t *testing.T) {
t.Errorf("Expected %v \n but received \n %v", utils.ToJSON(exp), utils.ToJSON(dp))
}
}
func TestDispatcherProfileAsInterface(t *testing.T) {
dp := DispatcherProfile{
Tenant: "cgrates.org",
ID: "ID",
FilterIDs: []string{"fltr1", "*string:~*req.Account:1001"},
Weight: 10,
Strategy: utils.MetaRandom,
StrategyParams: map[string]interface{}{
"opt1": "val1",
"opt2": "val1",
"opt3": "val1",
},
Hosts: DispatcherHostProfiles{
{
ID: "host1",
FilterIDs: []string{"fltr1"},
Weight: 10,
Blocker: true,
Params: map[string]interface{}{
"param1": "val1",
"param2": "val1",
},
},
{
Params: map[string]interface{}{
"param3": "val1",
},
},
},
}
if _, err := dp.FieldAsInterface(nil); err != utils.ErrNotFound {
t.Fatal(err)
}
if _, err := dp.FieldAsInterface([]string{"field"}); err != utils.ErrNotFound {
t.Fatal(err)
}
if _, err := dp.FieldAsInterface([]string{"field", ""}); err != utils.ErrNotFound {
t.Fatal(err)
}
if val, err := dp.FieldAsInterface([]string{utils.Tenant}); err != nil {
t.Fatal(err)
} else if exp := "cgrates.org"; exp != val {
t.Errorf("Expected %v \n but received \n %v", utils.ToJSON(exp), utils.ToJSON(val))
}
if val, err := dp.FieldAsInterface([]string{utils.ID}); err != nil {
t.Fatal(err)
} else if exp := utils.ID; exp != val {
t.Errorf("Expected %v \n but received \n %v", utils.ToJSON(exp), utils.ToJSON(val))
}
if val, err := dp.FieldAsInterface([]string{utils.FilterIDs}); err != nil {
t.Fatal(err)
} else if exp := dp.FilterIDs; !reflect.DeepEqual(exp, val) {
t.Errorf("Expected %v \n but received \n %v", utils.ToJSON(exp), utils.ToJSON(val))
}
if val, err := dp.FieldAsInterface([]string{utils.FilterIDs + "[0]"}); err != nil {
t.Fatal(err)
} else if exp := dp.FilterIDs[0]; exp != val {
t.Errorf("Expected %v \n but received \n %v", utils.ToJSON(exp), utils.ToJSON(val))
}
if val, err := dp.FieldAsInterface([]string{utils.Weight}); err != nil {
t.Fatal(err)
} else if exp := dp.Weight; !reflect.DeepEqual(exp, val) {
t.Errorf("Expected %v \n but received \n %v", utils.ToJSON(exp), utils.ToJSON(val))
}
if val, err := dp.FieldAsInterface([]string{utils.Hosts}); err != nil {
t.Fatal(err)
} else if exp := dp.Hosts; !reflect.DeepEqual(exp, val) {
t.Errorf("Expected %v \n but received \n %v", utils.ToJSON(exp), utils.ToJSON(val))
}
if val, err := dp.FieldAsInterface([]string{utils.Strategy}); err != nil {
t.Fatal(err)
} else if exp := dp.Strategy; !reflect.DeepEqual(exp, val) {
t.Errorf("Expected %v \n but received \n %v", utils.ToJSON(exp), utils.ToJSON(val))
}
if val, err := dp.FieldAsInterface([]string{utils.Hosts}); err != nil {
t.Fatal(err)
} else if exp := dp.Hosts; !reflect.DeepEqual(exp, val) {
t.Errorf("Expected %v \n but received \n %v", utils.ToJSON(exp), utils.ToJSON(val))
}
if val, err := dp.FieldAsInterface([]string{utils.Hosts + "[0]"}); err != nil {
t.Fatal(err)
} else if exp := dp.Hosts[0]; exp != val {
t.Errorf("Expected %v \n but received \n %v", utils.ToJSON(exp), utils.ToJSON(val))
}
expErrMsg := `strconv.Atoi: parsing "a": invalid syntax`
if _, err := dp.FieldAsInterface([]string{utils.FilterIDs + "[a]"}); err == nil || err.Error() != expErrMsg {
t.Errorf("Expeceted: %v, received: %v", expErrMsg, err)
}
if _, err := dp.FieldAsInterface([]string{utils.Hosts + "[a]"}); err == nil || err.Error() != expErrMsg {
t.Errorf("Expeceted: %v, received: %v", expErrMsg, err)
}
if _, err := dp.FieldAsInterface([]string{utils.Hosts + "[a]", ""}); err == nil || err.Error() != expErrMsg {
t.Errorf("Expeceted: %v, received: %v", expErrMsg, err)
}
if _, err := dp.FieldAsInterface([]string{utils.Hosts + "[4]", ""}); err != utils.ErrNotFound {
t.Fatal(err)
}
if _, err := dp.FieldAsInterface([]string{utils.Hosts + "[a]", ""}); err == nil || err.Error() != expErrMsg {
t.Errorf("Expeceted: %v, received: %v", expErrMsg, err)
}
if _, err := dp.FieldAsInterface([]string{utils.Hosts + "[0]", ""}); err != utils.ErrNotFound {
t.Fatal(err)
}
if _, err := dp.FieldAsInterface([]string{utils.Hosts, ""}); err != utils.ErrNotFound {
t.Fatal(err)
}
if _, err := dp.FieldAsInterface([]string{utils.StrategyParams + "[a]"}); err != utils.ErrNotFound {
t.Fatal(err)
}
if _, err := dp.FieldAsInterface([]string{utils.StrategyParams + "[a]", ""}); err != utils.ErrNotFound {
t.Fatal(err)
}
if val, err := dp.FieldAsInterface([]string{utils.Hosts + "[0]", utils.ID}); err != nil {
t.Fatal(err)
} else if exp := dp.Hosts[0].ID; !reflect.DeepEqual(exp, val) {
t.Errorf("Expected %v \n but received \n %v", utils.ToJSON(exp), utils.ToJSON(val))
}
if val, err := dp.FieldAsInterface([]string{utils.Hosts + "[0]", utils.FilterIDs}); err != nil {
t.Fatal(err)
} else if exp := dp.Hosts[0].FilterIDs; !reflect.DeepEqual(exp, val) {
t.Errorf("Expected %v \n but received \n %v", utils.ToJSON(exp), utils.ToJSON(val))
}
if val, err := dp.FieldAsInterface([]string{utils.Hosts + "[0]", utils.Weight}); err != nil {
t.Fatal(err)
} else if exp := dp.Hosts[0].Weight; !reflect.DeepEqual(exp, val) {
t.Errorf("Expected %v \n but received \n %v", utils.ToJSON(exp), utils.ToJSON(val))
}
if val, err := dp.FieldAsInterface([]string{utils.Hosts + "[0]", utils.Blocker}); err != nil {
t.Fatal(err)
} else if exp := dp.Hosts[0].Blocker; !reflect.DeepEqual(exp, val) {
t.Errorf("Expected %v \n but received \n %v", utils.ToJSON(exp), utils.ToJSON(val))
}
if val, err := dp.FieldAsInterface([]string{utils.Hosts + "[0]", utils.FilterIDs + "[0]"}); err != nil {
t.Fatal(err)
} else if exp := dp.Hosts[0].FilterIDs[0]; !reflect.DeepEqual(exp, val) {
t.Errorf("Expected %v \n but received \n %v", utils.ToJSON(exp), utils.ToJSON(val))
}
if _, err := dp.FieldAsInterface([]string{utils.Hosts + "[0]", utils.FilterIDs + "[a]"}); err == nil || err.Error() != expErrMsg {
t.Errorf("Expeceted: %v, received: %v", expErrMsg, err)
}
if _, err := dp.FieldAsInterface([]string{utils.Hosts + "[0]", utils.Params + "[a]"}); err != utils.ErrNotFound {
t.Fatal(err)
}
if _, err := dp.FieldAsInterface([]string{utils.Hosts + "[0]", utils.Params + "[a]", ""}); err != utils.ErrNotFound {
t.Fatal(err)
}
if _, err := dp.FieldAsInterface([]string{utils.Hosts + "[0]", utils.Params + "a]", ""}); err != utils.ErrNotFound {
t.Fatal(err)
}
if _, err := dp.FieldAsString([]string{""}); err != utils.ErrNotFound {
t.Fatal(err)
}
if val, err := dp.FieldAsString([]string{utils.ID}); err != nil {
t.Fatal(err)
} else if exp := "ID"; exp != val {
t.Errorf("Expected %v \n but received \n %v", utils.ToJSON(exp), utils.ToJSON(val))
}
if val, exp := dp.String(), utils.ToJSON(dp); exp != val {
t.Errorf("Expected %v \n but received \n %v", utils.ToJSON(exp), utils.ToJSON(val))
}
if _, err := dp.Hosts[0].FieldAsString([]string{}); err != utils.ErrNotFound {
t.Fatal(err)
}
if val, err := dp.Hosts[0].FieldAsString([]string{utils.ID}); err != nil {
t.Fatal(err)
} else if exp := "host1"; exp != val {
t.Errorf("Expected %v \n but received \n %v", utils.ToJSON(exp), utils.ToJSON(val))
}
if val, exp := dp.Hosts[0].String(), utils.ToJSON(dp.Hosts[0]); exp != val {
t.Errorf("Expected %v \n but received \n %v", utils.ToJSON(exp), utils.ToJSON(val))
}
}
func TestDispatcherProfileMerge(t *testing.T) {
dp := &DispatcherProfile{
StrategyParams: make(map[string]interface{}),
}
exp := &DispatcherProfile{
Tenant: "cgrates.org",
ID: "ID",
FilterIDs: []string{"fltr1"},
Weight: 65,
Strategy: utils.MetaLoad,
StrategyParams: map[string]interface{}{"k": "v"},
Hosts: DispatcherHostProfiles{{}},
}
if dp.Merge(&DispatcherProfile{
Tenant: "cgrates.org",
ID: "ID",
FilterIDs: []string{"fltr1"},
Weight: 65,
Strategy: utils.MetaLoad,
StrategyParams: map[string]interface{}{"k": "v"},
Hosts: DispatcherHostProfiles{{}},
}); !reflect.DeepEqual(exp, dp) {
t.Errorf("Expected %v \n but received \n %v", utils.ToJSON(exp), utils.ToJSON(dp))
}
}
func TestDispatcherHostAsInterface(t *testing.T) {
dh := DispatcherHost{
Tenant: "cgrates.org",
RemoteHost: &config.RemoteHost{
ID: "ID",
Address: "127.0.0.1",
Transport: utils.MetaJSON,
ConnectAttempts: 1,
Reconnects: 1,
ConnectTimeout: time.Nanosecond,
ReplyTimeout: time.Nanosecond,
TLS: true,
ClientKey: "key",
ClientCertificate: "ce",
CaCertificate: "ca",
},
}
if _, err := dh.FieldAsInterface(nil); err != utils.ErrNotFound {
t.Fatal(err)
}
if _, err := dh.FieldAsInterface([]string{"field"}); err != utils.ErrNotFound {
t.Fatal(err)
}
if _, err := dh.FieldAsInterface([]string{"field", ""}); err != utils.ErrNotFound {
t.Fatal(err)
}
if val, err := dh.FieldAsInterface([]string{utils.Tenant}); err != nil {
t.Fatal(err)
} else if exp := "cgrates.org"; exp != val {
t.Errorf("Expected %v \n but received \n %v", utils.ToJSON(exp), utils.ToJSON(val))
}
if val, err := dh.FieldAsInterface([]string{utils.ID}); err != nil {
t.Fatal(err)
} else if exp := utils.ID; exp != val {
t.Errorf("Expected %v \n but received \n %v", utils.ToJSON(exp), utils.ToJSON(val))
}
if val, err := dh.FieldAsInterface([]string{utils.Address}); err != nil {
t.Fatal(err)
} else if exp := dh.Address; exp != val {
t.Errorf("Expected %v \n but received \n %v", utils.ToJSON(exp), utils.ToJSON(val))
}
if val, err := dh.FieldAsInterface([]string{utils.Transport}); err != nil {
t.Fatal(err)
} else if exp := dh.Transport; exp != val {
t.Errorf("Expected %v \n but received \n %v", utils.ToJSON(exp), utils.ToJSON(val))
}
if val, err := dh.FieldAsInterface([]string{utils.ConnectAttempts}); err != nil {
t.Fatal(err)
} else if exp := dh.ConnectAttempts; exp != val {
t.Errorf("Expected %v \n but received \n %v", utils.ToJSON(exp), utils.ToJSON(val))
}
if val, err := dh.FieldAsInterface([]string{utils.Reconnects}); err != nil {
t.Fatal(err)
} else if exp := dh.Reconnects; exp != val {
t.Errorf("Expected %v \n but received \n %v", utils.ToJSON(exp), utils.ToJSON(val))
}
if val, err := dh.FieldAsInterface([]string{utils.ConnectTimeout}); err != nil {
t.Fatal(err)
} else if exp := dh.ConnectTimeout; exp != val {
t.Errorf("Expected %v \n but received \n %v", utils.ToJSON(exp), utils.ToJSON(val))
}
if val, err := dh.FieldAsInterface([]string{utils.ReplyTimeout}); err != nil {
t.Fatal(err)
} else if exp := dh.ReplyTimeout; exp != val {
t.Errorf("Expected %v \n but received \n %v", utils.ToJSON(exp), utils.ToJSON(val))
}
if val, err := dh.FieldAsInterface([]string{utils.TLS}); err != nil {
t.Fatal(err)
} else if exp := dh.TLS; exp != val {
t.Errorf("Expected %v \n but received \n %v", utils.ToJSON(exp), utils.ToJSON(val))
}
if val, err := dh.FieldAsInterface([]string{utils.ClientKey}); err != nil {
t.Fatal(err)
} else if exp := dh.ClientKey; exp != val {
t.Errorf("Expected %v \n but received \n %v", utils.ToJSON(exp), utils.ToJSON(val))
}
if val, err := dh.FieldAsInterface([]string{utils.ClientCertificate}); err != nil {
t.Fatal(err)
} else if exp := dh.ClientCertificate; exp != val {
t.Errorf("Expected %v \n but received \n %v", utils.ToJSON(exp), utils.ToJSON(val))
}
if val, err := dh.FieldAsInterface([]string{utils.CaCertificate}); err != nil {
t.Fatal(err)
} else if exp := dh.CaCertificate; exp != val {
t.Errorf("Expected %v \n but received \n %v", utils.ToJSON(exp), utils.ToJSON(val))
}
if _, err := dh.FieldAsString([]string{""}); err != utils.ErrNotFound {
t.Fatal(err)
}
if val, err := dh.FieldAsString([]string{utils.ID}); err != nil {
t.Fatal(err)
} else if exp := "ID"; exp != val {
t.Errorf("Expected %v \n but received \n %v", utils.ToJSON(exp), utils.ToJSON(val))
}
if val, exp := dh.String(), utils.ToJSON(dh); exp != val {
t.Errorf("Expected %v \n but received \n %v", utils.ToJSON(exp), utils.ToJSON(val))
}
}
func TestDispatcherHostMerge(t *testing.T) {
dp := &DispatcherHost{
RemoteHost: &config.RemoteHost{},
}
exp := &DispatcherHost{
Tenant: "cgrates.org",
RemoteHost: &config.RemoteHost{
ID: "ID",
Address: "127.0.0.1",
Transport: utils.MetaJSON,
ConnectAttempts: 1,
Reconnects: 1,
ConnectTimeout: time.Nanosecond,
ReplyTimeout: time.Nanosecond,
TLS: true,
ClientKey: "key",
ClientCertificate: "ce",
CaCertificate: "ca",
},
}
if dp.Merge(&DispatcherHost{
Tenant: "cgrates.org",
RemoteHost: &config.RemoteHost{
ID: "ID",
Address: "127.0.0.1",
Transport: utils.MetaJSON,
ConnectAttempts: 1,
Reconnects: 1,
ConnectTimeout: time.Nanosecond,
ReplyTimeout: time.Nanosecond,
TLS: true,
ClientKey: "key",
ClientCertificate: "ce",
CaCertificate: "ca",
},
}); !reflect.DeepEqual(exp, dp) {
t.Errorf("Expected %v \n but received \n %v", utils.ToJSON(exp), utils.ToJSON(dp))
}
}

118
engine/filters_test.go
View File

@@ -1369,3 +1369,121 @@ func TestFilterSet(t *testing.T) {
t.Errorf("Expected %v \n but received \n %v", utils.ToJSON(exp), utils.ToJSON(fltr))
}
}
func TestFilterAsInterface(t *testing.T) {
fltr := Filter{
Tenant: "cgrates.org",
ID: "ID",
Rules: []*FilterRule{{
Type: utils.MetaString,
Element: "~*req.Account",
Values: []string{"1001", "1002"},
}},
}
if _, err := fltr.FieldAsInterface(nil); err != utils.ErrNotFound {
t.Fatal(err)
}
if _, err := fltr.FieldAsInterface([]string{"field"}); err != utils.ErrNotFound {
t.Fatal(err)
}
if _, err := fltr.FieldAsInterface([]string{"field", ""}); err != utils.ErrNotFound {
t.Fatal(err)
}
if _, err := fltr.FieldAsInterface([]string{utils.Rules + "[4]", ""}); err != utils.ErrNotFound {
t.Fatal(err)
}
expErrMsg := `strconv.Atoi: parsing "a": invalid syntax`
if _, err := fltr.FieldAsInterface([]string{utils.Rules + "[a]", ""}); err == nil || err.Error() != expErrMsg {
t.Errorf("Expeceted: %v, received: %v", expErrMsg, err)
}
if _, err := fltr.FieldAsInterface([]string{utils.Rules + "[0]", ""}); err != utils.ErrNotFound {
t.Fatal(err)
}
if val, err := fltr.FieldAsInterface([]string{utils.Tenant}); err != nil {
t.Fatal(err)
} else if exp := "cgrates.org"; exp != val {
t.Errorf("Expected %v \n but received \n %v", utils.ToJSON(exp), utils.ToJSON(val))
}
if val, err := fltr.FieldAsInterface([]string{utils.ID}); err != nil {
t.Fatal(err)
} else if exp := utils.ID; exp != val {
t.Errorf("Expected %v \n but received \n %v", utils.ToJSON(exp), utils.ToJSON(val))
}
if val, err := fltr.FieldAsInterface([]string{utils.Rules + "[0]"}); err != nil {
t.Fatal(err)
} else if exp := fltr.Rules[0]; !reflect.DeepEqual(exp, val) {
t.Errorf("Expected %v \n but received \n %v", utils.ToJSON(exp), utils.ToJSON(val))
}
if val, err := fltr.FieldAsInterface([]string{utils.Rules + "[0]", utils.Values}); err != nil {
t.Fatal(err)
} else if exp := fltr.Rules[0].Values; !reflect.DeepEqual(exp, val) {
t.Errorf("Expected %v \n but received \n %v", utils.ToJSON(exp), utils.ToJSON(val))
}
if val, err := fltr.FieldAsInterface([]string{utils.Rules + "[0]", utils.Values + "[0]"}); err != nil {
t.Fatal(err)
} else if exp := fltr.Rules[0].Values[0]; !reflect.DeepEqual(exp, val) {
t.Errorf("Expected %v \n but received \n %v", utils.ToJSON(exp), utils.ToJSON(val))
}
if val, err := fltr.FieldAsInterface([]string{utils.Rules + "[0]", utils.Element}); err != nil {
t.Fatal(err)
} else if exp := fltr.Rules[0].Element; !reflect.DeepEqual(exp, val) {
t.Errorf("Expected %v \n but received \n %v", utils.ToJSON(exp), utils.ToJSON(val))
}
if val, err := fltr.FieldAsInterface([]string{utils.Rules + "[0]", utils.Type}); err != nil {
t.Fatal(err)
} else if exp := fltr.Rules[0].Type; !reflect.DeepEqual(exp, val) {
t.Errorf("Expected %v \n but received \n %v", utils.ToJSON(exp), utils.ToJSON(val))
}
if _, err := fltr.FieldAsString([]string{""}); err != utils.ErrNotFound {
t.Fatal(err)
}
if val, err := fltr.FieldAsString([]string{utils.ID}); err != nil {
t.Fatal(err)
} else if exp := "ID"; exp != val {
t.Errorf("Expected %v \n but received \n %v", utils.ToJSON(exp), utils.ToJSON(val))
}
if val, exp := fltr.String(), utils.ToJSON(fltr); exp != val {
t.Errorf("Expected %v \n but received \n %v", utils.ToJSON(exp), utils.ToJSON(val))
}
if _, err := fltr.Rules[0].FieldAsString([]string{}); err != utils.ErrNotFound {
t.Fatal(err)
}
if val, err := fltr.Rules[0].FieldAsString([]string{utils.Type}); err != nil {
t.Fatal(err)
} else if exp := utils.MetaString; exp != val {
t.Errorf("Expected %v \n but received \n %v", utils.ToJSON(exp), utils.ToJSON(val))
}
if val, exp := fltr.Rules[0].String(), utils.ToJSON(fltr.Rules[0]); exp != val {
t.Errorf("Expected %v \n but received \n %v", utils.ToJSON(exp), utils.ToJSON(val))
}
}
func TestFilterMerge(t *testing.T) {
dp := &Filter{}
exp := &Filter{
Tenant: "cgrates.org",
ID: "ID",
Rules: []*FilterRule{{
Type: utils.MetaString,
Element: "~*req.Account",
Values: []string{"1001", "1002"},
}},
}
if dp.Merge(&Filter{
Tenant: "cgrates.org",
ID: "ID",
Rules: []*FilterRule{{
Type: utils.MetaString,
Element: "~*req.Account",
Values: []string{"1001", "1002"},
}},
}); !reflect.DeepEqual(exp, dp) {
t.Errorf("Expected %v \n but received \n %v", utils.ToJSON(exp), utils.ToJSON(dp))
}
}

39
engine/libattributes.go
View File

@@ -21,7 +21,6 @@ package engine
import (
"fmt"
"sort"
"strconv"
"strings"
"github.com/cgrates/cgrates/config"
@@ -267,10 +266,17 @@ func (ap *AttributeProfile) FieldAsInterface(fldPath []string) (_ interface{}, e
switch fldPath[0] {
default:
fld, idx := utils.GetPathIndex(fldPath[0])
if fld == utils.FilterIDs &&
idx != nil &&
*idx < len(ap.FilterIDs) {
return ap.FilterIDs[*idx], nil
if idx != nil {
switch fld {
case utils.Attributes:
if *idx < len(ap.Attributes) {
return ap.Attributes[*idx], nil
}
case utils.FilterIDs:
if *idx < len(ap.FilterIDs) {
return ap.FilterIDs[*idx], nil
}
}
}
return nil, utils.ErrNotFound
case utils.Tenant:
@@ -287,20 +293,17 @@ func (ap *AttributeProfile) FieldAsInterface(fldPath []string) (_ interface{}, e
return ap.Attributes, nil
}
}
if len(fldPath) == 0 ||
!strings.HasPrefix(fldPath[0], utils.Attributes) ||
fldPath[0][10] != '[' ||
fldPath[0][len(fldPath[0])-1] != ']' {
if len(fldPath) == 0 {
return nil, utils.ErrNotFound
}
var idx int
if idx, err = strconv.Atoi(fldPath[0][11 : len(fldPath[0])-1]); err != nil {
return
}
if idx >= len(ap.Attributes) {
fld, idx := utils.GetPathIndex(fldPath[0])
if fld != utils.Attributes || idx == nil {
return nil, utils.ErrNotFound
}
return ap.Attributes[idx].FieldAsInterface(fldPath[1:])
if *idx >= len(ap.Attributes) {
return nil, utils.ErrNotFound
}
return ap.Attributes[*idx].FieldAsInterface(fldPath[1:])
}
func (at *Attribute) String() string { return utils.ToJSON(at) }
@@ -318,6 +321,12 @@ func (at *Attribute) FieldAsInterface(fldPath []string) (_ interface{}, err erro
}
switch fldPath[0] {
default:
fld, idx := utils.GetPathIndex(fldPath[0])
if idx != nil &&
fld == utils.FilterIDs &&
*idx < len(at.FilterIDs) {
return at.FilterIDs[*idx], nil
}
return nil, utils.ErrNotFound
case utils.FilterIDs:
return at.FilterIDs, nil

160
engine/libattributes_test.go
View File

@@ -280,3 +280,163 @@ func TestAttributeProfileSet(t *testing.T) {
t.Errorf("Expected %v \n but received \n %v", utils.ToJSON(exp), utils.ToJSON(dp))
}
}
func TestAttributeProfileAsInterface(t *testing.T) {
ap := AttributeProfile{
Tenant: "cgrates.org",
ID: "ID",
FilterIDs: []string{"fltr1", "*string:~*req.Account:1001"},
Weight: 10,
Blocker: true,
Attributes: []*Attribute{{
Path: "*req.Account",
Type: utils.MetaConstant,
Value: config.NewRSRParsersMustCompile("10", utils.InfieldSep),
FilterIDs: []string{"fltr1"},
}},
}
if _, err := ap.FieldAsInterface(nil); err != utils.ErrNotFound {
t.Fatal(err)
}
if _, err := ap.FieldAsInterface([]string{"field"}); err != utils.ErrNotFound {
t.Fatal(err)
}
if _, err := ap.FieldAsInterface([]string{"field", ""}); err != utils.ErrNotFound {
t.Fatal(err)
}
if val, err := ap.FieldAsInterface([]string{utils.Tenant}); err != nil {
t.Fatal(err)
} else if exp := "cgrates.org"; exp != val {
t.Errorf("Expected %v \n but received \n %v", utils.ToJSON(exp), utils.ToJSON(val))
}
if val, err := ap.FieldAsInterface([]string{utils.ID}); err != nil {
t.Fatal(err)
} else if exp := utils.ID; exp != val {
t.Errorf("Expected %v \n but received \n %v", utils.ToJSON(exp), utils.ToJSON(val))
}
if val, err := ap.FieldAsInterface([]string{utils.FilterIDs}); err != nil {
t.Fatal(err)
} else if exp := ap.FilterIDs; !reflect.DeepEqual(exp, val) {
t.Errorf("Expected %v \n but received \n %v", utils.ToJSON(exp), utils.ToJSON(val))
}
if val, err := ap.FieldAsInterface([]string{utils.FilterIDs + "[0]"}); err != nil {
t.Fatal(err)
} else if exp := ap.FilterIDs[0]; exp != val {
t.Errorf("Expected %v \n but received \n %v", utils.ToJSON(exp), utils.ToJSON(val))
}
if val, err := ap.FieldAsInterface([]string{utils.Weight}); err != nil {
t.Fatal(err)
} else if exp := ap.Weight; !reflect.DeepEqual(exp, val) {
t.Errorf("Expected %v \n but received \n %v", utils.ToJSON(exp), utils.ToJSON(val))
}
if val, err := ap.FieldAsInterface([]string{utils.Blocker}); err != nil {
t.Fatal(err)
} else if exp := ap.Blocker; !reflect.DeepEqual(exp, val) {
t.Errorf("Expected %v \n but received \n %v", utils.ToJSON(exp), utils.ToJSON(val))
}
if val, err := ap.FieldAsInterface([]string{utils.Attributes}); err != nil {
t.Fatal(err)
} else if exp := ap.Attributes; !reflect.DeepEqual(exp, val) {
t.Errorf("Expected %v \n but received \n %v", utils.ToJSON(exp), utils.ToJSON(val))
}
if val, err := ap.FieldAsInterface([]string{utils.Attributes + "[0]"}); err != nil {
t.Fatal(err)
} else if exp := ap.Attributes[0]; exp != val {
t.Errorf("Expected %v \n but received \n %v", utils.ToJSON(exp), utils.ToJSON(val))
}
if val, err := ap.FieldAsInterface([]string{utils.Attributes + "[0]"}); err != nil {
t.Fatal(err)
} else if exp := ap.Attributes[0]; exp != val {
t.Errorf("Expected %v \n but received \n %v", utils.ToJSON(exp), utils.ToJSON(val))
}
if _, err := ap.FieldAsInterface([]string{utils.Attributes + "[4]", ""}); err != utils.ErrNotFound {
t.Fatal(err)
}
if _, err := ap.FieldAsInterface([]string{utils.Attributes + "[0]", ""}); err != utils.ErrNotFound {
t.Fatal(err)
}
if _, err := ap.FieldAsInterface([]string{utils.Attributes + "0]"}); err != utils.ErrNotFound {
t.Fatal(err)
}
if val, err := ap.FieldAsInterface([]string{utils.Attributes + "[0]", utils.FilterIDs}); err != nil {
t.Fatal(err)
} else if exp := ap.Attributes[0].FilterIDs; !reflect.DeepEqual(exp, val) {
t.Errorf("Expected %v \n but received \n %v", utils.ToJSON(exp), utils.ToJSON(val))
}
if val, err := ap.FieldAsInterface([]string{utils.Attributes + "[0]", utils.FilterIDs + "[0]"}); err != nil {
t.Fatal(err)
} else if exp := ap.Attributes[0].FilterIDs[0]; !reflect.DeepEqual(exp, val) {
t.Errorf("Expected %v \n but received \n %v", utils.ToJSON(exp), utils.ToJSON(val))
}
if val, err := ap.FieldAsInterface([]string{utils.Attributes + "[0]", utils.Path}); err != nil {
t.Fatal(err)
} else if exp := ap.Attributes[0].Path; !reflect.DeepEqual(exp, val) {
t.Errorf("Expected %v \n but received \n %v", utils.ToJSON(exp), utils.ToJSON(val))
}
if val, err := ap.FieldAsInterface([]string{utils.Attributes + "[0]", utils.Type}); err != nil {
t.Fatal(err)
} else if exp := ap.Attributes[0].Type; !reflect.DeepEqual(exp, val) {
t.Errorf("Expected %v \n but received \n %v", utils.ToJSON(exp), utils.ToJSON(val))
}
if val, err := ap.FieldAsInterface([]string{utils.Attributes + "[0]", utils.Value}); err != nil {
t.Fatal(err)
} else if exp := "10"; !reflect.DeepEqual(exp, val) {
t.Errorf("Expected %v \n but received \n %v", utils.ToJSON(exp), utils.ToJSON(val))
}
if _, err := ap.FieldAsString([]string{""}); err != utils.ErrNotFound {
t.Fatal(err)
}
if val, err := ap.FieldAsString([]string{utils.ID}); err != nil {
t.Fatal(err)
} else if exp := "ID"; exp != val {
t.Errorf("Expected %v \n but received \n %v", utils.ToJSON(exp), utils.ToJSON(val))
}
if val, exp := ap.String(), utils.ToJSON(ap); exp != val {
t.Errorf("Expected %v \n but received \n %v", utils.ToJSON(exp), utils.ToJSON(val))
}
if _, err := ap.Attributes[0].FieldAsString([]string{}); err != utils.ErrNotFound {
t.Fatal(err)
}
if val, err := ap.Attributes[0].FieldAsString([]string{utils.Value}); err != nil {
t.Fatal(err)
} else if exp := "10"; exp != val {
t.Errorf("Expected %v \n but received \n %v", utils.ToJSON(exp), utils.ToJSON(val))
}
if val, exp := ap.Attributes[0].String(), utils.ToJSON(ap.Attributes[0]); exp != val {
t.Errorf("Expected %v \n but received \n %v", utils.ToJSON(exp), utils.ToJSON(val))
}
}
func TestAttributeProfileMerge(t *testing.T) {
dp := &AttributeProfile{}
exp := &AttributeProfile{
Tenant: "cgrates.org",
ID: "ID",
FilterIDs: []string{"fltr1", "*string:~*req.Account:1001"},
Weight: 10,
Blocker: true,
Attributes: []*Attribute{{
Path: "*req.Account",
Type: utils.MetaConstant,
Value: config.NewRSRParsersMustCompile("10", utils.InfieldSep),
FilterIDs: []string{"fltr1"},
}},
}
if dp.Merge(&AttributeProfile{
Tenant: "cgrates.org",
ID: "ID",
FilterIDs: []string{"fltr1", "*string:~*req.Account:1001"},
Weight: 10,
Blocker: true,
Attributes: []*Attribute{{
Path: "*req.Account",
Type: utils.MetaConstant,
Value: config.NewRSRParsersMustCompile("10", utils.InfieldSep),
FilterIDs: []string{"fltr1"},
}},
}); !reflect.DeepEqual(exp, dp) {
t.Errorf("Expected %v \n but received \n %v", utils.ToJSON(exp), utils.ToJSON(dp))
}
}

95
engine/libchargers_test.go
View File

@@ -77,3 +77,98 @@ func TestChargerProfilesSort(t *testing.T) {
t.Errorf("Expected %v \n but received \n %v", utils.ToJSON(exp), utils.ToJSON(cp))
}
}
func TestChargerProfileAsInterface(t *testing.T) {
ap := ChargerProfile{
Tenant: "cgrates.org",
ID: "ID",
FilterIDs: []string{"fltr1", "*string:~*req.Account:1001"},
Weight: 10,
RunID: utils.MetaDefault,
AttributeIDs: []string{"attr1"},
}
if _, err := ap.FieldAsInterface(nil); err != utils.ErrNotFound {
t.Fatal(err)
}
if _, err := ap.FieldAsInterface([]string{"field"}); err != utils.ErrNotFound {
t.Fatal(err)
}
if _, err := ap.FieldAsInterface([]string{"field", ""}); err != utils.ErrNotFound {
t.Fatal(err)
}
if val, err := ap.FieldAsInterface([]string{utils.Tenant}); err != nil {
t.Fatal(err)
} else if exp := "cgrates.org"; exp != val {
t.Errorf("Expected %v \n but received \n %v", utils.ToJSON(exp), utils.ToJSON(val))
}
if val, err := ap.FieldAsInterface([]string{utils.ID}); err != nil {
t.Fatal(err)
} else if exp := utils.ID; exp != val {
t.Errorf("Expected %v \n but received \n %v", utils.ToJSON(exp), utils.ToJSON(val))
}
if val, err := ap.FieldAsInterface([]string{utils.FilterIDs}); err != nil {
t.Fatal(err)
} else if exp := ap.FilterIDs; !reflect.DeepEqual(exp, val) {
t.Errorf("Expected %v \n but received \n %v", utils.ToJSON(exp), utils.ToJSON(val))
}
if val, err := ap.FieldAsInterface([]string{utils.FilterIDs + "[0]"}); err != nil {
t.Fatal(err)
} else if exp := ap.FilterIDs[0]; exp != val {
t.Errorf("Expected %v \n but received \n %v", utils.ToJSON(exp), utils.ToJSON(val))
}
if val, err := ap.FieldAsInterface([]string{utils.Weight}); err != nil {
t.Fatal(err)
} else if exp := ap.Weight; !reflect.DeepEqual(exp, val) {
t.Errorf("Expected %v \n but received \n %v", utils.ToJSON(exp), utils.ToJSON(val))
}
if val, err := ap.FieldAsInterface([]string{utils.RunID}); err != nil {
t.Fatal(err)
} else if exp := ap.RunID; !reflect.DeepEqual(exp, val) {
t.Errorf("Expected %v \n but received \n %v", utils.ToJSON(exp), utils.ToJSON(val))
}
if val, err := ap.FieldAsInterface([]string{utils.AttributeIDs}); err != nil {
t.Fatal(err)
} else if exp := ap.AttributeIDs; !reflect.DeepEqual(exp, val) {
t.Errorf("Expected %v \n but received \n %v", utils.ToJSON(exp), utils.ToJSON(val))
}
if val, err := ap.FieldAsInterface([]string{utils.AttributeIDs + "[0]"}); err != nil {
t.Fatal(err)
} else if exp := ap.AttributeIDs[0]; exp != val {
t.Errorf("Expected %v \n but received \n %v", utils.ToJSON(exp), utils.ToJSON(val))
}
if _, err := ap.FieldAsString([]string{""}); err != utils.ErrNotFound {
t.Fatal(err)
}
if val, err := ap.FieldAsString([]string{utils.ID}); err != nil {
t.Fatal(err)
} else if exp := "ID"; exp != val {
t.Errorf("Expected %v \n but received \n %v", utils.ToJSON(exp), utils.ToJSON(val))
}
if val, exp := ap.String(), utils.ToJSON(ap); exp != val {
t.Errorf("Expected %v \n but received \n %v", utils.ToJSON(exp), utils.ToJSON(val))
}
}
func TestChargerProfileMerge(t *testing.T) {
dp := &ChargerProfile{}
exp := &ChargerProfile{
Tenant: "cgrates.org",
ID: "ID",
FilterIDs: []string{"fltr1", "*string:~*req.Account:1001"},
Weight: 10,
RunID: utils.MetaDefault,
AttributeIDs: []string{"attr1"},
}
if dp.Merge(&ChargerProfile{
Tenant: "cgrates.org",
ID: "ID",
FilterIDs: []string{"fltr1", "*string:~*req.Account:1001"},
Weight: 10,
RunID: utils.MetaDefault,
AttributeIDs: []string{"attr1"},
}); !reflect.DeepEqual(exp, dp) {
t.Errorf("Expected %v \n but received \n %v", utils.ToJSON(exp), utils.ToJSON(dp))
}
}

19
engine/libstats.go
View File

@@ -24,7 +24,6 @@ import (
"encoding/json"
"fmt"
"sort"
"strconv"
"strings"
"time"
@@ -689,20 +688,18 @@ func (sqp *StatQueueProfile) FieldAsInterface(fldPath []string) (_ interface{},
return sqp.Blocker, nil
}
}
if len(fldPath) == 0 ||
!strings.HasPrefix(fldPath[0], utils.Metrics) ||
fldPath[0][7] != '[' ||
fldPath[0][len(fldPath[0])-1] != ']' {
if len(fldPath) == 0 {
return nil, utils.ErrNotFound
}
var idx int
if idx, err = strconv.Atoi(fldPath[0][8 : len(fldPath[0])-1]); err != nil {
return
}
if idx >= len(sqp.Metrics) {
fld, idx := utils.GetPathIndex(fldPath[0])
if fld != utils.Metrics ||
idx == nil {
return nil, utils.ErrNotFound
}
return sqp.Metrics[idx].FieldAsInterface(fldPath[1:])
if *idx >= len(sqp.Metrics) {
return nil, utils.ErrNotFound
}
return sqp.Metrics[*idx].FieldAsInterface(fldPath[1:])
}
func (mf *MetricWithFilters) String() string { return utils.ToJSON(mf) }

158
engine/libstats_test.go
View File

@@ -1446,3 +1446,161 @@ func TestStatQueueProfileSet(t *testing.T) {
t.Errorf("Expected %v \n but received \n %v", utils.ToJSON(exp), utils.ToJSON(sq))
}
}
func TestStatQueueProfileAsInterface(t *testing.T) {
ap := StatQueueProfile{
Tenant: "cgrates.org",
ID: "ID",
FilterIDs: []string{"fltr1", "*string:~*req.Account:1001"},
Weight: 10,
QueueLength: 10,
TTL: 10,
MinItems: 10,
Stored: true,
Blocker: true,
ThresholdIDs: []string{"TH1"},
Metrics: []*MetricWithFilters{{
MetricID: utils.MetaTCD,
}, {
MetricID: utils.MetaACD,
FilterIDs: []string{"fltr1"},
}},
}
if _, err := ap.FieldAsInterface(nil); err != utils.ErrNotFound {
t.Fatal(err)
}
if _, err := ap.FieldAsInterface([]string{"field"}); err != utils.ErrNotFound {
t.Fatal(err)
}
if _, err := ap.FieldAsInterface([]string{"field", ""}); err != utils.ErrNotFound {
t.Fatal(err)
}
if val, err := ap.FieldAsInterface([]string{utils.Tenant}); err != nil {
t.Fatal(err)
} else if exp := "cgrates.org"; exp != val {
t.Errorf("Expected %v \n but received \n %v", utils.ToJSON(exp), utils.ToJSON(val))
}
if val, err := ap.FieldAsInterface([]string{utils.ID}); err != nil {
t.Fatal(err)
} else if exp := utils.ID; exp != val {
t.Errorf("Expected %v \n but received \n %v", utils.ToJSON(exp), utils.ToJSON(val))
}
if val, err := ap.FieldAsInterface([]string{utils.FilterIDs}); err != nil {
t.Fatal(err)
} else if exp := ap.FilterIDs; !reflect.DeepEqual(exp, val) {
t.Errorf("Expected %v \n but received \n %v", utils.ToJSON(exp), utils.ToJSON(val))
}
if val, err := ap.FieldAsInterface([]string{utils.FilterIDs + "[0]"}); err != nil {
t.Fatal(err)
} else if exp := ap.FilterIDs[0]; exp != val {
t.Errorf("Expected %v \n but received \n %v", utils.ToJSON(exp), utils.ToJSON(val))
}
if val, err := ap.FieldAsInterface([]string{utils.Weight}); err != nil {
t.Fatal(err)
} else if exp := ap.Weight; !reflect.DeepEqual(exp, val) {
t.Errorf("Expected %v \n but received \n %v", utils.ToJSON(exp), utils.ToJSON(val))
}
if val, err := ap.FieldAsInterface([]string{utils.ThresholdIDs}); err != nil {
t.Fatal(err)
} else if exp := ap.ThresholdIDs; !reflect.DeepEqual(exp, val) {
t.Errorf("Expected %v \n but received \n %v", utils.ToJSON(exp), utils.ToJSON(val))
}
if val, err := ap.FieldAsInterface([]string{utils.ThresholdIDs + "[0]"}); err != nil {
t.Fatal(err)
} else if exp := ap.ThresholdIDs[0]; exp != val {
t.Errorf("Expected %v \n but received \n %v", utils.ToJSON(exp), utils.ToJSON(val))
}
if val, err := ap.FieldAsInterface([]string{utils.Metrics}); err != nil {
t.Fatal(err)
} else if exp := ap.Metrics; !reflect.DeepEqual(exp, val) {
t.Errorf("Expected %v \n but received \n %v", utils.ToJSON(exp), utils.ToJSON(val))
}
if val, err := ap.FieldAsInterface([]string{utils.Metrics + "[0]"}); err != nil {
t.Fatal(err)
} else if exp := ap.Metrics[0]; !reflect.DeepEqual(exp, val) {
t.Errorf("Expected %v \n but received \n %v", utils.ToJSON(exp), utils.ToJSON(val))
}
if val, err := ap.FieldAsInterface([]string{utils.QueueLength}); err != nil {
t.Fatal(err)
} else if exp := ap.QueueLength; exp != val {
t.Errorf("Expected %v \n but received \n %v", utils.ToJSON(exp), utils.ToJSON(val))
}
if val, err := ap.FieldAsInterface([]string{utils.TTL}); err != nil {
t.Fatal(err)
} else if exp := ap.TTL; exp != val {
t.Errorf("Expected %v \n but received \n %v", utils.ToJSON(exp), utils.ToJSON(val))
}
if val, err := ap.FieldAsInterface([]string{utils.MinItems}); err != nil {
t.Fatal(err)
} else if exp := ap.MinItems; exp != val {
t.Errorf("Expected %v \n but received \n %v", utils.ToJSON(exp), utils.ToJSON(val))
}
if val, err := ap.FieldAsInterface([]string{utils.Stored}); err != nil {
t.Fatal(err)
} else if exp := ap.Stored; exp != val {
t.Errorf("Expected %v \n but received \n %v", utils.ToJSON(exp), utils.ToJSON(val))
}
if val, err := ap.FieldAsInterface([]string{utils.Blocker}); err != nil {
t.Fatal(err)
} else if exp := ap.Blocker; exp != val {
t.Errorf("Expected %v \n but received \n %v", utils.ToJSON(exp), utils.ToJSON(val))
}
if _, err := ap.FieldAsInterface([]string{utils.Metrics + "[4]"}); err != utils.ErrNotFound {
t.Fatal(err)
}
if _, err := ap.FieldAsInterface([]string{utils.Metrics + "4]"}); err != utils.ErrNotFound {
t.Fatal(err)
}
if _, err := ap.FieldAsInterface([]string{utils.Metrics + "[4]", ""}); err != utils.ErrNotFound {
t.Fatal(err)
}
if _, err := ap.FieldAsInterface([]string{utils.Metrics + "[0]", ""}); err != utils.ErrNotFound {
t.Fatal(err)
}
if _, err := ap.FieldAsInterface([]string{utils.Metrics + "[0]", "", ""}); err != utils.ErrNotFound {
t.Fatal(err)
}
if val, err := ap.FieldAsInterface([]string{utils.Metrics + "[0]", utils.MetricID}); err != nil {
t.Fatal(err)
} else if exp := ap.Metrics[0].MetricID; exp != val {
t.Errorf("Expected %v \n but received \n %v", utils.ToJSON(exp), utils.ToJSON(val))
}
if val, err := ap.FieldAsInterface([]string{utils.Metrics + "[0]", utils.FilterIDs}); err != nil {
t.Fatal(err)
} else if exp := ap.Metrics[0].FilterIDs; !reflect.DeepEqual(exp, val) {
t.Errorf("Expected %v \n but received \n %v", utils.ToJSON(exp), utils.ToJSON(val))
}
if val, err := ap.FieldAsInterface([]string{utils.Metrics + "[1]", utils.FilterIDs + "[0]"}); err != nil {
t.Fatal(err)
} else if exp := ap.Metrics[1].FilterIDs[0]; exp != val {
t.Errorf("Expected %v \n but received \n %v", utils.ToJSON(exp), utils.ToJSON(val))
}
if _, err := ap.FieldAsString([]string{""}); err != utils.ErrNotFound {
t.Fatal(err)
}
if val, err := ap.FieldAsString([]string{utils.ID}); err != nil {
t.Fatal(err)
} else if exp := "ID"; exp != val {
t.Errorf("Expected %v \n but received \n %v", utils.ToJSON(exp), utils.ToJSON(val))
}
if val, exp := ap.String(), utils.ToJSON(ap); exp != val {
t.Errorf("Expected %v \n but received \n %v", utils.ToJSON(exp), utils.ToJSON(val))
}
if _, err := ap.Metrics[0].FieldAsString([]string{""}); err != utils.ErrNotFound {
t.Fatal(err)
}
if val, err := ap.Metrics[0].FieldAsString([]string{utils.MetricID}); err != nil {
t.Fatal(err)
} else if exp := utils.MetaTCD; exp != val {
t.Errorf("Expected %v \n but received \n %v", utils.ToJSON(exp), utils.ToJSON(val))
}
if val, exp := ap.Metrics[0].String(), utils.ToJSON(ap.Metrics[0]); exp != val {
t.Errorf("Expected %v \n but received \n %v", utils.ToJSON(exp), utils.ToJSON(val))
}
}

2
utils/dataconverter.go
View File

@@ -485,7 +485,7 @@ type LengthConverter struct{}
func (LengthConverter) Convert(in interface{}) (out interface{}, err error) {
switch val := in.(type) {
case string:
if len(val) > 2 {
if len(val) >= 2 {
var tmp interface{}
var l func() (interface{}, error)
switch {

13
utils/dataconverter_test.go
View File

@@ -1037,7 +1037,7 @@ func TestLenTimeConverter3(t *testing.T) {
} else if !reflect.DeepEqual(expected, rcv) {
t.Errorf("Expecting: %+v, received: %+v", expected, rcv)
}
if rcv, err := cnv.Convert("[]"); err != nil {
if rcv, err := cnv.Convert("[}"); err != nil {
t.Error(err)
} else if !reflect.DeepEqual(expected, rcv) {
t.Errorf("Expecting: %+v, received: %+v", expected, rcv)
@@ -1230,6 +1230,17 @@ func TestLenTimeConverter3(t *testing.T) {
} else if !reflect.DeepEqual(expected, rcv) {
t.Errorf("Expecting: %+v, received: %+v", expected, rcv)
}
if rcv, err := cnv.Convert("[]"); err != nil {
t.Error(err)
} else if !reflect.DeepEqual(expected, rcv) {
t.Errorf("Expecting: %+v, received: %+v", expected, rcv)
}
if rcv, err := cnv.Convert("{}"); err != nil {
t.Error(err)
} else if !reflect.DeepEqual(expected, rcv) {
t.Errorf("Expecting: %+v, received: %+v", expected, rcv)
}
}
func TestFloat64Converter(t *testing.T) {

145
utils/librates_test.go
View File

@@ -2097,6 +2097,15 @@ func TestRateProfileFieldAsInterface(t *testing.T) {
if _, err := rp.FieldAsInterface([]string{Rates, "rat2"}); err != ErrNotFound {
t.Fatal(err)
}
if _, err := rp.FieldAsInterface([]string{Rates, "rat1", ""}); err != ErrNotFound {
t.Fatal(err)
}
if _, err := rp.FieldAsInterface([]string{Rates, "rat1", "", ""}); err != ErrNotFound {
t.Fatal(err)
}
if _, err := rp.FieldAsInterface([]string{Rates, "rat1", "", "", ""}); err != ErrNotFound {
t.Fatal(err)
}
if val, err := rp.FieldAsInterface([]string{Rates + "[rat1]", ID}); err != nil {
t.Fatal(err)
@@ -2128,4 +2137,140 @@ func TestRateProfileFieldAsInterface(t *testing.T) {
} else if exp := ";0"; !reflect.DeepEqual(exp, val) {
t.Errorf("Expected %v \n but received \n %v", ToJSON(exp), ToJSON(val))
}
if val, err := rp.FieldAsInterface([]string{Rates + "[rat1]", FilterIDs + "[0]"}); err != nil {
t.Fatal(err)
} else if exp := rp.Rates["rat1"].FilterIDs[0]; !reflect.DeepEqual(exp, val) {
t.Errorf("Expected %v \n but received \n %v", ToJSON(exp), ToJSON(val))
}
if val, err := rp.FieldAsInterface([]string{Rates + "[rat1]", IntervalRates + "[0]"}); err != nil {
t.Fatal(err)
} else if exp := rp.Rates["rat1"].IntervalRates[0]; !reflect.DeepEqual(exp, val) {
t.Errorf("Expected %v \n but received \n %v", ToJSON(exp), ToJSON(val))
}
if _, err := rp.FieldAsInterface([]string{Rates + "[rat1]", IntervalRates + "[0]", ""}); err != ErrNotFound {
t.Fatal(err)
}
if _, err := rp.Rates["rat1"].IntervalRates[0].FieldAsInterface([]string{"", ""}); err != ErrNotFound {
t.Fatal(err)
}
if val, err := rp.FieldAsInterface([]string{Rates + "[rat1]", IntervalRates + "[0]", IntervalStart}); err != nil {
t.Fatal(err)
} else if exp := rp.Rates["rat1"].IntervalRates[0].IntervalStart; exp.Cmp(val.(*Decimal).Big) != 0 {
t.Errorf("Expected %v \n but received \n %v", ToJSON(exp), ToJSON(val))
}
if val, err := rp.FieldAsInterface([]string{Rates + "[rat1]", IntervalRates + "[0]", FixedFee}); err != nil {
t.Fatal(err)
} else if exp := rp.Rates["rat1"].IntervalRates[0].FixedFee; exp.Cmp(val.(*Decimal).Big) != 0 {
t.Errorf("Expected %v \n but received \n %v", ToJSON(exp), ToJSON(val))
}
if val, err := rp.FieldAsInterface([]string{Rates + "[rat1]", IntervalRates + "[0]", RecurrentFee}); err != nil {
t.Fatal(err)
} else if exp := rp.Rates["rat1"].IntervalRates[0].RecurrentFee; exp.Cmp(val.(*Decimal).Big) != 0 {
t.Errorf("Expected %v \n but received \n %v", ToJSON(exp), ToJSON(val))
}
if val, err := rp.FieldAsInterface([]string{Rates + "[rat1]", IntervalRates + "[0]", Unit}); err != nil {
t.Fatal(err)
} else if exp := rp.Rates["rat1"].IntervalRates[0].Unit; exp.Cmp(val.(*Decimal).Big) != 0 {
t.Errorf("Expected %v \n but received \n %v", ToJSON(exp), ToJSON(val))
}
if val, err := rp.FieldAsInterface([]string{Rates + "[rat1]", IntervalRates + "[0]", Increment}); err != nil {
t.Fatal(err)
} else if exp := rp.Rates["rat1"].IntervalRates[0].Increment; exp.Cmp(val.(*Decimal).Big) != 0 {
t.Errorf("Expected %v \n but received \n %v", ToJSON(exp), ToJSON(val))
}
if _, err := rp.FieldAsString([]string{""}); err != ErrNotFound {
t.Fatal(err)
}
if val, err := rp.FieldAsString([]string{Tenant}); err != nil {
t.Fatal(err)
} else if exp := "cgrates.org"; exp != val {
t.Errorf("Expected %v \n but received \n %v", ToJSON(exp), ToJSON(val))
}
if val, exp := rp.String(), ToJSON(rp); exp != val {
t.Errorf("Expected %v \n but received \n %v", ToJSON(exp), ToJSON(val))
}
if _, err := rp.Rates["rat1"].FieldAsString([]string{""}); err != ErrNotFound {
t.Fatal(err)
}
if val, err := rp.Rates["rat1"].FieldAsString([]string{ID}); err != nil {
t.Fatal(err)
} else if exp := "rat1"; exp != val {
t.Errorf("Expected %v \n but received \n %v", ToJSON(exp), ToJSON(val))
}
if val, exp := rp.Rates["rat1"].String(), ToJSON(rp.Rates["rat1"]); exp != val {
t.Errorf("Expected %v \n but received \n %v", ToJSON(exp), ToJSON(val))
}
if _, err := rp.Rates["rat1"].IntervalRates[0].FieldAsString([]string{""}); err != ErrNotFound {
t.Fatal(err)
}
if val, err := rp.Rates["rat1"].IntervalRates[0].FieldAsString([]string{IntervalStart}); err != nil {
t.Fatal(err)
} else if exp := "10"; exp != val {
t.Errorf("Expected %v \n but received \n %v", ToJSON(exp), ToJSON(val))
}
if val, exp := rp.Rates["rat1"].IntervalRates[0].String(), ToJSON(rp.Rates["rat1"].IntervalRates[0]); exp != val {
t.Errorf("Expected %v \n but received \n %v", ToJSON(exp), ToJSON(val))
}
}
func TestRateProfileMerge(t *testing.T) {
acc := &RateProfile{
Rates: map[string]*Rate{
"rat1": {},
"rat2": {Blocker: true},
},
}
exp := &RateProfile{
Tenant: "cgrates.org",
ID: "ID",
FilterIDs: []string{"fltr1"},
Weights: DynamicWeights{{}},
MinCost: NewDecimal(10, 0),
MaxCost: NewDecimal(10, 0),
MaxCostStrategy: "strategy",
Rates: map[string]*Rate{
"rat1": {
ID: "rat1",
FilterIDs: []string{"fltr1"},
ActivationTimes: "* * * * *",
Weights: DynamicWeights{{}},
Blocker: true,
IntervalRates: []*IntervalRate{{}},
},
"rat2": {
ID: "rat2",
Blocker: true,
},
"rat3": {},
},
}
if acc.Merge(&RateProfile{
Tenant: "cgrates.org",
ID: "ID",
FilterIDs: []string{"fltr1"},
Weights: DynamicWeights{{}},
MinCost: NewDecimal(10, 0),
MaxCost: NewDecimal(10, 0),
MaxCostStrategy: "strategy",
Rates: map[string]*Rate{
"rat1": {
ID: "rat1",
FilterIDs: []string{"fltr1"},
ActivationTimes: "* * * * *",
Weights: DynamicWeights{{}},
Blocker: true,
IntervalRates: []*IntervalRate{{}},
},
"rat2": {
ID: "rat2",
},
"rat3": {},
},
}); !reflect.DeepEqual(exp, acc) {
t.Errorf("Expected %v \n but received \n %v", ToJSON(exp), ToJSON(acc))
}
}

41
utils/struct_test.go
View File

@@ -18,6 +18,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>
package utils
import (
"fmt"
"math/cmplx"
"reflect"
"testing"
@@ -221,26 +222,20 @@ func TestUpdateStructWithIfaceMapErrorDefault(t *testing.T) {
}
}
// func TestContentStructFieldByIndexIsEmpty(t *testing.T) {
// type InsideStruct struct {
// Field1 int
// }
// type contentStruct struct {
// content1 string
// content2 InsideStruct
// }
// myStruct := contentStruct{
// content1: "string1",
// content2: InsideStruct{
// Field1: 1,
// },
// }
// value := reflect.ValueOf(myStruct)
// ptr := value.FieldByName("content2")
// value = reflect.Indirect(ptr).FieldByName("Field1")
// if fieldByIndexIsEmpty(value, []int{0, 1}) {
// fmt.Printf("%v", value)
// }
// }
func TestContentStructFieldByIndexIsEmpty(t *testing.T) {
type testStr struct {
fld int
}
myStruct := struct {
content1 string
content2 *testStr
}{
content1: "string1",
content2: &testStr{
fld: 1,
},
}
if fieldByIndexIsEmpty(reflect.ValueOf(myStruct), []int{1, 0}) {
fmt.Printf("%v", myStruct)
}
}