Coverage tests in ees package and updated Go version in Ansible scripts

ees/elastic.go

@@ -153,18 +153,8 @@ func (eEe *ElasticEe) ExportEvent(cgrEv *utils.CGREvent) (err error) {
 			return
 		}
 		for el := eeReq.OrdNavMP[utils.MetaExp].GetFirstElement(); el != nil; el = el.Next() {
-			var nmIt utils.NMInterface
-			if nmIt, err = eeReq.OrdNavMP[utils.MetaExp].Field(el.Value); err != nil {
-				return
-			}
-			itm, isNMItem := nmIt.(*config.NMItem)
-			if !isNMItem {
-				err = fmt.Errorf("cannot encode reply value: %s, err: not NMItems", utils.ToJSON(el.Value))
-				return
-			}
-			if itm == nil {
-				continue // all attributes, not writable to diameter packet
-			}
+			nmIt, _ := eeReq.OrdNavMP[utils.MetaExp].Field(el.Value)
+			itm := nmIt.(*config.NMItem)
 			valMp[strings.Join(itm.Path, utils.NestingSep)] = utils.IfaceAsString(itm.Data)
 		}
 	}

ees/elastic_test.go

@@ -22,6 +22,7 @@ import (
 	"testing"
 
 	"github.com/cgrates/cgrates/config"
+	"github.com/cgrates/cgrates/engine"
 	"github.com/cgrates/cgrates/utils"
 )
 
@@ -244,3 +245,67 @@ func TestInitCase10(t *testing.T) {
 		t.Errorf("Expected %+v \n but got %+v", utils.ToJSON(eeExpect), utils.ToJSON(ee.opts.WaitForActiveShards))
 	}
 }
+
+func TestElasticExportEvent(t *testing.T) {
+	cgrCfg := config.NewDefaultCGRConfig()
+	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)
+	}
+	eEe, err := NewElasticExporter(cgrCfg, 0, filterS, dc)
+	if err != nil {
+		t.Error(err)
+	}
+	cgrEv.Event = map[string]interface{}{
+		"test1": "value",
+	}
+	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 := `unsupported protocol scheme ""`
+	if err := eEe.ExportEvent(cgrEv); err == nil || err.Error() != errExpect {
+		t.Errorf("Expected %q but got %q", errExpect, err)
+	}
+	cgrCfg.EEsCfg().Exporters[0].ComputeFields()
+	if err := eEe.ExportEvent(cgrEv); err == nil || err.Error() != errExpect {
+		t.Errorf("Expected %q but got %q", errExpect, err)
+	}
+	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 := eEe.ExportEvent(cgrEv); err == nil || err.Error() != errExpect {
+		t.Errorf("Expected %q but received %q", errExpect, err)
+	}
+	eEe.OnEvicted("test", "test")
+}

ees/filecsv.go

