From 62709df691b5c15e07168a7036c07d3dc9303a0e Mon Sep 17 00:00:00 2001 From: nickolasdaniel Date: Tue, 16 Mar 2021 16:48:53 +0200 Subject: [PATCH] Coverage tests for ees --- ees/ees_test.go | 117 ++++++++++++++++++++ ees/httpjsonmap_test.go | 221 +++++++++++++++++++++++++------------- ees/httppost_test.go | 170 ++++++++++++++++++----------- ees/posterjsonmap_test.go | 194 +++++++++++++++++++++++---------- 4 files changed, 508 insertions(+), 194 deletions(-) diff --git a/ees/ees_test.go b/ees/ees_test.go index 0124c1439..cf2d9704f 100644 --- a/ees/ees_test.go +++ b/ees/ees_test.go @@ -19,14 +19,131 @@ along with this program. If not, see package ees import ( + "bytes" + "log" "reflect" + "strings" "testing" "time" + "github.com/cgrates/cgrates/config" "github.com/cgrates/cgrates/engine" "github.com/cgrates/cgrates/utils" + "github.com/cgrates/rpcclient" ) +func TestListenAndServer(t *testing.T) { + cgrCfg := config.NewDefaultCGRConfig() + cgrCfg.EEsCfg().Cache = make(map[string]*config.CacheParamCfg) + cgrCfg.EEsCfg().Cache = map[string]*config.CacheParamCfg{ + utils.MetaFileCSV: { + Limit: -1, + TTL: 5 * time.Second, + }, + utils.MetaNone: { + Limit: 0, + }, + } + newIDb := engine.NewInternalDB(nil, nil, true) + newDM := engine.NewDataManager(newIDb, cgrCfg.CacheCfg(), nil) + filterS := engine.NewFilterS(cgrCfg, nil, newDM) + eeS := NewEventExporterS(cgrCfg, filterS, nil) + stopChan := make(chan struct{}, 1) + cfgRld := make(chan struct{}, 1) + cfgRld <- struct{}{} + go func() { + time.Sleep(10) + stopChan <- struct{}{} + }() + var err error + utils.Logger, err = utils.Newlogger(utils.MetaStdLog, utils.EmptyString) + if err != nil { + t.Error(err) + } + utils.Logger.SetLogLevel(6) + logBuf := new(bytes.Buffer) + log.SetOutput(logBuf) + eeS.ListenAndServe(stopChan, cfgRld) + logExpect := "[INFO] starting " + if rcv := logBuf.String(); !strings.Contains(rcv, logExpect) { + t.Errorf("Expected %q but received %q", logExpect, rcv) + } + logBuf.Reset() +} + +func TestCall(t *testing.T) { + cgrCfg := config.NewDefaultCGRConfig() + newIDb := engine.NewInternalDB(nil, nil, true) + newDM := engine.NewDataManager(newIDb, cgrCfg.CacheCfg(), nil) + filterS := engine.NewFilterS(cgrCfg, nil, newDM) + eeS := NewEventExporterS(cgrCfg, filterS, nil) + errExpect := "UNSUPPORTED_SERVICE_METHOD" + if err := eeS.Call("test", 24532, 43643); err == nil || err.Error() != errExpect { + t.Errorf("Expected %q but received %q", errExpect, err) + } +} + +type testMockEvent struct { + calls map[string]func(args interface{}, reply interface{}) error +} + +func (sT *testMockEvent) Call(method string, arg interface{}, rply interface{}) error { + if call, has := sT.calls[method]; !has { + return rpcclient.ErrUnsupporteServiceMethod + } else { + return call(arg, rply) + } +} +func TestAttrSProcessEvent(t *testing.T) { + testMock := &testMockEvent{ + calls: map[string]func(args interface{}, reply interface{}) error{ + utils.AttributeSv1ProcessEvent: func(args, reply interface{}) error { + rplyEv := &engine.AttrSProcessEventReply{ + AlteredFields: []string{"testcase"}, + } + *reply.(*engine.AttrSProcessEventReply) = *rplyEv + return nil + }, + }, + } + cgrEv := &utils.CGREvent{ + Opts: map[string]interface{}{ + utils.OptsAttributesProcessRuns: "10", + }, + } + cgrCfg := config.NewDefaultCGRConfig() + cgrCfg.EEsNoLksCfg().AttributeSConns = []string{utils.ConcatenatedKey(utils.MetaInternal, utils.MetaAttributes)} + newIDb := engine.NewInternalDB(nil, nil, true) + newDM := engine.NewDataManager(newIDb, cgrCfg.CacheCfg(), nil) + filterS := engine.NewFilterS(cgrCfg, nil, newDM) + clientConn := make(chan rpcclient.ClientConnector, 1) + clientConn <- testMock + connMgr := engine.NewConnManager(cgrCfg, map[string]chan rpcclient.ClientConnector{ + utils.ConcatenatedKey(utils.MetaInternal, utils.MetaAttributes): clientConn, + }) + eeS := NewEventExporterS(cgrCfg, filterS, connMgr) + // cgrEv := &utils.CGREvent{} + if err := eeS.attrSProcessEvent(cgrEv, []string{}, utils.EmptyString); err != nil { + t.Error(err) + } +} + +func TestShutdown(t *testing.T) { + cgrCfg := config.NewDefaultCGRConfig() + newIDb := engine.NewInternalDB(nil, nil, true) + newDM := engine.NewDataManager(newIDb, cgrCfg.CacheCfg(), nil) + filterS := engine.NewFilterS(cgrCfg, nil, newDM) + eeS := NewEventExporterS(cgrCfg, filterS, nil) + logBuf := new(bytes.Buffer) + log.SetOutput(logBuf) + eeS.Shutdown() + logExpect := "[INFO] shutdown " + if rcv := logBuf.String(); !strings.Contains(rcv, logExpect) { + t.Errorf("Expected %q but received %q", logExpect, rcv) + } + logBuf.Reset() +} + func TestUpdateEEMetrics(t *testing.T) { dc, _ := newEEMetrics(utils.EmptyString) tnow := time.Now() diff --git a/ees/httpjsonmap_test.go b/ees/httpjsonmap_test.go index 5a42e1139..8f91cde67 100644 --- a/ees/httpjsonmap_test.go +++ b/ees/httpjsonmap_test.go @@ -78,84 +78,14 @@ func TestHttpJsonMapExportEvent1(t *testing.T) { cgrEv.Event = map[string]interface{}{ "test": "string", } - cgrCfg.EEsCfg().Exporters[0].Fields = []*config.FCTemplate{ - { - Path: "*exp.1", Type: utils.MetaVariable, - Value: config.NewRSRParsersMustCompile("~*req.field1", utils.InfieldSep), - }, - { - Path: "*exp.2", Type: utils.MetaVariable, - Value: config.NewRSRParsersMustCompile("*req.field2", utils.InfieldSep), - }, - } - for _, field := range cgrCfg.EEsCfg().Exporters[0].Fields { - field.ComputePath() - } errExpect := `Post "/var/spool/cgrates/ees": unsupported protocol scheme ""` if err := httpEE.ExportEvent(cgrEv); err == nil || err.Error() != errExpect { t.Errorf("Expected %q but received %q", errExpect, err) } - cgrCfg.EEsCfg().Exporters[0].ComputeFields() - if err := httpEE.ExportEvent(cgrEv); err == nil || err.Error() != errExpect { - t.Errorf("Expected %q but received %q", errExpect, err) + dcExpect := int64(1) + if !reflect.DeepEqual(dcExpect, httpEE.dc[utils.NumberOfEvents]) { + t.Errorf("Expected %q but received %q", dcExpect, httpEE.dc[utils.NumberOfEvents]) } - cgrCfg.EEsCfg().Exporters[0].Fields = []*config.FCTemplate{ - { - Path: "*exp.1", Type: utils.MetaVariable, - Value: config.NewRSRParsersMustCompile("~*req.field1", utils.InfieldSep), - Filters: []string{"*wrong-type"}, - }, - { - Path: "*exp.1", Type: utils.MetaVariable, - Value: config.NewRSRParsersMustCompile("~*req.field1", utils.InfieldSep), - Filters: []string{"*wrong-type"}, - }, - } - for _, field := range cgrCfg.EEsCfg().Exporters[0].Fields { - field.ComputePath() - } - cgrCfg.EEsCfg().Exporters[0].ComputeFields() - errExpect = "inline parse error for string: <*wrong-type>" - if err := httpEE.ExportEvent(cgrEv); err == nil || err.Error() != errExpect { - t.Errorf("Expected %q but received %q", errExpect, err) - } - cgrCfg.EEsCfg().Exporters[0].Fields = []*config.FCTemplate{ - { - Path: "*exp.1", Type: utils.MetaVariable, - Value: config.NewRSRParsersMustCompile("~*req.field1", utils.InfieldSep), - }, - { - Path: "*exp.2", Type: utils.MetaVariable, - Value: config.NewRSRParsersMustCompile("~*req.field2", utils.InfieldSep), - }, - { - Path: "*hdr.1", Type: utils.MetaVariable, - Value: config.NewRSRParsersMustCompile("~*req.field2", utils.InfieldSep), - Filters: []string{"*wrong-type"}, - }, - } - for _, field := range cgrCfg.EEsCfg().Exporters[0].Fields { - field.ComputePath() - } - cgrCfg.EEsCfg().Exporters[0].ComputeFields() - errExpect = "inline parse error for string: <*wrong-type>" - if err := httpEE.ExportEvent(cgrEv); err == nil || err.Error() != errExpect { - t.Errorf("Expected %q but received %q", errExpect, err) - } - //test marshal invalid input - cgrEv.Event = map[string]interface{}{ - "test": make(chan int), - } - cgrCfg.EEsCfg().Exporters[0].Fields = []*config.FCTemplate{{}} - for _, field := range cgrCfg.EEsCfg().Exporters[0].Fields { - field.ComputePath() - } - cgrCfg.EEsCfg().Exporters[0].ComputeFields() - errExpect = "json: unsupported type: chan int" - if err := httpEE.ExportEvent(cgrEv); err == nil || err.Error() != errExpect { - t.Errorf("Expected %q but received %q", errExpect, err) - } - httpEE.OnEvicted("test", "test") } func TestHttpJsonMapExportEvent2(t *testing.T) { @@ -212,6 +142,151 @@ func TestHttpJsonMapExportEvent2(t *testing.T) { if err := httpEE.ExportEvent(cgrEv); err != nil { t.Error(err) } + dcExpect := int64(1) + if !reflect.DeepEqual(dcExpect, httpEE.dc[utils.NumberOfEvents]) { + t.Errorf("Expected %q but received %q", dcExpect, httpEE.dc[utils.NumberOfEvents]) + } +} + +func TestHttpJsonMapExportEvent3(t *testing.T) { + cgrCfg := config.NewDefaultCGRConfig() + cgrCfg.EEsCfg().Exporters[0].Type = utils.MetaSQSjsonMap + cgrEv := new(utils.CGREvent) + newIDb := engine.NewInternalDB(nil, nil, true) + newDM := engine.NewDataManager(newIDb, cgrCfg.CacheCfg(), nil) + filterS := engine.NewFilterS(cgrCfg, nil, newDM) + dc, err := newEEMetrics(utils.FirstNonEmpty( + "Local", + utils.EmptyString, + )) + httpEE, err := NewHTTPjsonMapEE(cgrCfg, 0, filterS, dc) + if err != nil { + t.Error(err) + } + cgrEv.Event = map[string]interface{}{ + "test": "string", + } + cgrCfg.EEsCfg().Exporters[0].Fields = []*config.FCTemplate{ + { + Path: "*exp.1", Type: utils.MetaVariable, + Value: config.NewRSRParsersMustCompile("~*req.field1", utils.InfieldSep), + Filters: []string{"*wrong-type"}, + }, + { + Path: "*exp.1", Type: utils.MetaVariable, + Value: config.NewRSRParsersMustCompile("~*req.field1", utils.InfieldSep), + Filters: []string{"*wrong-type"}, + }, + } + for _, field := range cgrCfg.EEsCfg().Exporters[0].Fields { + field.ComputePath() + } + cgrCfg.EEsCfg().Exporters[0].ComputeFields() + errExpect := "inline parse error for string: <*wrong-type>" + if err := httpEE.ExportEvent(cgrEv); err == nil || err.Error() != errExpect { + t.Errorf("Expected %q but received %q", errExpect, err) + } + dcExpect := int64(1) + if !reflect.DeepEqual(dcExpect, httpEE.dc[utils.NumberOfEvents]) { + t.Errorf("Expected %q but received %q", dcExpect, httpEE.dc[utils.NumberOfEvents]) + } +} +func TestHttpJsonMapExportEvent4(t *testing.T) { + cgrCfg := config.NewDefaultCGRConfig() + cgrCfg.EEsCfg().Exporters[0].Type = utils.MetaSQSjsonMap + cgrEv := new(utils.CGREvent) + newIDb := engine.NewInternalDB(nil, nil, true) + newDM := engine.NewDataManager(newIDb, cgrCfg.CacheCfg(), nil) + filterS := engine.NewFilterS(cgrCfg, nil, newDM) + dc, err := newEEMetrics(utils.FirstNonEmpty( + "Local", + utils.EmptyString, + )) + httpEE, err := NewHTTPjsonMapEE(cgrCfg, 0, filterS, dc) + if err != nil { + t.Error(err) + } + cgrEv.Event = map[string]interface{}{ + "test": "string", + } + cgrCfg.EEsCfg().Exporters[0].Fields = []*config.FCTemplate{ + { + Path: "*exp.1", Type: utils.MetaVariable, + Value: config.NewRSRParsersMustCompile("~*req.field1", utils.InfieldSep), + }, + { + Path: "*exp.2", Type: utils.MetaVariable, + Value: config.NewRSRParsersMustCompile("~*req.field2", utils.InfieldSep), + }, + { + Path: "*hdr.1", Type: utils.MetaVariable, + Value: config.NewRSRParsersMustCompile("~*req.field2", utils.InfieldSep), + Filters: []string{"*wrong-type"}, + }, + } + for _, field := range cgrCfg.EEsCfg().Exporters[0].Fields { + field.ComputePath() + } + cgrCfg.EEsCfg().Exporters[0].ComputeFields() + errExpect := "inline parse error for string: <*wrong-type>" + if err := httpEE.ExportEvent(cgrEv); err == nil || err.Error() != errExpect { + t.Errorf("Expected %q but received %q", errExpect, err) + } + dcExpect := int64(1) + if !reflect.DeepEqual(dcExpect, httpEE.dc[utils.NumberOfEvents]) { + t.Errorf("Expected %q but received %q", dcExpect, httpEE.dc[utils.NumberOfEvents]) + } +} + +func TestHttpJsonMapExportEvent5(t *testing.T) { + cgrCfg := config.NewDefaultCGRConfig() + cgrCfg.EEsCfg().Exporters[0].Type = utils.MetaSQSjsonMap + cgrEv := new(utils.CGREvent) + newIDb := engine.NewInternalDB(nil, nil, true) + newDM := engine.NewDataManager(newIDb, cgrCfg.CacheCfg(), nil) + filterS := engine.NewFilterS(cgrCfg, nil, newDM) + dc, err := newEEMetrics(utils.FirstNonEmpty( + "Local", + utils.EmptyString, + )) + httpEE, err := NewHTTPjsonMapEE(cgrCfg, 0, filterS, dc) + if err != nil { + t.Error(err) + } + cgrEv.Event = map[string]interface{}{ + "test": "string", + } + cgrCfg.EEsCfg().Exporters[0].Fields = []*config.FCTemplate{ + { + Path: "*exp.1", Type: utils.MetaVariable, + Value: config.NewRSRParsersMustCompile("~*req.field1", utils.InfieldSep), + }, + { + Path: "*exp.2", Type: utils.MetaVariable, + Value: config.NewRSRParsersMustCompile("~*req.field2", utils.InfieldSep), + }, + } + for _, field := range cgrCfg.EEsCfg().Exporters[0].Fields { + field.ComputePath() + } + cgrCfg.EEsCfg().Exporters[0].ComputeFields() + cgrEv.Event = map[string]interface{}{ + "test": make(chan int), + } + cgrCfg.EEsCfg().Exporters[0].Fields = []*config.FCTemplate{{}} + for _, field := range cgrCfg.EEsCfg().Exporters[0].Fields { + field.ComputePath() + } + cgrCfg.EEsCfg().Exporters[0].ComputeFields() + errExpect := "json: unsupported type: chan int" + if err := httpEE.ExportEvent(cgrEv); err == nil || err.Error() != errExpect { + t.Errorf("Expected %q but received %q", errExpect, err) + } + dcExpect := int64(1) + if !reflect.DeepEqual(dcExpect, httpEE.dc[utils.NumberOfEvents]) { + t.Errorf("Expected %q but received %q", dcExpect, httpEE.dc[utils.NumberOfEvents]) + } + httpEE.OnEvicted("test", "test") } func TestHttpJsonMapComposeHeader(t *testing.T) { diff --git a/ees/httppost_test.go b/ees/httppost_test.go index f4d78d186..d43031d9a 100644 --- a/ees/httppost_test.go +++ b/ees/httppost_test.go @@ -77,71 +77,14 @@ func TestHttpPostExportEvent(t *testing.T) { cgrEv.Event = map[string]interface{}{ "Test1": 3, } - cgrCfg.EEsCfg().Exporters[0].Fields = []*config.FCTemplate{ - { - Path: "*exp.1", Type: utils.MetaVariable, - Value: config.NewRSRParsersMustCompile("~*req.field1", utils.InfieldSep), - }, - { - Path: "*exp.2", Type: utils.MetaVariable, - Value: config.NewRSRParsersMustCompile("*req.field2", utils.InfieldSep), - }, - } - for _, field := range cgrCfg.EEsCfg().Exporters[0].Fields { - field.ComputePath() - } errExpect := `Post "/var/spool/cgrates/ees": unsupported protocol scheme ""` if err := httpPost.ExportEvent(cgrEv); err == nil || err.Error() != errExpect { t.Errorf("Expected %q but received %q", errExpect, err) } - cgrCfg.EEsCfg().Exporters[0].ComputeFields() - if err := httpPost.ExportEvent(cgrEv); err == nil || err.Error() != errExpect { - t.Errorf("Expected %q but received %q", errExpect, err) + dcExpect := int64(1) + if !reflect.DeepEqual(dcExpect, httpPost.dc[utils.NumberOfEvents]) { + t.Errorf("Expected %q but received %q", dcExpect, httpPost.dc[utils.NumberOfEvents]) } - cgrCfg.EEsCfg().Exporters[0].Fields = []*config.FCTemplate{ - { - Path: "*exp.1", Type: utils.MetaVariable, - Value: config.NewRSRParsersMustCompile("~*req.field1", utils.InfieldSep), - Filters: []string{"*wrong-type"}, - }, - { - Path: "*exp.1", Type: utils.MetaVariable, - Value: config.NewRSRParsersMustCompile("~*req.field1", utils.InfieldSep), - Filters: []string{"*wrong-type"}, - }, - } - for _, field := range cgrCfg.EEsCfg().Exporters[0].Fields { - field.ComputePath() - } - cgrCfg.EEsCfg().Exporters[0].ComputeFields() - errExpect = "inline parse error for string: <*wrong-type>" - if err := httpPost.ExportEvent(cgrEv); err == nil || err.Error() != errExpect { - t.Errorf("Expected %q but received %q", errExpect, err) - } - cgrCfg.EEsCfg().Exporters[0].Fields = []*config.FCTemplate{ - { - Path: "*exp.1", Type: utils.MetaVariable, - Value: config.NewRSRParsersMustCompile("~*req.field1", utils.InfieldSep), - }, - { - Path: "*exp.2", Type: utils.MetaVariable, - Value: config.NewRSRParsersMustCompile("~*req.field2", utils.InfieldSep), - }, - { - Path: "*hdr.1", Type: utils.MetaVariable, - Value: config.NewRSRParsersMustCompile("~*req.field2", utils.InfieldSep), - Filters: []string{"*wrong-type"}, - }, - } - for _, field := range cgrCfg.EEsCfg().Exporters[0].Fields { - field.ComputePath() - } - cgrCfg.EEsCfg().Exporters[0].ComputeFields() - errExpect = "inline parse error for string: <*wrong-type>" - if err := httpPost.ExportEvent(cgrEv); err == nil || err.Error() != errExpect { - t.Errorf("Expected %q but received %q", errExpect, err) - } - httpPost.OnEvicted("test", "test") } func TestHttpPostExportEvent2(t *testing.T) { @@ -158,11 +101,6 @@ func TestHttpPostExportEvent2(t *testing.T) { if err != nil { t.Error(err) } - // hdrExpect := map[string][]string { - // "Accept-Encoding": []string{"gzip"}, - // "Content-Type": []string{"application/x-www-form-urlencoded"}, - - // } bodyExpect := "2=%2Areq.field2" srv := httptest.NewServer(http.HandlerFunc(func(rw http.ResponseWriter, r *http.Request) { defer r.Body.Close() @@ -201,6 +139,108 @@ func TestHttpPostExportEvent2(t *testing.T) { if err := httpPost.ExportEvent(cgrEv); err != nil { t.Error(err) } + dcExpect := int64(1) + if !reflect.DeepEqual(dcExpect, httpPost.dc[utils.NumberOfEvents]) { + t.Errorf("Expected %q but received %q", dcExpect, httpPost.dc[utils.NumberOfEvents]) + } +} + +func TestHttpPostExportEvent3(t *testing.T) { + cgrCfg := config.NewDefaultCGRConfig() + cgrCfg.EEsCfg().Exporters[0].Type = utils.MetaHTTPPost + cgrEv := new(utils.CGREvent) + newIDb := engine.NewInternalDB(nil, nil, true) + newDM := engine.NewDataManager(newIDb, cgrCfg.CacheCfg(), nil) + filterS := engine.NewFilterS(cgrCfg, nil, newDM) + dc, err := newEEMetrics(utils.FirstNonEmpty( + "Local", + utils.EmptyString, + )) + if err != nil { + t.Error(err) + } + httpPost, err := NewHTTPPostEe(cgrCfg, 0, filterS, dc) + if err != nil { + t.Error(err) + } + cgrEv.Event = map[string]interface{}{ + "Test1": 3, + } + cgrCfg.EEsCfg().Exporters[0].Fields = []*config.FCTemplate{ + { + Path: "*exp.1", Type: utils.MetaVariable, + Value: config.NewRSRParsersMustCompile("~*req.field1", utils.InfieldSep), + Filters: []string{"*wrong-type"}, + }, + { + Path: "*exp.1", Type: utils.MetaVariable, + Value: config.NewRSRParsersMustCompile("~*req.field1", utils.InfieldSep), + Filters: []string{"*wrong-type"}, + }, + } + for _, field := range cgrCfg.EEsCfg().Exporters[0].Fields { + field.ComputePath() + } + cgrCfg.EEsCfg().Exporters[0].ComputeFields() + errExpect := "inline parse error for string: <*wrong-type>" + if err := httpPost.ExportEvent(cgrEv); err == nil || err.Error() != errExpect { + t.Errorf("Expected %q but received %q", errExpect, err) + } + dcExpect := int64(1) + if !reflect.DeepEqual(dcExpect, httpPost.dc[utils.NumberOfEvents]) { + t.Errorf("Expected %q but received %q", dcExpect, httpPost.dc[utils.NumberOfEvents]) + } +} + +func TestHttpPostExportEvent4(t *testing.T) { + cgrCfg := config.NewDefaultCGRConfig() + cgrCfg.EEsCfg().Exporters[0].Type = utils.MetaHTTPPost + cgrEv := new(utils.CGREvent) + newIDb := engine.NewInternalDB(nil, nil, true) + newDM := engine.NewDataManager(newIDb, cgrCfg.CacheCfg(), nil) + filterS := engine.NewFilterS(cgrCfg, nil, newDM) + dc, err := newEEMetrics(utils.FirstNonEmpty( + "Local", + utils.EmptyString, + )) + if err != nil { + t.Error(err) + } + httpPost, err := NewHTTPPostEe(cgrCfg, 0, filterS, dc) + if err != nil { + t.Error(err) + } + cgrEv.Event = map[string]interface{}{ + "Test1": 3, + } + cgrCfg.EEsCfg().Exporters[0].Fields = []*config.FCTemplate{ + { + Path: "*exp.1", Type: utils.MetaVariable, + Value: config.NewRSRParsersMustCompile("~*req.field1", utils.InfieldSep), + }, + { + Path: "*exp.2", Type: utils.MetaVariable, + Value: config.NewRSRParsersMustCompile("~*req.field2", utils.InfieldSep), + }, + { + Path: "*hdr.1", Type: utils.MetaVariable, + Value: config.NewRSRParsersMustCompile("~*req.field2", utils.InfieldSep), + Filters: []string{"*wrong-type"}, + }, + } + for _, field := range cgrCfg.EEsCfg().Exporters[0].Fields { + field.ComputePath() + } + cgrCfg.EEsCfg().Exporters[0].ComputeFields() + errExpect := "inline parse error for string: <*wrong-type>" + if err := httpPost.ExportEvent(cgrEv); err == nil || err.Error() != errExpect { + t.Errorf("Expected %q but received %q", errExpect, err) + } + dcExpect := int64(1) + if !reflect.DeepEqual(dcExpect, httpPost.dc[utils.NumberOfEvents]) { + t.Errorf("Expected %q but received %q", dcExpect, httpPost.dc[utils.NumberOfEvents]) + } + httpPost.OnEvicted("test", "test") } func TestHttpPostComposeHeader(t *testing.T) { diff --git a/ees/posterjsonmap_test.go b/ees/posterjsonmap_test.go index 6f6b290c2..430d8a60c 100644 --- a/ees/posterjsonmap_test.go +++ b/ees/posterjsonmap_test.go @@ -19,6 +19,7 @@ along with this program. If not, see package ees import ( + "encoding/json" "reflect" "testing" @@ -181,10 +182,113 @@ func TestPosterJsonMapExportEvent(t *testing.T) { if err := pstrEE.ExportEvent(cgrEv); err == nil || err.Error() != errExpect { t.Errorf("Expected %q but received %q", errExpect, err) } + dcExpect := int64(1) + if !reflect.DeepEqual(dcExpect, pstrEE.dc[utils.NumberOfEvents]) { + t.Errorf("Expected %q but received %q", dcExpect, pstrEE.dc[utils.NumberOfEvents]) + } cgrCfg.EEsCfg().Exporters[pstrEE.cfgIdx].ComputeFields() if err := pstrEE.ExportEvent(cgrEv); err == nil || err.Error() != errExpect { t.Errorf("Expected %q but received %q", errExpect, err) } + dcExpect = int64(2) + if !reflect.DeepEqual(dcExpect, pstrEE.dc[utils.NumberOfEvents]) { + t.Errorf("Expected %q but received %q", dcExpect, pstrEE.dc[utils.NumberOfEvents]) + } +} + +type testPoster struct { + body []byte +} + +func (pstr *testPoster) Close() {} +func (pstr *testPoster) Post(body []byte, key string) error { + pstr.body = body + return nil +} +func TestPosterJsonMapExportEvent1(t *testing.T) { + cgrCfg := config.NewDefaultCGRConfig() + cgrCfg.EEsCfg().Exporters[0].Type = utils.MetaAMQPjsonMap + cgrEv := new(utils.CGREvent) + newIDb := engine.NewInternalDB(nil, nil, true) + newDM := engine.NewDataManager(newIDb, cgrCfg.CacheCfg(), nil) + filterS := engine.NewFilterS(cgrCfg, nil, newDM) + dc, err := newEEMetrics(utils.FirstNonEmpty( + "Local", + utils.EmptyString, + )) + if err != nil { + t.Error(err) + } + //// + //// + tstPstr := &testPoster{} + pstrEE := &PosterJSONMapEE{ + id: cgrCfg.EEsCfg().Exporters[0].ID, + cgrCfg: cgrCfg, + cfgIdx: 0, + filterS: filterS, + dc: dc, + poster: tstPstr, + } + // pstrEE.poster = tstPstr + cgrEv.Event = map[string]interface{}{ + "test": "string", + } + cgrCfg.EEsCfg().Exporters[0].Fields = []*config.FCTemplate{ + { + Path: "*exp.1", Type: utils.MetaVariable, + Value: config.NewRSRParsersMustCompile("~*req.field1", utils.InfieldSep), + }, + { + Path: "*exp.2", Type: utils.MetaVariable, + Value: config.NewRSRParsersMustCompile("*req.field2", utils.InfieldSep), + }, + } + for _, field := range cgrCfg.EEsCfg().Exporters[0].Fields { + field.ComputePath() + } + cgrCfg.EEsCfg().Exporters[0].ComputeFields() + if err := pstrEE.ExportEvent(cgrEv); err != nil { + t.Error(err) + } + dcExpect := int64(1) + if !reflect.DeepEqual(dcExpect, pstrEE.dc[utils.NumberOfEvents]) { + t.Errorf("Expected %q but received %q", dcExpect, pstrEE.dc[utils.NumberOfEvents]) + } + bodyExpect := map[string]interface{}{ + "2": "*req.field2", + } + var rcv map[string]interface{} + if err := json.Unmarshal(tstPstr.body, &rcv); err != nil { + t.Fatal(err) + } + if !reflect.DeepEqual(rcv, bodyExpect) { + t.Errorf("Expected %s but received %s", utils.ToJSON(bodyExpect), utils.ToJSON(rcv)) + } +} + +func TestPosterJsonMapExportEvent2(t *testing.T) { + cgrCfg := config.NewDefaultCGRConfig() + cgrCfg.EEsCfg().Exporters[0].Type = utils.MetaSQSjsonMap + cgrEv := new(utils.CGREvent) + newIDb := engine.NewInternalDB(nil, nil, true) + newDM := engine.NewDataManager(newIDb, cgrCfg.CacheCfg(), nil) + filterS := engine.NewFilterS(cgrCfg, nil, newDM) + dc, err := newEEMetrics(utils.FirstNonEmpty( + "Local", + utils.EmptyString, + )) + if err != nil { + t.Error(err) + } + + pstrEE, err := NewPosterJSONMapEE(cgrCfg, 0, filterS, dc) + if err != nil { + t.Error(err) + } + cgrEv.Event = map[string]interface{}{ + "test": "string", + } cgrCfg.EEsCfg().Exporters[0].Fields = []*config.FCTemplate{ { Path: "*exp.1", Type: utils.MetaVariable, @@ -201,11 +305,38 @@ func TestPosterJsonMapExportEvent(t *testing.T) { field.ComputePath() } cgrCfg.EEsCfg().Exporters[0].ComputeFields() - errExpect = "inline parse error for string: <*wrong-type>" + errExpect := "inline parse error for string: <*wrong-type>" if err := pstrEE.ExportEvent(cgrEv); err == nil || err.Error() != errExpect { t.Errorf("Expected %q but received %q", errExpect, err) } - //test marshal invalid input + dcExpect := int64(1) + if !reflect.DeepEqual(dcExpect, pstrEE.dc[utils.NumberOfEvents]) { + t.Errorf("Expected %q but received %q", dcExpect, pstrEE.dc[utils.NumberOfEvents]) + } +} + +func TestPosterJsonMapExportEvent3(t *testing.T) { + cgrCfg := config.NewDefaultCGRConfig() + cgrCfg.EEsCfg().Exporters[0].Type = utils.MetaSQSjsonMap + cgrEv := new(utils.CGREvent) + newIDb := engine.NewInternalDB(nil, nil, true) + newDM := engine.NewDataManager(newIDb, cgrCfg.CacheCfg(), nil) + filterS := engine.NewFilterS(cgrCfg, nil, newDM) + dc, err := newEEMetrics(utils.FirstNonEmpty( + "Local", + utils.EmptyString, + )) + if err != nil { + t.Error(err) + } + + pstrEE, err := NewPosterJSONMapEE(cgrCfg, 0, filterS, dc) + if err != nil { + t.Error(err) + } + cgrEv.Event = map[string]interface{}{ + "test": "string", + } cgrEv.Event = map[string]interface{}{ "test": make(chan int), } @@ -214,62 +345,13 @@ func TestPosterJsonMapExportEvent(t *testing.T) { field.ComputePath() } cgrCfg.EEsCfg().Exporters[0].ComputeFields() - errExpect = "json: unsupported type: chan int" + errExpect := "json: unsupported type: chan int" if err := pstrEE.ExportEvent(cgrEv); err == nil || err.Error() != errExpect { t.Errorf("Expected %q but received %q", errExpect, err) } + dcExpect := int64(1) + if !reflect.DeepEqual(dcExpect, pstrEE.dc[utils.NumberOfEvents]) { + t.Errorf("Expected %q but received %q", dcExpect, pstrEE.dc[utils.NumberOfEvents]) + } pstrEE.OnEvicted("test", "test") } - -// func TestPosterJsonMapExportEvent2(t *testing.T) { -// cgrCfg := config.NewDefaultCGRConfig() -// cgrCfg.EEsCfg().Exporters[0].Type = utils.MetaSQSjsonMap -// cgrEv := new(utils.CGREvent) -// newIDb := engine.NewInternalDB(nil, nil, true) -// newDM := engine.NewDataManager(newIDb, cgrCfg.CacheCfg(), nil) -// filterS := engine.NewFilterS(cgrCfg, nil, newDM) -// dc, err := newEEMetrics(utils.FirstNonEmpty( -// "Local", -// utils.EmptyString, -// )) -// if err != nil { -// t.Error(err) -// } -// srv := httptest.NewServer(http.HandlerFunc(func(rw http.ResponseWriter, r *http.Request) { -// defer r.Body.Close() -// // body, err := io.ReadAll(r.Body) -// // if err != nil { -// // t.Error(err) -// // } -// // if strBody := string(body); strBody != bodyExpect { -// // t.Errorf("Expected %q but received %q", bodyExpect, strBody) -// // } -// rw.WriteHeader(http.StatusOK) -// })) -// defer srv.Close() -// cgrCfg.EEsCfg().Exporters[0].ExportPath = srv.URL + "/" -// pstrEE, err := NewPosterJSONMapEE(cgrCfg, 0, filterS, dc) -// if err != nil { -// t.Error(err) -// } -// cgrEv.Event = map[string]interface{}{ -// "test": "string", -// } -// cgrCfg.EEsCfg().Exporters[pstrEE.cfgIdx].Fields = []*config.FCTemplate{ -// { -// Path: "*exp.1", Type: utils.MetaVariable, -// Value: config.NewRSRParsersMustCompile("~*req.field1", utils.InfieldSep), -// }, -// { -// Path: "*exp.2", Type: utils.MetaVariable, -// Value: config.NewRSRParsersMustCompile("*req.field2", utils.InfieldSep), -// }, -// } -// for _, field := range cgrCfg.EEsCfg().Exporters[pstrEE.cfgIdx].Fields { -// field.ComputePath() -// } -// cgrCfg.EEsCfg().Exporters[pstrEE.cfgIdx].ComputeFields() -// if err := pstrEE.ExportEvent(cgrEv); err != nil { -// t.Error(err) -// } -// }