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

Fix compilation errors and remove tests for deleted libdynamics functions

Browse Source
This commit is contained in:
ionutboangiu
2021-10-13 10:07:42 +03:00
committed by Dan Christian Bogos
parent e3f413ffb4
commit 92bb9ef87a
5 changed files with 24 additions and 438 deletions
Download Patch File Download Diff File Expand all files Collapse all files

16
config/accountscfg_test.go
View File

@@ -112,11 +112,19 @@ func TestAccountSCfgLoadFromJSONCfgOptsErr(t *testing.T) {
}
jsnCfg := &AccountsOptsJson{
AccountIDs: map[string][]string{},
Usage: map[string]string{
"Value": "error",
AccountIDs: []*utils.DynamicStringSliceOpt{
{},
},
Usage: []*utils.DynamicStringOpt{
{
Value: "error",
},
},
ProfileIgnoreFilters: []*utils.DynamicBoolOpt{
{
Value: false,
},
},
ProfileIgnoreFilters: map[string]bool{},
}
errExp := "can't convert <error> to decimal"
if err := accOpts.loadFromJSONCfg(jsnCfg); err == nil || err.Error() != errExp {

4
config/config.go
View File

@@ -157,8 +157,8 @@ func newCGRConfig(config []byte) (cfg *CGRConfig, err error) {
IgnoreErrors: []*utils.DynamicBoolOpt{},
MaxCost: []*utils.DynamicInterfaceOpt{},
ProfileCount: []*utils.DynamicIntOpt{},
Limit: []*utils.DynamicIntOpt{},
Offset: []*utils.DynamicIntOpt{},
Limit: []*utils.DynamicIntPointerOpt{},
Offset: []*utils.DynamicIntPointerOpt{},
Usage: []*utils.DynamicDecimalBigOpt{},
}},
sureTaxCfg: new(SureTaxCfg),

8
config/config_test.go
View File

@@ -860,8 +860,8 @@ func TestCgrCfgJSONDefaultRouteSCfg(t *testing.T) {
Value: utils.EmptyString,
},
},
Limit: []*utils.DynamicIntOpt{},
Offset: []*utils.DynamicIntOpt{},
Limit: []*utils.DynamicIntPointerOpt{},
Offset: []*utils.DynamicIntPointerOpt{},
Usage: []*utils.DynamicDecimalBigOpt{
{
FilterIDs: []string{utils.MetaDefault},
@@ -2154,8 +2154,8 @@ func TestRouteSConfig(t *testing.T) {
Value: utils.EmptyString,
},
},
Limit: []*utils.DynamicIntOpt{},
Offset: []*utils.DynamicIntOpt{},
Limit: []*utils.DynamicIntPointerOpt{},
Offset: []*utils.DynamicIntPointerOpt{},
Usage: []*utils.DynamicDecimalBigOpt{
{
FilterIDs: []string{utils.MetaDefault},

28
config/routescfg_test.go
View File

@@ -79,8 +79,8 @@ func TestRouteSCfgloadFromJsonCfg(t *testing.T) {
Value: utils.EmptyString,
},
},
Limit: []*utils.DynamicIntOpt{},
Offset: []*utils.DynamicIntOpt{},
Limit: []*utils.DynamicIntPointerOpt{},
Offset: []*utils.DynamicIntPointerOpt{},
Usage: []*utils.DynamicDecimalBigOpt{
{
FilterIDs: []string{utils.MetaDefault},
@@ -266,16 +266,8 @@ func TestDiffRouteSJsonCfg(t *testing.T) {
Value: 5,
},
},
Limit: []*utils.DynamicIntOpt{
{
Value: 1,
},
},
Offset: []*utils.DynamicIntOpt{
{
Value: 1,
},
},
Limit: []*utils.DynamicIntPointerOpt{},
Offset: []*utils.DynamicIntPointerOpt{},
ProfileCount: []*utils.DynamicIntOpt{
{
Value: 1,
@@ -311,16 +303,8 @@ func TestDiffRouteSJsonCfg(t *testing.T) {
Value: utils.MetaEventCost,
},
},
Limit: []*utils.DynamicIntOpt{
{
Value: 2,
},
},
Offset: []*utils.DynamicIntOpt{
{
Value: 2,
},
},
Limit: []*utils.DynamicIntPointerOpt{},
Offset: []*utils.DynamicIntPointerOpt{},
ProfileCount: []*utils.DynamicIntOpt{
{
Value: 2,

406
utils/libdynamics_test.go
View File

@@ -20,7 +20,6 @@ package utils
import (
"reflect"
"sort"
"testing"
"time"
@@ -550,408 +549,3 @@ func TestDynamicInterfaceOptEqual(t *testing.T) {
t.Error("Expected slices to differ")
}
}
// Dynamic to Map
func TestDynamicStringSliceOptsToMap(t *testing.T) {
in := []*DynamicStringSliceOpt{
{
Value: []string{"VAL_1", "VAL_2"},
FilterIDs: []string{"fltr1", "fltr2"},
},
{
Value: []string{"VAL_3", "VAL_4"},
FilterIDs: []string{"fltr2"},
},
}
exp := map[string][]string{
"fltr1;fltr2": {"VAL_1", "VAL_2"},
"fltr2": {"VAL_3", "VAL_4"},
}
if mp := DynamicStringSliceOptsToMap(in); !reflect.DeepEqual(exp, mp) {
t.Errorf("Expected %v \n but received \n %v", ToJSON(exp), ToJSON(mp))
}
}
func TestDynamicStringOptsToMap(t *testing.T) {
in := []*DynamicStringOpt{
{
Value: "VAL_1",
FilterIDs: []string{"fltr1", "fltr2"},
},
{
Value: "VAL_2",
FilterIDs: []string{"fltr2"},
},
}
exp := map[string]string{
"fltr1;fltr2": "VAL_1",
"fltr2": "VAL_2",
}
if mp := DynamicStringOptsToMap(in); !reflect.DeepEqual(exp, mp) {
t.Errorf("Expected %v \n but received \n %v", ToJSON(exp), ToJSON(mp))
}
}
func TestDynamicBoolOptsToMap(t *testing.T) {
in := []*DynamicBoolOpt{
{
Value: true,
FilterIDs: []string{"fltr1", "fltr2"},
},
{
Value: false,
FilterIDs: []string{"fltr2"},
},
}
exp := map[string]bool{
"fltr1;fltr2": true,
"fltr2": false,
}
if mp := DynamicBoolOptsToMap(in); !reflect.DeepEqual(exp, mp) {
t.Errorf("Expected %v \n but received \n %v", ToJSON(exp), ToJSON(mp))
}
}
func TestDynamicIntOptsToMap(t *testing.T) {
in := []*DynamicIntOpt{
{
Value: 1,
FilterIDs: []string{"fltr1", "fltr2"},
},
{
Value: 2,
FilterIDs: []string{"fltr2"},
},
}
exp := map[string]int{
"fltr1;fltr2": 1,
"fltr2": 2,
}
if mp := DynamicIntOptsToMap(in); !reflect.DeepEqual(exp, mp) {
t.Errorf("Expected %v \n but received \n %v", ToJSON(exp), ToJSON(mp))
}
}
func TestDynamicFloat64OptsToMap(t *testing.T) {
in := []*DynamicFloat64Opt{
{
Value: 2.2,
FilterIDs: []string{"fltr1", "fltr2"},
},
{
Value: 5.1,
FilterIDs: []string{"fltr2"},
},
}
exp := map[string]float64{
"fltr1;fltr2": 2.2,
"fltr2": 5.1,
}
if mp := DynamicFloat64OptsToMap(in); !reflect.DeepEqual(exp, mp) {
t.Errorf("Expected %v \n but received \n %v", ToJSON(exp), ToJSON(mp))
}
}
func TestDynamicDurationOptsToMap(t *testing.T) {
in := []*DynamicDurationOpt{
{
Value: time.Second * 2,
FilterIDs: []string{"fltr1", "fltr2"},
},
{
Value: time.Second * 8,
FilterIDs: []string{"fltr2"},
},
}
exp := map[string]string{
"fltr1;fltr2": "2s",
"fltr2": "8s",
}
if mp := DynamicDurationOptsToMap(in); !reflect.DeepEqual(exp, mp) {
t.Errorf("Expected %v \n but received \n %v", ToJSON(exp), ToJSON(mp))
}
}
func TestDynamicDecimalBigOptsToMap(t *testing.T) {
in := []*DynamicDecimalBigOpt{
{
Value: new(decimal.Big).SetUint64(21),
FilterIDs: []string{"fltr1", "fltr2"},
},
{
Value: new(decimal.Big).SetUint64(3),
FilterIDs: []string{"fltr2"},
},
}
exp := map[string]string{
"fltr1;fltr2": "21",
"fltr2": "3",
}
if mp := DynamicDecimalBigOptsToMap(in); !reflect.DeepEqual(exp, mp) {
t.Errorf("Expected %v \n but received \n %v", ToJSON(exp), ToJSON(mp))
}
}
func TestDynamicInterfaceOptsToMap(t *testing.T) {
in := []*DynamicInterfaceOpt{
{
Value: 1,
FilterIDs: []string{"fltr1", "fltr2"},
},
{
Value: 2,
FilterIDs: []string{"fltr2"},
},
}
exp := map[string]interface{}{
"fltr1;fltr2": 1,
"fltr2": 2,
}
if mp := DynamicInterfaceOptsToMap(in); !reflect.DeepEqual(exp, mp) {
t.Errorf("Expected %v \n but received \n %v", ToJSON(exp), ToJSON(mp))
}
}
// Map to Dynamic
func TestMapToDynamicStringSliceOpts(t *testing.T) {
exp := []*DynamicStringSliceOpt{
{
Value: []string{"VAL_1", "VAL_2"},
FilterIDs: []string{"fltr1", "fltr2"},
},
{
Value: []string{"VAL_3", "VAL_4"},
FilterIDs: []string{"fltr2"},
},
}
in := map[string][]string{
"fltr1;fltr2": {"VAL_1", "VAL_2"},
"fltr2": {"VAL_3", "VAL_4"},
}
rcv := MapToDynamicStringSliceOpts(in)
sort.Slice(rcv, func(i, j int) bool {
return rcv[i].Value[i] < rcv[j].Value[j]
})
if !reflect.DeepEqual(exp, rcv) {
t.Errorf("Expected %v \n but received \n %v", ToJSON(exp), ToJSON(rcv))
}
}
func TestMapToDynamicStringOpts(t *testing.T) {
exp := []*DynamicStringOpt{
{
Value: "VAL_1",
FilterIDs: []string{"fltr1", "fltr2"},
},
{
Value: "VAL_2",
FilterIDs: []string{"fltr2"},
},
}
in := map[string]string{
"fltr1;fltr2": "VAL_1",
"fltr2": "VAL_2",
}
rcv := MapToDynamicStringOpts(in)
sort.Slice(rcv, func(i, j int) bool {
return rcv[i].Value < rcv[j].Value
})
if !reflect.DeepEqual(exp, rcv) {
t.Errorf("Expected %v \n but received \n %v", ToJSON(exp), ToJSON(rcv))
}
}
func TestMapToDynamicBoolOpts(t *testing.T) {
exp := []*DynamicBoolOpt{
{
Value: true,
FilterIDs: []string{"fltr1", "fltr2"},
},
{
Value: false,
FilterIDs: []string{"fltr2"},
},
}
in := map[string]bool{
"fltr1;fltr2": true,
"fltr2": false,
}
rcv := MapToDynamicBoolOpts(in)
sort.Slice(rcv, func(i, j int) bool {
return len(rcv[i].FilterIDs) > len(rcv[j].FilterIDs)
})
if !reflect.DeepEqual(exp, rcv) {
t.Errorf("Expected %v \n but received \n %v", ToJSON(exp), ToJSON(rcv))
}
}
func TestMapToDynamicIntOpts(t *testing.T) {
exp := []*DynamicIntOpt{
{
Value: 1,
FilterIDs: []string{"fltr1", "fltr2"},
},
{
Value: 2,
FilterIDs: []string{"fltr2"},
},
}
in := map[string]int{
"fltr1;fltr2": 1,
"fltr2": 2,
}
rcv := MapToDynamicIntOpts(in)
sort.Slice(rcv, func(i, j int) bool {
return rcv[i].Value < rcv[j].Value
})
if !reflect.DeepEqual(exp, rcv) {
t.Errorf("Expected %v \n but received \n %v", ToJSON(exp), ToJSON(rcv))
}
}
func TestMapToDynamicFloat64Opts(t *testing.T) {
exp := []*DynamicFloat64Opt{
{
Value: 2.2,
FilterIDs: []string{"fltr1", "fltr2"},
},
{
Value: 5.1,
FilterIDs: []string{"fltr2"},
},
}
in := map[string]float64{
"fltr1;fltr2": 2.2,
"fltr2": 5.1,
}
rcv := MapToDynamicFloat64Opts(in)
sort.Slice(rcv, func(i, j int) bool {
return rcv[i].Value < rcv[j].Value
})
if !reflect.DeepEqual(exp, rcv) {
t.Errorf("Expected %v \n but received \n %v", ToJSON(exp), ToJSON(rcv))
}
}
func TestMapToDynamicDecimalBigOpts(t *testing.T) {
exp := []*DynamicDecimalBigOpt{
{
Value: new(decimal.Big).SetUint64(3),
FilterIDs: []string{"fltr1", "fltr2"},
},
{
Value: new(decimal.Big).SetUint64(21),
FilterIDs: []string{"fltr2"},
},
}
in := map[string]string{
"fltr1;fltr2": "3",
"fltr2": "21",
}
rcv, err := MapToDynamicDecimalBigOpts(in)
if err != nil {
t.Error(err)
}
sort.Slice(rcv, func(i, j int) bool {
return len(rcv[i].FilterIDs) > len(rcv[j].FilterIDs)
})
if !reflect.DeepEqual(exp, rcv) {
t.Errorf("Expected %v \n but received \n %v", ToJSON(exp), ToJSON(rcv))
}
in = map[string]string{
"fltr1;fltr2": "3c",
"fltr2": "21c",
}
errExp := "can't convert <3c> to decimal"
_, err = MapToDynamicDecimalBigOpts(in)
if err == nil || err.Error() != errExp {
t.Errorf("Expected error: %s \n received \n %+v", errExp, err)
}
}
func TestMapToDynamicDurationOpts(t *testing.T) {
exp := []*DynamicDurationOpt{
{
Value: time.Second * 2,
FilterIDs: []string{"fltr1", "fltr2"},
},
{
Value: time.Second * 8,
FilterIDs: []string{"fltr2"},
},
}
in := map[string]string{
"fltr1;fltr2": "2s",
"fltr2": "8s",
}
rcv, err := MapToDynamicDurationOpts(in)
sort.Slice(rcv, func(i, j int) bool {
return len(rcv[i].FilterIDs) > len(rcv[j].FilterIDs)
})
if err != nil {
t.Error(err)
}
if !reflect.DeepEqual(exp, rcv) {
t.Errorf("Expected %v \n but received \n %v", ToJSON(exp), ToJSON(rcv))
}
in = map[string]string{
"fltr1;fltr2": MetaUnlimited,
"fltr2": MetaUnlimited,
}
}
func TestMapToDynamicInterfaceOpts(t *testing.T) {
exp := []*DynamicInterfaceOpt{
{
Value: 1,
FilterIDs: []string{"fltr1", "fltr2"},
},
{
Value: 2,
FilterIDs: []string{"fltr2"},
},
}
in := map[string]interface{}{
"fltr1;fltr2": 1,
"fltr2": 2,
}
rcv := MapToDynamicInterfaceOpts(in)
sort.Slice(rcv, func(i, j int) bool {
return len(rcv[i].FilterIDs) > len(rcv[j].FilterIDs)
})
if !reflect.DeepEqual(exp, rcv) {
t.Errorf("Expected %v \n but received \n %v", ToJSON(exp), ToJSON(rcv))
}
}