From 60c48cf52b3ecf64be21b415f42588e8d33ee0f1 Mon Sep 17 00:00:00 2001 From: Anevo Date: Tue, 20 Mar 2018 11:02:07 -0400 Subject: [PATCH] Added tests for Dataconverter methods and renamed *usage_seconds to *duration_seconds --- data/conf/samples/radagent/cgrates.json | 2 +- utils/consts.go | 2 +- utils/dataconverter.go | 10 +- utils/dataconverter_test.go | 125 ++++++++++++++++++++++++ utils/reflect.go | 4 +- utils/rsrfield_test.go | 14 +-- 6 files changed, 141 insertions(+), 16 deletions(-) diff --git a/data/conf/samples/radagent/cgrates.json b/data/conf/samples/radagent/cgrates.json index dded9d9e9..43591620c 100644 --- a/data/conf/samples/radagent/cgrates.json +++ b/data/conf/samples/radagent/cgrates.json @@ -116,7 +116,7 @@ ], "reply_fields":[ {"tag": "MaxUsage", "field_id": "SIP-AVP", "type": "*composed", - "value": "^session_max_time#;*cgrReply>MaxUsage{*usage_seconds}", "mandatory": true}, + "value": "^session_max_time#;*cgrReply>MaxUsage{*duration_seconds}", "mandatory": true}, ], }, { diff --git a/utils/consts.go b/utils/consts.go index 30d5faace..121fbc957 100755 --- a/utils/consts.go +++ b/utils/consts.go @@ -583,7 +583,7 @@ const ( MetaTpDestinations = "*tp_destinations" MetaTpRatingPlan = "*tp_rating_plan" MetaTpRatingProfile = "*tp_rating_profile" - MetaUsageSeconds = "*usage_seconds" + MetaUsageSeconds = "*duration_seconds" ) // MetaFilterIndexesAPIs diff --git a/utils/dataconverter.go b/utils/dataconverter.go index d8e54d46a..aea51b875 100644 --- a/utils/dataconverter.go +++ b/utils/dataconverter.go @@ -55,7 +55,7 @@ func NewDataConverter(params string) ( conv DataConverter, err error) { switch { case params == MetaUsageSeconds: - return NewUsageSecondsConverter("") + return NewDurationSecondsConverter("") case strings.HasPrefix(params, MetaRound): if len(params) == len(MetaRound) { // no extra params, defaults implied return NewRoundConverter("") @@ -68,15 +68,15 @@ func NewDataConverter(params string) ( } } -func NewUsageSecondsConverter(params string) ( +func NewDurationSecondsConverter(params string) ( hdlr DataConverter, err error) { - return new(UsageSecondsConverter), nil + return new(DurationSecondsConverter), nil } // UsageSecondsDataConverter converts duration into seconds encapsulated in float64 -type UsageSecondsConverter struct{} +type DurationSecondsConverter struct{} -func (mS *UsageSecondsConverter) Convert(in interface{}) ( +func (mS *DurationSecondsConverter) Convert(in interface{}) ( out interface{}, err error) { var inDur time.Duration if inDur, err = IfaceAsDuration(in); err != nil { diff --git a/utils/dataconverter_test.go b/utils/dataconverter_test.go index 41f46a656..3f8d14b01 100644 --- a/utils/dataconverter_test.go +++ b/utils/dataconverter_test.go @@ -16,3 +16,128 @@ You should have received a copy of the GNU General Public License along with this program. If not, see */ package utils + +import ( + "reflect" + "testing" + "time" +) + +func TestNewDataConverter(t *testing.T) { + a, err := NewDataConverter(MetaUsageSeconds) + if err != nil { + t.Error(err.Error()) + } + b, err := NewDurationSecondsConverter("") + if err != nil { + t.Error(err.Error()) + } + if !reflect.DeepEqual(a, b) { + t.Error("Error reflect") + } +} + +func TestConvertFloatToSeconds(t *testing.T) { + b, err := NewDurationSecondsConverter("") + if err != nil { + t.Error(err.Error()) + } + a, err := b.Convert(time.Duration(10*time.Second + 300*time.Millisecond)) + if err != nil { + t.Error(err.Error()) + } + expVal := 10.3 + if !reflect.DeepEqual(a, expVal) { + t.Errorf("Expected %+v received: %+v", expVal, a) + } +} + +func TestRoundConverterFloat64(t *testing.T) { + b, err := NewRoundConverter("2") + if err != nil { + t.Error(err.Error()) + } + expData := &RoundConverter{ + Decimals: 2, + Method: ROUNDING_MIDDLE, + } + if !reflect.DeepEqual(b, expData) { + t.Errorf("Expected %+v received: %+v", expData, b) + } + val, err := b.Convert(2.3456) + if err != nil { + t.Error(err.Error()) + } + expV := 2.35 + if !reflect.DeepEqual(expV, val) { + t.Errorf("Expected %+v received: %+v", expV, val) + } +} + +//testRoundconv string / float / int / time + +func TestRoundConverterString(t *testing.T) { + b, err := NewRoundConverter("2") + if err != nil { + t.Error(err.Error()) + } + expData := &RoundConverter{ + Decimals: 2, + Method: ROUNDING_MIDDLE, + } + if !reflect.DeepEqual(b, expData) { + t.Errorf("Expected %+v received: %+v", expData, b) + } + val, err := b.Convert("10.4295") + if err != nil { + t.Error(err.Error()) + } + expV := 10.43 + if !reflect.DeepEqual(expV, val) { + t.Errorf("Expected %+v received: %+v", expV, val) + } +} + +func TestRoundConverterInt64(t *testing.T) { + b, err := NewRoundConverter("2") + if err != nil { + t.Error(err.Error()) + } + expData := &RoundConverter{ + Decimals: 2, + Method: ROUNDING_MIDDLE, + } + if !reflect.DeepEqual(b, expData) { + t.Errorf("Expected %+v received: %+v", expData, b) + } + val, err := b.Convert(int64(10)) + if err != nil { + t.Error(err.Error()) + } + expV := 10.0 + if !reflect.DeepEqual(expV, val) { + t.Errorf("Expected %+v received: %+v", expV, val) + } +} + +func TestRoundConverterTime(t *testing.T) { + b, err := NewRoundConverter("2") + if err != nil { + t.Error(err.Error()) + } + expData := &RoundConverter{ + Decimals: 2, + Method: ROUNDING_MIDDLE, + } + if !reflect.DeepEqual(b, expData) { + t.Errorf("Expected %+v received: %+v", expData, b) + } + val, err := b.Convert(time.Duration(123 * time.Nanosecond)) + if err != nil { + t.Error(err.Error()) + } + expV := 123.0 + if !reflect.DeepEqual(expV, val) { + t.Errorf("Expected %+v received: %+v", expV, val) + } +} diff --git a/utils/reflect.go b/utils/reflect.go index b0d22ff28..3062de354 100644 --- a/utils/reflect.go +++ b/utils/reflect.go @@ -170,7 +170,7 @@ func IfaceAsDuration(itm interface{}) (d time.Duration, err error) { return ParseDurationWithNanosecs(itm.(string)) default: - err = fmt.Errorf("cannot convert field: %+v to time.Time", itm) + err = fmt.Errorf("cannot convert field: %+v to time.Duration", itm) } return } @@ -186,7 +186,7 @@ func IfaceAsFloat64(itm interface{}) (f float64, err error) { case string: return strconv.ParseFloat(itm.(string), 64) default: - err = fmt.Errorf("cannot convert field: %+v to time.Time", itm) + err = fmt.Errorf("cannot convert field: %+v to float64", itm) } return } diff --git a/utils/rsrfield_test.go b/utils/rsrfield_test.go index e82dd1053..858402b77 100644 --- a/utils/rsrfield_test.go +++ b/utils/rsrfield_test.go @@ -44,7 +44,7 @@ func TestNewRSRField1(t *testing.T) { } // With filter rulesStr = `~sip_redirected_to:s/sip:\+49(\d+)@/0$1/(086517174963)` - // rulesStr = `~sip_redirected_to:s/sip:\+49(\d+)@/0$1/{*usage_seconds;*round:5:*middle}(086517174963)` + // rulesStr = `~sip_redirected_to:s/sip:\+49(\d+)@/0$1/{*duration_seconds;*round:5:*middle}(086517174963)` filter, _ = NewRSRFilter("086517174963") expRSRField2 := &RSRField{Id: "sip_redirected_to", Rules: rulesStr, filters: []*RSRFilter{filter}, RSRules: []*ReSearchReplace{&ReSearchReplace{SearchRegexp: regexp.MustCompile(`sip:\+49(\d+)@`), ReplaceTemplate: "0$1"}}} @@ -54,7 +54,7 @@ func TestNewRSRField1(t *testing.T) { t.Errorf("Expecting: %v, received: %v", expRSRField2, rsrField) } // with dataConverters - rulesStr = `~sip_redirected_to:s/sip:\+49(\d+)@/0$1/{*usage_seconds;*round:5:*middle}(086517174963)` + rulesStr = `~sip_redirected_to:s/sip:\+49(\d+)@/0$1/{*duration_seconds;*round:5:*middle}(086517174963)` filter, _ = NewRSRFilter("086517174963") expRSRField := &RSRField{ Id: "sip_redirected_to", @@ -65,7 +65,7 @@ func TestNewRSRField1(t *testing.T) { ReplaceTemplate: "0$1"}}, filters: []*RSRFilter{filter}, converters: []DataConverter{ - new(UsageSecondsConverter), &RoundConverter{Decimals: 5, Method: "*middle"}}} + new(DurationSecondsConverter), &RoundConverter{Decimals: 5, Method: "*middle"}}} if rsrField, err := NewRSRField(rulesStr); err != nil { t.Error("Unexpected error: ", err.Error()) } else if !reflect.DeepEqual(expRSRField, rsrField) { @@ -477,7 +477,7 @@ func TestParseRules(t *testing.T) { func TestRSRFldParse(t *testing.T) { // with dataConverters - rulesStr := `~Usage:s/(\d+)/${1}ms/{*usage_seconds;*round:1:*middle}(2.2)` + rulesStr := `~Usage:s/(\d+)/${1}ms/{*duration_seconds;*round:1:*middle}(2.2)` rsrField, err := NewRSRField(rulesStr) if err != nil { t.Error(err) @@ -488,12 +488,12 @@ func TestRSRFldParse(t *testing.T) { } else if out != eOut { t.Errorf("expecting: %s, received: %s", eOut, out) } - rulesStr = `~Usage:s/(\d+)/${1}ms/{*usage_seconds;*round:1:*middle}(2.21)` + rulesStr = `~Usage:s/(\d+)/${1}ms/{*duration_seconds;*round:1:*middle}(2.21)` rsrField, _ = NewRSRField(rulesStr) if _, err := rsrField.Parse("2210"); err == nil || err.Error() != "filter not passing" { t.Error(err) } - rulesStr = `~Usage:s/(\d+)/${1}ms/{*usage_seconds;*round}` + rulesStr = `~Usage:s/(\d+)/${1}ms/{*duration_seconds;*round}` if rsrField, err = NewRSRField(rulesStr); err != nil { t.Error(err) } @@ -503,7 +503,7 @@ func TestRSRFldParse(t *testing.T) { } else if out != eOut { t.Errorf("expecting: %s, received: %s", eOut, out) } - rulesStr = `Usage{*usage_seconds}` + rulesStr = `Usage{*duration_seconds}` rsrField, err = NewRSRField(rulesStr) if err != nil { t.Error(err)