From c7e0432b01a9e475f31ca2c00ff24ab2799e5565 Mon Sep 17 00:00:00 2001 From: NikolasPetriti Date: Fri, 16 Jun 2023 16:44:18 +0200 Subject: [PATCH] Added coverage tests for mapstorage.go, errors.go and dataprovider.go --- utils/dataprovider_test.go | 15 +++ utils/errors_test.go | 21 +++ utils/mapstorage_test.go | 254 +++++++++++++++++++++++++++++++------ 3 files changed, 253 insertions(+), 37 deletions(-) diff --git a/utils/dataprovider_test.go b/utils/dataprovider_test.go index 35ac88fc9..794df58ef 100644 --- a/utils/dataprovider_test.go +++ b/utils/dataprovider_test.go @@ -135,6 +135,21 @@ func TestComposeNavMapVal(t *testing.T) { if err := ComposeNavMapVal(onm, &FullPath{Path: "Field5", PathItems: PathItems{{Field: "Field5"}}}, &mockNMInterface{data: 10}); err != ErrNotImplemented { t.Error(err) } + + nm = NavigableMap2{ + "Field4": NewNMData(1), + "Field5": &NMSlice{NewNMData(10), NewNMData(101)}, + } + if err := ComposeNavMapVal(onm, &FullPath{}, NewNMData(10)); err == nil { + t.Error("was expecting an error") + } + + onm = NewOrderedNavigableMap() + nm = NavigableMap2{ + } + if err := ComposeNavMapVal(onm, &FullPath{Path: "Field", PathItems: PathItems{}}, NewNMData(18)); err == nil { + t.Error("was expecting an error") + } } // mock NMInterface structure diff --git a/utils/errors_test.go b/utils/errors_test.go index 0d6c34054..dc4cfe87c 100644 --- a/utils/errors_test.go +++ b/utils/errors_test.go @@ -217,6 +217,17 @@ func TestIsNetworkError(t *testing.T) { t.Errorf("%s error should be consider a network error", err) } + err = &net.DNSError{ + Err: "DNS error", + Name: "example.com", + Server: "8.8.8.8:53", + IsTimeout: true, + IsTemporary: true, + } + if !IsNetworkError(err) { + t.Errorf("%s error should be consider a network error", err) + } + } func TestErrPathNotReachable(t *testing.T) { @@ -230,3 +241,13 @@ func TestErrNotConvertibleTF(t *testing.T) { t.Errorf("Expecting: not convertible : from: test_type1 to:test_type2, received: %+v", rcv) } } + +func TestNewErrChargerS(t *testing.T) { + arg := fmt.Errorf("test") + exp := fmt.Errorf("CHARGERS_ERROR:%s", arg) + rcv := NewErrChargerS(arg) + + if exp.Error() != rcv.Error() { + t.Errorf("recived %s, expected %s", rcv, exp) + } +} diff --git a/utils/mapstorage_test.go b/utils/mapstorage_test.go index 0d9bb7902..5dbf8ac3f 100644 --- a/utils/mapstorage_test.go +++ b/utils/mapstorage_test.go @@ -18,8 +18,8 @@ along with this program. If not, see package utils import ( + "fmt" "reflect" - "sort" "strings" "testing" ) @@ -296,45 +296,225 @@ func TestNavMapFieldAsInterface(t *testing.T) { } func TestNavMapGetKeys(t *testing.T) { - navMp := MapStorage{ - "FirstLevel": map[string]any{ - "SecondLevel": map[string]any{ - "ThirdLevel": map[string]any{ - "Fld1": 123.123, - }, - }, + tests := []struct { + name string + arg bool + expected []string + }{ + { + name: "only first layer of keywords", + arg: false, + expected: []string{"SlcAny", "SlcString", "MS", "MP", "Test", + "SlcMapStorage", "SlcDataStorage", "SlcMap", "Uint8"}, }, - "FistLever2": map[string]any{ - "SecondLevel2": map[string]any{ - "Field2": 123, - }, - "Field3": "Value3", - "Field4": &testStruct{ - Item1: "Ten", - Item2: 10, - }, + { + name: "all layers", + arg: true, + expected: []string{"SlcAny[0]", "SlcString[0]", "MS.test", "MP.test2", "Test", + "SlcMapStorage[0].test3", "SlcDataStorage[0].test4", "SlcMap[0].test5", "Uint8"}, }, - "Field5": &testStruct{ - Item1: "Ten", - Item2: 10, - }, - "Field6": []string{"1", "2"}, } - expKeys := []string{ - "FirstLevel.SecondLevel.ThirdLevel.Fld1", - "FistLever2.SecondLevel2.Field2", - "FistLever2.Field3", - "FistLever2.Field4.Item1", - "FistLever2.Field4.Item2", - "Field5.Item1", - "Field5.Item2", - "Field6[0]", - "Field6[1]", + + var num uint8 = 1 + + ms := MapStorage{ + "MS": MapStorage{"test": 1}, + "MP": map[string]any{"test2": 2}, + "Test": "test string", + "SlcMapStorage": []MapStorage{{"test3": 3}}, + "SlcDataStorage": []dataStorage{MapStorage{"test4": 4}}, + "SlcMap": []map[string]any{{"test5": 5}}, + "SlcAny": []any{map[string]any{"test6": 6}}, + "SlcString": []string{"test7"}, + "Uint8": num, } - keys := navMp.GetKeys(true) - sort.Strings(expKeys) - sort.Strings(keys) - if !reflect.DeepEqual(expKeys, keys) { - t.Errorf("Expecting: %+v, received: %+v", ToJSON(expKeys), ToJSON(keys)) + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + rcv := ms.GetKeys(tt.arg) + var has bool + + for _, vRcv := range rcv { + has = false + for _, vExp := range tt.expected { + if vRcv == vExp { + has = true + } else { + continue + } + } + } + + if !has { + t.Errorf("recived %+v, expected %+v", rcv, tt.expected) + } + }) + } +} + +func TestMapRemove(t *testing.T) { + tests := []struct { + name string + arg []string + want error + }{ + { + name: "empty path", + arg: []string{}, + want: ErrWrongPath, + }, + { + name: "non existing path", + arg: []string{"abc"}, + want: nil, + }, + { + name: "one argument in path", + arg: []string{"Test"}, + want: nil, + }, + { + name: "case dataStorage", + arg: []string{"MS", "test"}, + want: nil, + }, + { + name: "case map[string]any", + arg: []string{"MP", "test2"}, + want: nil, + }, + { + name: "wrong path", + arg: []string{"Test1", "test3"}, + want: ErrWrongPath, + }, + } + + ms := MapStorage{ + "MS": MapStorage{"test": 1}, + "MP": map[string]any{"test2": 2}, + "Test": "test string", + "Test1": "test2 string", + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + + err := ms.Remove(tt.arg) + + if err != tt.want { + t.Errorf("expected %s, recived %s", tt.want, err) + } + }) + } +} + +func TestGetPathFromValue(t *testing.T) { + type args struct { + in reflect.Value + prefix string + } + tests := []struct { + name string + args args + exp []string + }{ + { + name: "ponter slice", + args: args{reflect.ValueOf(&[]string{"test"}), "test"}, + exp: []string{"test[0]"}, + }, + /*{ + name: "map", + args: args{reflect.ValueOf(map[string]string{"test": "test"}), "test"}, + exp: []string{"testtest"}, + },*/ + { + name: "struct", + args: args{reflect.ValueOf(struct{ test string }{"test"}), "test"}, + exp: []string{"testtest"}, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + rcv := getPathFromValue(tt.args.in, tt.args.prefix) + var has bool + + for _, vRcv := range rcv { + has = false + for _, vExp := range tt.exp { + if vRcv == vExp { + has = true + } else { + continue + } + } + } + + if !has { + t.Errorf("recived %+v, expected %+v", rcv, tt.exp) + } + }) + } +} + +func TestRemoteHost(t *testing.T) { + ms := MapStorage{ + "MS": MapStorage{"test": 1}, + "MP": map[string]any{"test2": 2}, + "Test": "test string", + "Test1": "test2 string", + } + rcv := ms.RemoteHost() + rcvStr := fmt.Sprintf("%T/", rcv) + + if rcvStr != "*utils.NetAddr/" { + t.Errorf("wrong return %s", rcvStr) + } +} + +func TestNavMapSet(t *testing.T) { + tests := []struct{ + name string + path []string + val any + err error + }{ + { + name: "empty path", + path: []string{}, + val: 1, + err: ErrWrongPath, + }, + { + name: "non supported data type", + path: []string{"Test", "test"}, + val: 1, + err: ErrWrongPath, + }, + { + name: "non supported data type", + path: []string{"MP", "test"}, + val: 1, + err: nil, + }, + } + + ms := MapStorage{ + "MS": MapStorage{"test": 1}, + "MP": map[string]any{"test2": 2}, + "Test": "test", + "Test1": "test2 string", + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + err := ms.Set(tt.path, tt.val) + + if err != tt.err { + t.Errorf("recived %s, expected %s", err, tt.err) + } + }) } }