Improving coverage at engine

engine/action_trigger_test.go

@@ -19,7 +19,11 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>
 package engine
 
 import (
+	"bytes"
+	"log"
+	"os"
 	"reflect"
+	"strings"
 	"testing"
 	"time"
 
@@ -256,11 +260,17 @@ func TestActionTriggerCreateBalance(t *testing.T) {
 
 }
 
-func TestATExecute(t *testing.T) {
+func TestATExecute22(t *testing.T) {
 	cfg := config.NewDefaultCGRConfig()
 	tmp := Cache
 	tmpDm := dm
+	utils.Logger.SetLogLevel(4)
+	utils.Logger.SetSyslog(nil)
+	buf := new(bytes.Buffer)
+	log.SetOutput(buf)
 	defer func() {
+		utils.Logger.SetLogLevel(0)
+		log.SetOutput(os.Stderr)
 		Cache = tmp
 		SetDataStorage(tmpDm)
 		config.SetCgrConfig(config.NewDefaultCGRConfig())
@@ -290,7 +300,6 @@ func TestATExecute(t *testing.T) {
 		AllowNegative:  false,
 		UpdateTime:     time.Date(2019, 3, 1, 12, 0, 0, 0, time.UTC),
 	}
-	fltrStr := `*lt:~*req.BalanceMap.*monetary.GetTotalValue:3`
 	db.db.Set(utils.CacheActions, "actID", Actions{
 		{
 			Id:               "cgrates.org:id1",
@@ -300,18 +309,31 @@ func TestATExecute(t *testing.T) {
 				Type:  utils.StringPointer("test"),
 				Value: &utils.ValueFormula{Static: 1.1},
 			},
-			Filters: []string{fltrStr},
+			Filters: []string{
+				"fltr",
+			},
 		},
 	}, []string{}, true, utils.NonTransactional)
+	fltrNew := &Filter{
+		ID:     "fltr",
+		Tenant: "cgrates.org",
+		Rules: []*FilterRule{
+			{
+				Type:    utils.MetaString,
+				Element: "~*req.ID",
+				Values:  []string{"acc_id", "acc1", "acc2"},
+			},
+		},
+	}
 	SetDataStorage(dm)
 	fltr := NewFilterS(cfg, nil, dm)
-	db.db.Set(utils.CacheFilters, utils.ConcatenatedKey("cgrates.org", fltrStr), &Filter{
-		ActivationInterval: &utils.ActivationInterval{
-			ActivationTime: time.Date(2022, 1, 12, 1, 0, 0, 0, time.UTC),
-			ExpiryTime:     time.Date(2024, 1, 12, 1, 0, 0, 0, time.UTC),
-		},
-	}, []string{}, true, utils.NonTransactional)
+	db.db.Set(utils.CacheFilters, utils.ConcatenatedKey("cgrates.org", "fltr"),
+		fltrNew, []string{}, true, utils.NonTransactional)
 	if err := at.Execute(ub, fltr); err != nil {
 		t.Error(err)
 	}
+	expLog := ` not available, aborting execution!`
+	if rcvLog := buf.String(); !strings.Contains(rcvLog, expLog) {
+		t.Errorf("expected %v,received%v", expLog, rcvLog)
+	}
 }

engine/balances_test.go

@@ -18,7 +18,11 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>
 package engine
 
 import (
+	"bytes"
+	"log"
+	"os"
 	"reflect"
+	"strings"
 	"testing"
 	"time"
 
@@ -753,3 +757,38 @@ func TestBalanceDebitUnits2(t *testing.T) {
 		t.Errorf("received %v", err)
 	}
 }
+
+func TestGetMinutesForCredi(t *testing.T) {
+	utils.Logger.SetLogLevel(4)
+	utils.Logger.SetSyslog(nil)
+	buf := new(bytes.Buffer)
+	log.SetOutput(buf)
+	defer func() {
+		utils.Logger.SetLogLevel(0)
+		log.SetOutput(os.Stderr)
+	}()
+	b := &Balance{
+		Value:          20 * float64(time.Second),
+		DestinationIDs: utils.NewStringMap("NAT"),
+		Weight:         10, RatingSubject: "rif",
+	}
+	cd := &CallDescriptor{
+		Category:      "postpaid",
+		ToR:           utils.MetaVoice,
+		Tenant:        "foehn",
+		Subject:       "foehn",
+		Account:       "foehn",
+		Destination:   "0034678096720",
+		TimeStart:     time.Date(2015, 4, 24, 7, 59, 4, 0, time.UTC),
+		TimeEnd:       time.Date(2015, 4, 24, 8, 2, 0, 0, time.UTC),
+		LoopIndex:     0,
+		DurationIndex: 176 * time.Second,
+	}
+	if dur, _ := b.GetMinutesForCredit(cd, 12); dur != 0 {
+		t.Error(err)
+	}
+	expLog := `Error getting new cost for balance subject:`
+	if rcvLog := buf.String(); !strings.Contains(rcvLog, expLog) {
+		t.Errorf("expected %v,received %v", utils.ToJSON(expLog), utils.ToJSON(rcvLog))
+	}
+}

engine/cdrs_test.go

@@ -248,51 +248,7 @@ func TestArgV1ProcessClone(t *testing.T) {
 
 }
 
-func TestCDRV1GetCDRs(t *testing.T) {
-
-	cfg := config.NewDefaultCGRConfig()
-	defer func() {
-		config.SetCgrConfig(config.NewDefaultCGRConfig())
-	}()
-	db := NewInternalDB(nil, nil, true, cfg.DataDbCfg().Items)
-	dm := NewDataManager(db, cfg.CacheCfg(), nil)
-	cdrS := &CDRServer{
-		cgrCfg:  cfg,
-		connMgr: nil,
-		cdrDb:   NewInternalDB(nil, nil, true, cfg.DataDbCfg().Items),
-		dm:      dm,
-	}
-	args := utils.RPCCDRsFilterWithAPIOpts{
-
-		RPCCDRsFilter: &utils.RPCCDRsFilter{
-			CGRIDs:         []string{"CGRIDs"},
-			NotCGRIDs:      []string{"NotCGRIDs"},
-			RunIDs:         []string{"RunIDs"},
-			NotRunIDs:      []string{"NotRunIDs"},
-			OriginIDs:      []string{"OriginIDs"},
-			NotOriginIDs:   []string{"NotOriginIDs"},
-			OriginHosts:    []string{"OriginHosts"},
-			SetupTimeStart: "2020-04-18T11:46:26.371Z",
-			SetupTimeEnd:   "2020-04-18T11:46:26.371Z",
-		},
-		Tenant:  "cgrates.org",
-		APIOpts: map[string]interface{}{},
-	}
-	cdrs := &[]*CDR{
-		{
-			CGRID: "cgrid"},
-		{
-			CGRID: "cgr1d",
-		},
-	}
-	if err := cdrS.V1GetCDRs(args, cdrs); err == nil || err.Error() != fmt.Sprintf("SERVER_ERROR: %s", utils.ErrNotFound) {
-		t.Error(utils.NewErrServerError(utils.ErrNotFound))
-	}
-
-}
-
 func TestCDRV1CountCDRs(t *testing.T) {
-
 	cfg := config.NewDefaultCGRConfig()
 	cfg.GeneralCfg().DefaultTimezone = "UTC"
 	db := NewInternalDB(nil, nil, true, cfg.DataDbCfg().Items)
@@ -314,7 +270,33 @@ func TestCDRV1CountCDRs(t *testing.T) {
 	if err := cdrS.V1CountCDRs(args, &i); err != nil {
 		t.Error(err)
 	}
-
+}
+func TestV1CountCDRsErr(t *testing.T) {
+	cfg := config.NewDefaultCGRConfig()
+	cfg.GeneralCfg().DefaultTimezone = "UTC"
+	db := NewInternalDB(nil, nil, true, cfg.DataDbCfg().Items)
+	dm := NewDataManager(db, cfg.CacheCfg(), nil)
+	cdrS := &CDRServer{
+		cgrCfg:  cfg,
+		connMgr: nil,
+		cdrDb:   NewInternalDB(nil, nil, true, cfg.DataDbCfg().Items),
+		dm:      dm,
+	}
+	args := &utils.RPCCDRsFilterWithAPIOpts{
+		RPCCDRsFilter: &utils.RPCCDRsFilter{
+			Accounts:       []string{"1001"},
+			RunIDs:         []string{utils.MetaDefault},
+			SetupTimeStart: "fdd",
+		},
+		Tenant: "cgrates.org",
+		APIOpts: map[string]interface{}{
+			utils.OptsAPIKey: "cdrs12345",
+		},
+	}
+	i := utils.Int64Pointer(23)
+	if err := cdrS.V1CountCDRs(args, i); err == nil {
+		t.Error(err)
+	}
 }
 func TestV1RateCDRs(t *testing.T) {
 	cfg := config.NewDefaultCGRConfig()
@@ -1356,10 +1338,15 @@ func TestV2StoreSessionCost(t *testing.T) {
 	if !has {
 		t.Error("has no value")
 	}
-
 	if !reflect.DeepEqual(exp, rcv) {
 		t.Errorf("expected %+v,received %+v", utils.ToJSON(exp), utils.ToJSON(rcv))
 	}
+	args = &ArgsV2CDRSStoreSMCost{
+		Cost: &V2SMCost{},
+	}
+	if err = cdrS.V2StoreSessionCost(args, &reply); err == nil {
+		t.Error(err)
+	}
 }
 
 func TestV2StoreSessionCostSet(t *testing.T) {
@@ -1510,7 +1497,41 @@ func TestV1RateCDRS(t *testing.T) {
 	if err := cdrS.V1RateCDRs(arg, &reply); err == nil || err != utils.ErrNotFound {
 		t.Error(err)
 	}
+}
 
+func TestV1GetCDRsErr(t *testing.T) {
+	cfg := config.NewDefaultCGRConfig()
+	defer func() {
+		config.SetCgrConfig(config.NewDefaultCGRConfig())
+	}()
+	db := NewInternalDB(nil, nil, true, cfg.DataDbCfg().Items)
+	dm := NewDataManager(db, cfg.CacheCfg(), nil)
+	cdrS := &CDRServer{
+		cgrCfg:  cfg,
+		connMgr: nil,
+		cdrDb:   NewInternalDB(nil, nil, true, cfg.DataDbCfg().Items),
+		dm:      dm,
+	}
+	args := utils.RPCCDRsFilterWithAPIOpts{
+
+		RPCCDRsFilter: &utils.RPCCDRsFilter{
+			CGRIDs:         []string{"CGRIDs"},
+			NotCGRIDs:      []string{"NotCGRIDs"},
+			OriginHosts:    []string{"OriginHosts"},
+			SetupTimeStart: "time",
+			SetupTimeEnd:   "2020-04-18T11:46:26.371Z",
+		},
+		Tenant:  "cgrates.org",
+		APIOpts: map[string]interface{}{},
+	}
+	var cdrs *[]*CDR
+	if err := cdrS.V1GetCDRs(args, cdrs); err == nil {
+		t.Error(utils.NewErrServerError(utils.ErrNotFound))
+	}
+	args.RPCCDRsFilter.SetupTimeStart = ""
+	if err := cdrS.V1GetCDRs(args, cdrs); err == nil || err.Error() != fmt.Sprintf("SERVER_ERROR: %s", utils.ErrNotFound) {
+		t.Error(utils.NewErrServerError(utils.ErrNotFound))
+	}
 }
 func TestGetCostFromRater2(t *testing.T) {
 	cfg := config.NewDefaultCGRConfig()

engine/datamanager_test.go

@@ -1284,7 +1284,6 @@ func TestDmDispatcherHost(t *testing.T) {
 	dm := NewDataManager(db, cfg.CacheCfg(), connMgr)
 	config.SetCgrConfig(cfg)
 	SetDataStorage(dm)
-
 	dH := &DispatcherHost{
 		Tenant: "testTenant",
 		RemoteHost: &config.RemoteHost{
@@ -1309,3 +1308,295 @@ func TestDmDispatcherHost(t *testing.T) {
 		t.Error("has not been removed from the cache")
 	}
 }
+
+func TestChargerProfileRemote(t *testing.T) {
+	cfg := config.NewDefaultCGRConfig()
+	tmpDm := dm
+	tmp := Cache
+	defer func() {
+		config.SetCgrConfig(config.NewDefaultCGRConfig())
+		Cache = tmp
+		SetDataStorage(tmpDm)
+	}()
+	Cache.Clear(nil)
+	cfg.DataDbCfg().RplConns = []string{utils.ConcatenatedKey(utils.MetaInternal, utils.ReplicatorSv1)}
+	cfg.DataDbCfg().RplFiltered = true
+	cfg.DataDbCfg().Items = map[string]*config.ItemOpt{
+		utils.CacheChargerProfiles: {
+			Limit:     3,
+			Replicate: true,
+			APIKey:    "key",
+			RouteID:   "route",
+		},
+	}
+	clientConn := make(chan rpcclient.ClientConnector, 1)
+	clientConn <- &ccMock{
+		calls: map[string]func(args interface{}, reply interface{}) error{
+			utils.ReplicatorSv1SetDispatcherHost: func(args, reply interface{}) error {
+				chrgPrflApiOpts, cancast := args.(ChargerProfileWithAPIOpts)
+				if !cancast {
+					return utils.ErrNotConvertible
+				}
+				dm.DataDB().SetChargerProfileDrv(chrgPrflApiOpts.ChargerProfile)
+				return nil
+			},
+			utils.ReplicatorSv1RemoveChargerProfile: func(args, reply interface{}) error {
+				tntApiOpts, cancast := args.(utils.TenantIDWithAPIOpts)
+				if !cancast {
+					return utils.ErrNotConvertible
+				}
+				dm.DataDB().RemoveChargerProfileDrv(tntApiOpts.Tenant, tntApiOpts.ID)
+				return nil
+			},
+		},
+	}
+	db := NewInternalDB(nil, nil, true, cfg.DataDbCfg().Items)
+	connMgr := NewConnManager(cfg, map[string]chan rpcclient.ClientConnector{
+		utils.ConcatenatedKey(utils.MetaInternal, utils.ReplicatorSv1): clientConn,
+	})
+	dm := NewDataManager(db, cfg.CacheCfg(), connMgr)
+	config.SetCgrConfig(cfg)
+	SetDataStorage(dm)
+	chrPrf := &ChargerProfile{
+		Tenant:    "cgrates.org",
+		ID:        "CPP_3",
+		FilterIDs: []string{"FLTR_CP_3"},
+		ActivationInterval: &utils.ActivationInterval{
+			ActivationTime: time.Date(2014, 7, 14, 14, 25, 0, 0, time.UTC),
+		},
+		RunID:        "*rated",
+		AttributeIDs: []string{"ATTR_1"},
+		Weight:       20,
+	}
+	if err := dm.SetChargerProfile(chrPrf, false); err != nil {
+		t.Error(err)
+	}
+	if val, err := dm.GetChargerProfile(chrPrf.Tenant, chrPrf.ID, true, false, utils.NonTransactional); err != nil {
+		t.Error(err)
+	} else if !reflect.DeepEqual(chrPrf, val) {
+		t.Errorf("expected %v,received %v", utils.ToJSON(val), utils.ToJSON(chrPrf))
+	}
+	if err = dm.RemoveChargerProfile(chrPrf.Tenant, chrPrf.ID, false); err != nil {
+		t.Error(err)
+	}
+	if _, has := db.db.Get(utils.CacheChargerProfiles, chrPrf.TenantID()); has {
+		t.Error("should been removed from the cache")
+	}
+}
+
+func TestDispatcherProfileRemote(t *testing.T) {
+	cfg := config.NewDefaultCGRConfig()
+	tmpDm := dm
+	tmp := Cache
+	defer func() {
+		config.SetCgrConfig(config.NewDefaultCGRConfig())
+		Cache = tmp
+		SetDataStorage(tmpDm)
+	}()
+	Cache.Clear(nil)
+	cfg.DataDbCfg().RplConns = []string{utils.ConcatenatedKey(utils.MetaInternal, utils.ReplicatorSv1)}
+	cfg.DataDbCfg().RplFiltered = true
+	cfg.DataDbCfg().Items = map[string]*config.ItemOpt{
+		utils.CacheDispatcherProfiles: {
+			Limit:     3,
+			Replicate: true,
+			APIKey:    "key",
+			RouteID:   "route",
+		},
+	}
+	clientConn := make(chan rpcclient.ClientConnector, 1)
+	clientConn <- &ccMock{
+		calls: map[string]func(args interface{}, reply interface{}) error{
+			utils.ReplicatorSv1SetDispatcherProfile: func(args, reply interface{}) error {
+				dspApiOpts, cancast := args.(DispatcherProfileWithAPIOpts)
+				if !cancast {
+					return utils.ErrNotConvertible
+				}
+				dm.DataDB().SetDispatcherProfileDrv(dspApiOpts.DispatcherProfile)
+				return nil
+			},
+			utils.ReplicatorSv1RemoveDispatcherProfile: func(args, reply interface{}) error {
+				tntApiOpts, cancast := args.(utils.TenantIDWithAPIOpts)
+				if !cancast {
+					return utils.ErrNotConvertible
+				}
+				dm.DataDB().RemoveDispatcherProfileDrv(tntApiOpts.Tenant, tntApiOpts.ID)
+				return nil
+			},
+		},
+	}
+	db := NewInternalDB(nil, nil, true, cfg.DataDbCfg().Items)
+	connMgr := NewConnManager(cfg, map[string]chan rpcclient.ClientConnector{
+		utils.ConcatenatedKey(utils.MetaInternal, utils.ReplicatorSv1): clientConn,
+	})
+	dm := NewDataManager(db, cfg.CacheCfg(), connMgr)
+	config.SetCgrConfig(cfg)
+	SetDataStorage(dm)
+	dsp := &DispatcherProfile{
+		Tenant:     "cgrates.org",
+		ID:         "Dsp1",
+		FilterIDs:  []string{"*string:~*req.Account:1001"},
+		Subsystems: []string{utils.MetaAny},
+		Strategy:   utils.MetaFirst,
+		Weight:     20,
+	}
+	if err := dm.SetDispatcherProfile(dsp, false); err != nil {
+		t.Error(err)
+	}
+	if val, err := dm.GetDispatcherProfile(dsp.Tenant, dsp.ID, true, false, utils.NonTransactional); err != nil {
+		t.Error(err)
+	} else if !reflect.DeepEqual(val, dsp) {
+		t.Errorf("expected %v,received %v", utils.ToJSON(dsp), utils.ToJSON(val))
+	}
+	if err := dm.RemoveDispatcherProfile(dsp.Tenant, dsp.ID, false); err != nil {
+		t.Error(err)
+	}
+	if _, has := db.db.Get(utils.CacheDispatcherProfiles, dsp.TenantID()); has {
+		t.Error("should been removed from the cache")
+	}
+}
+
+func TestRouteProfileRemote(t *testing.T) {
+	cfg := config.NewDefaultCGRConfig()
+	tmpDm := dm
+	tmp := Cache
+	defer func() {
+		config.SetCgrConfig(config.NewDefaultCGRConfig())
+		Cache = tmp
+		SetDataStorage(tmpDm)
+	}()
+	Cache.Clear(nil)
+	cfg.DataDbCfg().RplConns = []string{utils.ConcatenatedKey(utils.MetaInternal, utils.ReplicatorSv1)}
+	cfg.DataDbCfg().RplFiltered = true
+	cfg.DataDbCfg().Items = map[string]*config.ItemOpt{
+		utils.CacheRouteProfiles: {
+			Limit:     3,
+			Replicate: true,
+			APIKey:    "key",
+			RouteID:   "route",
+		},
+	}
+	clientConn := make(chan rpcclient.ClientConnector, 1)
+	clientConn <- &ccMock{
+		calls: map[string]func(args interface{}, reply interface{}) error{
+			utils.ReplicatorSv1SetRouteProfile: func(args, reply interface{}) error {
+				routeApiOpts, cancast := args.(RouteProfileWithAPIOpts)
+				if !cancast {
+					return utils.ErrNotConvertible
+				}
+				dm.DataDB().SetRouteProfileDrv(routeApiOpts.RouteProfile)
+				return nil
+			},
+			utils.ReplicatorSv1RemoveRouteProfile: func(args, reply interface{}) error {
+				tntApiOpts, cancast := args.(utils.TenantIDWithAPIOpts)
+				if !cancast {
+					return utils.ErrNotConvertible
+				}
+				dm.DataDB().RemoveRouteProfileDrv(tntApiOpts.Tenant, tntApiOpts.ID)
+				return nil
+			},
+		},
+	}
+	db := NewInternalDB(nil, nil, true, cfg.DataDbCfg().Items)
+	connMgr := NewConnManager(cfg, map[string]chan rpcclient.ClientConnector{
+		utils.ConcatenatedKey(utils.MetaInternal, utils.ReplicatorSv1): clientConn,
+	})
+	dm := NewDataManager(db, cfg.CacheCfg(), connMgr)
+	config.SetCgrConfig(cfg)
+	SetDataStorage(dm)
+	rpp := &RouteProfile{
+		Tenant:    "cgrates.org",
+		ID:        "ROUTE_ACNT_1002",
+		FilterIDs: []string{"FLTR_ACNT_1002"},
+	}
+	if err := dm.SetRouteProfile(rpp, false); err != nil {
+		t.Error(err)
+	}
+	if val, err := dm.GetRouteProfile(rpp.Tenant, rpp.ID, true, false, utils.NonTransactional); err != nil {
+		t.Error(err)
+	} else if !reflect.DeepEqual(val, rpp) {
+		t.Errorf("expected %v,received %v", utils.ToJSON(rpp), utils.ToJSON(val))
+	}
+	if err := dm.RemoveRouteProfile(rpp.Tenant, rpp.ID, false); err != nil {
+		t.Error(err)
+	}
+	if _, has := db.db.Get(utils.CacheRouteProfiles, rpp.TenantID()); has {
+		t.Error("should been removed from the cache")
+	}
+}
+
+func TestRatingPlanRemote(t *testing.T) {
+	cfg := config.NewDefaultCGRConfig()
+	tmpDm := dm
+	tmp := Cache
+	defer func() {
+		config.SetCgrConfig(config.NewDefaultCGRConfig())
+		Cache = tmp
+		SetDataStorage(tmpDm)
+	}()
+	Cache.Clear(nil)
+	cfg.DataDbCfg().RplConns = []string{utils.ConcatenatedKey(utils.MetaInternal, utils.ReplicatorSv1)}
+	cfg.DataDbCfg().RplFiltered = true
+	cfg.DataDbCfg().Items = map[string]*config.ItemOpt{
+		utils.CacheRatingPlans: {
+			Limit:     3,
+			Replicate: true,
+			APIKey:    "key",
+			RouteID:   "route",
+		},
+	}
+	clientConn := make(chan rpcclient.ClientConnector, 1)
+	clientConn <- &ccMock{
+		calls: map[string]func(args interface{}, reply interface{}) error{
+			utils.ReplicatorSv1SetRatingPlan: func(args, reply interface{}) error {
+				rPnApiOpts, cancast := args.(RatingPlanWithAPIOpts)
+				if !cancast {
+					return utils.ErrNotConvertible
+				}
+				dm.DataDB().SetRatingPlanDrv(rPnApiOpts.RatingPlan)
+				return nil
+			},
+			utils.ReplicatorSv1RemoveRatingPlan: func(args, reply interface{}) error {
+				strApiOpts, cancast := args.(utils.StringWithAPIOpts)
+				if !cancast {
+					return utils.ErrNotConvertible
+				}
+				dm.DataDB().RemoveRatingPlanDrv(strApiOpts.Arg)
+				return nil
+			},
+		},
+	}
+	db := NewInternalDB(nil, nil, true, cfg.DataDbCfg().Items)
+	connMgr := NewConnManager(cfg, map[string]chan rpcclient.ClientConnector{
+		utils.ConcatenatedKey(utils.MetaInternal, utils.ReplicatorSv1): clientConn,
+	})
+	dm := NewDataManager(db, cfg.CacheCfg(), connMgr)
+	config.SetCgrConfig(cfg)
+	SetDataStorage(dm)
+	rP := &RatingPlan{
+		Id: "RP1",
+		Timings: map[string]*RITiming{
+			"30eab300": {
+				Years:     utils.Years{},
+				Months:    utils.Months{},
+				MonthDays: utils.MonthDays{},
+				WeekDays:  utils.WeekDays{},
+				StartTime: "00:00:00",
+			},
+		},
+	}
+	if err := dm.SetRatingPlan(rP); err != nil {
+		t.Error(err)
+	}
+	if val, err := dm.GetRatingPlan(rP.Id, false, utils.NonTransactional); err != nil {
+		t.Error(err)
+	} else if !reflect.DeepEqual(val, rP) {
+		t.Errorf("expected %v,received %v", utils.ToJSON(rP), utils.ToJSON(val))
+	}
+	if err = dm.RemoveRatingPlan(rP.Id, utils.NonTransactional); err != nil {
+		t.Error(err)
+	}
+	if _, has := db.db.Get(utils.CacheRatingPlans, rP.Id); has {
+		t.Error("should been removed from the caches")
+	}
+}

engine/dispatcherprfl_test.go

@@ -21,6 +21,7 @@ import (
 	"reflect"
 	"testing"
 
+	"github.com/cgrates/cgrates/config"
 	"github.com/cgrates/cgrates/utils"
 )
 
@@ -321,3 +322,19 @@ func TestDispatcherHostProfileCloneWithParams(t *testing.T) {
 		t.Errorf("\nexpected: <%+v>, \nreceived: <%+v", exp, rcv)
 	}
 }
+
+func TestDispatcherHostCallErr(t *testing.T) {
+	dH := &DispatcherHost{
+		Tenant: "testTenant",
+		RemoteHost: &config.RemoteHost{
+			ID:        "testID",
+			Address:   "",
+			Transport: "",
+			TLS:       false,
+		},
+	}
+	var reply string
+	if err := dH.Call(utils.AttributeSv1Ping, &utils.CGREvent{}, &reply); err == nil || err.Error() != "dial tcp: missing address" {
+		t.Error(err)
+	}
+}

engine/responder_test.go

@@ -20,7 +20,10 @@ package engine
 import (
 	"bytes"
 	"encoding/gob"
+	"log"
+	"os"
 	"reflect"
+	"strings"
 	"testing"
 	"time"
 
@@ -631,7 +634,7 @@ func TestResponderDebit(t *testing.T) {
 	}
 }
 
-func TestGetCostOnRatingPlans(t *testing.T) {
+func TestGetCostOnRatingPlansErr(t *testing.T) {
 	Cache.Clear(nil)
 	cfg := config.NewDefaultCGRConfig()
 	db := NewInternalDB(nil, nil, true, cfg.DataDbCfg().Items)
@@ -1119,10 +1122,18 @@ func TestResponderRefundRoundingSet(t *testing.T) {
 
 }
 
-func TestGetMaxSessionTimeOnAccounts(t *testing.T) {
+func TestGetMaxSessionTimeOnAccountsErr(t *testing.T) {
+	utils.Logger.SetLogLevel(4)
+	utils.Logger.SetSyslog(nil)
+	buf := new(bytes.Buffer)
+	log.SetOutput(buf)
 	cfg := config.NewDefaultCGRConfig()
 	db := NewInternalDB(nil, nil, true, cfg.DataDbCfg().Items)
 	dm := NewDataManager(db, cfg.CacheCfg(), nil)
+	defer func() {
+		utils.Logger.SetLogLevel(0)
+		log.SetOutput(os.Stderr)
+	}()
 	arg := &utils.GetMaxSessionTimeOnAccountsArgs{
 		Subject:     "subject",
 		Tenant:      "",
@@ -1141,8 +1152,12 @@ func TestGetMaxSessionTimeOnAccounts(t *testing.T) {
 			connMgr: nil,
 		},
 	}
+	expLog := ` ignoring cost for account: `
 	if err := rs.GetMaxSessionTimeOnAccounts(arg, reply); err == nil || err != utils.ErrAccountNotFound {
 		t.Error(err)
 	}
+	if rcvLog := buf.String(); !strings.Contains(rcvLog, expLog) {
+		t.Errorf("logger %v doesn't contain %v", utils.ToJSON(rcvLog), utils.ToJSON(expLog))
+	}
 
 }

engine/routes_test.go

@@ -1038,9 +1038,15 @@ func TestRouteServiceSortRoutes(t *testing.T) {
 	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
 	rpS := NewRouteService(dmSPP, &FilterS{dm: dmSPP, cfg: cfg, connMgr: nil}, cfg, nil)
+	utils.Logger.SetLogLevel(4)
+	utils.Logger.SetSyslog(nil)
+	buf := new(bytes.Buffer)
+	log.SetOutput(buf)
+	defer func() {
+		utils.Logger.SetLogLevel(0)
+		log.SetOutput(os.Stderr)
+	}()
 	lcs := &LeastCostSorter{
 		sorting: "sort",
 		rS:      rpS,
@@ -1049,72 +1055,22 @@ func TestRouteServiceSortRoutes(t *testing.T) {
 	routes := map[string]*Route{
 		"route1": {
 			ID:              "id",
-			FilterIDs:       []string{"filterid1", "filterid2", "filterid3"},
-			AccountIDs:      []string{"acc_id1", "acc_id2", "acc_id3"},
-			RatingPlanIDs:   []string{"rate1", "rate2", "rate3", "rate4"},
-			ResourceIDs:     []string{"rsc1", "rsc2", "rsc3"},
-			StatIDs:         []string{"stat1", "stat2", "stat3"},
+			FilterIDs:       []string{"filterid1"},
+			AccountIDs:      []string{"acc_id1"},
+			RatingPlanIDs:   []string{"rate1"},
+			ResourceIDs:     []string{"rsc1"},
+			StatIDs:         []string{"stat1"},
 			Weight:          2.3,
 			Blocker:         true,
 			RouteParameters: "route",
 			cacheRoute: map[string]interface{}{
 				"*ratio": "ratio",
 			},
-			lazyCheckRules: []*FilterRule{
-				{
-					Type:    "*string",
-					Element: "elem",
-					Values:  []string{"val1", "val2", "val3"},
-					rsrValues: config.RSRParsers{
-						&config.RSRParser{Rules: "public"},
-						{Rules: "private"},
-					}},
-				{
-					Type:    "*string",
-					Element: "elem",
-					Values:  []string{"val1", "val2", "val3"},
-					rsrValues: config.RSRParsers{
-						&config.RSRParser{Rules: "public"},
-						{Rules: "private"},
-					},
-				},
-			},
-		},
-		"route2": {
-			ID:              "id",
-			FilterIDs:       []string{"filterid1", "filterid2", "filterid3"},
-			AccountIDs:      []string{"acc_id1", "acc_id2", "acc_id3"},
-			RatingPlanIDs:   []string{"rate1", "rate2", "rate3", "rate4"},
-			ResourceIDs:     []string{"rsc1", "rsc2", "rsc3"},
-			StatIDs:         []string{"stat1", "stat2", "stat3"},
-			Weight:          2.3,
-			Blocker:         true,
-			RouteParameters: "route",
-			cacheRoute: map[string]interface{}{
-				"*ratio": "ratio",
-			},
-			lazyCheckRules: []*FilterRule{
-				{
-					Type:    "*string",
-					Element: "elem",
-					Values:  []string{"val1", "val2", "val3"},
-					rsrValues: config.RSRParsers{
-						&config.RSRParser{Rules: "public"},
-						{Rules: "private"},
-					}},
-				{
-					Type:    "*string",
-					Element: "elem",
-					Values:  []string{"val1", "val2", "val3"},
-					rsrValues: config.RSRParsers{
-						&config.RSRParser{Rules: "public"},
-						{Rules: "private"},
-					},
-				},
-			},
+			lazyCheckRules: []*FilterRule{},
 		},
 	}
-	ev := &utils.CGREvent{ //matching RouteProfile1
+
+	ev := &utils.CGREvent{
 		Tenant: "cgrates.org",
 		ID:     "utils.CGREvent1",
 		Event: map[string]interface{}{
@@ -1145,10 +1101,26 @@ func TestRouteServiceSortRoutes(t *testing.T) {
 	} else if !reflect.DeepEqual(val, expSr) {
 		t.Errorf("recived %+v", utils.ToJSON(val))
 	}
+	routes["route1"].RatingPlanIDs = []string{}
+	routes["route1"].AccountIDs = []string{}
+	expLog := `empty RatingPlanIDs or AccountIDs`
+	if _, err = lcs.SortRoutes(prflID, routes, ev, extraOpts); err == nil {
+		t.Error(err)
+	} else if rcvLog := buf.String(); !strings.Contains(rcvLog, expLog) {
+		t.Errorf("Logger %v doesn't contain %v", utils.ToJSON(rcvLog), utils.ToJSON(expLog))
+	}
 
 }
 
 func TestRDSRSortRoutes(t *testing.T) {
+	utils.Logger.SetLogLevel(4)
+	utils.Logger.SetSyslog(nil)
+	buf := new(bytes.Buffer)
+	log.SetOutput(buf)
+	defer func() {
+		utils.Logger.SetLogLevel(0)
+		log.SetOutput(os.Stderr)
+	}()
 	cfg := config.NewDefaultCGRConfig()
 	data := NewInternalDB(nil, nil, true, cfg.DataDbCfg().Items)
 	dmSPP := NewDataManager(data, config.CgrConfig().CacheCfg(), nil)
@@ -1163,11 +1135,11 @@ func TestRDSRSortRoutes(t *testing.T) {
 	routes := map[string]*Route{
 		"sorted_route1": {
 			ID:              "id",
-			FilterIDs:       []string{"filterid1", "filterid2", "filterid3"},
-			AccountIDs:      []string{"acc_id1", "acc_id2", "acc_id3"},
-			RatingPlanIDs:   []string{"rate1", "rate2", "rate3", "rate4"},
-			ResourceIDs:     []string{"rsc1", "rsc2", "rsc3"},
-			StatIDs:         []string{"stat1", "stat2", "stat3"},
+			FilterIDs:       []string{"filterid1"},
+			AccountIDs:      []string{"acc_id1"},
+			RatingPlanIDs:   []string{"rate1"},
+			ResourceIDs:     []string{"rsc1"},
+			StatIDs:         []string{"stat1"},
 			Weight:          2.3,
 			Blocker:         true,
 			RouteParameters: "route",
@@ -1179,51 +1151,11 @@ func TestRDSRSortRoutes(t *testing.T) {
 					Type:    "*string",
 					Element: "elem",
 					Values:  []string{"val1", "val2", "val3"},
-					rsrValues: config.RSRParsers{
-						&config.RSRParser{Rules: "public"},
-						{Rules: "private"},
-					}},
-				{
-					Type:    "*string",
-					Element: "elem",
-					Values:  []string{"val1", "val2", "val3"},
-					rsrValues: config.RSRParsers{
-						&config.RSRParser{Rules: "public"},
-						{Rules: "private"},
-					},
 				},
-			},
-		},
-		"sorted_route2": {
-			ID:              "id",
-			FilterIDs:       []string{"filterid1", "filterid2", "filterid3"},
-			AccountIDs:      []string{"acc_id1", "acc_id2", "acc_id3"},
-			RatingPlanIDs:   []string{"rate1", "rate2", "rate3", "rate4"},
-			ResourceIDs:     []string{"rsc1", "rsc2", "rsc3"},
-			StatIDs:         []string{"stat1", "stat2", "stat3"},
-			Weight:          2.3,
-			Blocker:         true,
-			RouteParameters: "route",
-			cacheRoute: map[string]interface{}{
-				"*ratio": "ratio",
-			},
-			lazyCheckRules: []*FilterRule{
 				{
 					Type:    "*string",
 					Element: "elem",
 					Values:  []string{"val1", "val2", "val3"},
-					rsrValues: config.RSRParsers{
-						&config.RSRParser{Rules: "public"},
-						{Rules: "private"},
-					}},
-				{
-					Type:    "*string",
-					Element: "elem",
-					Values:  []string{"val1", "val2", "val3"},
-					rsrValues: config.RSRParsers{
-						&config.RSRParser{Rules: "public"},
-						{Rules: "private"},
-					},
 				},
 			},
 		},
@@ -1248,6 +1180,14 @@ func TestRDSRSortRoutes(t *testing.T) {
 	if _, err := rds.SortRoutes(prflID, routes, ev, extraOpts); err != nil {
 		t.Error(err)
 	}
+	routes["sorted_route1"].ResourceIDs = []string{}
+	expLog := `empty ResourceIDs`
+	if _, err = rds.SortRoutes(prflID, routes, ev, extraOpts); err == nil {
+		t.Error(err)
+	} else if rcvLog := buf.String(); !strings.Contains(rcvLog, expLog) {
+		t.Errorf("Logger %v doesn't contain %v", utils.ToJSON(rcvLog), utils.ToJSON(expLog))
+	}
+
 }
 func TestQosRSortRoutes(t *testing.T) {
 	cfg := config.NewDefaultCGRConfig()
@@ -1356,7 +1296,14 @@ func TestReaSortRoutes(t *testing.T) {
 	dm := NewDataManager(db, config.CgrConfig().CacheCfg(), nil)
 	cfg.RouteSCfg().RALsConns = []string{utils.ConcatenatedKey(utils.MetaInternal, utils.MetaRALs)}
 	cfg.RouteSCfg().StatSConns = []string{utils.ConcatenatedKey(utils.MetaInternal, utils.MetaStats)}
-	cfg.GeneralCfg().DefaultTimezone = "UTC"
+	utils.Logger.SetLogLevel(4)
+	utils.Logger.SetSyslog(nil)
+	buf := new(bytes.Buffer)
+	log.SetOutput(buf)
+	defer func() {
+		utils.Logger.SetLogLevel(0)
+		log.SetOutput(os.Stderr)
+	}()
 	clientConn := make(chan rpcclient.ClientConnector, 1)
 	clientConn <- &ccMock{
 		calls: map[string]func(args interface{}, reply interface{}) error{
@@ -1402,20 +1349,6 @@ func TestReaSortRoutes(t *testing.T) {
 				"*ratio": "ratio",
 			},
 		},
-		"sorted_route2": {
-			ID:              "id",
-			FilterIDs:       []string{"filterid1"},
-			AccountIDs:      []string{"acc_id1"},
-			RatingPlanIDs:   []string{"rate1"},
-			ResourceIDs:     []string{"rsc"},
-			StatIDs:         []string{"statID"},
-			Weight:          2.3,
-			Blocker:         true,
-			RouteParameters: "route",
-			cacheRoute: map[string]interface{}{
-				"*ratio": "ratio",
-			},
-		},
 	}
 	ev := &utils.CGREvent{
 		Tenant: "cgrates.org",
@@ -1436,86 +1369,48 @@ func TestReaSortRoutes(t *testing.T) {
 	if _, err := rea.SortRoutes(prflID, routes, ev, extraOpts); err != nil {
 		t.Error(err)
 	}
+	routes["sorted_route1"].ResourceIDs = []string{}
+	expLog := `empty ResourceIDs`
+	if _, err = rea.SortRoutes(prflID, routes, ev, extraOpts); err == nil {
+		t.Error(err)
+	} else if rcvLog := buf.String(); !strings.Contains(rcvLog, expLog) {
+		t.Errorf("Logger %v  doesn't contain %v", utils.ToJSON(rcvLog), utils.ToJSON(expLog))
+	}
+
 }
 func TestHCRSortRoutes(t *testing.T) {
 	Cache.Clear(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
 	rpS := NewRouteService(dmSPP, &FilterS{dm: dmSPP, cfg: cfg, connMgr: nil}, cfg, nil)
 	hcr := &HightCostSorter{
 		sorting: utils.MetaHC,
 		rS:      rpS,
 	}
+	utils.Logger.SetLogLevel(4)
+	utils.Logger.SetSyslog(nil)
+	buf := new(bytes.Buffer)
+	log.SetOutput(buf)
+	defer func() {
+		utils.Logger.SetLogLevel(0)
+		log.SetOutput(os.Stderr)
+	}()
 	prflID := "CGREvent1"
 	routes := map[string]*Route{
 		"sorted_route1": {
 			ID:              "id",
-			FilterIDs:       []string{"filterid1", "filterid2", "filterid3"},
-			AccountIDs:      []string{"acc_id1", "acc_id2", "acc_id3"},
-			RatingPlanIDs:   []string{"rate1", "rate2", "rate3", "rate4"},
-			ResourceIDs:     []string{"rsc1", "rsc2", "rsc3"},
-			StatIDs:         []string{"stat1", "stat2", "stat3"},
+			FilterIDs:       []string{"filterid1"},
+			AccountIDs:      []string{"acc_id1"},
+			RatingPlanIDs:   []string{"rate1"},
+			ResourceIDs:     []string{"rsc1"},
+			StatIDs:         []string{"stat1"},
 			Weight:          2.3,
 			Blocker:         true,
 			RouteParameters: "route",
 			cacheRoute: map[string]interface{}{
 				"*ratio": "ratio",
 			},
-			lazyCheckRules: []*FilterRule{
-				{
-					Type:    "*string",
-					Element: "elem",
-					Values:  []string{"val1", "val2", "val3"},
-					rsrValues: config.RSRParsers{
-						&config.RSRParser{Rules: "public"},
-						{Rules: "private"},
-					}},
-				{
-					Type:    "*string",
-					Element: "elem",
-					Values:  []string{"val1", "val2", "val3"},
-					rsrValues: config.RSRParsers{
-						&config.RSRParser{Rules: "public"},
-						{Rules: "private"},
-					},
-				},
-			},
-		},
-		"sorted_route2": {
-			ID:              "id",
-			FilterIDs:       []string{"filterid1", "filterid2", "filterid3"},
-			AccountIDs:      []string{"acc_id1", "acc_id2", "acc_id3"},
-			RatingPlanIDs:   []string{"rate1", "rate2", "rate3", "rate4"},
-			ResourceIDs:     []string{"rsc1", "rsc2", "rsc3"},
-			StatIDs:         []string{"stat1", "stat2", "stat3"},
-			Weight:          2.3,
-			Blocker:         true,
-			RouteParameters: "route",
-			cacheRoute: map[string]interface{}{
-				"*ratio": "ratio",
-			},
-			lazyCheckRules: []*FilterRule{
-				{
-					Type:    "*string",
-					Element: "elem",
-					Values:  []string{"val1", "val2", "val3"},
-					rsrValues: config.RSRParsers{
-						&config.RSRParser{Rules: "public"},
-						{Rules: "private"},
-					}},
-				{
-					Type:    "*string",
-					Element: "elem",
-					Values:  []string{"val1", "val2", "val3"},
-					rsrValues: config.RSRParsers{
-						&config.RSRParser{Rules: "public"},
-						{Rules: "private"},
-					},
-				},
-			},
 		},
 	}
 	ev := &utils.CGREvent{
@@ -1538,6 +1433,15 @@ func TestHCRSortRoutes(t *testing.T) {
 	if _, err := hcr.SortRoutes(prflID, routes, ev, extraOpts); err != nil {
 		t.Error(err)
 	}
+	routes["sorted_route1"].RatingPlanIDs = []string{}
+	routes["sorted_route1"].AccountIDs = []string{}
+	expLog := `empty RatingPlanIDs or AccountIDs`
+	if _, err := hcr.SortRoutes(prflID, routes, ev, extraOpts); err == nil {
+		t.Error(err)
+	} else if rcvLog := buf.String(); !strings.Contains(rcvLog, expLog) {
+		t.Errorf("Logger %v doesn't contains %v", rcvLog, expLog)
+	}
+
 }
 func TestLoadDistributionSorterSortRoutes(t *testing.T) {
 	cfg := config.NewDefaultCGRConfig()