uppal/cgrates
1
0
Fork 1
mirror of https://github.com/cgrates/cgrates.git synced 2026-02-11 18:16:24 +05:00
Code Issues Packages Projects Releases Wiki Activity

Updated tests in utils

Browse Source
This commit is contained in:
adragusin
2019-12-06 18:20:37 +02:00
parent 3528165b0e
commit a72e688672
3 changed files with 275 additions and 39 deletions
Download Patch File Download Diff File Expand all files Collapse all files

40
utils/dataconverter.go
View File

@@ -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

230
utils/dataconverter_test.go
View File

@@ -18,6 +18,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>
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: <test>" {
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: <test>" {
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: <US:1:2:error>" {
if rcv, err := NewDataConverter("*libphonenumber:US:1:2:error"); err == nil || err.Error() != "unsupported *libphonenumber converter parameters: <US:1:2:error>" {
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 {

44
utils/dateseries_test.go
View File

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