Tests for coverage

ees/amqp_test.go

@@ -0,0 +1,71 @@
+/*
+Real-time Online/Offline Charging System (OCS) for Telecom & ISP environments
+Copyright (C) ITsysCOM GmbH
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>
+*/
+
+package ees
+
+import (
+	"reflect"
+	"testing"
+
+	"github.com/cgrates/cgrates/config"
+	"github.com/cgrates/cgrates/utils"
+)
+
+func TestNewAMQPee(t *testing.T) {
+	cfg := config.NewDefaultCGRConfig()
+	dc := &utils.SafeMapStorage{
+		MapStorage: utils.MapStorage{
+			utils.NumberOfEvents:  int64(0),
+			utils.PositiveExports: utils.StringSet{},
+			utils.NegativeExports: 5,
+		}}
+	cfg.EEsCfg().GetDefaultExporter().ConcurrentRequests = 2
+	rcv := NewAMQPee(cfg.EEsCfg().GetDefaultExporter(), dc)
+	exp := &AMQPee{
+		cfg:  cfg.EEsCfg().GetDefaultExporter(),
+		dc:   dc,
+		reqs: newConcReq(cfg.EEsCfg().GetDefaultExporter().ConcurrentRequests),
+	}
+	rcv.reqs = nil
+	exp.reqs = nil
+	exp.parseOpts(cfg.EEsCfg().GetDefaultExporter().Opts)
+	if !reflect.DeepEqual(rcv, exp) {
+		t.Errorf("Expected %v\n but received %v", exp, rcv)
+	}
+}
+
+// func TestAMQPExportEvent(t *testing.T) {
+// 	cfg := config.NewDefaultCGRConfig()
+// 	dc := &utils.SafeMapStorage{
+// 		MapStorage: utils.MapStorage{
+// 			utils.NumberOfEvents:  int64(0),
+// 			utils.PositiveExports: utils.StringSet{},
+// 			utils.NegativeExports: 5,
+// 		}}
+// 	// cfg.EEsCfg().GetDefaultExporter().ConcurrentRequests = 2
+// 	// cfg.EEsCfg().GetDefaultExporter().Opts = &config.EventExporterOpts{
+
+// 	// }
+// 	pstr := NewAMQPee(cfg.EEsCfg().GetDefaultExporter(), dc)
+// 	content := "some_content"
+// 	pstr.postChan =
+// 	if err := pstr.ExportEvent(context.Background(), content, ""); err != nil {
+// 		t.Error(err)
+// 	}
+
+// }

engine/attributes_test.go

