From b0937e13ebf103b6e19cf7c567e7ff2619f90fc7 Mon Sep 17 00:00:00 2001 From: porosnicuadrian Date: Tue, 16 Feb 2021 16:49:59 +0200 Subject: [PATCH] Tests for utils package --- utils/accountprofile_test.go | 25 ++++++++++++ utils/decimal_test.go | 79 ++++++++++++++++++++++++++++++++++-- utils/dynamicweight_test.go | 42 +++++++++++++++++++ utils/errors_test.go | 8 ++++ utils/stringset_test.go | 6 +++ 5 files changed, 157 insertions(+), 3 deletions(-) diff --git a/utils/accountprofile_test.go b/utils/accountprofile_test.go index fb700ceb5..e467e1667 100644 --- a/utils/accountprofile_test.go +++ b/utils/accountprofile_test.go @@ -191,6 +191,31 @@ func TestAccountProfileAsAccountProfile(t *testing.T) { } } +func TestAsAccountProfileError(t *testing.T) { + apiAccPrf := &APIAccountProfile{ + Tenant: "cgrates.org", + ID: "test_ID1", + Opts: map[string]interface{}{}, + Balances: map[string]*APIBalance{ + "MonetaryBalance": { + Weights: ";10", + }, + }, + Weights: "10", + } + expectedErr := "invalid DynamicWeight format for string <10>" + if _, err := apiAccPrf.AsAccountProfile(); err == nil || err.Error() != expectedErr { + t.Errorf("Expected %+v, received %+v", expectedErr, err) + } + + apiAccPrf.Weights = ";10" + apiAccPrf.Balances["MonetaryBalance"].Weights = "10" + expectedErr = "invalid DynamicWeight format for string <10>" + if _, err := apiAccPrf.AsAccountProfile(); err == nil || err.Error() != expectedErr { + t.Errorf("Expected %+v, received %+v", expectedErr, err) + } +} + func TestAPIBalanceAsBalance(t *testing.T) { blc := &APIBalance{ ID: "VoiceBalance", diff --git a/utils/decimal_test.go b/utils/decimal_test.go index b9222a484..53514bcea 100644 --- a/utils/decimal_test.go +++ b/utils/decimal_test.go @@ -72,10 +72,83 @@ func TestUnmarshalMarshalBinary(t *testing.T) { t.Errorf("Expected %T, received %T", expected, dec.Big) } - expected2 := []byte(`10`) - if rcv, err := dec.MarshalBinary(); err != nil { + dec = nil + expected = NewDecimal(10, 0) + if err := dec.UnmarshalBinary([]byte(`10`)); err != nil { + t.Error(err) + } + + dec1 := new(Decimal) + expected2 := []byte(`0`) + if rcv, err := dec1.MarshalBinary(); err != nil { t.Error(err) } else if !reflect.DeepEqual(expected2, rcv) { - t.Errorf("Expected %+v, received %+v", expected2, rcv) + t.Errorf("Expected %+v, received %+v", string(expected2), string(rcv)) + } +} + +func TestUnmarshalJSON(t *testing.T) { + dec1 := new(Decimal) + expected := NewDecimal(0, 0) + if err := dec1.UnmarshalJSON([]byte(`0`)); err != nil { + t.Error(err) + } else if !reflect.DeepEqual(expected, dec1) { + t.Errorf("Expected %+v, received %+v", expected, dec1) + } + + dec1 = nil + if err := dec1.UnmarshalJSON([]byte(`0`)); err != nil { + t.Error(err) + } +} + +func TestDecimalCalculus(t *testing.T) { + d1 := NewDecimal(10, 0) + d2 := NewDecimal(20, 0) + if d1.Compare(d2) != -1 { + t.Errorf("%+v should be lower that %+v", d1, d2) + } + + if rcv := SubstractBig(d2.Big, d1.Big); !reflect.DeepEqual(rcv, d1.Big) { + t.Errorf("Expected %+v, received %+v", ToJSON(d1.Big), ToJSON(rcv)) + } + + if rcv := MultiplyDecimal(d1, d2); !reflect.DeepEqual(NewDecimal(200, 0), rcv) { + t.Errorf("Expected %+v, received %+v", ToJSON(NewDecimal(200, 0)), ToJSON(rcv)) + } + + if rcv := SubstractDecimal(d2, d1); !reflect.DeepEqual(d1, rcv) { + t.Errorf("Expected %+v, received %+v", ToJSON(d1), ToJSON(rcv)) + } +} + +func TestMarshalJSON(t *testing.T) { + dec := new(Decimal) + if rcv, err := dec.MarshalJSON(); err != nil { + t.Error(err) + } else if len(rcv) != 5 { + t.Error("Expected empty slice", len(rcv)) + } +} + +func TestNewDecimalFromUsage(t *testing.T) { + dec := "12tts" + expectedErr := "time: unknown unit \"tts\" in duration \"12tts\"" + if _, err := NewDecimalFromUsage(dec); err == nil || err.Error() != expectedErr { + t.Errorf("Expected %+v, received %+v", expectedErr, err) + } + + dec = "2" + expected := NewDecimal(2, 0) + if rcv, err := NewDecimalFromUsage(dec); err != nil { + t.Error(err) + } else if !reflect.DeepEqual(expected, rcv) { + t.Errorf("Expected %+v, received %+v", expected, rcv) + } + + dec = "invalid_decimal_format" + expectedErr = "strconv.ParseInt: parsing \"invalid_decimal_format\": invalid syntax" + if _, err := NewDecimalFromUsage(dec); err == nil || err.Error() != expectedErr { + t.Errorf("Expected %+v, received %+v", expectedErr, err) } } diff --git a/utils/dynamicweight_test.go b/utils/dynamicweight_test.go index f0986706a..e54f01e26 100644 --- a/utils/dynamicweight_test.go +++ b/utils/dynamicweight_test.go @@ -84,4 +84,46 @@ func TestNewDynamicWeightsFromString(t *testing.T) { } else if !reflect.DeepEqual(eDws, dws) { t.Errorf("expecting: %+v, received: %+v", eDws, dws) } + + dwsStr = "fltr1&fltr2;not_a_float64" + expected := "invalid Weight in string: " + if _, err := NewDynamicWeightsFromString(dwsStr, ";", "&"); err == nil || err.Error() != expected { + t.Errorf("expecting: %+v, received: %+v", expected, err) + } +} + +func TestDynamicWeightString(t *testing.T) { + dynWeigh := DynamicWeights{} + if rcv := dynWeigh.String(";", "&"); len(rcv) != 0 { + t.Errorf("Expected empty slice") + } + + expected := "fltr1&fltr2;10" + dynWeigh = DynamicWeights{ + { + FilterIDs: []string{"fltr1", "fltr2"}, + Weight: 10, + }, + } + if rcv := dynWeigh.String(";", "&"); !reflect.DeepEqual(expected, rcv) { + t.Errorf("Expected %+v, received %+v", expected, rcv) + } +} + +func TestCloneDynamicWeights(t *testing.T) { + dynWeigh := DynamicWeights{} + dynWeigh = nil + if rcv := dynWeigh.Clone(); len(rcv) != 0 { + t.Errorf("Expected empty slice") + } + + dynWeigh = DynamicWeights{ + { + FilterIDs: []string{"fltr1", "fltr2"}, + Weight: 10, + }, + } + if rcv := dynWeigh.Clone(); !reflect.DeepEqual(dynWeigh, rcv) { + t.Errorf("Expected %+v, received %+v", dynWeigh, rcv) + } } diff --git a/utils/errors_test.go b/utils/errors_test.go index c9542fc0a..5a62d1977 100644 --- a/utils/errors_test.go +++ b/utils/errors_test.go @@ -18,6 +18,7 @@ along with this program. If not, see package utils import ( + "errors" "reflect" "testing" ) @@ -91,6 +92,13 @@ func TestNewErrServiceNotOperational(t *testing.T) { } } +func TestNewErrRates(t *testing.T) { + err := errors.New("ErrorRates") + if rcv := NewErrRateS(err); rcv.Error() != "RATES_ERROR:ErrorRates" { + t.Errorf("Expecting: RATES_ERROR:ErrorRates, received: %+v", rcv) + } +} + func TestNewErrNotConnected(t *testing.T) { if rcv := NewErrNotConnected("Error"); rcv.Error() != "NOT_CONNECTED: Error" { t.Errorf("Expecting: NOT_CONNECTED: Error, received: %+v", rcv) diff --git a/utils/stringset_test.go b/utils/stringset_test.go index 2185df9cf..301af8248 100644 --- a/utils/stringset_test.go +++ b/utils/stringset_test.go @@ -103,6 +103,12 @@ func TestAsSlice(t *testing.T) { if rcv := s.AsSlice(); !reflect.DeepEqual(eOut, rcv) { t.Errorf("Expecting: %+v, received: %+v", eOut, rcv) } + + s = nil + if rcv := s.AsSlice(); len(rcv) != 0 { + t.Errorf("Expecting empty slice") + } + s = StringSet{ "test": struct{}{}, "test1": struct{}{},