Coverage tests for ees

ees/ees_test.go

@@ -19,14 +19,131 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>
 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] <CoreS> starting <EventExporterS>"
+	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] <CoreS> shutdown <EventExporterS>"
+	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()

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

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

ees/posterjsonmap_test.go

@@ -19,6 +19,7 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>
 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)
-// 	}
-// }