Covered tests for pathitem.go and dataconverter.go

utils/dataconverter_test.go

@@ -97,7 +97,7 @@ func TestNewDataConverter(t *testing.T) {
 	if !reflect.DeepEqual(a, b) {
 		t.Error("Error reflect")
 	}
-	if a, err = NewDataConverter(MetaMultiply); err == nil || err != ErrMandatoryIeMissingNoCaps {
+	if _, err = NewDataConverter(MetaMultiply); err == nil || err != ErrMandatoryIeMissingNoCaps {
 		t.Error(err)
 	}
 	a, err = NewDataConverter("*multiply:3.3")
@@ -111,7 +111,7 @@ func TestNewDataConverter(t *testing.T) {
 	if !reflect.DeepEqual(a, b) {
 		t.Error("Error reflect")
 	}
-	if a, err = NewDataConverter(MetaDivide); err == nil || err != ErrMandatoryIeMissingNoCaps {
+	if _, err = NewDataConverter(MetaDivide); err == nil || err != ErrMandatoryIeMissingNoCaps {
 		t.Error(err)
 	}
 	a, err = NewDataConverter("*divide:3.3")
@@ -125,7 +125,7 @@ func TestNewDataConverter(t *testing.T) {
 	if !reflect.DeepEqual(a, b) {
 		t.Error("Error reflect")
 	}
-	if a, err = NewDataConverter(MetaLibPhoneNumber); err == nil || err.Error() != "unsupported *libphonenumber converter parameters: <>" {
+	if _, err = NewDataConverter(MetaLibPhoneNumber); err == nil || err.Error() != "unsupported *libphonenumber converter parameters: <>" {
 		t.Error(err)
 	}
 	a, err = NewDataConverter("*libphonenumber:US")
@@ -140,6 +140,7 @@ func TestNewDataConverter(t *testing.T) {
 		t.Error("Error reflect")
 	}
 	if _, err := NewDataConverter("unsupported"); err == nil || err.Error() != "unsupported converter definition: <unsupported>" {
+		t.Error(err)
 	}
 
 	hex, err := NewDataConverter(MetaString2Hex)
@@ -150,6 +151,14 @@ func TestNewDataConverter(t *testing.T) {
 	if !reflect.DeepEqual(hex, exp) {
 		t.Errorf("Expected %+v received: %+v", exp, hex)
 	}
+	a, err = NewDataConverter(MetaIP2Hex)
+	if err != nil {
+		t.Fatal(err)
+	}
+	b = new(IP2HexConverter)
+	if !reflect.DeepEqual(a, b) {
+		t.Errorf("got %v, want %v", a, b)
+	}
 }
 
 func TestNewDataConverterMustCompile(t *testing.T) {
@@ -157,6 +166,20 @@ func TestNewDataConverterMustCompile(t *testing.T) {
 	if rcv := NewDataConverterMustCompile(MetaDurationSeconds); rcv != eOut {
 		t.Errorf("Expecting:  received: %+q", rcv)
 	}
+
+	t.Run("check panic", func(t *testing.T) {
+		shouldPanic(t, NewDataConverterMustCompile)
+	})
+}
+
+func shouldPanic(t *testing.T, f func(string) DataConverter) {
+	t.Helper()
+	defer func() {
+		_ = recover()
+	}()
+
+	NewDataConverterMustCompile("!£$%&/()=?123")
+	t.Error("should have panicked")
 }
 
 func TestNewDurationSecondsConverter(t *testing.T) {
@@ -709,3 +732,46 @@ func TestStringHexConvertor(t *testing.T) {
 		t.Errorf("expecting: %+v, received: %+v", expected, rpl)
 	}
 }
+
+func TestConvertString(t *testing.T) {
+	tests := []struct{
+		name string
+		arg string
+		want string
+		err bool
+	}{
+		{
+			name: "check error",
+			arg: "!£$%&/()=?^",
+			want: "",
+			err: true,
+		},
+		{
+			name: "check error",
+			arg: "1.5",
+			want: "1.5",
+			err: false,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			dc := DataConverters{&RoundConverter{}}
+			rcv, err := dc.ConvertString(tt.arg)
+
+			if tt.err {
+				if err == nil {
+					t.Error("was expecting an error but didnt get one")
+				}
+			} else {
+				if err != nil {
+					t.Errorf("was not expecting an error %s", err)
+				}
+			} 
+
+
+			if tt.want != rcv {
+				t.Errorf("recived %v, expected %v", rcv, tt.want)
+			}
+		})
+	}
+}

utils/pathitem_test.go

@@ -145,3 +145,79 @@ func TestPathItemsClone(t *testing.T) {
 		t.Errorf("Expected: %s, received: %s", ToJSON(expected), ToJSON(rply))
 	}
 }
+
+func TestGetIndexPath(t *testing.T) {
+	type want struct {
+		opath string
+		idx   int
+	}
+	tests := []struct {
+		name string
+		arg string
+		want want
+		returnNil bool
+	}{
+		{
+			name: "argument does not have square brackets",
+			arg: "1",
+			want: want{opath: "1"},
+			returnNil: true, 
+		},
+		{
+			name: "check error from strings.Atoi",
+			arg: "[a, b, c]",
+			want: want{opath: "[a, b, c]"},
+			returnNil: true,
+		},
+		{
+			name: "testing GetPathIndex",
+			arg: "test[1]",
+			want: want{opath: "test", idx: 1},
+			returnNil: false, 
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			opath, idx := GetPathIndex(tt.arg)
+
+			if tt.returnNil {
+				if opath != tt.want.opath || idx != nil {
+					t.Errorf("recived '%s' and %v, expexted '%s' and %v", opath, idx, tt.want.opath, tt.want.idx)
+				}
+			} else {
+				expInx := *idx
+				if opath != tt.want.opath || expInx != tt.want.idx {
+					t.Errorf("recived '%s' and %v, expexted '%s' and %v", opath, expInx, tt.want.opath, tt.want.idx)
+				}
+			}
+		})
+	}
+}
+
+func TestGetPathWithoutIndex(t *testing.T) {
+	tests := []struct {
+		name string
+		arg string
+		want string
+	}{
+		{
+			name: "argument does not have square brackets",
+			arg: "test",
+			want: "test",
+		},
+		{
+			name: "testing GetPathIndex",
+			arg: "test[1]",
+			want: "test",
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			opath := GetPathWithoutIndex(tt.arg)
+
+				if opath != tt.want {
+					t.Errorf("recived '%s', expexted '%s'", opath, tt.want)
+				}
+		})
+	}
+}