From 45105cfbacb9a6418ba91cc302920148c811557e Mon Sep 17 00:00:00 2001 From: NikolasPetriti Date: Tue, 13 Jun 2023 14:04:31 +0200 Subject: [PATCH] Covered tests for pathitem.go and dataconverter.go --- utils/dataconverter_test.go | 72 +++++++++++++++++++++++++++++++++-- utils/pathitem_test.go | 76 +++++++++++++++++++++++++++++++++++++ 2 files changed, 145 insertions(+), 3 deletions(-) diff --git a/utils/dataconverter_test.go b/utils/dataconverter_test.go index d399d0d6f..7a192b8de 100644 --- a/utils/dataconverter_test.go +++ b/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: " { + 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) + } + }) + } +} diff --git a/utils/pathitem_test.go b/utils/pathitem_test.go index b9bffe300..22f3a7c9f 100644 --- a/utils/pathitem_test.go +++ b/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) + } + }) + } +}