@@ -0,0 +1,454 @@
+/*
+Real-time Online/Offline Charging System (OCS) for Telecom & ISP environments
+Copyright (C) ITsysCOM GmbH
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>
+*/
+
+package engine
+
+import (
+	"testing"
+	"time"
+
+	"github.com/cgrates/cgrates/config"
+	"github.com/cgrates/cgrates/utils"
+)
+
+// func TestAttrProfileForEvent(t *testing.T) {
+// 	cfg := config.NewDefaultCGRConfig()
+// 	connMng := NewConnManager(cfg)
+// 	dataDB, err := NewDataDBConn(cfg.DataDbCfg().Type,
+// 		cfg.DataDbCfg().Host, cfg.DataDbCfg().Port,
+// 		cfg.DataDbCfg().Name, cfg.DataDbCfg().User,
+// 		cfg.DataDbCfg().Password, cfg.GeneralCfg().DBDataEncoding,
+// 		cfg.DataDbCfg().Opts, cfg.DataDbCfg().Items)
+// 	if err != nil {
+// 		t.Error(err)
+// 	}
+// 	defer dataDB.Close()
+// 	dm := NewDataManager(dataDB, config.CgrConfig().CacheCfg(), connMng)
+// 	attr := &AttributeS{
+// 		dm:    dm,
+// 		fltrS: NewFilterS(cfg, connMng, dm),
+// 		cfg:   cfg,
+// 	}
+// 	attrPrf := &AttributeProfile{
+// 		Tenant:    utils.CGRateSorg,
+// 		ID:        "TEST_ATTRIBUTES_TEST",
+// 		FilterIDs: []string{"*string:~*req.Account:1002", "*exists:~*opts.*usage:"},
+// 		Attributes: []*Attribute{
+// 			{
+// 				Path:  utils.AccountField,
+// 				Type:  utils.MetaConstant,
+// 				Value: nil,
+// 			},
+// 			{
+// 				Path:  "*tenant",
+// 				Type:  utils.MetaConstant,
+// 				Value: nil,
+// 			},
+// 		},
+// 		Weights: utils.DynamicWeights{
+// 			{
+// 				FilterIDs: []string{"non_existent"},
+// 				Weight:    20,
+// 			},
+// 		},
+// 	}
+// 	attr.dm.SetAttributeProfile(context.Background(), attrPrf, false)
+// 	rcv, err := attr.attributeProfileForEvent(context.Background(), "cgrates.org", []string{"TEST_ATTRIBUTES_TEST"}, utils.MapStorage{"some": "data"}, "", make(map[string]int), 1, false)
+// 	if err != nil {
+// 		t.Error(err)
+// 	}
+// 	fmt.Println(utils.ToJSON(rcv))
+// }
+
+func TestParseAtributeUsageDiffVal1(t *testing.T) {
+	dp := utils.MapStorage{
+		utils.MetaReq: utils.MapStorage{
+			"usage1": "20",
+			"usage2": "35",
+		},
+	}
+	_, err := ParseAttribute(dp, utils.MetaUsageDifference, utils.EmptyString, config.NewRSRParsersMustCompile("~*req.wrong;~*req.usage2", utils.InfieldSep),
+		0, utils.EmptyString, utils.EmptyString, utils.InfieldSep)
+	if err == nil || err != utils.ErrNotFound {
+		t.Errorf("Expected %v\n but received %v", utils.ErrNotFound, err)
+	}
+
+}
+
+func TestParseAtributeUsageDiffVal2(t *testing.T) {
+	dp := utils.MapStorage{
+		utils.MetaReq: utils.MapStorage{
+			"usage1": "20",
+			"usage2": "35",
+		},
+	}
+	_, err := ParseAttribute(dp, utils.MetaUsageDifference, utils.EmptyString, config.NewRSRParsersMustCompile("~*req.usage1;~*req.wrong", utils.InfieldSep),
+		0, utils.EmptyString, utils.EmptyString, utils.InfieldSep)
+	if err == nil || err != utils.ErrNotFound {
+		t.Errorf("Expected %v\n but received %v", utils.ErrNotFound, err)
+	}
+}
+
+func TestParseAtributeUsageDiffTimeVal1(t *testing.T) {
+	dp := utils.MapStorage{
+		utils.MetaReq: utils.MapStorage{
+			"usage1": "20",
+			"usage2": "35s",
+		},
+	}
+	_, err := ParseAttribute(dp, utils.MetaUsageDifference, utils.EmptyString, config.NewRSRParsersMustCompile("~*req.usage1;~*req.usage2", utils.InfieldSep),
+		0, utils.EmptyString, utils.EmptyString, utils.InfieldSep)
+	errExp := "Unsupported time format"
+	if err == nil || err.Error() != errExp {
+		t.Errorf("Expected %v\n but received %v", errExp, err)
+	}
+}
+
+func TestParseAtributeUsageDiffTimeVal2(t *testing.T) {
+	dp := utils.MapStorage{
+		utils.MetaReq: utils.MapStorage{
+			"usage1": "20s",
+			"usage2": "35",
+		},
+	}
+	_, err := ParseAttribute(dp, utils.MetaUsageDifference, utils.EmptyString, config.NewRSRParsersMustCompile("~*req.usage1;~*req.usage2", utils.InfieldSep),
+		0, utils.EmptyString, utils.EmptyString, utils.InfieldSep)
+	errExp := "Unsupported time format"
+	if err == nil || err.Error() != errExp {
+		t.Errorf("Expected %v\n but received %v", errExp, err)
+	}
+}
+
+func TestParseAtributeSum(t *testing.T) {
+	dp := utils.MapStorage{
+		utils.MetaReq: utils.MapStorage{
+			"not_valid": "field",
+		},
+	}
+	_, err := ParseAttribute(dp, utils.MetaSum, utils.EmptyString, config.NewRSRParsersMustCompile("~*req.valid", utils.InfieldSep),
+		0, utils.EmptyString, utils.EmptyString, utils.InfieldSep)
+	if err == nil || err != utils.ErrNotFound {
+		t.Errorf("Expected %v\n but received %v", utils.ErrNotFound, err)
+	}
+}
+
+func TestParseAtributeDifference(t *testing.T) {
+	dp := utils.MapStorage{
+		utils.MetaReq: utils.MapStorage{
+			"not_valid": "field",
+		},
+	}
+	_, err := ParseAttribute(dp, utils.MetaDifference, utils.EmptyString, config.NewRSRParsersMustCompile("~*req.valid", utils.InfieldSep),
+		0, utils.EmptyString, utils.EmptyString, utils.InfieldSep)
+	if err == nil || err != utils.ErrNotFound {
+		t.Errorf("Expected %v\n but received %v", utils.ErrNotFound, err)
+	}
+}
+
+func TestParseAtributeMultiply(t *testing.T) {
+	dp := utils.MapStorage{
+		utils.MetaReq: utils.MapStorage{
+			"not_valid": "field",
+		},
+	}
+	_, err := ParseAttribute(dp, utils.MetaMultiply, utils.EmptyString, config.NewRSRParsersMustCompile("~*req.valid", utils.InfieldSep),
+		0, utils.EmptyString, utils.EmptyString, utils.InfieldSep)
+	if err == nil || err != utils.ErrNotFound {
+		t.Errorf("Expected %v\n but received %v", utils.ErrNotFound, err)
+	}
+}
+
+func TestParseAtributeDivide(t *testing.T) {
+	dp := utils.MapStorage{
+		utils.MetaReq: utils.MapStorage{
+			"not_valid": "field",
+		},
+	}
+	_, err := ParseAttribute(dp, utils.MetaDivide, utils.EmptyString, config.NewRSRParsersMustCompile("~*req.valid", utils.InfieldSep),
+		0, utils.EmptyString, utils.EmptyString, utils.InfieldSep)
+	if err == nil || err != utils.ErrNotFound {
+		t.Errorf("Expected %v\n but received %v", utils.ErrNotFound, err)
+	}
+}
+
+func TestParseAtributeExponentVal1(t *testing.T) {
+	dp := utils.MapStorage{
+		utils.MetaReq: utils.MapStorage{
+			"number":   "20",
+			"exponent": "2",
+		},
+	}
+	_, err := ParseAttribute(dp, utils.MetaValueExponent, utils.EmptyString, config.NewRSRParsersMustCompile("~*req.wrong;~*req.exponent", utils.InfieldSep),
+		0, utils.EmptyString, utils.EmptyString, utils.InfieldSep)
+	if err == nil || err != utils.ErrNotFound {
+		t.Errorf("Expected %v\n but received %v", utils.ErrNotFound, err)
+	}
+}
+
+func TestParseAtributeExponentVal2(t *testing.T) {
+	dp := utils.MapStorage{
+		utils.MetaReq: utils.MapStorage{
+			"number":   "20",
+			"exponent": "2",
+		},
+	}
+	_, err := ParseAttribute(dp, utils.MetaValueExponent, utils.EmptyString, config.NewRSRParsersMustCompile("~*req.number;~*req.wrong", utils.InfieldSep),
+		0, utils.EmptyString, utils.EmptyString, utils.InfieldSep)
+	if err == nil || err != utils.ErrNotFound {
+		t.Errorf("Expected %v\n but received %v", utils.ErrNotFound, err)
+	}
+}
+
+func TestParseAtributeExponentWrongNumber(t *testing.T) {
+	dp := utils.MapStorage{
+		utils.MetaReq: utils.MapStorage{
+			"number":   "not_a_number",
+			"exponent": "2",
+		},
+	}
+	_, err := ParseAttribute(dp, utils.MetaValueExponent, utils.EmptyString, config.NewRSRParsersMustCompile("~*req.number;~*req.exponent", utils.InfieldSep),
+		0, utils.EmptyString, utils.EmptyString, utils.InfieldSep)
+	errExp := "invalid value <not_a_number> to *valueExponent"
+	if err == nil || err.Error() != errExp {
+		t.Errorf("Expected %v\n but received %v", errExp, err)
+	}
+}
+
+func TestParseAtributeExponentWrongExponent(t *testing.T) {
+	dp := utils.MapStorage{
+		utils.MetaReq: utils.MapStorage{
+			"number":   "4",
+			"exponent": "NaN",
+		},
+	}
+	_, err := ParseAttribute(dp, utils.MetaValueExponent, utils.EmptyString, config.NewRSRParsersMustCompile("~*req.number;~*req.exponent", utils.InfieldSep),
+		0, utils.EmptyString, utils.EmptyString, utils.InfieldSep)
+	errExp := `strconv.Atoi: parsing "NaN": invalid syntax`
+	if err == nil || err.Error() != errExp {
+		t.Errorf("Expected %v\n but received %v", errExp, err)
+	}
+}
+
+func TestParseAtributeUnixTimestampWrongField(t *testing.T) {
+	dp := utils.MapStorage{
+		utils.MetaReq: utils.MapStorage{
+			"unix_timestamp": "not_a_unix_timestamp",
+		},
+	}
+	_, err := ParseAttribute(dp, utils.MetaUnixTimestamp, utils.EmptyString, config.NewRSRParsersMustCompile("~*req.wrong", utils.InfieldSep),
+		0, utils.EmptyString, utils.EmptyString, utils.InfieldSep)
+	if err == nil || err != utils.ErrNotFound {
+		t.Errorf("Expected %v\n but received %v", utils.ErrNotFound, err)
+	}
+}
+
+func TestParseAtributeUnixTimestampWrongVal(t *testing.T) {
+	dp := utils.MapStorage{
+		utils.MetaReq: utils.MapStorage{
+			"unix_timestamp": "not_a_unix_timestamp",
+		},
+	}
+	_, err := ParseAttribute(dp, utils.MetaUnixTimestamp, utils.EmptyString, config.NewRSRParsersMustCompile("~*req.unix_timestamp", utils.InfieldSep),
+		0, utils.EmptyString, utils.EmptyString, utils.InfieldSep)
+	errExp := "Unsupported time format"
+	if err == nil || err.Error() != errExp {
+		t.Errorf("Expected %v\n but received %v", errExp, err)
+	}
+}
+
+func TestParseAtributePrefixPath(t *testing.T) {
+	dp := utils.MapStorage{
+		utils.MetaReq: utils.MapStorage{
+			"prefix": "prfx",
+		},
+	}
+	_, err := ParseAttribute(dp, utils.MetaPrefix, "```", config.NewRSRParsersMustCompile("~*req.prefix", utils.InfieldSep),
+		0, utils.EmptyString, utils.EmptyString, utils.InfieldSep)
+	errExp := "Closed unspilit syntax"
+	if err == nil || err.Error() != errExp {
+		t.Errorf("Expected %v\n but received %v", errExp, err)
+	}
+}
+
+func TestParseAtributePrefixField(t *testing.T) {
+	dp := utils.MapStorage{
+		utils.MetaReq: utils.MapStorage{
+			"prefix": "prfx",
+		},
+	}
+	_, err := ParseAttribute(dp, utils.MetaPrefix, utils.EmptyString, config.NewRSRParsersMustCompile("~*req.wrong", utils.InfieldSep),
+		0, utils.EmptyString, utils.EmptyString, utils.InfieldSep)
+	if err == nil || err != utils.ErrNotFound {
+		t.Errorf("Expected %v\n but received %v", utils.ErrNotFound, err)
+	}
+}
+
+func TestParseAtributeSuffixPath(t *testing.T) {
+	dp := utils.MapStorage{
+		utils.MetaReq: utils.MapStorage{
+			"suffix": "sfx",
+		},
+	}
+	_, err := ParseAttribute(dp, utils.MetaSuffix, "```", config.NewRSRParsersMustCompile("~*req.suffix", utils.InfieldSep),
+		0, utils.EmptyString, utils.EmptyString, utils.InfieldSep)
+	errExp := "Closed unspilit syntax"
+	if err == nil || err.Error() != errExp {
+		t.Errorf("Expected %v\n but received %v", errExp, err)
+	}
+}
+
+func TestParseAtributeSuffixField(t *testing.T) {
+	dp := utils.MapStorage{
+		utils.MetaReq: utils.MapStorage{
+			"suffix": "sfx",
+		},
+	}
+	_, err := ParseAttribute(dp, utils.MetaSuffix, utils.EmptyString, config.NewRSRParsersMustCompile("~*req.wrong", utils.InfieldSep),
+		0, utils.EmptyString, utils.EmptyString, utils.InfieldSep)
+	if err == nil || err != utils.ErrNotFound {
+		t.Errorf("Expected %v\n but received %v", utils.ErrNotFound, err)
+	}
+}
+
+func TestParseAtributeCCUsageLessThanTwo(t *testing.T) {
+	dp := utils.MapStorage{
+		utils.MetaReq: utils.MapStorage{
+			"cc1": "sfx",
+			"cc2": "sfx",
+			// "cc3": "sfx",
+		},
+	}
+	_, err := ParseAttribute(dp, utils.MetaCCUsage, utils.EmptyString, config.NewRSRParsersMustCompile("~*req.cc1;~*req.cc2", utils.InfieldSep),
+		0, utils.EmptyString, utils.EmptyString, utils.InfieldSep)
+	errExp := `invalid arguments <[{"Rules":"~*req.cc1"},{"Rules":"~*req.cc2"}]> to *ccUsage`
+	if err == nil || err.Error() != errExp {
+		t.Errorf("Expected %v\n but received %v", errExp, err)
+	}
+}
+
+func TestParseAtributeCCUsageField1(t *testing.T) {
+	dp := utils.MapStorage{
+		utils.MetaReq: utils.MapStorage{
+			"cc1": "20",
+			"cc2": "sfx",
+			"cc3": "sfx",
+		},
+	}
+	_, err := ParseAttribute(dp, utils.MetaCCUsage, utils.EmptyString, config.NewRSRParsersMustCompile("~*req.wrong;~*req.cc2;~*req.cc3", utils.InfieldSep),
+		0, utils.EmptyString, utils.EmptyString, utils.InfieldSep)
+	if err == nil || err != utils.ErrNotFound {
+		t.Errorf("Expected %v\n but received %v", utils.ErrNotFound, err)
+	}
+}
+
+func TestParseAtributeCCUsageVal1(t *testing.T) {
+	dp := utils.MapStorage{
+		utils.MetaReq: utils.MapStorage{
+			"cc1": "not_valid",
+			"cc2": "sfx",
+			"cc3": "sfx",
+		},
+	}
+	_, err := ParseAttribute(dp, utils.MetaCCUsage, utils.EmptyString, config.NewRSRParsersMustCompile("~*req.cc1;~*req.cc2;~*req.cc3", utils.InfieldSep),
+		0, utils.EmptyString, utils.EmptyString, utils.InfieldSep)
+	errExp := `invalid requestNumber <not_valid> to *ccUsage`
+	if err == nil || err.Error() != errExp {
+		t.Errorf("Expected %v\n but received %v", errExp, err)
+	}
+}
+
+func TestParseAtributeCCUsageField2(t *testing.T) {
+	dp := utils.MapStorage{
+		utils.MetaReq: utils.MapStorage{
+			"cc1": "20",
+			"cc2": "sfx",
+			"cc3": "sfx",
+		},
+	}
+	_, err := ParseAttribute(dp, utils.MetaCCUsage, utils.EmptyString, config.NewRSRParsersMustCompile("~*req.cc1;~*req.wrong;~*req.cc3", utils.InfieldSep),
+		0, utils.EmptyString, utils.EmptyString, utils.InfieldSep)
+	if err == nil || err != utils.ErrNotFound {
+		t.Errorf("Expected %v\n but received %v", utils.ErrNotFound, err)
+	}
+}
+
+func TestParseAtributeCCUsageVal2(t *testing.T) {
+	dp := utils.MapStorage{
+		utils.MetaReq: utils.MapStorage{
+			"cc1": "20",
+			"cc2": "sfx",
+			"cc3": "sfx",
+		},
+	}
+	_, err := ParseAttribute(dp, utils.MetaCCUsage, utils.EmptyString, config.NewRSRParsersMustCompile("~*req.cc1;~*req.cc2;~*req.cc3", utils.InfieldSep),
+		0, utils.EmptyString, utils.EmptyString, utils.InfieldSep)
+	errExp := `invalid usedCCTime <sfx> to *ccUsage`
+	if err == nil || err.Error() != errExp {
+		t.Errorf("Expected %v\n but received %v", errExp, err)
+	}
+}
+
+func TestParseAtributeCCUsageField3(t *testing.T) {
+	dp := utils.MapStorage{
+		utils.MetaReq: utils.MapStorage{
+			"cc1": "20",
+			"cc2": "20",
+			"cc3": "sfx",
+		},
+	}
+	_, err := ParseAttribute(dp, utils.MetaCCUsage, utils.EmptyString, config.NewRSRParsersMustCompile("~*req.cc1;~*req.cc2;~*req.wrong", utils.InfieldSep),
+		0, utils.EmptyString, utils.EmptyString, utils.InfieldSep)
+	if err == nil || err != utils.ErrNotFound {
+		t.Errorf("Expected %v\n but received %v", utils.ErrNotFound, err)
+	}
+}
+
+func TestParseAtributeCCUsageVal3(t *testing.T) {
+	dp := utils.MapStorage{
+		utils.MetaReq: utils.MapStorage{
+			"cc1": "20",
+			"cc2": "20",
+			"cc3": "sfx",
+		},
+	}
+	_, err := ParseAttribute(dp, utils.MetaCCUsage, utils.EmptyString, config.NewRSRParsersMustCompile("~*req.cc1;~*req.cc2;~*req.cc3", utils.InfieldSep),
+		0, utils.EmptyString, utils.EmptyString, utils.InfieldSep)
+	errExp := `invalid debitInterval <sfx> to *ccUsage`
+	if err == nil || err.Error() != errExp {
+		t.Errorf("Expected %v\n but received %v", errExp, err)
+	}
+}
+
+func TestParseAtributeCCUsageNoErr(t *testing.T) {
+	dp := utils.MapStorage{
+		utils.MetaReq: utils.MapStorage{
+			"cc1": "20",
+			"cc2": "20",
+			"cc3": "20",
+		},
+	}
+	out, err := ParseAttribute(dp, utils.MetaCCUsage, utils.EmptyString, config.NewRSRParsersMustCompile("~*req.cc1;~*req.cc2;~*req.cc3", utils.InfieldSep),
+		0, utils.EmptyString, utils.EmptyString, utils.InfieldSep)
+	if err != nil {
+		t.Error(err)
+	}
+	exp := 400 * time.Nanosecond
+	if out.(time.Duration) != exp {
+		t.Errorf("Expected %v\n but received %v", exp, out)
+	}
+}

