Updated IfaceAsString and MapEvent tests

engine/action.go

@@ -176,12 +176,8 @@ func cdrLogAction(acc *Account, a *Action, acs Actions, extraData interface{}) (
 	}
 	//In case that we have extra data we populate default templates
 	mapExtraData, _ := extraData.(map[string]interface{})
-	var strVal string
 	for key, val := range mapExtraData {
-		if strVal, err = utils.IfaceAsString(val); err != nil {
-			return
-		}
-		if defaultTemplate[key], err = config.NewRSRParsers(strVal,
+		if defaultTemplate[key], err = config.NewRSRParsers(utils.IfaceAsString(val),
 			true, config.CgrConfig().GeneralCfg().RsrSepatarot); err != nil {
 			return
 		}
@@ -965,8 +961,7 @@ func (cdrP *cdrLogProvider) FieldAsString(fldPath []string) (data string, err er
 	if err != nil {
 		return
 	}
-	data, err = utils.IfaceAsString(valIface)
-	return
+	return utils.IfaceAsString(valIface), nil
 }
 
 // AsNavigableMap is part of engine.DataProvider interface

engine/attributes.go

@@ -213,7 +213,7 @@ func (alS *AttributeService) processEvent(args *AttrArgsProcessEvent) (
 			if err != nil {
 				return nil, err
 			}
-			substitute, err = utils.IfaceAsString(ifaceSum)
+			substitute = utils.IfaceAsString(ifaceSum)
 		case utils.MetaValueExponent:
 			if len(attribute.Value) != 2 {
 				return nil, fmt.Errorf("invalid arguments <%s> to %s",
@@ -254,11 +254,7 @@ func (alS *AttributeService) processEvent(args *AttrArgsProcessEvent) (
 			continue
 		}
 		if attribute.Type == utils.META_COMPOSED {
-			evStrVal, err := utils.IfaceAsString(rply.CGREvent.Event[attribute.FieldName])
-			if err != nil {
-				return nil, err
-			}
-			substitute = evStrVal + substitute
+			substitute = utils.IfaceAsString(rply.CGREvent.Event[attribute.FieldName]) + substitute
 		}
 		rply.CGREvent.Event[attribute.FieldName] = substitute
 

engine/filterhelpers.go

@@ -19,7 +19,6 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>
 package engine
 
 import (
-	"fmt"
 	"strings"
 
 	"github.com/cgrates/cgrates/config"
@@ -71,13 +70,7 @@ func MatchingItemIDsForEvent(ev map[string]interface{}, stringFldIDs, prefixFldI
 					continue
 				}
 				if _, cached := stringFieldVals[fldName]; !cached {
-					strVal, err := utils.IfaceAsString(fieldValIf)
-					if err != nil {
-						utils.Logger.Warning(
-							fmt.Sprintf("<%s> cannot cast field: %s into string", utils.FilterS, fldName))
-						continue
-					}
-					stringFieldVals[fldName] = strVal
+					stringFieldVals[fldName] = utils.IfaceAsString(fieldValIf)
 				}
 				fldVal := stringFieldVals[fldName]
 				fldVals := []string{fldVal}

engine/mapevent.go

@@ -78,10 +78,10 @@ func (me MapEvent) GetString(fldName string) (out string, err error) {
 	if !has {
 		return "", utils.ErrNotFound
 	}
-	return utils.IfaceAsString(fldIface)
+	return utils.IfaceAsString(fldIface), nil
 }
 
-func (me MapEvent) GetInt64(fldName string) (out int64, err error) {
+func (me MapEvent) GetTInt64(fldName string) (out int64, err error) {
 	fldIface, has := me[fldName]
 	if !has {
 		return 0, utils.ErrNotFound
@@ -160,25 +160,13 @@ func (me MapEvent) AsMapString(ignoredFlds utils.StringMap) (mp map[string]strin
 		if ignoredFlds.HasKey(k) {
 			continue
 		}
-		var out string
-		if out, err = utils.IfaceAsString(v); err != nil {
-			return nil, err
-		}
-		mp[k] = out
+		mp[k] = utils.IfaceAsString(v)
 	}
 	return
 }
 
 func (me MapEvent) AsMapStringIgnoreErrors(ignoredFlds utils.StringMap) (mp map[string]string) {
-	mp = make(map[string]string)
-	for k, v := range me {
-		if ignoredFlds.HasKey(k) {
-			continue
-		}
-		if out, err := utils.IfaceAsString(v); err == nil {
-			mp[k] = out
-		}
-	}
+	mp, _ = me.AsMapString(ignoredFlds)
 	return
 }
 
@@ -187,62 +175,37 @@ func (me MapEvent) AsCDR(cfg *config.CGRConfig, tnt, tmz string) (cdr *CDR, err
 	cdr = &CDR{Tenant: tnt, Cost: -1.0, ExtraFields: make(map[string]string)}
 	for k, v := range me {
 		if _, has := utils.MainCDRFieldsMap[k]; !has { // not primary field, populate extra ones
-			if cdr.ExtraFields[k], err = utils.IfaceAsString(v); err != nil {
-				return nil, err
-			}
+			cdr.ExtraFields[k] = utils.IfaceAsString(v)
 			continue
 		}
 		switch k {
 		default:
+			// for the momment this return can not be reached because we implemented a case for every MainCDRField
 			return nil, fmt.Errorf("unimplemented CDR field: <%s>", k)
 		case utils.CGRID:
-			if cdr.CGRID, err = utils.IfaceAsString(v); err != nil {
-				return nil, err
-			}
+			cdr.CGRID = utils.IfaceAsString(v)
 		case utils.RunID:
-			if cdr.RunID, err = utils.IfaceAsString(v); err != nil {
-				return nil, err
-			}
+			cdr.RunID = utils.IfaceAsString(v)
 		case utils.OriginHost:
-			if cdr.OriginHost, err = utils.IfaceAsString(v); err != nil {
-				return nil, err
-			}
+			cdr.OriginHost = utils.IfaceAsString(v)
 		case utils.Source:
-			if cdr.Source, err = utils.IfaceAsString(v); err != nil {
-				return nil, err
-			}
+			cdr.Source = utils.IfaceAsString(v)
 		case utils.OriginID:
-			if cdr.OriginID, err = utils.IfaceAsString(v); err != nil {
-				return nil, err
-			}
+			cdr.OriginID = utils.IfaceAsString(v)
 		case utils.ToR:
-			if cdr.ToR, err = utils.IfaceAsString(v); err != nil {
-				return nil, err
-			}
+			cdr.ToR = utils.IfaceAsString(v)
 		case utils.RequestType:
-			if cdr.RequestType, err = utils.IfaceAsString(v); err != nil {
-				return nil, err
-			}
+			cdr.RequestType = utils.IfaceAsString(v)
 		case utils.Tenant:
-			if cdr.Tenant, err = utils.IfaceAsString(v); err != nil {
-				return nil, err
-			}
+			cdr.Tenant = utils.IfaceAsString(v)
 		case utils.Category:
-			if cdr.Category, err = utils.IfaceAsString(v); err != nil {
-				return nil, err
-			}
+			cdr.Category = utils.IfaceAsString(v)
 		case utils.Account:
-			if cdr.Account, err = utils.IfaceAsString(v); err != nil {
-				return nil, err
-			}
+			cdr.Account = utils.IfaceAsString(v)
 		case utils.Subject:
-			if cdr.Subject, err = utils.IfaceAsString(v); err != nil {
-				return nil, err
-			}
+			cdr.Subject = utils.IfaceAsString(v)
 		case utils.Destination:
-			if cdr.Destination, err = utils.IfaceAsString(v); err != nil {
-				return nil, err
-			}
+			cdr.Destination = utils.IfaceAsString(v)
 		case utils.SetupTime:
 			if cdr.SetupTime, err = utils.IfaceAsTime(v, tmz); err != nil {
 				return nil, err
@@ -264,9 +227,7 @@ func (me MapEvent) AsCDR(cfg *config.CGRConfig, tnt, tmz string) (cdr *CDR, err
 				return nil, err
 			}
 		case utils.CostSource:
-			if cdr.CostSource, err = utils.IfaceAsString(v); err != nil {
-				return nil, err
-			}
+			cdr.CostSource = utils.IfaceAsString(v)
 		case utils.Cost:
 			if cdr.Cost, err = utils.IfaceAsFloat64(v); err != nil {
 				return nil, err
@@ -276,9 +237,7 @@ func (me MapEvent) AsCDR(cfg *config.CGRConfig, tnt, tmz string) (cdr *CDR, err
 				return nil, err
 			}
 		case utils.ExtraInfo:
-			if cdr.ExtraInfo, err = utils.IfaceAsString(v); err != nil {
-				return nil, err
-			}
+			cdr.ExtraInfo = utils.IfaceAsString(v)
 		case utils.OrderID:
 			if cdr.OrderID, err = utils.IfaceAsTInt64(v); err != nil {
 				return nil, err

engine/mapevent_test.go

@@ -362,6 +362,15 @@ func TestMapEventAsCDR(t *testing.T) {
 	if _, err := me.AsCDR(nil, utils.EmptyString, utils.EmptyString); err == nil {
 		t.Errorf("Expecting not null error, received: null error")
 	}
+	me = MapEvent{"CostDetails": "clearly not CostDetails string"}
+	if _, err := me.AsCDR(nil, utils.EmptyString, utils.EmptyString); err == nil {
+		t.Errorf("Expecting not null error, received: null error")
+	}
+	me = MapEvent{"OrderID": "clearly not int64 string"}
+	if _, err := me.AsCDR(nil, utils.EmptyString, utils.EmptyString); err == nil {
+		t.Errorf("Expecting not null error, received: null error")
+	}
+
 	me = MapEvent{"ExtraField1": 5, "ExtraField2": "extra"}
 	expected = &CDR{
 		Cost: -1.0,
@@ -402,6 +411,50 @@ func TestMapEventAsCDR(t *testing.T) {
 	} else if !reflect.DeepEqual(expected, rply) {
 		t.Errorf("Expecting %+v, received: %+v", expected, rply)
 	}
+	me = MapEvent{
+		utils.CGRID:       "da39a3ee5e6b4b0d3255bfef95601890afd80709",
+		utils.RunID:       utils.MetaDefault,
+		utils.OriginHost:  utils.FreeSWITCHAgent,
+		utils.OriginID:    "127.0.0.1",
+		utils.ToR:         utils.VOICE,
+		utils.RequestType: utils.META_PREPAID,
+		utils.Tenant:      "cgrates.org",
+		utils.Category:    utils.CALL,
+		utils.Account:     "10010",
+		utils.Subject:     "10010",
+		utils.Destination: "10012",
+		"ExtraField1":     5,
+		"Source":          1001,
+		"CostSource":      "1002",
+		"ExtraField2":     "extra",
+		"ExtraInfo":       "ACCOUNT_NOT_FOUND",
+	}
+	expected = &CDR{
+		CGRID:       "da39a3ee5e6b4b0d3255bfef95601890afd80709",
+		RunID:       utils.MetaDefault,
+		OriginHost:  utils.FreeSWITCHAgent,
+		OriginID:    "127.0.0.1",
+		ToR:         utils.VOICE,
+		RequestType: utils.META_PREPAID,
+		Tenant:      "cgrates.org",
+		Category:    utils.CALL,
+		Account:     "10010",
+		Subject:     "10010",
+		Destination: "10012",
+		Cost:        -1.0,
+		Source:      "1001",
+		CostSource:  "1002",
+		ExtraFields: map[string]string{
+			"ExtraField1": "5",
+			"ExtraField2": "extra",
+		},
+		ExtraInfo: "ACCOUNT_NOT_FOUND",
+	}
+	if rply, err := me.AsCDR(cfg, utils.EmptyString, utils.EmptyString); err != nil {
+		t.Error(err)
+	} else if !reflect.DeepEqual(expected, rply) {
+		t.Errorf("Expecting %+v, received: %+v", expected, rply)
+	}
 	ec1 := &EventCost{
 		CGRID:     "164b0422fdc6a5117031b427439482c6a4f90e41",
 		RunID:     utils.META_DEFAULT,
@@ -614,3 +667,72 @@ func TestMapEventAsCDR(t *testing.T) {
 		t.Errorf("Expecting %+v, received: %+v", expected, rply)
 	}
 }
+
+func TestMapEventGetTInt64(t *testing.T) {
+	if rply, err := mapEv.GetTInt64("test2"); err != nil {
+		t.Error(err)
+	} else if rply != int64(42) {
+		t.Errorf("Expecting %+v, received: %+v", int64(42), rply)
+	}
+
+	if rply, err := mapEv.GetTInt64("test3"); err != nil {
+		t.Error(err)
+	} else if rply != int64(42) {
+		t.Errorf("Expecting %+v, received: %+v", int64(42), rply)
+	}
+
+	if rply, err := mapEv.GetTInt64("test4"); err == nil {
+		t.Errorf("Expecting error, received: %+v with error %v", rply, err)
+	}
+
+	if rply, err := mapEv.GetTInt64("0test"); err == nil || err.Error() != utils.ErrNotFound.Error() {
+		t.Errorf("Expecting error: %v, received: %+v with error %v", utils.ErrNotFound, rply, err)
+	}
+}
+
+func TestMapEventGetDurationPtr(t *testing.T) {
+	if rply, err := mapEv.GetDurationPtr("test4"); err == nil {
+		t.Errorf("Expecting error, received: %+v with error %v", rply, err)
+	}
+	if rply, err := mapEv.GetDurationPtr("test"); err != utils.ErrNotFound {
+		t.Errorf("Expected: %+v, received: %+v", utils.ErrNotFound, err)
+	} else if rply != nil {
+		t.Errorf("Expected: %+v , received duration: %+v", nil, rply)
+	}
+	expected := utils.DurationPointer(time.Duration(10 * time.Second))
+	if rply, err := mapEv.GetDurationPtr("test6"); err != nil {
+		t.Error(err)
+	} else if !reflect.DeepEqual(expected, rply) {
+		t.Errorf("Expecting %+v, received: %+v", expected, rply)
+	}
+	expected = utils.DurationPointer(time.Duration(42 * time.Second))
+	if rply, err := mapEv.GetDurationPtr("test7"); err != nil {
+		t.Error(err)
+	} else if !reflect.DeepEqual(expected, rply) {
+		t.Errorf("Expecting %+v, received: %+v", expected, rply)
+	}
+	expected = utils.DurationPointer(time.Duration(42))
+	if rply, err := mapEv.GetDurationPtr("test2"); err != nil {
+		t.Error(err)
+	} else if !reflect.DeepEqual(expected, rply) {
+		t.Errorf("Expecting %+v, received: %+v", expected, rply)
+	}
+}
+
+func TestMapEventGetDurationPtrIgnoreErrors(t *testing.T) {
+	if rply := mapEv.GetDurationPtrIgnoreErrors("test"); rply != nil {
+		t.Errorf("Expected: %+v, received: %+v", nil, rply)
+	}
+	expected := utils.DurationPointer(time.Duration(10 * time.Second))
+	if rply := mapEv.GetDurationPtrIgnoreErrors("test6"); *rply != *expected {
+		t.Errorf("Expected: %+v, received: %+v", expected, rply)
+	}
+	expected = utils.DurationPointer(time.Duration(42 * time.Second))
+	if rply := mapEv.GetDurationPtrIgnoreErrors("test7"); *rply != *expected {
+		t.Errorf("Expected: %+v, received: %+v", expected, rply)
+	}
+	expected = utils.DurationPointer(time.Duration(42))
+	if rply := mapEv.GetDurationPtrIgnoreErrors("test2"); *rply != *expected {
+		t.Errorf("Expected: %+v, received: %+v", expected, rply)
+	}
+}

engine/safevent.go

@@ -126,9 +126,9 @@ func (se *SafEvent) GetString(fldName string) (out string, err error) {
 	return
 }
 
-func (se SafEvent) GetInt64(fldName string) (out int64, err error) {
+func (se SafEvent) GetTInt64(fldName string) (out int64, err error) {
 	se.RLock()
-	out, err = se.Me.GetInt64(fldName)
+	out, err = se.Me.GetTInt64(fldName)
 	se.RUnlock()
 	return
 }
@@ -219,7 +219,7 @@ func (se *SafEvent) GetSetString(fldName string, setVal string) (out string, err
 		return
 	}
 	// should be present, return it as string
-	return utils.IfaceAsString(outIface)
+	return utils.IfaceAsString(outIface), nil
 }
 
 // GetMapInterface returns the map stored internally without cloning it

engine/safevent_test.go

@@ -790,3 +790,61 @@ func TestSafEventAsCDR(t *testing.T) {
 		t.Errorf("Expecting %+v, received: %+v", expected, rply)
 	}
 }
+
+func TestSafEventGetTInt64(t *testing.T) {
+	if rply, err := safEv.GetTInt64("test2"); err != nil {
+		t.Error(err)
+	} else if rply != int64(42) {
+		t.Errorf("Expecting %+v, received: %+v", int64(42), rply)
+	}
+
+	if rply, err := safEv.GetTInt64("test3"); err != nil {
+		t.Error(err)
+	} else if rply != int64(42) {
+		t.Errorf("Expecting %+v, received: %+v", int64(42), rply)
+	}
+
+	if rply, err := safEv.GetTInt64("test4"); err == nil {
+		t.Errorf("Expecting error, received: %+v with error %v", rply, err)
+	}
+
+	if rply, err := safEv.GetTInt64("0test"); err == nil || err.Error() != utils.ErrNotFound.Error() {
+		t.Errorf("Expecting error: %v, received: %+v with error %v", utils.ErrNotFound, rply, err)
+	}
+}
+
+func TestSafEventGetDurationPtrIgnoreErrors(t *testing.T) {
+	if rply := safEv.GetDurationPtrIgnoreErrors("test"); rply != nil {
+		t.Errorf("Expected: %+v, received: %+v", nil, rply)
+	}
+	expected := utils.DurationPointer(time.Duration(10 * time.Second))
+	if rply := safEv.GetDurationPtrIgnoreErrors("test6"); *rply != *expected {
+		t.Errorf("Expected: %+v, received: %+v", expected, rply)
+	}
+	expected = utils.DurationPointer(time.Duration(42 * time.Second))
+	if rply := safEv.GetDurationPtrIgnoreErrors("test7"); *rply != *expected {
+		t.Errorf("Expected: %+v, received: %+v", expected, rply)
+	}
+	expected = utils.DurationPointer(time.Duration(42))
+	if rply := safEv.GetDurationPtrIgnoreErrors("test2"); *rply != *expected {
+		t.Errorf("Expected: %+v, received: %+v", expected, rply)
+	}
+}
+
+func TestSafEventGetDurationOrDefault(t *testing.T) {
+	safEv.Remove("test7")
+	expected := time.Duration(10 * time.Second)
+	if rply, err := safEv.GetDurationOrDefault("test7", time.Duration(10*time.Second)); err != nil {
+		t.Error(err)
+	} else if rply != expected {
+		t.Errorf("Expecting %+v, received: %+v", expected, rply)
+	}
+	safEv.Set("test7", "42s")
+	expected = time.Duration(42 * time.Second)
+	if rply, err := safEv.GetDurationOrDefault("test7", time.Second); err != nil {
+		t.Error(err)
+	} else if !reflect.DeepEqual(expected, rply) {
+		t.Errorf("Expecting %+v, received: %+v", expected, rply)
+	}
+
+}