From 2aad952489a958edf41efd6368b3a12364cbfd43 Mon Sep 17 00:00:00 2001 From: nickolasdaniel Date: Mon, 11 Oct 2021 15:50:52 +0300 Subject: [PATCH] Unit tests for uttils --- utils/reflect_test.go | 242 +++++++++++++++++++++++++++++++++++ utils/safemapstorage_test.go | 16 +++ utils/stringset_test.go | 44 +++++++ 3 files changed, 302 insertions(+) diff --git a/utils/reflect_test.go b/utils/reflect_test.go index 1cf73c273..bda45a3fc 100644 --- a/utils/reflect_test.go +++ b/utils/reflect_test.go @@ -360,12 +360,30 @@ func TestIfaceAsBool(t *testing.T) { } else if itmConvert != false { t.Errorf("received: %+v", itmConvert) } + val = interface{}(int32(2)) + if itmConvert, err := IfaceAsBool(val); err != nil { + t.Error(err) + } else if itmConvert != true { + t.Errorf("received: %+v", itmConvert) + } val = interface{}(1) if itmConvert, err := IfaceAsBool(val); err != nil { t.Error(err) } else if itmConvert != true { t.Errorf("received: %+v", itmConvert) } + val = interface{}(uint32(2)) + if itmConvert, err := IfaceAsBool(val); err != nil { + t.Error(err) + } else if itmConvert != true { + t.Errorf("received: %+v", itmConvert) + } + val = interface{}(uint64(2)) + if itmConvert, err := IfaceAsBool(val); err != nil { + t.Error(err) + } else if itmConvert != true { + t.Errorf("received: %+v", itmConvert) + } val = interface{}(0.0) if itmConvert, err := IfaceAsBool(val); err != nil { t.Error(err) @@ -1316,6 +1334,13 @@ func TestIfaceAsBig(t *testing.T) { if !reflect.DeepEqual(rcv, new(decimal.Big).SetUint64(10)) { t.Errorf("Expected %v but received %v", new(decimal.Big).SetUint64(10), rcv) } + + def := []string{"test"} + _, err = IfaceAsBig(def) + if err == nil || err.Error() != "cannot convert field: []string to decimal.Big" { + t.Error(err) + } + } func TestReflectFieldMethodInterfaceStruct(t *testing.T) { @@ -1479,3 +1504,220 @@ func TestReflectFieldMethodInterfaceInvalidFieldMethod6(t *testing.T) { t.Errorf("Expected %v but received %v", exp, err) } } + +func TestIfaceAsStringSliceString(t *testing.T) { + //case of []string + fld := []string{"string_ex"} + rcv, err := IfaceAsStringSlice(fld) + if err != nil { + t.Error(err) + } + exp := []string{"string_ex"} + if !reflect.DeepEqual(rcv, exp) { + t.Errorf("Expected %v \n but received \n %v", exp, rcv) + } +} + +func TestIfaceAsStringSliceInt(t *testing.T) { + //case of []int + fld := []int{1, 2, 3} + rcv, err := IfaceAsStringSlice(fld) + if err != nil { + t.Error(err) + } + exp := []string{"1", "2", "3"} + if !reflect.DeepEqual(rcv, exp) { + t.Errorf("Expected %v \n but received \n %v", exp, rcv) + } +} + +func TestIfaceAsStringSliceInt32(t *testing.T) { + //case of []int32 + fld := []int32{1, 2, 3} + rcv, err := IfaceAsStringSlice(fld) + if err != nil { + t.Error(err) + } + exp := []string{"1", "2", "3"} + if !reflect.DeepEqual(rcv, exp) { + t.Errorf("Expected %v \n but received \n %v", exp, rcv) + } +} + +func TestIfaceAsStringSliceInt64(t *testing.T) { + //case of []int64 + fld := []int64{1, 2, 3} + rcv, err := IfaceAsStringSlice(fld) + if err != nil { + t.Error(err) + } + exp := []string{"1", "2", "3"} + if !reflect.DeepEqual(rcv, exp) { + t.Errorf("Expected %v \n but received \n %v", exp, rcv) + } +} + +func TestIfaceAsStringSliceUInt32(t *testing.T) { + //case of []uint32 + fld := []uint32{1, 2, 3} + rcv, err := IfaceAsStringSlice(fld) + if err != nil { + t.Error(err) + } + exp := []string{"1", "2", "3"} + if !reflect.DeepEqual(rcv, exp) { + t.Errorf("Expected %v \n but received \n %v", exp, rcv) + } +} + +func TestIfaceAsStringSliceUInt64(t *testing.T) { + //case of []uint64 + fld := []uint64{1, 2, 3} + rcv, err := IfaceAsStringSlice(fld) + if err != nil { + t.Error(err) + } + exp := []string{"1", "2", "3"} + if !reflect.DeepEqual(rcv, exp) { + t.Errorf("Expected %v \n but received \n %v", exp, rcv) + } +} + +func TestIfaceAsStringSliceBool(t *testing.T) { + //case of []bool + fld := []bool{true, false, false} + rcv, err := IfaceAsStringSlice(fld) + if err != nil { + t.Error(err) + } + exp := []string{"true", "false", "false"} + if !reflect.DeepEqual(rcv, exp) { + t.Errorf("Expected %v \n but received \n %v", exp, rcv) + } +} + +func TestIfaceAsStringSliceFloat32(t *testing.T) { + //case of []float32 + fld := []float32{1.2, 2.8, 3.1} + rcv, err := IfaceAsStringSlice(fld) + if err != nil { + t.Error(err) + } + exp := []string{"1.2000000476837158", "2.799999952316284", "3.0999999046325684"} + if !reflect.DeepEqual(rcv, exp) { + t.Errorf("Expected %v \n but received \n %v", exp, rcv) + } +} + +func TestIfaceAsStringSliceFloat64(t *testing.T) { + //case of []float64 + fld := []float64{1.2, 2.8, 3.1} + rcv, err := IfaceAsStringSlice(fld) + if err != nil { + t.Error(err) + } + exp := []string{"1.2", "2.8", "3.1"} + if !reflect.DeepEqual(rcv, exp) { + t.Errorf("Expected %v \n but received \n %v", exp, rcv) + } +} + +func TestIfaceAsStringSliceInterface(t *testing.T) { + //case of []interface + fld := []interface{}{1.2, "string", false} + rcv, err := IfaceAsStringSlice(fld) + if err != nil { + t.Error(err) + } + exp := []string{"1.2", "string", "false"} + if !reflect.DeepEqual(rcv, exp) { + t.Errorf("Expected %v \n but received \n %v", exp, rcv) + } +} + +func TestIfaceAsStringSliceStringNonSlice(t *testing.T) { + //case of string + fld := "very;long;string" + rcv, err := IfaceAsStringSlice(fld) + if err != nil { + t.Error(err) + } + exp := []string{"very", "long", "string"} + if !reflect.DeepEqual(rcv, exp) { + t.Errorf("Expected %v \n but received \n %v", exp, rcv) + } +} + +func TestIfaceAsStringSliceDefault(t *testing.T) { + //case of default + fld := time.Second * 2 + exp := "cannot convert field: 2s to []string" + _, err := IfaceAsStringSlice(fld) + if err.Error() != exp { + t.Errorf("Expected error") + } +} + +func TestOptAsBool(t *testing.T) { + opts := map[string]interface{}{ + "field1": 2, + } + rcv := OptAsBool(opts, "field1") + if !rcv { + t.Error("Output should've been true") + } + + rcv = OptAsBool(opts, "field2") + if rcv { + t.Error("Output should've been false") + } +} + +func TestOptAsBoolOrDef(t *testing.T) { + opts := map[string]interface{}{ + "field1": 2, + } + rcv := OptAsBoolOrDef(opts, "field1", false) + if !rcv { + t.Error("Output should've been true") + } + + rcv = OptAsBoolOrDef(opts, "field2", false) + if rcv { + t.Error("Output should've been false") + } +} + +func TestOptAsStringSlice(t *testing.T) { + opts := map[string]interface{}{ + "field1": []string{"val1", "val2"}, + } + rcv, err := OptAsStringSlice(opts, "field1") + if err != nil { + t.Error(err) + } + exp := []string{"val1", "val2"} + if !reflect.DeepEqual(rcv, exp) { + t.Errorf("Expected %v \n but received \n %v", exp, rcv) + } + + _, err = OptAsStringSlice(opts, "field2") + if err != nil { + t.Error(err) + } + + opts["field1"] = time.Second * 2 + _, err = OptAsStringSlice(opts, "field1") + errExp := "error for option : cannot convert field: 2s to []string" + if err == nil || err.Error() != errExp { + t.Errorf("Expected %v \n but received \n %v", errExp, err) + } +} + +func TestStringAsBig(t *testing.T) { + itm := "2ns" + _, err := StringAsBig(itm) + if err != nil { + t.Error(err) + } +} diff --git a/utils/safemapstorage_test.go b/utils/safemapstorage_test.go index 49eef307f..be42b6310 100644 --- a/utils/safemapstorage_test.go +++ b/utils/safemapstorage_test.go @@ -145,3 +145,19 @@ func TestSafeMapStorageClone(t *testing.T) { t.Errorf("Expected %v \n but received \n %v", expected, reply) } } + +func TestClonedMapStorage(t *testing.T) { + ms := &SafeMapStorage{ + MapStorage: MapStorage{ + "field1": []string{"v1", "v2"}, + }, + } + exp := MapStorage{ + "field1": []string{"v1", "v2"}, + } + msC := ms.ClonedMapStorage() + // fmt.Println(msC) + if !reflect.DeepEqual(exp, msC) { + t.Errorf("Expected %v \n but received \n %v", exp, msC) + } +} diff --git a/utils/stringset_test.go b/utils/stringset_test.go index 433f49d5a..97a949b15 100644 --- a/utils/stringset_test.go +++ b/utils/stringset_test.go @@ -290,3 +290,47 @@ func TestStringSetEquals(t *testing.T) { t.Error("The sets should match") } } + +func TestStringSetFieldAsInterface(t *testing.T) { + s := StringSet{ + "field1": struct{}{}, + } + _, err := s.FieldAsInterface([]string{"field1"}) + if err != nil { + t.Error(err) + } + // fmt.Println(rcv) + _, err = s.FieldAsInterface([]string{"field2"}) + if err != ErrNotFound { + t.Errorf("Expected %v", ErrNotFound) + } + + _, err = s.FieldAsInterface([]string{"field2", "field3"}) + if err != ErrNotFound { + t.Errorf("Expected %v", ErrNotFound) + } +} + +func TestString(t *testing.T) { + s := StringSet{ + "field1": struct{}{}, + } + rcv := s.String() + if rcv != "[\"field1\"]" { + t.Errorf("Expected %v \n but received \n %v", "[\"field1\"]", rcv) + } +} + +func TestFieldAsString(t *testing.T) { + s := StringSet{ + "field1": struct{}{}, + } + _, err := s.FieldAsString([]string{"field1"}) + if err != nil { + t.Error(err) + } + _, err = s.FieldAsString([]string{"field2"}) + if err == nil { + t.Error("Expected error") + } +}