From 0345819718ff48694e3d7f91dc829216b34d4c8e Mon Sep 17 00:00:00 2001 From: Trial97 Date: Fri, 21 Sep 2018 18:29:59 +0300 Subject: [PATCH] Added all tests for mapevent.go. --- engine/cdr.go | 14 +- engine/mapevent.go | 8 +- engine/mapevent_test.go | 346 +++++++++++++++++++++++++++++++++++----- utils/reflect.go | 2 + 4 files changed, 319 insertions(+), 51 deletions(-) diff --git a/engine/cdr.go b/engine/cdr.go index c719613f8..25b6e41a7 100644 --- a/engine/cdr.go +++ b/engine/cdr.go @@ -102,25 +102,25 @@ type CDR struct { // AddDefaults will add missing information based on other fields func (cdr *CDR) AddDefaults(cfg *config.CGRConfig) { - if cdr.CGRID == "" { + if cdr.CGRID == utils.EmptyString { cdr.ComputeCGRID() } - if cdr.RunID == "" { + if cdr.RunID == utils.EmptyString { cdr.RunID = utils.MetaRaw } - if cdr.ToR == "" { + if cdr.ToR == utils.EmptyString { cdr.ToR = utils.VOICE } - if cdr.RequestType == "" { + if cdr.RequestType == utils.EmptyString { cdr.RequestType = cfg.DefaultReqType } - if cdr.Tenant == "" { + if cdr.Tenant == utils.EmptyString { cdr.Tenant = cfg.DefaultTenant } - if cdr.Category == "" { + if cdr.Category == utils.EmptyString { cdr.Category = cfg.DefaultCategory } - if cdr.Subject == "" { + if cdr.Subject == utils.EmptyString { cdr.Subject = cdr.Account } } diff --git a/engine/mapevent.go b/engine/mapevent.go index 3a3dbac17..2d1a94426 100644 --- a/engine/mapevent.go +++ b/engine/mapevent.go @@ -110,7 +110,7 @@ func (me MapEvent) AsMapString(ignoredFlds utils.StringMap) (mp map[string]strin if out, err = utils.IfaceAsString(v); err != nil { return nil, err } - me[k] = out + mp[k] = out } return } @@ -122,7 +122,7 @@ func (me MapEvent) AsMapStringIgnoreErrors(ignoredFlds utils.StringMap) (mp map[ continue } if out, can := utils.CastFieldIfToString(v); can { - me[k] = out + mp[k] = out } } return @@ -132,7 +132,9 @@ func (me MapEvent) AsMapStringIgnoreErrors(ignoredFlds utils.StringMap) (mp map[ func (me MapEvent) AsCDR(cfg *config.CGRConfig, tmz string) (cdr *CDR, err error) { cdr = &CDR{Cost: -1.0, ExtraFields: make(map[string]string)} for k, v := range me { - if !utils.IsSliceMember(utils.PrimaryCdrFields, k) { // not primary field, populate extra ones + if !utils.IsSliceMember( + append(utils.PrimaryCdrFields, utils.PreRated, utils.CostSource), + k) { // not primary field, populate extra ones if cdr.ExtraFields[k], err = utils.IfaceAsString(v); err != nil { return nil, err } diff --git a/engine/mapevent_test.go b/engine/mapevent_test.go index 872ca9899..76554375c 100644 --- a/engine/mapevent_test.go +++ b/engine/mapevent_test.go @@ -21,8 +21,9 @@ package engine import ( "reflect" "testing" - //"time" - // "github.com/cgrates/cgrates/config" + "time" + + "github.com/cgrates/cgrates/config" "github.com/cgrates/cgrates/utils" ) @@ -32,12 +33,14 @@ var mapEv = MapEvent(map[string]interface{}{ "test3": 42.3, "test4": true, "test5": "test", + "test6": time.Duration(10 * time.Second), + "test7": "42s", + "test8": time.Date(2009, 11, 10, 23, 0, 0, 0, time.UTC), + "test9": "2009-11-10T23:00:00Z", }) func TestMapEventNewMapEvent(t *testing.T) { - expected := MapEvent(make(map[string]interface{})) - rply := NewMapEvent(nil) - if !reflect.DeepEqual(expected, rply) { + if rply, expected := NewMapEvent(nil), MapEvent(make(map[string]interface{})); !reflect.DeepEqual(expected, rply) { t.Errorf("Expecting %+v, received: %+v", expected, rply) } mp := map[string]interface{}{ @@ -47,70 +50,331 @@ func TestMapEventNewMapEvent(t *testing.T) { "test4": true, "test5": "test", } - expected = MapEvent(mp) - rply = NewMapEvent(mp) - if !reflect.DeepEqual(expected, rply) { + if rply, expected := NewMapEvent(mp), MapEvent(mp); !reflect.DeepEqual(expected, rply) { t.Errorf("Expecting %+v, received: %+v", expected, rply) } } func TestMapEventString(t *testing.T) { me := NewMapEvent(nil) - expected := utils.ToJSON(me) - rply := me.String() - if !reflect.DeepEqual(expected, rply) { + if rply, expected := me.String(), utils.ToJSON(me); !reflect.DeepEqual(expected, rply) { t.Errorf("Expecting %+v, received: %+v", expected, rply) } - expected = utils.ToJSON(mapEv) - rply = mapEv.String() - if !reflect.DeepEqual(expected, rply) { + if rply, expected := mapEv.String(), utils.ToJSON(mapEv); !reflect.DeepEqual(expected, rply) { t.Errorf("Expecting %+v, received: %+v", expected, rply) } } func TestMapEventHasField(t *testing.T) { me := NewMapEvent(nil) - expected := false - rply := me.HasField("test1") - if !reflect.DeepEqual(expected, rply) { - t.Errorf("Expecting %+v, received: %+v", expected, rply) + if rply := me.HasField("test1"); rply { + t.Errorf("Expecting false, received: %+v", rply) } - expected = true - rply = mapEv.HasField("test2") - if !reflect.DeepEqual(expected, rply) { - t.Errorf("Expecting %+v, received: %+v", expected, rply) + if rply := mapEv.HasField("test2"); !rply { + t.Errorf("Expecting true, received: %+v", rply) } - expected = false - rply = mapEv.HasField("test7") - if !reflect.DeepEqual(expected, rply) { - t.Errorf("Expecting %+v, received: %+v", expected, rply) + if rply := mapEv.HasField("test"); rply { + t.Errorf("Expecting false, received: %+v", rply) } } func TestMapEventGetString(t *testing.T) { - if _, err := mapEv.GetString("test"); err != utils.ErrNotFound { + if rply, err := mapEv.GetString("test"); err != utils.ErrNotFound { t.Errorf("Expected: %+v, received: %+v", utils.ErrNotFound, err) + } else if rply != utils.EmptyString { + t.Errorf("Expected error: %+v , received string: %+v", utils.ErrNotFound, rply) } - strI, err := mapEv.GetString("test2") - if strI != "42" || err != nil { - t.Errorf("Expecting %+v, received: %+v", "42", strI) + if rply, err := mapEv.GetString("test2"); err != nil { + t.Error(err) + } else if rply != "42" { + t.Errorf("Expecting %+v, received: %+v", "42", rply) } - strI, err = mapEv.GetString("test1") - if strI != "null" || err != nil { - t.Errorf("Expecting %+v, received: %+v", "null", strI) + if rply, err := mapEv.GetString("test1"); err != nil { + t.Error(err) + } else if rply != utils.EmptyString { + t.Errorf("Expecting , received: %+v", rply) } } func TestMapEventGetStringIgnoreErrors(t *testing.T) { - if s := mapEv.GetStringIgnoreErrors("test"); s != "" { - t.Errorf("Expected: %+v, received: %+v", "", s) + if rply := mapEv.GetStringIgnoreErrors("test"); rply != utils.EmptyString { + t.Errorf("Expected: , received: %+v", rply) } - strI := mapEv.GetStringIgnoreErrors("test2") - if strI != "42" { - t.Errorf("Expecting %+v, received: %+v", "42", strI) + if rply := mapEv.GetStringIgnoreErrors("test2"); rply != "42" { + t.Errorf("Expecting 42, received: %+v", rply) } - strI = mapEv.GetStringIgnoreErrors("test1") - if strI != "null" { - t.Errorf("Expecting %+v, received: %+v", "null", strI) + if rply := mapEv.GetStringIgnoreErrors("test1"); rply != utils.EmptyString { + t.Errorf("Expecting , received: %+v", rply) + } +} + +func TestMapEventGetDuration(t *testing.T) { + if rply, err := mapEv.GetDuration("test"); err != utils.ErrNotFound { + t.Errorf("Expected: %+v, received: %+v", utils.ErrNotFound, err) + } else if rply != time.Duration(0) { + t.Errorf("Expected: %+v , received duration: %+v", time.Duration(0), rply) + } + expected := time.Duration(10 * time.Second) + if rply, err := mapEv.GetDuration("test6"); err != nil { + t.Error(err) + } else if !reflect.DeepEqual(expected, rply) { + t.Errorf("Expecting %+v, received: %+v", expected, rply) + } + expected = time.Duration(42 * time.Second) + if rply, err := mapEv.GetDuration("test7"); err != nil { + t.Error(err) + } else if !reflect.DeepEqual(expected, rply) { + t.Errorf("Expecting %+v, received: %+v", expected, rply) + } + expected = time.Duration(42) + if rply, err := mapEv.GetDuration("test2"); err != nil { + t.Error(err) + } else if !reflect.DeepEqual(expected, rply) { + t.Errorf("Expecting %+v, received: %+v", expected, rply) + } +} + +func TestMapEventGetDurationIgnoreErrors(t *testing.T) { + if rply := mapEv.GetDurationIgnoreErrors("test"); rply != time.Duration(0) { + t.Errorf("Expected: %+v, received: %+v", time.Duration(0), rply) + } + expected := time.Duration(10 * time.Second) + if rply := mapEv.GetDurationIgnoreErrors("test6"); rply != expected { + t.Errorf("Expected: %+v, received: %+v", expected, rply) + } + expected = time.Duration(42 * time.Second) + if rply := mapEv.GetDurationIgnoreErrors("test7"); rply != expected { + t.Errorf("Expected: %+v, received: %+v", expected, rply) + } + expected = time.Duration(42) + if rply := mapEv.GetDurationIgnoreErrors("test2"); rply != expected { + t.Errorf("Expected: %+v, received: %+v", expected, rply) + } +} + +func TestMapEventGetTime(t *testing.T) { + if rply, err := mapEv.GetTime("test", utils.EmptyString); err != utils.ErrNotFound { + t.Errorf("Expected: %+v, received: %+v", utils.ErrNotFound, err) + } else if !rply.IsZero() { + t.Errorf("Expected: January 1, year 1, 00:00:00.000000000 UTC, received: %+v", rply) + } + expected := time.Date(2009, 11, 10, 23, 0, 0, 0, time.UTC) + if rply, err := mapEv.GetTime("test8", utils.EmptyString); err != nil { + t.Error(err) + } else if !reflect.DeepEqual(expected, rply) { + t.Errorf("Expecting %+v, received: %+v", expected, rply) + } + if rply, err := mapEv.GetTime("test9", utils.EmptyString); err != nil { + t.Error(err) + } else if !reflect.DeepEqual(expected, rply) { + t.Errorf("Expecting %+v, received: %+v", expected, rply) + } +} + +func TestMapEventGetTimeIgnoreErrors(t *testing.T) { + if rply := mapEv.GetTimeIgnoreErrors("test", utils.EmptyString); !rply.IsZero() { + t.Errorf("Expected: January 1, year 1, 00:00:00.000000000 UTC, received: %+v", rply) + } + expected := time.Date(2009, 11, 10, 23, 0, 0, 0, time.UTC) + if rply := mapEv.GetTimeIgnoreErrors("test8", utils.EmptyString); rply != expected { + t.Errorf("Expected: %+v, received: %+v", expected, rply) + } + if rply := mapEv.GetTimeIgnoreErrors("test9", utils.EmptyString); rply != expected { + t.Errorf("Expected: %+v, received: %+v", expected, rply) + } +} + +func TestMapEventClone(t *testing.T) { + rply := mapEv.Clone() + if !reflect.DeepEqual(mapEv, rply) { + t.Errorf("Expecting %+v, received: %+v", mapEv, rply) + } + rply["test1"] = "testTest" + if reflect.DeepEqual(mapEv, rply) { + t.Errorf("Expecting different from: %+v, received: %+v", mapEv, rply) + } +} + +func TestMapEventAsMapString(t *testing.T) { + expected := map[string]string{ + "test1": utils.EmptyString, + "test2": "42", + "test3": "42.3", + "test4": "true", + "test5": "test", + } + mpIgnore := utils.StringMap{ + "test6": true, + "test7": false, + "test8": true, + "test9": false, + } + if rply, err := mapEv.AsMapString(mpIgnore); err != nil { + t.Error(err) + } else if !reflect.DeepEqual(expected, rply) { + t.Errorf("Expecting %+v, received: %+v", expected, rply) + } + var mp MapEvent + mp = nil + if rply, err := mp.AsMapString(nil); err != nil { + t.Error(err) + } else if !reflect.DeepEqual(map[string]string{}, rply) { + t.Errorf("Expecting %+v, received: %+v", map[string]string{}, rply) + } + if rply, err := mp.AsMapString(mpIgnore); err != nil { + t.Error(err) + } else if !reflect.DeepEqual(map[string]string{}, rply) { + t.Errorf("Expecting %+v, received: %+v", map[string]string{}, rply) + } +} + +func TestMapEventAsMapStringIgnoreErrors(t *testing.T) { + expected := map[string]string{ + "test1": utils.EmptyString, + "test2": "42", + "test3": "42.3", + "test4": "true", + "test5": "test", + } + mpIgnore := utils.StringMap{ + "test6": true, + "test7": true, + "test8": true, + "test9": true, + } + if rply := mapEv.AsMapStringIgnoreErrors(mpIgnore); !reflect.DeepEqual(expected, rply) { + t.Errorf("Expecting %+v, received: %+v", expected, rply) + } + var mp MapEvent + mp = nil + if rply := mp.AsMapStringIgnoreErrors(nil); !reflect.DeepEqual(map[string]string{}, rply) { + t.Errorf("Expecting %+v, received: %+v", map[string]string{}, rply) + } + if rply := mp.AsMapStringIgnoreErrors(mpIgnore); !reflect.DeepEqual(map[string]string{}, rply) { + t.Errorf("Expecting %+v, received: %+v", map[string]string{}, rply) + } +} + +func TestMapEventAsCDR(t *testing.T) { + me := NewMapEvent(nil) + expected := &CDR{Cost: -1.0, ExtraFields: make(map[string]string)} + if rply, err := me.AsCDR(nil, utils.EmptyString); err != nil { + t.Error(err) + } else if !reflect.DeepEqual(expected, rply) { + t.Errorf("Expecting %+v, received: %+v", expected, rply) + } + cfg, err := config.NewDefaultCGRConfig() + if err != nil { + t.Errorf("Error: %+v", err) + } + expected = &CDR{ + CGRID: "da39a3ee5e6b4b0d3255bfef95601890afd80709", + Cost: -1.0, + RunID: utils.MetaRaw, + ToR: utils.VOICE, + RequestType: cfg.DefaultReqType, + Tenant: cfg.DefaultTenant, + Category: cfg.DefaultCategory, + ExtraFields: make(map[string]string), + } + if rply, err := me.AsCDR(cfg, utils.EmptyString); err != nil { + t.Error(err) + } else if !reflect.DeepEqual(expected, rply) { + t.Errorf("Expecting %+v, received: %+v", expected, rply) + } + me = MapEvent{"SetupTime": "clearly not time string"} + if _, err := me.AsCDR(nil, utils.EmptyString); err == nil { + t.Errorf("Expecting not null error, received: null error") + } + me = MapEvent{"AnswerTime": "clearly not time string"} + if _, err := me.AsCDR(nil, utils.EmptyString); err == nil { + t.Errorf("Expecting not null error, received: null error") + } + me = MapEvent{"Usage": "clearly not duration string"} + if _, err := me.AsCDR(nil, utils.EmptyString); err == nil { + t.Errorf("Expecting not null error, received: null error") + } + me = MapEvent{"Partial": "clearly not bool string"} + if _, err := me.AsCDR(nil, utils.EmptyString); err == nil { + t.Errorf("Expecting not null error, received: null error") + } + me = MapEvent{"PreRated": "clearly not bool string"} + if _, err := me.AsCDR(nil, utils.EmptyString); err == nil { + t.Errorf("Expecting not null error, received: null error") + } + me = MapEvent{"Cost": "clearly not float64 string"} + if _, err := me.AsCDR(nil, utils.EmptyString); err == nil { + t.Errorf("Expecting not null error, received: null error") + } + me = MapEvent{"ExtraField1": 5, "ExtraField2": "extra"} + expected = &CDR{ + Cost: -1.0, + ExtraFields: map[string]string{ + "ExtraField1": "5", + "ExtraField2": "extra", + }} + if rply, err := me.AsCDR(nil, utils.EmptyString); err != nil { + t.Error(err) + } else if !reflect.DeepEqual(expected, rply) { + t.Errorf("Expecting %+v, received: %+v", expected, rply) + } + me = MapEvent{ + "ExtraField1": 5, + "Source": 1001, + "CostSource": "1002", + "ExtraField2": "extra", + } + expected = &CDR{ + CGRID: "da39a3ee5e6b4b0d3255bfef95601890afd80709", + Cost: -1.0, + Source: "1001", + CostSource: "1002", + ExtraFields: map[string]string{ + "ExtraField1": "5", + "ExtraField2": "extra", + }, + RunID: utils.MetaRaw, + ToR: utils.VOICE, + RequestType: cfg.DefaultReqType, + Tenant: cfg.DefaultTenant, + Category: cfg.DefaultCategory, + } + if rply, err := me.AsCDR(cfg, utils.EmptyString); err != nil { + t.Error(err) + } else if !reflect.DeepEqual(expected, rply) { + t.Errorf("Expecting %+v, received: %+v", expected, rply) + } + me = MapEvent{ + "ExtraField1": 5, + "Source": 1001, + "CostSource": "1002", + "ExtraField2": "extra", + "SetupTime": "2009-11-10T23:00:00Z", + "Usage": "42s", + "PreRated": "True", + "Cost": "42.3", + } + expected = &CDR{ + CGRID: "da39a3ee5e6b4b0d3255bfef95601890afd80709", + Cost: 42.3, + Source: "1001", + CostSource: "1002", + PreRated: true, + Usage: time.Duration(42 * time.Second), + SetupTime: time.Date(2009, 11, 10, 23, 0, 0, 0, time.UTC), + ExtraFields: map[string]string{ + "ExtraField1": "5", + "ExtraField2": "extra", + }, + RunID: utils.MetaRaw, + ToR: utils.VOICE, + RequestType: cfg.DefaultReqType, + Tenant: cfg.DefaultTenant, + Category: cfg.DefaultCategory, + } + if rply, err := me.AsCDR(cfg, utils.EmptyString); err != nil { + t.Error(err) + } else if !reflect.DeepEqual(expected, rply) { + t.Errorf("Expecting %+v, received: %+v", expected, rply) } } diff --git a/utils/reflect.go b/utils/reflect.go index 4d59897d0..35b85f58a 100644 --- a/utils/reflect.go +++ b/utils/reflect.go @@ -236,6 +236,8 @@ func IfaceAsBool(itm interface{}) (b bool, err error) { func IfaceAsString(fld interface{}) (out string, err error) { switch fld.(type) { + case nil: + return case int: return strconv.Itoa(fld.(int)), nil case int64: