Coverage tests at engine

2026-02-17 06:09:53 +05:00 · 2023-01-24 10:55:33 -05:00
parent 04c77fd8b3
commit c31766dd91
3 changed files with 498 additions and 42 deletions
--- a/engine/kafka_logger_test.go
+++ b/engine/kafka_logger_test.go
@@ -28,7 +28,7 @@ import (
 	"github.com/segmentio/kafka-go"
 )

-func TestLoggerNewLoggerExport(t *testing.T) {
+func TestLoggerNewLoggerExportKafkaLog(t *testing.T) {
 	cfg := config.NewDefaultCGRConfig()
 	cM := NewConnManager(cfg)

@@ -40,6 +40,21 @@ func TestLoggerNewLoggerExport(t *testing.T) {
 	}
 }

+func TestLoggerNewLoggerExportStdLog(t *testing.T) {
+	cfg := config.NewDefaultCGRConfig()
+	cM := NewConnManager(cfg)
+
+	exp, err := utils.NewLogger(utils.MetaStdLog, "123", 6)
+	if err != nil {
+		t.Error(err)
+	}
+	if rcv, err := NewLogger(context.Background(), utils.MetaStdLog, "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)
@@ -72,6 +87,79 @@ func TestLoggerNewExportLogger(t *testing.T) {
 	}
 }

+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)
+	}
+
+}
+
+// unfinished panic when covering
+// func TestExportLoggerCall(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,
+// 		},
+// 	}
+// 	eesConn := utils.ConcatenatedKey(utils.MetaInternal, utils.MetaEEs)
+
+// 	cfg.CoreSCfg().EEsConns = []string{eesConn}
+
+// 	rpcInternal := make(chan birpc.ClientConnector, 1)
+// 	rpcInternal <- &ccMock{
+// 		calls: map[string]func(ctx *context.Context, args interface{}, reply interface{}) error{
+// 			utils.EeSv1ProcessEvent: func(ctx *context.Context, args, reply interface{}) error {
+// 				return nil
+// 			},
+// 		},
+// 	}
+// 	cM := NewConnManager(cfg)
+// 	cM.connCache.Set(connID, nil, nil)
+// 	cM.AddInternalConn(eesConn, utils.EeSv1, 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() {
@@ -90,61 +178,58 @@ func TestLoggerExportEmergNil(t *testing.T) {

 }

-// func TestLoggerExportEmergOk(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", 0, cM, cfg)
-
-// 	if err := el.Emerg("Emergency message"); err != nil {
-// 		t.Error(err)
-// 	}
-// }
-
 /*
-func TestLoggerExportAlert(t *testing.T) {
+func TestLoggerExportEmergOk(t *testing.T) {
 	tmp := Cache
 	defer func() {
 		Cache = tmp
 	}()
-	eesConn := utils.ConcatenatedKey(utils.MetaInternal, utils.MetaEEs)
+
+	Cache.Clear(nil)
 	cfg := config.NewDefaultCGRConfig()
-	cfg.CoreSCfg().EEsConns = []string{eesConn}
-	Cache = NewCacheS(cfg, nil, nil)
 	cM := NewConnManager(cfg)
+
+	el := NewExportLogger(context.Background(), "123", "cgrates.org", 0, cM, cfg)
+
+	if err := el.Emerg("Emergency message"); err != nil {
+		t.Error(err)
+	}
+}
+
+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 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
+				*reply.(*map[string]map[string]interface{}) = map[string]map[string]interface{}{}
+				return utils.ErrNotFound
 			},
 		},
 	}
 	rpcInternal := make(chan birpc.ClientConnector, 1)
 	rpcInternal <- ccM
-	cM.AddInternalConn(eesConn, utils.EeSv1, rpcInternal)
+	newCDRSrv.connMgr.AddInternalConn(utils.ConcatenatedKey(utils.MetaInternal,
+		utils.MetaEEs), utils.EeSv1, rpcInternal)

-	el := NewExportLogger("123", "cgrates.org", 0, cfg.LoggerCfg().Opts)
+	el := NewExportLogger(context.Background(), "123", "cgrates.org", 0, cM, cfg)

 	if err := el.Alert("Alert message"); err != nil {
 		t.Error(err)
@@ -155,6 +240,7 @@ func TestLoggerExportAlert(t *testing.T) {
 	}
 }

+
 func TestLoggerExportCrit(t *testing.T) {
 	tmp := Cache
 	defer func() {
@@ -436,10 +522,12 @@ func TestLoggerExportDebug(t *testing.T) {
 		t.Error(err)
 	}
 }
+*/

 func TestLoggerSetGetLogLevel(t *testing.T) {
 	cfg := config.NewDefaultCGRConfig()
-	el := NewExportLogger("123", "cgrates.org", 6, cfg.LoggerCfg().Opts)
+	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)
 	}
