Improving coverage at engine

engine/actions_test.go

@@ -3457,7 +3457,6 @@ func TestResetAccountCDRSuccesful(t *testing.T) {
 func TestRemoveSessionCost(t *testing.T) {
 	tmp := Cache
 	tmpCdr := cdrStorage
-
 	utils.Logger.SetLogLevel(4)
 	utils.Logger.SetSyslog(nil)
 	buf := new(bytes.Buffer)
@@ -3467,11 +3466,9 @@ func TestRemoveSessionCost(t *testing.T) {
 		log.SetOutput(os.Stderr)
 		Cache = tmp
 		cdrStorage = tmpCdr
-
 	}()
 	Cache.Clear(nil)
 	cfg := config.NewDefaultCGRConfig()
-
 	action := &Action{
 		ExtraParameters: "*acnt.BalanceID;*act.ActionID",
 	}
@@ -3482,14 +3479,21 @@ func TestRemoveSessionCost(t *testing.T) {
 				Values:  []string{"val1,val2"},
 				Type:    utils.MetaString,
 				Element: utils.MetaScPrefix + utils.CGRID},
+			{
+				Values:  []string{"val1,val2"},
+				Type:    utils.MetaString,
+				Element: "test"},
 		},
 	}, []string{"grpId"}, true, utils.NonTransactional)
 
 	expLog := `for filter`
+	expLog2 := `in action:`
 	if err := removeSessionCosts(nil, action, nil, nil, nil); err == nil || err != utils.ErrNotFound {
 		t.Error(err)
 	} else if rcvLog := buf.String(); !strings.Contains(rcvLog, expLog) {
 		t.Errorf("expected %v,received %v", expLog, rcvLog)
+	} else if rcvLog := buf.String(); !strings.Contains(rcvLog, expLog2) {
+		t.Errorf("expected %v,received %v", expLog, rcvLog)
 	}
 
 }
@@ -3976,5 +3980,37 @@ func TestRemoveBalanceActionErr(t *testing.T) {
 	if err := removeBalanceAction(acc, acs, nil, nil, nil); err == nil || err != utils.ErrNotFound {
 		t.Error(err)
 	}
-
+}
+
+func TestDebitResetAction(t *testing.T) {
+
+	ub := &Account{
+		ID: "OUT:CUSTOMER_1:rif",
+		BalanceMap: map[string]Balances{
+			utils.MetaVoice:    {&Balance{Value: 21}},
+			utils.MetaMonetary: {&Balance{Value: 21}},
+		},
+	}
+	a := &Action{
+		Id:               "MINI",
+		ActionType:       utils.MetaTopUpReset,
+		ExpirationString: utils.MetaUnlimited,
+		ExtraParameters:  "",
+		Weight:           10,
+		Balance: &BalanceFilter{
+			Type:           utils.StringPointer(utils.MetaMonetary),
+			Uuid:           utils.StringPointer("uuid"),
+			Value:          &utils.ValueFormula{Static: 10},
+			Weight:         utils.Float64Pointer(10),
+			DestinationIDs: nil,
+			TimingIDs:      nil,
+			SharedGroups:   nil,
+			Categories:     nil,
+			Disabled:       utils.BoolPointer(false),
+			Blocker:        utils.BoolPointer(false),
+		},
+	}
+	if err := debitResetAction(ub, a, nil, nil, nil); err != nil {
+		t.Error(err)
+	}
 }

engine/balances_test.go

