Tests for utils package

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",

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)
 	}
 }

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 <not_a_float64> in string: <fltr1&fltr2;not_a_float64>"
+	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)
+	}
 }

utils/errors_test.go

@@ -18,6 +18,7 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>
 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)

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{}{},