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

Added DynamicDataProvider to AgentRequest

Browse Source
This commit is contained in:
Trial97
2020-05-20 10:39:05 +03:00
committed by Dan Christian Bogos
parent da9344128c
commit 1fd9ac009e
13 changed files with 316 additions and 294 deletions
Download Patch File Download Diff File Expand all files Collapse all files

7
utils/dataprovider.go
View File

@@ -20,6 +20,7 @@ package utils
import (
"net"
"strconv"
"strings"
)
@@ -93,7 +94,7 @@ func AppendNavMapVal(nm navMap, fldPath *FullPath, val NMInterface) (err error)
} else {
indx = prevItm.Len()
}
fldPath.PathItems[len(fldPath.PathItems)-1].Index = &indx
fldPath.PathItems[len(fldPath.PathItems)-1].Index = StringPointer(strconv.Itoa(indx))
_, err = nm.Set(fldPath, val)
return
}
@@ -109,7 +110,7 @@ func ComposeNavMapVal(nm navMap, fldPath *FullPath, val NMInterface) (err error)
} else {
indx = prevItmSlice.Len() - 1
var prevItm NMInterface
if prevItm, err = prevItmSlice.Field(PathItems{{Index: &indx}}); err != nil {
if prevItm, err = prevItmSlice.Field(PathItems{{Index: StringPointer(strconv.Itoa(indx))}}); err != nil {
if err != ErrNotFound {
return
}
@@ -117,7 +118,7 @@ func ComposeNavMapVal(nm navMap, fldPath *FullPath, val NMInterface) (err error)
return
}
}
fldPath.PathItems[len(fldPath.PathItems)-1].Index = &indx
fldPath.PathItems[len(fldPath.PathItems)-1].Index = StringPointer(strconv.Itoa(indx))
_, err = nm.Set(fldPath, val)
return
}

15
utils/mapstorage_test.go
View File

