From a72e68867232e17ab51451b7abffa49886f515aa Mon Sep 17 00:00:00 2001 From: adragusin Date: Fri, 6 Dec 2019 18:20:37 +0200 Subject: [PATCH] Updated tests in utils --- utils/dataconverter.go | 40 +++---- utils/dataconverter_test.go | 230 +++++++++++++++++++++++++++++++++--- utils/dateseries_test.go | 44 +++++++ 3 files changed, 275 insertions(+), 39 deletions(-) diff --git a/utils/dataconverter.go b/utils/dataconverter.go index 6e0f2cb77..5dcac41a3 100644 --- a/utils/dataconverter.go +++ b/utils/dataconverter.go @@ -89,8 +89,7 @@ func NewDataConverterMustCompile(params string) (conv DataConverter) { return } -func NewDurationSecondsConverter(params string) ( - hdlr DataConverter, err error) { +func NewDurationSecondsConverter(params string) (hdlr DataConverter, err error) { return new(DurationSecondsConverter), nil } @@ -128,21 +127,24 @@ func (mS *DurationNanosecondsConverter) Convert(in interface{}) ( func NewRoundConverter(params string) (hdlr DataConverter, err error) { rc := new(RoundConverter) var paramsSplt []string - if params != "" { + if params != EmptyString { paramsSplt = strings.Split(params, InInFieldSep) } switch len(paramsSplt) { - case 2: - rc.Method = paramsSplt[1] - fallthrough + case 0: + rc.Method = ROUNDING_MIDDLE case 1: if rc.Decimals, err = strconv.Atoi(paramsSplt[0]); err != nil { return nil, fmt.Errorf("%s converter needs integer as decimals, have: <%s>", MetaRound, paramsSplt[0]) } - fallthrough - case 0: rc.Method = ROUNDING_MIDDLE + case 2: + rc.Method = paramsSplt[1] + if rc.Decimals, err = strconv.Atoi(paramsSplt[0]); err != nil { + return nil, fmt.Errorf("%s converter needs integer as decimals, have: <%s>", + MetaRound, paramsSplt[0]) + } default: return nil, fmt.Errorf("unsupported %s converter parameters: <%s>", MetaRound, params) @@ -156,8 +158,7 @@ type RoundConverter struct { Method string } -func (rnd *RoundConverter) Convert(in interface{}) ( - out interface{}, err error) { +func (rnd *RoundConverter) Convert(in interface{}) (out interface{}, err error) { var inFloat float64 if inFloat, err = IfaceAsFloat64(in); err != nil { return @@ -167,7 +168,7 @@ func (rnd *RoundConverter) Convert(in interface{}) ( } func NewMultiplyConverter(constructParams string) (hdlr DataConverter, err error) { - if constructParams == "" { + if constructParams == EmptyString { return nil, ErrMandatoryIeMissingNoCaps } var val float64 @@ -183,8 +184,7 @@ type MultiplyConverter struct { Value float64 } -func (m *MultiplyConverter) Convert(in interface{}) ( - out interface{}, err error) { +func (m *MultiplyConverter) Convert(in interface{}) (out interface{}, err error) { var inFloat64 float64 if inFloat64, err = IfaceAsFloat64(in); err != nil { return nil, err @@ -193,8 +193,7 @@ func (m *MultiplyConverter) Convert(in interface{}) ( return } -func NewDivideConverter(constructParams string) ( - hdlr DataConverter, err error) { +func NewDivideConverter(constructParams string) (hdlr DataConverter, err error) { if constructParams == "" { return nil, ErrMandatoryIeMissingNoCaps } @@ -211,8 +210,7 @@ type DivideConverter struct { Value float64 } -func (m *DivideConverter) Convert(in interface{}) ( - out interface{}, err error) { +func (m *DivideConverter) Convert(in interface{}) (out interface{}, err error) { var inFloat64 float64 if inFloat64, err = IfaceAsFloat64(in); err != nil { return nil, err @@ -221,8 +219,7 @@ func (m *DivideConverter) Convert(in interface{}) ( return } -func NewDurationConverter(params string) ( - hdlr DataConverter, err error) { +func NewDurationConverter(params string) (hdlr DataConverter, err error) { return new(DurationConverter), nil } @@ -242,7 +239,7 @@ func NewPhoneNumberConverter(params string) ( pbDC DataConverter, err error) { lc := new(PhoneNumberConverter) var paramsSplt []string - if params != "" { + if params != EmptyString { paramsSplt = strings.Split(params, InInFieldSep) } switch len(paramsSplt) { @@ -269,8 +266,7 @@ type PhoneNumberConverter struct { Format phonenumbers.PhoneNumberFormat } -func (lc *PhoneNumberConverter) Convert(in interface{}) ( - out interface{}, err error) { +func (lc *PhoneNumberConverter) Convert(in interface{}) (out interface{}, err error) { num, err := phonenumbers.Parse(IfaceAsString(in), lc.CountryCode) if err != nil { return nil, err diff --git a/utils/dataconverter_test.go b/utils/dataconverter_test.go index 1e1a00108..7a47411c2 100644 --- a/utils/dataconverter_test.go +++ b/utils/dataconverter_test.go @@ -18,6 +18,7 @@ along with this program. If not, see package utils import ( + "math" "reflect" "testing" "time" @@ -42,11 +43,11 @@ func TestDataConvertersConvertString(t *testing.T) { func TestNewDataConverter(t *testing.T) { a, err := NewDataConverter(MetaDurationSeconds) if err != nil { - t.Error(err.Error()) + t.Error(err) } b, err := NewDurationSecondsConverter(EmptyString) if err != nil { - t.Error(err.Error()) + t.Error(err) } if !reflect.DeepEqual(a, b) { t.Error("Error reflect") @@ -149,6 +150,198 @@ func TestNewDataConverterMustCompile(t *testing.T) { } } +func TestNewDurationSecondsConverter(t *testing.T) { + eOut := DurationSecondsConverter{} + if rcv, err := NewDurationSecondsConverter("test"); err != nil { + t.Error(err) + } else if reflect.DeepEqual(rcv, eOut) { + t.Errorf("Expected %+v received: %+v", eOut, rcv) + } +} + +func TestDurationSecondsConverterConvert(t *testing.T) { + mS := &DurationSecondsConverter{} + if _, err := mS.Convert("string"); err.Error() != "time: invalid duration string" { + t.Error(err) + } +} + +func TestDurationNanosecondsConverterConvert(t *testing.T) { + nS := &DurationNanosecondsConverter{} + if _, err := nS.Convert("string"); err.Error() != "time: invalid duration string" { + t.Error(err) + } +} +func TestNewRoundConverter(t *testing.T) { + if _, err := NewRoundConverter("test"); err == nil || err.Error() != "*round converter needs integer as decimals, have: " { + t.Error(err) + } + if _, err := NewRoundConverter(":test"); err == nil || err.Error() != "*round converter needs integer as decimals, have: <>" { + t.Error(err) + } + if _, err := NewRoundConverter("test:"); err == nil || err.Error() != "*round converter needs integer as decimals, have: " { + t.Error(err) + } + eOut := &RoundConverter{ + Method: ROUNDING_MIDDLE, + } + if rcv, err := NewRoundConverter(EmptyString); err != nil { + t.Error(err) + } else if !reflect.DeepEqual(rcv, eOut) { + t.Errorf("Expected %+v received: %+v", eOut, rcv) + } + eOut = &RoundConverter{ + Decimals: 12, + Method: ROUNDING_UP, + } + if rcv, err := NewRoundConverter("12:*up"); err != nil { + t.Error(err) + } else if !reflect.DeepEqual(rcv, eOut) { + t.Errorf("Expected %+v received: %+v", eOut, rcv) + } + eOut = &RoundConverter{ + Decimals: 12, + Method: ROUNDING_DOWN, + } + if rcv, err := NewRoundConverter("12:*down"); err != nil { + t.Error(err) + } else if !reflect.DeepEqual(rcv, eOut) { + t.Errorf("Expected %+v received: %+v", eOut, rcv) + } + eOut = &RoundConverter{ + Decimals: 12, + Method: ROUNDING_MIDDLE, + } + if rcv, err := NewRoundConverter("12:*middle"); err != nil { + t.Error(err) + } else if !reflect.DeepEqual(rcv, eOut) { + t.Errorf("Expected %+v received: %+v", eOut, rcv) + } + eOut = &RoundConverter{} + if rcv, err := NewRoundConverter("12:*middle:wrong_length"); err == nil || err.Error() != "unsupported *round converter parameters: <12:*middle:wrong_length>" { + t.Error(err) + } else if !reflect.DeepEqual(rcv, nil) { + t.Errorf("Expected %+v received: %+v", nil, rcv) + } + +} + +func TestRoundConverterConvert(t *testing.T) { + rnd := &RoundConverter{} + if rcv, err := rnd.Convert("string_test"); err == nil || err.Error() != `strconv.ParseFloat: parsing "string_test": invalid syntax` { + t.Error(err) + } else if !reflect.DeepEqual(rcv, nil) { + t.Errorf("Expected %+v received: %+v", nil, rcv) + } + eOut := Round(18, rnd.Decimals, rnd.Method) + if rcv, err := rnd.Convert(18); err != nil { + t.Error(err) + } else if !reflect.DeepEqual(eOut, rcv) { + t.Errorf("Expected %+v received: %+v", eOut, rcv) + } +} + +func TestNewMultiplyConverter(t *testing.T) { + if rcv, err := NewMultiplyConverter(EmptyString); err == nil || err != ErrMandatoryIeMissingNoCaps { + t.Error(err) + } else if !reflect.DeepEqual(rcv, nil) { + t.Errorf("Expected %+v received: %+v", nil, rcv) + } + if rcv, err := NewMultiplyConverter("string_test"); err == nil || err.Error() != `strconv.ParseFloat: parsing "string_test": invalid syntax` { + t.Error(err) + } else if !reflect.DeepEqual(rcv, nil) { + t.Errorf("Expected %+v received: %+v", nil, rcv) + } + eOut := &MultiplyConverter{Value: 0.7} + if rcv, err := NewMultiplyConverter("0.7"); err != nil { + t.Error(err) + } else if !reflect.DeepEqual(rcv, eOut) { + t.Errorf("Expected %+v received: %+v", eOut, rcv) + } +} + +func TestMultiplyConverterConvert(t *testing.T) { + m := &MultiplyConverter{} + if rcv, err := m.Convert(EmptyString); err == nil || err.Error() != `strconv.ParseFloat: parsing "": invalid syntax` { + t.Error(err) + } else if !reflect.DeepEqual(rcv, nil) { + t.Errorf("Expected %+v received: %+v", nil, rcv) + } + if rcv, err := m.Convert("string_test"); err == nil || err.Error() != `strconv.ParseFloat: parsing "string_test": invalid syntax` { + t.Error(err) + } else if !reflect.DeepEqual(rcv, nil) { + t.Errorf("Expected %+v received: %+v", nil, rcv) + } + if rcv, err := m.Convert(3); err != nil { + t.Error(err) + } else if !reflect.DeepEqual(rcv, 0.0) { + t.Errorf("Expected %+v received: %+v", 0, rcv) + } +} + +func TestNewDivideConverter(t *testing.T) { + if rcv, err := NewDivideConverter(EmptyString); err == nil || err != ErrMandatoryIeMissingNoCaps { + t.Error(err) + } else if !reflect.DeepEqual(rcv, nil) { + t.Errorf("Expected %+v received: %+v", nil, rcv) + } + if rcv, err := NewDivideConverter("string_test"); err == nil || err.Error() != `strconv.ParseFloat: parsing "string_test": invalid syntax` { + t.Error(err) + } else if !reflect.DeepEqual(rcv, nil) { + t.Errorf("Expected %+v received: %+v", nil, rcv) + } + eOut := &DivideConverter{Value: 0.7} + if rcv, err := NewDivideConverter("0.7"); err != nil { + t.Error(err) + } else if !reflect.DeepEqual(eOut, rcv) { + t.Errorf("Expected %+v received: %+v", eOut, rcv) + } +} + +func TestDivideConverterConvert(t *testing.T) { + m := DivideConverter{} + if rcv, err := m.Convert("string_test"); err == nil || err.Error() != `strconv.ParseFloat: parsing "string_test": invalid syntax` { + t.Error(err) + } else if !reflect.DeepEqual(rcv, nil) { + t.Errorf("Expected %+v received: %+v", nil, rcv) + } + eOut := math.Inf(1) + if rcv, err := m.Convert("96"); err != nil { + t.Error(err) + } else if !reflect.DeepEqual(eOut, rcv) { + t.Errorf("Expected %+v received: %+v", eOut, rcv) + } + eOut = math.Inf(-1) + if rcv, err := m.Convert("-96"); err != nil { + t.Error(err) + } else if !reflect.DeepEqual(eOut, rcv) { + t.Errorf("Expected %+v received: %+v", eOut, rcv) + } + m = DivideConverter{Value: 0.7} + eOut = 137.14285714285714 + if rcv, err := m.Convert("96"); err != nil { + t.Error(err) + } else if !reflect.DeepEqual(eOut, rcv) { + t.Errorf("Expected %+v received: %+v", eOut, rcv) + } +} + +func TestNewDurationConverter(t *testing.T) { + nS := &DurationConverter{} + eOut := time.Duration(0 * time.Second) + if rcv, err := nS.Convert(EmptyString); err != nil { + t.Error(err) + } else if !reflect.DeepEqual(eOut, rcv) { + t.Errorf("Expected %+v received: %+v", eOut, rcv) + } + eOut = time.Duration(7 * time.Nanosecond) + if rcv, err := nS.Convert(7); err != nil { + t.Error(err) + } else if !reflect.DeepEqual(eOut, rcv) { + t.Errorf("Expected %+v received: %+v", eOut, rcv) + } +} + func TestConvertFloatToSeconds(t *testing.T) { b, err := NewDataConverter(MetaDurationSeconds) if err != nil { @@ -344,11 +537,18 @@ func TestDurationConverter(t *testing.T) { func TestPhoneNumberConverter(t *testing.T) { // test for error - if _, err := NewDataConverter("*libphonenumber:US:1:2:error"); err == nil || - err.Error() != "unsupported *libphonenumber converter parameters: " { + if rcv, err := NewDataConverter("*libphonenumber:US:1:2:error"); err == nil || err.Error() != "unsupported *libphonenumber converter parameters: " { t.Error(err) + } else if !reflect.DeepEqual(nil, rcv) { + t.Errorf("Expecting: %+v, received: %+v", nil, rcv) + } + if rcv, err := NewDataConverter("*libphonenumber:US:X"); err == nil || err.Error() != `strconv.Atoi: parsing "X": invalid syntax` { + t.Error(err) + } else if !reflect.DeepEqual(nil, rcv) { + t.Errorf("Expecting: %+v, received: %+v", nil, rcv) } + // US/National eLc := &PhoneNumberConverter{CountryCode: "US", Format: phonenumbers.NATIONAL} d, err := NewDataConverter("*libphonenumber:US") if err != nil { @@ -363,40 +563,36 @@ func TestPhoneNumberConverter(t *testing.T) { } else if !reflect.DeepEqual(phoneNumberConverted, "(443) 123-4567") { t.Errorf("expecting: %+v, received: %+v", "(443) 123-4567", phoneNumberConverted) } -} - -func TestPhoneNumberConverter2(t *testing.T) { - eLc := &PhoneNumberConverter{CountryCode: "US", Format: phonenumbers.INTERNATIONAL} - d, err := NewDataConverter("*libphonenumber:US:1") + //US/International + eLc = &PhoneNumberConverter{CountryCode: "US", Format: phonenumbers.INTERNATIONAL} + d, err = NewDataConverter("*libphonenumber:US:1") if err != nil { t.Error(err) } else if !reflect.DeepEqual(eLc, d) { t.Errorf("expecting: %+v, received: %+v", eLc, d) } // simulate an E164 number and Format it into a National number - phoneNumberConverted, err := d.Convert("+14431234567") + phoneNumberConverted, err = d.Convert("+14431234567") if err != nil { t.Error(err) } else if !reflect.DeepEqual(phoneNumberConverted, "+1 443-123-4567") { t.Errorf("expecting: %+v, received: %+v", "+1 443-123-4567", phoneNumberConverted) } -} - -func TestPhoneNumberConverter3(t *testing.T) { - eLc := &PhoneNumberConverter{CountryCode: "DE", Format: phonenumbers.INTERNATIONAL} - d, err := NewDataConverter("*libphonenumber:DE:1") + // DE/International + eLc = &PhoneNumberConverter{CountryCode: "DE", Format: phonenumbers.INTERNATIONAL} + d, err = NewDataConverter("*libphonenumber:DE:1") if err != nil { t.Error(err) } else if !reflect.DeepEqual(eLc, d) { t.Errorf("expecting: %+v, received: %+v", eLc, d) } - phoneNumberConverted, err := d.Convert("6502530000") + phoneNumberConverted, err = d.Convert("6502530000") if err != nil { t.Error(err) } else if !reflect.DeepEqual(phoneNumberConverted, "+49 6502 530000") { t.Errorf("expecting: %+v, received: %+v", "+49 6502 530000", phoneNumberConverted) } - + // DE/E164 eLc = &PhoneNumberConverter{CountryCode: "DE", Format: phonenumbers.E164} d, err = NewDataConverter("*libphonenumber:DE:0") if err != nil { diff --git a/utils/dateseries_test.go b/utils/dateseries_test.go index 6cfe92331..54d12ef03 100644 --- a/utils/dateseries_test.go +++ b/utils/dateseries_test.go @@ -24,6 +24,50 @@ import ( "time" ) +func TestYearsSort(t *testing.T) { + ys := &Years{} + ys.Sort() + if !reflect.DeepEqual(ys, &Years{}) { + t.Errorf("Expecting %+v received: %+v", &Years{}, ys) + } + ys = &Years{2019, 2010, 2020, 2005, 2018, 2007} + ysSorted := &Years{2005, 2007, 2010, 2018, 2019, 2020} + ys.Sort() + if !reflect.DeepEqual(ys, ysSorted) { + t.Errorf("Expecting %+v received: %+v", ysSorted, ys) + } +} + +func TestYearsLen(t *testing.T) { + ys := &Years{} + if rcv := ys.Len(); rcv != 0 { + t.Errorf("Expecting %+v received: %+v", 0, rcv) + } + ys = &Years{2019, 2010, 2020, 2005, 2018, 2007} + if rcv := ys.Len(); rcv != 6 { + t.Errorf("Expecting %+v received: %+v", 6, rcv) + } +} + +func TestYearsSwap(t *testing.T) { + ys := &Years{2019, 2010, 2020, 2005, 2018, 2007} + ys.Swap(0, 1) + ysSwapped := &Years{2010, 2019, 2020, 2005, 2018, 2007} + if !reflect.DeepEqual(ys, ysSwapped) { + t.Errorf("Expecting %+v received: %+v", ysSwapped, ys) + } +} + +func TestYearsLess(t *testing.T) { + ys := &Years{2019, 2010, 2020, 2005, 2018, 2007} + if rcv := ys.Less(0, 1); rcv { + t.Errorf("Expecting false received: %+v", rcv) + } + if rcv := ys.Less(1, 2); !rcv { + t.Errorf("Expecting true received: %+v", rcv) + } +} + func TestDateseriesMonthStoreRestoreJson(t *testing.T) { m := Months{5, 6, 7, 8} r, _ := json.Marshal(m)