From 8abd4d93c4d229a5dd0ac585aa49ba6fdab210a0 Mon Sep 17 00:00:00 2001 From: arberkatellari Date: Wed, 16 Nov 2022 08:10:15 -0500 Subject: [PATCH] Improving coverage at utils --- utils/coreutils_test.go | 5 +- utils/decimal.go | 2 +- utils/decimal_test.go | 5 ++ utils/eventcharges_test.go | 9 +- utils/librates_test.go | 26 +++--- utils/logger_test.go | 164 +++++++++++++++++++++++++++++++++++++ 6 files changed, 187 insertions(+), 24 deletions(-) diff --git a/utils/coreutils_test.go b/utils/coreutils_test.go index 6d0415737..4120095c0 100644 --- a/utils/coreutils_test.go +++ b/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) } diff --git a/utils/decimal.go b/utils/decimal.go index a8615acec..5725a2d2d 100644 --- a/utils/decimal.go +++ b/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) diff --git a/utils/decimal_test.go b/utils/decimal_test.go index e62db3cde..28b1bf8a4 100644 --- a/utils/decimal_test.go +++ b/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) { diff --git a/utils/eventcharges_test.go b/utils/eventcharges_test.go index d16f48ae8..1c2eef487 100644 --- a/utils/eventcharges_test.go +++ b/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 , Recevied <%v>", rcv) - } - ac = nil - nAc = nil + var ac *AccountCharge + var nAc *AccountCharge if rcv := ac.equals(nAc); rcv != true { t.Errorf("Expected , Recevied <%v>", rcv) } diff --git a/utils/librates_test.go b/utils/librates_test.go index e7faf8a6e..780852224 100644 --- a/utils/librates_test.go +++ b/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 " -// exp := APIRate{} + Weights: "notEmpty", + } + expErr := "invalid DynamicWeight format for string " + 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) + } +} diff --git a/utils/logger_test.go b/utils/logger_test.go index 4a1134bcf..5703e02dc 100644 --- a/utils/logger_test.go +++ b/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 , 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 , 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 , received %v", err) + } + sl, _ = NewSysLogger("test2", 2) + if err := sl.Alert("Alert Message 2"); err != nil { + t.Errorf("Expected , received %v", err) + } +} +func TestCritSysLogger(t *testing.T) { + sl, _ := NewSysLogger("test", 1) + + if err := sl.Crit("Critical Message"); err != nil { + t.Errorf("Expected , received %v", err) + } + sl, _ = NewSysLogger("test2", 4) + if err := sl.Crit("Critical Message 2"); err != nil { + t.Errorf("Expected , received %v", err) + } +} + +func TestDebugSysLogger(t *testing.T) { + sl, _ := NewSysLogger("test", 6) + + if err := sl.Debug("Debug Message"); err != nil { + t.Errorf("Expected , received %v", err) + } + sl, _ = NewSysLogger("test2", 8) + if err := sl.Debug("Debug Message 2"); err != nil { + t.Errorf("Expected , received %v", err) + } +} + +func TestEmergSysLogger(t *testing.T) { + sl, _ := NewSysLogger("test", -1) + + if err := sl.Emerg("Emergency Message"); err != nil { + t.Errorf("Expected , received %v", err) + } + // always prints to stderr + // sl, _ = NewSysLogger("test2", 1) + // if err := sl.Emerg("Emergency Message 2"); err != nil { + // t.Errorf("Expected , received %v", err) + // } +} + +func TestErrSysLogger(t *testing.T) { + sl, _ := NewSysLogger("test", 2) + + if err := sl.Err("Error Message"); err != nil { + t.Errorf("Expected , received %v", err) + } + sl, _ = NewSysLogger("test2", 4) + if err := sl.Err("Error Message 2"); err != nil { + t.Errorf("Expected , received %v", err) + } +} +func TestInfoSysLogger(t *testing.T) { + sl, _ := NewSysLogger("test", 5) + + if err := sl.Info("Info Message"); err != nil { + t.Errorf("Expected , received %v", err) + } + sl, _ = NewSysLogger("test2", 7) + if err := sl.Info("Info Message 2"); err != nil { + t.Errorf("Expected , received %v", err) + } +} +func TestNoticeSysLogger(t *testing.T) { + sl, _ := NewSysLogger("test", 4) + + if err := sl.Notice("Notice Message"); err != nil { + t.Errorf("Expected , received %v", err) + } + sl, _ = NewSysLogger("test2", 6) + if err := sl.Notice("Notice Message 2"); err != nil { + t.Errorf("Expected , received %v", err) + } +} +func TestWarningSysLogger(t *testing.T) { + sl, _ := NewSysLogger("test", 3) + + if err := sl.Warning("Warning Message"); err != nil { + t.Errorf("Expected , received %v", err) + } + sl, _ = NewSysLogger("test2", 5) + if err := sl.Warning("Warning Message 2"); err != nil { + t.Errorf("Expected , received %v", err) + } +} + +func TestCloseNopCloser(t *testing.T) { + var nC NopCloser + + if err := nC.Close(); err != nil { + t.Errorf("Expected , 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 , received %v", err) + } + +} + +func TestGetSyslogStdLogger(t *testing.T) { + sl := &StdLogger{} + if rcv := sl.GetSyslog(); rcv != nil { + t.Errorf("Expected , received %v", rcv) + } +} +func TestCloseStdLogger(t *testing.T) { + sl := &StdLogger{w: Logger} + if rcv := sl.Close(); rcv != nil { + t.Errorf("Expected , received %v", rcv) + } +} + +// unfinished +// func TestWriteStdLogger(t *testing.T) { +// sl := &StdLogger{w: Logger} +// if rcv, err := sl.Write([]byte{}); err != nil { +// t.Errorf("Expected , received %v %v", err, rcv) +// } +// }