@@ -189,12 +189,12 @@ func TestNavMapFieldAsInterface(t *testing.T) {
nM := MapStorage{
"FirstLevel": map[string]interface{}{
"SecondLevel": []map[string]interface{}{
map[string]interface{}{
{
"ThirdLevel": map[string]interface{}{
"Fld1": "Val1",
},
},
map[string]interface{}{
{
"Count": 10,
"ThirdLevel2": map[string]interface{}{
"Fld2": []string{"Val1", "Val2", "Val3"},
@@ -297,9 +297,10 @@ func TestNavMapGetKeys(t *testing.T) {
func TestNavMapFieldAsInterface2(t *testing.T) {
nM := MapStorage{
"Slice": &[]struct{}{{}},
"SliceString": []string{"1", "2"},
"SliceInterface": []interface{}{1, "2"},
"AnotherFirstLevel": "ValAnotherFirstLevel",
"Slice": &[]struct{}{{}},
"SliceString": []string{"1", "2"},
"SliceInterface": []interface{}{1, "2"},
}
path := []string{"Slice[1]"}
@@ -379,12 +380,12 @@ func TestNavMapGetField2(t *testing.T) {
},
"FirstLevel2": MapStorage{
"SecondLevel2": []MapStorage{
MapStorage{
{
"ThirdLevel2": MapStorage{
"Fld1": "Val1",
},
},
MapStorage{
{
"Count": 10,
"ThirdLevel2": MapStorage{
"Fld2": []string{"Val1", "Val2", "Val3"},

4
utils/navigablemap.go
View File

@@ -58,7 +58,9 @@ func (nm NavigableMap2) Field(path PathItems) (val NMInterface, err error) {
return nil, ErrNotFound
case NMMapType:
if path[0].Index != nil {
return nil, ErrNotFound
path[0].Field = *path[0].Index
path[0].Index = nil
return el.Field(path)
}
return el.Field(path[1:])
case NMSliceType:

46
utils/navigablemap_test.go
View File

@@ -68,15 +68,15 @@ func TestNavigableMap2Field(t *testing.T) {
t.Errorf("Expected %q ,received: %q", "1001", val.Interface())
}
if _, err := nm.Field(PathItems{{Field: "Field1", Index: IntPointer(0)}}); err != ErrNotFound {
if _, err := nm.Field(PathItems{{Field: "Field1", Index: StringPointer("0")}}); err != ErrNotFound {
t.Error(err)
}
if val, err := nm.Field(PathItems{{Field: "Field5", Index: IntPointer(0)}}); err != nil {
if val, err := nm.Field(PathItems{{Field: "Field5", Index: StringPointer("0")}}); err != nil {
t.Error(err)
} else if val.Interface() != 10 {
t.Errorf("Expected %q ,received: %q", 10, val.Interface())
}
if _, err := nm.Field(PathItems{{Field: "Field3", Index: IntPointer(0)}}); err != ErrNotFound {
if _, err := nm.Field(PathItems{{Field: "Field3", Index: StringPointer("0")}}); err != ErrNotFound {
t.Error(err)
}
if val, err := nm.Field(PathItems{{Field: "Field3"}, {Field: "Field4"}}); err != nil {
@@ -91,11 +91,11 @@ func TestNavigableMap2Set(t *testing.T) {
if _, err := nm.Set(nil, nil); err != ErrWrongPath {
t.Error(err)
}
if _, err := nm.Set(PathItems{{Field: "Field1", Index: IntPointer(10)}}, NewNMData("1001")); err != ErrWrongPath {
if _, err := nm.Set(PathItems{{Field: "Field1", Index: StringPointer("10")}}, NewNMData("1001")); err != ErrWrongPath {
t.Error(err)
}
expected := NavigableMap2{"Field1": &NMSlice{NewNMData("1001")}}
if _, err := nm.Set(PathItems{{Field: "Field1", Index: IntPointer(0)}}, NewNMData("1001")); err != nil {
if _, err := nm.Set(PathItems{{Field: "Field1", Index: StringPointer("0")}}, NewNMData("1001")); err != nil {
t.Error(err)
} else if !reflect.DeepEqual(nm, expected) {
t.Errorf("Expected %s ,received: %s", expected, nm)
@@ -109,14 +109,14 @@ func TestNavigableMap2Set(t *testing.T) {
} else if !reflect.DeepEqual(nm, expected) {
t.Errorf("Expected %s ,received: %s", expected, nm)
}
if _, err := nm.Set(PathItems{{Field: "Field2", Index: IntPointer(1)}}, NewNMData("1003")); err != ErrWrongPath {
if _, err := nm.Set(PathItems{{Field: "Field2", Index: StringPointer("1")}}, NewNMData("1003")); err != ErrWrongPath {
t.Error(err)
}
expected = NavigableMap2{
"Field1": &NMSlice{NewNMData("1001"), NewNMData("1003")},
"Field2": NewNMData("1002"),
}
if _, err := nm.Set(PathItems{{Field: "Field1", Index: IntPointer(1)}}, NewNMData("1003")); err != nil {
if _, err := nm.Set(PathItems{{Field: "Field1", Index: StringPointer("1")}}, NewNMData("1003")); err != nil {
t.Error(err)
} else if !reflect.DeepEqual(nm, expected) {
t.Errorf("Expected %s ,received: %s", expected, nm)
@@ -131,7 +131,7 @@ func TestNavigableMap2Set(t *testing.T) {
t.Errorf("Expected %s ,received: %s", expected, nm)
}
if _, err := nm.Set(PathItems{{Field: "Field3", Index: IntPointer(10)}, {}}, NewNMData("1001")); err != ErrWrongPath {
if _, err := nm.Set(PathItems{{Field: "Field3", Index: StringPointer("10")}, {}}, NewNMData("1001")); err != ErrWrongPath {
t.Error(err)
}
expected = NavigableMap2{
@@ -139,13 +139,13 @@ func TestNavigableMap2Set(t *testing.T) {
"Field2": NewNMData("1004"),
"Field3": &NMSlice{NavigableMap2{"Field4": NewNMData("1005")}},
}
if _, err := nm.Set(PathItems{{Field: "Field3", Index: IntPointer(0)}, {Field: "Field4"}}, NewNMData("1005")); err != nil {
if _, err := nm.Set(PathItems{{Field: "Field3", Index: StringPointer("0")}, {Field: "Field4"}}, NewNMData("1005")); err != nil {
t.Error(err)
} else if !reflect.DeepEqual(nm, expected) {
t.Errorf("Expected %s ,received: %s", expected, nm)
}
if _, err := nm.Set(PathItems{{Field: "Field5"}, {Field: "Field6", Index: IntPointer(10)}}, NewNMData("1006")); err != ErrWrongPath {
if _, err := nm.Set(PathItems{{Field: "Field5"}, {Field: "Field6", Index: StringPointer("10")}}, NewNMData("1006")); err != ErrWrongPath {
t.Error(err)
}
@@ -161,7 +161,7 @@ func TestNavigableMap2Set(t *testing.T) {
t.Errorf("Expected %s ,received: %s", expected, nm)
}
if _, err := nm.Set(PathItems{{Field: "Field2", Index: IntPointer(0)}, {}}, NewNMData("1006")); err != ErrWrongPath {
if _, err := nm.Set(PathItems{{Field: "Field2", Index: StringPointer("0")}, {}}, NewNMData("1006")); err != ErrWrongPath {
t.Error(err)
}
expected = NavigableMap2{
@@ -170,7 +170,7 @@ func TestNavigableMap2Set(t *testing.T) {
"Field3": &NMSlice{NavigableMap2{"Field4": NewNMData("1005")}},
"Field5": NavigableMap2{"Field6": NewNMData("1006")},
}
if _, err := nm.Set(PathItems{{Field: "Field1", Index: IntPointer(2)}, {Field: "Field6"}}, NewNMData("1006")); err != nil {
if _, err := nm.Set(PathItems{{Field: "Field1", Index: StringPointer("2")}, {Field: "Field6"}}, NewNMData("1006")); err != nil {
t.Error(err)
} else if !reflect.DeepEqual(nm, expected) {
t.Errorf("Expected %s ,received: %s", expected, nm)
@@ -238,7 +238,7 @@ func TestNavigableMap2Remove(t *testing.T) {
t.Error(err)
}
if err := nm.Remove(PathItems{{Index: IntPointer(-1)}, {}}); err != nil {
if err := nm.Remove(PathItems{{Index: StringPointer("-1")}, {}}); err != nil {
t.Error(err)
}
expected := NavigableMap2{
@@ -269,13 +269,13 @@ func TestNavigableMap2Remove(t *testing.T) {
"Field5": &NMSlice{NewNMData(101)},
}
if err := nm.Remove(PathItems{{Field: "Field5", Index: IntPointer(0)}}); err != nil {
if err := nm.Remove(PathItems{{Field: "Field5", Index: StringPointer("0")}}); err != nil {
t.Error(err)
} else if !reflect.DeepEqual(nm, expected) {
t.Errorf("Expected %s ,received: %s", expected, nm)
}
if err := nm.Remove(PathItems{{Field: "Field1", Index: IntPointer(0)}, {}}); err != ErrWrongPath {
if err := nm.Remove(PathItems{{Field: "Field1", Index: StringPointer("0")}, {}}); err != ErrWrongPath {
t.Error(err)
}
@@ -284,7 +284,7 @@ func TestNavigableMap2Remove(t *testing.T) {
"Field3": NavigableMap2{"Field4": NewNMData("Val")},
}
if err := nm.Remove(PathItems{{Field: "Field5", Index: IntPointer(0)}}); err != nil {
if err := nm.Remove(PathItems{{Field: "Field5", Index: StringPointer("0")}}); err != nil {
t.Error(err)
} else if !reflect.DeepEqual(nm, expected) {
t.Errorf("Expected %s ,received: %s", expected, nm)
@@ -295,7 +295,7 @@ func TestNavigableMap2Remove(t *testing.T) {
"Field3": NavigableMap2{"Field4": NewNMData("Val")},
"Field5": &NMSlice{NavigableMap2{"Field42": NewNMData("Val2")}},
}
if err := nm.Remove(PathItems{{Field: "Field5", Index: IntPointer(0)}, {Field: "Field42", Index: IntPointer(0)}}); err != ErrWrongPath {
if err := nm.Remove(PathItems{{Field: "Field5", Index: StringPointer("0")}, {Field: "Field42", Index: StringPointer("0")}}); err != ErrWrongPath {
t.Error(err)
}
@@ -305,7 +305,7 @@ func TestNavigableMap2Remove(t *testing.T) {
"Field3": NavigableMap2{"Field4": NewNMData("Val")},
}
if err := nm.Remove(PathItems{{Field: "Field5", Index: IntPointer(0)}, {Field: "Field42"}}); err != nil {
if err := nm.Remove(PathItems{{Field: "Field5", Index: StringPointer("0")}, {Field: "Field42"}}); err != nil {
t.Error(err)
} else if !reflect.DeepEqual(nm, expected) {
t.Errorf("Expected %s ,received: %s", expected, nm)
@@ -314,7 +314,7 @@ func TestNavigableMap2Remove(t *testing.T) {
if err := nm.Remove(PathItems{{Field: "Field1"}, {}}); err != ErrWrongPath {
t.Error(err)
}
if err := nm.Remove(PathItems{{Field: "Field3"}, {Field: "Field4", Index: IntPointer(0)}}); err != ErrWrongPath {
if err := nm.Remove(PathItems{{Field: "Field3"}, {Field: "Field4", Index: StringPointer("0")}}); err != ErrWrongPath {
t.Error(err)
}
expected = NavigableMap2{
@@ -357,7 +357,7 @@ func TestNavigableMap2GetSet(t *testing.T) {
t.Errorf("Expected %q ,received: %q", 5, val.Interface())
}
path = PathItems{{Field: "Field2", Index: IntPointer(2)}}
path = PathItems{{Field: "Field2", Index: StringPointer("2")}}
if _, err := nm.Set(path, NewNMData("500")); err != nil {
t.Error(err)
}
@@ -367,17 +367,17 @@ func TestNavigableMap2GetSet(t *testing.T) {
t.Errorf("Expected %q ,received: %q", "500", val.Interface())
}
path = PathItems{{Field: "Field2", Index: IntPointer(1)}, {Field: "Account"}}
path = PathItems{{Field: "Field2", Index: StringPointer("1")}, {Field: "Account"}}
if _, err := nm.Set(path, NewNMData("5")); err != nil {
t.Error(err)
}
path = PathItems{{Field: "Field2", Index: IntPointer(1)}, {Field: "Account"}}
path = PathItems{{Field: "Field2", Index: StringPointer("1")}, {Field: "Account"}}
if val, err := nm.Field(path); err != nil {
t.Error(err)
} else if val.Interface() != "5" {
t.Errorf("Expected %q ,received: %q", "5", val.Interface())
}
path = PathItems{{Field: "Field2", Index: IntPointer(1)}, {Field: "Account", Index: IntPointer(0)}}
path = PathItems{{Field: "Field2", Index: StringPointer("1")}, {Field: "Account", Index: StringPointer("0")}}
if _, err := nm.Field(path); err != ErrNotFound {
t.Error(err)
}

21
utils/nmslice.go
View File

@@ -18,6 +18,8 @@ along with this program. If not, see <http://www.gnu.org/licenses/>
package utils
import "strconv"
// NMSlice is the basic slice of NM interface
type NMSlice []NMInterface
@@ -46,7 +48,10 @@ func (nms *NMSlice) Field(path PathItems) (val NMInterface, err error) {
if nms.Empty() || path[0].Index == nil {
return nil, ErrNotFound
}
idx := *path[0].Index
var idx int
if idx, err = strconv.Atoi(*path[0].Index); err != nil {
return
}
if idx < 0 {
idx = len(*nms) + idx
}
@@ -64,7 +69,10 @@ func (nms *NMSlice) Set(path PathItems, val NMInterface) (addedNew bool, err err
if len(path) == 0 || path[0].Index == nil {
return false, ErrWrongPath
}
idx := *path[0].Index
var idx int
if idx, err = strconv.Atoi(*path[0].Index); err != nil {
return
}
if idx == len(*nms) { // append element
addedNew = true
if len(path) == 1 {
@@ -84,7 +92,7 @@ func (nms *NMSlice) Set(path PathItems, val NMInterface) (addedNew bool, err err
if idx < 0 || idx >= len(*nms) {
return false, ErrWrongPath
}
path[0].Index = &idx
path[0].Index = StringPointer(strconv.Itoa(idx))
if len(path) == 1 {
(*nms)[idx] = val
return
@@ -100,14 +108,17 @@ func (nms *NMSlice) Remove(path PathItems) (err error) {
if len(path) == 0 || path[0].Index == nil {
return ErrWrongPath
}
idx := *path[0].Index
var idx int
if idx, err = strconv.Atoi(*path[0].Index); err != nil {
return
}
if idx < 0 {
idx = len(*nms) + idx
}
if idx < 0 || idx >= len(*nms) { // already removed
return
}
path[0].Index = &idx
path[0].Index = StringPointer(strconv.Itoa(idx))
if len(path) == 1 {
*nms = append((*nms)[:idx], (*nms)[idx+1:]...)
return

30
utils/nmslice_test.go
View File

@@ -57,18 +57,18 @@ func TestNMSliceField(t *testing.T) {
if _, err := nm.Field(PathItems{{}}); err != ErrNotFound {
t.Error(err)
}
if _, err := nm.Field(PathItems{{Index: IntPointer(4)}}); err != ErrNotFound {
if _, err := nm.Field(PathItems{{Index: StringPointer("4")}}); err != ErrNotFound {
t.Error(err)
}
if _, err := nm.Field(nil); err != ErrWrongPath {
t.Error(err)
}
if val, err := nm.Field(PathItems{{Field: "None", Index: IntPointer(-1)}, {Field: "Field1"}}); err != nil {
if val, err := nm.Field(PathItems{{Field: "None", Index: StringPointer("-1")}, {Field: "Field1"}}); err != nil {
t.Error(err)
} else if val.Interface() != "Val" {
t.Errorf("Expected %q ,received: %q", "Val", val.Interface())
}
if val, err := nm.Field(PathItems{{Field: "1234", Index: IntPointer(1)}}); err != nil {
if val, err := nm.Field(PathItems{{Field: "1234", Index: StringPointer("1")}}); err != nil {
t.Error(err)
} else if val.Interface() != "1003" {
t.Errorf("Expected %q ,received: %q", "Val", val.Interface())
@@ -81,31 +81,31 @@ func TestNMSliceSet(t *testing.T) {
t.Error(err)
}
expected := &NMSlice{NewNMData("1001")}
if _, err := nm.Set(PathItems{{Field: "1234", Index: IntPointer(0)}}, NewNMData("1001")); err != nil {
if _, err := nm.Set(PathItems{{Field: "1234", Index: StringPointer("0")}}, NewNMData("1001")); err != nil {
t.Error(err)
} else if !reflect.DeepEqual(nm, expected) {
t.Errorf("Expected %s ,received: %s", expected, nm)
}
if _, err := nm.Set(PathItems{{Field: "1234", Index: IntPointer(1)}, {Field: "Field1", Index: IntPointer(1)}},
if _, err := nm.Set(PathItems{{Field: "1234", Index: StringPointer("1")}, {Field: "Field1", Index: StringPointer("1")}},
NewNMData("1001")); err != ErrWrongPath {
t.Error(err)
}
expected = &NMSlice{NewNMData("1001"), NavigableMap2{"Field1": NewNMData("1001")}}
if _, err := nm.Set(PathItems{{Field: "1234", Index: IntPointer(1)}, {Field: "Field1"}},
if _, err := nm.Set(PathItems{{Field: "1234", Index: StringPointer("1")}, {Field: "Field1"}},
NewNMData("1001")); err != nil {
t.Error(err)
} else if !reflect.DeepEqual(nm, expected) {
t.Errorf("Expected %s ,received: %s", expected, nm)
}
expected = &NMSlice{NewNMData("1001"), NewNMData("1001")}
if _, err := nm.Set(PathItems{{Field: "1234", Index: IntPointer(-1)}}, NewNMData("1001")); err != nil {
if _, err := nm.Set(PathItems{{Field: "1234", Index: StringPointer("-1")}}, NewNMData("1001")); err != nil {
t.Error(err)
} else if !reflect.DeepEqual(nm, expected) {
t.Errorf("Expected %s ,received: %s", expected, nm)
}
nm = &NMSlice{&NMSlice{}}
if _, err := nm.Set(PathItems{{Field: "1234", Index: IntPointer(0)}, {}}, NewNMData("1001")); err != ErrWrongPath {
if _, err := nm.Set(PathItems{{Field: "1234", Index: StringPointer("0")}, {}}, NewNMData("1001")); err != ErrWrongPath {
t.Error(err)
}
}
@@ -156,7 +156,7 @@ func TestNMSliceRemove(t *testing.T) {
t.Error(err)
}
if err := nm.Remove(PathItems{{Index: IntPointer(-1)}, {}}); err != ErrWrongPath {
if err := nm.Remove(PathItems{{Index: StringPointer("-1")}, {}}); err != ErrWrongPath {
t.Error(err)
}
expected := &NMSlice{
@@ -165,13 +165,13 @@ func TestNMSliceRemove(t *testing.T) {
&NavigableMap2{"Field1": NewNMData("Val")},
}
if err := nm.Remove(PathItems{{Index: IntPointer(-1)}}); err != nil {
if err := nm.Remove(PathItems{{Index: StringPointer("-1")}}); err != nil {
t.Error(err)
} else if !reflect.DeepEqual(nm, expected) {
t.Errorf("Expected %s ,received: %s", expected, nm)
}
if err := nm.Remove(PathItems{{Index: IntPointer(1)}, {}}); err != ErrWrongPath {
if err := nm.Remove(PathItems{{Index: StringPointer("1")}, {}}); err != ErrWrongPath {
t.Error(err)
}
@@ -179,25 +179,25 @@ func TestNMSliceRemove(t *testing.T) {
NewNMData("1001"),
&NavigableMap2{"Field1": NewNMData("Val")},
}
if err := nm.Remove(PathItems{{Index: IntPointer(1)}}); err != nil {
if err := nm.Remove(PathItems{{Index: StringPointer("1")}}); err != nil {
t.Error(err)
} else if !reflect.DeepEqual(nm, expected) {
t.Errorf("Expected %s ,received: %s", expected, nm)
}
if err := nm.Remove(PathItems{{Index: IntPointer(10)}}); err != nil {
if err := nm.Remove(PathItems{{Index: StringPointer("10")}}); err != nil {
t.Error(err)
} else if !reflect.DeepEqual(nm, expected) {
t.Errorf("Expected %s ,received: %s", expected, nm)
}
if err := nm.Remove(PathItems{{Index: IntPointer(1)}, {Field: "Field1", Index: IntPointer(1)}}); err != ErrWrongPath {
if err := nm.Remove(PathItems{{Index: StringPointer("1")}, {Field: "Field1", Index: StringPointer("1")}}); err != ErrWrongPath {
t.Error(err)
}
expected = &NMSlice{
NewNMData("1001"),
}
if err := nm.Remove(PathItems{{Index: IntPointer(1)}, {Field: "Field1"}}); err != nil {
if err := nm.Remove(PathItems{{Index: StringPointer("1")}, {Field: "Field1"}}); err != nil {
t.Error(err)
} else if !reflect.DeepEqual(nm, expected) {
t.Errorf("Expected %s ,received: %s", expected, nm)

3
utils/orderednavigablemap.go
View File

@@ -20,6 +20,7 @@ package utils
import (
"net"
"strconv"
"strings"
)
@@ -108,7 +109,7 @@ func (onm *OrderedNavigableMap) Set(fullPath *FullPath, val NMInterface) (addedN
pathItmsSet = make([]PathItems, len(*val.(*NMSlice)))
for i := 0; i < val.Len(); i++ {
pathItms := fullPath.PathItems.Clone()
pathItms[len(pathItms)-1].Index = IntPointer(i)
pathItms[len(pathItms)-1].Index = StringPointer(strconv.Itoa(i))
pathItmsSet[i] = pathItms
}
} else {

146
utils/orderednavigablemap_test.go
View File

@@ -38,11 +38,11 @@ func TestOrderedNavigableMap(t *testing.T) {
onm.Set(&FullPath{
Path: "Field2[0]",
PathItems: PathItems{{Field: "Field2", Index: IntPointer(0)}},
PathItems: PathItems{{Field: "Field2", Index: StringPointer("0")}},
}, NewNMData("1001"))
expOrder = []PathItems{
PathItems{{Field: "Field1"}},
PathItems{{Field: "Field2", Index: IntPointer(0)}},
PathItems{{Field: "Field2", Index: StringPointer("0")}},
}
if !reflect.DeepEqual(expOrder, onm.GetOrder()) {
t.Errorf("Expected %s ,received: %s", expOrder, ToJSON(onm.GetOrder()))
@@ -51,15 +51,15 @@ func TestOrderedNavigableMap(t *testing.T) {
onm.Set(&FullPath{
Path: "Field2[1].Account[0]",
PathItems: PathItems{
{Field: "Field2", Index: IntPointer(1)},
{Field: "Account", Index: IntPointer(0)}},
{Field: "Field2", Index: StringPointer("1")},
{Field: "Account", Index: StringPointer("0")}},
}, NewNMData(10))
expOrder = []PathItems{
PathItems{{Field: "Field1"}},
PathItems{{Field: "Field2", Index: IntPointer(0)}},
PathItems{{Field: "Field2", Index: StringPointer("0")}},
PathItems{
{Field: "Field2", Index: IntPointer(1)},
{Field: "Account", Index: IntPointer(0)}},
{Field: "Field2", Index: StringPointer("1")},
{Field: "Account", Index: StringPointer("0")}},
}
if !reflect.DeepEqual(expOrder, onm.GetOrder()) {
t.Errorf("Expected %s ,received: %s", expOrder, ToJSON(onm.GetOrder()))
@@ -68,18 +68,18 @@ func TestOrderedNavigableMap(t *testing.T) {
onm.Set(&FullPath{
Path: "Field2[1].Account[1]",
PathItems: PathItems{
{Field: "Field2", Index: IntPointer(1)},
{Field: "Account", Index: IntPointer(1)}},
{Field: "Field2", Index: StringPointer("1")},
{Field: "Account", Index: StringPointer("1")}},
}, NewNMData(11))
expOrder = []PathItems{
PathItems{{Field: "Field1"}},
PathItems{{Field: "Field2", Index: IntPointer(0)}},
PathItems{{Field: "Field2", Index: StringPointer("0")}},
PathItems{
{Field: "Field2", Index: IntPointer(1)},
{Field: "Account", Index: IntPointer(0)}},
{Field: "Field2", Index: StringPointer("1")},
{Field: "Account", Index: StringPointer("0")}},
PathItems{
{Field: "Field2", Index: IntPointer(1)},
{Field: "Account", Index: IntPointer(1)}},
{Field: "Field2", Index: StringPointer("1")},
{Field: "Account", Index: StringPointer("1")}},
}
if !reflect.DeepEqual(expOrder, onm.GetOrder()) {
t.Errorf("Expected %s ,received: %s", expOrder, ToJSON(onm.GetOrder()))
@@ -87,18 +87,18 @@ func TestOrderedNavigableMap(t *testing.T) {
onm.Set(&FullPath{
Path: "Field2[2]",
PathItems: PathItems{{Field: "Field2", Index: IntPointer(2)}},
PathItems: PathItems{{Field: "Field2", Index: StringPointer("2")}},
}, NewNMData(111))
expOrder = []PathItems{
PathItems{{Field: "Field1"}},
PathItems{{Field: "Field2", Index: IntPointer(0)}},
PathItems{{Field: "Field2", Index: StringPointer("0")}},
PathItems{
{Field: "Field2", Index: IntPointer(1)},
{Field: "Account", Index: IntPointer(0)}},
{Field: "Field2", Index: StringPointer("1")},
{Field: "Account", Index: StringPointer("0")}},
PathItems{
{Field: "Field2", Index: IntPointer(1)},
{Field: "Account", Index: IntPointer(1)}},
PathItems{{Field: "Field2", Index: IntPointer(2)}},
{Field: "Field2", Index: StringPointer("1")},
{Field: "Account", Index: StringPointer("1")}},
PathItems{{Field: "Field2", Index: StringPointer("2")}},
}
if !reflect.DeepEqual(expOrder, onm.GetOrder()) {
t.Errorf("Expected %s ,received: %s", expOrder, ToJSON(onm.GetOrder()))
@@ -113,14 +113,14 @@ func TestOrderedNavigableMap(t *testing.T) {
}, NewNMData(5))
expOrder = []PathItems{
PathItems{{Field: "Field1"}},
PathItems{{Field: "Field2", Index: IntPointer(0)}},
PathItems{{Field: "Field2", Index: StringPointer("0")}},
PathItems{
{Field: "Field2", Index: IntPointer(1)},
{Field: "Account", Index: IntPointer(0)}},
{Field: "Field2", Index: StringPointer("1")},
{Field: "Account", Index: StringPointer("0")}},
PathItems{
{Field: "Field2", Index: IntPointer(1)},
{Field: "Account", Index: IntPointer(1)}},
PathItems{{Field: "Field2", Index: IntPointer(2)}},
{Field: "Field2", Index: StringPointer("1")},
{Field: "Account", Index: StringPointer("1")}},
PathItems{{Field: "Field2", Index: StringPointer("2")}},
PathItems{
{Field: "Field3"},
{Field: "Field4"},
@@ -173,14 +173,14 @@ func TestOrderedNavigableMap(t *testing.T) {
{Field: "Field3"},
{Field: "Field4"},
{Field: "Field5"}},
PathItems{{Field: "Field2", Index: IntPointer(0)}},
PathItems{{Field: "Field2", Index: IntPointer(1)}},
PathItems{{Field: "Field2", Index: StringPointer("0")}},
PathItems{{Field: "Field2", Index: StringPointer("1")}},
}
if !reflect.DeepEqual(expOrder, onm.GetOrder()) {
t.Errorf("Expected %s ,received: %s", expOrder, onm.GetOrder())
}
path = PathItems{{Field: "Field2", Index: IntPointer(0)}}
path = PathItems{{Field: "Field2", Index: StringPointer("0")}}
if val, err := onm.Field(path); err != nil {
t.Error(err)
} else if val.Interface() != "500" {
@@ -248,15 +248,15 @@ func TestOrderedNavigableMapField(t *testing.T) {
t.Errorf("Expected %q ,received: %q", "1001", val.Interface())
}
if _, err := nm.Field(PathItems{{Field: "Field1", Index: IntPointer(0)}}); err != ErrNotFound {
if _, err := nm.Field(PathItems{{Field: "Field1", Index: StringPointer("0")}}); err != ErrNotFound {
t.Error(err)
}
if val, err := nm.Field(PathItems{{Field: "Field5", Index: IntPointer(0)}}); err != nil {
if val, err := nm.Field(PathItems{{Field: "Field5", Index: StringPointer("0")}}); err != nil {
t.Error(err)
} else if val.Interface() != 10 {
t.Errorf("Expected %q ,received: %q", 10, val.Interface())
}
if _, err := nm.Field(PathItems{{Field: "Field3", Index: IntPointer(0)}}); err != ErrNotFound {
if _, err := nm.Field(PathItems{{Field: "Field3", Index: StringPointer("0")}}); err != ErrNotFound {
t.Error(err)
}
if val, err := nm.Field(PathItems{{Field: "Field3"}, {Field: "Field4"}}); err != nil {
@@ -298,17 +298,17 @@ func TestOrderedNavigableMapLen(t *testing.T) {
func TestOrderedNavigableMapGetSet(t *testing.T) {
nm := NewOrderedNavigableMap()
nm.Set(&FullPath{
PathItems: PathItems{{Field: "Account", Index: IntPointer(0)}},
PathItems: PathItems{{Field: "Account", Index: StringPointer("0")}},
Path: "Account",
}, NewNMData(1001))
nm.Set(&FullPath{
PathItems: PathItems{{Field: "Account", Index: IntPointer(1)}},
PathItems: PathItems{{Field: "Account", Index: StringPointer("1")}},
Path: "Account",
}, NewNMData("account_on_new_branch"))
expectedOrder := []PathItems{
{{Field: "Account", Index: IntPointer(0)}},
{{Field: "Account", Index: IntPointer(1)}},
{{Field: "Account", Index: StringPointer("0")}},
{{Field: "Account", Index: StringPointer("1")}},
}
if recivedOrder := nm.GetOrder(); !reflect.DeepEqual(expectedOrder, recivedOrder) {
@@ -346,7 +346,7 @@ func TestOrderedNavigableMapGetSet(t *testing.T) {
t.Errorf("Expected %q ,received: %q", 5, val.Interface())
}
path = PathItems{{Field: "Field2", Index: IntPointer(2)}}
path = PathItems{{Field: "Field2", Index: StringPointer("2")}}
if _, err := nm.Set(&FullPath{Path: path.String(), PathItems: path}, NewNMData("500")); err != nil {
t.Error(err)
}
@@ -356,17 +356,17 @@ func TestOrderedNavigableMapGetSet(t *testing.T) {
t.Errorf("Expected %q ,received: %q", "500", val.Interface())
}
path = PathItems{{Field: "Field2", Index: IntPointer(1)}, {Field: "Account"}}
path = PathItems{{Field: "Field2", Index: StringPointer("1")}, {Field: "Account"}}
if _, err := nm.Set(&FullPath{Path: path.String(), PathItems: path}, NewNMData("5")); err != nil {
t.Error(err)
}
path = PathItems{{Field: "Field2", Index: IntPointer(1)}, {Field: "Account"}}
path = PathItems{{Field: "Field2", Index: StringPointer("1")}, {Field: "Account"}}
if val, err := nm.Field(path); err != nil {
t.Error(err)
} else if val.Interface() != "5" {
t.Errorf("Expected %q ,received: %q", "5", val.Interface())
}
path = PathItems{{Field: "Field2", Index: IntPointer(1)}, {Field: "Account", Index: IntPointer(0)}}
path = PathItems{{Field: "Field2", Index: StringPointer("1")}, {Field: "Account", Index: StringPointer("0")}}
if _, err := nm.Field(path); err != ErrNotFound {
t.Error(err)
}
@@ -423,26 +423,26 @@ func TestOrderedNavigableMapFieldAsString(t *testing.T) {
func TestOrderedNavigableMapGetOrder(t *testing.T) {
nm := NewOrderedNavigableMap()
nm.Set(&FullPath{
PathItems: PathItems{{Field: "Field1"}, {Field: "Field2", Index: IntPointer(0)}},
PathItems: PathItems{{Field: "Field1"}, {Field: "Field2", Index: StringPointer("0")}},
Path: "Field1.Field2[0]",
}, NewNMData("1003"))
nm.Set(&FullPath{
PathItems: PathItems{{Field: "Field1"}, {Field: "Field2", Index: IntPointer(1)}},
PathItems: PathItems{{Field: "Field1"}, {Field: "Field2", Index: StringPointer("1")}},
Path: "Field1.Field2[1]",
}, NewNMData("Val"))
nm.Set(&FullPath{
PathItems: PathItems{{Field: "Field3"}, {Field: "Field4"}, {Field: "Field5", Index: IntPointer(0)}},
PathItems: PathItems{{Field: "Field3"}, {Field: "Field4"}, {Field: "Field5", Index: StringPointer("0")}},
Path: "Field3.Field4.Field5",
}, NewNMData("1001"))
nm.Set(&FullPath{
PathItems: PathItems{{Field: "Field1"}, {Field: "Field2", Index: IntPointer(2)}},
PathItems: PathItems{{Field: "Field1"}, {Field: "Field2", Index: StringPointer("2")}},
Path: "Field1.Field2[2]",
}, NewNMData(101))
expected := []PathItems{
{{Field: "Field1"}, {Field: "Field2", Index: IntPointer(0)}},
{{Field: "Field1"}, {Field: "Field2", Index: IntPointer(1)}},
{{Field: "Field3"}, {Field: "Field4"}, {Field: "Field5", Index: IntPointer(0)}},
{{Field: "Field1"}, {Field: "Field2", Index: IntPointer(2)}},
{{Field: "Field1"}, {Field: "Field2", Index: StringPointer("0")}},
{{Field: "Field1"}, {Field: "Field2", Index: StringPointer("1")}},
{{Field: "Field3"}, {Field: "Field4"}, {Field: "Field5", Index: StringPointer("0")}},
{{Field: "Field1"}, {Field: "Field2", Index: StringPointer("2")}},
}
if rply := nm.GetOrder(); !reflect.DeepEqual(rply, expected) {
t.Errorf("Expected %s ,received: %s", expected, rply)
@@ -457,18 +457,18 @@ func TestOrderedNavigableMapSet(t *testing.T) {
t.Error(err)
}
if _, err := nm.Set(&FullPath{
PathItems: PathItems{{Field: "Field1", Index: IntPointer(10)}},
PathItems: PathItems{{Field: "Field1", Index: StringPointer("10")}},
Path: "Field1[10]",
}, NewNMData("1001")); err != ErrWrongPath {
t.Error(err)
}
if _, err := nm.Set(&FullPath{
PathItems: PathItems{{Field: "Field1", Index: IntPointer(10)}, {Field: "Field2"}},
PathItems: PathItems{{Field: "Field1", Index: StringPointer("10")}, {Field: "Field2"}},
Path: "Field1[10].Field2",
}, NewNMData("1001")); err != ErrWrongPath {
t.Error(err)
}
path := PathItems{{Field: "Field1", Index: IntPointer(0)}}
path := PathItems{{Field: "Field1", Index: StringPointer("0")}}
if addedNew, err := nm.Set(&FullPath{
PathItems: path,
Path: path.String(),
@@ -486,26 +486,26 @@ func TestOrderedNavigableMapSet(t *testing.T) {
t.Errorf("Expected %s ,received: %s", order, nm.GetOrder())
}
if _, err := nm.Set(&FullPath{
PathItems: PathItems{{Field: "Field1", Index: IntPointer(0)}, {}},
PathItems: PathItems{{Field: "Field1", Index: StringPointer("0")}, {}},
Path: "Field1[0]",
}, NewNMData("1001")); err != ErrWrongPath {
t.Error(err)
}
if _, err := nm.Set(&FullPath{
PathItems: PathItems{{Field: "Field1", Index: IntPointer(10)}},
PathItems: PathItems{{Field: "Field1", Index: StringPointer("10")}},
Path: "Field1[10]",
}, NewNMData("1001")); err != ErrWrongPath {
t.Error(err)
}
if _, err := nm.Set(&FullPath{
PathItems: PathItems{{Field: "Field1", Index: IntPointer(0)}, {}},
PathItems: PathItems{{Field: "Field1", Index: StringPointer("0")}, {}},
Path: "Field1[0]",
}, &NMSlice{}); err != ErrWrongPath {
t.Error(err)
}
if _, err := nm.Set(&FullPath{
PathItems: PathItems{{Field: "Field1", Index: IntPointer(10)}},
PathItems: PathItems{{Field: "Field1", Index: StringPointer("10")}},
Path: "Field[10]",
}, &NMSlice{}); err != ErrWrongPath {
t.Error(err)
@@ -547,7 +547,7 @@ func TestOrderedNavigableMapSet(t *testing.T) {
if !reflect.DeepEqual(nm.GetOrder(), order) {
t.Errorf("Expected %s ,received: %s", order, nm.GetOrder())
}
path = PathItems{{Field: "Field1", Index: IntPointer(1)}}
path = PathItems{{Field: "Field1", Index: StringPointer("1")}}
nMap = NavigableMap2{
"Field1": &NMSlice{NewNMData("1002"), NewNMData("1003")},
"Field2": NewNMData("1002"),
@@ -574,7 +574,7 @@ func TestOrderedNavigableMapSet(t *testing.T) {
"Field2": NewNMData("1002"),
"Field3": obj,
}
order = append(order, PathItems{{Field: "Field3", Index: IntPointer(0)}}, PathItems{{Field: "Field3", Index: IntPointer(1)}})
order = append(order, PathItems{{Field: "Field3", Index: StringPointer("0")}}, PathItems{{Field: "Field3", Index: StringPointer("1")}})
if addedNew, err := nm.Set(&FullPath{
PathItems: path,
Path: path.String(),
@@ -597,10 +597,10 @@ func TestOrderedNavigableMapSet(t *testing.T) {
}
order = []PathItems{
{{Field: "Field2"}},
{{Field: "Field3", Index: IntPointer(0)}},
{{Field: "Field3", Index: IntPointer(1)}},
{{Field: "Field1", Index: IntPointer(0)}},
{{Field: "Field1", Index: IntPointer(1)}},
{{Field: "Field3", Index: StringPointer("0")}},
{{Field: "Field3", Index: StringPointer("1")}},
{{Field: "Field1", Index: StringPointer("0")}},
{{Field: "Field1", Index: StringPointer("1")}},
}
if addedNew, err := nm.Set(&FullPath{
PathItems: PathItems{{Field: "Field1"}},
@@ -624,13 +624,13 @@ func TestOrderedNavigableMapSet(t *testing.T) {
}
order = []PathItems{
{{Field: "Field2"}},
{{Field: "Field3", Index: IntPointer(0)}},
{{Field: "Field1", Index: IntPointer(0)}},
{{Field: "Field1", Index: IntPointer(1)}},
{{Field: "Field3", Index: IntPointer(1)}},
{{Field: "Field3", Index: StringPointer("0")}},
{{Field: "Field1", Index: StringPointer("0")}},
{{Field: "Field1", Index: StringPointer("1")}},
{{Field: "Field3", Index: StringPointer("1")}},
}
if addedNew, err := nm.Set(&FullPath{
PathItems: PathItems{{Field: "Field3", Index: IntPointer(-1)}},
PathItems: PathItems{{Field: "Field3", Index: StringPointer("-1")}},
Path: "Field3[-1]",
}, NewNMData("1007")); err != nil {
t.Error(err)
@@ -673,7 +673,7 @@ func TestOrderedNavigableMapRemove(t *testing.T) {
t.Error(err)
}
if err := nm.Remove(&FullPath{PathItems: PathItems{{Index: IntPointer(-1)}, {}}}); err != ErrWrongPath {
if err := nm.Remove(&FullPath{PathItems: PathItems{{Index: StringPointer("-1")}, {}}}); err != ErrWrongPath {
t.Error(err)
}
nMap := NavigableMap2{
@@ -686,8 +686,8 @@ func TestOrderedNavigableMapRemove(t *testing.T) {
{{Field: "Field2"}},
{{Field: "Field3"}, {Field: "Field4"}},
{{Field: "Field1"}},
{{Field: "Field5", Index: IntPointer(0)}},
{{Field: "Field5", Index: IntPointer(1)}},
{{Field: "Field5", Index: StringPointer("0")}},
{{Field: "Field5", Index: StringPointer("1")}},
}
if !reflect.DeepEqual(nm.nm, nMap) {
t.Errorf("Expected %s ,received: %s", nMap, nm)
@@ -703,8 +703,8 @@ func TestOrderedNavigableMapRemove(t *testing.T) {
order = []PathItems{
{{Field: "Field3"}, {Field: "Field4"}},
{{Field: "Field1"}},
{{Field: "Field5", Index: IntPointer(0)}},
{{Field: "Field5", Index: IntPointer(1)}},
{{Field: "Field5", Index: StringPointer("0")}},
{{Field: "Field5", Index: StringPointer("1")}},
}
if err := nm.Remove(&FullPath{PathItems: PathItems{{Field: "Field2"}}, Path: "Field2"}); err != nil {
@@ -734,7 +734,7 @@ func TestOrderedNavigableMapRemove(t *testing.T) {
if !reflect.DeepEqual(nm.GetOrder(), order) {
t.Errorf("Expected %s ,received: %s", order, nm.GetOrder())
}
if err := nm.Remove(&FullPath{PathItems: PathItems{{Field: "Field1", Index: IntPointer(0)}, {}}}); err != ErrWrongPath {
if err := nm.Remove(&FullPath{PathItems: PathItems{{Field: "Field1", Index: StringPointer("0")}, {}}}); err != ErrWrongPath {
t.Error(err)
}
}

11
utils/pathitem.go
View File

@@ -44,7 +44,7 @@ type FullPath struct {
func NewPathItems(path []string) (pItms PathItems) {
pItms = make(PathItems, len(path))
for i, v := range path {
field, indx := GetPathIndex(v)
field, indx := GetPathIndexString(v)
pItms[i] = PathItem{
Field: field,
Index: indx,
@@ -82,7 +82,7 @@ func (path PathItems) String() (out string) {
// PathItem used by the NM interface to store the path information
type PathItem struct {
Field string
Index *int
Index *string
}
// Equal returns true if p==p2
@@ -102,7 +102,7 @@ func (p PathItem) Equal(p2 PathItem) bool {
func (p PathItem) String() (out string) {
out = p.Field
if p.Index != nil {
out += IdxStart + strconv.Itoa(*p.Index) + IdxEnd
out += IdxStart + *p.Index + IdxEnd
}
return
}
@@ -114,7 +114,7 @@ func (p PathItem) Clone() (c PathItem) {
// }
c.Field = p.Field
if p.Index != nil {
c.Index = IntPointer(*p.Index)
c.Index = StringPointer(*p.Index)
}
return
}
@@ -148,6 +148,9 @@ func GetPathWithoutIndex(spath string) (opath string) {
return
}
// GetPathIndexString returns the path and index as string if index present
// path[index]=>path,index
// path=>path,nil
func GetPathIndexString(spath string) (opath string, idx *string) {
idxStart := strings.Index(spath, IdxStart)
if idxStart == -1 || !strings.HasSuffix(spath, IdxEnd) {

14
utils/pathitem_test.go
View File

@@ -56,7 +56,7 @@ func TestStripIdxFromLastPathElm(t *testing.T) {
func TestNewPathItems(t *testing.T) {
pathSlice := strings.Split("*req.Field1[0].Account", NestingSep)
expected := PathItems{{Field: MetaReq}, {Field: "Field1", Index: IntPointer(0)}, {Field: Account}}
expected := PathItems{{Field: MetaReq}, {Field: "Field1", Index: StringPointer("0")}, {Field: Account}}
if rply := NewPathItems(pathSlice); !reflect.DeepEqual(expected, rply) {
t.Errorf("Expected: %s, received: %s", ToJSON(expected), ToJSON(rply))
}
@@ -73,7 +73,7 @@ func TestPathItemString(t *testing.T) {
if rply := path.String(); expected != rply {
t.Errorf("Expected: %q, received: %q", expected, rply)
}
path = PathItem{Field: MetaReq, Index: IntPointer(10)}
path = PathItem{Field: MetaReq, Index: StringPointer("10")}
expected = MetaReq + "[10]"
if rply := path.String(); expected != rply {
t.Errorf("Expected: %q, received: %q", expected, rply)
@@ -90,21 +90,21 @@ func TestPathItemEqual(t *testing.T) {
if path.Equal(p1) {
t.Errorf("Expected %s to not be equal to %s", ToJSON(path), ToJSON(p1))
}
p1 = PathItem{Field: MetaReq, Index: IntPointer(0)}
p1 = PathItem{Field: MetaReq, Index: StringPointer("0")}
if path.Equal(p1) {
t.Errorf("Expected %s to not be equal to %s", ToJSON(path), ToJSON(p1))
}
path = PathItem{Field: MetaReq, Index: IntPointer(0)}
path = PathItem{Field: MetaReq, Index: StringPointer("0")}
if !path.Equal(p1) {
t.Errorf("Expected %s to be equal to %s", ToJSON(path), ToJSON(p1))
}
}
func TestPathItemClone(t *testing.T) {
path := PathItem{Field: MetaReq, Index: IntPointer(0)}
expected := PathItem{Field: MetaReq, Index: IntPointer(0)}
path := PathItem{Field: MetaReq, Index: StringPointer("0")}
expected := PathItem{Field: MetaReq, Index: StringPointer("0")}
rply := path.Clone()
*path.Index = 1
*path.Index = "1"
if !reflect.DeepEqual(expected, rply) {
t.Errorf("Expected: %s, received: %s", ToJSON(expected), ToJSON(rply))
}