engine/datamanager_test.go

@@ -68,3 +68,481 @@ func TestDatamanagerCacheDataFromDBMetaAPIBanErr(t *testing.T) {
 		t.Error(err)
 	}
 }
+
+func TestDatamanagerCacheDataFromDBMustBeCached(t *testing.T) {
+	cfg := config.NewDefaultCGRConfig()
+	dm := NewDataManager(nil, cfg.CacheCfg(), nil)
+	dm.cacheCfg.Partitions = map[string]*config.CacheParamCfg{
+		utils.CachePrefixToInstance[utils.AttributeProfilePrefix]: {
+			Limit: 1,
+		},
+	}
+	err := dm.CacheDataFromDB(context.Background(), utils.AttributeProfilePrefix, []string{utils.MetaAny}, true)
+	if err != nil {
+		t.Error(err)
+	}
+}
+
+func TestDatamanagerCacheDataFromDBNotCachedResourceProfiles(t *testing.T) {
+	// cfg := config.NewDefaultCGRConfig()
+	// dm := NewDataManager(nil, cfg.CacheCfg(), nil)
+	cfg := config.NewDefaultCGRConfig()
+	connMng := NewConnManager(cfg)
+	dataDB, err := NewDataDBConn(cfg.DataDbCfg().Type,
+		cfg.DataDbCfg().Host, cfg.DataDbCfg().Port,
+		cfg.DataDbCfg().Name, cfg.DataDbCfg().User,
+		cfg.DataDbCfg().Password, cfg.GeneralCfg().DBDataEncoding,
+		cfg.DataDbCfg().Opts, cfg.DataDbCfg().Items)
+	if err != nil {
+		t.Error(err)
+	}
+	defer dataDB.Close()
+	dm := NewDataManager(dataDB, config.CgrConfig().CacheCfg(), connMng)
+	dm.cacheCfg.Partitions = map[string]*config.CacheParamCfg{
+		utils.CachePrefixToInstance[utils.ResourceProfilesPrefix]: {
+			Limit: 1,
+		},
+		utils.CacheRPCResponses: {
+			Limit: 1,
+		},
+	}
+	err = dm.CacheDataFromDB(context.Background(), utils.ResourceProfilesPrefix, []string{utils.MetaAny}, false)
+	if err != nil {
+		t.Error(err)
+	}
+}
+
+func TestDatamanagerCacheDataFromDBNotCachedResources(t *testing.T) {
+	// cfg := config.NewDefaultCGRConfig()
+	// dm := NewDataManager(nil, cfg.CacheCfg(), nil)
+	cfg := config.NewDefaultCGRConfig()
+	connMng := NewConnManager(cfg)
+	dataDB, err := NewDataDBConn(cfg.DataDbCfg().Type,
+		cfg.DataDbCfg().Host, cfg.DataDbCfg().Port,
+		cfg.DataDbCfg().Name, cfg.DataDbCfg().User,
+		cfg.DataDbCfg().Password, cfg.GeneralCfg().DBDataEncoding,
+		cfg.DataDbCfg().Opts, cfg.DataDbCfg().Items)
+	if err != nil {
+		t.Error(err)
+	}
+	defer dataDB.Close()
+	dm := NewDataManager(dataDB, config.CgrConfig().CacheCfg(), connMng)
+	dm.cacheCfg.Partitions = map[string]*config.CacheParamCfg{
+		utils.CachePrefixToInstance[utils.ResourcesPrefix]: {
+			Limit: 1,
+		},
+		utils.CacheRPCResponses: {
+			Limit: 1,
+		},
+	}
+	err = dm.CacheDataFromDB(context.Background(), utils.ResourcesPrefix, []string{utils.MetaAny}, false)
+	if err != nil {
+		t.Error(err)
+	}
+}
+
+func TestDatamanagerCacheDataFromDBNotCachedStatQueueProfiles(t *testing.T) {
+	// cfg := config.NewDefaultCGRConfig()
+	// dm := NewDataManager(nil, cfg.CacheCfg(), nil)
+	cfg := config.NewDefaultCGRConfig()
+	connMng := NewConnManager(cfg)
+	dataDB, err := NewDataDBConn(cfg.DataDbCfg().Type,
+		cfg.DataDbCfg().Host, cfg.DataDbCfg().Port,
+		cfg.DataDbCfg().Name, cfg.DataDbCfg().User,
+		cfg.DataDbCfg().Password, cfg.GeneralCfg().DBDataEncoding,
+		cfg.DataDbCfg().Opts, cfg.DataDbCfg().Items)
+	if err != nil {
+		t.Error(err)
+	}
+	defer dataDB.Close()
+	dm := NewDataManager(dataDB, config.CgrConfig().CacheCfg(), connMng)
+	dm.cacheCfg.Partitions = map[string]*config.CacheParamCfg{
+		utils.CachePrefixToInstance[utils.StatQueueProfilePrefix]: {
+			Limit: 1,
+		},
+		utils.CacheRPCResponses: {
+			Limit: 1,
+		},
+	}
+	err = dm.CacheDataFromDB(context.Background(), utils.StatQueueProfilePrefix, []string{utils.MetaAny}, false)
+	if err != nil {
+		t.Error(err)
+	}
+}
+
+func TestDatamanagerCacheDataFromDBNotCachedStatQueuePrefix(t *testing.T) {
+	// cfg := config.NewDefaultCGRConfig()
+	// dm := NewDataManager(nil, cfg.CacheCfg(), nil)
+	cfg := config.NewDefaultCGRConfig()
+	connMng := NewConnManager(cfg)
+	dataDB, err := NewDataDBConn(cfg.DataDbCfg().Type,
+		cfg.DataDbCfg().Host, cfg.DataDbCfg().Port,
+		cfg.DataDbCfg().Name, cfg.DataDbCfg().User,
+		cfg.DataDbCfg().Password, cfg.GeneralCfg().DBDataEncoding,
+		cfg.DataDbCfg().Opts, cfg.DataDbCfg().Items)
+	if err != nil {
+		t.Error(err)
+	}
+	defer dataDB.Close()
+	dm := NewDataManager(dataDB, config.CgrConfig().CacheCfg(), connMng)
+	dm.cacheCfg.Partitions = map[string]*config.CacheParamCfg{
+		utils.CachePrefixToInstance[utils.StatQueuePrefix]: {
+			Limit: 1,
+		},
+		utils.CacheRPCResponses: {
+			Limit: 1,
+		},
+	}
+	err = dm.CacheDataFromDB(context.Background(), utils.StatQueuePrefix, []string{utils.MetaAny}, false)
+	if err != nil {
+		t.Error(err)
+	}
+}
+
+func TestDatamanagerCacheDataFromDBNotCachedThresholdProfilePrefix(t *testing.T) {
+	// cfg := config.NewDefaultCGRConfig()
+	// dm := NewDataManager(nil, cfg.CacheCfg(), nil)
+	cfg := config.NewDefaultCGRConfig()
+	connMng := NewConnManager(cfg)
+	dataDB, err := NewDataDBConn(cfg.DataDbCfg().Type,
+		cfg.DataDbCfg().Host, cfg.DataDbCfg().Port,
+		cfg.DataDbCfg().Name, cfg.DataDbCfg().User,
+		cfg.DataDbCfg().Password, cfg.GeneralCfg().DBDataEncoding,
+		cfg.DataDbCfg().Opts, cfg.DataDbCfg().Items)
+	if err != nil {
+		t.Error(err)
+	}
+	defer dataDB.Close()
+	dm := NewDataManager(dataDB, config.CgrConfig().CacheCfg(), connMng)
+	dm.cacheCfg.Partitions = map[string]*config.CacheParamCfg{
+		utils.CachePrefixToInstance[utils.ThresholdProfilePrefix]: {
+			Limit: 1,
+		},
+		utils.CacheRPCResponses: {
+			Limit: 1,
+		},
+	}
+	err = dm.CacheDataFromDB(context.Background(), utils.ThresholdProfilePrefix, []string{utils.MetaAny}, false)
+	if err != nil {
+		t.Error(err)
+	}
+}
+
+func TestDatamanagerCacheDataFromDBNotCachedThresholdPrefix(t *testing.T) {
+	// cfg := config.NewDefaultCGRConfig()
+	// dm := NewDataManager(nil, cfg.CacheCfg(), nil)
+	cfg := config.NewDefaultCGRConfig()
+	connMng := NewConnManager(cfg)
+	dataDB, err := NewDataDBConn(cfg.DataDbCfg().Type,
+		cfg.DataDbCfg().Host, cfg.DataDbCfg().Port,
+		cfg.DataDbCfg().Name, cfg.DataDbCfg().User,
+		cfg.DataDbCfg().Password, cfg.GeneralCfg().DBDataEncoding,
+		cfg.DataDbCfg().Opts, cfg.DataDbCfg().Items)
+	if err != nil {
+		t.Error(err)
+	}
+	defer dataDB.Close()
+	dm := NewDataManager(dataDB, config.CgrConfig().CacheCfg(), connMng)
+	dm.cacheCfg.Partitions = map[string]*config.CacheParamCfg{
+		utils.CachePrefixToInstance[utils.ThresholdPrefix]: {
+			Limit: 1,
+		},
+		utils.CacheRPCResponses: {
+			Limit: 1,
+		},
+	}
+	err = dm.CacheDataFromDB(context.Background(), utils.ThresholdPrefix, []string{utils.MetaAny}, false)
+	if err != nil {
+		t.Error(err)
+	}
+}
+
+func TestDatamanagerCacheDataFromDBNotCachedFilterPrefix(t *testing.T) {
+	// cfg := config.NewDefaultCGRConfig()
+	// dm := NewDataManager(nil, cfg.CacheCfg(), nil)
+	cfg := config.NewDefaultCGRConfig()
+	connMng := NewConnManager(cfg)
+	dataDB, err := NewDataDBConn(cfg.DataDbCfg().Type,
+		cfg.DataDbCfg().Host, cfg.DataDbCfg().Port,
+		cfg.DataDbCfg().Name, cfg.DataDbCfg().User,
+		cfg.DataDbCfg().Password, cfg.GeneralCfg().DBDataEncoding,
+		cfg.DataDbCfg().Opts, cfg.DataDbCfg().Items)
+	if err != nil {
+		t.Error(err)
+	}
+	defer dataDB.Close()
+	dm := NewDataManager(dataDB, config.CgrConfig().CacheCfg(), connMng)
+	dm.cacheCfg.Partitions = map[string]*config.CacheParamCfg{
+		utils.CachePrefixToInstance[utils.FilterPrefix]: {
+			Limit: 1,
+		},
+		utils.CacheRPCResponses: {
+			Limit: 1,
+		},
+	}
+	err = dm.CacheDataFromDB(context.Background(), utils.FilterPrefix, []string{utils.MetaAny}, false)
+	if err != nil {
+		t.Error(err)
+	}
+}
+
+func TestDatamanagerCacheDataFromDBNotCachedRouteProfilePrefix(t *testing.T) {
+	// cfg := config.NewDefaultCGRConfig()
+	// dm := NewDataManager(nil, cfg.CacheCfg(), nil)
+	cfg := config.NewDefaultCGRConfig()
+	connMng := NewConnManager(cfg)
+	dataDB, err := NewDataDBConn(cfg.DataDbCfg().Type,
+		cfg.DataDbCfg().Host, cfg.DataDbCfg().Port,
+		cfg.DataDbCfg().Name, cfg.DataDbCfg().User,
+		cfg.DataDbCfg().Password, cfg.GeneralCfg().DBDataEncoding,
+		cfg.DataDbCfg().Opts, cfg.DataDbCfg().Items)
+	if err != nil {
+		t.Error(err)
+	}
+	defer dataDB.Close()
+	dm := NewDataManager(dataDB, config.CgrConfig().CacheCfg(), connMng)
+	dm.cacheCfg.Partitions = map[string]*config.CacheParamCfg{
+		utils.CachePrefixToInstance[utils.RouteProfilePrefix]: {
+			Limit: 1,
+		},
+		utils.CacheRPCResponses: {
+			Limit: 1,
+		},
+	}
+	err = dm.CacheDataFromDB(context.Background(), utils.RouteProfilePrefix, []string{utils.MetaAny}, false)
+	if err != nil {
+		t.Error(err)
+	}
+}
+
+func TestDatamanagerCacheDataFromDBNotCachedAttributeProfilePrefix(t *testing.T) {
+	// cfg := config.NewDefaultCGRConfig()
+	// dm := NewDataManager(nil, cfg.CacheCfg(), nil)
+	cfg := config.NewDefaultCGRConfig()
+	connMng := NewConnManager(cfg)
+	dataDB, err := NewDataDBConn(cfg.DataDbCfg().Type,
+		cfg.DataDbCfg().Host, cfg.DataDbCfg().Port,
+		cfg.DataDbCfg().Name, cfg.DataDbCfg().User,
+		cfg.DataDbCfg().Password, cfg.GeneralCfg().DBDataEncoding,
+		cfg.DataDbCfg().Opts, cfg.DataDbCfg().Items)
+	if err != nil {
+		t.Error(err)
+	}
+	defer dataDB.Close()
+	dm := NewDataManager(dataDB, config.CgrConfig().CacheCfg(), connMng)
+	dm.cacheCfg.Partitions = map[string]*config.CacheParamCfg{
+		utils.CachePrefixToInstance[utils.AttributeProfilePrefix]: {
+			Limit: 1,
+		},
+		utils.CacheRPCResponses: {
+			Limit: 1,
+		},
+	}
+	err = dm.CacheDataFromDB(context.Background(), utils.AttributeProfilePrefix, []string{utils.MetaAny}, false)
+	if err != nil {
+		t.Error(err)
+	}
+}
+
+func TestDatamanagerCacheDataFromDBNotCachedChargerProfilePrefix(t *testing.T) {
+	// cfg := config.NewDefaultCGRConfig()
+	// dm := NewDataManager(nil, cfg.CacheCfg(), nil)
+	cfg := config.NewDefaultCGRConfig()
+	connMng := NewConnManager(cfg)
+	dataDB, err := NewDataDBConn(cfg.DataDbCfg().Type,
+		cfg.DataDbCfg().Host, cfg.DataDbCfg().Port,
+		cfg.DataDbCfg().Name, cfg.DataDbCfg().User,
+		cfg.DataDbCfg().Password, cfg.GeneralCfg().DBDataEncoding,
+		cfg.DataDbCfg().Opts, cfg.DataDbCfg().Items)
+	if err != nil {
+		t.Error(err)
+	}
+	defer dataDB.Close()
+	dm := NewDataManager(dataDB, config.CgrConfig().CacheCfg(), connMng)
+	dm.cacheCfg.Partitions = map[string]*config.CacheParamCfg{
+		utils.CachePrefixToInstance[utils.ChargerProfilePrefix]: {
+			Limit: 1,
+		},
+		utils.CacheRPCResponses: {
+			Limit: 1,
+		},
+	}
+	err = dm.CacheDataFromDB(context.Background(), utils.ChargerProfilePrefix, []string{utils.MetaAny}, false)
+	if err != nil {
+		t.Error(err)
+	}
+}
+
+func TestDatamanagerCacheDataFromDBNotCachedDispatcherProfilePrefix(t *testing.T) {
+	// cfg := config.NewDefaultCGRConfig()
+	// dm := NewDataManager(nil, cfg.CacheCfg(), nil)
+	cfg := config.NewDefaultCGRConfig()
+	connMng := NewConnManager(cfg)
+	dataDB, err := NewDataDBConn(cfg.DataDbCfg().Type,
+		cfg.DataDbCfg().Host, cfg.DataDbCfg().Port,
+		cfg.DataDbCfg().Name, cfg.DataDbCfg().User,
+		cfg.DataDbCfg().Password, cfg.GeneralCfg().DBDataEncoding,
+		cfg.DataDbCfg().Opts, cfg.DataDbCfg().Items)
+	if err != nil {
+		t.Error(err)
+	}
+	defer dataDB.Close()
+	dm := NewDataManager(dataDB, config.CgrConfig().CacheCfg(), connMng)
+	dm.cacheCfg.Partitions = map[string]*config.CacheParamCfg{
+		utils.CachePrefixToInstance[utils.DispatcherProfilePrefix]: {
+			Limit: 1,
+		},
+		utils.CacheRPCResponses: {
+			Limit: 1,
+		},
+	}
+	err = dm.CacheDataFromDB(context.Background(), utils.DispatcherProfilePrefix, []string{utils.MetaAny}, false)
+	if err != nil {
+		t.Error(err)
+	}
+}
+
+func TestDatamanagerCacheDataFromDBNotCachedDispatcherHostPrefix(t *testing.T) {
+	// cfg := config.NewDefaultCGRConfig()
+	// dm := NewDataManager(nil, cfg.CacheCfg(), nil)
+	cfg := config.NewDefaultCGRConfig()
+	connMng := NewConnManager(cfg)
+	dataDB, err := NewDataDBConn(cfg.DataDbCfg().Type,
+		cfg.DataDbCfg().Host, cfg.DataDbCfg().Port,
+		cfg.DataDbCfg().Name, cfg.DataDbCfg().User,
+		cfg.DataDbCfg().Password, cfg.GeneralCfg().DBDataEncoding,
+		cfg.DataDbCfg().Opts, cfg.DataDbCfg().Items)
+	if err != nil {
+		t.Error(err)
+	}
+	defer dataDB.Close()
+	dm := NewDataManager(dataDB, config.CgrConfig().CacheCfg(), connMng)
+	dm.cacheCfg.Partitions = map[string]*config.CacheParamCfg{
+		utils.CachePrefixToInstance[utils.DispatcherHostPrefix]: {
+			Limit: 1,
+		},
+		utils.CacheRPCResponses: {
+			Limit: 1,
+		},
+	}
+	err = dm.CacheDataFromDB(context.Background(), utils.DispatcherHostPrefix, []string{utils.MetaAny}, false)
+	if err != nil {
+		t.Error(err)
+	}
+}
+
+func TestDatamanagerCacheDataFromDBNotCachedAccountFilterIndexPrfx(t *testing.T) {
+	// cfg := config.NewDefaultCGRConfig()
+	// dm := NewDataManager(nil, cfg.CacheCfg(), nil)
+	cfg := config.NewDefaultCGRConfig()
+	connMng := NewConnManager(cfg)
+	dataDB, err := NewDataDBConn(cfg.DataDbCfg().Type,
+		cfg.DataDbCfg().Host, cfg.DataDbCfg().Port,
+		cfg.DataDbCfg().Name, cfg.DataDbCfg().User,
+		cfg.DataDbCfg().Password, cfg.GeneralCfg().DBDataEncoding,
+		cfg.DataDbCfg().Opts, cfg.DataDbCfg().Items)
+	if err != nil {
+		t.Error(err)
+	}
+	defer dataDB.Close()
+	dm := NewDataManager(dataDB, config.CgrConfig().CacheCfg(), connMng)
+	dm.cacheCfg.Partitions = map[string]*config.CacheParamCfg{
+		utils.CachePrefixToInstance[utils.AccountFilterIndexPrfx]: {
+			Limit: 1,
+		},
+		utils.CacheRPCResponses: {
+			Limit: 1,
+		},
+	}
+	err = dm.CacheDataFromDB(context.Background(), utils.AccountFilterIndexPrfx, []string{utils.MetaAny}, false)
+	if err != nil {
+		t.Error(err)
+	}
+}
+
+func TestDatamanagerCacheDataFromDBNotCachedAccountPrefix(t *testing.T) {
+	// cfg := config.NewDefaultCGRConfig()
+	// dm := NewDataManager(nil, cfg.CacheCfg(), nil)
+	cfg := config.NewDefaultCGRConfig()
+	connMng := NewConnManager(cfg)
+	dataDB, err := NewDataDBConn(cfg.DataDbCfg().Type,
+		cfg.DataDbCfg().Host, cfg.DataDbCfg().Port,
+		cfg.DataDbCfg().Name, cfg.DataDbCfg().User,
+		cfg.DataDbCfg().Password, cfg.GeneralCfg().DBDataEncoding,
+		cfg.DataDbCfg().Opts, cfg.DataDbCfg().Items)
+	if err != nil {
+		t.Error(err)
+	}
+	defer dataDB.Close()
+	dm := NewDataManager(dataDB, config.CgrConfig().CacheCfg(), connMng)
+	dm.cacheCfg.Partitions = map[string]*config.CacheParamCfg{
+		utils.CachePrefixToInstance[utils.AccountPrefix]: {
+			Limit: 1,
+		},
+		utils.CacheRPCResponses: {
+			Limit: 1,
+		},
+	}
+	err = dm.CacheDataFromDB(context.Background(), utils.AccountPrefix, []string{utils.MetaAny}, false)
+	if err != nil {
+		t.Error(err)
+	}
+}
+
+func TestDatamanagerCacheDataFromDBNotCachedRateProfilePrefix(t *testing.T) {
+	// cfg := config.NewDefaultCGRConfig()
+	// dm := NewDataManager(nil, cfg.CacheCfg(), nil)
+	cfg := config.NewDefaultCGRConfig()
+	connMng := NewConnManager(cfg)
+	dataDB, err := NewDataDBConn(cfg.DataDbCfg().Type,
+		cfg.DataDbCfg().Host, cfg.DataDbCfg().Port,
+		cfg.DataDbCfg().Name, cfg.DataDbCfg().User,
+		cfg.DataDbCfg().Password, cfg.GeneralCfg().DBDataEncoding,
+		cfg.DataDbCfg().Opts, cfg.DataDbCfg().Items)
+	if err != nil {
+		t.Error(err)
+	}
+	defer dataDB.Close()
+	dm := NewDataManager(dataDB, config.CgrConfig().CacheCfg(), connMng)
+	dm.cacheCfg.Partitions = map[string]*config.CacheParamCfg{
+		utils.CachePrefixToInstance[utils.RateProfilePrefix]: {
+			Limit: 1,
+		},
+		utils.CacheRPCResponses: {
+			Limit: 1,
+		},
+	}
+	err = dm.CacheDataFromDB(context.Background(), utils.RateProfilePrefix, []string{utils.MetaAny}, false)
+	if err != nil {
+		t.Error(err)
+	}
+}
+
+func TestDatamanagerCacheDataFromDBNotCachedActionProfilePrefix(t *testing.T) {
+	// cfg := config.NewDefaultCGRConfig()
+	// dm := NewDataManager(nil, cfg.CacheCfg(), nil)
+	cfg := config.NewDefaultCGRConfig()
+	connMng := NewConnManager(cfg)
+	dataDB, err := NewDataDBConn(cfg.DataDbCfg().Type,
+		cfg.DataDbCfg().Host, cfg.DataDbCfg().Port,
+		cfg.DataDbCfg().Name, cfg.DataDbCfg().User,
+		cfg.DataDbCfg().Password, cfg.GeneralCfg().DBDataEncoding,
+		cfg.DataDbCfg().Opts, cfg.DataDbCfg().Items)
+	if err != nil {
+		t.Error(err)
+	}
+	defer dataDB.Close()
+	dm := NewDataManager(dataDB, config.CgrConfig().CacheCfg(), connMng)
+	dm.cacheCfg.Partitions = map[string]*config.CacheParamCfg{
+		utils.CachePrefixToInstance[utils.ActionProfilePrefix]: {
+			Limit: 1,
+		},
+		utils.CacheRPCResponses: {
+			Limit: 1,
+		},
+	}
+	err = dm.CacheDataFromDB(context.Background(), utils.ActionProfilePrefix, []string{utils.MetaAny}, false)
+	if err != nil {
+		t.Error(err)
+	}
+}