uppal/cgrates
1
0
Fork 1
mirror of https://github.com/cgrates/cgrates.git synced 2026-02-11 18:16:24 +05:00
Code Issues Packages Projects Releases Wiki Activity

Coverage tests for ees

Browse Source
This commit is contained in:
nickolasdaniel
2021-03-11 15:03:28 +02:00
committed by Dan Christian Bogos
parent f36b543df3
commit 6d2690ec72
7 changed files with 693 additions and 16 deletions
Download Patch File Download Diff File Expand all files Collapse all files

34
config/configsanity_test.go
View File

@@ -1296,7 +1296,41 @@ func TestConfigSanityDataDB(t *testing.T) {
if err := cfg.checkConfigSanity(); err == nil || err.Error() != expected {
t.Errorf("Expecting: %+q received: %+q", expected, err)
}
//RpcConns
cfg.dataDbCfg.RplConns = []string{"test1"}
expected = "<data_db> connection with id: <test1> not defined"
if err := cfg.checkConfigSanity(); err == nil || err.Error() != expected {
t.Errorf("Expecting: %+q received: %+q", expected, err)
}
cfg.dataDbCfg.RplConns = []string{utils.MetaInternal}
cfg.rpcConns[utils.MetaInternal].Conns = []*RemoteHost{
{
Transport: utils.MetaNone,
},
}
expected = "<data_db> unsuported transport <*none> for connection with ID: <*internal>"
if err := cfg.checkConfigSanity(); err == nil || err.Error() != expected {
t.Errorf("Expecting: %+q received: %+q", expected, err)
}
cfg.dataDbCfg.RplConns = []string{}
cfg.dataDbCfg.Items = map[string]*ItemOpt{}
//RmtConns
cfg.dataDbCfg.RmtConns = []string{"test2"}
expected = "<data_db> connection with id: <test2> not defined"
if err := cfg.checkConfigSanity(); err == nil || err.Error() != expected {
t.Errorf("Expecting: %+q received: %+q", expected, err)
}
cfg.dataDbCfg.RmtConns = []string{utils.MetaInternal}
cfg.rpcConns[utils.MetaInternal].Conns = []*RemoteHost{
{
Transport: utils.MetaNone,
},
}
expected = "<data_db> unsuported transport <*none> for connection with ID: <*internal>"
if err := cfg.checkConfigSanity(); err == nil || err.Error() != expected {
t.Errorf("Expecting: %+q received: %+q", expected, err)
}
}
func TestConfigSanityAPIer(t *testing.T) {

38
config/eescfg.go
View File

@@ -223,9 +223,6 @@ func (eeC *EventExporterCfg) loadFromJSONCfg(jsnEec *EventExporterJsonCfg, msgTe
eeC.FieldSep = *jsnEec.Field_separator
}
if jsnEec.Fields != nil {
eeC.headerFields = make([]*FCTemplate, 0)
eeC.contentFields = make([]*FCTemplate, 0)
eeC.trailerFields = make([]*FCTemplate, 0)
eeC.Fields, err = FCTemplatesFromFCTemplatesJSONCfg(*jsnEec.Fields, separator)
if err != nil {
return
@@ -235,19 +232,7 @@ func (eeC *EventExporterCfg) loadFromJSONCfg(jsnEec *EventExporterJsonCfg, msgTe
} else if tpls != nil {
eeC.Fields = tpls
}
for _, field := range eeC.Fields {
switch field.GetPathSlice()[0] {
case utils.MetaHdr:
eeC.headerFields = append(eeC.headerFields, field)
case utils.MetaExp:
eeC.contentFields = append(eeC.contentFields, field)
case utils.MetaTrl:
eeC.trailerFields = append(eeC.trailerFields, field)
}
if strings.HasPrefix(field.GetPathSlice()[0], utils.MetaUCH) { // special cache when loading fields that contains *uch in path
eeC.contentFields = append(eeC.contentFields, field)
}
}
eeC.ComputeFields()
}
if jsnEec.Opts != nil {
for k, v := range jsnEec.Opts {
@@ -257,6 +242,27 @@ func (eeC *EventExporterCfg) loadFromJSONCfg(jsnEec *EventExporterJsonCfg, msgTe
return
}
// ComputeFields will split the fields in header trailer or content
// exported for ees testing
func (eeC *EventExporterCfg) ComputeFields() {
eeC.headerFields = make([]*FCTemplate, 0)
eeC.contentFields = make([]*FCTemplate, 0)
eeC.trailerFields = make([]*FCTemplate, 0)
for _, field := range eeC.Fields {
switch field.GetPathSlice()[0] {
case utils.MetaHdr:
eeC.headerFields = append(eeC.headerFields, field)
case utils.MetaExp:
eeC.contentFields = append(eeC.contentFields, field)
case utils.MetaTrl:
eeC.trailerFields = append(eeC.trailerFields, field)
}
if strings.HasPrefix(field.GetPathSlice()[0], utils.MetaUCH) { // special cache when loading fields that contains *uch in path
eeC.contentFields = append(eeC.contentFields, field)
}
}
}
// HeaderFields returns the fields that have *hdr prefix
func (eeC *EventExporterCfg) HeaderFields() []*FCTemplate {
return eeC.headerFields

215
ees/filecsv_test.go
View File

@@ -19,9 +19,14 @@ along with this program. If not, see <http://www.gnu.org/licenses/>
package ees
import (
"bytes"
"encoding/csv"
"io"
"reflect"
"testing"
"github.com/cgrates/cgrates/config"
"github.com/cgrates/cgrates/engine"
"github.com/cgrates/cgrates/utils"
)
@@ -50,3 +55,213 @@ func TestFileCsvGetMetrics(t *testing.T) {
t.Errorf("Expected %+v \n but got %+v", utils.ToJSON(rcv), utils.ToJSON(fCsv.dc))
}
}
type nopCloser struct {
io.Writer
}
func (nopCloser) Close() error { return nil }
func TestFileCsvComposeHeader(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)
byteBuff := new(bytes.Buffer)
csvNW := csv.NewWriter(byteBuff)
fCsv := &FileCSVee{
id: "string",
cgrCfg: cgrCfg,
cfgIdx: 0,
filterS: filterS,
file: nopCloser{byteBuff},
csvWriter: csvNW,
dc: utils.MapStorage{},
}
cgrCfg.EEsCfg().Exporters[fCsv.cfgIdx].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[fCsv.cfgIdx].Fields {
field.ComputePath()
}
if err := fCsv.composeHeader(); err != nil {
t.Error(err)
}
cgrCfg.EEsCfg().Exporters[fCsv.cfgIdx].ComputeFields()
if err := fCsv.composeHeader(); err != nil {
t.Error(err)
}
csvNW.Flush()
expected := "field1,field2\n"
if expected != byteBuff.String() {
t.Errorf("Expected %q but received %q", expected, byteBuff.String())
}
cgrCfg.EEsCfg().Exporters[fCsv.cfgIdx].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[fCsv.cfgIdx].Fields {
field.ComputePath()
}
cgrCfg.EEsCfg().Exporters[fCsv.cfgIdx].ComputeFields()
byteBuff.Reset()
errExpect := "inline parse error for string: <*wrong-type>"
if err := fCsv.composeHeader(); err == nil || err.Error() != errExpect {
t.Errorf("Expected %q but received %q", errExpect, err)
}
}
func TestFileCsvComposeTrailer(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)
byteBuff := new(bytes.Buffer)
csvNW := csv.NewWriter(byteBuff)
fCsv := &FileCSVee{
id: "string",
cgrCfg: cgrCfg,
cfgIdx: 0,
filterS: filterS,
file: nopCloser{byteBuff},
csvWriter: csvNW,
dc: utils.MapStorage{},
}
cgrCfg.EEsCfg().Exporters[fCsv.cfgIdx].Fields = []*config.FCTemplate{
{
Path: "*trl.1", Type: utils.MetaVariable,
Value: config.NewRSRParsersMustCompile("field1", utils.InfieldSep),
},
{
Path: "*trl.2", Type: utils.MetaVariable,
Value: config.NewRSRParsersMustCompile("field2", utils.InfieldSep),
},
}
for _, field := range cgrCfg.EEsCfg().Exporters[fCsv.cfgIdx].Fields {
field.ComputePath()
}
if err := fCsv.composeTrailer(); err != nil {
t.Error(err)
}
cgrCfg.EEsCfg().Exporters[fCsv.cfgIdx].ComputeFields()
if err := fCsv.composeTrailer(); err != nil {
t.Error(err)
}
csvNW.Flush()
expected := "field1,field2\n"
if expected != byteBuff.String() {
t.Errorf("Expected %q but received %q", expected, byteBuff.String())
}
cgrCfg.EEsCfg().Exporters[fCsv.cfgIdx].Fields = []*config.FCTemplate{
{
Path: "*trl.1", Type: utils.MetaVariable,
Value: config.NewRSRParsersMustCompile("field1", utils.InfieldSep),
Filters: []string{"*wrong-type"},
},
{
Path: "*trl.1", Type: utils.MetaVariable,
Value: config.NewRSRParsersMustCompile("field1", utils.InfieldSep),
Filters: []string{"*wrong-type"},
},
}
for _, field := range cgrCfg.EEsCfg().Exporters[fCsv.cfgIdx].Fields {
field.ComputePath()
}
cgrCfg.EEsCfg().Exporters[fCsv.cfgIdx].ComputeFields()
byteBuff.Reset()
errExpect := "inline parse error for string: <*wrong-type>"
if err := fCsv.composeTrailer(); err == nil || err.Error() != errExpect {
t.Errorf("Expected %q but received %q", errExpect, err)
}
}
func TestFileCsvExportEvent(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)
byteBuff := new(bytes.Buffer)
csvNW := csv.NewWriter(byteBuff)
dc, err := newEEMetrics(utils.FirstNonEmpty(
"Local",
utils.EmptyString,
))
if err != nil {
t.Error(err)
}
fCsv := &FileCSVee{
id: "string",
cgrCfg: cgrCfg,
cfgIdx: 0,
filterS: filterS,
file: nopCloser{byteBuff},
csvWriter: csvNW,
dc: dc,
}
cgrEv.Event = map[string]interface{}{
"test1": "value",
}
cgrCfg.EEsCfg().Exporters[fCsv.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[fCsv.cfgIdx].Fields {
field.ComputePath()
}
if err := fCsv.ExportEvent(cgrEv); err != nil {
t.Error(err)
}
cgrCfg.EEsCfg().Exporters[fCsv.cfgIdx].ComputeFields()
if err := fCsv.ExportEvent(cgrEv); err != nil {
t.Error(err)
}
csvNW.Flush()
expected := "value\n\n"
if expected != byteBuff.String() {
t.Errorf("Expected %q but received %q", expected, byteBuff.String())
}
cgrCfg.EEsCfg().Exporters[fCsv.cfgIdx].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[fCsv.cfgIdx].Fields {
field.ComputePath()
}
cgrCfg.EEsCfg().Exporters[fCsv.cfgIdx].ComputeFields()
byteBuff.Reset()
errExpect := "inline parse error for string: <*wrong-type>"
if err := fCsv.ExportEvent(cgrEv); err == nil || err.Error() != errExpect {
t.Errorf("Expected %q but received %q", errExpect, err)
}
}

204
ees/filefwv_test.go
View File

@@ -19,9 +19,13 @@ along with this program. If not, see <http://www.gnu.org/licenses/>
package ees
import (
"bytes"
"encoding/csv"
"reflect"
"testing"
"github.com/cgrates/cgrates/config"
"github.com/cgrates/cgrates/engine"
"github.com/cgrates/cgrates/utils"
)
@@ -50,3 +54,203 @@ func TestFileFwvGetMetrics(t *testing.T) {
t.Errorf("Expected %+v \n but got %+v", utils.ToJSON(rcv), utils.ToJSON(fFwv.dc))
}
}
func TestFilveFwvComposeHeader(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)
byteBuff := new(bytes.Buffer)
csvNW := csv.NewWriter(byteBuff)
fFwv := &FileFWVee{
id: "string",
cgrCfg: cgrCfg,
cfgIdx: 0,
filterS: filterS,
file: nopCloser{byteBuff},
dc: utils.MapStorage{},
}
cgrCfg.EEsCfg().Exporters[fFwv.cfgIdx].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[fFwv.cfgIdx].Fields {
field.ComputePath()
}
if err := fFwv.composeHeader(); err != nil {
t.Error(err)
}
cgrCfg.EEsCfg().Exporters[fFwv.cfgIdx].ComputeFields()
if err := fFwv.composeHeader(); err != nil {
t.Error(err)
}
csvNW.Flush()
expected := "field1field2\n"
if expected != byteBuff.String() {
t.Errorf("Expected %q but received %q", expected, byteBuff.String())
}
cgrCfg.EEsCfg().Exporters[fFwv.cfgIdx].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[fFwv.cfgIdx].Fields {
field.ComputePath()
}
cgrCfg.EEsCfg().Exporters[fFwv.cfgIdx].ComputeFields()
byteBuff.Reset()
errExpect := "inline parse error for string: <*wrong-type>"
if err := fFwv.composeHeader(); err == nil || err.Error() != errExpect {
t.Errorf("Expected %q but received %q", errExpect, err)
}
}
func TestFileFwvComposeTrailer(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)
byteBuff := new(bytes.Buffer)
csvNW := csv.NewWriter(byteBuff)
fFwv := &FileFWVee{
id: "string",
cgrCfg: cgrCfg,
cfgIdx: 0,
filterS: filterS,
file: nopCloser{byteBuff},
dc: utils.MapStorage{},
}
cgrCfg.EEsCfg().Exporters[fFwv.cfgIdx].Fields = []*config.FCTemplate{
{
Path: "*trl.1", Type: utils.MetaVariable,
Value: config.NewRSRParsersMustCompile("field1", utils.InfieldSep),
},
{
Path: "*trl.2", Type: utils.MetaVariable,
Value: config.NewRSRParsersMustCompile("field2", utils.InfieldSep),
},
}
for _, field := range cgrCfg.EEsCfg().Exporters[fFwv.cfgIdx].Fields {
field.ComputePath()
}
if err := fFwv.composeTrailer(); err != nil {
t.Error(err)
}
cgrCfg.EEsCfg().Exporters[fFwv.cfgIdx].ComputeFields()
if err := fFwv.composeTrailer(); err != nil {
t.Error(err)
}
csvNW.Flush()
expected := "field1field2\n"
if expected != byteBuff.String() {
t.Errorf("Expected %q but received %q", expected, byteBuff.String())
}
cgrCfg.EEsCfg().Exporters[fFwv.cfgIdx].Fields = []*config.FCTemplate{
{
Path: "*trl.1", Type: utils.MetaVariable,
Value: config.NewRSRParsersMustCompile("field1", utils.InfieldSep),
Filters: []string{"*wrong-type"},
},
{
Path: "*trl.1", Type: utils.MetaVariable,
Value: config.NewRSRParsersMustCompile("field1", utils.InfieldSep),
Filters: []string{"*wrong-type"},
},
}
for _, field := range cgrCfg.EEsCfg().Exporters[fFwv.cfgIdx].Fields {
field.ComputePath()
}
cgrCfg.EEsCfg().Exporters[fFwv.cfgIdx].ComputeFields()
byteBuff.Reset()
errExpect := "inline parse error for string: <*wrong-type>"
if err := fFwv.composeTrailer(); err == nil || err.Error() != errExpect {
t.Errorf("Expected %q but received %q", errExpect, err)
}
}
func TestFileFwvExportEvent(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)
byteBuff := new(bytes.Buffer)
csvNW := csv.NewWriter(byteBuff)
dc, err := newEEMetrics(utils.FirstNonEmpty(
"Local",
utils.EmptyString,
))
if err != nil {
t.Error(err)
}
fFwv := &FileFWVee{
id: "string",
cgrCfg: cgrCfg,
cfgIdx: 0,
filterS: filterS,
file: nopCloser{byteBuff},
dc: dc,
}
cgrEv.Event = map[string]interface{}{
"test1": "value",
}
cgrCfg.EEsCfg().Exporters[fFwv.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[fFwv.cfgIdx].Fields {
field.ComputePath()
}
if err := fFwv.ExportEvent(cgrEv); err != nil {
t.Error(err)
}
cgrCfg.EEsCfg().Exporters[fFwv.cfgIdx].ComputeFields()
if err := fFwv.ExportEvent(cgrEv); err != nil {
t.Error(err)
}
csvNW.Flush()
expected := "value\n\n"
if expected != byteBuff.String() {
t.Errorf("Expected %q but received %q", expected, byteBuff.String())
}
cgrCfg.EEsCfg().Exporters[fFwv.cfgIdx].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[fFwv.cfgIdx].Fields {
field.ComputePath()
}
cgrCfg.EEsCfg().Exporters[fFwv.cfgIdx].ComputeFields()
byteBuff.Reset()
errExpect := "inline parse error for string: <*wrong-type>"
if err := fFwv.ExportEvent(cgrEv); err == nil || err.Error() != errExpect {
t.Errorf("Expected %q but received %q", errExpect, err)
}
}

