diff --git a/engine/account_test.go b/engine/account_test.go
index 2b3699c37..f2a97b63e 100644
--- a/engine/account_test.go
+++ b/engine/account_test.go
@@ -18,14 +18,20 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>
 package engine
 
 import (
+	"bytes"
 	"encoding/json"
+	"errors"
+	"log"
+	"os"
 	"reflect"
 	"sort"
+	"strings"
 	"testing"
 	"time"
 
 	"github.com/cgrates/cgrates/config"
 	"github.com/cgrates/cgrates/utils"
+	"github.com/cgrates/rpcclient"
 )
 
 var (
@@ -2897,26 +2903,32 @@ func TestAccountSummary(t *testing.T) {
 }
 
 func TestAccountGetCreditForPrefix(t *testing.T) {
+	tmp := Cache
+	defer func() {
+		Cache = tmp
+	}()
+	Cache.Clear(nil)
 	acc := &Account{
 		ID:            "cgrates.org:account1",
 		AllowNegative: true,
 		BalanceMap: map[string]Balances{
-			utils.MetaSMS: {&Balance{ID: "sms1", Value: 14,
-				SharedGroups: utils.StringMap{
-					"group": true,
-				}}},
-			utils.MetaMMS: {&Balance{ID: "mms1", Value: 140, SharedGroups: utils.StringMap{
-				"group": true,
-			}}},
-			utils.MetaData: {&Balance{ID: "data1", Value: 1204, SharedGroups: utils.StringMap{
-				"group": true,
-			}}},
-			utils.MetaVoice: {
-				&Balance{ID: "voice1", Weight: 20, DestinationIDs: utils.StringMap{"NAT": true}, Value: 3600},
-				&Balance{ID: "voice2", Weight: 10, DestinationIDs: utils.StringMap{"RET": true}, Value: 1200},
+			utils.MetaMonetary: {
+				&Balance{
+					ID:             "voice1",
+					Weight:         20,
+					DestinationIDs: utils.StringMap{utils.MetaAny: false},
+					precision:      0,
+					SharedGroups:   utils.NewStringMap("SG_TEST"),
+					Value:          3600},
 			},
 		},
 	}
+	Cache.Set(utils.CacheSharedGroups, "SG_TEST", &SharedGroup{
+		Id: "SG_TEST", MemberIds: utils.NewStringMap("cgrates.org:account1"),
+		AccountParameters: map[string]*SharingParameters{
+			"*any": {Strategy: STRATEGY_MINE_RANDOM},
+		},
+	}, []string{}, true, utils.NonTransactional)
 	cd := &CallDescriptor{
 		Category:      "0",
 		Tenant:        "vdf",
@@ -2925,11 +2937,9 @@ func TestAccountGetCreditForPrefix(t *testing.T) {
 		LoopIndex:     0,
 		DurationIndex: 10 * time.Second,
 		Destination:   "0723",
-		ToR:           utils.MetaVoice,
+		ToR:           utils.MetaMonetary,
 	}
-
 	if _, _, balances := acc.getCreditForPrefix(cd); len(balances) == 0 {
-
 		t.Errorf("received %+v", utils.ToJSON(balances))
 	}
 }
@@ -2998,8 +3008,151 @@ func TestAcountSetBalanceAction(t *testing.T) {
 	} else if !reflect.DeepEqual(val.MemberIds, exp) {
 		t.Errorf("expected %v,received %v", utils.ToJSON(exp), utils.ToJSON(val.MemberIds))
 	}
-
 	if err = acc.setBalanceAction(nil, fltrs); err == nil || err.Error() != "nil action" {
 		t.Error(err)
 	}
 }
+
+func TestDebitCreditBalance(t *testing.T) {
+	cfg := config.NewDefaultCGRConfig()
+	db := NewInternalDB(nil, nil, true, cfg.DataDbCfg().Items)
+	dm := NewDataManager(db, cfg.CacheCfg(), nil)
+	fltrs := NewFilterS(cfg, nil, dm)
+	tmpConn := connMgr
+	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)
+		connMgr = tmpConn
+		config.SetCgrConfig(config.NewDefaultCGRConfig())
+	}()
+	cfg.RalsCfg().ThresholdSConns = []string{utils.ConcatenatedKey(utils.MetaInternal, utils.MetaThresholds)}
+	clientConn := make(chan rpcclient.ClientConnector, 1)
+	clientConn <- &ccMock{
+		calls: map[string]func(args interface{}, reply interface{}) error{
+			utils.ThresholdSv1ProcessEvent: func(args, reply interface{}) error {
+				rpl := &[]string{"id"}
+				*reply.(*[]string) = *rpl
+				return errors.New("Can't process Event")
+			},
+		},
+	}
+	connMgr := NewConnManager(cfg, map[string]chan rpcclient.ClientConnector{
+		utils.ConcatenatedKey(utils.MetaInternal, utils.MetaThresholds): clientConn,
+	})
+	cd := &CallDescriptor{
+		Tenant:        "cgrates.org",
+		Category:      "call",
+		TimeStart:     time.Date(2015, 9, 24, 10, 48, 0, 0, time.UTC),
+		TimeEnd:       time.Date(2015, 9, 24, 10, 58, 1, 0, time.UTC),
+		Destination:   "4444",
+		Subject:       "dy",
+		Account:       "dy",
+		ToR:           utils.MetaVoice,
+		DurationIndex: 600,
+	}
+	acc := &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},
+			}},
+	}
+	config.SetCgrConfig(cfg)
+	SetConnManager(connMgr)
+	expLog := `processing balance event`
+	if _, err := acc.debitCreditBalance(cd, true, true, true, fltrs); 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 TestAccGetAllBalancesForPrefixLogg(t *testing.T) {
+	tmp := Cache
+	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
+	}()
+	Cache.Clear(nil)
+	acc := &Account{
+		ID:            "cgrates.org:account1",
+		AllowNegative: true,
+		BalanceMap: map[string]Balances{
+			utils.MetaMonetary: {
+				&Balance{
+					ID:             "voice1",
+					Weight:         20,
+					DestinationIDs: utils.StringMap{utils.MetaAny: false},
+					precision:      0,
+					SharedGroups:   utils.NewStringMap("SG_TEST"),
+					Value:          3600},
+			},
+		},
+	}
+	Cache.Set(utils.CacheSharedGroups, "SG_TEST", nil, []string{}, true, utils.NonTransactional)
+	acc.getAlldBalancesForPrefix("0723", "0", utils.MetaMonetary, time.Date(2013, 10, 4, 15, 46, 0, 0, time.UTC))
+	expLog := "Could not get shared group:"
+	if rcvLog := buf.String(); !strings.Contains(rcvLog, expLog) {
+		t.Errorf("Logger %v doesn't containe %v ", rcvLog, expLog)
+	}
+}
+
+func TestGetUniqueSharedGroupMemebersErr(t *testing.T) {
+	utils.Logger.SetLogLevel(4)
+	utils.Logger.SetSyslog(nil)
+	buf := new(bytes.Buffer)
+	log.SetOutput(buf)
+	tmp := Cache
+	defer func() {
+		utils.Logger.SetLogLevel(0)
+		log.SetOutput(os.Stderr)
+		Cache = tmp
+	}()
+	Cache.Clear(nil)
+	acc := &Account{
+		ID:            "cgrates.org:account1",
+		AllowNegative: true,
+		BalanceMap: map[string]Balances{
+			utils.MetaMonetary: {
+				&Balance{
+					ID:             "voice1",
+					Weight:         20,
+					DestinationIDs: utils.StringMap{utils.MetaAny: false},
+					precision:      0,
+					SharedGroups:   utils.NewStringMap("SG_TEST"),
+					Value:          3600},
+			},
+		},
+	}
+	Cache.Set(utils.CacheSharedGroups, "SG_TEST", nil, []string{}, true, utils.NonTransactional)
+	cd := &CallDescriptor{
+		Category:      "0",
+		Tenant:        "vdf",
+		TimeStart:     time.Date(2013, 10, 4, 15, 46, 0, 0, time.UTC),
+		TimeEnd:       time.Date(2013, 10, 4, 15, 46, 10, 0, time.UTC),
+		LoopIndex:     0,
+		DurationIndex: 10 * time.Second,
+		Destination:   "0723",
+		ToR:           utils.MetaMonetary,
+	}
+	expLog := `Could not get shared group: `
+	if _, err := acc.GetUniqueSharedGroupMembers(cd); err == nil || err != utils.ErrNotFound {
+		t.Error(err)
+	} else if rcvLog := buf.String(); !strings.Contains(rcvLog, expLog) {
+		t.Errorf("Logger %v doesn't contain %v", rcvLog, expLog)
+	}
+
+}
diff --git a/engine/actions_test.go b/engine/actions_test.go
index f1bc7ca49..f77a6728c 100644
--- a/engine/actions_test.go
+++ b/engine/actions_test.go
@@ -3057,9 +3057,15 @@ func TestActionSetDDestinations(t *testing.T) {
 }
 
 func TestActionPublishAccount(t *testing.T) {
+	utils.Logger.SetLogLevel(4)
+	utils.Logger.SetSyslog(nil)
+	buf := new(bytes.Buffer)
+	log.SetOutput(buf)
 	cfg := config.NewDefaultCGRConfig()
 	tmpCfg := cfg
 	defer func() {
+		utils.Logger.SetLogLevel(0)
+		log.SetOutput(os.Stderr)
 		config.SetCgrConfig(tmpCfg)
 		SetConnManager(nil)
 	}()
@@ -3070,11 +3076,11 @@ func TestActionPublishAccount(t *testing.T) {
 		calls: map[string]func(args interface{}, reply interface{}) error{
 			utils.ThresholdSv1ProcessEvent: func(args, reply interface{}) error {
 				*reply.(*[]string) = []string{"*thr"}
-				return nil
+				return errors.New("Can't publish!")
 			},
 			utils.StatSv1ProcessEvent: func(args, reply interface{}) error {
 				*reply.(*[]string) = []string{"*stat"}
-				return nil
+				return errors.New("Can't publish!")
 			},
 		},
 	}
@@ -3101,7 +3107,6 @@ func TestActionPublishAccount(t *testing.T) {
 		},
 		BalanceMap: map[string]Balances{
 			utils.MetaMonetary: {
-
 				&Balance{Value: 10,
 					DestinationIDs: utils.StringMap{
 
@@ -3145,8 +3150,14 @@ func TestActionPublishAccount(t *testing.T) {
 			balanceValue: 10,
 		},
 	}
+	expLog := ` with ThresholdS`
+	expLog2 := `with StatS.`
 	if err := publishAccount(ub, a, acs, nil, nil); err != nil {
 		t.Errorf("received %v", err)
+	} else if rcvLog := buf.String(); !strings.Contains(rcvLog, expLog) {
+		t.Errorf("Logger %v doesn't contain %v", rcvLog, expLog)
+	} else if rcvLog := buf.String(); !strings.Contains(rcvLog, expLog2) {
+		t.Errorf("Logger %v doesn't contain %v", rcvLog, expLog2)
 	}
 }
 
@@ -3446,7 +3457,7 @@ func TestResetAccountCDRSuccesful(t *testing.T) {
 func TestRemoveSessionCost(t *testing.T) {
 	tmp := Cache
 	tmpCdr := cdrStorage
-	tmpDm := dm
+
 	utils.Logger.SetLogLevel(4)
 	utils.Logger.SetSyslog(nil)
 	buf := new(bytes.Buffer)
@@ -3456,26 +3467,15 @@ func TestRemoveSessionCost(t *testing.T) {
 		log.SetOutput(os.Stderr)
 		Cache = tmp
 		cdrStorage = tmpCdr
-		dm = tmpDm
+
 	}()
 	Cache.Clear(nil)
 	cfg := config.NewDefaultCGRConfig()
-	cfg.DataDbCfg().Items = map[string]*config.ItemOpt{
-		utils.CacheFilters: {
-			Limit:     3,
-			Replicate: true,
-		},
-		utils.CacheSessionCostsTBL: {
-			Limit: 2,
-		},
-	}
-	db := NewInternalDB(nil, nil, true, cfg.DataDbCfg().Items)
-	dm := NewDataManager(db, cfg.CacheCfg(), nil)
-	SetDataStorage(dm)
+
 	action := &Action{
 		ExtraParameters: "*acnt.BalanceID;*act.ActionID",
 	}
-	db.db.Set(utils.CacheFilters, utils.ConcatenatedKey(cfg.GeneralCfg().DefaultTenant, "*acnt.BalanceID"), &Filter{
+	Cache.Set(utils.CacheFilters, utils.ConcatenatedKey(cfg.GeneralCfg().DefaultTenant, "*acnt.BalanceID"), &Filter{
 		Tenant: "tnt",
 		Rules: []*FilterRule{
 			{
@@ -3484,17 +3484,7 @@ func TestRemoveSessionCost(t *testing.T) {
 				Element: utils.MetaScPrefix + utils.CGRID},
 		},
 	}, []string{"grpId"}, true, utils.NonTransactional)
-	db.db.Set(utils.CacheFilters, utils.ConcatenatedKey(cfg.GeneralCfg().DefaultTenant, "*act.ActionID"), &Filter{
-		Tenant: "tnt",
-		Rules: []*FilterRule{
-			{
-				Values:  []string{"val1,vla2"},
-				Type:    utils.MetaString,
-				Element: utils.MetaScPrefix + utils.CGRID,
-			},
-		},
-	}, []string{"grpId"}, true, utils.NonTransactional)
-	SetCdrStorage(db)
+
 	expLog := `for filter`
 	if err := removeSessionCosts(nil, action, nil, nil, nil); err == nil || err != utils.ErrNotFound {
 		t.Error(err)
@@ -3953,5 +3943,38 @@ func TestTransferMonetaryDefaultAction(t *testing.T) {
 	if err := transferMonetaryDefaultAction(ub, a, acs, nil, "data"); err == nil || err != utils.ErrNotFound {
 		t.Errorf("expected <%v>,received <%v>", utils.ErrNotFound, err)
 	}
+}
+
+func TestRemoveBalanceActionErr(t *testing.T) {
+	acc := &Account{
+		ID: "vdf:minu",
+		BalanceMap: map[string]Balances{
+			utils.MetaMonetary: {&Balance{Value: 50}},
+			utils.MetaVoice: {
+				&Balance{Value: 200 * float64(time.Second),
+					ExpirationDate: time.Date(2022, 11, 22, 2, 0, 0, 0, time.UTC),
+					DestinationIDs: utils.NewStringMap("NAT"), Weight: 10},
+				&Balance{Value: 100 * float64(time.Second),
+					DestinationIDs: utils.NewStringMap("RET"), Weight: 20},
+			},
+		},
+	}
+	acs := &Action{
+		Balance: &BalanceFilter{},
+	}
+	if err := removeBalanceAction(nil, acs, nil, nil, nil); err == nil {
+		t.Error(err)
+	}
+	if err := removeBalanceAction(acc, acs, nil, nil, nil); err == nil {
+		t.Error(err)
+	}
+	acs.Balance = &BalanceFilter{
+		ExpirationDate: utils.TimePointer(time.Date(2022, 11, 12, 2, 0, 0, 0, time.UTC)),
+		Type:           utils.StringPointer(utils.MetaMonetary),
+		Value:          &utils.ValueFormula{Static: 10},
+	}
+	if err := removeBalanceAction(acc, acs, nil, nil, nil); err == nil || err != utils.ErrNotFound {
+		t.Error(err)
+	}
 
 }
diff --git a/engine/caches_test.go b/engine/caches_test.go
index d3ab76b31..c837f3186 100644
--- a/engine/caches_test.go
+++ b/engine/caches_test.go
@@ -20,6 +20,7 @@ package engine
 import (
 	"fmt"
 	"reflect"
+	"regexp"
 	"testing"
 	"time"
 
@@ -1021,3 +1022,26 @@ func TestV1LoadCache(t *testing.T) {
 	}
 
 }
+
+func TestCacheSBeginTransaction(t *testing.T) {
+	tmp := Cache
+	defer func() {
+		Cache = tmp
+	}()
+	Cache.Clear(nil)
+
+	cfg := config.NewDefaultCGRConfig()
+	db := NewInternalDB(nil, nil, false, cfg.DataDbCfg().Items)
+	dm := NewDataManager(db, cfg.CacheCfg(), nil)
+
+	cacheS := NewCacheS(cfg, dm, nil)
+
+	expFormat := `........-....-....-....-............`
+	rcv := cacheS.BeginTransaction()
+	if matched, err := regexp.Match(expFormat, []byte(rcv)); err != nil {
+		t.Error(err)
+	} else if !matched {
+		t.Errorf("Unexpected transaction format, Received <%v>", rcv)
+	}
+
+}
diff --git a/engine/cdrs_test.go b/engine/cdrs_test.go
index 9d2e2c045..5eaed3bee 100644
--- a/engine/cdrs_test.go
+++ b/engine/cdrs_test.go
@@ -1676,7 +1676,7 @@ func TestV2StoreSessionCost2(t *testing.T) {
 				Charges: []*ChargingInterval{
 					{
 
-						RatingID: "acc_id",
+						RatingID: utils.MetaRounding,
 						Increments: []*ChargingIncrement{
 							{
 
@@ -1698,7 +1698,7 @@ func TestV2StoreSessionCost2(t *testing.T) {
 						cost:           utils.Float64Pointer(38),
 					},
 					{
-						RatingID: "acc_id2",
+						RatingID: utils.MetaRounding,
 
 						Increments: []*ChargingIncrement{
 							{
@@ -1730,10 +1730,10 @@ func TestV2StoreSessionCost2(t *testing.T) {
 
 				Accounting: Accounting{
 					"acc_id": &BalanceCharge{
-						RatingID: "acc_id",
+						RatingID: utils.MetaRounding,
 					},
 					"acc_id2": &BalanceCharge{
-						RatingID: "acc_id2",
+						RatingID: utils.MetaRounding,
 					},
 				},
 				RatingFilters: RatingFilters{
@@ -1753,7 +1753,7 @@ func TestV2StoreSessionCost2(t *testing.T) {
 				Rates:   ChargedRates{},
 				Timings: ChargedTimings{},
 				Rating: Rating{
-					"acc_id": &RatingUnit{
+					utils.MetaRounding: &RatingUnit{
 						ConnectFee:       21,
 						RoundingMethod:   "method",
 						RoundingDecimals: 3,
@@ -1762,16 +1762,6 @@ func TestV2StoreSessionCost2(t *testing.T) {
 						RatesID:          "rates",
 						RatingFiltersID:  "filtersid",
 					},
-
-					"acc_id2": &RatingUnit{
-						ConnectFee:       21,
-						RoundingMethod:   "method",
-						RoundingDecimals: 3,
-						MaxCost:          22,
-						MaxCostStrategy:  "sr",
-						RatesID:          "rates",
-						RatingFiltersID:  "ratefilter",
-					},
 				},
 			},
 		},
diff --git a/engine/datamanager_test.go b/engine/datamanager_test.go
index 460ffe2ea..e32f17baf 100644
--- a/engine/datamanager_test.go
+++ b/engine/datamanager_test.go
@@ -2178,3 +2178,245 @@ func TestGetReverseDestinationRemote(t *testing.T) {
 		t.Error(err)
 	}
 }
+
+func TestDMRemoveDestination(t *testing.T) {
+	cfg := config.NewDefaultCGRConfig()
+	tmpDm := dm
+	tmp := Cache
+	tmpConn := connMgr
+	defer func() {
+		config.SetCgrConfig(config.NewDefaultCGRConfig())
+		Cache = tmp
+		SetDataStorage(tmpDm)
+		connMgr = tmpConn
+	}()
+	Cache.Clear(nil)
+	cfg.DataDbCfg().RplConns = []string{utils.ConcatenatedKey(utils.MetaInternal, utils.ReplicatorSv1)}
+	cfg.DataDbCfg().RplFiltered = true
+	cfg.CacheCfg().Partitions[utils.CacheDestinations].Replicate = true
+	cfg.CacheCfg().ReplicationConns = []string{utils.ConcatenatedKey(utils.MetaInternal, utils.MetaCaches)}
+	cfg.DataDbCfg().Items = map[string]*config.ItemOpt{
+		utils.CacheDestinations: {
+			Limit:     3,
+			Replicate: true,
+			APIKey:    "key",
+			RouteID:   "route",
+		},
+		utils.CacheReverseDestinations: {
+			Remote: true,
+		},
+	}
+	dest := &Destination{
+		Id: "nat", Prefixes: []string{"0257", "0256", "0723"},
+	}
+	clientConn := make(chan rpcclient.ClientConnector, 1)
+	clientConn <- &ccMock{
+		calls: map[string]func(args interface{}, reply interface{}) error{
+			utils.ReplicatorSv1RemoveDestination: func(args, reply interface{}) error {
+				strApiOpts, cancast := args.(utils.StringWithAPIOpts)
+				if !cancast {
+					return utils.ErrNotConvertible
+				}
+				dm.DataDB().RemoveDestinationDrv(strApiOpts.Arg, utils.NonTransactional)
+				return nil
+			},
+			utils.ReplicatorSv1GetReverseDestination: func(args, reply interface{}) error {
+				strApiOpts, cancast := args.(utils.StringWithAPIOpts)
+				if !cancast {
+					return utils.ErrNotConvertible
+				}
+				dm.DataDB().GetReverseDestinationDrv(strApiOpts.Arg, utils.NonTransactional)
+				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)
+	dm.DataDB().SetDestinationDrv(dest, utils.NonTransactional)
+	if err := dm.RemoveDestination(dest.Id, utils.NonTransactional); err != nil {
+		t.Error(err)
+	}
+	if err := dm.RemoveDestination(dest.Id, utils.NonTransactional); err == nil || err != utils.ErrNotFound {
+		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.CacheSv1ReplicateRemove: 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.RemoveDestination(dest.Id, utils.NonTransactional); err == nil {
+		t.Error(err)
+	}
+	var dm2 *DataManager
+	if err := dm2.RemoveDestination(dest.Id, utils.NonTransactional); err == nil {
+		t.Error(err)
+	}
+}
+
+func TestDMRemoveFilter(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().RmtConns = []string{utils.ConcatenatedKey(utils.MetaInternal, utils.ReplicatorSv1)}
+	cfg.DataDbCfg().Items = map[string]*config.ItemOpt{
+		utils.CacheFilters: {
+			Limit:     3,
+			Replicate: true,
+			APIKey:    "key",
+			RouteID:   "route",
+			Remote:    false,
+		},
+		utils.CacheReverseFilterIndexes: {
+			Remote: true,
+		},
+	}
+	clientConn := make(chan rpcclient.ClientConnector, 1)
+	clientConn <- &ccMock{
+		calls: map[string]func(args interface{}, reply interface{}) error{
+			utils.ReplicatorSv1RemoveFilter: func(args, reply interface{}) error {
+				tntApiOpts, cancast := args.(utils.TenantIDWithAPIOpts)
+				if !cancast {
+					return utils.ErrNotConvertible
+				}
+				dm.dataDB.RemoveFilterDrv(tntApiOpts.TenantID.Tenant, tntApiOpts.TenantID.ID)
+				return nil
+			},
+			utils.ReplicatorSv1GetIndexes: func(args, reply interface{}) error {
+				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)
+	fltr := &Filter{
+		Tenant: "cgrates.org",
+		ID:     "Filter1",
+		Rules: []*FilterRule{
+			{
+				Element: "~*req.Account",
+				Type:    utils.MetaString,
+				Values:  []string{"1001", "1002"},
+			},
+		},
+		ActivationInterval: &utils.ActivationInterval{
+			ActivationTime: time.Date(2014, 7, 14, 14, 25, 0, 0, time.UTC),
+			ExpiryTime:     time.Date(2014, 7, 14, 14, 25, 0, 0, time.UTC),
+		},
+	}
+	dm.DataDB().SetFilterDrv(fltr)
+	if err := dm.RemoveFilter(fltr.Tenant, fltr.ID, true); err == nil {
+		t.Error(err)
+	}
+	if err := dm.RemoveFilter(fltr.Tenant, fltr.ID, false); err != nil {
+		t.Error(err)
+	}
+	if err := dm.RemoveFilter(fltr.Tenant, fltr.ID, false); err == nil || err != utils.ErrNotFound {
+		t.Error(err)
+	}
+	var dm2 *DataManager
+	if err := dm2.RemoveFilter(fltr.Tenant, fltr.ID, false); err == nil || err != utils.ErrNoDatabaseConn {
+		t.Error(err)
+	}
+}
+
+func TestRemoveStatQueueProfile(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().RmtConns = []string{utils.ConcatenatedKey(utils.MetaInternal, utils.ReplicatorSv1)}
+	cfg.DataDbCfg().RplFiltered = true
+	cfg.DataDbCfg().Items = map[string]*config.ItemOpt{
+		utils.CacheStatQueueProfiles: {
+			Limit:     3,
+			Replicate: true,
+			APIKey:    "key",
+			RouteID:   "route",
+		},
+		utils.CacheStatQueues: {
+			Limit:     3,
+			Replicate: true,
+			APIKey:    "key",
+			RouteID:   "route",
+		},
+		utils.CacheReverseFilterIndexes: {
+			Remote: true,
+		},
+	}
+	sQ := &StatQueueProfile{
+		Tenant:    "cgrates.org",
+		ID:        "STATS_RES_TEST12",
+		FilterIDs: []string{"FLTR_ST_Resource1", "*string:~*req.Account:1001"},
+		Weight:    50,
+	}
+	clientConn := make(chan rpcclient.ClientConnector, 1)
+	clientConn <- &ccMock{
+		calls: map[string]func(args interface{}, reply interface{}) error{
+			utils.ReplicatorSv1RemoveStatQueueProfile: func(args, reply interface{}) error {
+				tntApiOpts, cancast := args.(utils.TenantIDWithAPIOpts)
+				if !cancast {
+					return utils.ErrNotConvertible
+				}
+				dm.DataDB().RemStatQueueProfileDrv(tntApiOpts.Tenant, tntApiOpts.ID)
+				return nil
+			},
+			utils.ReplicatorSv1GetIndexes: 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.ReplicatorSv1): clientConn,
+	})
+	dm := NewDataManager(db, cfg.CacheCfg(), connMgr)
+	config.SetCgrConfig(cfg)
+	SetDataStorage(dm)
+	dm.DataDB().SetStatQueueProfileDrv(sQ)
+	if err = dm.RemoveStatQueueProfile(sQ.Tenant, sQ.ID, true); err == nil {
+		t.Error(err)
+	}
+	dm.DataDB().SetStatQueueProfileDrv(sQ)
+	if err = dm.RemoveStatQueueProfile(sQ.Tenant, sQ.ID, false); err != nil {
+		t.Error(err)
+	}
+	if err = dm.RemoveStatQueueProfile(sQ.Tenant, sQ.ID, true); err == nil || err != utils.ErrNotFound {
+		t.Error(err)
+	}
+	var dm2 *DataManager
+	if err = dm2.RemoveStatQueueProfile(sQ.Tenant, sQ.ID, true); err == nil || err != utils.ErrNoDatabaseConn {
+		t.Error(err)
+	}
+}