@@ -106,6 +106,7 @@ func (fCsv *FileCSVee) ExportEvent(cgrEv *utils.CGREvent) (err error) {
 
 	var csvRecord []string
 	if len(fCsv.cgrCfg.EEsCfg().Exporters[fCsv.cfgIdx].ContentFields()) == 0 {
+		csvRecord = make([]string, 0, len(cgrEv.Event))
 		for _, val := range cgrEv.Event {
 			csvRecord = append(csvRecord, utils.IfaceAsString(val))
 		}
@@ -124,13 +125,7 @@ func (fCsv *FileCSVee) ExportEvent(cgrEv *utils.CGREvent) (err error) {
 		if err = eeReq.SetFields(fCsv.cgrCfg.EEsCfg().Exporters[fCsv.cfgIdx].ContentFields()); err != nil {
 			return
 		}
-		for el := eeReq.OrdNavMP[utils.MetaExp].GetFirstElement(); el != nil; el = el.Next() {
-			var strVal string
-			if strVal, err = eeReq.OrdNavMP[utils.MetaExp].FieldAsString(el.Value.Slice()); err != nil {
-				return
-			}
-			csvRecord = append(csvRecord, strVal)
-		}
+		csvRecord = eeReq.OrdNavMP[utils.MetaExp].OrderedFieldsAsStrings()
 	}
 
 	updateEEMetrics(fCsv.dc, cgrEv.Event, utils.FirstNonEmpty(fCsv.cgrCfg.EEsCfg().Exporters[fCsv.cfgIdx].Timezone,
@@ -143,7 +138,6 @@ func (fCsv *FileCSVee) composeHeader() (err error) {
 	if len(fCsv.cgrCfg.EEsCfg().Exporters[fCsv.cfgIdx].HeaderFields()) == 0 {
 		return
 	}
-	var csvRecord []string
 	oNm := map[string]*utils.OrderedNavigableMap{
 		utils.MetaHdr: utils.NewOrderedNavigableMap(),
 	}
@@ -156,14 +150,7 @@ func (fCsv *FileCSVee) composeHeader() (err error) {
 	if err = eeReq.SetFields(fCsv.cgrCfg.EEsCfg().Exporters[fCsv.cfgIdx].HeaderFields()); err != nil {
 		return
 	}
-	for el := eeReq.OrdNavMP[utils.MetaHdr].GetFirstElement(); el != nil; el = el.Next() {
-		var strVal string
-		if strVal, err = eeReq.OrdNavMP[utils.MetaHdr].FieldAsString(el.Value.Slice()); err != nil {
-			return
-		}
-		csvRecord = append(csvRecord, strVal)
-	}
-	return fCsv.csvWriter.Write(csvRecord)
+	return fCsv.csvWriter.Write(eeReq.OrdNavMP[utils.MetaHdr].OrderedFieldsAsStrings())
 }
 
 // Compose and cache the trailer
@@ -171,7 +158,6 @@ func (fCsv *FileCSVee) composeTrailer() (err error) {
 	if len(fCsv.cgrCfg.EEsCfg().Exporters[fCsv.cfgIdx].TrailerFields()) == 0 {
 		return
 	}
-	var csvRecord []string
 	oNm := map[string]*utils.OrderedNavigableMap{
 		utils.MetaTrl: utils.NewOrderedNavigableMap(),
 	}
@@ -184,14 +170,8 @@ func (fCsv *FileCSVee) composeTrailer() (err error) {
 	if err = eeReq.SetFields(fCsv.cgrCfg.EEsCfg().Exporters[fCsv.cfgIdx].TrailerFields()); err != nil {
 		return
 	}
-	for el := eeReq.OrdNavMP[utils.MetaTrl].GetFirstElement(); el != nil; el = el.Next() {
-		var strVal string
-		if strVal, err = eeReq.OrdNavMP[utils.MetaTrl].FieldAsString(el.Value.Slice()); err != nil {
-			return
-		}
-		csvRecord = append(csvRecord, strVal)
-	}
-	return fCsv.csvWriter.Write(csvRecord)
+
+	return fCsv.csvWriter.Write(eeReq.OrdNavMP[utils.MetaTrl].OrderedFieldsAsStrings())
 }
 
 func (fCsv *FileCSVee) GetMetrics() utils.MapStorage {

ees/filecsv_test.go

@@ -219,11 +219,11 @@ func TestFileCsvExportEvent(t *testing.T) {
 	cgrCfg.EEsCfg().Exporters[fCsv.cfgIdx].Fields = []*config.FCTemplate{
 		{
 			Path: "*exp.1", Type: utils.MetaVariable,
-			Value: config.NewRSRParsersMustCompile("~*req.field1", utils.InfieldSep),
+			Value: config.NewRSRParsersMustCompile("~*req.test1", utils.InfieldSep),
 		},
 		{
 			Path: "*exp.2", Type: utils.MetaVariable,
-			Value: config.NewRSRParsersMustCompile("~*req.field2", utils.InfieldSep),
+			Value: config.NewRSRParsersMustCompile("3", utils.InfieldSep),
 		},
 	}
 	for _, field := range cgrCfg.EEsCfg().Exporters[fCsv.cfgIdx].Fields {
@@ -232,12 +232,18 @@ func TestFileCsvExportEvent(t *testing.T) {
 	if err := fCsv.ExportEvent(cgrEv); err != nil {
 		t.Error(err)
 	}
+	csvNW.Flush()
+	expected := "value\n"
+	if expected != byteBuff.String() {
+		t.Errorf("Expected %q but received %q", expected, byteBuff.String())
+	}
+	byteBuff.Reset()
 	cgrCfg.EEsCfg().Exporters[fCsv.cfgIdx].ComputeFields()
 	if err := fCsv.ExportEvent(cgrEv); err != nil {
 		t.Error(err)
 	}
 	csvNW.Flush()
-	expected := "value\n\n"
+	expected = "value,3\n"
 	if expected != byteBuff.String() {
 		t.Errorf("Expected %q but received %q", expected, byteBuff.String())
 	}
@@ -263,5 +269,5 @@ func TestFileCsvExportEvent(t *testing.T) {
 	if err := fCsv.ExportEvent(cgrEv); err == nil || err.Error() != errExpect {
 		t.Errorf("Expected %q but received %q", errExpect, err)
 	}
-
+	fCsv.OnEvicted("test", "test")
 }

ees/filefwv.go

@@ -95,6 +95,7 @@ func (fFwv *FileFWVee) ExportEvent(cgrEv *utils.CGREvent) (err error) {
 	fFwv.dc[utils.NumberOfEvents] = fFwv.dc[utils.NumberOfEvents].(int64) + 1
 	var records []string
 	if len(fFwv.cgrCfg.EEsCfg().Exporters[fFwv.cfgIdx].ContentFields()) == 0 {
+		records = make([]string, 0, len(cgrEv.Event))
 		for _, val := range cgrEv.Event {
 			records = append(records, utils.IfaceAsString(val))
 		}
@@ -113,22 +114,17 @@ func (fFwv *FileFWVee) ExportEvent(cgrEv *utils.CGREvent) (err error) {
 		if err = eeReq.SetFields(fFwv.cgrCfg.EEsCfg().Exporters[fFwv.cfgIdx].ContentFields()); err != nil {
 			return
 		}
-		for el := eeReq.OrdNavMP[utils.MetaExp].GetFirstElement(); el != nil; el = el.Next() {
-			var strVal string
-			if strVal, err = eeReq.OrdNavMP[utils.MetaExp].FieldAsString(el.Value.Slice()); err != nil {
-				return
-			}
-			records = append(records, strVal)
-		}
+		records = eeReq.OrdNavMP[utils.MetaExp].OrderedFieldsAsStrings()
 	}
 
 	updateEEMetrics(fFwv.dc, cgrEv.Event, utils.FirstNonEmpty(fFwv.cgrCfg.EEsCfg().Exporters[fFwv.cfgIdx].Timezone,
 		fFwv.cgrCfg.GeneralCfg().DefaultTimezone))
-	for _, record := range append(records, "\n") {
+	for _, record := range records {
 		if _, err = io.WriteString(fFwv.file, record); err != nil {
 			return
 		}
 	}
+	_, err = io.WriteString(fFwv.file, "\n")
 	return
 }
 
@@ -137,7 +133,6 @@ func (fFwv *FileFWVee) composeHeader() (err error) {
 	if len(fFwv.cgrCfg.EEsCfg().Exporters[fFwv.cfgIdx].HeaderFields()) == 0 {
 		return
 	}
-	var records []string
 	oNm := map[string]*utils.OrderedNavigableMap{
 		utils.MetaHdr: utils.NewOrderedNavigableMap(),
 	}
@@ -150,18 +145,12 @@ func (fFwv *FileFWVee) composeHeader() (err error) {
 	if err = eeReq.SetFields(fFwv.cgrCfg.EEsCfg().Exporters[fFwv.cfgIdx].HeaderFields()); err != nil {
 		return
 	}
-	for el := eeReq.OrdNavMP[utils.MetaHdr].GetFirstElement(); el != nil; el = el.Next() {
-		var strVal string
-		if strVal, err = eeReq.OrdNavMP[utils.MetaHdr].FieldAsString(el.Value.Slice()); err != nil {
-			return
-		}
-		records = append(records, strVal)
-	}
-	for _, record := range append(records, "\n") {
+	for _, record := range eeReq.OrdNavMP[utils.MetaHdr].OrderedFieldsAsStrings() {
 		if _, err = io.WriteString(fFwv.file, record); err != nil {
 			return
 		}
 	}
+	_, err = io.WriteString(fFwv.file, "\n")
 	return
 }
 
@@ -170,7 +159,6 @@ func (fFwv *FileFWVee) composeTrailer() (err error) {
 	if len(fFwv.cgrCfg.EEsCfg().Exporters[fFwv.cfgIdx].TrailerFields()) == 0 {
 		return
 	}
-	var records []string
 	oNm := map[string]*utils.OrderedNavigableMap{
 		utils.MetaTrl: utils.NewOrderedNavigableMap(),
 	}
@@ -183,18 +171,12 @@ func (fFwv *FileFWVee) composeTrailer() (err error) {
 	if err = eeReq.SetFields(fFwv.cgrCfg.EEsCfg().Exporters[fFwv.cfgIdx].TrailerFields()); err != nil {
 		return
 	}
-	for el := eeReq.OrdNavMP[utils.MetaTrl].GetFirstElement(); el != nil; el = el.Next() {
-		var strVal string
-		if strVal, err = eeReq.OrdNavMP[utils.MetaTrl].FieldAsString(el.Value.Slice()); err != nil {
-			return
-		}
-		records = append(records, strVal)
-	}
-	for _, record := range append(records, "\n") {
+	for _, record := range eeReq.OrdNavMP[utils.MetaTrl].OrderedFieldsAsStrings() {
 		if _, err = io.WriteString(fFwv.file, record); err != nil {
 			return
 		}
 	}
+	_, err = io.WriteString(fFwv.file, "\n")
 	return
 }
 

ees/filefwv_test.go

@@ -55,7 +55,16 @@ func TestFileFwvGetMetrics(t *testing.T) {
 	}
 }
 
-func TestFilveFwvComposeHeader(t *testing.T) {
+// type MyError struct{}
+
+// func (m *MyError) Error() string {
+// 	return "ERR"
+// }
+
+// func (nopCloser) WriteString(w io.Writer, s string) error {
+// 	return &MyError{}
+// }
+func TestFileFwvComposeHeader(t *testing.T) {
 	cgrCfg := config.NewDefaultCGRConfig()
 	newIDb := engine.NewInternalDB(nil, nil, true)
 	newDM := engine.NewDataManager(newIDb, cgrCfg.CacheCfg(), nil)
@@ -116,6 +125,7 @@ func TestFilveFwvComposeHeader(t *testing.T) {
 	if err := fFwv.composeHeader(); err == nil || err.Error() != errExpect {
 		t.Errorf("Expected %q but received %q", errExpect, err)
 	}
+
 }
 
 func TestFileFwvComposeTrailer(t *testing.T) {
@@ -210,11 +220,11 @@ func TestFileFwvExportEvent(t *testing.T) {
 	cgrCfg.EEsCfg().Exporters[fFwv.cfgIdx].Fields = []*config.FCTemplate{
 		{
 			Path: "*exp.1", Type: utils.MetaVariable,
-			Value: config.NewRSRParsersMustCompile("~*req.field1", utils.InfieldSep),
+			Value: config.NewRSRParsersMustCompile("~*req.test1", utils.InfieldSep),
 		},
 		{
 			Path: "*exp.2", Type: utils.MetaVariable,
-			Value: config.NewRSRParsersMustCompile("~*req.field2", utils.InfieldSep),
+			Value: config.NewRSRParsersMustCompile("3", utils.InfieldSep),
 		},
 	}
 	for _, field := range cgrCfg.EEsCfg().Exporters[fFwv.cfgIdx].Fields {
@@ -223,12 +233,18 @@ func TestFileFwvExportEvent(t *testing.T) {
 	if err := fFwv.ExportEvent(cgrEv); err != nil {
 		t.Error(err)
 	}
+	csvNW.Flush()
+	expected := "value\n"
+	if expected != byteBuff.String() {
+		t.Errorf("Expected %q but received %q", expected, byteBuff.String())
+	}
 	cgrCfg.EEsCfg().Exporters[fFwv.cfgIdx].ComputeFields()
+	byteBuff.Reset()
 	if err := fFwv.ExportEvent(cgrEv); err != nil {
 		t.Error(err)
 	}
 	csvNW.Flush()
-	expected := "value\n\n"
+	expected = "value3\n"
 	if expected != byteBuff.String() {
 		t.Errorf("Expected %q but received %q", expected, byteBuff.String())
 	}

ees/httpjsonmap.go

@@ -20,7 +20,6 @@ package ees
 
 import (
 	"encoding/json"
-	"fmt"
 	"net/http"
 	"strings"
 	"sync"
@@ -100,18 +99,8 @@ func (httpEE *HTTPjsonMapEE) ExportEvent(cgrEv *utils.CGREvent) (err error) {
 			return
 		}
 		for el := eeReq.OrdNavMP[utils.MetaExp].GetFirstElement(); el != nil; el = el.Next() {
-			var nmIt utils.NMInterface
-			if nmIt, err = eeReq.OrdNavMP[utils.MetaExp].Field(el.Value); err != nil {
-				return
-			}
-			itm, isNMItem := nmIt.(*config.NMItem)
-			if !isNMItem {
-				err = fmt.Errorf("cannot encode reply value: %s, err: not NMItems", utils.ToJSON(el.Value))
-				return
-			}
-			if itm == nil {
-				continue // all attributes, not writable to diameter packet
-			}
+			nmIt, _ := eeReq.OrdNavMP[utils.MetaExp].Field(el.Value)
+			itm := nmIt.(*config.NMItem)
 			valMp[strings.Join(itm.Path, utils.NestingSep)] = utils.IfaceAsString(itm.Data)
 		}
 		if hdr, err = httpEE.composeHeader(); err != nil {
@@ -157,18 +146,8 @@ func (httpEE *HTTPjsonMapEE) composeHeader() (hdr http.Header, err error) {
 		return
 	}
 	for el := eeReq.OrdNavMP[utils.MetaHdr].GetFirstElement(); el != nil; el = el.Next() {
-		var nmIt utils.NMInterface
-		if nmIt, err = eeReq.OrdNavMP[utils.MetaHdr].Field(el.Value); err != nil {
-			return
-		}
-		itm, isNMItem := nmIt.(*config.NMItem)
-		if !isNMItem {
-			err = fmt.Errorf("cannot encode reply value: %s, err: not NMItems", utils.ToJSON(el.Value))
-			return
-		}
-		if itm == nil {
-			continue // all attributes, not writable to diameter packet
-		}
+		nmIt, _ := eeReq.OrdNavMP[utils.MetaHdr].Field(el.Value) //Safe to ignore error, since the path always exists
+		itm := nmIt.(*config.NMItem)                             //We only store nmItems in the map
 		hdr.Set(strings.Join(itm.Path, utils.NestingSep), utils.IfaceAsString(itm.Data))
 	}
 	return

ees/httpjsonmap_test.go

@@ -0,0 +1,202 @@
+/*
+Real-time Online/Offline Charging System (OerS) for Telecom & ISP environments
+Copyright (C) ITsysCOM GmbH
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+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 ees
+
+import (
+	"reflect"
+	"testing"
+
+	"github.com/cgrates/cgrates/config"
+	"github.com/cgrates/cgrates/engine"
+	"github.com/cgrates/cgrates/utils"
+)
+
+func TestHttpJsonMapID(t *testing.T) {
+	httpEE := &HTTPjsonMapEE{
+		id: "3",
+	}
+	if rcv := httpEE.ID(); !reflect.DeepEqual(rcv, "3") {
+		t.Errorf("Expected %+v but got %+v", "3", rcv)
+	}
+}
+
+func TestHttpJsonMapGetMetrics(t *testing.T) {
+	dc, err := newEEMetrics(utils.FirstNonEmpty(
+		"Local",
+		utils.EmptyString,
+	))
+	if err != nil {
+		t.Error(err)
+	}
+	httpEE := &HTTPjsonMapEE{
+		dc: dc,
+	}
+
+	if rcv := httpEE.GetMetrics(); !reflect.DeepEqual(rcv, httpEE.dc) {
+		t.Errorf("Expected %+v \n but got %+v", utils.ToJSON(rcv), utils.ToJSON(httpEE.dc))
+	}
+}
+
+func TestHttpJsonMapExportEvent(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)
+	}
+
+	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()
+	}
+	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)
+	}
+	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)
+	}
+	httpEE.OnEvicted("test", "test")
+}
+
+func TestHttpJsonMapComposeHeader(t *testing.T) {
+	cgrCfg := config.NewDefaultCGRConfig()
+	cgrCfg.EEsCfg().Exporters[0].Type = utils.MetaHTTPjson
+	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)
+	}
+	httpEE, err := NewHTTPjsonMapEE(cgrCfg, 0, filterS, dc)
+	if err != nil {
+		t.Error(err)
+	}
+	cgrCfg.EEsCfg().Exporters[0].Fields = []*config.FCTemplate{
+		{
+			Path: "*hdr.1", Type: utils.MetaVariable,
+			Value: config.NewRSRParsersMustCompile("field1", utils.InfieldSep),
+		},
+		{
+			Path: "*hdr.2", Type: utils.MetaVariable,
+			Value: config.NewRSRParsersMustCompile("field2", utils.InfieldSep),
+		},
+	}
+	for _, field := range cgrCfg.EEsCfg().Exporters[0].Fields {
+		field.ComputePath()
+	}
+	if _, err := httpEE.composeHeader(); err != nil {
+		t.Error(err)
+	}
+	cgrCfg.EEsCfg().Exporters[0].ComputeFields()
+	if _, err := httpEE.composeHeader(); err != nil {
+		t.Error(err)
+	}
+	cgrCfg.EEsCfg().Exporters[0].Fields = []*config.FCTemplate{
+		{
+			Path: "*hdr.1", Type: utils.MetaVariable,
+			Value:   config.NewRSRParsersMustCompile("field1", utils.InfieldSep),
+			Filters: []string{"*wrong-type"},
+		},
+		{
+			Path: "*hdr.1", Type: utils.MetaVariable,
+			Value:   config.NewRSRParsersMustCompile("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.composeHeader(); err == nil || err.Error() != errExpect {
+		t.Errorf("Expected %q but received %q", errExpect, err)
+	}
+}

ees/httppost.go

@@ -19,7 +19,6 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>
 package ees
 
 import (
-	"fmt"
 	"net/http"
 	"net/url"
 	"strings"
@@ -96,17 +95,8 @@ func (httpPost *HTTPPost) ExportEvent(cgrEv *utils.CGREvent) (err error) {
 			return
 		}
 		for el := eeReq.OrdNavMP[utils.MetaExp].GetFirstElement(); el != nil; el = el.Next() {
-			var nmIt utils.NMInterface
-			if nmIt, err = eeReq.OrdNavMP[utils.MetaExp].Field(el.Value); err != nil {
-				return
-			}
-			itm, isNMItem := nmIt.(*config.NMItem)
-			if !isNMItem {
-				return fmt.Errorf("cannot encode reply value: %s, err: not NMItems", utils.ToJSON(el.Value))
-			}
-			if itm == nil {
-				continue // all attributes, not writable to diameter packet
-			}
+			nmIt, _ := eeReq.OrdNavMP[utils.MetaExp].Field(el.Value)
+			itm := nmIt.(*config.NMItem)
 			urlVals.Set(strings.Join(itm.Path, utils.NestingSep), utils.IfaceAsString(itm.Data))
 		}
 		if hdr, err = httpPost.composeHeader(); err != nil {
@@ -150,18 +140,8 @@ func (httpPost *HTTPPost) composeHeader() (hdr http.Header, err error) {
 		return
 	}
 	for el := eeReq.OrdNavMP[utils.MetaHdr].GetFirstElement(); el != nil; el = el.Next() {
-		var nmIt utils.NMInterface
-		if nmIt, err = eeReq.OrdNavMP[utils.MetaHdr].Field(el.Value); err != nil {
-			return
-		}
-		itm, isNMItem := nmIt.(*config.NMItem)
-		if !isNMItem {
-			err = fmt.Errorf("cannot encode reply value: %s, err: not NMItems", utils.ToJSON(el.Value))
-			return
-		}
-		if itm == nil {
-			continue // all attributes, not writable to diameter packet
-		}
+		nmIt, _ := eeReq.OrdNavMP[utils.MetaHdr].Field(el.Value)
+		itm := nmIt.(*config.NMItem)
 		hdr.Set(strings.Join(itm.Path, utils.NestingSep), utils.IfaceAsString(itm.Data))
 	}
 	return

ees/httppost_test.go

@@ -22,6 +22,8 @@ import (
 	"reflect"
 	"testing"
 
+	"github.com/cgrates/cgrates/config"
+	"github.com/cgrates/cgrates/engine"
 	"github.com/cgrates/cgrates/utils"
 )
 
@@ -50,3 +52,150 @@ func TestHttpPostGetMetrics(t *testing.T) {
 		t.Errorf("Expected %+v \n but got %+v", utils.ToJSON(rcv), utils.ToJSON(httpPost.dc))
 	}
 }
+
+func TestHttpPostExportEvent(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),
+		},
+	}
+	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)
+	}
+	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 TestHttpPostComposeHeader(t *testing.T) {
+	cgrCfg := config.NewDefaultCGRConfig()
+	cgrCfg.EEsCfg().Exporters[0].Type = utils.MetaHTTPPost
+	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)
+	}
+	cgrCfg.EEsCfg().Exporters[0].Fields = []*config.FCTemplate{
+		{
+			Path: "*hdr.1", Type: utils.MetaVariable,
+			Value: config.NewRSRParsersMustCompile("field1", utils.InfieldSep),
+		},
+		{
+			Path: "*hdr.2", Type: utils.MetaVariable,
+			Value: config.NewRSRParsersMustCompile("field2", utils.InfieldSep),
+		},
+	}
+	for _, field := range cgrCfg.EEsCfg().Exporters[0].Fields {
+		field.ComputePath()
+	}
+	if _, err := httpPost.composeHeader(); err != nil {
+		t.Error(err)
+	}
+	cgrCfg.EEsCfg().Exporters[0].ComputeFields()
+	if _, err := httpPost.composeHeader(); err != nil {
+		t.Error(err)
+	}
+	cgrCfg.EEsCfg().Exporters[0].Fields = []*config.FCTemplate{
+		{
+			Path: "*hdr.1", Type: utils.MetaVariable,
+			Value:   config.NewRSRParsersMustCompile("field1", utils.InfieldSep),
+			Filters: []string{"*wrong-type"},
+		},
+		{
+			Path: "*hdr.1", Type: utils.MetaVariable,
+			Value:   config.NewRSRParsersMustCompile("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.composeHeader(); err == nil || err.Error() != errExpect {
+		t.Errorf("Expected %q but received %q", errExpect, err)
+	}
+}

ees/posterjsonmap.go

@@ -20,7 +20,6 @@ package ees
 
 import (
 	"encoding/json"
-	"fmt"
 	"strings"
 	"sync"
 
@@ -111,18 +110,8 @@ func (pstrEE *PosterJSONMapEE) ExportEvent(cgrEv *utils.CGREvent) (err error) {
 			return
 		}
 		for el := eeReq.OrdNavMP[utils.MetaExp].GetFirstElement(); el != nil; el = el.Next() {
-			var nmIt utils.NMInterface
-			if nmIt, err = eeReq.OrdNavMP[utils.MetaExp].Field(el.Value); err != nil {
-				return
-			}
-			itm, isNMItem := nmIt.(*config.NMItem)
-			if !isNMItem {
-				err = fmt.Errorf("cannot encode reply value: %s, err: not NMItems", utils.ToJSON(el.Value))
-				return
-			}
-			if itm == nil {
-				continue // all attributes, not writable to diameter packet
-			}
+			nmIt, _ := eeReq.OrdNavMP[utils.MetaExp].Field(el.Value)
+			itm := nmIt.(*config.NMItem)
 			valMp[strings.Join(itm.Path, utils.NestingSep)] = utils.IfaceAsString(itm.Data)
 		}
 	}

ees/posterjsonmap_test.go

@@ -171,7 +171,7 @@ func TestPosterJsonMapExportEvent(t *testing.T) {
 		},
 		{
 			Path: "*exp.2", Type: utils.MetaVariable,
-			Value: config.NewRSRParsersMustCompile("~*req.field2", utils.InfieldSep),
+			Value: config.NewRSRParsersMustCompile("*req.field2", utils.InfieldSep),
 		},
 	}
 	for _, field := range cgrCfg.EEsCfg().Exporters[pstrEE.cfgIdx].Fields {
@@ -185,5 +185,25 @@ func TestPosterJsonMapExportEvent(t *testing.T) {
 	if err := pstrEE.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),
+			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 := pstrEE.ExportEvent(cgrEv); err == nil || err.Error() != errExpect {
+		t.Errorf("Expected %q but received %q", errExpect, err)
+	}
+	pstrEE.OnEvicted("test", "test")
 }

ees/virtualee_test.go

@@ -115,4 +115,5 @@ func TestVirtualEeExportEvent(t *testing.T) {
 	if err := vEe.ExportEvent(cgrEv); err == nil || err.Error() != errExpect {
 		t.Errorf("Expected %q but received %q", errExpect, err)
 	}
+	vEe.OnEvicted("test", "test")
 }