From e307bd82efd91d755853baf7e7fc704faab90c80 Mon Sep 17 00:00:00 2001 From: nickolasdaniel Date: Tue, 22 Mar 2022 17:18:26 +0200 Subject: [PATCH] Tests for coverage --- ees/amqp_test.go | 71 ++++++ engine/attributes_test.go | 454 +++++++++++++++++++++++++++++++++++ engine/datamanager_test.go | 478 +++++++++++++++++++++++++++++++++++++ 3 files changed, 1003 insertions(+) create mode 100644 ees/amqp_test.go create mode 100644 engine/attributes_test.go diff --git a/ees/amqp_test.go b/ees/amqp_test.go new file mode 100644 index 000000000..380b56157 --- /dev/null +++ b/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 +*/ + +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) +// } + +// } diff --git a/engine/attributes_test.go b/engine/attributes_test.go new file mode 100644 index 000000000..8c1a25219 --- /dev/null +++ b/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 +*/ + +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 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 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 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 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) + } +} diff --git a/engine/datamanager_test.go b/engine/datamanager_test.go index 027e250ac..b8304d20c 100644 --- a/engine/datamanager_test.go +++ b/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) + } +}