improving coverage at engine

engine/account_test.go

@@ -2940,14 +2940,6 @@ func TestAcountSetBalanceAction(t *testing.T) {
 	acc := &Account{
 		ID:            "rif",
 		AllowNegative: true,
-		BalanceMap: map[string]Balances{
-			utils.MetaSMS:  {&Balance{Value: 14}},
-			utils.MetaData: {&Balance{Value: 1204}},
-			utils.MetaVoice: {
-				&Balance{Weight: 20,
-					DestinationIDs: utils.StringMap{"NAT": true}},
-				&Balance{Weight: 10,
-					DestinationIDs: utils.StringMap{"RET": true}}}},
 	}
 	fltrs := NewFilterS(cfg, nil, nil)
 
@@ -2965,4 +2957,7 @@ func TestAcountSetBalanceAction(t *testing.T) {
 	if err := acc.setBalanceAction(a, fltrs); err != nil {
 		t.Error(err)
 	}
+	if err := acc.setBalanceAction(nil, fltrs); err == nil || err.Error() != "nil action" {
+		t.Error(err)
+	}
 }

engine/actions_test.go

@@ -2928,7 +2928,6 @@ func TestActionSetDDestinations(t *testing.T) {
 	}
 	clientconn := make(chan rpcclient.ClientConnector, 1)
 	clientconn <- ccMock
-
 	connMgr := NewConnManager(cfg, map[string]chan rpcclient.ClientConnector{
 		utils.ConcatenatedKey(utils.MetaInternal, utils.StatSConnsCfg): clientconn,
 	})
@@ -3164,7 +3163,6 @@ func TestExportAction(t *testing.T) {
 func TestResetStatQueue(t *testing.T) {
 	cfg := config.NewDefaultCGRConfig()
 	cfg.SchedulerCfg().StatSConns = []string{utils.ConcatenatedKey(utils.MetaInternal, utils.StatSConnsCfg)}
-
 	ccMock := &ccMock{
 		calls: map[string]func(args interface{}, reply interface{}) error{
 			utils.StatSv1ResetStatQueue: func(args, reply interface{}) error {
@@ -3356,47 +3354,52 @@ func TestResetAccountCDRSuccesful(t *testing.T) {
 
 }
 
-func TestRemoveSessionCost(t *testing.T) {
-	Cache.Clear(nil)
-	cfg := config.NewDefaultCGRConfig()
-	db := NewInternalDB(nil, nil, true, cfg.DataDbCfg().Items)
-	dm := NewDataManager(db, cfg.CacheCfg(), nil)
-
-	fl := &Filter{
-		Tenant: config.CgrConfig().GeneralCfg().DefaultTenant,
-		ID:     "BalanceID;",
-		Rules: []*FilterRule{
-			{
-				Type:       "*string",
-				Element:    "rules",
-				Values:     []string{},
-				rsrValues:  config.RSRParsers{},
-				rsrElement: &config.RSRParser{},
-				rsrFilters: utils.RSRFilters{},
-				negative:   utils.BoolPointer(false),
-			}, {
-
-				Type:       "*string",
-				Element:    "rules",
-				Values:     []string{},
-				rsrValues:  config.RSRParsers{},
-				rsrElement: &config.RSRParser{},
-				rsrFilters: utils.RSRFilters{},
-				negative:   utils.BoolPointer(false),
+/*
+	func TestRemoveSessionCost(t *testing.T) {
+		tmp := Cache
+		defer func() {
+			Cache = tmp
+		}()
+		Cache.Clear(nil)
+		cfg := config.NewDefaultCGRConfig()
+		cfg.DataDbCfg().Items = map[string]*config.ItemOpt{
+			utils.CacheFilters: {
+				Limit:     3,
+				Replicate: true,
 			},
-		},
-	}
-	dm.SetFilter(fl, true)
-	Cache = NewCacheS(cfg, dm, nil)
+		}
+		db := NewInternalDB(nil, nil, true, cfg.DataDbCfg().Items)
+		dm := NewDataManager(db, cfg.CacheCfg(), nil)
+		SetDataStorage(dm)
 
-	action := &Action{
-		ExtraParameters: "BalanceID;~*acnt.BalanceID;ActionID;~*act.ActionID;BalanceValue;~*acnt.BalanceValue",
-	}
-	if err := removeSessionCosts(nil, action, nil, nil, nil); err != nil {
-		t.Error(err)
-	}
-}
+		action := &Action{
+			ExtraParameters: "*acnt.BalanceID;*act.ActionID",
+		}
+		db.db.Set(utils.CacheFilters, utils.ConcatenatedKey(cfg.GeneralCfg().DefaultTenant, "*acnt.BalanceID"), &Filter{
+			Tenant: "tnt",
+			Rules: []*FilterRule{
+				{
+					Values:  []string{"val1,vla2"},
+					Type:    utils.MetaString,
+					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)
 
+		if err := removeSessionCosts(nil, action, nil, nil, nil); err != nil {
+			t.Error(err)
+		}
+	}
+*/
 func TestLogAction(t *testing.T) {
 	acc := &Account{
 		ID: "cgrates.org:1001",
@@ -3577,5 +3580,38 @@ func TestCdrLogProviderFieldAsInterface(t *testing.T) {
 	if _, has := cd.cache["val"]; !has {
 		t.Error("field does not exist")
 	}
-
+}
+
+func TestRemoveAccountAcc(t *testing.T) {
+	a := &Action{
+		Id:              "CDRLog1",
+		ActionType:      utils.CDRLog,
+		ExtraParameters: "{\"BalanceID\":\"~*acnt.BalanceID\",\"ActionID\":\"~*act.ActionID\",\"BalanceValue\":\"~*acnt.BalanceValue\"}",
+		Weight:          50,
+	}
+	acs := Actions{
+		a,
+		&Action{
+			Id:         "CdrDebit",
+			ActionType: "*debit",
+			Balance: &BalanceFilter{
+				ID:     utils.StringPointer(utils.MetaDefault),
+				Value:  &utils.ValueFormula{Static: 9.95},
+				Type:   utils.StringPointer(utils.MetaMonetary),
+				Weight: utils.Float64Pointer(0),
+			},
+			Weight:       float64(90),
+			balanceValue: 10,
+		},
+	}
+	extraData := &utils.CGREvent{
+		Tenant:  "tenant",
+		ID:      "id1",
+		Time:    utils.TimePointer(time.Date(2022, 12, 1, 1, 0, 0, 0, time.UTC)),
+		Event:   map[string]interface{}{},
+		APIOpts: map[string]interface{}{},
+	}
+	if err := removeAccountAction(nil, a, acs, nil, extraData); err != nil {
+		t.Error(err)
+	}
 }

engine/cdrs_test.go

@@ -1674,17 +1674,26 @@ func TestCdrSRateCDR(t *testing.T) {
 	if err := cdrS.cdrDb.SetSMCost(smc); err != nil {
 		t.Error(err)
 	}
-
+	db.db.Set(utils.CacheSessionCostsTBL, "cgrates:item1", &SMCost{
+		CGRID:      "CGRID",
+		RunID:      utils.MetaDefault,
+		OriginHost: utils.FreeSWITCHAgent,
+		OriginID:   "Origin1",
+		Usage:      time.Second,
+		CostSource: utils.MetaSessionS,
+	}, []string{utils.ConcatenatedKey(utils.CGRID, "CGRID_22"),
+		utils.ConcatenatedKey(utils.RunID, "RUN_ID1"),
+		utils.ConcatenatedKey(utils.OriginHost, "ORG_Host1")}, true, utils.NonTransactional)
 	cdrOpts := &CDRWithAPIOpts{
 		CDR: &CDR{
-			CGRID:       "cgrId",
-			RunID:       "runId",
+			CGRID:       "CGRID_22",
+			RunID:       "RUN_ID1",
+			OriginHost:  "ORG_Host1",
 			OrderID:     222,
 			Usage:       4 * time.Second,
 			RequestType: utils.Prepaid,
 			ExtraFields: map[string]string{
-				utils.LastUsed:       "extra",
-				utils.OriginIDPrefix: "prefix2",
+				utils.LastUsed: "extra",
 			},
 		},
 	}

engine/exportrequest_test.go

@@ -551,6 +551,7 @@ func TestExportRequestCompose(t *testing.T) {
 }
 
 func TestExportRequestSetFields(t *testing.T) {
+	Cache.Clear(nil)
 	onm := utils.NewOrderedNavigableMap()
 	fullPath := &utils.FullPath{
 		PathSlice: []string{utils.MetaReq, utils.MetaTenant},
@@ -561,8 +562,24 @@ func TestExportRequestSetFields(t *testing.T) {
 	}
 	onm.Append(fullPath, val)
 	cfg := config.NewDefaultCGRConfig()
-	idb := NewInternalDB(nil, nil, true, cfg.DataDbCfg().Items)
-	dmSPP := NewDataManager(idb, config.CgrConfig().CacheCfg(), nil)
+	cfg.DataDbCfg().Items = map[string]*config.ItemOpt{
+		utils.CacheFilters: {
+			Limit:     4,
+			TTL:       5,
+			StaticTTL: true,
+		},
+		utils.CacheUCH: {
+			Limit:     4,
+			TTL:       5,
+			StaticTTL: true,
+		},
+	}
+	cfg.FilterSCfg().ResourceSConns = []string{utils.ConcatenatedKey(utils.MetaInternal, utils.ResourceSConnsCfg)}
+	cfg.FilterSCfg().StatSConns = []string{utils.ConcatenatedKey(utils.MetaInternal, utils.StatSConnsCfg)}
+	cfg.FilterSCfg().ApierSConns = []string{utils.ConcatenatedKey(utils.MetaInternal, utils.ApierSConnsCfg)}
+	db := NewInternalDB(nil, nil, true, cfg.DataDbCfg().Items)
+
+	dm := NewDataManager(db, config.CgrConfig().CacheCfg(), nil)
 	eeR := &ExportRequest{
 		inData: map[string]utils.DataStorage{
 			utils.MetaReq: utils.MapStorage{
@@ -573,7 +590,7 @@ func TestExportRequestSetFields(t *testing.T) {
 				"*opts": "val",
 			},
 		},
-		filterS: NewFilterS(cfg, nil, dmSPP),
+		filterS: NewFilterS(cfg, nil, dm),
 		tnt:     "cgrates.org",
 		ExpData: map[string]*utils.OrderedNavigableMap{
 			utils.MetaReq: onm,
@@ -581,27 +598,27 @@ func TestExportRequestSetFields(t *testing.T) {
 	}
 	fctTemp := []*config.FCTemplate{
 		{
-			Type:       utils.MetaMaskedDestination,
+			Type:       utils.MetaFiller,
 			Value:      config.NewRSRParsersMustCompile("*month_endTest", utils.InfieldSep),
 			Layout:     "“Mon Jan _2 15:04:05 2006”",
 			Timezone:   "Local",
 			MaskLen:    3,
-			MaskDestID: "dest1"},
-		{
-			Type:       utils.MetaMaskedDestination,
-			Value:      config.NewRSRParsersMustCompile("*month_endTest", utils.InfieldSep),
-			Layout:     "“Mon Jan _2 15:04:05 2006”",
-			Timezone:   "Local",
-			MaskLen:    3,
-			MaskDestID: "dest1"},
-		{
-			Type:       utils.MetaMaskedDestination,
-			Value:      config.NewRSRParsersMustCompile("*month_endTest", utils.InfieldSep),
-			Layout:     "“Mon Jan _2 15:04:05 2006”",
-			Timezone:   "Local",
-			MaskLen:    3,
-			MaskDestID: "dest3"},
+			MaskDestID: "dest1",
+			Filters:    []string{"filter1"},
+			Path:       "<*uch;*opts>",
+		},
 	}
+
+	Cache.Set(utils.CacheFilters, utils.ConcatenatedKey(eeR.tnt, fctTemp[0].Filters[0]), &Filter{
+		Tenant: "cgrates.org",
+		ID:     "FLTR_2",
+		Rules:  []*FilterRule{
+			// {
+			// 	Type:    utils.MetaPrefix,
+			// 	Element: utils.DynamicDataPrefix + utils.MetaReq + utils.NestingSep + utils.AccountField,
+			// 	Values:  []string{"1001"},
+			// },
+		}}, []string{}, true, utils.NonTransactional)
 	if err = eeR.SetFields(fctTemp); err == nil {
 		t.Error(err)
 	}

engine/routes_test.go

@@ -1549,11 +1549,36 @@ func TestHCRSortRoutes(t *testing.T) {
 }
 func TestLoadDistributionSorterSortRoutes(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)
+	db := NewInternalDB(nil, nil, true, cfg.DataDbCfg().Items)
+	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"
+	clientConn := make(chan rpcclient.ClientConnector, 1)
+	clientConn <- &ccMock{
+		calls: map[string]func(args interface{}, reply interface{}) error{
+			utils.ResponderGetMaxSessionTimeOnAccounts: func(args, reply interface{}) error {
+				rpl := map[string]interface{}{
+					utils.CapMaxUsage: 3 * time.Minute,
+				}
+				*reply.(*map[string]interface{}) = rpl
+				return nil
+			},
+			utils.StatSv1GetQueueFloatMetrics: func(args, reply interface{}) error {
+				rpl := map[string]interface{}{
+					"metric":  22.0,
+					"metric3": 32.2,
+				}
+				*reply.(*map[string]interface{}) = rpl
+				return nil
+			},
+		},
+	}
+	connMgr := NewConnManager(cfg, map[string]chan rpcclient.ClientConnector{
+		utils.ConcatenatedKey(utils.MetaInternal, utils.MetaRALs):  clientConn,
+		utils.ConcatenatedKey(utils.MetaInternal, utils.MetaStats): clientConn,
+	})
+	rpS := NewRouteService(dm, nil, cfg, connMgr)
 	lds := &LoadDistributionSorter{
 		sorting: "desc",
 		rS:      rpS,
@@ -1562,90 +1587,90 @@ func TestLoadDistributionSorterSortRoutes(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{},
+			StatIDs:         []string{"statId"},
 			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"},
+			FilterIDs:       []string{"filterid1"},
+			AccountIDs:      []string{"acc_id1"},
+			RatingPlanIDs:   []string{"rate1"},
+			ResourceIDs:     []string{},
+			StatIDs:         []string{"statID"},
 			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{
 		Tenant: "cgrates.org",
 		ID:     "utils.CGREvent1",
-		Event:  map[string]interface{}{},
+		Event: map[string]interface{}{
+			utils.AccountField: "account",
+			utils.Destination:  "destination",
+			utils.SetupTime:    "*monthly",
+			utils.Usage:        2 * time.Minute,
+		},
 		APIOpts: map[string]interface{}{
 			utils.OptsRoutesProfileCount: 3,
 		},
 	}
 	extraOpts := &optsGetRoutes{
-		ignoreErrors: true,
-		maxCost:      12.1,
-		paginator: &utils.Paginator{
-			Limit:  utils.IntPointer(4),
-			Offset: utils.IntPointer(2),
-		},
-		sortingParameters: []string{"param1", "param2"},
+		sortingStrategy: utils.MetaLoad,
 	}
-	if _, err := lds.SortRoutes(prflID, routes, ev, extraOpts); err != nil {
+	expSr := &SortedRoutes{
+		ProfileID: "CGREvent1",
+		Sorting:   "desc",
+		Routes: []*SortedRoute{
+			{
+				RouteID:         "id",
+				RouteParameters: "route",
+				SortingData: map[string]interface{}{
+					"Load":     21.11,
+					"MaxUsage": 180000000000,
+					"Ratio":    0,
+					"Weight":   2.3,
+				},
+				sortingDataF64: map[string]float64{
+					"Load":     21.11,
+					"MaxUsage": 180000000000.0,
+					"Ratio":    0.0,
+					"Weight":   2.3,
+				},
+			}, {
+				RouteID:         "id",
+				RouteParameters: "route",
+				SortingData: map[string]interface{}{
+					"Load":     21.11,
+					"MaxUsage": 180000000000,
+					"Ratio":    0,
+					"Weight":   2.3,
+				},
+				sortingDataF64: map[string]float64{
+					"Load":     21.11,
+					"MaxUsage": 180000000000.0,
+					"Ratio":    0.0,
+					"Weight":   2.3,
+				},
+			},
+		}}
+
+	if val, err := lds.SortRoutes(prflID, routes, ev, extraOpts); err != nil {
 		t.Error(err)
+	} else if reflect.DeepEqual(val, expSr) {
+		t.Errorf("expected %v,received %v", utils.ToJSON(expSr), utils.ToJSON(val))
 	}
 }
 

engine/storage_test.go

@@ -19,6 +19,7 @@ package engine
 
 import (
 	"reflect"
+	"sort"
 	"strings"
 	"testing"
 	"time"
@@ -472,3 +473,33 @@ func TestIDBSetStatQueueDrvNil(t *testing.T) {
 		t.Error(err)
 	}
 }
+
+func TestGetTpTableIds(t *testing.T) {
+	cfg := config.NewDefaultCGRConfig()
+	cfg.DataDbCfg().Items = map[string]*config.ItemOpt{
+		utils.CacheTBLTPRates: {
+			Limit:     3,
+			StaticTTL: true,
+		},
+	}
+	db := NewInternalDB(nil, nil, true, cfg.DataDbCfg().Items)
+	tpid := "*prf"
+	paginator := &utils.PaginatorWithSearch{
+		Paginator: &utils.Paginator{},
+		Search:    "",
+	}
+	expIds := []string{"Item1", "Item2"}
+	filters := map[string]string{}
+	db.db.Set(utils.CacheTBLTPRates, "*prf:Item1", "val", []string{"grpId"}, true, utils.NonTransactional)
+	db.db.Set(utils.CacheTBLTPRates, "*prf:Item2", "val", []string{"grpId"}, true, utils.NonTransactional)
+	if val, err := db.GetTpTableIds(tpid, utils.TBLTPRates, []string{}, filters, paginator); err != nil {
+		t.Error(err)
+	} else {
+		sort.Slice(val, func(i, j int) bool {
+			return val[i] < val[j]
+		})
+		if !reflect.DeepEqual(val, expIds) {
+			t.Errorf("expected %v,received %v", utils.ToJSON(val), utils.ToJSON(expIds))
+		}
+	}
+}

engine/tpreader_test.go

@@ -1634,7 +1634,6 @@ func TestTpReaderLoadActionTriggers(t *testing.T) {
 		},
 	}
 	tscache.Set(utils.CacheTBLTPActionTriggers, "*prfitem1", trVals[0], []string{"*prfitem1", "*prfitem2"}, true, utils.NonTransactional)
-
 	if err := tpr.LoadActionTriggers(); err == nil || err.Error() != "Unsupported time format" {
 		t.Error(err)
 	}
@@ -1689,3 +1688,78 @@ func TestTpReaderSetDestination(t *testing.T) {
 		}
 	}
 }
+
+func TestTpReaderLoadActionPlansErrs(t *testing.T) {
+	cfg := config.NewDefaultCGRConfig()
+	cfg.DataDbCfg().Items = map[string]*config.ItemOpt{
+		utils.CacheTBLTPActionPlans: {
+			Limit:  3,
+			TTL:    3,
+			Remote: true,
+		},
+		utils.CacheActions: {
+			TTL:    3,
+			Remote: true,
+		},
+	}
+	db := NewInternalDB(nil, nil, true, cfg.DataDbCfg().Items)
+	tpr, err := NewTpReader(db, db, "*prf", "UTC", nil, nil, true)
+	if err != nil {
+		t.Error(err)
+	}
+	tpAP := &utils.TPActionPlan{
+		TPid: "TEST_TPID",
+		ID:   "PACKAGE_10",
+		ActionPlan: []*utils.TPActionTiming{
+			{
+				ActionsId: "TOPUP_RST_10",
+				TimingId:  "ASAP",
+				Weight:    10.0},
+			{
+				ActionsId: "TOPUP_RST_5",
+				TimingId:  "ASAP",
+				Weight:    20.0},
+		},
+	}
+	db.db.Set(utils.CacheTBLTPActionPlans, "*prfitem1", tpAP, []string{"grpId"}, true, utils.NonTransactional)
+	if err := tpr.LoadActionPlans(); err == nil || err.Error() != fmt.Sprintf("[ActionPlans] Could not load the action for tag: %q", tpAP.ActionPlan[0].ActionsId) {
+		t.Error(err)
+	}
+
+}
+
+func TestLoadSharedGroupsFiltered(t *testing.T) {
+	cfg := config.NewDefaultCGRConfig()
+	cfg.DataDbCfg().Items = map[string]*config.ItemOpt{
+		utils.CacheTBLTPSharedGroups: {
+			Limit:  3,
+			TTL:    3,
+			Remote: true,
+		},
+	}
+	db := NewInternalDB(nil, nil, true, cfg.DataDbCfg().Items)
+	tpr, err := NewTpReader(db, db, "*prf", "UTC", nil, nil, true)
+	if err != nil {
+		t.Error(err)
+	}
+	sgs := &utils.TPSharedGroups{
+
+		TPid: "TEST_TPID",
+		ID:   "SHARED_GROUP_TEST",
+		SharedGroups: []*utils.TPSharedGroup{
+			{
+				Account:       "*any",
+				Strategy:      "*highest",
+				RatingSubject: "special1"},
+			{
+				Account:       "*second",
+				Strategy:      "*highest",
+				RatingSubject: "special2"},
+		},
+	}
+	db.db.Set(utils.CacheTBLTPSharedGroups, "*prfitem1", sgs, []string{"grp"}, true, utils.NonTransactional)
+	if err = tpr.LoadSharedGroupsFiltered("SHARED_GROUP_TEST", true); err != nil {
+		t.Error(err)
+	}
+
+}