improving coverage tests at engine

engine/action_trigger_test.go

@@ -257,10 +257,12 @@ func TestActionTriggerCreateBalance(t *testing.T) {
 }
 
 func TestATExecute(t *testing.T) {
+	Cache.Clear(nil)
 	cfg := config.NewDefaultCGRConfig()
 	db := NewInternalDB(nil, nil, true, cfg.DataDbCfg().Items)
 	dm := NewDataManager(db, cfg.CacheCfg(), nil)
 	at := &ActionTrigger{
+		ActionsID:         "id",
 		ID:                "id",
 		UniqueID:          "uid",
 		ThresholdType:     "*min_event_counter",
@@ -277,9 +279,10 @@ func TestATExecute(t *testing.T) {
 		AllowNegative:  false,
 		UpdateTime:     time.Date(2019, 3, 1, 12, 0, 0, 0, time.UTC),
 	}
+
 	fltrs := NewFilterS(cfg, nil, dm)
 
-	if err := at.Execute(ub, fltrs); err == nil {
-		t.Error(err)
+	if err := at.Execute(ub, fltrs); err == nil || err != utils.ErrNotFound {
+		t.Errorf("expected <%+v>,received <%+v>", utils.ErrNotFound, err)
 	}
 }

engine/cdrs_test.go

@@ -1326,7 +1326,7 @@ func TestGetCostFromRater2(t *testing.T) {
 		APIOpts: map[string]interface{}{},
 	}
 
-	if _, err := cdrS.getCostFromRater(cdr); err == nil {
+	if _, err := cdrS.getCostFromRater(cdr); err == nil || err != utils.ErrAccountNotFound {
 		t.Error(err)
 	}
 }
@@ -1370,7 +1370,163 @@ func TestGetCostFromRater3(t *testing.T) {
 		APIOpts: map[string]interface{}{},
 	}
 
-	if _, err := cdrS.getCostFromRater(cdr); err == nil {
-		t.Error(err)
+	if _, err := cdrS.getCostFromRater(cdr); err == nil || err != rpcclient.ErrUnsupporteServiceMethod {
+		t.Errorf("expected %+v,received %v", rpcclient.ErrUnsupporteServiceMethod, err)
 	}
 }
+
+func TestV2StoreSessionCost2(t *testing.T) {
+	Cache.Clear(nil)
+	cfg := config.NewDefaultCGRConfig()
+	cfg.CacheCfg().Partitions[utils.CacheRPCResponses].Limit = 0
+	cfg.CdrsCfg().RaterConns = []string{utils.ConcatenatedKey(utils.MetaInternal, utils.RateSConnsCfg)}
+	db := NewInternalDB(nil, nil, true, cfg.DataDbCfg().Items)
+	dm := NewDataManager(db, cfg.CacheCfg(), nil)
+
+	ccMOck := &ccMock{
+
+		calls: map[string]func(args interface{}, reply interface{}) error{
+			utils.ResponderRefundRounding: func(args, reply interface{}) error {
+				rpl := &Account{}
+				*reply.(*Account) = *rpl
+				return nil
+			},
+		},
+	}
+	clientconn := make(chan rpcclient.ClientConnector, 1)
+	clientconn <- ccMOck
+	connMgr := NewConnManager(cfg, map[string]chan rpcclient.ClientConnector{
+		utils.ConcatenatedKey(utils.MetaInternal, utils.RateSConnsCfg): clientconn,
+	})
+	cdrS := &CDRServer{
+		cgrCfg:  cfg,
+		cdrDb:   db,
+		dm:      dm,
+		connMgr: connMgr,
+	}
+
+	args := &ArgsV2CDRSStoreSMCost{
+
+		CheckDuplicate: false,
+		Cost: &V2SMCost{
+			CGRID:      "cgrid",
+			RunID:      "runid",
+			OriginHost: "host",
+			OriginID:   "originid",
+			CostSource: "cgrates",
+			CostDetails: &EventCost{
+				CGRID:     "evcgrid",
+				RunID:     "evrunid",
+				StartTime: time.Date(2021, 11, 1, 2, 0, 0, 0, time.UTC),
+				Usage:     utils.DurationPointer(122),
+				Cost:      utils.Float64Pointer(134),
+				Charges: []*ChargingInterval{
+					{
+
+						RatingID: "acc_id",
+						Increments: []*ChargingIncrement{
+							{
+
+								Usage:          5 * time.Minute,
+								Cost:           23,
+								AccountingID:   "acc_id",
+								CompressFactor: 5,
+							},
+							{
+								Usage:          5 * time.Minute,
+								Cost:           23,
+								AccountingID:   "acc_id2",
+								CompressFactor: 5,
+							},
+						},
+						CompressFactor: 3,
+						usage:          utils.DurationPointer(10 * time.Minute),
+						ecUsageIdx:     utils.DurationPointer(4 * time.Minute),
+						cost:           utils.Float64Pointer(38),
+					},
+					{
+						RatingID: "acc_id2",
+
+						Increments: []*ChargingIncrement{
+							{
+								Usage:          5 * time.Minute,
+								Cost:           23,
+								AccountingID:   "acc_id",
+								CompressFactor: 5,
+							},
+							{
+								Usage:          5 * time.Minute,
+								Cost:           23,
+								AccountingID:   "acc_id2",
+								CompressFactor: 5,
+							},
+						},
+						CompressFactor: 3,
+						usage:          utils.DurationPointer(10 * time.Minute),
+						ecUsageIdx:     utils.DurationPointer(4 * time.Minute),
+						cost:           utils.Float64Pointer(38),
+					},
+				},
+				AccountSummary: &AccountSummary{
+					Tenant:           "Tenant",
+					ID:               "acc_id",
+					BalanceSummaries: BalanceSummaries{},
+					AllowNegative:    false,
+					Disabled:         true,
+				},
+
+				Accounting: Accounting{
+					"acc_id": &BalanceCharge{
+						RatingID: "acc_id",
+					},
+					"acc_id2": &BalanceCharge{
+						RatingID: "acc_id2",
+					},
+				},
+				RatingFilters: RatingFilters{
+					"filtersid": RatingMatchedFilters{
+						utils.Subject:               "string",
+						utils.DestinationPrefixName: "string",
+						utils.DestinationID:         "dest",
+						utils.RatingPlanID:          "rating",
+					},
+					"ratefilter": RatingMatchedFilters{
+						utils.Subject:               "string",
+						utils.DestinationPrefixName: "string",
+						utils.DestinationID:         "dest",
+						utils.RatingPlanID:          "rating",
+					},
+				},
+				Rates:   ChargedRates{},
+				Timings: ChargedTimings{},
+				Rating: Rating{
+					"acc_id": &RatingUnit{
+						ConnectFee:       21,
+						RoundingMethod:   "method",
+						RoundingDecimals: 3,
+						MaxCost:          22,
+						MaxCostStrategy:  "sr",
+						RatesID:          "rates",
+						RatingFiltersID:  "filtersid",
+					},
+
+					"acc_id2": &RatingUnit{
+						ConnectFee:       21,
+						RoundingMethod:   "method",
+						RoundingDecimals: 3,
+						MaxCost:          22,
+						MaxCostStrategy:  "sr",
+						RatesID:          "rates",
+						RatingFiltersID:  "ratefilter",
+					},
+				},
+			},
+		},
+		Tenant:  "cgrates.org",
+		APIOpts: map[string]interface{}{},
+	}
+	if err := cdrS.V2StoreSessionCost(args, utils.StringPointer("reply")); err != nil {
+		t.Error(err)
+	}
+
+}

engine/responder_test.go

@@ -626,8 +626,8 @@ func TestResponderDebit(t *testing.T) {
 		Account:     "acount",
 		Destination: "uk",
 	}
-	if err := rs.Debit(arg, reply); err == nil {
-		t.Error(err)
+	if err := rs.Debit(arg, reply); err == nil || err != utils.ErrAccountNotFound {
+		t.Errorf("expected %+v ,received %+v", utils.ErrAccountNotFound, err)
 	}
 }
 
@@ -655,8 +655,8 @@ func TestGetCostOnRatingPlans(t *testing.T) {
 			dm:  dm,
 		},
 	}
-	if err := rs.GetCostOnRatingPlans(arg, reply); err == nil {
-		t.Error(err)
+	if err := rs.GetCostOnRatingPlans(arg, reply); err == nil || err != utils.ErrUnauthorizedDestination {
+		t.Errorf("expected %+v ,received %+v", utils.ErrUnauthorizedDestination, err)
 	}
 }
 
@@ -781,8 +781,8 @@ func TestResponderMaxDebit(t *testing.T) {
 		Account:     "acount",
 		Destination: "uk",
 	}
-	if err := rs.MaxDebit(arg, reply); err == nil {
-		t.Error(err)
+	if err := rs.MaxDebit(arg, reply); err == nil || err != utils.ErrAccountNotFound {
+		t.Errorf("expected %+v ,received %+v", utils.ErrAccountNotFound, err)
 	}
 	exp := &utils.CachedRPCResponse{
 		Result: reply,

engine/routes_test.go

@@ -829,58 +829,6 @@ func TestRouteProfileCompileCacheParameters(t *testing.T) {
 
 }
 
-func TestRouteServiceCostForEvent(t *testing.T) {
-	ccMock := &ccMock{
-		calls: map[string]func(args, reply interface{}) error{
-			utils.ResponderGetMaxSessionTimeOnAccounts: func(args, reply interface{}) error {
-				rpl := map[string]interface{}{
-					utils.CapMaxUsage: 10 * time.Minute,
-				}
-				*reply.(*map[string]interface{}) = rpl
-				return nil
-			},
-			utils.ResponderGetMaxSessionTime: func(args, reply interface{}) error {
-				rpl := map[string]interface{}{
-					utils.CapMaxUsage: 20 * time.Minute,
-				}
-				*reply.(*map[string]interface{}) = rpl
-				return nil
-			},
-		},
-	}
-	cfg := config.NewDefaultCGRConfig()
-
-	data := NewInternalDB(nil, nil, true, cfg.DataDbCfg().Items)
-	dmSPP := NewDataManager(data, config.CgrConfig().CacheCfg(), nil)
-	cfg.RouteSCfg().StringIndexedFields = nil
-	cfg.RouteSCfg().PrefixIndexedFields = nil
-	cfg.RouteSCfg().RALsConns = []string{utils.ConcatenatedKey(utils.MetaInternal, utils.MetaAttributes)}
-	clientconn := make(chan rpcclient.ClientConnector, 1)
-	clientconn <- ccMock
-	connMgr := NewConnManager(cfg, map[string]chan rpcclient.ClientConnector{
-		utils.ConcatenatedKey(utils.MetaInternal, utils.MetaAttributes): clientconn})
-	routeService := NewRouteService(dmSPP, &FilterS{
-		dm: dmSPP, cfg: cfg, connMgr: nil}, cfg, connMgr)
-	ev := &utils.CGREvent{
-		Tenant: "tnt",
-		ID:     "id",
-
-		Time: utils.TimePointer(time.Date(2022, 12, 1, 20, 0, 0, 0, time.UTC)),
-		Event: map[string]interface{}{
-			utils.AccountField: "acc_event",
-			utils.Destination:  "desc_event",
-			utils.SetupTime:    time.Now(),
-			utils.Usage:        20 * time.Minute,
-		},
-	}
-	if _, err := routeService.costForEvent(ev, []string{}, []string{}); err == nil {
-		t.Error(err)
-	} else if _, err := routeService.costForEvent(ev, []string{"acc1", "acc2", "acc3"}, []string{"rpid"}); err == nil {
-		t.Error(err)
-	}
-
-}
-
 func TestRouteServiceStatMetrics(t *testing.T) {
 
 	testMock := &ccMock{
@@ -1081,71 +1029,6 @@ func TestRouteServiceV1GetRoutes(t *testing.T) {
 
 }
 
-func TestRouteServiceResourceUsage(t *testing.T) {
-	ccMock := &ccMock{
-		calls: map[string]func(args, reply interface{}) error{
-			utils.ResourceSv1GetResource: func(args, reply interface{}) error {
-				rpl := &Resource{
-					Usages: map[string]*ResourceUsage{
-						"test_usage1": {
-							Units: 29.2,
-						},
-						"test_usage2": {
-							Units: 19,
-						},
-					},
-				}
-				*reply.(*Resource) = *rpl
-				return nil
-			},
-		},
-	}
-	cfg := config.NewDefaultCGRConfig()
-	clientconn := make(chan rpcclient.ClientConnector, 1)
-	clientconn <- ccMock
-	connMgr := NewConnManager(cfg, map[string]chan rpcclient.ClientConnector{
-		utils.ConcatenatedKey(utils.MetaInternal, utils.ResourceSConnsCfg): clientconn,
-	})
-	data := NewInternalDB(nil, nil, true, cfg.DataDbCfg().Items)
-	dmSPP := NewDataManager(data, config.CgrConfig().CacheCfg(), nil)
-	cfg.RouteSCfg().StringIndexedFields = nil
-	cfg.RouteSCfg().PrefixIndexedFields = nil
-	cfg.RouteSCfg().ResourceSConns = []string{utils.ConcatenatedKey(utils.MetaInternal, utils.ResourceSConnsCfg)}
-	rpS := NewRouteService(dmSPP, &FilterS{dm: dmSPP, cfg: cfg, connMgr: nil}, cfg, connMgr)
-	if _, err := rpS.resourceUsage([]string{"res1", "res2", "res3"}, "cgrates.org"); err != nil {
-		t.Error(err)
-	}
-}
-
-func TestRouteServiceStatMetricsForLoadDistribution(t *testing.T) {
-	ccMock := &ccMock{
-		calls: map[string]func(args interface{}, reply interface{}) error{
-			utils.StatSv1GetQueueFloatMetrics: func(args, reply interface{}) error {
-				rpl := map[string]float64{
-					"stat": 2.1,
-				}
-				*reply.(*map[string]float64) = rpl
-				return nil
-			},
-		},
-	}
-	clientconn := make(chan rpcclient.ClientConnector, 1)
-	clientconn <- ccMock
-	cfg := config.NewDefaultCGRConfig()
-	connMgr := NewConnManager(cfg, map[string]chan rpcclient.ClientConnector{
-		utils.ConcatenatedKey(utils.MetaInternal, utils.StatSConnsCfg): clientconn})
-	data := NewInternalDB(nil, nil, true, cfg.DataDbCfg().Items)
-	dmSPP := NewDataManager(data, config.CgrConfig().CacheCfg(), nil)
-	cfg.RouteSCfg().StringIndexedFields = nil
-	cfg.RouteSCfg().PrefixIndexedFields = nil
-	cfg.RouteSCfg().StatSConns = []string{utils.ConcatenatedKey(utils.MetaInternal, utils.StatSConnsCfg)}
-	rpS := NewRouteService(dmSPP, &FilterS{dm: dmSPP, cfg: cfg, connMgr: nil}, cfg, connMgr)
-	if _, err := rpS.statMetricsForLoadDistribution([]string{"res1", "res2", "res3"}, "cgrates.org"); err != nil {
-		t.Error(err)
-	}
-
-}
-
 func TestRouteServiceSortRoutes(t *testing.T) {
 	cfg := config.NewDefaultCGRConfig()
 	data := NewInternalDB(nil, nil, true, cfg.DataDbCfg().Items)
@@ -1765,3 +1648,115 @@ func TestLoadDistributionSorterSortRoutes(t *testing.T) {
 		t.Error(err)
 	}
 }
+
+func TestRouteServicePopulateSortingData(t *testing.T) {
+
+	ccMock := &ccMock{
+		calls: map[string]func(args, reply interface{}) error{
+			utils.ResponderGetMaxSessionTimeOnAccounts: func(args, reply interface{}) error {
+				rpl := map[string]interface{}{
+					utils.CapMaxUsage: 1 * time.Second,
+					utils.Cost:        0,
+				}
+				*reply.(*map[string]interface{}) = rpl
+				return nil
+			},
+			utils.ResponderGetCostOnRatingPlans: func(args, reply interface{}) error {
+				rpl := map[string]interface{}{
+					utils.CapMaxUsage: 5 * time.Second,
+					utils.Cost:        0,
+				}
+				*reply.(*map[string]interface{}) = rpl
+				return nil
+			},
+			utils.StatSv1GetQueueFloatMetrics: func(args, reply interface{}) error {
+				rpl := &map[string]float64{
+					"metric1": 12,
+					"stat":    2.1,
+				}
+				*reply.(*map[string]float64) = *rpl
+				return nil
+			},
+			utils.ResourceSv1GetResource: func(args, reply interface{}) error {
+				rpl := &Resource{
+					Usages: map[string]*ResourceUsage{
+						"test_usage1": {
+							Units: 20,
+						},
+						"test_usage2": {
+							Units: 19,
+						},
+					},
+				}
+				*reply.(*Resource) = *rpl
+				return nil
+			},
+		},
+	}
+	cfg := config.NewDefaultCGRConfig()
+
+	data := NewInternalDB(nil, nil, true, cfg.DataDbCfg().Items)
+	dmSPP := NewDataManager(data, config.CgrConfig().CacheCfg(), nil)
+	cfg.RouteSCfg().StringIndexedFields = nil
+	cfg.RouteSCfg().PrefixIndexedFields = nil
+	cfg.RouteSCfg().ResourceSConns = []string{utils.ConcatenatedKey(utils.MetaInternal, utils.ResourceSConnsCfg)}
+	cfg.RouteSCfg().StatSConns = []string{utils.ConcatenatedKey(utils.MetaInternal, utils.StatSConnsCfg)}
+	cfg.RouteSCfg().RALsConns = []string{utils.ConcatenatedKey(utils.MetaInternal, utils.RALsConnsCfg)}
+	clientconn := make(chan rpcclient.ClientConnector, 1)
+	clientconn <- ccMock
+	connMgr := NewConnManager(cfg, map[string]chan rpcclient.ClientConnector{
+		utils.ConcatenatedKey(utils.MetaInternal, utils.RALsConnsCfg):      clientconn,
+		utils.ConcatenatedKey(utils.MetaInternal, utils.StatSConnsCfg):     clientconn,
+		utils.ConcatenatedKey(utils.MetaInternal, utils.ResourceSConnsCfg): clientconn})
+	routeService := NewRouteService(dmSPP, &FilterS{
+		dm: dmSPP, cfg: cfg, connMgr: nil}, cfg, connMgr)
+	ev := &utils.CGREvent{
+		Tenant: "cgrates.org",
+		ID:     "id",
+
+		Time: utils.TimePointer(time.Date(2022, 12, 1, 20, 0, 0, 0, time.UTC)),
+		Event: map[string]interface{}{
+			utils.AccountField: "acc_event",
+			utils.Destination:  "desc_event",
+			utils.SetupTime:    time.Now(),
+			utils.Usage:        20 * time.Minute,
+		},
+	}
+	route := &Route{
+		ID:              "id",
+		Weight:          21.1,
+		RouteParameters: "params",
+		AccountIDs:      []string{"acc1", "acc2", "acc3"},
+		RatingPlanIDs:   []string{"rpid"},
+		StatIDs:         []string{"stat"},
+		ResourceIDs:     []string{"res1", "res2", "res3"},
+	}
+
+	extraOpts := &optsGetRoutes{
+		sortingStrategy: utils.MetaLoad,
+	}
+	exp := &SortedRoute{
+		RouteID:         "id",
+		RouteParameters: "params",
+		SortingData: map[string]interface{}{
+			"Cost":          0,
+			"Load":          14.1,
+			"MaxUsage":      5 * time.Second,
+			"ResourceUsage": 117.0,
+			"Weight":        21.1,
+		},
+		sortingDataF64: map[string]float64{
+			"Cost":          0.0,
+			"Load":          14.1,
+			"MaxUsage":      5000000000.0,
+			"ResourceUsage": 117.0,
+			"Weight":        21.1,
+		},
+	}
+
+	if sroutes, pass, err := routeService.populateSortingData(ev, route, extraOpts); err != nil || !pass {
+		t.Error(err)
+	} else if !reflect.DeepEqual(exp.SortingData, sroutes.SortingData) {
+		t.Errorf("expected %+v,received %+v", utils.ToJSON(exp), utils.ToJSON(sroutes))
+	}
+}

engine/tpreader_test.go

@@ -1054,3 +1054,72 @@ func TestTPReaderLoadAll(t *testing.T) {
 		t.Error(err)
 	}
 }
+
+func TestTpReaderReloadScheduler(t *testing.T) {
+	cfg := config.NewDefaultCGRConfig()
+	ccMocK := &ccMock{
+		calls: map[string]func(args interface{}, reply interface{}) error{
+			utils.SchedulerSv1Reload: func(args, reply interface{}) error {
+				rpl := "reply"
+
+				*reply.(*string) = rpl
+				return nil
+			},
+		},
+	}
+	clientconn := make(chan rpcclient.ClientConnector, 1)
+	clientconn <- ccMocK
+
+	tmp := connMgr
+	defer func() { connMgr = tmp }()
+	connMgr = NewConnManager(cfg, map[string]chan rpcclient.ClientConnector{
+		utils.ConcatenatedKey(utils.MetaInternal, utils.SchedulerConnsCfg): clientconn,
+	})
+
+	tpr := &TpReader{
+		actions: map[string][]*Action{
+			"ActionsID": {},
+		},
+		actionPlans: map[string]*ActionPlan{
+			"ActionPlansID":  {},
+			"ActionPlansID2": {},
+		},
+
+		resProfiles: map[utils.TenantID]*utils.TPResourceProfile{
+			{Tenant: "cgrates.org", ID: "resourceProfilesID"}: {},
+		},
+		sqProfiles: map[utils.TenantID]*utils.TPStatProfile{
+			{Tenant: "cgrates.org", ID: "statProfilesID"}: {},
+		},
+		thProfiles: map[utils.TenantID]*utils.TPThresholdProfile{
+			{Tenant: "cgrates.org", ID: "thresholdProfilesID"}: {},
+		},
+		filters: map[utils.TenantID]*utils.TPFilterProfile{
+			{Tenant: "cgrates.org", ID: "filtersID"}: {},
+		},
+		routeProfiles: map[utils.TenantID]*utils.TPRouteProfile{
+			{Tenant: "cgrates.org", ID: "routeProfilesID"}: {},
+		},
+		attributeProfiles: map[utils.TenantID]*utils.TPAttributeProfile{
+			{Tenant: "cgrates.org", ID: "attributeProfilesID"}: {},
+		},
+		chargerProfiles: map[utils.TenantID]*utils.TPChargerProfile{
+			{Tenant: "cgrates.org", ID: "chargerProfilesID"}: {},
+		},
+		dispatcherProfiles: map[utils.TenantID]*utils.TPDispatcherProfile{
+			{Tenant: "cgrates.org", ID: "dispatcherProfilesID"}: {},
+		},
+		dispatcherHosts: map[utils.TenantID]*utils.TPDispatcherHost{
+			{Tenant: "cgrates.org", ID: "dispatcherHostsID"}: {},
+		},
+
+		dm: NewDataManager(NewInternalDB(nil, nil, false, cfg.DataDbCfg().Items), config.CgrConfig().CacheCfg(), connMgr),
+	}
+	tpr.dm.SetLoadIDs(make(map[string]int64))
+	tpr.schedulerConns = []string{utils.ConcatenatedKey(utils.MetaInternal, utils.SchedulerConnsCfg)}
+
+	if err := tpr.ReloadScheduler(false); err != nil {
+		t.Error(err)
+	}
+
+}