mirror of
https://github.com/cgrates/cgrates.git
synced 2026-02-17 22:29:55 +05:00
4c34d321de
HierarchyPath parser now returns nil when the path is empty (instead of a string slice with one EmptyString element). If isAbsolute is set to true, when calling the AsString method on a nil HierarchyPath, only the separator will be returned. Alternatively, if isAbsolute is false, it will just return . to signal that the path currently being processed is the one required.This avoids a nil expr error coming from the xmlquery library. Use the Query and QueryAll functions from the xmlquery package to be able to handle the errors ourselves and avoid panics. Remove config default value for xmlRootPath. The field will remain commented in config_defaults for reference. Add tests for HierarchyPath.AsString function. Add comments for XmlProvider and xmlRootPath opt. Update XmlProvider String() func based on the comment which specifies that it should display the already parsed values out of cache.
610 lines
17 KiB
Go
610 lines
17 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 TestLoggerNewLoggerExportKafkaLog(t *testing.T) {
|
|
cfg := config.NewDefaultCGRConfig()
|
|
cM := NewConnManager(cfg)
|
|
|
|
exp := NewExportLogger(context.Background(), "123", "cgrates.org", 6, cM, cfg)
|
|
if rcv, err := NewLogger(context.Background(), utils.MetaKafkaLog, "cgrates.org", "123", cM, cfg); err != nil {
|
|
t.Error(err)
|
|
} else if !reflect.DeepEqual(rcv, exp) {
|
|
t.Errorf("expected: <%+v>, \nreceived: <%+v>", exp, rcv)
|
|
}
|
|
}
|
|
|
|
func TestLoggerNewLoggerDefault(t *testing.T) {
|
|
cfg := config.NewDefaultCGRConfig()
|
|
cM := NewConnManager(cfg)
|
|
experr := `unsupported logger: <invalid>`
|
|
if _, err := NewLogger(context.Background(), "invalid", "cgrates.org", "123", cM, cfg); err == nil ||
|
|
err.Error() != experr {
|
|
t.Errorf("expected: <%s>, \nreceived: <%s>", experr, err)
|
|
}
|
|
}
|
|
|
|
func TestLoggerNewExportLogger(t *testing.T) {
|
|
cfg := config.NewDefaultCGRConfig()
|
|
cM := NewConnManager(cfg)
|
|
exp := &ExportLogger{
|
|
ctx: context.Background(),
|
|
cfg: cfg,
|
|
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(), "123", "cgrates.org", 7, cM, cfg); !reflect.DeepEqual(rcv, exp) {
|
|
t.Errorf("expected: <%+v>, \nreceived: <%+v>", exp, rcv)
|
|
}
|
|
}
|
|
|
|
func TestCloseExportLogger(t *testing.T) {
|
|
cfg := config.NewDefaultCGRConfig()
|
|
cM := NewConnManager(cfg)
|
|
el := NewExportLogger(context.Background(), "123", "cgrates.org", 7, cM, cfg)
|
|
|
|
if el == nil {
|
|
t.Error("Export logger should'nt be empty")
|
|
}
|
|
|
|
if err := el.Close(); err != nil {
|
|
t.Error(err)
|
|
}
|
|
exp := &ExportLogger{
|
|
ctx: context.Background(),
|
|
connMgr: cM,
|
|
cfg: cfg,
|
|
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(), "123", "cgrates.org", 7, 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(), "123", "cgrates.org", -1, 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(), "123", "cgrates.org", 6, 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(), "123", "cgrates.org", 6, 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()
|
|
}*/
|