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

Added tests for Dataconverter methods and renamed *usage_seconds to *duration_seconds

Browse Source
This commit is contained in:
Anevo
2018-03-20 11:02:07 -04:00
committed by Dan Christian Bogos
parent 2a73e50a24
commit 60c48cf52b
6 changed files with 141 additions and 16 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
data/conf/samples/radagent/cgrates.json
View File

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

2
utils/consts.go
View File

@@ -583,7 +583,7 @@ const (
MetaTpDestinations = "*tp_destinations"
MetaTpRatingPlan = "*tp_rating_plan"
MetaTpRatingProfile = "*tp_rating_profile"
MetaUsageSeconds = "*usage_seconds"
MetaUsageSeconds = "*duration_seconds"
)
// MetaFilterIndexesAPIs

10
utils/dataconverter.go
View File

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

125
utils/dataconverter_test.go
View File

@@ -16,3 +16,128 @@ You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>
*/
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)
}
}

4
utils/reflect.go
View File

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

14
utils/rsrfield_test.go
View File

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