@@ -451,12 +539,14 @@ func TestLoggerSetGetLogLevel(t *testing.T) {

 func TestLoggerGetSyslog(t *testing.T) {
 	cfg := config.NewDefaultCGRConfig()
-	el := NewExportLogger("123", "cgrates.org", 6, cfg.LoggerCfg().Opts)
+	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() {
--- a/engine/libindex_test.go
+++ b/engine/libindex_test.go
@@ -2230,3 +2230,217 @@ func TestUpdateFilterIndexActionProfilesErr2(t *testing.T) {
 	}

 }
+
+func TestUpdateFilterIndexRateProfilesIndex(t *testing.T) {
+	tmp := Cache
+	defer func() {
+		Cache = tmp
+	}()
+	Cache.Clear(nil)
+
+	cfg := config.NewDefaultCGRConfig()
+	dataDB := NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
+	dm := NewDataManager(dataDB, cfg.CacheCfg(), nil)
+
+	oldFlt := &Filter{
+		Tenant: "cgrates.org",
+		ID:     "fltr_test",
+		Rules: []*FilterRule{
+			{
+				Type:    utils.MetaString,
+				Element: "~*req.Cost",
+				Values:  []string{"unRegVal2"},
+			},
+		},
+	}
+
+	if err := oldFlt.Compile(); err != nil {
+		t.Error(err)
+	}
+
+	if err := dm.SetFilter(context.Background(), oldFlt, true); err != nil {
+		t.Error(err)
+	}
+	rpp := &utils.RateProfile{
+		Tenant:    "cgrates.org",
+		ID:        "ID",
+		FilterIDs: []string{"fltr_test"},
+		Weights: utils.DynamicWeights{
+			{
+				FilterIDs: []string{"fltr2"},
+				Weight:    40,
+			},
+		},
+		MaxCostStrategy: "*free",
+		Rates: map[string]*utils.Rate{
+			"FIRST_GI": {
+				ID:        "FIRST_GI",
+				FilterIDs: []string{"*string:~*req.Category:call"},
+				Weights: utils.DynamicWeights{
+					{
+						Weight: 0,
+					},
+				},
+				Blocker: false,
+			},
+		},
+		MinCost: utils.DecimalNaN,
+		MaxCost: utils.DecimalNaN,
+	}
+
+	if err := dm.SetRateProfile(context.Background(), rpp, false, true); err != nil {
+		t.Error(err)
+	}
+
+	expindx := map[string]utils.StringSet{
+		"*string:*req.Cost:unRegVal2": {"ID": {}},
+	}
+
+	getindx, err := dm.GetIndexes(context.Background(), utils.CacheRateProfilesFilterIndexes, utils.CGRateSorg, utils.EmptyString, utils.EmptyString, true, true)
+	if err != nil {
+		t.Error(err)
+	} else if !reflect.DeepEqual(expindx, getindx) {
+		t.Errorf("Expected \n<%v>, \nReceived \n<%v>", utils.ToJSON(expindx), utils.ToJSON(getindx))
+	}
+
+	newFlt := &Filter{
+		Tenant: "cgrates.org",
+		ID:     "fltr_test",
+		Rules: []*FilterRule{
+			{
+				Type:    utils.MetaPrefix,
+				Element: "~*req.Usage",
+				Values:  []string{"10s"},
+			},
+		},
+	}
+	if err := newFlt.Compile(); err != nil {
+		t.Error(err)
+	}
+	if err := dm.SetFilter(context.Background(), newFlt, false); err != nil {
+		t.Error(err)
+	}
+
+	if err := UpdateFilterIndex(context.Background(), dm, oldFlt, newFlt); err != nil {
+		t.Error(err)
+	}
+
+	expindxNew := map[string]utils.StringSet{
+		"*prefix:*req.Usage:10s": {"ID": {}},
+	}
+	getindxNew, err := dm.GetIndexes(context.Background(), utils.CacheRateProfilesFilterIndexes, utils.CGRateSorg, utils.EmptyString, utils.EmptyString, true, true)
+	if err != nil {
+		t.Error(err)
+	} else if !reflect.DeepEqual(expindxNew, getindxNew) {
+		t.Errorf("Expected \n<%v>, \nReceived \n<%v>", utils.ToJSON(expindxNew), utils.ToJSON(getindxNew))
+	}
+
+}
+
+func TestUpdateFilterRateProfilesIndexErr1(t *testing.T) {
+	tmp := Cache
+	defer func() {
+		Cache = tmp
+	}()
+	Cache.Clear(nil)
+
+	cfg := config.NewDefaultCGRConfig()
+	dataDB := NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
+	dm := NewDataManager(dataDB, cfg.CacheCfg(), nil)
+
+	dm.dataDB = &DataDBMock{
+		GetIndexesDrvF: func(ctx *context.Context, idxItmType, tntCtx, idxKey, transactionID string) (indexes map[string]utils.StringSet, err error) {
+			return map[string]utils.StringSet{
+				utils.CacheRateProfilesFilterIndexes: {
+					"ATTR_TEST": {},
+				},
+			}, nil
+		},
+		SetIndexesDrvF: func(ctx *context.Context, idxItmType, tntCtx string, indexes map[string]utils.StringSet, commit bool, transactionID string) (err error) {
+			return utils.ErrNotImplemented
+		},
+	}
+
+	oldFlt := &Filter{
+		Tenant: "cgrates.org",
+		ID:     "fltr_test",
+		Rules: []*FilterRule{
+			{
+				Type:    utils.MetaString,
+				Element: "~*req.Cost",
+				Values:  []string{"unRegVal2"},
+			},
+		},
+	}
+	newFlt := &Filter{
+		Tenant: "cgrates.org",
+		ID:     "fltr_test",
+		Rules: []*FilterRule{
+			{
+				Type:    utils.MetaPrefix,
+				Element: "~*req.Usage",
+				Values:  []string{"10s"},
+			},
+		},
+	}
+
+	expErr := utils.ErrNotImplemented
+	if err := UpdateFilterIndex(context.Background(), dm, oldFlt, newFlt); err != expErr {
+		t.Errorf("Expected error <%v>, Received error <%v>", expErr, err)
+	}
+
+}
+
+func TestUpdateFilterIndexRateProfilesErr2(t *testing.T) {
+	tmp := Cache
+	defer func() {
+		Cache = tmp
+	}()
+	Cache.Clear(nil)
+
+	cfg := config.NewDefaultCGRConfig()
+	dataDB := NewInternalDB(nil, nil, cfg.DataDbCfg().Items)
+	dm := NewDataManager(dataDB, cfg.CacheCfg(), nil)
+
+	dm.dataDB = &DataDBMock{
+		GetIndexesDrvF: func(ctx *context.Context, idxItmType, tntCtx, idxKey, transactionID string) (indexes map[string]utils.StringSet, err error) {
+			return map[string]utils.StringSet{
+				utils.CacheRateProfilesFilterIndexes: {
+					"ATTR_TEST": {},
+				},
+			}, nil
+		},
+		SetIndexesDrvF: func(ctx *context.Context, idxItmType, tntCtx string, indexes map[string]utils.StringSet, commit bool, transactionID string) (err error) {
+			return nil
+		},
+	}
+
+	oldFlt := &Filter{
+		Tenant: "cgrates.org",
+		ID:     "fltr_test",
+		Rules: []*FilterRule{
+			{
+				Type:    utils.MetaString,
+				Element: "~*req.Cost",
+				Values:  []string{"unRegVal2"},
+			},
+		},
+	}
+	newFlt := &Filter{
+		Tenant: "cgrates.org",
+		ID:     "fltr_test",
+		Rules: []*FilterRule{
+			{
+				Type:    utils.MetaPrefix,
+				Element: "~*req.Usage",
+				Values:  []string{"10s"},
+			},
+		},
+	}
+
+	expErr := "SERVER_ERROR: NOT_IMPLEMENTED"
+	if err := UpdateFilterIndex(context.Background(), dm, oldFlt, newFlt); err.Error() != expErr {
+		t.Errorf("Expected error <%v>, Received error <%v>", expErr, err)
+	}
+
+}
--- a/engine/routes_test.go
+++ b/engine/routes_test.go
@@ -1204,3 +1204,155 @@ func TestRouteMerge(t *testing.T) {
 		t.Errorf("Expected %v \n but received \n %v", utils.ToJSON(exp), utils.ToJSON(route))
 	}
 }
+
+func TestRouteProfileCompileCacheParametersErrParse(t *testing.T) {
+	tmp := Cache
+	defer func() {
+		Cache = tmp
+	}()
+
+	Cache.Clear(nil)
+
+	rp := &RouteProfile{
+		Tenant:            "cgrates.org",
+		ID:                "ID",
+		FilterIDs:         []string{"fltr1", "*string:~*req.Account:1001"},
+		Weights:           utils.DynamicWeights{{}},
+		Sorting:           utils.MetaLoad,
+		SortingParameters: []string{"sort:param"},
+		Routes: []*Route{{
+			ID:             "RT1",
+			FilterIDs:      []string{"fltr1"},
+			AccountIDs:     []string{"acc1"},
+			RateProfileIDs: []string{"rp1"},
+			ResourceIDs:    []string{"res1"},
+			StatIDs:        []string{"stat1"},
+			Weights:        utils.DynamicWeights{{}},
+			Blockers: utils.DynamicBlockers{
+				{
+					Blocker: true,
+				},
+			},
+			RouteParameters: "params",
+		}},
+	}
+
+	expErr := `strconv.Atoi: parsing "param": invalid syntax`
+	if err := rp.compileCacheParameters(); err.Error() != expErr || err == nil {
+		t.Errorf("Expected error <%v>, Received error <%v>", expErr, err)
+	}
+}
+
+func TestRouteProfileCompileCacheParametersConfigRatio(t *testing.T) {
+	tmp := Cache
+	defer func() {
+		Cache = tmp
+	}()
+
+	Cache.Clear(nil)
+
+	rp := &RouteProfile{
+		Tenant:            "cgrates.org",
+		ID:                "ID",
+		FilterIDs:         []string{"fltr1", "*string:~*req.Account:1001"},
+		Weights:           utils.DynamicWeights{{}},
+		Sorting:           utils.MetaLoad,
+		SortingParameters: []string{"param:1"},
+		Routes: []*Route{{
+			ID:             "RT1",
+			FilterIDs:      []string{"fltr1"},
+			AccountIDs:     []string{"acc1"},
+			RateProfileIDs: []string{"rp1"},
+			ResourceIDs:    []string{"res1"},
+			StatIDs:        []string{"stat1"},
+			Weights:        utils.DynamicWeights{{}},
+			Blockers: utils.DynamicBlockers{
+				{
+					Blocker: true,
+				},
+			},
+			RouteParameters: "params",
+		}},
+	}
+
+	expErr := `strconv.Atoi: parsing "param": invalid syntax`
+	if err := rp.compileCacheParameters(); err != nil {
+		t.Errorf("Expected error <%v>, Received error <%v>", expErr, err)
+	}
+}
+
+func TestRouteProfileCompileCacheParametersDefaultRatio(t *testing.T) {
+	tmp := Cache
+	defer func() {
+		Cache = tmp
+	}()
+
+	Cache.Clear(nil)
+
+	rp := &RouteProfile{
+		Tenant:            "cgrates.org",
+		ID:                "ID",
+		FilterIDs:         []string{"fltr1", "*string:~*req.Account:1001"},
+		Weights:           utils.DynamicWeights{{}},
+		Sorting:           utils.MetaLoad,
+		SortingParameters: []string{"*default:1"},
+		Routes: []*Route{{
+			ID:             "RT1",
+			FilterIDs:      []string{"fltr1"},
+			AccountIDs:     []string{"acc1"},
+			RateProfileIDs: []string{"rp1"},
+			ResourceIDs:    []string{"res1"},
+			StatIDs:        []string{"stat1"},
+			Weights:        utils.DynamicWeights{{}},
+			Blockers: utils.DynamicBlockers{
+				{
+					Blocker: true,
+				},
+			},
+			RouteParameters: "params",
+		}},
+	}
+
+	expErr := `strconv.Atoi: parsing "param": invalid syntax`
+	if err := rp.compileCacheParameters(); err != nil {
+		t.Errorf("Expected error <%v>, Received error <%v>", expErr, err)
+	}
+}
+
+func TestRouteProfileCompileCacheParametersRouteRatio(t *testing.T) {
+	tmp := Cache
+	defer func() {
+		Cache = tmp
+	}()
+
+	Cache.Clear(nil)
+
+	rp := &RouteProfile{
+		Tenant:            "cgrates.org",
+		ID:                "ID",
+		FilterIDs:         []string{"fltr1", "*string:~*req.Account:1001"},
+		Weights:           utils.DynamicWeights{{}},
+		Sorting:           utils.MetaLoad,
+		SortingParameters: []string{"RT1:1"},
+		Routes: []*Route{{
+			ID:             "RT1",
+			FilterIDs:      []string{"fltr1"},
+			AccountIDs:     []string{"acc1"},
+			RateProfileIDs: []string{"rp1"},
+			ResourceIDs:    []string{"res1"},
+			StatIDs:        []string{"stat1"},
+			Weights:        utils.DynamicWeights{{}},
+			Blockers: utils.DynamicBlockers{
+				{
+					Blocker: true,
+				},
+			},
+			RouteParameters: "params",
+		}},
+	}
+
+	expErr := `strconv.Atoi: parsing "param": invalid syntax`
+	if err := rp.compileCacheParameters(); err != nil {
+		t.Errorf("Expected error <%v>, Received error <%v>", expErr, err)
+	}
+}