@@ -508,7 +508,7 @@ func TestBalanceDebitUnits(t *testing.T) {
 		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,
+		DurationIndex: 17 * time.Second,
 
 		FallbackSubject: "",
 		RatingInfos: RatingInfos{
@@ -606,15 +606,22 @@ func TestBalanceDebitUnits(t *testing.T) {
 		t.Errorf("expected %+v ,received  %+v", utils.ToJSON(exp), utils.ToJSON(val))
 	}
 }
-func TestBalanceDebitMoney(t *testing.T) {
-
+func TestBalanceDebitMoneyMaxCostFree(t *testing.T) {
+	utils.Logger.SetLogLevel(3)
+	utils.Logger.SetSyslog(nil)
+	buf := new(bytes.Buffer)
+	log.SetOutput(buf)
+	defer func() {
+		utils.Logger.SetLogLevel(0)
+		log.SetOutput(os.Stderr)
+	}()
 	cd := &CallDescriptor{
-		Category:  "postpaid",
-		ToR:       utils.MetaVoice,
-		Tenant:    "foehn",
-		TimeStart: time.Date(2015, 4, 24, 7, 59, 4, 0, time.UTC),
-		TimeEnd:   time.Date(2015, 4, 24, 8, 2, 0, 0, time.UTC),
-
+		Category:     "postpaid",
+		ToR:          utils.MetaVoice,
+		Tenant:       "foehn",
+		TimeStart:    time.Date(2015, 4, 24, 7, 59, 4, 0, time.UTC),
+		TimeEnd:      time.Date(2015, 4, 24, 8, 2, 0, 0, time.UTC),
+		MaxCostSoFar: 33,
 		testCallcost: &CallCost{
 			Category:         "generic",
 			Tenant:           "cgrates.org",
@@ -635,8 +642,9 @@ func TestBalanceDebitMoney(t *testing.T) {
 						}},
 					RateInterval: &RateInterval{
 						Rating: &RIRate{
-							ConnectFee: 0.15,
-							MaxCost:    23.2,
+							ConnectFee:      0.15,
+							MaxCost:         23.2,
+							MaxCostStrategy: utils.MetaMaxCostFree,
 							Rates: RateGroups{&RGRate{GroupIntervalStart: 0,
 								Value: 0.1, RateIncrement: time.Second,
 								RateUnit: time.Second}}}},
@@ -670,22 +678,109 @@ func TestBalanceDebitMoney(t *testing.T) {
 			"FACT_VAL": 20.22,
 		},
 	}
-	if val, err := b.debitMoney(cd, ub, moneyBalances, true, true, true, nil); err != nil {
-		t.Errorf("expected nil,received %+v", utils.ToJSON(val))
+
+	if _, err := b.debitMoney(cd, ub, moneyBalances, true, true, true, nil); err != nil {
+		t.Error(err)
 	}
 }
-
-func TestBalanceDebitUnits2(t *testing.T) {
-	cfg := config.NewDefaultCGRConfig()
-	db := NewInternalDB(nil, nil, true, nil)
-	dm := NewDataManager(db, cfg.CacheCfg(), nil)
+func TestBalanceDebitMoneyMaxCostDisconnect(t *testing.T) {
+	utils.Logger.SetLogLevel(3)
+	utils.Logger.SetSyslog(nil)
+	buf := new(bytes.Buffer)
+	log.SetOutput(buf)
+	defer func() {
+		utils.Logger.SetLogLevel(0)
+		log.SetOutput(os.Stderr)
+	}()
 	cd := &CallDescriptor{
-		Category:  "postpaid",
-		ToR:       utils.MetaVoice,
-		Tenant:    "foehn",
-		TimeStart: time.Date(2015, 4, 24, 7, 59, 4, 0, time.UTC),
-		TimeEnd:   time.Date(2015, 4, 24, 8, 2, 0, 0, time.UTC),
-
+		Category:     "postpaid",
+		ToR:          utils.MetaVoice,
+		Tenant:       "foehn",
+		TimeStart:    time.Date(2015, 4, 24, 7, 59, 4, 0, time.UTC),
+		TimeEnd:      time.Date(2015, 4, 24, 8, 2, 0, 0, time.UTC),
+		MaxCostSoFar: 33,
+		testCallcost: &CallCost{
+			Category:         "generic",
+			Tenant:           "cgrates.org",
+			Subject:          "1001",
+			Account:          "1001",
+			Destination:      "data",
+			ToR:              "*data",
+			Cost:             0,
+			deductConnectFee: true,
+			Timespans: TimeSpans{
+				{
+					TimeStart:     time.Date(2013, 9, 24, 10, 48, 0, 0, time.UTC),
+					TimeEnd:       time.Date(2013, 9, 24, 10, 48, 10, 0, time.UTC),
+					DurationIndex: 0,
+					Increments: Increments{
+						{Cost: 2, BalanceInfo: &DebitInfo{
+							Monetary: &MonetaryInfo{UUID: "moneya"}},
+						}},
+				},
+			},
+		},
+		FallbackSubject: "",
+	}
+	ub := &Account{
+		ID: "vdf:broker",
+		BalanceMap: map[string]Balances{
+			utils.MetaVoice: {
+				&Balance{Value: 20 * float64(time.Second),
+					DestinationIDs: utils.NewStringMap("NAT"),
+					Weight:         10, RatingSubject: "rif"},
+				&Balance{Value: 100 * float64(time.Second),
+					DestinationIDs: utils.NewStringMap("RET"), Weight: 20},
+			}},
+	}
+	moneyBalances := Balances{}
+	b := &Balance{
+		Uuid:           "uuid",
+		ID:             "id",
+		Value:          12.22,
+		ExpirationDate: time.Date(2022, 11, 1, 20, 0, 0, 0, time.UTC),
+		Blocker:        true,
+		Disabled:       false,
+		precision:      2,
+		RatingSubject:  "*val34",
+		Factor: ValueFactor{
+			"FACT_VAL": 20.22,
+		},
+	}
+	expLog := `Nil RateInterval ERROR on TS:`
+	if _, err := b.debitMoney(cd, ub, moneyBalances, true, true, true, nil); err == nil {
+		t.Error(err)
+	} else if rcvLog := buf.String(); !strings.Contains(rcvLog, expLog) {
+		t.Errorf("Logger %v,doesn't contain %v", rcvLog, expLog)
+	}
+	cd.testCallcost.Timespans[0].RateInterval = &RateInterval{
+		Rating: &RIRate{
+			ConnectFee:      0.15,
+			MaxCost:         23.2,
+			MaxCostStrategy: utils.MetaMaxCostDisconnect,
+			Rates: RateGroups{&RGRate{GroupIntervalStart: 0,
+				Value: 0.1, RateIncrement: time.Second,
+				RateUnit: time.Second}}}}
+	if _, err := b.debitMoney(cd, ub, moneyBalances, true, true, true, nil); err != nil {
+		t.Error(err)
+	}
+}
+func TestBalanceDebitMoney(t *testing.T) {
+	utils.Logger.SetLogLevel(3)
+	utils.Logger.SetSyslog(nil)
+	buf := new(bytes.Buffer)
+	log.SetOutput(buf)
+	defer func() {
+		utils.Logger.SetLogLevel(0)
+		log.SetOutput(os.Stderr)
+	}()
+	cd := &CallDescriptor{
+		Category:     "postpaid",
+		ToR:          utils.MetaVoice,
+		Tenant:       "foehn",
+		TimeStart:    time.Date(2015, 4, 24, 7, 59, 4, 0, time.UTC),
+		TimeEnd:      time.Date(2015, 4, 24, 8, 2, 0, 0, time.UTC),
+		MaxCostSoFar: 33,
 		testCallcost: &CallCost{
 			Category:         "generic",
 			Tenant:           "cgrates.org",
@@ -708,6 +803,76 @@ func TestBalanceDebitUnits2(t *testing.T) {
 						Rating: &RIRate{
 							ConnectFee: 0.15,
 							MaxCost:    23.2,
+
+							Rates: RateGroups{&RGRate{GroupIntervalStart: 0,
+								Value: 0.1, RateIncrement: time.Second,
+								RateUnit: time.Second}}}},
+				},
+			},
+		},
+		FallbackSubject: "",
+	}
+	ub := &Account{
+		ID: "vdf:broker",
+		BalanceMap: map[string]Balances{
+			utils.MetaVoice: {
+				&Balance{Value: 20 * float64(time.Second),
+					DestinationIDs: utils.NewStringMap("NAT"),
+					Weight:         10, RatingSubject: "rif"},
+				&Balance{Value: 100 * float64(time.Second),
+					DestinationIDs: utils.NewStringMap("RET"), Weight: 20},
+			}},
+	}
+	moneyBalances := Balances{}
+	b := &Balance{
+		ID:             "id",
+		Value:          12.22,
+		ExpirationDate: time.Date(2022, 11, 1, 20, 0, 0, 0, time.UTC),
+		precision:      2,
+		RatingSubject:  "*val34",
+		Factor: ValueFactor{
+			"FACT_VAL": 20.22,
+		},
+	}
+	if _, err := b.debitMoney(cd, ub, moneyBalances, true, true, true, nil); err != nil {
+		t.Error(err)
+	}
+}
+func TestBalanceDebitUnits2(t *testing.T) {
+	cfg := config.NewDefaultCGRConfig()
+	db := NewInternalDB(nil, nil, true, nil)
+	dm := NewDataManager(db, cfg.CacheCfg(), nil)
+	cd := &CallDescriptor{
+		Category:     "postpaid",
+		ToR:          utils.MetaVoice,
+		Tenant:       "foehn",
+		TimeStart:    time.Date(2015, 4, 24, 7, 59, 4, 0, time.UTC),
+		TimeEnd:      time.Date(2015, 4, 24, 8, 2, 0, 0, time.UTC),
+		MaxCostSoFar: 23.8,
+		testCallcost: &CallCost{
+			Category: "generic",
+			Tenant:   "cgrates.org",
+			Subject:  "1001",
+			Account:  "1001",
+
+			Destination:      "data",
+			ToR:              "*data",
+			Cost:             0,
+			deductConnectFee: true,
+			Timespans: TimeSpans{
+				{
+					TimeStart:     time.Date(2013, 9, 24, 10, 48, 0, 0, time.UTC),
+					TimeEnd:       time.Date(2013, 9, 24, 10, 48, 10, 0, time.UTC),
+					DurationIndex: 0,
+					Increments: Increments{
+						{Cost: 2, BalanceInfo: &DebitInfo{
+							Monetary: &MonetaryInfo{UUID: "moneya"}},
+						}},
+					RateInterval: &RateInterval{
+						Rating: &RIRate{
+							ConnectFee:      0.15,
+							MaxCost:         23.2,
+							MaxCostStrategy: utils.MetaMaxCostDisconnect,
 							Rates: RateGroups{&RGRate{GroupIntervalStart: 0,
 								Value: 0.1, RateIncrement: time.Second,
 								RateUnit: time.Second}}}},
@@ -753,7 +918,7 @@ func TestBalanceDebitUnits2(t *testing.T) {
 	fltrs := FilterS{cfg, dm, nil}
 	config.SetCgrConfig(cfg)
 
-	if _, err := b.debitUnits(cd, ub, moneyBalances, true, false, true, &fltrs); err != nil {
+	if _, err := b.debitUnits(cd, ub, moneyBalances, true, true, true, &fltrs); err != nil {
 		t.Errorf("received %v", err)
 	}
 }

engine/cdrs_test.go

@@ -1774,6 +1774,22 @@ func TestV2StoreSessionCost2(t *testing.T) {
 	} else if reply != utils.OK {
 		t.Errorf("expected %+v,received %+v", utils.OK, reply)
 	}
+	clientconn2 := make(chan rpcclient.ClientConnector, 1)
+	clientconn2 <- &ccMock{
+
+		calls: map[string]func(args interface{}, reply interface{}) error{
+			utils.ResponderRefundRounding: func(args, reply interface{}) error {
+				rpl := &Account{}
+				*reply.(*Account) = *rpl
+				return utils.ErrNotFound
+			},
+		},
+	}
+	cdrS.connMgr.rpcInternal[utils.ConcatenatedKey(utils.MetaInternal, utils.RateSConnsCfg)] = clientconn2
+
+	if err := cdrS.V2StoreSessionCost(args, &reply); err != nil {
+		t.Error(err)
+	}
 
 }
 func TestV1RateCDRSSuccesful(t *testing.T) {
@@ -2078,3 +2094,42 @@ func TestChrgrSProcessEvent(t *testing.T) {
 		t.Errorf("expected %v,received %v", utils.ToJSON(expcgrEv), utils.ToJSON(val))
 	}
 }
+
+func TestCdrSCall123(t *testing.T) {
+	cfg := config.NewDefaultCGRConfig()
+
+	tmpConnMgr := connMgr
+	defer func() {
+		connMgr = tmpConnMgr
+		config.SetCgrConfig(config.NewDefaultCGRConfig())
+	}()
+	db := NewInternalDB(nil, nil, true, cfg.DataDbCfg().Items)
+	dm := NewDataManager(db, cfg.CacheCfg(), nil)
+	cdrS := &CDRServer{
+		cgrCfg:  cfg,
+		connMgr: connMgr,
+		dm:      dm,
+		cdrDb:   db,
+	}
+	clientConn := make(chan rpcclient.ClientConnector, 1)
+	clientConn <- cdrS
+	connMgr := NewConnManager(cfg, map[string]chan rpcclient.ClientConnector{})
+	config.SetCgrConfig(cfg)
+	SetConnManager(connMgr)
+	var reply string
+	attr := &AttrCDRSStoreSMCost{
+		Cost: &SMCost{
+			CGRID:    "cgrid1",
+			RunID:    "run1",
+			OriginID: "originid",
+			CostDetails: &EventCost{
+				Usage: utils.DurationPointer(1 * time.Minute),
+				Cost:  utils.Float64Pointer(32.3),
+			},
+		},
+		CheckDuplicate: false,
+	}
+	if err := cdrS.Call(utils.CDRsV1StoreSessionCost, attr, &reply); err != nil {
+		t.Error(err)
+	}
+}

engine/datamanager_test.go

@@ -2420,3 +2420,326 @@ func TestRemoveStatQueueProfile(t *testing.T) {
 		t.Error(err)
 	}
 }
+
+func TestDMGetTimingRemote(t *testing.T) {
+	cfg := config.NewDefaultCGRConfig()
+	tmpDm := dm
+	tmp := Cache
+	tmpConn := connMgr
+	defer func() {
+		config.SetCgrConfig(config.NewDefaultCGRConfig())
+		Cache = tmp
+		SetConnManager(tmpConn)
+		SetDataStorage(tmpDm)
+	}()
+	Cache.Clear(nil)
+	cfg.CacheCfg().Partitions[utils.CacheTimings].Replicate = true
+	cfg.DataDbCfg().RmtConns = []string{utils.ConcatenatedKey(utils.MetaInternal, utils.ReplicatorSv1)}
+	cfg.CacheCfg().ReplicationConns = []string{utils.ConcatenatedKey(utils.MetaInternal, utils.MetaCaches)}
+	cfg.DataDbCfg().RmtConnID = "rmt"
+	cfg.GeneralCfg().NodeID = "node"
+	cfg.DataDbCfg().Items = map[string]*config.ItemOpt{
+		utils.CacheTimings: {
+			Limit:   3,
+			Remote:  true,
+			APIKey:  "key",
+			RouteID: "route",
+		},
+	}
+	tp := &utils.TPTiming{
+		ID:        "MIDNIGHT",
+		Years:     utils.Years{2020, 2019},
+		Months:    utils.Months{1, 2, 3, 4},
+		MonthDays: utils.MonthDays{5, 6, 7, 8},
+		WeekDays:  utils.WeekDays{0, 1, 2, 3},
+		StartTime: "00:00:00",
+		EndTime:   "00:00:01",
+	}
+
+	clientConn := make(chan rpcclient.ClientConnector, 1)
+	clientConn <- &ccMock{
+		calls: map[string]func(args interface{}, reply interface{}) error{
+			utils.ReplicatorSv1GetTiming: func(args, reply interface{}) error {
+				strApiOpts, cancast := args.(*utils.StringWithAPIOpts)
+				if !cancast {
+					return utils.ErrNotConvertible
+				}
+				dm.DataDB().GetTimingDrv(strApiOpts.Arg)
+				*reply.(**utils.TPTiming) = tp
+				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)
+	if _, err := dm.GetTiming(tp.ID, true, utils.NonTransactional); err != nil {
+		t.Error(err)
+	}
+	Cache = NewCacheS(cfg, dm, nil)
+	clientConn2 := make(chan rpcclient.ClientConnector, 1)
+	clientConn2 <- &ccMock{
+		calls: map[string]func(args interface{}, reply interface{}) error{
+			utils.CacheSv1ReplicateSet: func(args, reply interface{}) error {
+				return errors.New("Can't replicate")
+			},
+		},
+	}
+	connMgr2 := NewConnManager(cfg, map[string]chan rpcclient.ClientConnector{utils.ConcatenatedKey(utils.MetaInternal, utils.MetaCaches): clientConn2})
+	SetConnManager(connMgr2)
+	if _, err := dm.GetTiming(tp.ID, true, utils.NonTransactional); err == nil || err.Error() != "Can't replicate" {
+		t.Error(err)
+	}
+	var dm2 *DataManager
+	if _, err := dm2.GetTiming(tp.ID, true, utils.NonTransactional); err == nil || err != utils.ErrNoDatabaseConn {
+		t.Error(err)
+	}
+}
+
+func TestDmGetActions(t *testing.T) {
+	cfg := config.NewDefaultCGRConfig()
+	tmpDm := dm
+	tmp := Cache
+	tmpConn := connMgr
+	defer func() {
+		config.SetCgrConfig(config.NewDefaultCGRConfig())
+		Cache = tmp
+		SetConnManager(tmpConn)
+		SetDataStorage(tmpDm)
+	}()
+	Cache.Clear(nil)
+	cfg.CacheCfg().Partitions[utils.CacheTimings].Replicate = true
+	cfg.DataDbCfg().RmtConns = []string{utils.ConcatenatedKey(utils.MetaInternal, utils.ReplicatorSv1)}
+	cfg.DataDbCfg().RmtConnID = "rmt"
+	cfg.GeneralCfg().NodeID = "node"
+	cfg.DataDbCfg().Items = map[string]*config.ItemOpt{
+		utils.CacheActions: {
+			Limit:   3,
+			Remote:  true,
+			APIKey:  "key",
+			RouteID: "route",
+		},
+	}
+	acs := &Actions{
+		{Id: "MINI",
+			ActionType:       utils.MetaTopUpReset,
+			ExpirationString: utils.MetaUnlimited},
+	}
+	clientConn := make(chan rpcclient.ClientConnector, 1)
+	clientConn <- &ccMock{
+		calls: map[string]func(args interface{}, reply interface{}) error{
+			utils.ReplicatorSv1GetActions: func(args, reply interface{}) error {
+				strApiOpts, cancast := args.(*utils.StringWithAPIOpts)
+				if !cancast {
+					return utils.ErrNotConvertible
+				}
+				dm.DataDB().GetActionsDrv(strApiOpts.Arg)
+				*reply.(*Actions) = *acs
+				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)
+	if _, err := dm.GetActions("MINI", true, utils.NonTransactional); err != nil {
+		t.Error(err)
+	}
+}
+
+func TestDMSetLoadIDs(t *testing.T) {
+	cfg := config.NewDefaultCGRConfig()
+	tmpDm := dm
+	tmp := Cache
+	tmpConn := connMgr
+	defer func() {
+		config.SetCgrConfig(config.NewDefaultCGRConfig())
+		Cache = tmp
+		SetConnManager(tmpConn)
+		SetDataStorage(tmpDm)
+	}()
+	Cache.Clear(nil)
+	cfg.CacheCfg().Partitions[utils.CacheTimings].Replicate = true
+	cfg.DataDbCfg().RplConns = []string{utils.ConcatenatedKey(utils.MetaInternal, utils.ReplicatorSv1)}
+	cfg.DataDbCfg().Items = map[string]*config.ItemOpt{
+		utils.CacheLoadIDs: {
+			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.ReplicatorSv1SetLoadIDs: func(args, reply interface{}) error {
+				ldApiOpts, cancast := args.(*utils.LoadIDsWithAPIOpts)
+				if !cancast {
+					return utils.ErrNotConvertible
+				}
+				dm.DataDB().SetLoadIDsDrv(ldApiOpts.LoadIDs)
+				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)
+	ld := map[string]int64{
+		"load1": 23,
+		"load2": 22,
+	}
+	if err := dm.SetLoadIDs(ld); err != nil {
+		t.Error(err)
+	}
+	dm.dataDB = &DataDBMock{}
+	if err = dm.SetLoadIDs(ld); err == nil || err != utils.ErrNotImplemented {
+		t.Error(err)
+	}
+	var dm2 *DataManager
+	if err = dm2.SetLoadIDs(ld); err == nil || err != utils.ErrNoDatabaseConn {
+		t.Error(err)
+	}
+}
+
+func TestGetItemLoadIDsRemote(t *testing.T) {
+	cfg := config.NewDefaultCGRConfig()
+	tmpDm := dm
+	tmp := Cache
+	tmpConn := connMgr
+	defer func() {
+		config.SetCgrConfig(config.NewDefaultCGRConfig())
+		Cache = tmp
+		SetConnManager(tmpConn)
+		SetDataStorage(tmpDm)
+	}()
+	Cache.Clear(nil)
+	cfg.CacheCfg().Partitions[utils.CacheLoadIDs].Replicate = true
+	cfg.CacheCfg().ReplicationConns = []string{utils.ConcatenatedKey(utils.MetaInternal, utils.MetaCaches)}
+	cfg.CacheCfg().Partitions[utils.CacheLoadIDs].Remote = true
+	cfg.DataDbCfg().RmtConns = []string{utils.ConcatenatedKey(utils.MetaInternal, utils.ReplicatorSv1)}
+	cfg.DataDbCfg().Items = map[string]*config.ItemOpt{
+		utils.CacheLoadIDs: {
+			Limit:   3,
+			Remote:  true,
+			APIKey:  "key",
+			RouteID: "route",
+		},
+	}
+	ld := map[string]int64{
+		"load1": 23,
+		"load2": 22,
+	}
+	clientConn := make(chan rpcclient.ClientConnector, 1)
+	clientConn <- &ccMock{
+		calls: map[string]func(args interface{}, reply interface{}) error{
+			utils.ReplicatorSv1GetItemLoadIDs: func(args, reply interface{}) error {
+				strApiOpts, cancast := args.(*utils.StringWithAPIOpts)
+				if !cancast {
+					return utils.ErrNotConvertible
+				}
+				*reply.(*map[string]int64) = ld
+				dm.DataDB().GetItemLoadIDsDrv(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)
+	if val, err := dm.GetItemLoadIDs("load1", true); err != nil {
+		t.Error(err)
+	} else if !reflect.DeepEqual(val, ld) {
+		t.Error(err)
+	}
+	for key := range ld {
+		if _, has := Cache.Get(utils.CacheLoadIDs, key); !has {
+			t.Error("Item isn't stored on the Cache")
+		}
+	}
+
+	Cache = NewCacheS(cfg, dm, nil)
+	clientconn := make(chan rpcclient.ClientConnector, 1)
+	clientconn <- &ccMock{
+		calls: map[string]func(args interface{}, reply interface{}) error{
+			utils.CacheSv1ReplicateSet: func(args, reply interface{}) error { return errors.New("Can't replicate") },
+		},
+	}
+	connMgr2 := NewConnManager(cfg, map[string]chan rpcclient.ClientConnector{
+		utils.ConcatenatedKey(utils.MetaInternal, utils.MetaCaches): clientconn,
+	})
+	SetConnManager(connMgr2)
+	if _, err := dm.GetItemLoadIDs("load1", true); err == nil {
+		t.Error(err)
+	}
+}
+func TestDMItemLoadIDsRemoteErr(t *testing.T) {
+	cfg := config.NewDefaultCGRConfig()
+	tmpDm := dm
+	tmp := Cache
+	tmpConn := connMgr
+	defer func() {
+		config.SetCgrConfig(config.NewDefaultCGRConfig())
+		Cache = tmp
+		SetConnManager(tmpConn)
+		SetDataStorage(tmpDm)
+	}()
+	Cache.Clear(nil)
+	cfg.CacheCfg().Partitions[utils.CacheLoadIDs].Replicate = true
+	cfg.CacheCfg().ReplicationConns = []string{utils.ConcatenatedKey(utils.MetaInternal, utils.MetaCaches)}
+	cfg.CacheCfg().Partitions[utils.CacheLoadIDs].Remote = true
+	cfg.DataDbCfg().RmtConns = []string{utils.ConcatenatedKey(utils.MetaInternal, utils.ReplicatorSv1)}
+	cfg.DataDbCfg().Items = map[string]*config.ItemOpt{
+		utils.CacheLoadIDs: {
+			Limit:   3,
+			Remote:  true,
+			APIKey:  "key",
+			RouteID: "route",
+		},
+	}
+	ld := map[string]int64{
+		"load1": 23,
+		"load2": 22,
+	}
+	clientConn := make(chan rpcclient.ClientConnector, 1)
+	clientConn <- &ccMock{
+		calls: map[string]func(args interface{}, reply interface{}) error{
+			utils.ReplicatorSv1GetItemLoadIDs: func(args, reply interface{}) error {
+				*reply.(*map[string]int64) = ld
+				return utils.ErrNotFound
+			},
+			utils.CacheSv1ReplicateSet: func(args, reply interface{}) error { return errors.New("Can't replicate") },
+		},
+	}
+	db := NewInternalDB(nil, nil, true, cfg.DataDbCfg().Items)
+	connMgr := NewConnManager(cfg, map[string]chan rpcclient.ClientConnector{
+		utils.ConcatenatedKey(utils.MetaInternal, utils.MetaCaches):    clientConn,
+		utils.ConcatenatedKey(utils.MetaInternal, utils.ReplicatorSv1): clientConn,
+	})
+
+	dm := NewDataManager(db, cfg.CacheCfg(), connMgr)
+	SetConnManager(connMgr)
+
+	config.SetCgrConfig(cfg)
+
+	Cache = NewCacheS(cfg, dm, nil)
+	if _, err := dm.GetItemLoadIDs("load1", true); err == nil || err.Error() != "Can't replicate" {
+		t.Error(err)
+	}
+}