mirror of
https://github.com/cgrates/cgrates.git
synced 2026-02-12 10:36:24 +05:00
516 lines
15 KiB
Go
516 lines
15 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 (
|
|
"fmt"
|
|
"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 TestLoggerNewLoggerExport(t *testing.T) {
|
|
cfg := config.NewDefaultCGRConfig()
|
|
exp := &ExportLogger{
|
|
logLevel: 7,
|
|
nodeID: "123",
|
|
tenant: "cgrates.org",
|
|
loggOpts: cfg.LoggerCfg().Opts,
|
|
writer: &kafka.Writer{
|
|
Addr: kafka.TCP(cfg.LoggerCfg().Opts.KafkaConn),
|
|
Topic: cfg.LoggerCfg().Opts.KafkaTopic,
|
|
MaxAttempts: cfg.LoggerCfg().Opts.Attempts,
|
|
},
|
|
}
|
|
if rcv, err := NewLogger(utils.MetaEEs, "cgrates.org", "123", nil, nil); err != nil {
|
|
t.Error(err)
|
|
} else if !reflect.DeepEqual(rcv.(*ExportLogger), exp) {
|
|
t.Errorf("expected: <%+v>, \nreceived: <%+v>", exp, rcv)
|
|
}
|
|
}
|
|
|
|
func TestLoggerNewLoggerDefault(t *testing.T) {
|
|
experr := `unsupported logger: <invalid>`
|
|
if _, err := NewLogger("invalid", "cgrates.org", "123", nil, nil); err == nil ||
|
|
err.Error() != experr {
|
|
t.Errorf("expected: <%s>, \nreceived: <%s>", experr, err)
|
|
}
|
|
}
|
|
|
|
func TestLoggerNewExportLogger(t *testing.T) {
|
|
cfg := config.NewDefaultCGRConfig()
|
|
exp := &ExportLogger{
|
|
logLevel: 7,
|
|
nodeID: "123",
|
|
tenant: "cgrates.org",
|
|
loggOpts: cfg.LoggerCfg().Opts,
|
|
writer: &kafka.Writer{
|
|
Addr: kafka.TCP(cfg.LoggerCfg().Opts.KafkaConn),
|
|
Topic: cfg.LoggerCfg().Opts.KafkaTopic,
|
|
MaxAttempts: cfg.LoggerCfg().Opts.Attempts,
|
|
},
|
|
}
|
|
if rcv := NewExportLogger("123", "cgrates.org", 7, cfg.LoggerCfg().Opts, nil); !reflect.DeepEqual(rcv, exp) {
|
|
t.Errorf("expected: <%+v>, \nreceived: <%+v>", exp, rcv)
|
|
}
|
|
}
|
|
|
|
func TestLoggerExportEmerg(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 interface{}, reply interface{}) error{
|
|
utils.EeSv1ProcessEvent: func(ctx *context.Context, args, reply interface{}) error {
|
|
delete(args.(*utils.CGREventWithEeIDs).Event, "Timestamp")
|
|
exp := &utils.CGREventWithEeIDs{
|
|
CGREvent: &utils.CGREvent{
|
|
Tenant: "cgrates.org",
|
|
Event: map[string]interface{}{
|
|
utils.NodeID: "123",
|
|
"Message": "Emergency message",
|
|
"Severity": utils.LOGLEVEL_EMERGENCY,
|
|
},
|
|
},
|
|
}
|
|
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, cM, []string{eesConn})
|
|
|
|
if err := el.Emerg("Emergency message"); err != nil {
|
|
t.Error(err)
|
|
}
|
|
el.SetLogLevel(0)
|
|
if err := el.Emerg("Emergency message"); err != nil {
|
|
t.Error(err)
|
|
}
|
|
}
|
|
|
|
func TestLoggerExportAlert(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 interface{}, reply interface{}) error{
|
|
utils.EeSv1ProcessEvent: func(ctx *context.Context, args, reply interface{}) error {
|
|
delete(args.(*utils.CGREventWithEeIDs).Event, "Timestamp")
|
|
exp := &utils.CGREventWithEeIDs{
|
|
CGREvent: &utils.CGREvent{
|
|
Tenant: "cgrates.org",
|
|
Event: map[string]interface{}{
|
|
utils.NodeID: "123",
|
|
"Message": "Alert message",
|
|
"Severity": utils.LOGLEVEL_ALERT,
|
|
},
|
|
},
|
|
}
|
|
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", 0, cM, []string{eesConn})
|
|
|
|
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 interface{}, reply interface{}) error{
|
|
utils.EeSv1ProcessEvent: func(ctx *context.Context, args, reply interface{}) error {
|
|
delete(args.(*utils.CGREventWithEeIDs).Event, "Timestamp")
|
|
exp := &utils.CGREventWithEeIDs{
|
|
CGREvent: &utils.CGREvent{
|
|
Tenant: "cgrates.org",
|
|
Event: map[string]interface{}{
|
|
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, cM, []string{eesConn})
|
|
|
|
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
|
|
}()
|
|
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 interface{}, reply interface{}) error{
|
|
utils.EeSv1ProcessEvent: func(ctx *context.Context, args, reply interface{}) error {
|
|
delete(args.(*utils.CGREventWithEeIDs).Event, "Timestamp")
|
|
exp := &utils.CGREventWithEeIDs{
|
|
CGREvent: &utils.CGREvent{
|
|
Tenant: "cgrates.org",
|
|
Event: map[string]interface{}{
|
|
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(eesConn, utils.EeSv1, rpcInternal)
|
|
|
|
el := NewExportLogger("123", "cgrates.org", 2, cM, []string{eesConn})
|
|
|
|
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 interface{}, reply interface{}) error{
|
|
utils.EeSv1ProcessEvent: func(ctx *context.Context, args, reply interface{}) error {
|
|
delete(args.(*utils.CGREventWithEeIDs).Event, "Timestamp")
|
|
exp := &utils.CGREventWithEeIDs{
|
|
CGREvent: &utils.CGREvent{
|
|
Tenant: "cgrates.org",
|
|
Event: map[string]interface{}{
|
|
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, cM, []string{eesConn})
|
|
|
|
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 interface{}, reply interface{}) error{
|
|
utils.EeSv1ProcessEvent: func(ctx *context.Context, args, reply interface{}) error {
|
|
delete(args.(*utils.CGREventWithEeIDs).Event, "Timestamp")
|
|
exp := &utils.CGREventWithEeIDs{
|
|
CGREvent: &utils.CGREvent{
|
|
Tenant: "cgrates.org",
|
|
Event: map[string]interface{}{
|
|
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, cM, []string{eesConn})
|
|
|
|
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 interface{}, reply interface{}) error{
|
|
utils.EeSv1ProcessEvent: func(ctx *context.Context, args, reply interface{}) error {
|
|
delete(args.(*utils.CGREventWithEeIDs).Event, "Timestamp")
|
|
exp := &utils.CGREventWithEeIDs{
|
|
CGREvent: &utils.CGREvent{
|
|
Tenant: "cgrates.org",
|
|
Event: map[string]interface{}{
|
|
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, cM, []string{eesConn})
|
|
|
|
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 interface{}, reply interface{}) error{
|
|
utils.EeSv1ProcessEvent: func(ctx *context.Context, args, reply interface{}) error {
|
|
delete(args.(*utils.CGREventWithEeIDs).Event, "Timestamp")
|
|
exp := &utils.CGREventWithEeIDs{
|
|
CGREvent: &utils.CGREvent{
|
|
Tenant: "cgrates.org",
|
|
Event: map[string]interface{}{
|
|
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, cM, []string{eesConn})
|
|
|
|
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) {
|
|
el := NewExportLogger("123", "cgrates.org", 6, nil, nil)
|
|
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) {
|
|
el := NewExportLogger("123", "cgrates.org", 6, nil, nil)
|
|
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 interface{}, reply interface{}) error{
|
|
utils.EeSv1ProcessEvent: func(ctx *context.Context, args, reply interface{}) error {
|
|
delete(args.(*utils.CGREventWithEeIDs).Event, "Timestamp")
|
|
exp := &utils.CGREventWithEeIDs{
|
|
CGREvent: &utils.CGREvent{
|
|
Tenant: "cgrates.org",
|
|
Event: map[string]interface{}{
|
|
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, cM, []string{eesConn})
|
|
|
|
if _, err := el.Write([]byte("message")); err != nil {
|
|
t.Error(err)
|
|
}
|
|
el.Close()
|
|
}
|