46
ees/posterjsonmap_test.go
View File

@@ -141,3 +141,49 @@ func TestPosterJsonMapNewPosterJSONMapEECase5(t *testing.T) {
t.Errorf("Expected %+v \n but got %+v", utils.ToJSON(pstrJSONExpect), utils.ToJSON(pstrJSON.poster))
}
}
func TestPosterJsonMapExportEvent(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[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()
}
errExpect := "MissingRegion: could not find region configuration"
if err := pstrEE.ExportEvent(cgrEv); err == nil || err.Error() != errExpect {
t.Errorf("Expected %q but received %q", errExpect, err)
}
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)
}
////////
}

54
ees/sql_test.go Normal file
View File

@@ -0,0 +1,54 @@
// +build integration
/*
Real-time Online/Offline Charging System (OCS) 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/utils"
)
func TestSqlID(t *testing.T) {
sqlEe := &SQLEe{
id: "3",
}
if rcv := sqlEe.ID(); !reflect.DeepEqual(rcv, "3") {
t.Errorf("Expected %+v but got %+v", "3", rcv)
}
}
func TestSqlGetMetrics(t *testing.T) {
dc, err := newEEMetrics(utils.FirstNonEmpty(
"Local",
utils.EmptyString,
))
if err != nil {
t.Error(err)
}
sqlEe := &SQLEe{
dc: dc,
}
if rcv := sqlEe.ID(); !reflect.DeepEqual(rcv, "3") {
t.Errorf("Expected %+v but got %+v", "3", rcv)
}
}

118
ees/virtualee_test.go Normal file
View File

@@ -0,0 +1,118 @@
/*
Real-time Online/Offline Charging System (OCS) 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 TestVirtualEeID(t *testing.T) {
vEe := &VirtualEe{
id: "3",
}
if rcv := vEe.ID(); !reflect.DeepEqual(rcv, "3") {
t.Errorf("Expected %+v \n but got %+v", "3", rcv)
}
}
func TestVirtualEeGetMetrics(t *testing.T) {
dc, err := newEEMetrics(utils.FirstNonEmpty(
"Local",
utils.EmptyString,
))
if err != nil {
t.Error(err)
}
vEe := &VirtualEe{
dc: dc,
}
if rcv := vEe.GetMetrics(); !reflect.DeepEqual(rcv, vEe.dc) {
t.Errorf("Expected %+v \n but got %+v", utils.ToJSON(rcv), utils.ToJSON(vEe.dc))
}
}
func TestVirtualEeExportEvent(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)
}
vEe := &VirtualEe{
id: "string",
cgrCfg: cgrCfg,
cfgIdx: 0,
filterS: filterS,
dc: dc,
}
cgrEv.Event = map[string]interface{}{
"test1": "value",
}
cgrCfg.EEsCfg().Exporters[vEe.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[vEe.cfgIdx].Fields {
field.ComputePath()
}
if err := vEe.ExportEvent(cgrEv); err != nil {
t.Error(err)
}
cgrCfg.EEsCfg().Exporters[vEe.cfgIdx].ComputeFields()
if err := vEe.ExportEvent(cgrEv); err != nil {
t.Error(err)
}
cgrCfg.EEsCfg().Exporters[vEe.cfgIdx].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[vEe.cfgIdx].Fields {
field.ComputePath()
}
cgrCfg.EEsCfg().Exporters[vEe.cfgIdx].ComputeFields()
errExpect := "inline parse error for string: <*wrong-type>"
if err := vEe.ExportEvent(cgrEv); err == nil || err.Error() != errExpect {
t.Errorf("Expected %q but received %q", errExpect, err)
}
}