Improving coverage at utils

utils/coreutils_test.go

@@ -542,8 +542,9 @@ func TestParseTimeDetectLayout(t *testing.T) {
 	if err != nil || !date.UTC().Equal(expected.UTC()) {
 		t.Errorf("Expecting: %v, received: %v", expected.UTC(), date.UTC())
 	}
-	if date, err := ParseTimeDetectLayout("2014-11-25T00:00:00+01:00", "65"); err == nil {
-		t.Errorf("Expecting error 'timezone: invalid timezone', received: %v", err)
+	expErr := "unknown time zone 65"
+	if date, err := ParseTimeDetectLayout("2014-11-25T00:00:00+01:00", "65"); err == nil || err.Error() != expErr {
+		t.Errorf("Expecting error %v, received: %v", expErr, err)
 	} else if date != nilTime {
 		t.Errorf("Expecting %+v, received: %+v", nilTime, date)
 	}

utils/decimal.go

@@ -200,7 +200,7 @@ func (d *Decimal) MarshalBinary() ([]byte, error) {
 // UnmarshalJSON implements the method for jsonUnmarshal for JSON encoding
 func (d *Decimal) UnmarshalJSON(data []byte) (err error) {
 	if d == nil {
-		*d = Decimal{decimal.WithContext(DecimalContext)}
+		d = &Decimal{decimal.WithContext(DecimalContext)}
 	}
 	if d.Big == nil {
 		d.Big = decimal.WithContext(DecimalContext)

utils/decimal_test.go

@@ -264,6 +264,11 @@ func TestUnmarshalJSON(t *testing.T) {
 	if err := dec2.UnmarshalJSON([]byte(`0`)); err != nil {
 		t.Error(err)
 	}
+
+	var decnil *Decimal
+	if err := decnil.UnmarshalJSON([]byte(`0`)); err != nil {
+		t.Error(err)
+	}
 }
 
 func TestDecimalCalculus(t *testing.T) {

utils/eventcharges_test.go

@@ -1661,13 +1661,8 @@ func TestECEventChargesClone(t *testing.T) {
 }
 
 func TestEqualsAccountCharges(t *testing.T) {
-	ac := &AccountCharge{}
-	nAc := &AccountCharge{}
-	if rcv := ac.equals(nAc); rcv != true {
-		t.Errorf("Expected <true>, Recevied <%v>", rcv)
-	}
-	ac = nil
-	nAc = nil
+	var ac *AccountCharge
+	var nAc *AccountCharge
 	if rcv := ac.equals(nAc); rcv != true {
 		t.Errorf("Expected <true>, Recevied <%v>", rcv)
 	}

utils/librates_test.go

@@ -2249,19 +2249,17 @@ func TestLibratesRateSIncrementClone(t *testing.T) {
 	}
 }
 
-// unfinished
-// func TestAsRateAPIConvert(t *testing.T) {
-// 	ext := APIRate{
+func TestAsRateAPIConvert(t *testing.T) {
+	ext := APIRate{
 
-// 		Weights: "notEmpty",
-// 	}
-// 	expErr := "invalid DynamicWeight format for string <notEmpty>"
-// 	exp := APIRate{}
+		Weights: "notEmpty",
+	}
+	expErr := "invalid DynamicWeight format for string <notEmpty>"
+	var exp *Rate
 
-// 	if rcv, err := ext.AsRate(); err == nil || err.Error() != expErr {
-// 		t.Errorf("%+v", err)
-// 	} else if !reflect.DeepEqual(exp, rcv) {
-// 		t.Errorf("Expected <%+v>, Recevied <%+v>", ToJSON(exp), ToJSON(rcv))
-// 	}
-
-// }
+	if rcv, err := ext.AsRate(); err == nil || err.Error() != expErr {
+		t.Errorf("%+v", err)
+	} else if !reflect.DeepEqual(exp, rcv) {
+		t.Errorf("Expected <%+v %T>, Recevied <%+v %T>", ToJSON(exp), exp, ToJSON(rcv), rcv)
+	}
+}

utils/logger_test.go

@@ -21,6 +21,7 @@ package utils
 import (
 	"bytes"
 	"fmt"
+	"io"
 	"log"
 	"os"
 	"reflect"
@@ -228,3 +229,166 @@ func TestLoggerStdLoggerDebug(t *testing.T) {
 		t.Errorf("expected: <%s>, \nreceived: <%s>", expMsg, buf.String())
 	}
 }
+
+func TestCloseSysLogger(t *testing.T) {
+	sl, _ := NewSysLogger("test", 2)
+
+	if err := sl.Close(); err != nil {
+		t.Errorf("Expected <nil>, received %v", err)
+	}
+
+}
+func TestWriteSysLogger(t *testing.T) {
+	sl, _ := NewSysLogger("test", 2)
+	exp := 6
+	testbyte := []byte{97, 98, 99, 100, 101, 102}
+	if rcv, err := sl.Write(testbyte); err != nil {
+		t.Errorf("Expected <nil>, received %v", err)
+	} else if !reflect.DeepEqual(rcv, exp) {
+		t.Errorf("expected: <%v>, received: <%v>", exp, rcv)
+	}
+
+}
+
+func TestAlertSysLogger(t *testing.T) {
+	sl, _ := NewSysLogger("test", 0)
+
+	if err := sl.Alert("Alert Message"); err != nil {
+		t.Errorf("Expected <nil>, received %v", err)
+	}
+	sl, _ = NewSysLogger("test2", 2)
+	if err := sl.Alert("Alert Message 2"); err != nil {
+		t.Errorf("Expected <nil>, received %v", err)
+	}
+}
+func TestCritSysLogger(t *testing.T) {
+	sl, _ := NewSysLogger("test", 1)
+
+	if err := sl.Crit("Critical Message"); err != nil {
+		t.Errorf("Expected <nil>, received %v", err)
+	}
+	sl, _ = NewSysLogger("test2", 4)
+	if err := sl.Crit("Critical Message 2"); err != nil {
+		t.Errorf("Expected <nil>, received %v", err)
+	}
+}
+
+func TestDebugSysLogger(t *testing.T) {
+	sl, _ := NewSysLogger("test", 6)
+
+	if err := sl.Debug("Debug Message"); err != nil {
+		t.Errorf("Expected <nil>, received %v", err)
+	}
+	sl, _ = NewSysLogger("test2", 8)
+	if err := sl.Debug("Debug Message 2"); err != nil {
+		t.Errorf("Expected <nil>, received %v", err)
+	}
+}
+
+func TestEmergSysLogger(t *testing.T) {
+	sl, _ := NewSysLogger("test", -1)
+
+	if err := sl.Emerg("Emergency Message"); err != nil {
+		t.Errorf("Expected <nil>, received %v", err)
+	}
+	// always prints to stderr
+	// sl, _ = NewSysLogger("test2", 1)
+	// if err := sl.Emerg("Emergency Message 2"); err != nil {
+	// 	t.Errorf("Expected <nil>, received %v", err)
+	// }
+}
+
+func TestErrSysLogger(t *testing.T) {
+	sl, _ := NewSysLogger("test", 2)
+
+	if err := sl.Err("Error Message"); err != nil {
+		t.Errorf("Expected <nil>, received %v", err)
+	}
+	sl, _ = NewSysLogger("test2", 4)
+	if err := sl.Err("Error Message 2"); err != nil {
+		t.Errorf("Expected <nil>, received %v", err)
+	}
+}
+func TestInfoSysLogger(t *testing.T) {
+	sl, _ := NewSysLogger("test", 5)
+
+	if err := sl.Info("Info Message"); err != nil {
+		t.Errorf("Expected <nil>, received %v", err)
+	}
+	sl, _ = NewSysLogger("test2", 7)
+	if err := sl.Info("Info Message 2"); err != nil {
+		t.Errorf("Expected <nil>, received %v", err)
+	}
+}
+func TestNoticeSysLogger(t *testing.T) {
+	sl, _ := NewSysLogger("test", 4)
+
+	if err := sl.Notice("Notice Message"); err != nil {
+		t.Errorf("Expected <nil>, received %v", err)
+	}
+	sl, _ = NewSysLogger("test2", 6)
+	if err := sl.Notice("Notice Message 2"); err != nil {
+		t.Errorf("Expected <nil>, received %v", err)
+	}
+}
+func TestWarningSysLogger(t *testing.T) {
+	sl, _ := NewSysLogger("test", 3)
+
+	if err := sl.Warning("Warning Message"); err != nil {
+		t.Errorf("Expected <nil>, received %v", err)
+	}
+	sl, _ = NewSysLogger("test2", 5)
+	if err := sl.Warning("Warning Message 2"); err != nil {
+		t.Errorf("Expected <nil>, received %v", err)
+	}
+}
+
+func TestCloseNopCloser(t *testing.T) {
+	var nC NopCloser
+
+	if err := nC.Close(); err != nil {
+		t.Errorf("Expected <nil>, received %v", err)
+	}
+
+}
+
+func TestWriteLogWriter(t *testing.T) {
+	l := &logWriter{
+		log.New(io.Discard, EmptyString, log.LstdFlags),
+	}
+	exp := 1
+	if rcv, err := l.Write([]byte{51}); err != nil {
+		t.Error(err)
+	} else if rcv != exp {
+		t.Errorf("Expected <%+v> <%T>, received <%+v> <%T>", exp, exp, rcv, rcv)
+	}
+}
+
+func TestCloseLogWriter(t *testing.T) {
+	var lW logWriter
+	if err := lW.Close(); err != nil {
+		t.Errorf("Expected <nil>, received %v", err)
+	}
+
+}
+
+func TestGetSyslogStdLogger(t *testing.T) {
+	sl := &StdLogger{}
+	if rcv := sl.GetSyslog(); rcv != nil {
+		t.Errorf("Expected <nil>, received %v", rcv)
+	}
+}
+func TestCloseStdLogger(t *testing.T) {
+	sl := &StdLogger{w: Logger}
+	if rcv := sl.Close(); rcv != nil {
+		t.Errorf("Expected <nil>, received %v", rcv)
+	}
+}
+
+//  unfinished
+// func TestWriteStdLogger(t *testing.T) {
+// sl := &StdLogger{w: Logger}
+// if rcv, err := sl.Write([]byte{}); err != nil {
+// t.Errorf("Expected <nil>, received %v %v", err, rcv)
+// }
+// }