mirror of
https://github.com/cgrates/cgrates.git
synced 2026-02-14 12:49:54 +05:00
592 lines
16 KiB
Go
592 lines
16 KiB
Go
/*
|
|
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 engine
|
|
|
|
import (
|
|
"reflect"
|
|
"testing"
|
|
|
|
"github.com/cgrates/birpc"
|
|
"github.com/cgrates/birpc/context"
|
|
"github.com/cgrates/cgrates/config"
|
|
"github.com/cgrates/cgrates/utils"
|
|
"github.com/segmentio/kafka-go"
|
|
)
|
|
|
|
func TestLoggerNewExportLogger(t *testing.T) {
|
|
cfg := config.NewDefaultCGRConfig()
|
|
cfg.LoggerCfg().Level = 7
|
|
cfg.GeneralCfg().NodeID = "123"
|
|
cM := NewConnManager(cfg)
|
|
exp := &ExportLogger{
|
|
ctx: context.Background(),
|
|
efsConns: []string{"*internal:*efs"},
|
|
connMgr: cM,
|
|
FldPostDir: "/var/spool/cgrates/failed_posts",
|
|
LogLevel: 7,
|
|
NodeID: "123",
|
|
Tenant: "cgrates.org",
|
|
Writer: &kafka.Writer{
|
|
Addr: kafka.TCP(cfg.LoggerCfg().Opts.KafkaConn),
|
|
Topic: cfg.LoggerCfg().Opts.KafkaTopic,
|
|
MaxAttempts: cfg.LoggerCfg().Opts.KafkaAttempts,
|
|
},
|
|
}
|
|
if rcv := NewExportLogger(context.Background(), "cgrates.org", cM, cfg); !reflect.DeepEqual(rcv, exp) {
|
|
t.Errorf("expected: <%+v>, \nreceived: <%+v>", exp, rcv)
|
|
}
|
|
}
|
|
|
|
func TestCloseExportLogger(t *testing.T) {
|
|
cfg := config.NewDefaultCGRConfig()
|
|
cfg.LoggerCfg().Level = 7
|
|
cfg.GeneralCfg().NodeID = "123"
|
|
cM := NewConnManager(cfg)
|
|
el := NewExportLogger(context.Background(), "cgrates.org", cM, cfg)
|
|
|
|
if el == nil {
|
|
t.Error("Export logger shouldn't be empty")
|
|
}
|
|
|
|
if err := el.Close(); err != nil {
|
|
t.Error(err)
|
|
}
|
|
exp := &ExportLogger{
|
|
ctx: context.Background(),
|
|
connMgr: cM,
|
|
efsConns: []string{"*internal:*efs"},
|
|
LogLevel: 7,
|
|
FldPostDir: cfg.LoggerCfg().Opts.FailedPostsDir,
|
|
NodeID: "123",
|
|
Tenant: "cgrates.org",
|
|
Writer: nil,
|
|
}
|
|
if !reflect.DeepEqual(exp, el) {
|
|
t.Errorf("\nExpected \n<%+v>, \nReceived \n<%+v>", exp, el)
|
|
}
|
|
|
|
}
|
|
|
|
func TestExportLoggerCallErrWriter(t *testing.T) {
|
|
tmp := Cache
|
|
defer func() {
|
|
Cache = tmp
|
|
}()
|
|
|
|
Cache.Clear(nil)
|
|
|
|
connID := "connID"
|
|
cfg := config.NewDefaultCGRConfig()
|
|
cfg.RPCConns()[connID] = config.NewDfltRPCConn()
|
|
cfg.RPCConns()[connID].Conns = []*config.RemoteHost{
|
|
{
|
|
ID: connID,
|
|
Address: utils.MetaInternal,
|
|
},
|
|
}
|
|
efsConn := utils.ConcatenatedKey(utils.MetaInternal, utils.MetaEFs)
|
|
|
|
cfg.LoggerCfg().EFsConns = []string{efsConn}
|
|
|
|
rpcInternal := make(chan birpc.ClientConnector, 1)
|
|
rpcInternal <- &ccMock{
|
|
calls: map[string]func(ctx *context.Context, args any, reply any) error{
|
|
utils.EfSv1ProcessEvent: func(ctx *context.Context, args, reply any) error {
|
|
return nil
|
|
},
|
|
},
|
|
}
|
|
cM := NewConnManager(cfg)
|
|
cM.connCache.Set(connID, nil, nil)
|
|
cM.AddInternalConn(efsConn, utils.EfSv1, rpcInternal)
|
|
db := NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
|
|
dm := NewDataManager(db, cfg.CacheCfg(), cM)
|
|
Cache = NewCacheS(cfg, dm, cM, nil)
|
|
|
|
el := NewExportLogger(context.Background(), "cgrates.org", cM, cfg)
|
|
|
|
if err := el.call("test msg", 7); err != utils.ErrLoggerChanged || err == nil {
|
|
t.Error(err)
|
|
}
|
|
|
|
}
|
|
|
|
func TestLoggerExportEmergNil(t *testing.T) {
|
|
tmp := Cache
|
|
defer func() {
|
|
Cache = tmp
|
|
}()
|
|
|
|
Cache.Clear(nil)
|
|
cfg := config.NewDefaultCGRConfig()
|
|
cM := NewConnManager(cfg)
|
|
|
|
el := NewExportLogger(context.Background(), "cgrates.org", cM, cfg)
|
|
|
|
if err := el.Emerg("Emergency message"); err != nil {
|
|
t.Error(err)
|
|
}
|
|
|
|
}
|
|
|
|
// func TestLoggerExportDebugOk(t *testing.T) {
|
|
|
|
// tmpC := Cache
|
|
// defer func() {
|
|
// Cache = tmpC
|
|
|
|
// }()
|
|
// Cache.Clear(nil)
|
|
|
|
// connID := "connID"
|
|
// cfg := config.NewDefaultCGRConfig()
|
|
// cfg.RPCConns()[connID] = config.NewDfltRPCConn()
|
|
// cfg.RPCConns()[connID].Conns = []*config.RemoteHost{
|
|
// {
|
|
// ID: connID,
|
|
// Address: utils.MetaInternal,
|
|
// },
|
|
// }
|
|
// efsConn := utils.ConcatenatedKey(utils.MetaInternal, utils.MetaEFs)
|
|
|
|
// cfg.LoggerCfg().EFsConns = []string{efsConn}
|
|
|
|
// rpcInternal := make(chan birpc.ClientConnector, 1)
|
|
// rpcInternal <- &ccMock{
|
|
// calls: map[string]func(ctx *context.Context, args any, reply any) error{
|
|
// utils.EfSv1ProcessEvent: func(ctx *context.Context, args, reply any) error {
|
|
// return nil
|
|
// },
|
|
// },
|
|
// }
|
|
// cM := NewConnManager(cfg)
|
|
// cM.connCache.Set(connID, nil, nil)
|
|
// cM.AddInternalConn(efsConn, utils.EfSv1, rpcInternal)
|
|
// db := NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
|
|
// dm := NewDataManager(db, cfg.CacheCfg(), cM)
|
|
// Cache = NewCacheS(cfg, dm, cM, nil)
|
|
|
|
// el := NewExportLogger(context.Background(), "123", "cgrates.org", 7, cM, cfg)
|
|
|
|
// logMsg := "log message"
|
|
|
|
// if err := el.Debug(logMsg); err != nil {
|
|
// t.Error(err)
|
|
// }
|
|
|
|
// el.SetLogLevel(utils.LOGLEVEL_DEBUG)
|
|
|
|
// }
|
|
|
|
/*
|
|
func TestLoggerExportAlert(t *testing.T) {
|
|
testCache := Cache
|
|
tmpC := config.CgrConfig()
|
|
tmpCM := connMgr
|
|
defer func() {
|
|
Cache = testCache
|
|
config.SetCgrConfig(tmpC)
|
|
connMgr = tmpCM
|
|
}()
|
|
|
|
cfg := config.NewDefaultCGRConfig()
|
|
cfg.CdrsCfg().EEsConns = []string{utils.ConcatenatedKey(utils.MetaInternal,
|
|
utils.MetaEEs)}
|
|
|
|
data := NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
|
|
cM := NewConnManager(cfg)
|
|
dm := NewDataManager(data, cfg.CacheCfg(), nil)
|
|
fltrs := NewFilterS(cfg, nil, dm)
|
|
Cache = NewCacheS(cfg, dm, nil, nil)
|
|
newCDRSrv := NewCDRServer(cfg, dm, fltrs, cM)
|
|
ccM := &ccMock{
|
|
calls: map[string]func(ctx *context.Context, args any, reply any) error{
|
|
utils.EeSv1ProcessEvent: func(ctx *context.Context, args, reply any) error {
|
|
*reply.(*map[string]map[string]any) = map[string]map[string]any{}
|
|
return utils.ErrNotFound
|
|
},
|
|
},
|
|
}
|
|
rpcInternal := make(chan birpc.ClientConnector, 1)
|
|
rpcInternal <- ccM
|
|
newCDRSrv.connMgr.AddInternalConn(utils.ConcatenatedKey(utils.MetaInternal,
|
|
utils.MetaEEs), utils.EeSv1, rpcInternal)
|
|
|
|
el := NewExportLogger(context.Background(), "123", "cgrates.org", 0, cM, cfg)
|
|
|
|
if err := el.Alert("Alert message"); err != nil {
|
|
t.Error(err)
|
|
}
|
|
el.SetLogLevel(1)
|
|
if err := el.Alert("Alert message"); err != nil {
|
|
t.Error(err)
|
|
}
|
|
}
|
|
|
|
func TestLoggerExportCrit(t *testing.T) {
|
|
tmp := Cache
|
|
defer func() {
|
|
Cache = tmp
|
|
}()
|
|
eesConn := utils.ConcatenatedKey(utils.MetaInternal, utils.MetaEEs)
|
|
cfg := config.NewDefaultCGRConfig()
|
|
cfg.CoreSCfg().EEsConns = []string{eesConn}
|
|
Cache = NewCacheS(cfg, nil, nil)
|
|
cM := NewConnManager(cfg)
|
|
ccM := &ccMock{
|
|
calls: map[string]func(ctx *context.Context, args any, reply any) error{
|
|
utils.EeSv1ProcessEvent: func(ctx *context.Context, args, reply any) error {
|
|
delete(args.(*utils.CGREventWithEeIDs).Event, "Timestamp")
|
|
exp := &utils.CGREventWithEeIDs{
|
|
CGREvent: &utils.CGREvent{
|
|
Tenant: "cgrates.org",
|
|
Event: map[string]any{
|
|
utils.NodeID: "123",
|
|
"Message": "Critical message",
|
|
"Severity": utils.LOGLEVEL_CRITICAL,
|
|
},
|
|
},
|
|
}
|
|
if !reflect.DeepEqual(exp, args) {
|
|
return fmt.Errorf("\nexpected: <%+v>, \nreceived: <%+v>",
|
|
utils.ToJSON(exp), utils.ToJSON(args))
|
|
}
|
|
return nil
|
|
},
|
|
},
|
|
}
|
|
rpcInternal := make(chan birpc.ClientConnector, 1)
|
|
rpcInternal <- ccM
|
|
cM.AddInternalConn(eesConn, utils.EeSv1, rpcInternal)
|
|
|
|
el := NewExportLogger("123", "cgrates.org", 1, cfg.LoggerCfg().Opts)
|
|
|
|
if err := el.Crit("Critical message"); err != nil {
|
|
t.Error(err)
|
|
}
|
|
el.SetLogLevel(2)
|
|
if err := el.Crit("Critical message"); err != nil {
|
|
t.Error(err)
|
|
}
|
|
}
|
|
*/
|
|
// func TestLoggerExportErr(t *testing.T) {
|
|
// tmp := Cache
|
|
// defer func() {
|
|
// Cache = tmp
|
|
// }()
|
|
// efsConn := utils.ConcatenatedKey(utils.MetaInternal, utils.MetaEFs)
|
|
// cfg := config.NewDefaultCGRConfig()
|
|
// cfg.LoggerCfg().EFsConns = []string{efsConn}
|
|
// Cache = NewCacheS(cfg, nil, nil, nil)
|
|
// cM := NewConnManager(cfg)
|
|
// ccM := &ccMock{
|
|
// calls: map[string]func(ctx *context.Context, args any, reply any) error{
|
|
// utils.EfSv1ProcessEvent: func(ctx *context.Context, args, reply any) error {
|
|
// delete(args.(*utils.CGREventWithEeIDs).Event, "Timestamp")
|
|
// exp := &utils.CGREventWithEeIDs{
|
|
// CGREvent: &utils.CGREvent{
|
|
// Tenant: "cgrates.org",
|
|
// Event: map[string]any{
|
|
// utils.NodeID: "123",
|
|
// "Message": "Error message",
|
|
// "Severity": utils.LOGLEVEL_ERROR,
|
|
// },
|
|
// },
|
|
// }
|
|
// if !reflect.DeepEqual(exp, args) {
|
|
// return fmt.Errorf("\nexpected: <%+v>, \nreceived: <%+v>",
|
|
// utils.ToJSON(exp), utils.ToJSON(args))
|
|
// }
|
|
// return nil
|
|
// },
|
|
// },
|
|
// }
|
|
// rpcInternal := make(chan birpc.ClientConnector, 1)
|
|
// rpcInternal <- ccM
|
|
// cM.AddInternalConn(efsConn, utils.EfSv1, rpcInternal)
|
|
|
|
// el := NewExportLogger(context.Background(), "123", "cgrates.org", 2, cM, cfg)
|
|
|
|
// if err := el.Err("Error message"); err != nil {
|
|
// t.Error(err)
|
|
// }
|
|
// el.SetLogLevel(3)
|
|
// if err := el.Err("Error message"); err != nil {
|
|
// t.Error(err)
|
|
// }
|
|
// }
|
|
|
|
/*
|
|
func TestLoggerExportWarning(t *testing.T) {
|
|
tmp := Cache
|
|
defer func() {
|
|
Cache = tmp
|
|
}()
|
|
eesConn := utils.ConcatenatedKey(utils.MetaInternal, utils.MetaEEs)
|
|
cfg := config.NewDefaultCGRConfig()
|
|
cfg.CoreSCfg().EEsConns = []string{eesConn}
|
|
Cache = NewCacheS(cfg, nil, nil)
|
|
cM := NewConnManager(cfg)
|
|
ccM := &ccMock{
|
|
calls: map[string]func(ctx *context.Context, args any, reply any) error{
|
|
utils.EeSv1ProcessEvent: func(ctx *context.Context, args, reply any) error {
|
|
delete(args.(*utils.CGREventWithEeIDs).Event, "Timestamp")
|
|
exp := &utils.CGREventWithEeIDs{
|
|
CGREvent: &utils.CGREvent{
|
|
Tenant: "cgrates.org",
|
|
Event: map[string]any{
|
|
utils.NodeID: "123",
|
|
"Message": "Warning message",
|
|
"Severity": utils.LOGLEVEL_WARNING,
|
|
},
|
|
},
|
|
}
|
|
if !reflect.DeepEqual(exp, args) {
|
|
return fmt.Errorf("\nexpected: <%+v>, \nreceived: <%+v>",
|
|
utils.ToJSON(exp), utils.ToJSON(args))
|
|
}
|
|
return nil
|
|
},
|
|
},
|
|
}
|
|
rpcInternal := make(chan birpc.ClientConnector, 1)
|
|
rpcInternal <- ccM
|
|
cM.AddInternalConn(eesConn, utils.EeSv1, rpcInternal)
|
|
|
|
el := NewExportLogger("123", "cgrates.org", 3, cfg.LoggerCfg().Opts)
|
|
|
|
if err := el.Warning("Warning message"); err != nil {
|
|
t.Error(err)
|
|
}
|
|
el.SetLogLevel(4)
|
|
if err := el.Warning("Warning message"); err != nil {
|
|
t.Error(err)
|
|
}
|
|
}
|
|
|
|
func TestLoggerExportNotice(t *testing.T) {
|
|
tmp := Cache
|
|
defer func() {
|
|
Cache = tmp
|
|
}()
|
|
eesConn := utils.ConcatenatedKey(utils.MetaInternal, utils.MetaEEs)
|
|
cfg := config.NewDefaultCGRConfig()
|
|
cfg.CoreSCfg().EEsConns = []string{eesConn}
|
|
Cache = NewCacheS(cfg, nil, nil)
|
|
cM := NewConnManager(cfg)
|
|
ccM := &ccMock{
|
|
calls: map[string]func(ctx *context.Context, args any, reply any) error{
|
|
utils.EeSv1ProcessEvent: func(ctx *context.Context, args, reply any) error {
|
|
delete(args.(*utils.CGREventWithEeIDs).Event, "Timestamp")
|
|
exp := &utils.CGREventWithEeIDs{
|
|
CGREvent: &utils.CGREvent{
|
|
Tenant: "cgrates.org",
|
|
Event: map[string]any{
|
|
utils.NodeID: "123",
|
|
"Message": "Notice message",
|
|
"Severity": utils.LOGLEVEL_NOTICE,
|
|
},
|
|
},
|
|
}
|
|
if !reflect.DeepEqual(exp, args) {
|
|
return fmt.Errorf("\nexpected: <%+v>, \nreceived: <%+v>",
|
|
utils.ToJSON(exp), utils.ToJSON(args))
|
|
}
|
|
return nil
|
|
},
|
|
},
|
|
}
|
|
rpcInternal := make(chan birpc.ClientConnector, 1)
|
|
rpcInternal <- ccM
|
|
cM.AddInternalConn(eesConn, utils.EeSv1, rpcInternal)
|
|
|
|
el := NewExportLogger("123", "cgrates.org", 4, cfg.LoggerCfg().Opts)
|
|
|
|
if err := el.Notice("Notice message"); err != nil {
|
|
t.Error(err)
|
|
}
|
|
el.SetLogLevel(5)
|
|
if err := el.Notice("Notice message"); err != nil {
|
|
t.Error(err)
|
|
}
|
|
}
|
|
|
|
func TestLoggerExportInfo(t *testing.T) {
|
|
tmp := Cache
|
|
defer func() {
|
|
Cache = tmp
|
|
}()
|
|
eesConn := utils.ConcatenatedKey(utils.MetaInternal, utils.MetaEEs)
|
|
cfg := config.NewDefaultCGRConfig()
|
|
cfg.CoreSCfg().EEsConns = []string{eesConn}
|
|
Cache = NewCacheS(cfg, nil, nil)
|
|
cM := NewConnManager(cfg)
|
|
ccM := &ccMock{
|
|
calls: map[string]func(ctx *context.Context, args any, reply any) error{
|
|
utils.EeSv1ProcessEvent: func(ctx *context.Context, args, reply any) error {
|
|
delete(args.(*utils.CGREventWithEeIDs).Event, "Timestamp")
|
|
exp := &utils.CGREventWithEeIDs{
|
|
CGREvent: &utils.CGREvent{
|
|
Tenant: "cgrates.org",
|
|
Event: map[string]any{
|
|
utils.NodeID: "123",
|
|
"Message": "Info message",
|
|
"Severity": utils.LOGLEVEL_INFO,
|
|
},
|
|
},
|
|
}
|
|
if !reflect.DeepEqual(exp, args) {
|
|
return fmt.Errorf("\nexpected: <%+v>, \nreceived: <%+v>",
|
|
utils.ToJSON(exp), utils.ToJSON(args))
|
|
}
|
|
return nil
|
|
},
|
|
},
|
|
}
|
|
rpcInternal := make(chan birpc.ClientConnector, 1)
|
|
rpcInternal <- ccM
|
|
cM.AddInternalConn(eesConn, utils.EeSv1, rpcInternal)
|
|
|
|
el := NewExportLogger("123", "cgrates.org", 5, cfg.LoggerCfg().Opts)
|
|
|
|
if err := el.Info("Info message"); err != nil {
|
|
t.Error(err)
|
|
}
|
|
el.SetLogLevel(6)
|
|
if err := el.Info("Info message"); err != nil {
|
|
t.Error(err)
|
|
}
|
|
}
|
|
|
|
func TestLoggerExportDebug(t *testing.T) {
|
|
tmp := Cache
|
|
defer func() {
|
|
Cache = tmp
|
|
}()
|
|
eesConn := utils.ConcatenatedKey(utils.MetaInternal, utils.MetaEEs)
|
|
cfg := config.NewDefaultCGRConfig()
|
|
cfg.CoreSCfg().EEsConns = []string{eesConn}
|
|
Cache = NewCacheS(cfg, nil, nil)
|
|
cM := NewConnManager(cfg)
|
|
ccM := &ccMock{
|
|
calls: map[string]func(ctx *context.Context, args any, reply any) error{
|
|
utils.EeSv1ProcessEvent: func(ctx *context.Context, args, reply any) error {
|
|
delete(args.(*utils.CGREventWithEeIDs).Event, "Timestamp")
|
|
exp := &utils.CGREventWithEeIDs{
|
|
CGREvent: &utils.CGREvent{
|
|
Tenant: "cgrates.org",
|
|
Event: map[string]any{
|
|
utils.NodeID: "123",
|
|
"Message": "Debug message",
|
|
"Severity": utils.LOGLEVEL_DEBUG,
|
|
},
|
|
},
|
|
}
|
|
if !reflect.DeepEqual(exp, args) {
|
|
return fmt.Errorf("\nexpected: <%+v>, \nreceived: <%+v>",
|
|
utils.ToJSON(exp), utils.ToJSON(args))
|
|
}
|
|
return nil
|
|
},
|
|
},
|
|
}
|
|
rpcInternal := make(chan birpc.ClientConnector, 1)
|
|
rpcInternal <- ccM
|
|
cM.AddInternalConn(eesConn, utils.EeSv1, rpcInternal)
|
|
|
|
el := NewExportLogger("123", "cgrates.org", 6, cfg.LoggerCfg().Opts)
|
|
|
|
if err := el.Debug("Debug message"); err != nil {
|
|
t.Error(err)
|
|
}
|
|
el.SetLogLevel(7)
|
|
if err := el.Debug("Debug message"); err != nil {
|
|
t.Error(err)
|
|
}
|
|
}
|
|
*/
|
|
|
|
func TestLoggerSetGetLogLevel(t *testing.T) {
|
|
cfg := config.NewDefaultCGRConfig()
|
|
cM := NewConnManager(cfg)
|
|
el := NewExportLogger(context.Background(), "cgrates.org", cM, cfg)
|
|
if rcv := el.GetLogLevel(); rcv != 6 {
|
|
t.Errorf("expected: <%+v>, \nreceived: <%+v>", 6, rcv)
|
|
}
|
|
el.SetLogLevel(3)
|
|
if rcv := el.GetLogLevel(); rcv != 3 {
|
|
t.Errorf("expected: <%+v>, \nreceived: <%+v>", 3, rcv)
|
|
}
|
|
}
|
|
|
|
func TestLoggerGetSyslog(t *testing.T) {
|
|
cfg := config.NewDefaultCGRConfig()
|
|
cM := NewConnManager(cfg)
|
|
el := NewExportLogger(context.Background(), "cgrates.org", cM, cfg)
|
|
if el.GetSyslog() != nil {
|
|
t.Errorf("expected: <%+v>, \nreceived: <%+v>", nil, el.GetSyslog())
|
|
}
|
|
}
|
|
|
|
/*
|
|
func TestLoggerExportWrite(t *testing.T) {
|
|
tmp := Cache
|
|
defer func() {
|
|
Cache = tmp
|
|
}()
|
|
eesConn := utils.ConcatenatedKey(utils.MetaInternal, utils.MetaEEs)
|
|
cfg := config.NewDefaultCGRConfig()
|
|
cfg.CoreSCfg().EEsConns = []string{eesConn}
|
|
Cache = NewCacheS(cfg, nil, nil)
|
|
cM := NewConnManager(cfg)
|
|
ccM := &ccMock{
|
|
calls: map[string]func(ctx *context.Context, args any, reply any) error{
|
|
utils.EeSv1ProcessEvent: func(ctx *context.Context, args, reply any) error {
|
|
delete(args.(*utils.CGREventWithEeIDs).Event, "Timestamp")
|
|
exp := &utils.CGREventWithEeIDs{
|
|
CGREvent: &utils.CGREvent{
|
|
Tenant: "cgrates.org",
|
|
Event: map[string]any{
|
|
utils.NodeID: "123",
|
|
"Message": "message",
|
|
"Severity": 8,
|
|
},
|
|
},
|
|
}
|
|
if !reflect.DeepEqual(exp, args) {
|
|
return fmt.Errorf("\nexpected: <%+v>, \nreceived: <%+v>",
|
|
utils.ToJSON(exp), utils.ToJSON(args))
|
|
}
|
|
return nil
|
|
},
|
|
},
|
|
}
|
|
rpcInternal := make(chan birpc.ClientConnector, 1)
|
|
rpcInternal <- ccM
|
|
cM.AddInternalConn(eesConn, utils.EeSv1, rpcInternal)
|
|
|
|
el := NewExportLogger("123", "cgrates.org", 8, cfg.LoggerCfg().Opts)
|
|
|
|
if _, err := el.Write([]byte("message")); err != nil {
|
|
t.Error(err)
|
|
}
|
|
el.Close()
|
|
}*/
|