Added coverage tests for mapstorage.go, errors.go and dataprovider.go

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

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)
+	}
+}

utils/mapstorage_test.go

@@ -18,8 +18,8 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>
 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)
+			}
+		})
 	}
 }