From 16eb745f00dac6c836e8bf53ce67f53d2080ba1c Mon Sep 17 00:00:00 2001 From: ionutboangiu Date: Thu, 4 Apr 2024 19:33:29 +0300 Subject: [PATCH] Centralize test flags in utils for shared use across tests --- agents/diam_it_test.go | 32 +++++++------- agents/dnsagent_it_test.go | 12 +++--- agents/httpagent_it_test.go | 18 ++++---- agents/lib_test.go | 10 +---- agents/radagent_it_test.go | 22 +++++----- agents/radius_coa_it_test.go | 10 ++--- agents/sipagent_it_test.go | 10 ++--- analyzers/analyzers_it_test.go | 15 ++----- apier/v1/accounts_it_test.go | 16 +++---- apier/v1/apier2_it_test.go | 22 +++++----- apier/v1/apier_it_test.go | 12 +++--- apier/v1/attributes_it_test.go | 10 ++--- apier/v1/cache_replication_it_test.go | 12 +++--- apier/v1/caches_it_test.go | 10 ++--- apier/v1/caps_it_test.go | 8 ++-- apier/v1/cdrs_it_test.go | 16 +++---- apier/v1/chargers_it_test.go | 8 ++-- apier/v1/config_it_test.go | 28 ++++++------- apier/v1/core_it_test.go | 8 ++-- apier/v1/costs_it_test.go | 10 ++--- apier/v1/dispatcher_it_test.go | 10 ++--- apier/v1/dispatchersv1_it_test.go | 14 +++---- apier/v1/ees_it_test.go | 6 +-- apier/v1/filter_indexes_health_it_test.go | 14 +++---- apier/v1/filter_indexes_it_test.go | 8 ++-- apier/v1/filterindexecache_it_test.go | 8 ++-- apier/v1/filters_it_test.go | 6 +-- apier/v1/full_remote_it_test.go | 8 ++-- apier/v1/guardian_it_test.go | 6 +-- apier/v1/lib_test.go | 10 +---- apier/v1/precache_it_test.go | 12 +++--- apier/v1/preload_it_test.go | 4 +- apier/v1/rating_profile_late_it_test.go | 10 ++--- apier/v1/remote_it_test.go | 24 +++++------ apier/v1/replicate_it_test.go | 16 +++---- apier/v1/resourcesv1_it_test.go | 12 +++--- apier/v1/routes_it_test.go | 16 +++---- apier/v1/schedulers_it_test.go | 14 +++---- apier/v1/sessions_process_event_it_test.go | 10 ++--- apier/v1/sessions_thresholds_it_test.go | 6 +-- apier/v1/sessionsv1_it_test.go | 12 +++--- apier/v1/stats_it_test.go | 14 +++---- apier/v1/thresholds_it_test.go | 12 +++--- apier/v1/timing_it_test.go | 6 +-- apier/v1/tp_it_test.go | 10 ++--- apier/v1/tpaccountactions_it_test.go | 4 +- apier/v1/tpactionplans_it_test.go | 4 +- apier/v1/tpactions_it_test.go | 4 +- apier/v1/tpactiontriggers_it_test.go | 4 +- apier/v1/tpattributes_it_test.go | 4 +- apier/v1/tpchargers_it_test.go | 4 +- apier/v1/tpdestinationrates_it_test.go | 4 +- apier/v1/tpdestinations_it_test.go | 4 +- apier/v1/tpdispatchers_it_test.go | 4 +- apier/v1/tpfilters_it_test.go | 4 +- apier/v1/tprates_it_test.go | 4 +- apier/v1/tpratingplans_it_test.go | 4 +- apier/v1/tpratingprofiles_it_test.go | 4 +- apier/v1/tpresources_it_test.go | 4 +- apier/v1/tproutes_it_test.go | 4 +- apier/v1/tpsharedgroups_it_test.go | 4 +- apier/v1/tpstats_it_test.go | 4 +- apier/v1/tpthresholds_it_test.go | 4 +- apier/v1/tptimings_it_test.go | 4 +- apier/v1/versions_it_test.go | 6 +-- apier/v2/accounts_it_test.go | 8 ++-- apier/v2/apierv2_it_test.go | 4 +- apier/v2/attributes_it_test.go | 6 +-- apier/v2/cdrs_it_test.go | 12 +++--- apier/v2/cdrs_offline_it_test.go | 12 +++--- apier/v2/lib_test.go | 10 +---- apier/v2/tp_it_test.go | 6 +-- cmd/cgr-console/cgr-console_it_test.go | 37 +++++++--------- cmd/cgr-loader/cgr-loader_it_test.go | 28 +++++-------- cmd/cgr-loader/cgr-loader_remove_it_test.go | 12 +++--- cmd/cgr-tester/cdr_repl/process_cdr.go | 4 +- dispatchers/attributes_it_test.go | 12 +++--- dispatchers/caches_it_test.go | 4 +- dispatchers/cdrs_it_test.go | 8 ++-- dispatchers/chargers_it_test.go | 14 +++---- dispatchers/config_it_test.go | 4 +- dispatchers/ees_it_test.go | 4 +- dispatchers/guardian_it_test.go | 4 +- dispatchers/lib_test.go | 25 ++++------- dispatchers/rals_it_test.go | 4 +- dispatchers/replicator_it_test.go | 4 +- dispatchers/resources_it_test.go | 4 +- dispatchers/responder_it_test.go | 4 +- dispatchers/routes_it_test.go | 6 +-- dispatchers/scheduler_it_test.go | 4 +- dispatchers/sessions_it_test.go | 16 +++---- dispatchers/stats_it_test.go | 4 +- dispatchers/thresholds_it_test.go | 4 +- ees/amqp_it_test.go | 4 +- ees/amqpv1_it_test.go | 4 +- ees/elastic_it_test.go | 4 +- ees/filecsv_it_test.go | 4 +- ees/filefwv_it_test.go | 4 +- ees/httppost_it_test.go | 4 +- ees/kafka_it_test.go | 4 +- ees/lib_test.go | 9 +--- ees/nats_it_test.go | 4 +- ees/posterjsonmap_it_test.go | 4 +- ees/s3_it_test.go | 4 +- ees/sql_it_test.go | 4 +- ees/sqs_it_test.go | 4 +- ees/virtual_ee_it_test.go | 4 +- engine/lib_test.go | 10 +---- engine/z_actions2_it_test.go | 10 ++--- engine/z_actions_it_test.go | 10 ++--- engine/z_datamanager_it_test.go | 6 +-- engine/z_filterindexer_it_test.go | 6 +-- engine/z_loader_it_test.go | 18 ++++---- engine/z_onstor_it_test.go | 6 +-- engine/z_storage_cdrs_it_test.go | 12 +++--- engine/z_stordb_it_test.go | 8 ++-- engine/z_versions_it_test.go | 4 +- ers/ers_reload_it_test.go | 10 ++--- ers/filecsv_it_test.go | 10 ++--- ers/filefwv_it_test.go | 8 ++-- ers/filejson_it_test.go | 8 ++-- ers/filexml_it_test.go | 10 ++--- ers/flatstore_it_test.go | 8 ++-- ers/lib_test.go | 10 +---- ers/nats_it_test.go | 16 +++---- ers/partial_csv_it_test.go | 8 ++-- ers/sql_it_test.go | 4 +- general_tests/a1_it_test.go | 8 ++-- general_tests/accounts_it_test.go | 6 +-- .../accountswiththresholds_it_test.go | 4 +- general_tests/all_cfg_sect_rld_it_test.go | 10 ++--- general_tests/api_escape_char_it_test.go | 2 +- .../attributes_filters_index_it_test.go | 8 ++-- general_tests/attributes_it_test.go | 18 ++++---- .../attributeswithdataconverters_it_test.go | 8 ++-- .../authorize_event_sms_data_it_test.go | 8 ++-- general_tests/balance_it_test.go | 12 +++--- general_tests/birpc_benchmark_test.go | 2 +- general_tests/broadcast_client_it_test.go | 12 +++--- .../cacherpl_filter_update_it_test.go | 12 +++--- general_tests/cacherpl_it_test.go | 32 +++++++------- general_tests/cdrlog_ees_it_test.go | 4 +- general_tests/cdrs_exp_it_test.go | 7 ++-- general_tests/cdrs_internal_it_test.go | 8 ++-- general_tests/cdrs_it_test.go | 16 +++---- general_tests/cdrs_onlexp_it_test.go | 18 ++++---- general_tests/cdrs_post_failover_it_test.go | 12 +++--- general_tests/cdrs_processevent_it_test.go | 18 ++++---- general_tests/cgrloader_it_test.go | 8 ++-- general_tests/data_it_test.go | 6 +-- general_tests/dest_management_it_test.go | 42 +++++++++---------- general_tests/destination_combined_it_test.go | 6 +-- general_tests/dispatcher_opts_it_test.go | 16 +++---- general_tests/doubleremove_it_test.go | 6 +-- general_tests/ees_it_test.go | 4 +- general_tests/export_it_test.go | 14 +++---- general_tests/fallback_depth_it_test.go | 4 +- general_tests/filtered_replication_it_test.go | 20 ++++----- general_tests/filterhttp_it_test.go | 4 +- general_tests/filters_it_test.go | 12 +++--- general_tests/fltr_sep_it_test.go | 6 +-- general_tests/fraud_detection_it_test.go | 4 +- general_tests/get_account_cost_it_test.go | 6 +-- general_tests/gocs_it_test.go | 16 +++---- general_tests/kafka_ssl_it_test.go | 6 +-- general_tests/lib_test.go | 9 +--- general_tests/libengine_it_test.go | 8 ++-- general_tests/loader_nocontext_it_test.go | 4 +- .../loaders_internal_indexes_it_test.go | 12 +++--- general_tests/oldtutorial_it_test.go | 24 +++++------ general_tests/poster_it_test.go | 10 ++--- general_tests/redis_cluster_it_test.go | 8 ++-- general_tests/redis_tls_it_test.go | 2 +- general_tests/rerate_cdrs_it_test.go | 8 ++-- general_tests/rerate_ers_cdrs_it_test.go | 4 +- general_tests/rerate_exp_it_test.go | 8 ++-- general_tests/resourcesv1_it_test.go | 8 ++-- general_tests/route_it_test.go | 8 ++-- general_tests/routes_cases_it_test.go | 8 ++-- general_tests/rpccaching_it_test.go | 12 +++--- general_tests/rpcclient_it_test.go | 26 ++++++------ general_tests/rpsubj_set_it_test.go | 8 ++-- general_tests/sentinel_it_test.go | 12 +++--- general_tests/session2_it_test.go | 8 ++-- general_tests/session3_it_test.go | 10 ++--- general_tests/session4_it_test.go | 8 ++-- .../session_graceful_shutdown_it_test.go | 12 +++--- general_tests/session_it_test.go | 8 ++-- .../session_money_rating_subject_it_test.go | 6 +-- general_tests/session_nonereq_it_test.go | 6 +-- .../session_refund_expired_it_test.go | 6 +-- ...ion_replications_automaticdebit_it_test.go | 18 ++++---- general_tests/session_rounding_it_test.go | 6 +-- general_tests/session_rpl_prepaid_it_test.go | 8 ++-- general_tests/sessionpause_it_test.go | 8 ++-- general_tests/sessionrefund_it_test.go | 8 ++-- general_tests/sessionroutes_it_test.go | 8 ++-- general_tests/sessions_benchmark_it_test.go | 6 +-- general_tests/sessions_concur_test.go | 8 ++-- general_tests/sessions_message_it_test.go | 6 +-- .../sessions_tnt_change_cdr_it_test.go | 6 +-- general_tests/sessions_tnt_change_it_test.go | 6 +-- general_tests/set_rmv_prfl_dlay_it_test.go | 12 +++--- general_tests/shared_subject_it_test.go | 4 +- general_tests/suretax_it_test.go | 4 +- general_tests/tls_it_test.go | 6 +-- general_tests/tp_it_test.go | 8 ++-- general_tests/transfer_balance_it_test.go | 4 +- general_tests/tut_smgeneric_it_test.go | 10 ++--- general_tests/tutorial2_calls_test.go | 10 ++--- general_tests/tutorial2_it_test.go | 8 ++-- general_tests/tutorial_calls_test.go | 10 ++--- general_tests/tutorial_it_test.go | 6 +-- general_tests/twoengines_it_test.go | 10 ++--- loaders/lib_test.go | 10 +---- loaders/loader_it_test.go | 8 ++-- migrator/accounts2_it_test.go | 4 +- migrator/accounts_it_test.go | 26 ++++++------ migrator/action_it_test.go | 24 +++++------ migrator/action_plan_it_test.go | 24 +++++------ migrator/action_trigger_it_test.go | 20 ++++----- migrator/alias_it_test.go | 12 +++--- migrator/attributes_it_test.go | 28 ++++++------- migrator/cdrs_it_test.go | 4 +- migrator/chargers_it_test.go | 16 +++---- migrator/derived_chargers_it_test.go | 12 +++--- migrator/dispatchers_it_test.go | 16 +++---- migrator/filters_it_test.go | 24 +++++------ migrator/load_ids_it_test.go | 8 ++-- migrator/rating_plan_it_test.go | 16 +++---- migrator/rating_profile_it_test.go | 16 +++---- migrator/resource_it_test.go | 16 +++---- migrator/routes_it_test.go | 16 +++---- migrator/session_costs_it_test.go | 8 ++-- migrator/sharedgroup_it_test.go | 20 ++++----- migrator/stats_it_test.go | 12 +++--- migrator/thresholds_it_test.go | 20 ++++----- migrator/tp_account_actions_it_test.go | 4 +- migrator/tp_action_plans_it_test.go | 4 +- migrator/tp_action_triggers_it_test.go | 4 +- migrator/tp_actions_it_test.go | 4 +- migrator/tp_destination_rates_it_test.go | 4 +- migrator/tp_destinations_it_test.go | 4 +- migrator/tp_dispatchers_it_test.go | 4 +- migrator/tp_filters_it_test.go | 4 +- migrator/tp_rates_it_test.go | 4 +- migrator/tp_rating_plans_it_test.go | 4 +- migrator/tp_rating_profiles_it_test.go | 4 +- migrator/tp_resources_it_test.go | 4 +- migrator/tp_routes_it_test.go | 4 +- migrator/tp_shared_groups_it_test.go | 4 +- migrator/tp_stats_it_test.go | 4 +- migrator/tp_thresholds_it_test.go | 4 +- migrator/tp_timings_it_test.go | 4 +- migrator/user_it_test.go | 8 ++-- migrator/versions_it_test.go | 4 +- registrarc/lib_test.go | 10 +---- registrarc/registarc_defaultid_it_test.go | 14 +++---- registrarc/registrarc_it_test.go | 18 ++++---- registrarc/registrarcrpc_it_test.go | 14 +++---- sessions/lib_test.go | 10 +---- sessions/sessions_bench_test.go | 8 ++-- sessions/sessions_birpc_it_test.go | 12 +++--- sessions/sessions_data_it_test.go | 12 +++--- sessions/sessions_it_test.go | 12 +++--- sessions/sessions_rpl_it_test.go | 36 ++++++++-------- sessions/sessions_voice_it_test.go | 10 ++--- utils/testflag.go | 32 ++++++++++++++ 268 files changed, 1262 insertions(+), 1340 deletions(-) create mode 100644 utils/testflag.go diff --git a/agents/diam_it_test.go b/agents/diam_it_test.go index 9d53cce6b..cbfbd2f6a 100644 --- a/agents/diam_it_test.go +++ b/agents/diam_it_test.go @@ -87,7 +87,7 @@ var ( // Test start here func TestDiamItTcp(t *testing.T) { - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: diamConfigDIR = "diamagent_internal" case utils.MetaMySQL: @@ -105,14 +105,14 @@ func TestDiamItTcp(t *testing.T) { } func TestDiamItDispatcher(t *testing.T) { - if *encoding == utils.MetaGOB { + if *utils.Encoding == utils.MetaGOB { t.SkipNow() return } testDiamItResetAllDB(t) isDispatcherActive = true - engine.StartEngine(path.Join(*dataDir, "conf", "samples", "dispatchers", "all"), 200) - engine.StartEngine(path.Join(*dataDir, "conf", "samples", "dispatchers", "all2"), 200) + engine.StartEngine(path.Join(*utils.DataDir, "conf", "samples", "dispatchers", "all"), 200) + engine.StartEngine(path.Join(*utils.DataDir, "conf", "samples", "dispatchers", "all2"), 200) diamConfigDIR = "dispatchers/diamagent" for _, stest := range sTestsDiam { t.Run(diamConfigDIR, stest) @@ -121,7 +121,7 @@ func TestDiamItDispatcher(t *testing.T) { } func TestDiamItSctp(t *testing.T) { - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: diamConfigDIR = "diamsctpagent_internal" case utils.MetaMySQL: @@ -139,7 +139,7 @@ func TestDiamItSctp(t *testing.T) { } func TestDiamItBiRPC(t *testing.T) { - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: diamConfigDIR = "diamagent_internal_%sbirpc" case utils.MetaMySQL: @@ -151,14 +151,14 @@ func TestDiamItBiRPC(t *testing.T) { default: t.Fatal("Unknown Database type") } - diamConfigDIR = fmt.Sprintf(diamConfigDIR, strings.TrimPrefix(*encoding, utils.Meta)) + diamConfigDIR = fmt.Sprintf(diamConfigDIR, strings.TrimPrefix(*utils.Encoding, utils.Meta)) for _, stest := range sTestsDiam { t.Run(diamConfigDIR, stest) } } func TestDiamItMaxConn(t *testing.T) { - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: diamConfigDIR = "diamagentmaxconn_internal" case utils.MetaMySQL: @@ -178,7 +178,7 @@ func TestDiamItMaxConn(t *testing.T) { } func TestDiamItSessionDisconnect(t *testing.T) { - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: diamConfigDIR = "diamagent_internal" case utils.MetaMySQL: @@ -199,14 +199,14 @@ func TestDiamItSessionDisconnect(t *testing.T) { } func testDiamItInitCfg(t *testing.T) { - daCfgPath = path.Join(*dataDir, "conf", "samples", diamConfigDIR) + daCfgPath = path.Join(*utils.DataDir, "conf", "samples", diamConfigDIR) // Init config first var err error daCfg, err = config.NewCGRConfigFromPath(daCfgPath) if err != nil { t.Fatal(err) } - daCfg.DataFolderPath = *dataDir // Share DataFolderPath through config towards StoreDb for Flush() + daCfg.DataFolderPath = *utils.DataDir // Share DataFolderPath through config towards StoreDb for Flush() rplyTimeout, _ = utils.ParseDurationWithSecs(*replyTimeout) if isDispatcherActive { daCfg.ListenCfg().RPCJSONListen = ":6012" @@ -214,7 +214,7 @@ func testDiamItInitCfg(t *testing.T) { } func testDiamItResetAllDB(t *testing.T) { - cfgPath1 := path.Join(*dataDir, "conf", "samples", "dispatchers", "all") + cfgPath1 := path.Join(*utils.DataDir, "conf", "samples", "dispatchers", "all") allCfg, err := config.NewCGRConfigFromPath(cfgPath1) if err != nil { t.Fatal(err) @@ -226,7 +226,7 @@ func testDiamItResetAllDB(t *testing.T) { t.Fatal(err) } - cfgPath2 := path.Join(*dataDir, "conf", "samples", "dispatchers", "all2") + cfgPath2 := path.Join(*utils.DataDir, "conf", "samples", "dispatchers", "all2") allCfg2, err := config.NewCGRConfigFromPath(cfgPath2) if err != nil { t.Fatal(err) @@ -281,7 +281,7 @@ func testDiamItApierRpcConn(t *testing.T) { // Load the tariff plan, creating accounts and their balances func testDiamItTPFromFolder(t *testing.T) { - attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*dataDir, "tariffplans", "tutorial")} + attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*utils.DataDir, "tariffplans", "tutorial")} var loadInst utils.LoadInstance if err := apierRpc.Call(context.Background(), utils.APIerSv2LoadTariffPlanFromFolder, attrs, &loadInst); err != nil { t.Error(err) @@ -299,7 +299,7 @@ func testDiamItTPLoadData(t *testing.T) { if err != nil { t.Error(err) } - loader := exec.Command(loaderPath, "-config_path", daCfgPath, "-path", path.Join(*dataDir, "tariffplans", "dispatchers")) + loader := exec.Command(loaderPath, "-config_path", daCfgPath, "-path", path.Join(*utils.DataDir, "tariffplans", "dispatchers")) if err := loader.Start(); err != nil { t.Error(err) @@ -927,7 +927,7 @@ func testDiamItCCRTerminate(t *testing.T) { } else if val != eVal { t.Errorf("expecting: %s, received: <%s>", eVal, val) } - time.Sleep(time.Duration(*waitRater) * time.Millisecond) + time.Sleep(time.Duration(*utils.WaitRater) * time.Millisecond) var cdrs []*engine.CDR args := utils.RPCCDRsFilterWithAPIOpts{RPCCDRsFilter: &utils.RPCCDRsFilter{RunIDs: []string{utils.MetaRaw}}} if err := apierRpc.Call(context.Background(), utils.CDRsV1GetCDRs, &args, &cdrs); err != nil { diff --git a/agents/dnsagent_it_test.go b/agents/dnsagent_it_test.go index eb28ff6cf..3e0e99988 100644 --- a/agents/dnsagent_it_test.go +++ b/agents/dnsagent_it_test.go @@ -75,7 +75,7 @@ var ( ) func TestDNSitSimple(t *testing.T) { - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: dnsCfgDIR = "dnsagent_internal" case utils.MetaMySQL: @@ -95,7 +95,7 @@ func TestDNSitSimple(t *testing.T) { // Init config func testDNSitInitCfg(t *testing.T) { var err error - dnsCfgPath = path.Join(*dataDir, "conf", "samples", dnsCfgDIR) + dnsCfgPath = path.Join(*utils.DataDir, "conf", "samples", dnsCfgDIR) dnsCfg, err = config.NewCGRConfigFromPath(dnsCfgPath) if err != nil { t.Error(err) @@ -114,7 +114,7 @@ func testDNSitResetDB(t *testing.T) { // Start CGR Engine func testDNSitStartEngine(t *testing.T) { - if _, err := engine.StopStartEngine(dnsCfgPath, *waitRater); err != nil { + if _, err := engine.StopStartEngine(dnsCfgPath, *utils.WaitRater); err != nil { t.Fatal(err) } } @@ -130,13 +130,13 @@ func testDNSitApierRpcConn(t *testing.T) { // Load the tariff plan, creating accounts and their balances func testDNSitTPFromFolder(t *testing.T) { - attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*dataDir, "tariffplans", "dnsagent")} + attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*utils.DataDir, "tariffplans", "dnsagent")} var loadInst utils.LoadInstance if err := dnsRPC.Call(context.Background(), utils.APIerSv2LoadTariffPlanFromFolder, attrs, &loadInst); err != nil { t.Error(err) } - time.Sleep(time.Duration(*waitRater) * time.Millisecond) // Give time for scheduler to execute topups + time.Sleep(time.Duration(*utils.WaitRater) * time.Millisecond) // Give time for scheduler to execute topups } // Connect DNS client to server @@ -1501,7 +1501,7 @@ func testDNSitClntNAPTROptsWithAttributes(t *testing.T) { } func testDNSitStopEngine(t *testing.T) { - if err := engine.KillEngine(*waitRater); err != nil { + if err := engine.KillEngine(*utils.WaitRater); err != nil { t.Error(err) } } diff --git a/agents/httpagent_it_test.go b/agents/httpagent_it_test.go index 375736851..8ec619ba4 100644 --- a/agents/httpagent_it_test.go +++ b/agents/httpagent_it_test.go @@ -67,7 +67,7 @@ var ( ) func TestHAit(t *testing.T) { - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: haCfgDIR = "httpagent_internal" case utils.MetaMySQL: @@ -79,7 +79,7 @@ func TestHAit(t *testing.T) { default: t.Fatal("Unknown Database type") } - if *encoding == utils.MetaGOB { + if *utils.Encoding == utils.MetaGOB { haCfgDIR += "_gob" } //Run the tests without Tls @@ -91,7 +91,7 @@ func TestHAit(t *testing.T) { } func TestHAitTls(t *testing.T) { - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: haCfgDIR = "httpagenttls_internal" case utils.MetaMySQL: @@ -103,7 +103,7 @@ func TestHAitTls(t *testing.T) { default: t.Fatal("Unknown Database type") } - if *encoding == utils.MetaGOB { + if *utils.Encoding == utils.MetaGOB { haCfgDIR += "_gob" } //Run the tests with Tls @@ -116,7 +116,7 @@ func TestHAitTls(t *testing.T) { // Init config first func testHAitInitCfg(t *testing.T) { var err error - haCfgPath = path.Join(*dataDir, "conf", "samples", haCfgDIR) + haCfgPath = path.Join(*utils.DataDir, "conf", "samples", haCfgDIR) haCfg, err = config.NewCGRConfigFromPath(haCfgPath) if err != nil { t.Error(err) @@ -166,7 +166,7 @@ func testHAitResetDB(t *testing.T) { // Start CGR Engine func testHAitStartEngine(t *testing.T) { - if _, err := engine.StopStartEngine(haCfgPath, *waitRater); err != nil { + if _, err := engine.StopStartEngine(haCfgPath, *utils.WaitRater); err != nil { t.Fatal(err) } } @@ -182,12 +182,12 @@ func testHAitApierRpcConn(t *testing.T) { // Load the tariff plan, creating accounts and their balances func testHAitTPFromFolder(t *testing.T) { - attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*dataDir, "tariffplans", "oldtutorial")} + attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*utils.DataDir, "tariffplans", "oldtutorial")} var loadInst utils.LoadInstance if err := haRPC.Call(context.Background(), utils.APIerSv2LoadTariffPlanFromFolder, attrs, &loadInst); err != nil { t.Error(err) } - time.Sleep(time.Duration(*waitRater) * time.Millisecond) // Give time for scheduler to execute topups + time.Sleep(time.Duration(*utils.WaitRater) * time.Millisecond) // Give time for scheduler to execute topups } func testHAitAuthDryRun(t *testing.T) { @@ -375,7 +375,7 @@ Item1.1=Val1 } func testHAitStopEngine(t *testing.T) { - if err := engine.KillEngine(*waitRater); err != nil { + if err := engine.KillEngine(*utils.WaitRater); err != nil { t.Error(err) } } diff --git a/agents/lib_test.go b/agents/lib_test.go index 296b0206a..77fe79c43 100644 --- a/agents/lib_test.go +++ b/agents/lib_test.go @@ -20,7 +20,6 @@ package agents import ( "errors" - "flag" "github.com/cgrates/birpc" "github.com/cgrates/birpc/jsonrpc" @@ -28,15 +27,8 @@ import ( "github.com/cgrates/cgrates/utils" ) -var ( - waitRater = flag.Int("wait_rater", 100, "Number of miliseconds to wait for rater to start and cache") - dataDir = flag.String("data_dir", "/usr/share/cgrates", "CGR data dir path here") - encoding = flag.String("rpc", utils.MetaJSON, "what encoding whould be used for rpc comunication") - dbType = flag.String("dbtype", utils.MetaInternal, "The type of DataBase (Internal/Mongo/mySql)") -) - func newRPCClient(cfg *config.ListenCfg) (c *birpc.Client, err error) { - switch *encoding { + switch *utils.Encoding { case utils.MetaJSON: return jsonrpc.Dial(utils.TCP, cfg.RPCJSONListen) case utils.MetaGOB: diff --git a/agents/radagent_it_test.go b/agents/radagent_it_test.go index 36ed25cb9..b89154389 100644 --- a/agents/radagent_it_test.go +++ b/agents/radagent_it_test.go @@ -82,7 +82,7 @@ var ( // Test start here func TestRAit(t *testing.T) { // engine.KillEngine(0) - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: raonfigDIR = "radagent_internal" case utils.MetaMySQL: @@ -94,7 +94,7 @@ func TestRAit(t *testing.T) { default: t.Fatal("Unknown Database type") } - if *encoding == utils.MetaGOB { + if *utils.Encoding == utils.MetaGOB { raonfigDIR += "_gob" } for _, stest := range sTestsRadius { @@ -104,13 +104,13 @@ func TestRAit(t *testing.T) { func TestRAitDispatcher(t *testing.T) { engine.KillEngine(100) - if *encoding == utils.MetaGOB { + if *utils.Encoding == utils.MetaGOB { t.SkipNow() return } isDispatcherActive = true - engine.StartEngine(path.Join(*dataDir, "conf", "samples", "dispatchers", "all"), 400) - engine.StartEngine(path.Join(*dataDir, "conf", "samples", "dispatchers", "all2"), 400) + engine.StartEngine(path.Join(*utils.DataDir, "conf", "samples", "dispatchers", "all"), 400) + engine.StartEngine(path.Join(*utils.DataDir, "conf", "samples", "dispatchers", "all2"), 400) raonfigDIR = "dispatchers/radagent" testRadiusitResetAllDB(t) for _, stest := range sTestsRadius { @@ -121,7 +121,7 @@ func TestRAitDispatcher(t *testing.T) { } func testRAitInitCfg(t *testing.T) { - raCfgPath = path.Join(*dataDir, "conf", "samples", raonfigDIR) + raCfgPath = path.Join(*utils.DataDir, "conf", "samples", raonfigDIR) // Init config first var err error raCfg, err = config.NewCGRConfigFromPath(raCfgPath) @@ -134,7 +134,7 @@ func testRAitInitCfg(t *testing.T) { } func testRadiusitResetAllDB(t *testing.T) { - cfgPath1 := path.Join(*dataDir, "conf", "samples", "dispatchers", "all") + cfgPath1 := path.Join(*utils.DataDir, "conf", "samples", "dispatchers", "all") allCfg, err := config.NewCGRConfigFromPath(cfgPath1) if err != nil { t.Fatal(err) @@ -163,7 +163,7 @@ func testRAitResetStorDb(t *testing.T) { // Start CGR Engine func testRAitStartEngine(t *testing.T) { - if _, err := engine.StartEngine(raCfgPath, *waitRater); err != nil { + if _, err := engine.StartEngine(raCfgPath, *utils.WaitRater); err != nil { t.Fatal(err) } } @@ -179,7 +179,7 @@ func testRAitApierRpcConn(t *testing.T) { // Load the tariff plan, creating accounts and their balances func testRAitTPFromFolder(t *testing.T) { - attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*dataDir, "tariffplans", "oldtutorial")} + attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*utils.DataDir, "tariffplans", "oldtutorial")} var loadInst utils.LoadInstance if err := raRPC.Call(context.Background(), utils.APIerSv2LoadTariffPlanFromFolder, attrs, &loadInst); err != nil { t.Error(err) @@ -187,7 +187,7 @@ func testRAitTPFromFolder(t *testing.T) { if isDispatcherActive { testRadiusitTPLoadData(t) } - time.Sleep(time.Duration(*waitRater) * time.Millisecond) // Give time for scheduler to execute topups + time.Sleep(time.Duration(*utils.WaitRater) * time.Millisecond) // Give time for scheduler to execute topups } func testRadiusitTPLoadData(t *testing.T) { @@ -197,7 +197,7 @@ func testRadiusitTPLoadData(t *testing.T) { if err != nil { t.Error(err) } - loader := exec.Command(loaderPath, "-config_path", raCfgPath, "-path", path.Join(*dataDir, "tariffplans", "dispatchers")) + loader := exec.Command(loaderPath, "-config_path", raCfgPath, "-path", path.Join(*utils.DataDir, "tariffplans", "dispatchers")) if err := loader.Start(); err != nil { t.Error(err) diff --git a/agents/radius_coa_it_test.go b/agents/radius_coa_it_test.go index e5cfc78a2..a263f032a 100644 --- a/agents/radius_coa_it_test.go +++ b/agents/radius_coa_it_test.go @@ -59,7 +59,7 @@ client will then verify that the packet was populated correctly. session created previously and verify the request packet fields. */ func TestRadiusCoADisconnect(t *testing.T) { - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: case utils.MetaMySQL, utils.MetaMongo, utils.MetaPostgres: t.SkipNow() @@ -68,7 +68,7 @@ func TestRadiusCoADisconnect(t *testing.T) { } // Set up test environment. - cfgPath := path.Join(*dataDir, "conf", "samples", "radius_coa_disconnect") + cfgPath := path.Join(*utils.DataDir, "conf", "samples", "radius_coa_disconnect") raDiscCfg, err := config.NewCGRConfigFromPath(cfgPath) if err != nil { t.Fatal(err) @@ -79,7 +79,7 @@ func TestRadiusCoADisconnect(t *testing.T) { if err := engine.InitStorDb(raDiscCfg); err != nil { t.Fatal(err) } - if _, err := engine.StartEngine(cfgPath, *waitRater); err != nil { + if _, err := engine.StartEngine(cfgPath, *utils.WaitRater); err != nil { t.Fatal(err) } defer engine.KillEngine(100) @@ -87,12 +87,12 @@ func TestRadiusCoADisconnect(t *testing.T) { if err != nil { t.Fatal(err) } - attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*dataDir, "tariffplans", "oldtutorial")} + attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*utils.DataDir, "tariffplans", "oldtutorial")} var loadInst utils.LoadInstance if err := raDiscRPC.Call(context.Background(), utils.APIerSv2LoadTariffPlanFromFolder, attrs, &loadInst); err != nil { t.Error(err) } - time.Sleep(time.Duration(*waitRater) * time.Millisecond) + time.Sleep(time.Duration(*utils.WaitRater) * time.Millisecond) var reply string diff --git a/agents/sipagent_it_test.go b/agents/sipagent_it_test.go index c3229b94c..b923d9222 100644 --- a/agents/sipagent_it_test.go +++ b/agents/sipagent_it_test.go @@ -60,7 +60,7 @@ var ( // Test start here func TestSAit(t *testing.T) { // engine.KillEngine(0) - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: saonfigDIR = "sipagent_internal" case utils.MetaMySQL: @@ -78,7 +78,7 @@ func TestSAit(t *testing.T) { } func testSAitInitCfg(t *testing.T) { - saCfgPath = path.Join(*dataDir, "conf", "samples", saonfigDIR) + saCfgPath = path.Join(*utils.DataDir, "conf", "samples", saonfigDIR) // Init config first var err error saCfg, err = config.NewCGRConfigFromPath(saCfgPath) @@ -106,7 +106,7 @@ func testSAitResetStorDb(t *testing.T) { // Start CGR Engine func testSAitStartEngine(t *testing.T) { - if _, err := engine.StartEngine(saCfgPath, *waitRater); err != nil { + if _, err := engine.StartEngine(saCfgPath, *utils.WaitRater); err != nil { t.Fatal(err) } } @@ -125,12 +125,12 @@ func testSAitApierRpcConn(t *testing.T) { // Load the tariff plan, creating accounts and their balances func testSAitTPFromFolder(t *testing.T) { - attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*dataDir, "tariffplans", "tut_sip_redirect")} + attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*utils.DataDir, "tariffplans", "tut_sip_redirect")} var loadInst utils.LoadInstance if err := saRPC.Call(context.Background(), utils.APIerSv2LoadTariffPlanFromFolder, attrs, &loadInst); err != nil { t.Error(err) } - time.Sleep(time.Duration(*waitRater) * time.Millisecond) // Give time for scheduler to execute topups + time.Sleep(time.Duration(*utils.WaitRater) * time.Millisecond) // Give time for scheduler to execute topups } func testSAitStopCgrEngine(t *testing.T) { diff --git a/analyzers/analyzers_it_test.go b/analyzers/analyzers_it_test.go index 2d6167eaf..9c513af7e 100644 --- a/analyzers/analyzers_it_test.go +++ b/analyzers/analyzers_it_test.go @@ -23,7 +23,6 @@ package analyzers import ( "errors" - "flag" "os" "path" "reflect" @@ -62,14 +61,8 @@ var ( } ) -var ( - dataDir = flag.String("data_dir", "/usr/share/cgrates", "CGR data dir path here") - waitRater = flag.Int("wait_rater", 500, "Number of miliseconds to wait for rater to start and cache") - encoding = flag.String("rpc", utils.MetaJSON, "what encoding whould be uused for rpc comunication") -) - func newRPCClient(cfg *config.ListenCfg) (c *birpc.Client, err error) { - switch *encoding { + switch *utils.Encoding { case utils.MetaJSON: return jsonrpc.Dial(utils.TCP, cfg.RPCJSONListen) case utils.MetaGOB: @@ -94,7 +87,7 @@ func testAnalyzerSInitCfg(t *testing.T) { if err = os.MkdirAll("/tmp/analyzers/", 0700); err != nil { t.Fatal(err) } - anzCfgPath = path.Join(*dataDir, "conf", "samples", "analyzers") + anzCfgPath = path.Join(*utils.DataDir, "conf", "samples", "analyzers") anzCfg, err = config.NewCGRConfigFromPath(anzCfgPath) if err != nil { t.Error(err) @@ -116,7 +109,7 @@ func testAnalyzerSResetStorDb(t *testing.T) { // Start CGR Engine func testAnalyzerSStartEngine(t *testing.T) { - if _, err := engine.StopStartEngine(anzCfgPath, *waitRater); err != nil { + if _, err := engine.StopStartEngine(anzCfgPath, *utils.WaitRater); err != nil { t.Fatal(err) } } @@ -139,7 +132,7 @@ func testAnalyzerSRPCConn(t *testing.T) { func testAnalyzerSLoadTarrifPlans(t *testing.T) { var reply string - attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*dataDir, "tariffplans", "tutorial")} + attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*utils.DataDir, "tariffplans", "tutorial")} if err := anzRPC.Call(context.Background(), utils.APIerSv1LoadTariffPlanFromFolder, attrs, &reply); err != nil { t.Error(err) } else if reply != utils.OK { diff --git a/apier/v1/accounts_it_test.go b/apier/v1/accounts_it_test.go index 4c47a5d55..b16f5cb89 100644 --- a/apier/v1/accounts_it_test.go +++ b/apier/v1/accounts_it_test.go @@ -84,7 +84,7 @@ var ( ) func TestAccITWithRemove(t *testing.T) { - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: accTestsConfig = "tutinternal" case utils.MetaMySQL: @@ -96,7 +96,7 @@ func TestAccITWithRemove(t *testing.T) { default: t.Fatal("Unknown Database type") } - accCfgPath = path.Join(*dataDir, "conf", "samples", accTestsConfig) + accCfgPath = path.Join(*utils.DataDir, "conf", "samples", accTestsConfig) for _, stest := range accTests { t.Run(accTestsConfig, stest) @@ -104,7 +104,7 @@ func TestAccITWithRemove(t *testing.T) { } func TestAccITWithoutRemove(t *testing.T) { - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: accTestsConfig = "acc_balance_keep_internal" case utils.MetaMySQL: @@ -114,12 +114,12 @@ func TestAccITWithoutRemove(t *testing.T) { case utils.MetaPostgres: t.SkipNow() default: - t.Fatalf("Unknown Database type <%s>", *dbType) + t.Fatalf("Unknown Database type <%s>", *utils.DBType) } - if *encoding == utils.MetaGOB { + if *utils.Encoding == utils.MetaGOB { accTestsConfig += "_gob" } - accCfgPath = path.Join(*dataDir, "conf", "samples", accTestsConfig) + accCfgPath = path.Join(*utils.DataDir, "conf", "samples", accTestsConfig) accExist = true for _, stest := range accTests { @@ -147,7 +147,7 @@ func testAccITResetStorDb(t *testing.T) { } func testAccITStartEngine(t *testing.T) { - if _, err := engine.StopStartEngine(accCfgPath, *waitRater); err != nil { + if _, err := engine.StopStartEngine(accCfgPath, *utils.WaitRater); err != nil { t.Fatal(err) } } @@ -903,7 +903,7 @@ func testAccITAddBalanceWithValueInMap(t *testing.T) { // Load the tariff plan, creating accounts and their balances func testAccITTPFromFolder(t *testing.T) { attrs := &utils.AttrLoadTpFromFolder{ - FolderPath: path.Join(*dataDir, "tariffplans", "tutorial")} + FolderPath: path.Join(*utils.DataDir, "tariffplans", "tutorial")} var loadInst utils.LoadInstance if err := accRPC.Call(context.Background(), utils.APIerSv2LoadTariffPlanFromFolder, attrs, &loadInst); err != nil { diff --git a/apier/v1/apier2_it_test.go b/apier/v1/apier2_it_test.go index 1ea57ec0e..e4a3d28fb 100644 --- a/apier/v1/apier2_it_test.go +++ b/apier/v1/apier2_it_test.go @@ -81,7 +81,7 @@ var ( // Test start here func TestApierIT2(t *testing.T) { // no need for a new config with *gob transport in this case - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: APIerSv2ConfigDIR = "tutinternal" sTestsAPIer = sTestsAPIer[:len(sTestsAPIer)-6] @@ -101,7 +101,7 @@ func TestApierIT2(t *testing.T) { func testAPIerInitCfg(t *testing.T) { var err error - apierCfgPath = path.Join(*dataDir, "conf", "samples", APIerSv2ConfigDIR) + apierCfgPath = path.Join(*utils.DataDir, "conf", "samples", APIerSv2ConfigDIR) apierCfg, err = config.NewCGRConfigFromPath(apierCfgPath) if err != nil { t.Error(err) @@ -124,14 +124,14 @@ func testAPIerResetStorDb(t *testing.T) { // Start CGR Engine func testAPIerStartEngineSleep(t *testing.T) { time.Sleep(500 * time.Millisecond) - if _, err := engine.StopStartEngine(apierCfgPath, *waitRater); err != nil { + if _, err := engine.StopStartEngine(apierCfgPath, *utils.WaitRater); err != nil { t.Fatal(err) } } // Start CGR Engine func testAPIerStartEngine(t *testing.T) { - if _, err := engine.StopStartEngine(apierCfgPath, *waitRater); err != nil { + if _, err := engine.StopStartEngine(apierCfgPath, *utils.WaitRater); err != nil { t.Fatal(err) } } @@ -147,7 +147,7 @@ func testAPIerRPCConn(t *testing.T) { func testAPIerLoadFromFolder(t *testing.T) { var reply string - attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*dataDir, "tariffplans", "tutorial")} + attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*utils.DataDir, "tariffplans", "tutorial")} if err := apierRPC.Call(context.Background(), utils.APIerSv1LoadTariffPlanFromFolder, attrs, &reply); err != nil { t.Error(err) } @@ -183,7 +183,7 @@ func testAPIerVerifyAttributesAfterLoad(t *testing.T) { Weight: 20.0, }, } - if *encoding == utils.MetaGOB { + if *utils.Encoding == utils.MetaGOB { eAttrPrf.Attributes[0].FilterIDs = nil // in gob emtpty slice is encoded as nil } eAttrPrf.Compile() @@ -207,7 +207,7 @@ func testAPIerVerifyAttributesAfterLoad(t *testing.T) { func testAPIerRemoveTPFromFolder(t *testing.T) { var reply string - attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*dataDir, "tariffplans", "tutorial")} + attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*utils.DataDir, "tariffplans", "tutorial")} if err := apierRPC.Call(context.Background(), utils.APIerSv1RemoveTPFromFolder, attrs, &reply); err != nil { t.Error(err) } @@ -654,12 +654,12 @@ func testAPIerLoadRatingProfile(t *testing.T) { func testAPIerLoadFromFolderAccountAction(t *testing.T) { var reply string - attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*dataDir, "tariffplans", "tutorial")} + attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*utils.DataDir, "tariffplans", "tutorial")} if err := apierRPC.Call(context.Background(), utils.APIerSv1LoadTariffPlanFromFolder, attrs, &reply); err != nil { t.Error(err) } time.Sleep(100 * time.Millisecond) - attrs2 := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*dataDir, "tariffplans", "account_action_from_tutorial")} + attrs2 := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*utils.DataDir, "tariffplans", "account_action_from_tutorial")} if err := apierRPC.Call(context.Background(), utils.APIerSv1LoadTariffPlanFromFolder, attrs2, &reply); err != nil { t.Error(err) } @@ -678,7 +678,7 @@ func testAPIerLoadFromFolderAccountAction(t *testing.T) { } func testApierSetAndRemoveRatingProfileAnySubject(t *testing.T) { - loader := exec.Command("cgr-loader", "-config_path", apierCfgPath, "-path", path.Join(*dataDir, "tariffplans", "tutorial")) + loader := exec.Command("cgr-loader", "-config_path", apierCfgPath, "-path", path.Join(*utils.DataDir, "tariffplans", "tutorial")) if err := loader.Run(); err != nil { t.Error(err) } @@ -737,7 +737,7 @@ func testApierSetAndRemoveRatingProfileAnySubject(t *testing.T) { } func testAPIerKillEngine(t *testing.T) { - if err := engine.KillEngine(*waitRater); err != nil { + if err := engine.KillEngine(*utils.WaitRater); err != nil { t.Error(err) } } diff --git a/apier/v1/apier_it_test.go b/apier/v1/apier_it_test.go index ac6adeb87..c4fc0b8c7 100644 --- a/apier/v1/apier_it_test.go +++ b/apier/v1/apier_it_test.go @@ -174,7 +174,7 @@ var ( ) func TestApierIT(t *testing.T) { - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: t.SkipNow() // need tests redesign case utils.MetaMySQL: @@ -194,7 +194,7 @@ func TestApierIT(t *testing.T) { func testApierLoadConfig(t *testing.T) { var err error - cfgPath = path.Join(*dataDir, "conf", "samples", APIerSv1ConfigDIR) // no need for a new config with *gob transport in this case + cfgPath = path.Join(*utils.DataDir, "conf", "samples", APIerSv1ConfigDIR) // no need for a new config with *gob transport in this case if cfg, err = config.NewCGRConfigFromPath(cfgPath); err != nil { t.Error(err) } @@ -226,7 +226,7 @@ func testApierInitStorDb(t *testing.T) { // Start engine func testApierStartEngine(t *testing.T) { - if _, err := engine.StopStartEngine(cfgPath, *waitRater); err != nil { + if _, err := engine.StopStartEngine(cfgPath, *utils.WaitRater); err != nil { t.Fatal(err) } } @@ -1633,7 +1633,7 @@ func testApierLoadTariffPlanFromFolder(t *testing.T) { t.Error(err) } // Simple test that command is executed without errors - attrs = &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*dataDir, "tariffplans", "testtp")} + attrs = &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*utils.DataDir, "tariffplans", "testtp")} startTime := time.Now() if err := rater.Call(context.Background(), utils.APIerSv1LoadTariffPlanFromFolder, attrs, &reply); err != nil { t.Error("Got error on APIerSv1.LoadTariffPlanFromFolder: ", err.Error()) @@ -1822,7 +1822,7 @@ func testApierCdrServer(t *testing.T) { t.Error(err.Error()) } } - time.Sleep(time.Duration(*waitRater) * time.Millisecond) + time.Sleep(time.Duration(*utils.WaitRater) * time.Millisecond) } func testApierITGetCdrs(t *testing.T) { @@ -1920,7 +1920,7 @@ func testApierGetCallCostLog(t *testing.T) { Rates: engine.ChargedRates{}, Timings: engine.ChargedTimings{}, } - if *encoding == utils.MetaGOB { + if *utils.Encoding == utils.MetaGOB { expected.Usage = nil // 0 value are encoded as nil in gob expected.Cost = nil } diff --git a/apier/v1/attributes_it_test.go b/apier/v1/attributes_it_test.go index 4f842c6dc..ecc8c6d01 100644 --- a/apier/v1/attributes_it_test.go +++ b/apier/v1/attributes_it_test.go @@ -109,7 +109,7 @@ var ( // Test start here func TestAttributeSIT(t *testing.T) { attrsTests := sTestsAlsPrf - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: attrsTests = sTestsAlsPrf[:29] alsPrfConfigDIR = "tutinternal" @@ -129,7 +129,7 @@ func TestAttributeSIT(t *testing.T) { func testAttributeSInitCfg(t *testing.T) { var err error - alsPrfCfgPath = path.Join(*dataDir, "conf", "samples", alsPrfConfigDIR) + alsPrfCfgPath = path.Join(*utils.DataDir, "conf", "samples", alsPrfConfigDIR) alsPrfCfg, err = config.NewCGRConfigFromPath(alsPrfCfgPath) if err != nil { t.Error(err) @@ -151,7 +151,7 @@ func testAttributeSResetStorDb(t *testing.T) { // Start CGR Engine func testAttributeSStartEngine(t *testing.T) { - if _, err := engine.StopStartEngine(alsPrfCfgPath, *waitRater); err != nil { + if _, err := engine.StopStartEngine(alsPrfCfgPath, *utils.WaitRater); err != nil { t.Fatal(err) } } @@ -176,7 +176,7 @@ func testAttributeSGetAlsPrfBeforeSet(t *testing.T) { func testAttributeSLoadFromFolder(t *testing.T) { var reply string - attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*dataDir, "tariffplans", "oldtutorial")} + attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*utils.DataDir, "tariffplans", "oldtutorial")} if err := attrSRPC.Call(context.Background(), utils.APIerSv1LoadTariffPlanFromFolder, attrs, &reply); err != nil { t.Error(err) } @@ -219,7 +219,7 @@ func testAttributeSGetAttributeForEvent(t *testing.T) { }, Weight: 10.0, } - if *encoding == utils.MetaGOB { + if *utils.Encoding == utils.MetaGOB { eAttrPrf.Attributes[0].FilterIDs = nil eAttrPrf.Attributes[1].FilterIDs = nil } diff --git a/apier/v1/cache_replication_it_test.go b/apier/v1/cache_replication_it_test.go index 2069a0be0..1a031662c 100644 --- a/apier/v1/cache_replication_it_test.go +++ b/apier/v1/cache_replication_it_test.go @@ -64,11 +64,11 @@ func TestCacheSv1ReplicateIT(t *testing.T) { func testCacheSReplicateLoadConfig(t *testing.T) { var err error - engine1CfgPath = path.Join(*dataDir, "conf", "samples", "replication_cache", "engine1") + engine1CfgPath = path.Join(*utils.DataDir, "conf", "samples", "replication_cache", "engine1") if engine1Cfg, err = config.NewCGRConfigFromPath(engine1CfgPath); err != nil { t.Error(err) } - engine2CfgPath = path.Join(*dataDir, "conf", "samples", "replication_cache", "engine2") + engine2CfgPath = path.Join(*utils.DataDir, "conf", "samples", "replication_cache", "engine2") if engine2Cfg, err = config.NewCGRConfigFromPath(engine2CfgPath); err != nil { t.Error(err) } @@ -95,10 +95,10 @@ func testCacheSReplicateInitStorDb(t *testing.T) { // Start engine func testCacheSReplicateStartEngine(t *testing.T) { - if _, err := engine.StopStartEngine(engine1CfgPath, *waitRater); err != nil { + if _, err := engine.StopStartEngine(engine1CfgPath, *utils.WaitRater); err != nil { t.Fatal(err) } - if _, err := engine.StartEngine(engine2CfgPath, *waitRater); err != nil { + if _, err := engine.StartEngine(engine2CfgPath, *utils.WaitRater); err != nil { t.Fatal(err) } } @@ -117,11 +117,11 @@ func testCacheSReplicateRpcConn(t *testing.T) { func testCacheSReplicateLoadTariffPlanFromFolder(t *testing.T) { var reply string - attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*dataDir, "tariffplans", "testit")} + attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*utils.DataDir, "tariffplans", "testit")} if err := engine2RPC.Call(context.Background(), utils.APIerSv1LoadTariffPlanFromFolder, attrs, &reply); err != nil { t.Error(err) } - time.Sleep(time.Duration(*waitRater) * time.Millisecond) + time.Sleep(time.Duration(*utils.WaitRater) * time.Millisecond) } func testCacheSReplicateProcessAttributes(t *testing.T) { diff --git a/apier/v1/caches_it_test.go b/apier/v1/caches_it_test.go index 5cdb00ae5..afd166810 100644 --- a/apier/v1/caches_it_test.go +++ b/apier/v1/caches_it_test.go @@ -66,7 +66,7 @@ var ( // Test start here func TestCacheSv1IT(t *testing.T) { - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: t.SkipNow() case utils.MetaMySQL: @@ -85,7 +85,7 @@ func TestCacheSv1IT(t *testing.T) { func testCacheSLoadConfig(t *testing.T) { var err error - chcCfgPath = path.Join(*dataDir, "conf", "samples", "precache", cacheConfigDIR) + chcCfgPath = path.Join(*utils.DataDir, "conf", "samples", "precache", cacheConfigDIR) if chcCfg, err = config.NewCGRConfigFromPath(chcCfgPath); err != nil { t.Error(err) } @@ -106,7 +106,7 @@ func testCacheSInitStorDb(t *testing.T) { // Start engine func testCacheSStartEngine(t *testing.T) { - if _, err := engine.StopStartEngine(chcCfgPath, *waitRater); err != nil { + if _, err := engine.StopStartEngine(chcCfgPath, *utils.WaitRater); err != nil { t.Fatal(err) } } @@ -121,11 +121,11 @@ func testCacheSRpcConn(t *testing.T) { func testCacheSLoadTariffPlanFromFolder(t *testing.T) { var reply string - attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*dataDir, "tariffplans", "testtp")} + attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*utils.DataDir, "tariffplans", "testtp")} if err := chcRPC.Call(context.Background(), utils.APIerSv1LoadTariffPlanFromFolder, attrs, &reply); err != nil { t.Error(err) } - time.Sleep(time.Duration(*waitRater) * time.Millisecond) + time.Sleep(time.Duration(*utils.WaitRater) * time.Millisecond) } func testCacheSAfterLoadFromFolder(t *testing.T) { diff --git a/apier/v1/caps_it_test.go b/apier/v1/caps_it_test.go index ee056082e..20750d4b9 100644 --- a/apier/v1/caps_it_test.go +++ b/apier/v1/caps_it_test.go @@ -81,7 +81,7 @@ func TestCapsQueueJSON(t *testing.T) { func testCapsInitCfg(t *testing.T) { var err error - capsCfgPath = path.Join(*dataDir, "conf", "samples", capsConfigDIR) + capsCfgPath = path.Join(*utils.DataDir, "conf", "samples", capsConfigDIR) capsCfg, err = config.NewCGRConfigFromPath(capsCfgPath) if err != nil { t.Error(err) @@ -90,7 +90,7 @@ func testCapsInitCfg(t *testing.T) { // Start CGR Engine func testCapsStartEngine(t *testing.T) { - if _, err := engine.StopStartEngine(capsCfgPath, *waitRater); err != nil { + if _, err := engine.StopStartEngine(capsCfgPath, *utils.WaitRater); err != nil { t.Fatal(err) } } @@ -295,11 +295,11 @@ func benchmarkInit(b *testing.B, cfgDir string) { capsOnce.Do(func() { capsLastCfgDir = cfgDir var err error - capsCfgPath = path.Join(*dataDir, "conf", "samples", cfgDir) + capsCfgPath = path.Join(*utils.DataDir, "conf", "samples", cfgDir) if capsCfg, err = config.NewCGRConfigFromPath(capsCfgPath); err != nil { b.Fatal(err) } - if _, err := engine.StopStartEngine(capsCfgPath, *waitRater); err != nil { + if _, err := engine.StopStartEngine(capsCfgPath, *utils.WaitRater); err != nil { b.Fatal(err) } if capsRPC, err = newRPCClient(capsCfg.ListenCfg()); err != nil { diff --git a/apier/v1/cdrs_it_test.go b/apier/v1/cdrs_it_test.go index 60b5a836b..d7c23579b 100644 --- a/apier/v1/cdrs_it_test.go +++ b/apier/v1/cdrs_it_test.go @@ -62,7 +62,7 @@ var ( ) func TestCDRsIT(t *testing.T) { - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: cdrsConfDIR = "cdrsv1internal" case utils.MetaMySQL: @@ -82,7 +82,7 @@ func TestCDRsIT(t *testing.T) { func testV1CDRsInitConfig(t *testing.T) { var err error - cdrsCfgPath = path.Join(*dataDir, "conf", "samples", cdrsConfDIR) + cdrsCfgPath = path.Join(*utils.DataDir, "conf", "samples", cdrsConfDIR) if cdrsCfg, err = config.NewCGRConfigFromPath(cdrsCfgPath); err != nil { t.Fatal("Got config error: ", err.Error()) } @@ -102,7 +102,7 @@ func testV1CDRsInitCdrDb(t *testing.T) { } func testV1CDRsStartEngine(t *testing.T) { - if _, err := engine.StopStartEngine(cdrsCfgPath, *waitRater); err != nil { + if _, err := engine.StopStartEngine(cdrsCfgPath, *utils.WaitRater); err != nil { t.Fatal(err) } } @@ -120,10 +120,10 @@ func testV1CDRsLoadTariffPlanFromFolder(t *testing.T) { var loadInst string if err := cdrsRpc.Call(context.Background(), utils.APIerSv1LoadTariffPlanFromFolder, &utils.AttrLoadTpFromFolder{FolderPath: path.Join( - *dataDir, "tariffplans", "testit")}, &loadInst); err != nil { + *utils.DataDir, "tariffplans", "testit")}, &loadInst); err != nil { t.Error(err) } - time.Sleep(time.Duration(*waitRater) * time.Millisecond) // Give time for scheduler to execute topups + time.Sleep(time.Duration(*utils.WaitRater) * time.Millisecond) // Give time for scheduler to execute topups } func testV1CDRsProcessEventWithRefund(t *testing.T) { @@ -531,10 +531,10 @@ func testV1CDRsLoadTariffPlanFromFolderSMS(t *testing.T) { var loadInst string if err := cdrsRpc.Call(context.Background(), utils.APIerSv1LoadTariffPlanFromFolder, &utils.AttrLoadTpFromFolder{FolderPath: path.Join( - *dataDir, "tariffplans", "tutorial")}, &loadInst); err != nil { + *utils.DataDir, "tariffplans", "tutorial")}, &loadInst); err != nil { t.Error(err) } - time.Sleep(time.Duration(*waitRater) * time.Millisecond) // Give time for scheduler to execute topups + time.Sleep(time.Duration(*utils.WaitRater) * time.Millisecond) // Give time for scheduler to execute topups } func testV1CDRsAddBalanceForSMS(t *testing.T) { @@ -620,7 +620,7 @@ func testV1CDRsAddBalanceForSMS(t *testing.T) { } func testV1CDRsKillEngine(t *testing.T) { - if err := engine.KillEngine(*waitRater); err != nil { + if err := engine.KillEngine(*utils.WaitRater); err != nil { t.Error(err) } } diff --git a/apier/v1/chargers_it_test.go b/apier/v1/chargers_it_test.go index bd75cb7b8..eec66d029 100644 --- a/apier/v1/chargers_it_test.go +++ b/apier/v1/chargers_it_test.go @@ -108,7 +108,7 @@ var ( // Test start here func TestChargerSIT(t *testing.T) { sTestsChargerCache := sTestsCharger - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: chargerConfigDIR = "tutinternal" sTestsChargerCache = sTestsChargerCache[:len(sTestsChargerCache)-10] @@ -128,7 +128,7 @@ func TestChargerSIT(t *testing.T) { func testChargerSInitCfg(t *testing.T) { var err error - chargerCfgPath = path.Join(*dataDir, "conf", "samples", chargerConfigDIR) + chargerCfgPath = path.Join(*utils.DataDir, "conf", "samples", chargerConfigDIR) chargerCfg, err = config.NewCGRConfigFromPath(chargerCfgPath) if err != nil { t.Error(err) @@ -150,7 +150,7 @@ func testChargerSResetStorDb(t *testing.T) { // Start CGR Engine func testChargerSStartEngine(t *testing.T) { - if _, err := engine.StopStartEngine(chargerCfgPath, *waitRater); err != nil { + if _, err := engine.StopStartEngine(chargerCfgPath, *utils.WaitRater); err != nil { t.Fatal(err) } } @@ -549,7 +549,7 @@ func testChargerSProcessWithNotFoundAttribute(t *testing.T) { }, }, } - if *encoding == utils.MetaGOB { + if *utils.Encoding == utils.MetaGOB { processedEv[0].AttributeSProfiles = nil } var rply []*engine.ChrgSProcessEventReply diff --git a/apier/v1/config_it_test.go b/apier/v1/config_it_test.go index fe7b7d157..a8e261e0d 100644 --- a/apier/v1/config_it_test.go +++ b/apier/v1/config_it_test.go @@ -69,7 +69,7 @@ var ( // Test start here func TestConfigSIT(t *testing.T) { - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: configConfigDIR = "tutinternal" case utils.MetaMySQL: @@ -88,7 +88,7 @@ func TestConfigSIT(t *testing.T) { func testConfigSInitCfg(t *testing.T) { var err error - configCfgPath = path.Join(*dataDir, "conf", "samples", configConfigDIR) + configCfgPath = path.Join(*utils.DataDir, "conf", "samples", configConfigDIR) configCfg, err = config.NewCGRConfigFromPath(configCfgPath) if err != nil { t.Error(err) @@ -110,7 +110,7 @@ func testConfigSResetStorDb(t *testing.T) { // Start CGR Engine func testConfigSStartEngine(t *testing.T) { - if _, err := engine.StopStartEngine(configCfgPath, *waitRater); err != nil { + if _, err := engine.StopStartEngine(configCfgPath, *utils.WaitRater); err != nil { t.Fatal(err) } } @@ -182,7 +182,7 @@ func testConfigSSetConfigSessionS(t *testing.T) { utils.MetaSMS: "1", }, } - if *encoding == utils.MetaGOB { + if *utils.Encoding == utils.MetaGOB { var empty []string exp = map[string]any{ "enabled": true, @@ -275,7 +275,7 @@ func testConfigSv1GetJSONSectionWithoutTenant(t *testing.T) { utils.MetaSMS: "1", }, } - if *encoding == utils.MetaGOB { + if *utils.Encoding == utils.MetaGOB { var empty []string exp = map[string]any{ "enabled": true, @@ -329,7 +329,7 @@ func testConfigSv1GetJSONSectionWithoutTenant(t *testing.T) { } func testConfigSSetConfigEEsDryRun(t *testing.T) { - if *encoding == utils.MetaGOB { + if *utils.Encoding == utils.MetaGOB { t.SkipNow() } var reply string @@ -357,7 +357,7 @@ func testConfigSSetConfigEEsDryRun(t *testing.T) { } func testConfigSSetConfigEEs(t *testing.T) { - if *encoding == utils.MetaGOB { + if *utils.Encoding == utils.MetaGOB { t.SkipNow() } var reply string @@ -421,12 +421,12 @@ func testConfigSKillEngine(t *testing.T) { func testConfigStartEngineWithConfigs(t *testing.T) { var err error - configCfgPath = path.Join(*dataDir, "conf", "samples", "configs_active") + configCfgPath = path.Join(*utils.DataDir, "conf", "samples", "configs_active") configCfg, err = config.NewCGRConfigFromPath(configCfgPath) if err != nil { t.Error(err) } - if _, err := engine.StopStartEngine(configCfgPath, *waitRater); err != nil { + if _, err := engine.StopStartEngine(configCfgPath, *utils.WaitRater); err != nil { t.Fatal(err) } configRPC, err = newRPCClient(configCfg.ListenCfg()) // We connect over JSON so we can also troubleshoot if needed @@ -526,7 +526,7 @@ func testConfigSReloadConfigCoreSDryRun(t *testing.T) { var reply string if err := configRPC.Call(context.Background(), utils.ConfigSv1ReloadConfig, &config.ReloadArgs{ Tenant: "cgrates.org", - Path: path.Join(*dataDir, "conf", "samples", "caps_busy"), + Path: path.Join(*utils.DataDir, "conf", "samples", "caps_busy"), Section: config.CoreSCfgJson, DryRun: true, }, &reply); err != nil { @@ -551,7 +551,7 @@ func testConfigSReloadConfigCoreS(t *testing.T) { var reply string if err := configRPC.Call(context.Background(), utils.ConfigSv1ReloadConfig, &config.ReloadArgs{ Tenant: "cgrates.org", - Path: path.Join(*dataDir, "conf", "samples", "caps_busy"), + Path: path.Join(*utils.DataDir, "conf", "samples", "caps_busy"), Section: config.CoreSCfgJson, }, &reply); err != nil { t.Error(err) @@ -572,12 +572,12 @@ func testConfigSReloadConfigCoreS(t *testing.T) { func testConfigSStartEngineCAPSAllocated(t *testing.T) { var err error - configCfgPath = path.Join(*dataDir, "conf", "samples", "caps_peak") + configCfgPath = path.Join(*utils.DataDir, "conf", "samples", "caps_peak") configCfg, err = config.NewCGRConfigFromPath(configCfgPath) if err != nil { t.Error(err) } - if _, err := engine.StopStartEngine(configCfgPath, *waitRater); err != nil { + if _, err := engine.StopStartEngine(configCfgPath, *utils.WaitRater); err != nil { t.Fatal(err) } configRPC, err = newRPCClient(configCfg.ListenCfg()) // We connect over JSON so we can also troubleshoot if needed @@ -601,7 +601,7 @@ func testConfigSCAPSPeak(t *testing.T) { var reply string if err := configRPC.Call(context.Background(), utils.ConfigSv1ReloadConfig, &config.ReloadArgs{ Tenant: "cgrates.org", - Path: path.Join(*dataDir, "conf", "samples", "caps_peak"), + Path: path.Join(*utils.DataDir, "conf", "samples", "caps_peak"), Section: config.CoreSCfgJson, }, &reply); err != nil { t.Error(err) diff --git a/apier/v1/core_it_test.go b/apier/v1/core_it_test.go index 135cca802..030bea21a 100644 --- a/apier/v1/core_it_test.go +++ b/apier/v1/core_it_test.go @@ -89,7 +89,7 @@ var ( func TestITCoreSv1(t *testing.T) { argPath = "/tmp" - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: coreV1ConfDIR = "tutinternal" case utils.MetaMySQL: @@ -105,7 +105,7 @@ func TestITCoreSv1(t *testing.T) { } func testCoreSv1LoadCofig(t *testing.T) { - coreV1CfgPath = path.Join(*dataDir, "conf", "samples", coreV1ConfDIR) + coreV1CfgPath = path.Join(*utils.DataDir, "conf", "samples", coreV1ConfDIR) var err error if coreV1Cfg, err = config.NewCGRConfigFromPath(coreV1CfgPath); err != nil { t.Error(err) @@ -165,7 +165,7 @@ func testCoreSv1StartCPUProfilingErrorAlreadyStarted(t *testing.T) { } func testCoreSv1StartEngine(t *testing.T) { - if _, err := engine.StartEngine(coreV1CfgPath, *waitRater); err != nil { + if _, err := engine.StartEngine(coreV1CfgPath, *utils.WaitRater); err != nil { t.Error(err) } } @@ -347,7 +347,7 @@ func testCoreSv1StartMemoryProfiling(t *testing.T) { } func testCoreSv1KillEngine(t *testing.T) { - if err := engine.KillEngine(*waitRater); err != nil { + if err := engine.KillEngine(*utils.WaitRater); err != nil { t.Error(err) } } diff --git a/apier/v1/costs_it_test.go b/apier/v1/costs_it_test.go index 8e6f26cb1..39aeed79d 100644 --- a/apier/v1/costs_it_test.go +++ b/apier/v1/costs_it_test.go @@ -53,7 +53,7 @@ var ( // Test start here func TestCostIT(t *testing.T) { - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: costConfigDIR = "tutinternal" case utils.MetaMySQL: @@ -72,7 +72,7 @@ func TestCostIT(t *testing.T) { func testCostInitCfg(t *testing.T) { var err error - costCfgPath = path.Join(*dataDir, "conf", "samples", costConfigDIR) + costCfgPath = path.Join(*utils.DataDir, "conf", "samples", costConfigDIR) costCfg, err = config.NewCGRConfigFromPath(costCfgPath) if err != nil { t.Error(err) @@ -94,7 +94,7 @@ func testCostResetStorDb(t *testing.T) { // Start CGR Engine func testCostStartEngine(t *testing.T) { - if _, err := engine.StopStartEngine(costCfgPath, *waitRater); err != nil { + if _, err := engine.StopStartEngine(costCfgPath, *utils.WaitRater); err != nil { t.Fatal(err) } } @@ -110,7 +110,7 @@ func testCostRPCConn(t *testing.T) { func testCostLoadFromFolder(t *testing.T) { var reply string - attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*dataDir, "tariffplans", "tutorial")} + attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*utils.DataDir, "tariffplans", "tutorial")} if err := costRPC.Call(context.Background(), utils.APIerSv1LoadTariffPlanFromFolder, attrs, &reply); err != nil { t.Error(err) } @@ -129,7 +129,7 @@ func testCostGetCost(t *testing.T) { } func testCostKillEngine(t *testing.T) { - if err := engine.KillEngine(*waitRater); err != nil { + if err := engine.KillEngine(*utils.WaitRater); err != nil { t.Error(err) } } diff --git a/apier/v1/dispatcher_it_test.go b/apier/v1/dispatcher_it_test.go index 7eb253b42..f76b44a15 100644 --- a/apier/v1/dispatcher_it_test.go +++ b/apier/v1/dispatcher_it_test.go @@ -90,7 +90,7 @@ var ( // Test start here func TestDispatcherSIT(t *testing.T) { sTestsDispatcherCacheSV1 := sTestsDispatcher - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: dispatcherConfigDIR = "tutinternal" sTestsDispatcherCacheSV1 = sTestsDispatcherCacheSV1[:len(sTestsDispatcherCacheSV1)-10] @@ -111,12 +111,12 @@ func TestDispatcherSIT(t *testing.T) { func testDispatcherSInitCfg(t *testing.T) { var err error - dispatcherCfgPath = path.Join(*dataDir, "conf", "samples", dispatcherConfigDIR) + dispatcherCfgPath = path.Join(*utils.DataDir, "conf", "samples", dispatcherConfigDIR) dispatcherCfg, err = config.NewCGRConfigFromPath(dispatcherCfgPath) if err != nil { t.Error(err) } - dispatcherCfg.DataFolderPath = *dataDir + dispatcherCfg.DataFolderPath = *utils.DataDir } func testDispatcherSInitDataDb(t *testing.T) { @@ -134,7 +134,7 @@ func testDispatcherSResetStorDb(t *testing.T) { // Start CGR Engine func testDispatcherSStartEngine(t *testing.T) { - if _, err := engine.StopStartEngine(dispatcherCfgPath, *waitRater); err != nil { + if _, err := engine.StopStartEngine(dispatcherCfgPath, *utils.WaitRater); err != nil { t.Fatal(err) } } @@ -427,7 +427,7 @@ func testV1DispatcherStopCPUProfiling(t *testing.T) { } func testDispatcherSKillEngine(t *testing.T) { - if err := engine.KillEngine(*waitRater); err != nil { + if err := engine.KillEngine(*utils.WaitRater); err != nil { t.Error(err) } } diff --git a/apier/v1/dispatchersv1_it_test.go b/apier/v1/dispatchersv1_it_test.go index 3f9608d23..58f9d3b10 100644 --- a/apier/v1/dispatchersv1_it_test.go +++ b/apier/v1/dispatchersv1_it_test.go @@ -56,7 +56,7 @@ var ( //Test start here func TestDspDspv1(t *testing.T) { - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: t.SkipNow() case utils.MetaMySQL: @@ -68,7 +68,7 @@ func TestDspDspv1(t *testing.T) { default: t.Fatal("Unknown Database type") } - if *encoding == utils.MetaGOB { + if *utils.Encoding == utils.MetaGOB { dispatcherConfigDIR += "_gob" } for _, stest := range sTestsDspDspv1 { @@ -78,7 +78,7 @@ func TestDspDspv1(t *testing.T) { func testDspITLoadConfig(t *testing.T) { var err error - dspCfgPath = path.Join(*dataDir, "conf", "samples", "dispatchers", dispatcherConfigDIR) + dspCfgPath = path.Join(*utils.DataDir, "conf", "samples", "dispatchers", dispatcherConfigDIR) if dspCfg, err = config.NewCGRConfigFromPath(dspCfgPath); err != nil { t.Error(err) } @@ -97,7 +97,7 @@ func testDspITResetStorDb(t *testing.T) { } func testDspITStartEngine(t *testing.T) { - if _, err := engine.StopStartEngine(dspCfgPath, *waitRater); err != nil { + if _, err := engine.StopStartEngine(dspCfgPath, *utils.WaitRater); err != nil { t.Fatal(err) } } @@ -117,7 +117,7 @@ func testDspITLoadData(t *testing.T) { if err != nil { t.Error(err) } - loader := exec.Command(loaderPath, "-config_path", dspCfgPath, "-path", path.Join(*dataDir, "tariffplans", "dispatchers")) + loader := exec.Command(loaderPath, "-config_path", dspCfgPath, "-path", path.Join(*utils.DataDir, "tariffplans", "dispatchers")) if err := loader.Start(); err != nil { t.Error(err) @@ -169,7 +169,7 @@ func testDspDspv1GetProfileForEvent(t *testing.T) { }, }, } - if *encoding == utils.MetaGOB { // in gob emtpty slice is encoded as nil + if *utils.Encoding == utils.MetaGOB { // in gob emtpty slice is encoded as nil expected.Hosts[0].FilterIDs = nil expected.Hosts[1].FilterIDs = nil } @@ -235,7 +235,7 @@ func testDspDspv1GetProfileForEventWithMethod(t *testing.T) { }, }, } - if *encoding == utils.MetaGOB { // in gob emtpty slice is encoded as nil + if *utils.Encoding == utils.MetaGOB { // in gob emtpty slice is encoded as nil expected.Hosts[0].FilterIDs = nil } expected.Hosts.Sort() diff --git a/apier/v1/ees_it_test.go b/apier/v1/ees_it_test.go index 2f7730cff..f5827fc85 100644 --- a/apier/v1/ees_it_test.go +++ b/apier/v1/ees_it_test.go @@ -61,7 +61,7 @@ var ( // Test start here func TestExportCDRs(t *testing.T) { - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: eeSConfigDIR = "ees_internal" case utils.MetaMySQL: @@ -91,7 +91,7 @@ func testEEsPrepareFolder(t *testing.T) { func testEEsInitCfg(t *testing.T) { var err error - eeSCfgPath = path.Join(*dataDir, "conf", "samples", eeSConfigDIR) + eeSCfgPath = path.Join(*utils.DataDir, "conf", "samples", eeSConfigDIR) eeSCfg, err = config.NewCGRConfigFromPath(eeSCfgPath) if err != nil { t.Fatal(err) @@ -113,7 +113,7 @@ func testEEsResetStorDb(t *testing.T) { // Start CGR Engine func testEEsStartEngine(t *testing.T) { - if _, err := engine.StopStartEngine(eeSCfgPath, *waitRater); err != nil { + if _, err := engine.StopStartEngine(eeSCfgPath, *utils.WaitRater); err != nil { t.Fatal(err) } } diff --git a/apier/v1/filter_indexes_health_it_test.go b/apier/v1/filter_indexes_health_it_test.go index 76d3eb6ea..98658b629 100644 --- a/apier/v1/filter_indexes_health_it_test.go +++ b/apier/v1/filter_indexes_health_it_test.go @@ -72,7 +72,7 @@ var ( // Test start here func TestFIdxHealthIT(t *testing.T) { tSv1InternalRestart = false - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: tSv1ConfDIR = "tutinternal" case utils.MetaMySQL: @@ -90,7 +90,7 @@ func TestFIdxHealthIT(t *testing.T) { } func testV1FIdxHLoadConfig(t *testing.T) { - tSv1CfgPath = path.Join(*dataDir, "conf", "samples", tSv1ConfDIR) + tSv1CfgPath = path.Join(*utils.DataDir, "conf", "samples", tSv1ConfDIR) var err error if tSv1Cfg, err = config.NewCGRConfigFromPath(tSv1CfgPath); err != nil { t.Error(err) @@ -98,7 +98,7 @@ func testV1FIdxHLoadConfig(t *testing.T) { } func testV1FIdxHdxInitDataDb(t *testing.T) { - if *dbType == utils.MetaInternal && tSv1InternalRestart { + if *utils.DBType == utils.MetaInternal && tSv1InternalRestart { testV1FIdxStopEngine(t) testV1FIdxHStartEngine(t) testV1FIdxHRpcConn(t) @@ -118,7 +118,7 @@ func testV1FIdxHResetStorDb(t *testing.T) { } func testV1FIdxHStartEngine(t *testing.T) { - if _, err := engine.StopStartEngine(tSv1CfgPath, *waitRater); err != nil { + if _, err := engine.StopStartEngine(tSv1CfgPath, *utils.WaitRater); err != nil { t.Fatal(err) } } @@ -140,7 +140,7 @@ func testV1FIdxHLoadFromFolderTutorial2(t *testing.T) { } else if reply != utils.OK { t.Error("Reply: ", reply) } - attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*dataDir, "tariffplans", "tutorial2")} + attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*utils.DataDir, "tariffplans", "tutorial2")} if err := tFIdxHRpc.Call(context.Background(), utils.APIerSv1LoadTariffPlanFromFolder, attrs, &reply); err != nil { t.Error(err) } @@ -190,7 +190,7 @@ func testV1FIdxHLoadFromFolderTutorial(t *testing.T) { } else if reply != utils.OK { t.Error("Reply: ", reply) } - attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*dataDir, "tariffplans", "tutorial")} + attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*utils.DataDir, "tariffplans", "tutorial")} if err := tFIdxHRpc.Call(context.Background(), utils.APIerSv1LoadTariffPlanFromFolder, attrs, &reply); err != nil { t.Error(err) } @@ -761,7 +761,7 @@ func testV1FIdxGetAttributesIndexesHealth(t *testing.T) { func testV1FIdxHLoadFromFolderDispatchers(t *testing.T) { var reply string - attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*dataDir, "tariffplans", "dispatchers")} + attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*utils.DataDir, "tariffplans", "dispatchers")} if err := tFIdxHRpc.Call(context.Background(), utils.APIerSv1LoadTariffPlanFromFolder, attrs, &reply); err != nil { t.Error(err) } diff --git a/apier/v1/filter_indexes_it_test.go b/apier/v1/filter_indexes_it_test.go index bc439a560..2ee738a73 100644 --- a/apier/v1/filter_indexes_it_test.go +++ b/apier/v1/filter_indexes_it_test.go @@ -119,7 +119,7 @@ var ( // Test start here func TestFIdxV1IT(t *testing.T) { tSv1InternalRestart = false - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: tSv1ConfDIR = "tutinternal" case utils.MetaMySQL: @@ -137,7 +137,7 @@ func TestFIdxV1IT(t *testing.T) { } func testV1FIdxLoadConfig(t *testing.T) { - tSv1CfgPath = path.Join(*dataDir, "conf", "samples", tSv1ConfDIR) + tSv1CfgPath = path.Join(*utils.DataDir, "conf", "samples", tSv1ConfDIR) var err error if tSv1Cfg, err = config.NewCGRConfigFromPath(tSv1CfgPath); err != nil { t.Error(err) @@ -145,7 +145,7 @@ func testV1FIdxLoadConfig(t *testing.T) { } func testV1FIdxdxInitDataDb(t *testing.T) { - if *dbType == utils.MetaInternal && tSv1InternalRestart { + if *utils.DBType == utils.MetaInternal && tSv1InternalRestart { testV1FIdxHStopEngine(t) testV1FIdxStartEngine(t) testV1FIdxRpcConn(t) @@ -172,7 +172,7 @@ func testV1FIdxResetStorDb(t *testing.T) { } func testV1FIdxStartEngine(t *testing.T) { - if _, err := engine.StopStartEngine(tSv1CfgPath, *waitRater); err != nil { + if _, err := engine.StopStartEngine(tSv1CfgPath, *utils.WaitRater); err != nil { t.Fatal(err) } } diff --git a/apier/v1/filterindexecache_it_test.go b/apier/v1/filterindexecache_it_test.go index 28180ae94..d5367fd4e 100644 --- a/apier/v1/filterindexecache_it_test.go +++ b/apier/v1/filterindexecache_it_test.go @@ -82,7 +82,7 @@ var ( // Test start here func TestFIdxCaV1IT(t *testing.T) { - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: t.SkipNow() case utils.MetaMySQL: @@ -101,7 +101,7 @@ func TestFIdxCaV1IT(t *testing.T) { func testV1FIdxCaLoadConfig(t *testing.T) { var err error - tSv1CfgPath = path.Join(*dataDir, "conf", "samples", tSv1ConfDIR) + tSv1CfgPath = path.Join(*utils.DataDir, "conf", "samples", tSv1ConfDIR) if tSv1Cfg, err = config.NewCGRConfigFromPath(tSv1CfgPath); err != nil { t.Error(err) } @@ -121,7 +121,7 @@ func testV1FIdxCaResetStorDb(t *testing.T) { } func testV1FIdxCaStartEngine(t *testing.T) { - if _, err := engine.StopStartEngine(tSv1CfgPath, *waitRater); err != nil { + if _, err := engine.StopStartEngine(tSv1CfgPath, *utils.WaitRater); err != nil { t.Fatal(err) } } @@ -136,7 +136,7 @@ func testV1FIdxCaRpcConn(t *testing.T) { func testV1FIdxCaFromFolder(t *testing.T) { var reply string - attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*dataDir, "tariffplans", "oldtutorial")} + attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*utils.DataDir, "tariffplans", "oldtutorial")} if err := tFIdxCaRpc.Call(context.Background(), utils.APIerSv1LoadTariffPlanFromFolder, attrs, &reply); err != nil { t.Error(err) } diff --git a/apier/v1/filters_it_test.go b/apier/v1/filters_it_test.go index 97e70944f..f6acf4ae2 100644 --- a/apier/v1/filters_it_test.go +++ b/apier/v1/filters_it_test.go @@ -65,7 +65,7 @@ var ( // Test start here func TestFilterIT(t *testing.T) { - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: filterConfigDIR = "tutinternal" case utils.MetaMySQL: @@ -84,7 +84,7 @@ func TestFilterIT(t *testing.T) { func testFilterInitCfg(t *testing.T) { var err error - filterCfgPath = path.Join(*dataDir, "conf", "samples", filterConfigDIR) + filterCfgPath = path.Join(*utils.DataDir, "conf", "samples", filterConfigDIR) filterCfg, err = config.NewCGRConfigFromPath(filterCfgPath) if err != nil { t.Error(err) @@ -100,7 +100,7 @@ func testFilterResetDataDB(t *testing.T) { // Start CGR Engine func testFilterStartEngine(t *testing.T) { - if _, err := engine.StopStartEngine(filterCfgPath, *waitRater); err != nil { + if _, err := engine.StopStartEngine(filterCfgPath, *utils.WaitRater); err != nil { t.Fatal(err) } } diff --git a/apier/v1/full_remote_it_test.go b/apier/v1/full_remote_it_test.go index d0a8a2c25..084214c7f 100644 --- a/apier/v1/full_remote_it_test.go +++ b/apier/v1/full_remote_it_test.go @@ -67,26 +67,26 @@ func TestFullRemoteIT(t *testing.T) { fullRemEngineOneCfgDirPath = "remote" for _, stest := range sTestsFullRemoteIT { - t.Run(*dbType, stest) + t.Run(*utils.DBType, stest) } } func testFullRemoteITInitCfg(t *testing.T) { var err error - fullRemInternalCfgPath = path.Join(*dataDir, "conf", "samples", "full_remote", fullRemInternalCfgDirPath) + fullRemInternalCfgPath = path.Join(*utils.DataDir, "conf", "samples", "full_remote", fullRemInternalCfgDirPath) fullRemInternalCfg, err = config.NewCGRConfigFromPath(fullRemInternalCfgPath) if err != nil { t.Error(err) } // prepare config for engine1 - fullRemEngineOneCfgPath = path.Join(*dataDir, "conf", "samples", + fullRemEngineOneCfgPath = path.Join(*utils.DataDir, "conf", "samples", "full_remote", fullRemEngineOneCfgDirPath) fullRemEngineOneCfg, err = config.NewCGRConfigFromPath(fullRemEngineOneCfgPath) if err != nil { t.Error(err) } - fullRemEngineOneCfg.DataFolderPath = *dataDir // Share DataFolderPath through config towards StoreDb for Flush() + fullRemEngineOneCfg.DataFolderPath = *utils.DataDir // Share DataFolderPath through config towards StoreDb for Flush() } diff --git a/apier/v1/guardian_it_test.go b/apier/v1/guardian_it_test.go index 6f24f8d50..d79b3bf08 100644 --- a/apier/v1/guardian_it_test.go +++ b/apier/v1/guardian_it_test.go @@ -37,7 +37,7 @@ import ( func TestGuardianSIT(t *testing.T) { var err error var guardianConfigDIR string - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: guardianConfigDIR = "tutinternal" case utils.MetaMySQL: @@ -49,7 +49,7 @@ func TestGuardianSIT(t *testing.T) { default: t.Fatal("Unknown Database type") } - guardianCfgPath := path.Join(*dataDir, "conf", "samples", guardianConfigDIR) + guardianCfgPath := path.Join(*utils.DataDir, "conf", "samples", guardianConfigDIR) guardianCfg, err := config.NewCGRConfigFromPath(guardianCfgPath) if err != nil { t.Error(err) @@ -64,7 +64,7 @@ func TestGuardianSIT(t *testing.T) { } // start engine - if _, err = engine.StopStartEngine(guardianCfgPath, *waitRater); err != nil { + if _, err = engine.StopStartEngine(guardianCfgPath, *utils.WaitRater); err != nil { t.Fatal(err) } diff --git a/apier/v1/lib_test.go b/apier/v1/lib_test.go index 21e3f57ec..140c7248b 100644 --- a/apier/v1/lib_test.go +++ b/apier/v1/lib_test.go @@ -20,7 +20,6 @@ package v1 import ( "errors" - "flag" "github.com/cgrates/birpc" "github.com/cgrates/birpc/jsonrpc" @@ -28,15 +27,8 @@ import ( "github.com/cgrates/cgrates/utils" ) -var ( - dataDir = flag.String("data_dir", "/usr/share/cgrates", "CGR data dir path here") - waitRater = flag.Int("wait_rater", 100, "Number of miliseconds to wait for rater to start and cache") - encoding = flag.String("rpc", utils.MetaJSON, "what encoding whould be uused for rpc comunication") - dbType = flag.String("dbtype", utils.MetaInternal, "The type of DataBase (Internal/Mongo/mySql)") -) - func newRPCClient(cfg *config.ListenCfg) (c *birpc.Client, err error) { - switch *encoding { + switch *utils.Encoding { case utils.MetaJSON: return jsonrpc.Dial(utils.TCP, cfg.RPCJSONListen) case utils.MetaGOB: diff --git a/apier/v1/precache_it_test.go b/apier/v1/precache_it_test.go index 531fd35d8..d53862b5c 100644 --- a/apier/v1/precache_it_test.go +++ b/apier/v1/precache_it_test.go @@ -62,7 +62,7 @@ var ( // this tests may fail because of apiban limit( 5 requests per 2 minutes for an APIKey) // if needed add more APIKeys func TestPrecacheIT(t *testing.T) { - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: t.SkipNow() case utils.MetaMySQL: @@ -84,7 +84,7 @@ func TestPrecacheIT(t *testing.T) { func testPrecacheInitCfg(t *testing.T) { var err error - precacheCfgPath = path.Join(*dataDir, "conf", "samples", "precache", precacheConfigDIR) + precacheCfgPath = path.Join(*utils.DataDir, "conf", "samples", "precache", precacheConfigDIR) precacheCfg, err = config.NewCGRConfigFromPath(precacheCfgPath) if err != nil { t.Error(err) @@ -98,7 +98,7 @@ func testPrecacheResetDataDB(t *testing.T) { } func testPrecacheStartEngine(t *testing.T) { - if _, err := engine.StopStartEngine(precacheCfgPath, *waitRater); err != nil { + if _, err := engine.StopStartEngine(precacheCfgPath, *utils.WaitRater); err != nil { t.Fatal(err) } } @@ -138,7 +138,7 @@ func testPrecacheGetCacheStatsBeforeLoad(t *testing.T) { func testPrecacheFromFolder(t *testing.T) { var reply string - attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*dataDir, "tariffplans", "precache")} + attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*utils.DataDir, "tariffplans", "precache")} if err := precacheRPC.Call(context.Background(), utils.APIerSv1LoadTariffPlanFromFolder, attrs, &reply); err != nil { t.Error(err) } @@ -146,7 +146,7 @@ func testPrecacheFromFolder(t *testing.T) { } func testPrecacheRestartEngine(t *testing.T) { - if _, err := engine.StopStartEngine(precacheCfgPath, *waitRater); err != nil { + if _, err := engine.StopStartEngine(precacheCfgPath, *utils.WaitRater); err != nil { t.Fatal(err) } var err error @@ -240,7 +240,7 @@ func testPrecacheGetCacheStatsAfterRestart(t *testing.T) { } func testPrecacheKillEngine(t *testing.T) { - if err := engine.KillEngine(*waitRater); err != nil { + if err := engine.KillEngine(*utils.WaitRater); err != nil { t.Error(err) } } diff --git a/apier/v1/preload_it_test.go b/apier/v1/preload_it_test.go index 7c9bfb068..4639eafc4 100644 --- a/apier/v1/preload_it_test.go +++ b/apier/v1/preload_it_test.go @@ -81,7 +81,7 @@ func testCreateDirs(t *testing.T) { func testPreloadITInitConfig(t *testing.T) { var err error - preloadCfgPath = path.Join(*dataDir, "conf", "samples", "loaders", preloadCfgDIR) + preloadCfgPath = path.Join(*utils.DataDir, "conf", "samples", "loaders", preloadCfgDIR) if preloadCfg, err = config.NewCGRConfigFromPath(preloadCfgPath); err != nil { t.Fatal("Got config error: ", err.Error()) } @@ -173,7 +173,7 @@ func testCleanupFiles(t *testing.T) { } func testPreloadITKillEngine(t *testing.T) { - if err := engine.KillEngine(*waitRater); err != nil { + if err := engine.KillEngine(*utils.WaitRater); err != nil { t.Error(err) } } diff --git a/apier/v1/rating_profile_late_it_test.go b/apier/v1/rating_profile_late_it_test.go index f54a26380..b5fc5f3be 100644 --- a/apier/v1/rating_profile_late_it_test.go +++ b/apier/v1/rating_profile_late_it_test.go @@ -54,7 +54,7 @@ var ( // Test start here func TestRPLateIT2(t *testing.T) { // no need for a new config with *gob transport in this case - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: rpLateConfigDIR = "processcdrs_late_internal" case utils.MetaMySQL: @@ -73,7 +73,7 @@ func TestRPLateIT2(t *testing.T) { func testRpLateInitCfg(t *testing.T) { var err error - rpLateCfGPath = path.Join(*dataDir, "conf", "samples", rpLateConfigDIR) + rpLateCfGPath = path.Join(*utils.DataDir, "conf", "samples", rpLateConfigDIR) rpLateCfg, err = config.NewCGRConfigFromPath(rpLateCfGPath) if err != nil { t.Error(err) @@ -95,7 +95,7 @@ func testRpLateResetStorDb(t *testing.T) { // Start CGR Engine func testRpLateStartEngine(t *testing.T) { - if _, err := engine.StopStartEngine(rpLateCfGPath, *waitRater); err != nil { + if _, err := engine.StopStartEngine(rpLateCfGPath, *utils.WaitRater); err != nil { t.Fatal(err) } } @@ -111,7 +111,7 @@ func testRpLateRPCConn(t *testing.T) { func testRpLateLoadFromFolder(t *testing.T) { var reply string - attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*dataDir, "tariffplans", "tutorial")} + attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*utils.DataDir, "tariffplans", "tutorial")} if err := rpLateRPC.Call(context.Background(), utils.APIerSv1LoadTariffPlanFromFolder, attrs, &reply); err != nil { t.Error(err) } @@ -161,7 +161,7 @@ func testRpLateCDRProcessEvent(t *testing.T) { } func testRpLateKillEngine(t *testing.T) { - if err := engine.KillEngine(*waitRater); err != nil { + if err := engine.KillEngine(*utils.WaitRater); err != nil { t.Error(err) } } diff --git a/apier/v1/remote_it_test.go b/apier/v1/remote_it_test.go index b5d4e08e3..2ecf5ccbe 100644 --- a/apier/v1/remote_it_test.go +++ b/apier/v1/remote_it_test.go @@ -88,7 +88,7 @@ var ( func TestInternalRemoteIT(t *testing.T) { internalCfgDirPath = "internal" - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: t.SkipNow() case utils.MetaMySQL: @@ -102,39 +102,39 @@ func TestInternalRemoteIT(t *testing.T) { default: t.Fatal("Unknown Database type") } - if *encoding == utils.MetaGOB { + if *utils.Encoding == utils.MetaGOB { internalCfgDirPath += "_gob" } for _, stest := range sTestsInternalRemoteIT { - t.Run(*dbType, stest) + t.Run(*utils.DBType, stest) } } func testInternalRemoteITInitCfg(t *testing.T) { var err error - internalCfgPath = path.Join(*dataDir, "conf", "samples", "remote_replication", internalCfgDirPath) + internalCfgPath = path.Join(*utils.DataDir, "conf", "samples", "remote_replication", internalCfgDirPath) internalCfg, err = config.NewCGRConfigFromPath(internalCfgPath) if err != nil { t.Error(err) } // prepare config for engine1 - engineOneCfgPath = path.Join(*dataDir, "conf", "samples", + engineOneCfgPath = path.Join(*utils.DataDir, "conf", "samples", "remote_replication", engineOneCfgDirPath) engineOneCfg, err = config.NewCGRConfigFromPath(engineOneCfgPath) if err != nil { t.Error(err) } - engineOneCfg.DataFolderPath = *dataDir // Share DataFolderPath through config towards StoreDb for Flush() + engineOneCfg.DataFolderPath = *utils.DataDir // Share DataFolderPath through config towards StoreDb for Flush() // prepare config for engine2 - engineTwoCfgPath = path.Join(*dataDir, "conf", "samples", + engineTwoCfgPath = path.Join(*utils.DataDir, "conf", "samples", "remote_replication", engineTwoCfgDirPath) engineTwoCfg, err = config.NewCGRConfigFromPath(engineTwoCfgPath) if err != nil { t.Error(err) } - engineTwoCfg.DataFolderPath = *dataDir // Share DataFolderPath through config towards StoreDb for Flush() + engineTwoCfg.DataFolderPath = *utils.DataDir // Share DataFolderPath through config towards StoreDb for Flush() } @@ -180,7 +180,7 @@ func testInternalRemoteITRPCConn(t *testing.T) { func testInternalRemoteLoadDataInEngineTwo(t *testing.T) { var reply string - attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*dataDir, "tariffplans", "tutorial")} + attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*utils.DataDir, "tariffplans", "tutorial")} if err := engineTwoRPC.Call(context.Background(), utils.APIerSv1LoadTariffPlanFromFolder, attrs, &reply); err != nil { t.Error(err) } @@ -253,7 +253,7 @@ func testInternalRemoteITGetAttribute(t *testing.T) { utils.TenantIDWithAPIOpts{TenantID: &utils.TenantID{Tenant: "cgrates.org", ID: "ATTR_1001_SIMPLEAUTH"}}, &reply); err != nil { t.Fatal(err) } - if *encoding == utils.MetaGOB { // in gob empty slice is encoded as nil + if *utils.Encoding == utils.MetaGOB { // in gob empty slice is encoded as nil alsPrf.AttributeProfile.Attributes[0].FilterIDs = nil } reply.Compile() @@ -445,7 +445,7 @@ func testInternalRemoteITGetRoute(t *testing.T) { }}, Weight: 20, } - if *encoding == utils.MetaGOB { // in gob emtpty slice is encoded as nil + if *utils.Encoding == utils.MetaGOB { // in gob emtpty slice is encoded as nil routePrf.SortingParameters = nil routePrf2.SortingParameters = nil } @@ -588,7 +588,7 @@ func testInternalRemoteITGetChargerProfile(t *testing.T) { AttributeIDs: []string{utils.MetaNone}, Weight: 0, } - if *encoding == utils.MetaGOB { + if *utils.Encoding == utils.MetaGOB { chargerProfile.FilterIDs = nil } var reply *engine.ChargerProfile diff --git a/apier/v1/replicate_it_test.go b/apier/v1/replicate_it_test.go index 394bb5ee8..1fe350fc9 100644 --- a/apier/v1/replicate_it_test.go +++ b/apier/v1/replicate_it_test.go @@ -64,7 +64,7 @@ var ( func TestInternalReplicateIT(t *testing.T) { internalCfgDirPath = "internal" - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: t.SkipNow() case utils.MetaMySQL: @@ -78,31 +78,31 @@ func TestInternalReplicateIT(t *testing.T) { default: t.Fatal("Unknown Database type") } - if *encoding == utils.MetaGOB { + if *utils.Encoding == utils.MetaGOB { internalCfgDirPath += "_gob" } for _, stest := range sTestsInternalReplicateIT { - t.Run(*dbType, stest) + t.Run(*utils.DBType, stest) } } func testInternalReplicateITInitCfg(t *testing.T) { var err error - internalCfgPath = path.Join(*dataDir, "conf", "samples", "replication", internalCfgDirPath) + internalCfgPath = path.Join(*utils.DataDir, "conf", "samples", "replication", internalCfgDirPath) internalCfg, err = config.NewCGRConfigFromPath(internalCfgPath) if err != nil { t.Error(err) } // prepare config for engine1 - engineOneCfgPath = path.Join(*dataDir, "conf", "samples", "replication", engineOneCfgDirPath) + engineOneCfgPath = path.Join(*utils.DataDir, "conf", "samples", "replication", engineOneCfgDirPath) engineOneCfg, err = config.NewCGRConfigFromPath(engineOneCfgPath) if err != nil { t.Error(err) } // prepare config for engine2 - engineTwoCfgPath = path.Join(*dataDir, "conf", "samples", "replication", engineTwoCfgDirPath) + engineTwoCfgPath = path.Join(*utils.DataDir, "conf", "samples", "replication", engineTwoCfgDirPath) engineTwoCfg, err = config.NewCGRConfigFromPath(engineTwoCfgPath) if err != nil { t.Error(err) @@ -148,7 +148,7 @@ func testInternalReplicateITRPCConn(t *testing.T) { func testInternalReplicateLoadDataInInternalEngine(t *testing.T) { var reply string - attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*dataDir, "tariffplans", "tutorial")} + attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*utils.DataDir, "tariffplans", "tutorial")} if err := internalRPC.Call(context.Background(), utils.APIerSv1LoadTariffPlanFromFolder, attrs, &reply); err != nil { t.Error(err) } @@ -1060,7 +1060,7 @@ func testInternalReplicateITThresholdProfile(t *testing.T) { } func testInternalReplicateITSetAccount(t *testing.T) { - if *encoding == utils.MetaGOB { + if *utils.Encoding == utils.MetaGOB { t.SkipNow() // skip this function because // APIerSv1GetAccount returns the old format of Account // and it can not register that interface because is duplicate diff --git a/apier/v1/resourcesv1_it_test.go b/apier/v1/resourcesv1_it_test.go index b5d47c864..3dc87b945 100644 --- a/apier/v1/resourcesv1_it_test.go +++ b/apier/v1/resourcesv1_it_test.go @@ -108,7 +108,7 @@ var ( // Test start here func TestRsV1IT(t *testing.T) { - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: rlsV1ConfDIR = "tutinternal" sTestsRLSV1 = sTestsRLSV1[:len(sTestsRLSV1)-24] @@ -128,7 +128,7 @@ func TestRsV1IT(t *testing.T) { func testV1RsLoadConfig(t *testing.T) { var err error - rlsV1CfgPath = path.Join(*dataDir, "conf", "samples", rlsV1ConfDIR) + rlsV1CfgPath = path.Join(*utils.DataDir, "conf", "samples", rlsV1ConfDIR) if rlsV1Cfg, err = config.NewCGRConfigFromPath(rlsV1CfgPath); err != nil { t.Error(err) } @@ -148,7 +148,7 @@ func testV1RsResetStorDb(t *testing.T) { } func testV1RsStartEngine(t *testing.T) { - if _, err := engine.StopStartEngine(rlsV1CfgPath, *waitRater); err != nil { + if _, err := engine.StopStartEngine(rlsV1CfgPath, *utils.WaitRater); err != nil { t.Fatal(err) } } @@ -235,7 +235,7 @@ func testV1RsCacheResourceWithConfig(t *testing.T) { func testV1RsFromFolder(t *testing.T) { var reply string - attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*dataDir, "tariffplans", "oldtutorial")} + attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*utils.DataDir, "tariffplans", "oldtutorial")} if err := rlsV1Rpc.Call(context.Background(), utils.APIerSv1LoadTariffPlanFromFolder, attrs, &reply); err != nil { t.Error(err) } @@ -734,7 +734,7 @@ func testV1RsDBStore(t *testing.T) { } } } - if _, err := engine.StopStartEngine(rlsV1CfgPath, *waitRater); err != nil { + if _, err := engine.StopStartEngine(rlsV1CfgPath, *utils.WaitRater); err != nil { t.Fatal(err) } var err error @@ -1007,7 +1007,7 @@ func testV1RsAllocateUnlimited(t *testing.T) { } func testV1RsStopEngine(t *testing.T) { - if err := engine.KillEngine(*waitRater); err != nil { + if err := engine.KillEngine(*utils.WaitRater); err != nil { t.Error(err) } } diff --git a/apier/v1/routes_it_test.go b/apier/v1/routes_it_test.go index 99ccc3ee2..5973127dd 100644 --- a/apier/v1/routes_it_test.go +++ b/apier/v1/routes_it_test.go @@ -98,7 +98,7 @@ var ( // Test start here func TestRouteSV1IT(t *testing.T) { sTestsRouteCacheSV1 := sTestsRouteSV1 - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: routeSv1ConfDIR = "tutinternal" sTestsRouteCacheSV1 = sTestsRouteCacheSV1[:len(sTestsRouteCacheSV1)-10] @@ -118,7 +118,7 @@ func TestRouteSV1IT(t *testing.T) { func testV1RouteLoadConfig(t *testing.T) { var err error - routeSv1CfgPath = path.Join(*dataDir, "conf", "samples", routeSv1ConfDIR) + routeSv1CfgPath = path.Join(*utils.DataDir, "conf", "samples", routeSv1ConfDIR) if routeSv1Cfg, err = config.NewCGRConfigFromPath(routeSv1CfgPath); err != nil { t.Error(err) } @@ -145,7 +145,7 @@ func testV1RouteResetStorDb(t *testing.T) { } func testV1RouteStartEngine(t *testing.T) { - if _, err := engine.StopStartEngine(routeSv1CfgPath, *waitRater); err != nil { + if _, err := engine.StopStartEngine(routeSv1CfgPath, *utils.WaitRater); err != nil { t.Fatal(err) } } @@ -171,7 +171,7 @@ func testV1RouteGetBeforeDataLoad(t *testing.T) { func testV1RouteFromFolder(t *testing.T) { var reply string - attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*dataDir, "tariffplans", "testit")} + attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*utils.DataDir, "tariffplans", "testit")} if err := routeSv1Rpc.Call(context.Background(), utils.APIerSv1LoadTariffPlanFromFolder, attrs, &reply); err != nil { t.Error(err) } @@ -1052,7 +1052,7 @@ func testV1RouteGetRouteForEvent(t *testing.T) { }, Weight: 50, } - if *encoding == utils.MetaGOB { // in gob emtpty slice is encoded as nil + if *utils.Encoding == utils.MetaGOB { // in gob emtpty slice is encoded as nil expected.SortingParameters = nil } var supProf []*engine.RouteProfile @@ -1376,7 +1376,7 @@ func testV1RouteAccountWithRatingPlan(t *testing.T) { }, }, }} - if *encoding == utils.MetaGOB { + if *utils.Encoding == utils.MetaGOB { (*eSpls)[0].Routes = []*engine.SortedRoute{ { RouteID: "RouteWithAccAndRP", @@ -1445,7 +1445,7 @@ func testV1RouteAccountWithRatingPlan(t *testing.T) { }, }, }} - if *encoding == utils.MetaGOB { + if *utils.Encoding == utils.MetaGOB { (*eSpls)[0].Routes = []*engine.SortedRoute{ { RouteID: "RouteWithAccAndRP", @@ -1515,7 +1515,7 @@ func testV1RouteAccountWithRatingPlan(t *testing.T) { }, }, }} - if *encoding == utils.MetaGOB { + if *utils.Encoding == utils.MetaGOB { (*eSpls)[0].Routes = []*engine.SortedRoute{ { RouteID: "RouteWithRP", diff --git a/apier/v1/schedulers_it_test.go b/apier/v1/schedulers_it_test.go index 6c2aa5fc6..047d2dbe2 100644 --- a/apier/v1/schedulers_it_test.go +++ b/apier/v1/schedulers_it_test.go @@ -57,7 +57,7 @@ var sTestsSchedFiltered = []func(t *testing.T){ // TestSchedWithoutFilters will execute action for all accounts func TestSchedWithoutFilters(t *testing.T) { - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: schedConfDIR = "tutinternal" case utils.MetaMySQL: @@ -77,7 +77,7 @@ func TestSchedWithoutFilters(t *testing.T) { // TestSchedWithFiltersSingleAccount will execute actions only for account 1001 func TestSchedWithFiltersSingleAccount(t *testing.T) { - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: schedConfDIR = "filtered_scheduler_internal" case utils.MetaMySQL: @@ -96,7 +96,7 @@ func TestSchedWithFiltersSingleAccount(t *testing.T) { // TestSchedWithFilters2 will execute actions for accounts 1002 and 1003 ( 1001 will be skiped ) func TestSchedWithFilters2(t *testing.T) { - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: schedConfDIR = "filtered_scheduler2_internal" case utils.MetaMySQL: @@ -115,7 +115,7 @@ func TestSchedWithFilters2(t *testing.T) { func testSchedLoadConfig(t *testing.T) { var err error - schedCfgPath = path.Join(*dataDir, "conf", "samples", schedConfDIR) + schedCfgPath = path.Join(*utils.DataDir, "conf", "samples", schedConfDIR) if schedCfg, err = config.NewCGRConfigFromPath(schedCfgPath); err != nil { t.Error(err) } @@ -134,7 +134,7 @@ func testSchedResetStorDb(t *testing.T) { } func testSchedStartEngine(t *testing.T) { - if _, err := engine.StopStartEngine(schedCfgPath, *waitRater); err != nil { + if _, err := engine.StopStartEngine(schedCfgPath, *utils.WaitRater); err != nil { t.Fatal(err) } } @@ -149,7 +149,7 @@ func testSchedRpcConn(t *testing.T) { func testSchedFromFolder(t *testing.T) { var reply string - attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*dataDir, "tariffplans", "tutorial")} + attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*utils.DataDir, "tariffplans", "tutorial")} if err := schedRpc.Call(context.Background(), utils.APIerSv1LoadTariffPlanFromFolder, attrs, &reply); err != nil { t.Error(err) } @@ -328,7 +328,7 @@ func testSchedExecuteAction(t *testing.T) { } func testSchedStopEngine(t *testing.T) { - if err := engine.KillEngine(*waitRater); err != nil { + if err := engine.KillEngine(*utils.WaitRater); err != nil { t.Error(err) } } diff --git a/apier/v1/sessions_process_event_it_test.go b/apier/v1/sessions_process_event_it_test.go index 4a354469f..add9fc1cd 100644 --- a/apier/v1/sessions_process_event_it_test.go +++ b/apier/v1/sessions_process_event_it_test.go @@ -66,7 +66,7 @@ var sTestSessionSv1ProcessEvent = []func(t *testing.T){ } func TestSSv1ItProcessEventWithPrepaid(t *testing.T) { - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: sessionsConfDIR = "sessions_internal" case utils.MetaMySQL: @@ -86,7 +86,7 @@ func TestSSv1ItProcessEventWithPrepaid(t *testing.T) { } func TestSSv1ItProcessEventWithPostPaid(t *testing.T) { - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: sessionsConfDIR = "sessions_internal" case utils.MetaMySQL: @@ -107,7 +107,7 @@ func TestSSv1ItProcessEventWithPostPaid(t *testing.T) { } func TestSSv1ItProcessEventWithRated(t *testing.T) { - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: sessionsConfDIR = "sessions_internal" case utils.MetaMySQL: @@ -128,7 +128,7 @@ func TestSSv1ItProcessEventWithRated(t *testing.T) { } func TestSSv1ItProcessEventWithPseudoPrepaid(t *testing.T) { - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: sessionsConfDIR = "sessions_internal" case utils.MetaMySQL: @@ -149,7 +149,7 @@ func TestSSv1ItProcessEventWithPseudoPrepaid(t *testing.T) { func testSSv1ItInitCfg(t *testing.T) { var err error - sSv1CfgPath = path.Join(*dataDir, "conf", "samples", sessionsConfDIR) + sSv1CfgPath = path.Join(*utils.DataDir, "conf", "samples", sessionsConfDIR) // Init config first sSv1Cfg, err = config.NewCGRConfigFromPath(sSv1CfgPath) if err != nil { diff --git a/apier/v1/sessions_thresholds_it_test.go b/apier/v1/sessions_thresholds_it_test.go index bc50fc5fe..0915f87dc 100644 --- a/apier/v1/sessions_thresholds_it_test.go +++ b/apier/v1/sessions_thresholds_it_test.go @@ -65,7 +65,7 @@ var ( ) func TestSessionSITtests(t *testing.T) { - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: sessionsConfDIR = "sessions_internal" case utils.MetaMySQL: @@ -94,7 +94,7 @@ func (*smock2) DisconnectSession(ctx *context.Context, func testSessionSv1ItInitCfg(t *testing.T) { var err error - sSv1CfgPath2 = path.Join(*dataDir, "conf", "samples", sessionsConfDIR) + sSv1CfgPath2 = path.Join(*utils.DataDir, "conf", "samples", sessionsConfDIR) // Init config first sSv1Cfg2, err = config.NewCGRConfigFromPath(sSv1CfgPath2) if err != nil { @@ -143,7 +143,7 @@ func testSessionSv1ItRpcConn(t *testing.T) { // Load the tariff plan, creating accounts and their balances func testSessionSv1ItTPFromFolder(t *testing.T) { attrs := &utils.AttrLoadTpFromFolder{ - FolderPath: path.Join(*dataDir, "tariffplans", "testit")} + FolderPath: path.Join(*utils.DataDir, "tariffplans", "testit")} var loadInst utils.LoadInstance if err := sSApierRpc2.Call(context.Background(), utils.APIerSv2LoadTariffPlanFromFolder, attrs, &loadInst); err != nil { t.Error(err) diff --git a/apier/v1/sessionsv1_it_test.go b/apier/v1/sessionsv1_it_test.go index 32977e6d1..d3951eaee 100644 --- a/apier/v1/sessionsv1_it_test.go +++ b/apier/v1/sessionsv1_it_test.go @@ -73,7 +73,7 @@ var ( ) func testSSv1ItInitCfgDir(t *testing.T) { - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: sessionsConfDIR = "sessions_internal" case utils.MetaMySQL: @@ -104,7 +104,7 @@ func (*smock) GetActiveSessionIDs(ctx *context.Context, } func TestSSv1ItWithPrepaid(t *testing.T) { - if *dbType == utils.MetaPostgres { + if *utils.DBType == utils.MetaPostgres { t.SkipNow() } sSV1RequestType = utils.MetaPrepaid @@ -114,7 +114,7 @@ func TestSSv1ItWithPrepaid(t *testing.T) { } func TestSSv1ItWithPostPaid(t *testing.T) { - if *dbType == utils.MetaPostgres { + if *utils.DBType == utils.MetaPostgres { t.SkipNow() } sSV1RequestType = utils.MetaPostpaid @@ -124,7 +124,7 @@ func TestSSv1ItWithPostPaid(t *testing.T) { } func TestSSv1ItWithRated(t *testing.T) { - if *dbType == utils.MetaPostgres { + if *utils.DBType == utils.MetaPostgres { t.SkipNow() } sSV1RequestType = utils.MetaRated @@ -134,7 +134,7 @@ func TestSSv1ItWithRated(t *testing.T) { } func TestSSv1ItWithPseudoPrepaid(t *testing.T) { - if *dbType == utils.MetaPostgres { + if *utils.DBType == utils.MetaPostgres { t.SkipNow() } sSV1RequestType = utils.MetaPseudoPrepaid @@ -193,7 +193,7 @@ func testSSv1ItPing(t *testing.T) { // Load the tariff plan, creating accounts and their balances func testSSv1ItTPFromFolder(t *testing.T) { attrs := &utils.AttrLoadTpFromFolder{ - FolderPath: path.Join(*dataDir, "tariffplans", "testit")} + FolderPath: path.Join(*utils.DataDir, "tariffplans", "testit")} var loadInst utils.LoadInstance if err := sSApierRpc.Call(context.Background(), utils.APIerSv2LoadTariffPlanFromFolder, attrs, &loadInst); err != nil { diff --git a/apier/v1/stats_it_test.go b/apier/v1/stats_it_test.go index 056ea7e14..b1917f42c 100644 --- a/apier/v1/stats_it_test.go +++ b/apier/v1/stats_it_test.go @@ -124,7 +124,7 @@ func init() { // Test start here func TestSTSV1IT(t *testing.T) { - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: stsV1ConfDIR = "tutinternal" sTestsStatSV1 = sTestsStatSV1[:len(sTestsStatSV1)-15] @@ -145,7 +145,7 @@ func TestSTSV1IT(t *testing.T) { func testV1STSLoadConfig(t *testing.T) { var err error - stsV1CfgPath = path.Join(*dataDir, "conf", "samples", stsV1ConfDIR) + stsV1CfgPath = path.Join(*utils.DataDir, "conf", "samples", stsV1ConfDIR) if stsV1Cfg, err = config.NewCGRConfigFromPath(stsV1CfgPath); err != nil { t.Error(err) } @@ -158,7 +158,7 @@ func testV1STSInitDataDb(t *testing.T) { } func testV1STSStartEngine(t *testing.T) { - if _, err := engine.StopStartEngine(stsV1CfgPath, *waitRater); err != nil { + if _, err := engine.StopStartEngine(stsV1CfgPath, *utils.WaitRater); err != nil { t.Fatal(err) } } @@ -196,7 +196,7 @@ func testV1STSCacheQueueAfterLoad(t *testing.T) { // the APIerSv1LoadTariffPlanF func testV1STSFromFolder(t *testing.T) { var reply string - attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*dataDir, "tariffplans", "oldtutorial")} + attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*utils.DataDir, "tariffplans", "oldtutorial")} if err := stsV1Rpc.Call(context.Background(), utils.APIerSv1LoadTariffPlanFromFolder, attrs, &reply); err != nil { t.Error(err) } @@ -425,7 +425,7 @@ func testV1STSGetStatsAfterRestart(t *testing.T) { t.SkipNow() } // time.Sleep(time.Second) - if _, err := engine.StopStartEngine(stsV1CfgPath, *waitRater); err != nil { + if _, err := engine.StopStartEngine(stsV1CfgPath, *utils.WaitRater); err != nil { t.Fatal(err) } var err error @@ -1363,7 +1363,7 @@ func testV1STSProcessStatWithThreshold2(t *testing.T) { } func testV1STSStopEngine(t *testing.T) { - if err := engine.KillEngine(*waitRater); err != nil { + if err := engine.KillEngine(*utils.WaitRater); err != nil { t.Error(err) } } @@ -1692,7 +1692,7 @@ func testV1STSGetStatQueueWithoutExpired(t *testing.T) { } func testV1STSGetStatQueueWithoutStored(t *testing.T) { - if *dbType == utils.MetaInternal { + if *utils.DBType == utils.MetaInternal { t.SkipNow() } var result string diff --git a/apier/v1/thresholds_it_test.go b/apier/v1/thresholds_it_test.go index ea5e44dc6..5005009c8 100644 --- a/apier/v1/thresholds_it_test.go +++ b/apier/v1/thresholds_it_test.go @@ -236,7 +236,7 @@ var ( // Test start here func TestTSV1IT(t *testing.T) { sTestsThresholdCacheSV1 := sTestsThresholdSV1 - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: tSv1ConfDIR = "tutinternal" sTestsThresholdCacheSV1 = sTestsThresholdCacheSV1[:len(sTestsThresholdCacheSV1)-10] @@ -257,7 +257,7 @@ func TestTSV1IT(t *testing.T) { func testV1TSLoadConfig(t *testing.T) { var err error - tSv1CfgPath = path.Join(*dataDir, "conf", "samples", tSv1ConfDIR) + tSv1CfgPath = path.Join(*utils.DataDir, "conf", "samples", tSv1ConfDIR) if tSv1Cfg, err = config.NewCGRConfigFromPath(tSv1CfgPath); err != nil { t.Error(err) } @@ -277,7 +277,7 @@ func testV1TSResetStorDb(t *testing.T) { } func testV1TSStartEngine(t *testing.T) { - if _, err := engine.StopStartEngine(tSv1CfgPath, *waitRater); err != nil { + if _, err := engine.StopStartEngine(tSv1CfgPath, *utils.WaitRater); err != nil { t.Fatal(err) } } @@ -322,7 +322,7 @@ func testV1TSCacheThresholdAfterLoad(t *testing.T) { // the APIerSv1LoadTariffPl } func testV1TSFromFolder(t *testing.T) { var reply string - attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*dataDir, "tariffplans", "oldtutorial")} + attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*utils.DataDir, "tariffplans", "oldtutorial")} if err := tSv1Rpc.Call(context.Background(), utils.APIerSv1LoadTariffPlanFromFolder, attrs, &reply); err != nil { t.Error(err) } @@ -434,7 +434,7 @@ func testV1TSGetThresholdsAfterRestart(t *testing.T) { t.SkipNow() } // time.Sleep(time.Second) - if _, err := engine.StopStartEngine(tSv1CfgPath, *waitRater); err != nil { + if _, err := engine.StopStartEngine(tSv1CfgPath, *utils.WaitRater); err != nil { t.Fatal(err) } var err error @@ -761,7 +761,7 @@ func testV1TSUpdateSnooze(t *testing.T) { } func testV1TSStopEngine(t *testing.T) { - if err := engine.KillEngine(*waitRater); err != nil { + if err := engine.KillEngine(*utils.WaitRater); err != nil { t.Error(err) } } diff --git a/apier/v1/timing_it_test.go b/apier/v1/timing_it_test.go index a9153422d..8631efd15 100644 --- a/apier/v1/timing_it_test.go +++ b/apier/v1/timing_it_test.go @@ -57,7 +57,7 @@ var ( // Tests start here func TestTimingIT(t *testing.T) { timingTests := sTestsTiming - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: timConfigDIR = "tutinternal" case utils.MetaMySQL: @@ -76,7 +76,7 @@ func TestTimingIT(t *testing.T) { func testTimingInitCfg(t *testing.T) { var err error - timCfgPath = path.Join(*dataDir, "conf", "samples", timConfigDIR) + timCfgPath = path.Join(*utils.DataDir, "conf", "samples", timConfigDIR) timCfg, err = config.NewCGRConfigFromPath(timCfgPath) if err != nil { t.Error(err) @@ -98,7 +98,7 @@ func testTimingResetStorDb(t *testing.T) { // Start CGR Engine func testTimingStartEngine(t *testing.T) { - if _, err := engine.StopStartEngine(timCfgPath, *waitRater); err != nil { + if _, err := engine.StopStartEngine(timCfgPath, *utils.WaitRater); err != nil { t.Fatal(err) } } diff --git a/apier/v1/tp_it_test.go b/apier/v1/tp_it_test.go index 372b20ce9..f1ea806e5 100644 --- a/apier/v1/tp_it_test.go +++ b/apier/v1/tp_it_test.go @@ -55,7 +55,7 @@ var ( // Test start here func TestTPIT(t *testing.T) { - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: tpConfigDIR = "tutinternal" case utils.MetaMySQL: @@ -75,7 +75,7 @@ func TestTPIT(t *testing.T) { func testTPInitCfg(t *testing.T) { var err error - tpCfgPath = path.Join(*dataDir, "conf", "samples", tpConfigDIR) + tpCfgPath = path.Join(*utils.DataDir, "conf", "samples", tpConfigDIR) tpCfg, err = config.NewCGRConfigFromPath(tpCfgPath) if err != nil { t.Error(err) @@ -91,7 +91,7 @@ func testTPResetStorDb(t *testing.T) { // Start CGR Engine func testTPStartEngine(t *testing.T) { - if _, err := engine.StopStartEngine(tpCfgPath, *waitRater); err != nil { + if _, err := engine.StopStartEngine(tpCfgPath, *utils.WaitRater); err != nil { t.Fatal(err) } } @@ -109,7 +109,7 @@ func testTPImportTPFromFolderPath(t *testing.T) { var reply string if err := tpRPC.Call(context.Background(), utils.APIerSv1ImportTariffPlanFromFolder, utils.AttrImportTPFromFolder{TPid: "TEST_TPID2", - FolderPath: path.Join(*dataDir, "tariffplans", "tutorial")}, &reply); err != nil { + FolderPath: path.Join(*utils.DataDir, "tariffplans", "tutorial")}, &reply); err != nil { t.Error("Got error on APIerSv1.ImportTarrifPlanFromFolder: ", err.Error()) } else if reply != utils.OK { t.Error("Calling APIerSv1.ImportTarrifPlanFromFolder got reply: ", reply) @@ -154,7 +154,7 @@ func testTPExportTPToFolderWithError(t *testing.T) { } func testTPKillEngine(t *testing.T) { - if err := engine.KillEngine(*waitRater); err != nil { + if err := engine.KillEngine(*utils.WaitRater); err != nil { t.Error(err) } } diff --git a/apier/v1/tpaccountactions_it_test.go b/apier/v1/tpaccountactions_it_test.go index a4adba180..99a427d1d 100644 --- a/apier/v1/tpaccountactions_it_test.go +++ b/apier/v1/tpaccountactions_it_test.go @@ -64,7 +64,7 @@ var sTestsTPAccActions = []func(t *testing.T){ // Test start here func TestTPAccActionsIT(t *testing.T) { - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: tpAccActionsConfigDIR = "tutinternal" case utils.MetaMySQL: @@ -83,7 +83,7 @@ func TestTPAccActionsIT(t *testing.T) { func testTPAccActionsInitCfg(t *testing.T) { var err error - tpAccActionsCfgPath = path.Join(*dataDir, "conf", "samples", tpAccActionsConfigDIR) + tpAccActionsCfgPath = path.Join(*utils.DataDir, "conf", "samples", tpAccActionsConfigDIR) tpAccActionsCfg, err = config.NewCGRConfigFromPath(tpAccActionsCfgPath) if err != nil { t.Error(err) diff --git a/apier/v1/tpactionplans_it_test.go b/apier/v1/tpactionplans_it_test.go index afe0c6d29..4fe05be61 100644 --- a/apier/v1/tpactionplans_it_test.go +++ b/apier/v1/tpactionplans_it_test.go @@ -62,7 +62,7 @@ var sTestsTPAccPlans = []func(t *testing.T){ // Test start here func TestTPAccPlansIT(t *testing.T) { - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: tpAccPlansConfigDIR = "tutinternal" case utils.MetaMySQL: @@ -81,7 +81,7 @@ func TestTPAccPlansIT(t *testing.T) { func testTPAccPlansInitCfg(t *testing.T) { var err error - tpAccPlansCfgPath = path.Join(*dataDir, "conf", "samples", tpAccPlansConfigDIR) + tpAccPlansCfgPath = path.Join(*utils.DataDir, "conf", "samples", tpAccPlansConfigDIR) tpAccPlansCfg, err = config.NewCGRConfigFromPath(tpAccPlansCfgPath) if err != nil { t.Error(err) diff --git a/apier/v1/tpactions_it_test.go b/apier/v1/tpactions_it_test.go index 47516dfc7..09bce9559 100644 --- a/apier/v1/tpactions_it_test.go +++ b/apier/v1/tpactions_it_test.go @@ -62,7 +62,7 @@ var sTestsTPActions = []func(t *testing.T){ // Test start here func TestTPActionsIT(t *testing.T) { - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: tpActionConfigDIR = "tutinternal" case utils.MetaMySQL: @@ -81,7 +81,7 @@ func TestTPActionsIT(t *testing.T) { func testTPActionsInitCfg(t *testing.T) { var err error - tpActionCfgPath = path.Join(*dataDir, "conf", "samples", tpActionConfigDIR) + tpActionCfgPath = path.Join(*utils.DataDir, "conf", "samples", tpActionConfigDIR) tpActionCfg, err = config.NewCGRConfigFromPath(tpActionCfgPath) if err != nil { t.Error(err) diff --git a/apier/v1/tpactiontriggers_it_test.go b/apier/v1/tpactiontriggers_it_test.go index 7cd1fef27..f266dae5a 100644 --- a/apier/v1/tpactiontriggers_it_test.go +++ b/apier/v1/tpactiontriggers_it_test.go @@ -62,7 +62,7 @@ var sTestsTPActionTriggers = []func(t *testing.T){ // Test start here func TestTPActionTriggersIT(t *testing.T) { - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: tpActionTriggerConfigDIR = "tutinternal" case utils.MetaMySQL: @@ -81,7 +81,7 @@ func TestTPActionTriggersIT(t *testing.T) { func testTPActionTriggersInitCfg(t *testing.T) { var err error - tpActionTriggerCfgPath = path.Join(*dataDir, "conf", "samples", tpActionTriggerConfigDIR) + tpActionTriggerCfgPath = path.Join(*utils.DataDir, "conf", "samples", tpActionTriggerConfigDIR) tpActionTriggerCfg, err = config.NewCGRConfigFromPath(tpActionTriggerCfgPath) if err != nil { t.Error(err) diff --git a/apier/v1/tpattributes_it_test.go b/apier/v1/tpattributes_it_test.go index 1ecb4f67f..d6387f1b5 100644 --- a/apier/v1/tpattributes_it_test.go +++ b/apier/v1/tpattributes_it_test.go @@ -63,7 +63,7 @@ var sTestsTPAlsPrf = []func(t *testing.T){ // Test start here func TestTPAlsPrfIT(t *testing.T) { - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: tpAlsPrfConfigDIR = "tutinternal" case utils.MetaMySQL: @@ -82,7 +82,7 @@ func TestTPAlsPrfIT(t *testing.T) { func testTPAlsPrfInitCfg(t *testing.T) { var err error - tpAlsPrfCfgPath = path.Join(*dataDir, "conf", "samples", tpAlsPrfConfigDIR) + tpAlsPrfCfgPath = path.Join(*utils.DataDir, "conf", "samples", tpAlsPrfConfigDIR) tpAlsPrfCfg, err = config.NewCGRConfigFromPath(tpAlsPrfCfgPath) if err != nil { t.Error(err) diff --git a/apier/v1/tpchargers_it_test.go b/apier/v1/tpchargers_it_test.go index 8e6ff29fe..ae6bff42b 100644 --- a/apier/v1/tpchargers_it_test.go +++ b/apier/v1/tpchargers_it_test.go @@ -62,7 +62,7 @@ var sTestsTPChrgs = []func(t *testing.T){ // Test start here func TestTPChrgsIT(t *testing.T) { - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: tpChrgsConfigDIR = "tutinternal" case utils.MetaMySQL: @@ -81,7 +81,7 @@ func TestTPChrgsIT(t *testing.T) { func testTPChrgsInitCfg(t *testing.T) { var err error - tpChrgsCfgPath = path.Join(*dataDir, "conf", "samples", tpChrgsConfigDIR) + tpChrgsCfgPath = path.Join(*utils.DataDir, "conf", "samples", tpChrgsConfigDIR) tpChrgsCfg, err = config.NewCGRConfigFromPath(tpChrgsCfgPath) if err != nil { t.Error(err) diff --git a/apier/v1/tpdestinationrates_it_test.go b/apier/v1/tpdestinationrates_it_test.go index 6e4200f9a..acdf5965a 100644 --- a/apier/v1/tpdestinationrates_it_test.go +++ b/apier/v1/tpdestinationrates_it_test.go @@ -61,7 +61,7 @@ var sTestsTPDstRates = []func(t *testing.T){ // Test start here func TestTPDstRateIT(t *testing.T) { - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: tpDstRateConfigDIR = "tutinternal" case utils.MetaMySQL: @@ -80,7 +80,7 @@ func TestTPDstRateIT(t *testing.T) { func testTPDstRateInitCfg(t *testing.T) { var err error - tpDstRateCfgPath = path.Join(*dataDir, "conf", "samples", tpDstRateConfigDIR) + tpDstRateCfgPath = path.Join(*utils.DataDir, "conf", "samples", tpDstRateConfigDIR) tpDstRateCfg, err = config.NewCGRConfigFromPath(tpDstRateCfgPath) if err != nil { t.Error(err) diff --git a/apier/v1/tpdestinations_it_test.go b/apier/v1/tpdestinations_it_test.go index 2d1e8c192..c8a65feaf 100644 --- a/apier/v1/tpdestinations_it_test.go +++ b/apier/v1/tpdestinations_it_test.go @@ -61,7 +61,7 @@ var sTestsTPDestinations = []func(t *testing.T){ // Test start here func TestTPDestinationsIT(t *testing.T) { - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: tpDestinationConfigDIR = "tutinternal" case utils.MetaMySQL: @@ -80,7 +80,7 @@ func TestTPDestinationsIT(t *testing.T) { func testTPDestinationsInitCfg(t *testing.T) { var err error - tpDestinationCfgPath = path.Join(*dataDir, "conf", "samples", tpDestinationConfigDIR) + tpDestinationCfgPath = path.Join(*utils.DataDir, "conf", "samples", tpDestinationConfigDIR) tpDestinationCfg, err = config.NewCGRConfigFromPath(tpDestinationCfgPath) if err != nil { t.Error(err) diff --git a/apier/v1/tpdispatchers_it_test.go b/apier/v1/tpdispatchers_it_test.go index 2e1c54d21..771e3f1db 100644 --- a/apier/v1/tpdispatchers_it_test.go +++ b/apier/v1/tpdispatchers_it_test.go @@ -61,7 +61,7 @@ var sTestsTPDispatchers = []func(t *testing.T){ // Test start here func TestTPDispatcherIT(t *testing.T) { - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: tpDispatcherConfigDIR = "tutinternal" case utils.MetaMySQL: @@ -80,7 +80,7 @@ func TestTPDispatcherIT(t *testing.T) { func testTPDispatcherInitCfg(t *testing.T) { var err error - tpDispatcherCfgPath = path.Join(*dataDir, "conf", "samples", tpDispatcherConfigDIR) + tpDispatcherCfgPath = path.Join(*utils.DataDir, "conf", "samples", tpDispatcherConfigDIR) tpDispatcherCfg, err = config.NewCGRConfigFromPath(tpDispatcherCfgPath) if err != nil { t.Error(err) diff --git a/apier/v1/tpfilters_it_test.go b/apier/v1/tpfilters_it_test.go index 212c2133d..58f37fc3a 100644 --- a/apier/v1/tpfilters_it_test.go +++ b/apier/v1/tpfilters_it_test.go @@ -63,7 +63,7 @@ var sTestsTPFilters = []func(t *testing.T){ // Test start here func TestTPFilterITMySql(t *testing.T) { - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: tpFilterConfigDIR = "tutinternal" case utils.MetaMySQL: @@ -82,7 +82,7 @@ func TestTPFilterITMySql(t *testing.T) { func testTPFilterInitCfg(t *testing.T) { var err error - tpFilterCfgPath = path.Join(*dataDir, "conf", "samples", tpFilterConfigDIR) + tpFilterCfgPath = path.Join(*utils.DataDir, "conf", "samples", tpFilterConfigDIR) tpFilterCfg, err = config.NewCGRConfigFromPath(tpFilterCfgPath) if err != nil { t.Error(err) diff --git a/apier/v1/tprates_it_test.go b/apier/v1/tprates_it_test.go index 3fc8380ed..458c3ebda 100644 --- a/apier/v1/tprates_it_test.go +++ b/apier/v1/tprates_it_test.go @@ -61,7 +61,7 @@ var sTestsTPRates = []func(t *testing.T){ // Test start here func TestTPRatesIT(t *testing.T) { - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: tpRateConfigDIR = "tutinternal" case utils.MetaMySQL: @@ -80,7 +80,7 @@ func TestTPRatesIT(t *testing.T) { func testTPRatesInitCfg(t *testing.T) { var err error - tpRateCfgPath = path.Join(*dataDir, "conf", "samples", tpRateConfigDIR) + tpRateCfgPath = path.Join(*utils.DataDir, "conf", "samples", tpRateConfigDIR) tpRateCfg, err = config.NewCGRConfigFromPath(tpRateCfgPath) if err != nil { t.Error(err) diff --git a/apier/v1/tpratingplans_it_test.go b/apier/v1/tpratingplans_it_test.go index 35243b592..620bb58f8 100644 --- a/apier/v1/tpratingplans_it_test.go +++ b/apier/v1/tpratingplans_it_test.go @@ -61,7 +61,7 @@ var sTestsTPRatingPlans = []func(t *testing.T){ // Test start here func TestTPRatingPlansIT(t *testing.T) { - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: tpRatingPlanConfigDIR = "tutinternal" case utils.MetaMySQL: @@ -80,7 +80,7 @@ func TestTPRatingPlansIT(t *testing.T) { func testTPRatingPlansInitCfg(t *testing.T) { var err error - tpRatingPlanCfgPath = path.Join(*dataDir, "conf", "samples", tpRatingPlanConfigDIR) + tpRatingPlanCfgPath = path.Join(*utils.DataDir, "conf", "samples", tpRatingPlanConfigDIR) tpRatingPlanCfg, err = config.NewCGRConfigFromPath(tpRatingPlanCfgPath) if err != nil { t.Error(err) diff --git a/apier/v1/tpratingprofiles_it_test.go b/apier/v1/tpratingprofiles_it_test.go index 15be9234e..870dc350a 100644 --- a/apier/v1/tpratingprofiles_it_test.go +++ b/apier/v1/tpratingprofiles_it_test.go @@ -64,7 +64,7 @@ var sTestsTPRatingProfiles = []func(t *testing.T){ // Test start here func TestTPRatingProfilesIT(t *testing.T) { - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: tpRatingProfileConfigDIR = "tutinternal" case utils.MetaMySQL: @@ -83,7 +83,7 @@ func TestTPRatingProfilesIT(t *testing.T) { func testTPRatingProfilesInitCfg(t *testing.T) { var err error - tpRatingProfileCfgPath = path.Join(*dataDir, "conf", "samples", tpRatingProfileConfigDIR) + tpRatingProfileCfgPath = path.Join(*utils.DataDir, "conf", "samples", tpRatingProfileConfigDIR) tpRatingProfileCfg, err = config.NewCGRConfigFromPath(tpRatingProfileCfgPath) if err != nil { t.Error(err) diff --git a/apier/v1/tpresources_it_test.go b/apier/v1/tpresources_it_test.go index 3e45b45ae..cdb0d6069 100644 --- a/apier/v1/tpresources_it_test.go +++ b/apier/v1/tpresources_it_test.go @@ -61,7 +61,7 @@ var sTestsTPResources = []func(t *testing.T){ // Test start here func TestTPResIT(t *testing.T) { - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: tpResConfigDIR = "tutinternal" case utils.MetaMySQL: @@ -80,7 +80,7 @@ func TestTPResIT(t *testing.T) { func testTPResInitCfg(t *testing.T) { var err error - tpResCfgPath = path.Join(*dataDir, "conf", "samples", tpResConfigDIR) + tpResCfgPath = path.Join(*utils.DataDir, "conf", "samples", tpResConfigDIR) tpResCfg, err = config.NewCGRConfigFromPath(tpResCfgPath) if err != nil { t.Error(err) diff --git a/apier/v1/tproutes_it_test.go b/apier/v1/tproutes_it_test.go index ca3fea00c..13d99f361 100644 --- a/apier/v1/tproutes_it_test.go +++ b/apier/v1/tproutes_it_test.go @@ -63,7 +63,7 @@ var sTestsTPRoute = []func(t *testing.T){ // Test start here func TestTPRouteIT(t *testing.T) { - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: tpRouteConfigDIR = "tutinternal" case utils.MetaMySQL: @@ -82,7 +82,7 @@ func TestTPRouteIT(t *testing.T) { func testTPRouteInitCfg(t *testing.T) { var err error - tpRouteCfgPath = path.Join(*dataDir, "conf", "samples", tpRouteConfigDIR) + tpRouteCfgPath = path.Join(*utils.DataDir, "conf", "samples", tpRouteConfigDIR) tpRouteCfg, err = config.NewCGRConfigFromPath(tpRouteCfgPath) if err != nil { t.Error(err) diff --git a/apier/v1/tpsharedgroups_it_test.go b/apier/v1/tpsharedgroups_it_test.go index 8c3f493cb..ec4fe4fbd 100644 --- a/apier/v1/tpsharedgroups_it_test.go +++ b/apier/v1/tpsharedgroups_it_test.go @@ -61,7 +61,7 @@ var sTestsTPSharedGroups = []func(t *testing.T){ // Test start here func TestTPSharedGroupsIT(t *testing.T) { - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: tpSharedGroupConfigDIR = "tutinternal" case utils.MetaMySQL: @@ -80,7 +80,7 @@ func TestTPSharedGroupsIT(t *testing.T) { func testTPSharedGroupsInitCfg(t *testing.T) { var err error - tpSharedGroupCfgPath = path.Join(*dataDir, "conf", "samples", tpSharedGroupConfigDIR) + tpSharedGroupCfgPath = path.Join(*utils.DataDir, "conf", "samples", tpSharedGroupConfigDIR) tpSharedGroupCfg, err = config.NewCGRConfigFromPath(tpSharedGroupCfgPath) if err != nil { t.Error(err) diff --git a/apier/v1/tpstats_it_test.go b/apier/v1/tpstats_it_test.go index de9334db3..28b20d06e 100644 --- a/apier/v1/tpstats_it_test.go +++ b/apier/v1/tpstats_it_test.go @@ -62,7 +62,7 @@ var sTestsTPStats = []func(t *testing.T){ // Test start here func TestTPStatIT(t *testing.T) { - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: tpStatConfigDIR = "tutinternal" case utils.MetaMySQL: @@ -81,7 +81,7 @@ func TestTPStatIT(t *testing.T) { func testTPStatsInitCfg(t *testing.T) { var err error - tpStatCfgPath = path.Join(*dataDir, "conf", "samples", tpStatConfigDIR) + tpStatCfgPath = path.Join(*utils.DataDir, "conf", "samples", tpStatConfigDIR) tpStatCfg, err = config.NewCGRConfigFromPath(tpStatCfgPath) if err != nil { t.Error(err) diff --git a/apier/v1/tpthresholds_it_test.go b/apier/v1/tpthresholds_it_test.go index e4e718129..99b549dcb 100644 --- a/apier/v1/tpthresholds_it_test.go +++ b/apier/v1/tpthresholds_it_test.go @@ -62,7 +62,7 @@ var sTestsTPThreshold = []func(t *testing.T){ // Test start here func TestTPThresholdIT(t *testing.T) { - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: tpThresholdConfigDIR = "tutinternal" case utils.MetaMySQL: @@ -81,7 +81,7 @@ func TestTPThresholdIT(t *testing.T) { func testTPThreholdInitCfg(t *testing.T) { var err error - tpThresholdCfgPath = path.Join(*dataDir, "conf", "samples", tpThresholdConfigDIR) + tpThresholdCfgPath = path.Join(*utils.DataDir, "conf", "samples", tpThresholdConfigDIR) tpThresholdCfg, err = config.NewCGRConfigFromPath(tpThresholdCfgPath) if err != nil { t.Error(err) diff --git a/apier/v1/tptimings_it_test.go b/apier/v1/tptimings_it_test.go index 9dd450867..7b15709b2 100644 --- a/apier/v1/tptimings_it_test.go +++ b/apier/v1/tptimings_it_test.go @@ -61,7 +61,7 @@ var sTestsTPTiming = []func(t *testing.T){ // Test start here func TestTPTimingIT(t *testing.T) { - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: tpTimingConfigDIR = "tutinternal" case utils.MetaMySQL: @@ -80,7 +80,7 @@ func TestTPTimingIT(t *testing.T) { func testTPTimingsInitCfg(t *testing.T) { var err error - tpTimingCfgPath = path.Join(*dataDir, "conf", "samples", tpTimingConfigDIR) + tpTimingCfgPath = path.Join(*utils.DataDir, "conf", "samples", tpTimingConfigDIR) tpTimingCfg, err = config.NewCGRConfigFromPath(tpTimingCfgPath) if err != nil { t.Error(err) diff --git a/apier/v1/versions_it_test.go b/apier/v1/versions_it_test.go index adda062fe..ea5e346cd 100644 --- a/apier/v1/versions_it_test.go +++ b/apier/v1/versions_it_test.go @@ -55,7 +55,7 @@ var ( // Test start here func TestVrsIT(t *testing.T) { - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: // vrsConfigDIR = "tutinternal" // vrsStorageType = utils.INTERNAL @@ -87,12 +87,12 @@ func TestVrsIT(t *testing.T) { func testVrsInitCfg(t *testing.T) { var err error - vrsCfgPath = path.Join(*dataDir, "conf", "samples", vrsConfigDIR) + vrsCfgPath = path.Join(*utils.DataDir, "conf", "samples", vrsConfigDIR) vrsCfg, err = config.NewCGRConfigFromPath(vrsCfgPath) if err != nil { t.Error(err) } - vrsCfg.DataFolderPath = *dataDir // Share DataFolderPath through config towards StoreDb for Flush() + vrsCfg.DataFolderPath = *utils.DataDir // Share DataFolderPath through config towards StoreDb for Flush() vrsDelay = 1000 } diff --git a/apier/v2/accounts_it_test.go b/apier/v2/accounts_it_test.go index e49cabedb..9e96290d8 100644 --- a/apier/v2/accounts_it_test.go +++ b/apier/v2/accounts_it_test.go @@ -62,7 +62,7 @@ var ( // Test start here func TestAccountsIT(t *testing.T) { - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: accConfigDIR = "tutinternal" case utils.MetaMySQL: @@ -82,12 +82,12 @@ func TestAccountsIT(t *testing.T) { func testAccountsInitCfg(t *testing.T) { var err error - accCfgPath = path.Join(*dataDir, "conf", "samples", accConfigDIR) + accCfgPath = path.Join(*utils.DataDir, "conf", "samples", accConfigDIR) accCfg, err = config.NewCGRConfigFromPath(accCfgPath) if err != nil { t.Error(err) } - accCfg.DataFolderPath = *dataDir // Share DataFolderPath through config towards StoreDb for Flush() + accCfg.DataFolderPath = *utils.DataDir // Share DataFolderPath through config towards StoreDb for Flush() config.SetCgrConfig(accCfg) } @@ -106,7 +106,7 @@ func testAccountsResetStorDb(t *testing.T) { // Start CGR Engine func testAccountsStartEngine(t *testing.T) { - if _, err := engine.StopStartEngine(accCfgPath, *waitRater); err != nil { + if _, err := engine.StopStartEngine(accCfgPath, *utils.WaitRater); err != nil { t.Fatal(err) } } diff --git a/apier/v2/apierv2_it_test.go b/apier/v2/apierv2_it_test.go index 8b322d447..fa25b9141 100644 --- a/apier/v2/apierv2_it_test.go +++ b/apier/v2/apierv2_it_test.go @@ -65,7 +65,7 @@ var ( ) func TestV2IT(t *testing.T) { - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: t.Skip() case utils.MetaMySQL: @@ -84,7 +84,7 @@ func TestV2IT(t *testing.T) { } func testAPIerSv2itLoadConfig(t *testing.T) { - apierCfgPath = path.Join(*dataDir, "conf", "samples", APIerSv2ConfDIR) + apierCfgPath = path.Join(*utils.DataDir, "conf", "samples", APIerSv2ConfDIR) if apierCfg, err = config.NewCGRConfigFromPath(apierCfgPath); err != nil { t.Error(err) } diff --git a/apier/v2/attributes_it_test.go b/apier/v2/attributes_it_test.go index abe2aa00c..0b390ed2c 100644 --- a/apier/v2/attributes_it_test.go +++ b/apier/v2/attributes_it_test.go @@ -57,7 +57,7 @@ var ( // Test start here func TestAttributeSIT(t *testing.T) { - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: alsPrfConfigDIR = "tutinternal" case utils.MetaMySQL: @@ -77,7 +77,7 @@ func TestAttributeSIT(t *testing.T) { func testAttributeSInitCfg(t *testing.T) { var err error - alsPrfCfgPath = path.Join(*dataDir, "conf", "samples", alsPrfConfigDIR) + alsPrfCfgPath = path.Join(*utils.DataDir, "conf", "samples", alsPrfConfigDIR) alsPrfCfg, err = config.NewCGRConfigFromPath(alsPrfCfgPath) if err != nil { t.Error(err) @@ -99,7 +99,7 @@ func testAttributeSResetStorDb(t *testing.T) { // Start CGR Engine func testAttributeSStartEngine(t *testing.T) { - if _, err := engine.StopStartEngine(alsPrfCfgPath, *waitRater); err != nil { + if _, err := engine.StopStartEngine(alsPrfCfgPath, *utils.WaitRater); err != nil { t.Fatal(err) } } diff --git a/apier/v2/cdrs_it_test.go b/apier/v2/cdrs_it_test.go index 67f522a63..292607896 100644 --- a/apier/v2/cdrs_it_test.go +++ b/apier/v2/cdrs_it_test.go @@ -85,7 +85,7 @@ var ( // Tests starting here func TestCDRsIT(t *testing.T) { - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: cdrsConfDIR = "cdrsv2internal" case utils.MetaMySQL: @@ -105,7 +105,7 @@ func TestCDRsIT(t *testing.T) { func testV2CDRsInitConfig(t *testing.T) { var err error - cdrsCfgPath = path.Join(*dataDir, "conf", "samples", cdrsConfDIR) + cdrsCfgPath = path.Join(*utils.DataDir, "conf", "samples", cdrsConfDIR) if cdrsCfg, err = config.NewCGRConfigFromPath(cdrsCfgPath); err != nil { t.Fatal("Got config error: ", err.Error()) } @@ -125,7 +125,7 @@ func testV2CDRsInitCdrDb(t *testing.T) { } func testV2CDRsStartEngine(t *testing.T) { - if _, err := engine.StopStartEngine(cdrsCfgPath, *waitRater); err != nil { + if _, err := engine.StopStartEngine(cdrsCfgPath, *utils.WaitRater); err != nil { t.Fatal(err) } } @@ -142,10 +142,10 @@ func testV2CDRsLoadTariffPlanFromFolder(t *testing.T) { var loadInst utils.LoadInstance if err := cdrsRpc.Call(context.Background(), utils.APIerSv2LoadTariffPlanFromFolder, &utils.AttrLoadTpFromFolder{FolderPath: path.Join( - *dataDir, "tariffplans", "testit")}, &loadInst); err != nil { + *utils.DataDir, "tariffplans", "testit")}, &loadInst); err != nil { t.Error(err) } - time.Sleep(time.Duration(*waitRater) * time.Millisecond) // Give time for scheduler to execute topups + time.Sleep(time.Duration(*utils.WaitRater) * time.Millisecond) // Give time for scheduler to execute topups } func testV2CDRsProcessCDR(t *testing.T) { @@ -1152,7 +1152,7 @@ func testV2CDRsDuplicateCDRs(t *testing.T) { } func testV2CDRsKillEngine(t *testing.T) { - if err := engine.KillEngine(*waitRater); err != nil { + if err := engine.KillEngine(*utils.WaitRater); err != nil { t.Error(err) } } diff --git a/apier/v2/cdrs_offline_it_test.go b/apier/v2/cdrs_offline_it_test.go index c1e39f302..7ee426b19 100644 --- a/apier/v2/cdrs_offline_it_test.go +++ b/apier/v2/cdrs_offline_it_test.go @@ -59,7 +59,7 @@ var ( // Tests starting here func TestCDRsOfflineIT(t *testing.T) { - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: cdrsOfflineConfDIR = "cdrsv2internal" case utils.MetaMySQL: @@ -78,7 +78,7 @@ func TestCDRsOfflineIT(t *testing.T) { func testV2CDRsOfflineInitConfig(t *testing.T) { var err error - cdrsOfflineCfgPath = path.Join(*dataDir, "conf", "samples", cdrsOfflineConfDIR) + cdrsOfflineCfgPath = path.Join(*utils.DataDir, "conf", "samples", cdrsOfflineConfDIR) if cdrsOfflineCfg, err = config.NewCGRConfigFromPath(cdrsOfflineCfgPath); err != nil { t.Fatal("Got config error: ", err.Error()) } @@ -98,7 +98,7 @@ func testV2CDRsOfflineInitCdrDb(t *testing.T) { } func testV2CDRsOfflineStartEngine(t *testing.T) { - if _, err := engine.StopStartEngine(cdrsOfflineCfgPath, *waitRater); err != nil { + if _, err := engine.StopStartEngine(cdrsOfflineCfgPath, *utils.WaitRater); err != nil { t.Fatal(err) } } @@ -115,10 +115,10 @@ func testV2CDRsOfflineLoadData(t *testing.T) { var loadInst utils.LoadInstance if err := cdrsOfflineRpc.Call(context.Background(), utils.APIerSv2LoadTariffPlanFromFolder, &utils.AttrLoadTpFromFolder{FolderPath: path.Join( - *dataDir, "tariffplans", "testit")}, &loadInst); err != nil { + *utils.DataDir, "tariffplans", "testit")}, &loadInst); err != nil { t.Error(err) } - time.Sleep(time.Duration(*waitRater) * time.Millisecond) // Give time for scheduler to execute topups + time.Sleep(time.Duration(*utils.WaitRater) * time.Millisecond) // Give time for scheduler to execute topups } func testV2CDRsOfflineBalanceUpdate(t *testing.T) { @@ -388,7 +388,7 @@ func testV2CDRsBalancesWithSameWeight(t *testing.T) { } func testV2CDRsOfflineKillEngine(t *testing.T) { - if err := engine.KillEngine(*waitRater); err != nil { + if err := engine.KillEngine(*utils.WaitRater); err != nil { t.Error(err) } } diff --git a/apier/v2/lib_test.go b/apier/v2/lib_test.go index e2636c3fc..0b53dfccc 100644 --- a/apier/v2/lib_test.go +++ b/apier/v2/lib_test.go @@ -20,7 +20,6 @@ package v2 import ( "errors" - "flag" "github.com/cgrates/birpc" "github.com/cgrates/birpc/jsonrpc" @@ -28,15 +27,8 @@ import ( "github.com/cgrates/cgrates/utils" ) -var ( - dataDir = flag.String("data_dir", "/usr/share/cgrates", "CGR data dir path here") - waitRater = flag.Int("wait_rater", 100, "Number of miliseconds to wait for rater to start and cache") - encoding = flag.String("rpc", utils.MetaJSON, "what encoding whould be uused for rpc comunication") - dbType = flag.String("dbtype", utils.MetaInternal, "The type of DataBase (Internal/Mongo/mySql)") -) - func newRPCClient(cfg *config.ListenCfg) (c *birpc.Client, err error) { - switch *encoding { + switch *utils.Encoding { case utils.MetaJSON: return jsonrpc.Dial(utils.TCP, cfg.RPCJSONListen) case utils.MetaGOB: diff --git a/apier/v2/tp_it_test.go b/apier/v2/tp_it_test.go index 543881d1a..740313a29 100644 --- a/apier/v2/tp_it_test.go +++ b/apier/v2/tp_it_test.go @@ -61,7 +61,7 @@ var ( func TestTPit(t *testing.T) { - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: configDIR = "tutinternal" case utils.MetaMySQL: @@ -80,7 +80,7 @@ func TestTPit(t *testing.T) { } func testTPitLoadConfig(t *testing.T) { - tpCfgPath = path.Join(*dataDir, "conf", "samples", configDIR) + tpCfgPath = path.Join(*utils.DataDir, "conf", "samples", configDIR) if tpCfg, err = config.NewCGRConfigFromPath(tpCfgPath); err != nil { t.Error(err) } @@ -88,7 +88,7 @@ func testTPitLoadConfig(t *testing.T) { case "tutmongo": // Mongo needs more time to reset db, need to investigate delay = 4000 default: - delay = *waitRater + delay = *utils.WaitRater } } diff --git a/cmd/cgr-console/cgr-console_it_test.go b/cmd/cgr-console/cgr-console_it_test.go index 74840549d..a223e3310 100644 --- a/cmd/cgr-console/cgr-console_it_test.go +++ b/cmd/cgr-console/cgr-console_it_test.go @@ -25,7 +25,6 @@ import ( "bytes" "encoding/json" "errors" - "flag" "fmt" "os" "os/exec" @@ -47,13 +46,7 @@ import ( "github.com/cgrates/cgrates/utils" ) -var ( - dataDir = flag.String("data_dir", "/usr/share/cgrates", "CGR data dir path here") - dbType = flag.String("dbtype", utils.MetaInternal, "The type of DataBase (Internal/Mongo/mySql)") - waitRater = flag.Int("wait_rater", 100, "Number of milliseconds to wait for rater to start and cache") - encoding = flag.String("rpc", utils.MetaJSON, "what encoding whould be uused for rpc comunication") - cnslRPC *birpc.Client -) +var cnslRPC *birpc.Client var ( cnslItCfgPath string @@ -218,7 +211,7 @@ var ( ) func TestConsoleItTests(t *testing.T) { - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: t.SkipNow() case utils.MetaMySQL: @@ -236,7 +229,7 @@ func TestConsoleItTests(t *testing.T) { } func TestConsoleItDispatchersTests(t *testing.T) { - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: t.SkipNow() case utils.MetaMySQL: @@ -254,7 +247,7 @@ func TestConsoleItDispatchersTests(t *testing.T) { } func TestConsoleItLoadersTests(t *testing.T) { - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: t.SkipNow() case utils.MetaMySQL: @@ -273,7 +266,7 @@ func TestConsoleItLoadersTests(t *testing.T) { func testConsoleItLoadConfig(t *testing.T) { var err error - cnslItCfgPath = path.Join(*dataDir, "conf", "samples", cnslItDirPath) + cnslItCfgPath = path.Join(*utils.DataDir, "conf", "samples", cnslItDirPath) if cnslItCfg, err = config.NewCGRConfigFromPath(cnslItCfgPath); err != nil { t.Fatal(err) } @@ -290,7 +283,7 @@ func testConsoleItLoadersLoadConfig(t *testing.T) { } var err error - cnslItCfgPath = path.Join(*dataDir, "conf", "samples", cnslItDirPath) + cnslItCfgPath = path.Join(*utils.DataDir, "conf", "samples", cnslItDirPath) if cnslItCfg, err = config.NewCGRConfigFromPath(cnslItCfgPath); err != nil { t.Fatal(err) } @@ -309,13 +302,13 @@ func testConsoleItInitStorDB(t *testing.T) { } func testConsoleItStartEngine(t *testing.T) { - if _, err := engine.StartEngine(cnslItCfgPath, *waitRater); err != nil { + if _, err := engine.StartEngine(cnslItCfgPath, *utils.WaitRater); err != nil { t.Fatal(err) } } func newRPCClient(cfg *config.ListenCfg) (c *birpc.Client, err error) { - switch *encoding { + switch *utils.Encoding { case utils.MetaJSON: return jsonrpc.Dial(utils.TCP, cfg.RPCJSONListen) case utils.MetaGOB: @@ -342,13 +335,13 @@ func testConsoleItLoadersStartEngine(t *testing.T) { if err := os.MkdirAll(fldPathOut, 0777); err != nil { t.Error(err) } - if _, err := engine.StartEngine(cnslItCfgPath, *waitRater); err != nil { + if _, err := engine.StartEngine(cnslItCfgPath, *utils.WaitRater); err != nil { t.Fatal(err) } } func testConsoleItLoadTP(t *testing.T) { - cmd := exec.Command("cgr-loader", "-config_path="+cnslItCfgPath, "-path="+path.Join(*dataDir, "tariffplans", "tutorial")) + cmd := exec.Command("cgr-loader", "-config_path="+cnslItCfgPath, "-path="+path.Join(*utils.DataDir, "tariffplans", "tutorial")) output := bytes.NewBuffer(nil) cmd.Stdout = output if err := cmd.Run(); err != nil { @@ -359,7 +352,7 @@ func testConsoleItLoadTP(t *testing.T) { } func testConsoleItDispatchersLoadTP(t *testing.T) { - cmd := exec.Command("cgr-loader", "-config_path="+cnslItCfgPath, "-path="+path.Join(*dataDir, "tariffplans", "dispatchers"), `-caches_address=`, `-scheduler_address=`) + cmd := exec.Command("cgr-loader", "-config_path="+cnslItCfgPath, "-path="+path.Join(*utils.DataDir, "tariffplans", "dispatchers"), `-caches_address=`, `-scheduler_address=`) output := bytes.NewBuffer(nil) cmd.Stdout = output cmd.Stderr = output @@ -4578,7 +4571,7 @@ func testConsoleItAccountTriggersSet(t *testing.T) { } func testConsoleItAccountActionPlanGet(t *testing.T) { - cmd := exec.Command("cgr-loader", "-config_path="+cnslItCfgPath, "-path="+path.Join(*dataDir, "tariffplans", "tutorial2")) + cmd := exec.Command("cgr-loader", "-config_path="+cnslItCfgPath, "-path="+path.Join(*utils.DataDir, "tariffplans", "tutorial2")) output := bytes.NewBuffer(nil) cmd.Stdout = output if err := cmd.Run(); err != nil { @@ -4644,7 +4637,7 @@ func testConsoleItAccountActionPlanGet(t *testing.T) { if !reflect.DeepEqual(rcv, expected) { t.Fatalf("Expected %v \n but received \n %v", utils.ToJSON(expected), utils.ToJSON(rcv)) } - cmd = exec.Command("cgr-loader", "-config_path="+cnslItCfgPath, "-path="+path.Join(*dataDir, "tariffplans", "tutorial")) + cmd = exec.Command("cgr-loader", "-config_path="+cnslItCfgPath, "-path="+path.Join(*utils.DataDir, "tariffplans", "tutorial")) output = bytes.NewBuffer(nil) cmd.Stdout = output if err := cmd.Run(); err != nil { @@ -4980,7 +4973,7 @@ func testConsoleItCostDetails(t *testing.T) { } func testConsoleItKillEngine(t *testing.T) { - if err := engine.KillEngine(*waitRater); err != nil { + if err := engine.KillEngine(*utils.WaitRater); err != nil { t.Fatal(err) } } @@ -4994,7 +4987,7 @@ func testConsoleItLoadersKillEngine(t *testing.T) { if err := os.Remove(fldPathOut); err != nil { t.Error(err) } - if err := engine.KillEngine(*waitRater); err != nil { + if err := engine.KillEngine(*utils.WaitRater); err != nil { t.Fatal(err) } } diff --git a/cmd/cgr-loader/cgr-loader_it_test.go b/cmd/cgr-loader/cgr-loader_it_test.go index 848d394ae..f6e8902c2 100644 --- a/cmd/cgr-loader/cgr-loader_it_test.go +++ b/cmd/cgr-loader/cgr-loader_it_test.go @@ -23,7 +23,6 @@ package main import ( "bytes" - "flag" "fmt" "net" "net/rpc" @@ -40,16 +39,9 @@ import ( "github.com/cgrates/rpcclient" ) -var ( - dataDir = flag.String("data_dir", "/usr/share/cgrates", "CGR data dir path here") - dbType = flag.String("dbtype", utils.MetaInternal, "The type of DataBase (Internal/Mongo/mySql)") - encoding = flag.String("rpc", utils.MetaJSON, "what encoding whould be used for rpc comunication") - waitRater = flag.Int("wait_rater", 100, "Number of miliseconds to wait for rater to start and cache") -) - func TestLoadConfig(t *testing.T) { // DataDb - *cfgPath = path.Join(*dataDir, "conf", "samples", "tutmongo") + *cfgPath = path.Join(*utils.DataDir, "conf", "samples", "tutmongo") *dataDBType = utils.MetaRedis *dataDBHost = "localhost" *dataDBPort = "2012" @@ -249,7 +241,7 @@ var ( ) func TestLoadIt(t *testing.T) { - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: t.SkipNow() case utils.MetaMySQL: @@ -268,7 +260,7 @@ func TestLoadIt(t *testing.T) { func testLoadItLoadConfig(t *testing.T) { var err error - ldrItCfgPath = path.Join(*dataDir, "conf", "samples", ldrItCfgDir) + ldrItCfgPath = path.Join(*utils.DataDir, "conf", "samples", ldrItCfgDir) if ldrItCfg, err = config.NewCGRConfigFromPath(ldrItCfgPath); err != nil { t.Error(err) } @@ -287,7 +279,7 @@ func testLoadItResetStorDb(t *testing.T) { } func testLoadItStartLoader(t *testing.T) { - cmd := exec.Command("cgr-loader", "-config_path="+ldrItCfgPath, "-path="+path.Join(*dataDir, "tariffplans", "tutorial"), "-caches_address=", "-scheduler_address=") + cmd := exec.Command("cgr-loader", "-config_path="+ldrItCfgPath, "-path="+path.Join(*utils.DataDir, "tariffplans", "tutorial"), "-caches_address=", "-scheduler_address=") output := bytes.NewBuffer(nil) outerr := bytes.NewBuffer(nil) cmd.Stdout = output @@ -335,7 +327,7 @@ func testLoadItCheckAttributes(t *testing.T) { } func testLoadItStartLoaderRemove(t *testing.T) { - cmd := exec.Command("cgr-loader", "-config_path="+ldrItCfgPath, "-path="+path.Join(*dataDir, "tariffplans", "tutorial"), "-caches_address=", "-scheduler_address=", "-remove") + cmd := exec.Command("cgr-loader", "-config_path="+ldrItCfgPath, "-path="+path.Join(*utils.DataDir, "tariffplans", "tutorial"), "-caches_address=", "-scheduler_address=", "-remove") output := bytes.NewBuffer(nil) outerr := bytes.NewBuffer(nil) cmd.Stdout = output @@ -355,7 +347,7 @@ func testLoadItCheckAttributes2(t *testing.T) { } func testLoadItStartLoaderToStorDB(t *testing.T) { - cmd := exec.Command("cgr-loader", "-config_path="+ldrItCfgPath, "-path="+path.Join(*dataDir, "tariffplans", "tutorial"), "-caches_address=", "-scheduler_address=", "-to_stordb", "-tpid=TPID") + cmd := exec.Command("cgr-loader", "-config_path="+ldrItCfgPath, "-path="+path.Join(*utils.DataDir, "tariffplans", "tutorial"), "-caches_address=", "-scheduler_address=", "-to_stordb", "-tpid=TPID") output := bytes.NewBuffer(nil) outerr := bytes.NewBuffer(nil) cmd.Stdout = output @@ -383,7 +375,7 @@ func testLoadItStartLoaderFromStorDB(t *testing.T) { } func testLoadItStartLoaderWithTenant(t *testing.T) { - cmd := exec.Command("cgr-loader", "-config_path="+ldrItCfgPath, "-path="+path.Join(*dataDir, "tariffplans", "tutorial"), fmt.Sprintf("-caches_address=%s", address), "-scheduler_address=", `-tenant="tenant.com"`, "-verbose") + cmd := exec.Command("cgr-loader", "-config_path="+ldrItCfgPath, "-path="+path.Join(*utils.DataDir, "tariffplans", "tutorial"), fmt.Sprintf("-caches_address=%s", address), "-scheduler_address=", `-tenant="tenant.com"`, "-verbose") output := bytes.NewBuffer(nil) cmd.Stdout = output if err := cmd.Run(); err != nil { @@ -439,7 +431,7 @@ func testLoadItCheckTenantFlag(t *testing.T) { } func testLoadItStartLoaderFlushStorDB(t *testing.T) { - cmd := exec.Command("cgr-loader", "-config_path="+ldrItCfgPath, "-path="+path.Join(*dataDir, "tariffplans", "dispatchers"), "-caches_address=", "-scheduler_address=", "-to_stordb", "-flush_stordb", "-tpid=TPID") + cmd := exec.Command("cgr-loader", "-config_path="+ldrItCfgPath, "-path="+path.Join(*utils.DataDir, "tariffplans", "dispatchers"), "-caches_address=", "-scheduler_address=", "-to_stordb", "-flush_stordb", "-tpid=TPID") output := bytes.NewBuffer(nil) outerr := bytes.NewBuffer(nil) cmd.Stdout = output @@ -453,7 +445,7 @@ func testLoadItStartLoaderFlushStorDB(t *testing.T) { } func testLoadItStartLoaderWithDelayWConf(t *testing.T) { - cmd := exec.Command("cgr-loader", "-config_path="+path.Join(*dataDir, "conf", "samples", "apier_mysql"), "-path="+path.Join(*dataDir, "tariffplans", "tutorial"), "-caches_address=", "-scheduler_address=", "-to_stordb", "-flush_stordb", "-tpid=TPID") + cmd := exec.Command("cgr-loader", "-config_path="+path.Join(*utils.DataDir, "conf", "samples", "apier_mysql"), "-path="+path.Join(*utils.DataDir, "tariffplans", "tutorial"), "-caches_address=", "-scheduler_address=", "-to_stordb", "-flush_stordb", "-tpid=TPID") output := bytes.NewBuffer(nil) outerr := bytes.NewBuffer(nil) cmd.Stdout = output @@ -467,7 +459,7 @@ func testLoadItStartLoaderWithDelayWConf(t *testing.T) { } func testLoadItStartLoaderWithDelayWFlag(t *testing.T) { - cmd := exec.Command("cgr-loader", "-path="+path.Join(*dataDir, "tariffplans", "tutorial"), "-caches_address=", "-scheduler_address=", "-to_stordb", "-flush_stordb", "-tpid=TPID", "-caching_delay=5s") + cmd := exec.Command("cgr-loader", "-path="+path.Join(*utils.DataDir, "tariffplans", "tutorial"), "-caches_address=", "-scheduler_address=", "-to_stordb", "-flush_stordb", "-tpid=TPID", "-caching_delay=5s") output := bytes.NewBuffer(nil) outerr := bytes.NewBuffer(nil) cmd.Stdout = output diff --git a/cmd/cgr-loader/cgr-loader_remove_it_test.go b/cmd/cgr-loader/cgr-loader_remove_it_test.go index 7aba1b131..55fb1aea1 100644 --- a/cmd/cgr-loader/cgr-loader_remove_it_test.go +++ b/cmd/cgr-loader/cgr-loader_remove_it_test.go @@ -72,7 +72,7 @@ var ( ) func TestCGRLoaderRemove(t *testing.T) { - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: t.SkipNow() case utils.MetaMongo: @@ -91,7 +91,7 @@ func TestCGRLoaderRemove(t *testing.T) { func testCgrLdrInitCfg(t *testing.T) { var err error - cgrLdrCfgPath = path.Join(*dataDir, "conf", "samples", cgrLdrCfgDir) + cgrLdrCfgPath = path.Join(*utils.DataDir, "conf", "samples", cgrLdrCfgDir) cgrLdrCfg, err = config.NewCGRConfigFromPath(cgrLdrCfgPath) if err != nil { t.Error(err) @@ -111,7 +111,7 @@ func testCgrLdrInitStorDB(t *testing.T) { } func testCgrLdrStartEngine(t *testing.T) { - if _, err := engine.StartEngine(cgrLdrCfgPath, *waitRater); err != nil { + if _, err := engine.StartEngine(cgrLdrCfgPath, *utils.WaitRater); err != nil { t.Fatal(err) } } @@ -209,7 +209,7 @@ func testCgrLdrGetSubsystemsNotLoadedLoad(t *testing.T) { func testCgrLdrLoadData(t *testing.T) { // *cacheSAddress = "127.0.0.1:2012" - cmd := exec.Command("cgr-loader", "-config_path="+cgrLdrCfgPath, "-path="+path.Join(*dataDir, "tariffplans", "testit")) + cmd := exec.Command("cgr-loader", "-config_path="+cgrLdrCfgPath, "-path="+path.Join(*utils.DataDir, "tariffplans", "testit")) output := bytes.NewBuffer(nil) outerr := bytes.NewBuffer(nil) cmd.Stdout = output @@ -483,7 +483,7 @@ func testCgrLdrGetChargerProfileAfterLoad(t *testing.T) { func testCgrLdrRemoveData(t *testing.T) { // *cacheSAddress = "127.0.0.1:2012" - cmd := exec.Command("cgr-loader", "-config_path="+cgrLdrCfgPath, "-path="+path.Join(*dataDir, "tariffplans", "testit"), "-remove") + cmd := exec.Command("cgr-loader", "-config_path="+cgrLdrCfgPath, "-path="+path.Join(*utils.DataDir, "tariffplans", "testit"), "-remove") output := bytes.NewBuffer(nil) outerr := bytes.NewBuffer(nil) cmd.Stdout = output @@ -504,7 +504,7 @@ func testCgrLdrKillEngine(t *testing.T) { } func newRPCClient(cfg *config.ListenCfg) (c *birpc.Client, err error) { - switch *encoding { + switch *utils.Encoding { case utils.MetaJSON: return jsonrpc.Dial(utils.TCP, cfg.RPCJSONListen) case utils.MetaGOB: diff --git a/cmd/cgr-tester/cdr_repl/process_cdr.go b/cmd/cgr-tester/cdr_repl/process_cdr.go index 740a9bc3a..6c192bdbc 100644 --- a/cmd/cgr-tester/cdr_repl/process_cdr.go +++ b/cmd/cgr-tester/cdr_repl/process_cdr.go @@ -32,15 +32,13 @@ import ( "github.com/cgrates/rpcclient" ) -var dataDir = flag.String("data_dir", "/usr/share/cgrates", "CGR data dir path here") - func main() { flag.Parse() var err error var cdrsMasterRpc *rpcclient.RPCClient var cdrsMasterCfgPath string var cdrsMasterCfg *config.CGRConfig - cdrsMasterCfgPath = path.Join(*dataDir, "conf", "samples", "cdrsreplicationmaster") + cdrsMasterCfgPath = path.Join(*utils.DataDir, "conf", "samples", "cdrsreplicationmaster") if cdrsMasterCfg, err = config.NewCGRConfigFromPath(cdrsMasterCfgPath); err != nil { log.Fatal("Got config error: ", err.Error()) } diff --git a/dispatchers/attributes_it_test.go b/dispatchers/attributes_it_test.go index 29499d95e..0f0319e23 100644 --- a/dispatchers/attributes_it_test.go +++ b/dispatchers/attributes_it_test.go @@ -52,7 +52,7 @@ var sTestsDspAttr = []func(t *testing.T){ // Test start here func TestDspAttributeS(t *testing.T) { var config1, config2, config3 string - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: t.SkipNow() case utils.MetaMySQL: @@ -70,14 +70,14 @@ func TestDspAttributeS(t *testing.T) { } dispDIR := "dispatchers" - if *encoding == utils.MetaGOB { + if *utils.Encoding == utils.MetaGOB { dispDIR += "_gob" } testDsp(t, sTestsDspAttr, "TestDspAttributeS", config1, config2, config3, "tutorial", "oldtutorial", dispDIR) } func TestDspAttributeSNoConn(t *testing.T) { - if *dbType != utils.MetaMySQL { + if *utils.DBType != utils.MetaMySQL { t.SkipNow() } testDsp(t, []func(t *testing.T){ @@ -240,7 +240,7 @@ func testDspAttrGetAttrFailover(t *testing.T) { Weight: 20.0, } eAttrPrf.Compile() - if *encoding == utils.MetaGOB { + if *utils.Encoding == utils.MetaGOB { eAttrPrf.Attributes[0].FilterIDs = nil // empty slice are nil in gob } @@ -426,7 +426,7 @@ func testDspAttrTestAuthKey2(t *testing.T) { Weight: 20.0, } eAttrPrf.Compile() - if *encoding == utils.MetaGOB { + if *utils.Encoding == utils.MetaGOB { eAttrPrf.Attributes[0].FilterIDs = nil // empty slice are nil in gob } var attrReply *engine.AttributeProfile @@ -520,7 +520,7 @@ func testDspAttrGetAttrRoundRobin(t *testing.T) { Weight: 20.0, } eAttrPrf.Compile() - if *encoding == utils.MetaGOB { + if *utils.Encoding == utils.MetaGOB { eAttrPrf.Attributes[0].FilterIDs = nil // empty slice are nil in gob } diff --git a/dispatchers/caches_it_test.go b/dispatchers/caches_it_test.go index 35b352b2b..dcc2c3d76 100644 --- a/dispatchers/caches_it_test.go +++ b/dispatchers/caches_it_test.go @@ -48,7 +48,7 @@ var sTestsDspChc = []func(t *testing.T){ // Test start here func TestDspCacheSv1(t *testing.T) { var config1, config2, config3 string - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: t.SkipNow() case utils.MetaMySQL: @@ -66,7 +66,7 @@ func TestDspCacheSv1(t *testing.T) { } dispDIR := "dispatchers" - if *encoding == utils.MetaGOB { + if *utils.Encoding == utils.MetaGOB { dispDIR += "_gob" } testDsp(t, sTestsDspChc, "TestDspCacheSv1", config1, config2, config3, "tutorial", "oldtutorial", dispDIR) diff --git a/dispatchers/cdrs_it_test.go b/dispatchers/cdrs_it_test.go index f6ec363b2..01a0d5671 100644 --- a/dispatchers/cdrs_it_test.go +++ b/dispatchers/cdrs_it_test.go @@ -63,7 +63,7 @@ var ( // Test start here func TestDspCDRsIT(t *testing.T) { var config1, config2, config3 string - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: t.SkipNow() case utils.MetaMySQL: @@ -81,17 +81,17 @@ func TestDspCDRsIT(t *testing.T) { } dispDIR := "dispatchers" - if *encoding == utils.MetaGOB { + if *utils.Encoding == utils.MetaGOB { dispDIR += "_gob" } testDsp(t, sTestsDspCDRs, "TestDspCDRs", config1, config2, config3, "tutorial", "oldtutorial", dispDIR) } func TestDspCDRsITMySQLWithoutAuth(t *testing.T) { - if *dbType != utils.MetaMySQL { + if *utils.DBType != utils.MetaMySQL { t.SkipNow() } - if *encoding == utils.MetaGOB { + if *utils.Encoding == utils.MetaGOB { testDsp(t, sTestsDspCDRsWithoutAuth, "TestDspCDRsWithoutAuth", "all_mysql", "all2_mysql", "dispatchers_no_attributes", "tutorial", "oldtutorial", "dispatchers_gob") } else { testDsp(t, sTestsDspCDRsWithoutAuth, "TestDspCDRsWithoutAuth", "all_mysql", "all2_mysql", "dispatchers_no_attributes", "tutorial", "oldtutorial", "dispatchers") diff --git a/dispatchers/chargers_it_test.go b/dispatchers/chargers_it_test.go index f104347d4..5554445ac 100644 --- a/dispatchers/chargers_it_test.go +++ b/dispatchers/chargers_it_test.go @@ -45,7 +45,7 @@ var sTestsDspCpp = []func(t *testing.T){ // Test start here func TestDspChargerST(t *testing.T) { var config1, config2, config3 string - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: t.SkipNow() case utils.MetaMySQL: @@ -63,7 +63,7 @@ func TestDspChargerST(t *testing.T) { } dispDIR := "dispatchers" - if *encoding == utils.MetaGOB { + if *utils.Encoding == utils.MetaGOB { dispDIR += "_gob" } testDsp(t, sTestsDspCpp, "TestDspChargerS", config1, config2, config3, "tutorial", "oldtutorial", dispDIR) @@ -125,7 +125,7 @@ func testDspCppGetChtgFailover(t *testing.T) { Weight: 0, }, } - if *encoding == utils.MetaGOB { + if *utils.Encoding == utils.MetaGOB { (*eChargers)[0].FilterIDs = nil // empty slice are nil in gob } var reply *engine.ChargerProfiles @@ -147,7 +147,7 @@ func testDspCppGetChtgFailover(t *testing.T) { Weight: 0, }, ) - if *encoding == utils.MetaGOB { + if *utils.Encoding == utils.MetaGOB { (*eChargers)[1].FilterIDs = nil // empty slice are nil in gob } if err := dispEngine.RPC.Call(context.Background(), utils.ChargerSv1GetChargersForEvent, @@ -231,7 +231,7 @@ func testDspCppTestAuthKey2(t *testing.T) { Weight: 0, }, } - if *encoding == utils.MetaGOB { + if *utils.Encoding == utils.MetaGOB { (*eChargers)[0].FilterIDs = nil // empty slice are nil in gob (*eChargers)[1].FilterIDs = nil // empty slice are nil in gob } @@ -270,7 +270,7 @@ func testDspCppGetChtgRoundRobin(t *testing.T) { Weight: 0, }, } - if *encoding == utils.MetaGOB { + if *utils.Encoding == utils.MetaGOB { (*eChargers)[0].FilterIDs = nil // empty slice are nil in gob } var reply *engine.ChargerProfiles @@ -292,7 +292,7 @@ func testDspCppGetChtgRoundRobin(t *testing.T) { Weight: 0, }, ) - if *encoding == utils.MetaGOB { + if *utils.Encoding == utils.MetaGOB { (*eChargers)[1].FilterIDs = nil // empty slice are nil in gob } if err := dispEngine.RPC.Call(context.Background(), utils.ChargerSv1GetChargersForEvent, diff --git a/dispatchers/config_it_test.go b/dispatchers/config_it_test.go index 39e67661d..52c0c475f 100644 --- a/dispatchers/config_it_test.go +++ b/dispatchers/config_it_test.go @@ -37,7 +37,7 @@ var sTestsDspConfig = []func(t *testing.T){ // Test start here func TestDspConfigIT(t *testing.T) { var config1, config2, config3 string - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: t.SkipNow() case utils.MetaMySQL: @@ -55,7 +55,7 @@ func TestDspConfigIT(t *testing.T) { } dispDIR := "dispatchers" - if *encoding == utils.MetaGOB { + if *utils.Encoding == utils.MetaGOB { dispDIR += "_gob" } testDsp(t, sTestsDspConfig, "TestDspConfigIT", config1, config2, config3, "tutorial", "oldtutorial", dispDIR) diff --git a/dispatchers/ees_it_test.go b/dispatchers/ees_it_test.go index 527f257d5..c285f0b43 100644 --- a/dispatchers/ees_it_test.go +++ b/dispatchers/ees_it_test.go @@ -41,7 +41,7 @@ var sTestsDspEEs = []func(t *testing.T){ func TestDspEEsIT(t *testing.T) { var config1, config2, config3 string - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: t.SkipNow() case utils.MetaMySQL: @@ -59,7 +59,7 @@ func TestDspEEsIT(t *testing.T) { } dispDIR := "dispatchers" - if *encoding == utils.MetaGOB { + if *utils.Encoding == utils.MetaGOB { dispDIR += "_gob" } testDsp(t, sTestsDspEEs, "TestDspEEs", config1, config2, config3, "tutorial", "oldtutorial", dispDIR) diff --git a/dispatchers/guardian_it_test.go b/dispatchers/guardian_it_test.go index 6d616699b..a9ba02745 100644 --- a/dispatchers/guardian_it_test.go +++ b/dispatchers/guardian_it_test.go @@ -38,7 +38,7 @@ var sTestsDspGrd = []func(t *testing.T){ // Test start here func TestDspGuardianST(t *testing.T) { var config1, config2, config3 string - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: t.SkipNow() case utils.MetaMySQL: @@ -56,7 +56,7 @@ func TestDspGuardianST(t *testing.T) { } dispDIR := "dispatchers" - if *encoding == utils.MetaGOB { + if *utils.Encoding == utils.MetaGOB { dispDIR += "_gob" } testDsp(t, sTestsDspGrd, "TestDspGuardianS", config1, config2, config3, "tutorial", "oldtutorial", dispDIR) diff --git a/dispatchers/lib_test.go b/dispatchers/lib_test.go index 7b71189d4..ea0166f2b 100644 --- a/dispatchers/lib_test.go +++ b/dispatchers/lib_test.go @@ -20,7 +20,6 @@ package dispatchers import ( "errors" - "flag" "os/exec" "path" "strconv" @@ -40,15 +39,9 @@ var ( allEngine *testDispatcher allEngine2 *testDispatcher ) -var ( - waitRater = flag.Int("wait_rater", 100, "Number of miliseconds to wait for rater to start and cache") - dataDir = flag.String("data_dir", "/usr/share/cgrates", "CGR data dir path here") - encoding = flag.String("rpc", utils.MetaJSON, "what encoding whould be used for rpc comunication") - dbType = flag.String("dbtype", utils.MetaInternal, "The type of DataBase (Internal/Mongo/mySql)") -) func newRPCClient(cfg *config.ListenCfg) (c *birpc.Client, err error) { - switch *encoding { + switch *utils.Encoding { case utils.MetaJSON: return jsonrpc.Dial(utils.TCP, cfg.RPCJSONListen) case utils.MetaGOB: @@ -73,7 +66,7 @@ func newTestEngine(t *testing.T, cfgPath string, initDataDB, initStoreDB bool) ( if err != nil { t.Fatalf("Error at config init :%v\n", err) } - d.Cfg.DataFolderPath = *dataDir // Share DataFolderPath through config towards StoreDb for Flush() + d.Cfg.DataFolderPath = *utils.DataDir // Share DataFolderPath through config towards StoreDb for Flush() if initDataDB { d.initDataDb(t) @@ -88,7 +81,7 @@ func newTestEngine(t *testing.T, cfgPath string, initDataDB, initStoreDB bool) ( func (d *testDispatcher) startEngine(t *testing.T) { var err error - if d.cmd, err = engine.StartEngine(d.CfgPath, *waitRater); err != nil { + if d.cmd, err = engine.StartEngine(d.CfgPath, *utils.WaitRater); err != nil { t.Fatalf("Error at engine start:%v\n", err) } @@ -151,12 +144,12 @@ func (d *testDispatcher) loadData2(t *testing.T, path string) { func testDsp(t *testing.T, tests []func(t *testing.T), testName, all, all2, disp, allTF, all2TF, attrTF string) { engine.KillEngine(0) - allEngine = newTestEngine(t, path.Join(*dataDir, "conf", "samples", "dispatchers", all), true, true) - allEngine2 = newTestEngine(t, path.Join(*dataDir, "conf", "samples", "dispatchers", all2), true, true) - dispEngine = newTestEngine(t, path.Join(*dataDir, "conf", "samples", "dispatchers", disp), true, true) - dispEngine.loadData2(t, path.Join(*dataDir, "tariffplans", attrTF)) - allEngine.loadData(t, path.Join(*dataDir, "tariffplans", allTF)) - allEngine2.loadData(t, path.Join(*dataDir, "tariffplans", all2TF)) + allEngine = newTestEngine(t, path.Join(*utils.DataDir, "conf", "samples", "dispatchers", all), true, true) + allEngine2 = newTestEngine(t, path.Join(*utils.DataDir, "conf", "samples", "dispatchers", all2), true, true) + dispEngine = newTestEngine(t, path.Join(*utils.DataDir, "conf", "samples", "dispatchers", disp), true, true) + dispEngine.loadData2(t, path.Join(*utils.DataDir, "tariffplans", attrTF)) + allEngine.loadData(t, path.Join(*utils.DataDir, "tariffplans", allTF)) + allEngine2.loadData(t, path.Join(*utils.DataDir, "tariffplans", all2TF)) time.Sleep(200 * time.Millisecond) for _, stest := range tests { t.Run(testName, stest) diff --git a/dispatchers/rals_it_test.go b/dispatchers/rals_it_test.go index f6cdc19e6..5cb251f4c 100644 --- a/dispatchers/rals_it_test.go +++ b/dispatchers/rals_it_test.go @@ -37,7 +37,7 @@ var sTestsDspRALs = []func(t *testing.T){ // Test start here func TestDspRALsIT(t *testing.T) { var config1, config2, config3 string - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: t.SkipNow() case utils.MetaMySQL: @@ -55,7 +55,7 @@ func TestDspRALsIT(t *testing.T) { } dispDIR := "dispatchers" - if *encoding == utils.MetaGOB { + if *utils.Encoding == utils.MetaGOB { dispDIR += "_gob" } testDsp(t, sTestsDspRALs, "TestDspRALsITMySQL", config1, config2, config3, "tutorial", "oldtutorial", dispDIR) diff --git a/dispatchers/replicator_it_test.go b/dispatchers/replicator_it_test.go index 03cac35bc..67df2f1d5 100644 --- a/dispatchers/replicator_it_test.go +++ b/dispatchers/replicator_it_test.go @@ -60,7 +60,7 @@ var sTestsDspRpl = []func(t *testing.T){ // Test start here func TestDspReplicator(t *testing.T) { var config1, config2, config3 string - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: t.SkipNow() case utils.MetaMySQL: @@ -78,7 +78,7 @@ func TestDspReplicator(t *testing.T) { } dispDIR := "dispatchers" - if *encoding == utils.MetaGOB { + if *utils.Encoding == utils.MetaGOB { dispDIR += "_gob" } testDsp(t, sTestsDspRpl, "TestDspReplicator", config1, config2, config3, "tutorial", "oldtutorial", dispDIR) diff --git a/dispatchers/resources_it_test.go b/dispatchers/resources_it_test.go index ad9d7a649..063639273 100644 --- a/dispatchers/resources_it_test.go +++ b/dispatchers/resources_it_test.go @@ -42,7 +42,7 @@ var sTestsDspRes = []func(t *testing.T){ // Test start here func TestDspResourceSIT(t *testing.T) { var config1, config2, config3 string - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: t.SkipNow() case utils.MetaMySQL: @@ -60,7 +60,7 @@ func TestDspResourceSIT(t *testing.T) { } dispDIR := "dispatchers" - if *encoding == utils.MetaGOB { + if *utils.Encoding == utils.MetaGOB { dispDIR += "_gob" } testDsp(t, sTestsDspRes, "TestDspResourceS", config1, config2, config3, "tutorial", "oldtutorial", dispDIR) diff --git a/dispatchers/responder_it_test.go b/dispatchers/responder_it_test.go index f50887cb0..1a0cd31ea 100644 --- a/dispatchers/responder_it_test.go +++ b/dispatchers/responder_it_test.go @@ -43,7 +43,7 @@ var sTestsDspRsp = []func(t *testing.T){ // Test start here func TestDspResponder(t *testing.T) { var config1, config2, config3 string - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: t.SkipNow() case utils.MetaMySQL: @@ -61,7 +61,7 @@ func TestDspResponder(t *testing.T) { } dispDIR := "dispatchers" - if *encoding == utils.MetaGOB { + if *utils.Encoding == utils.MetaGOB { dispDIR += "_gob" } testDsp(t, sTestsDspRsp, "TestDspResponder", config1, config2, config3, "tutorial", "oldtutorial", dispDIR) diff --git a/dispatchers/routes_it_test.go b/dispatchers/routes_it_test.go index b23b0d7b6..19a75d10d 100644 --- a/dispatchers/routes_it_test.go +++ b/dispatchers/routes_it_test.go @@ -49,7 +49,7 @@ var ( // Test start here func TestDspSupplierS(t *testing.T) { var config1, config2, config3 string - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: t.SkipNow() case utils.MetaMySQL: @@ -67,7 +67,7 @@ func TestDspSupplierS(t *testing.T) { } dispDIR := "dispatchers" - if *encoding == utils.MetaGOB { + if *utils.Encoding == utils.MetaGOB { dispDIR += "_gob" } testDsp(t, sTestsDspSup, "TestDspSupplierS", config1, config2, config3, "tutorial", "oldtutorial", dispDIR) @@ -391,7 +391,7 @@ func testDspSupGetSupplierForEvent(t *testing.T) { }, Weight: 10, } - if *encoding == utils.MetaGOB { + if *utils.Encoding == utils.MetaGOB { expected.SortingParameters = nil // empty slices are nil in gob } var supProf []*engine.RouteProfile diff --git a/dispatchers/scheduler_it_test.go b/dispatchers/scheduler_it_test.go index 2e695c35a..4d8c1c455 100644 --- a/dispatchers/scheduler_it_test.go +++ b/dispatchers/scheduler_it_test.go @@ -36,7 +36,7 @@ var sTestsDspSched = []func(t *testing.T){ func TestDspSchedulerS(t *testing.T) { var config1, config2, config3 string - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: t.SkipNow() case utils.MetaMySQL: @@ -54,7 +54,7 @@ func TestDspSchedulerS(t *testing.T) { } dispDIR := "dispatchers" - if *encoding == utils.MetaGOB { + if *utils.Encoding == utils.MetaGOB { dispDIR += "_gob" } testDsp(t, sTestsDspSched, "TestDspSchedulerSTMySQL", config1, config2, config3, "tutorial", "oldtutorial", dispDIR) diff --git a/dispatchers/sessions_it_test.go b/dispatchers/sessions_it_test.go index 69c4a1fcf..4e222a50e 100644 --- a/dispatchers/sessions_it_test.go +++ b/dispatchers/sessions_it_test.go @@ -65,7 +65,7 @@ var sTestsDspSession = []func(t *testing.T){ // Test start here func TestDspSessionS(t *testing.T) { var config1, config2, config3 string - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: t.SkipNow() case utils.MetaMySQL: @@ -83,7 +83,7 @@ func TestDspSessionS(t *testing.T) { } dispDIR := "dispatchers" - if *encoding == utils.MetaGOB { + if *utils.Encoding == utils.MetaGOB { dispDIR += "_gob" config3 += "_gob" } @@ -411,7 +411,7 @@ func testDspSessionUpdate(t *testing.T) { }, }, } - if *encoding == utils.MetaGOB { // gob maintains the variable type + if *utils.Encoding == utils.MetaGOB { // gob maintains the variable type eAttrs.CGREvent.Event[utils.Usage] = reqUsage eAttrs.CGREvent.Event[utils.SetupTime] = argsUpdate.CGREvent.Event[utils.SetupTime] eAttrs.CGREvent.Event[utils.AnswerTime] = argsUpdate.CGREvent.Event[utils.AnswerTime] @@ -488,7 +488,7 @@ func testDspSessionUpdate2(t *testing.T) { }, } sort.Strings(eAttrs.AlteredFields) - if *encoding == utils.MetaGOB { // gob maintains the variable type + if *utils.Encoding == utils.MetaGOB { // gob maintains the variable type eAttrs.CGREvent.Event[utils.Usage] = reqUsage eAttrs.CGREvent.Event[utils.SetupTime] = argsUpdate.CGREvent.Event[utils.SetupTime] eAttrs.CGREvent.Event[utils.AnswerTime] = argsUpdate.CGREvent.Event[utils.AnswerTime] @@ -645,7 +645,7 @@ func testDspSessionProcessEvent(t *testing.T) { }, }, } - if *encoding == utils.MetaGOB { // gob maintains the variable type + if *utils.Encoding == utils.MetaGOB { // gob maintains the variable type eAttrs.CGREvent.Event[utils.Usage] = initUsage eAttrs.CGREvent.Event[utils.SetupTime] = args.CGREvent.Event[utils.SetupTime] eAttrs.CGREvent.Event[utils.AnswerTime] = args.CGREvent.Event[utils.AnswerTime] @@ -727,7 +727,7 @@ func testDspSessionProcessEvent2(t *testing.T) { }, }, } - if *encoding == utils.MetaGOB { // gob maintains the variable type + if *utils.Encoding == utils.MetaGOB { // gob maintains the variable type eAttrs.CGREvent.Event[utils.Usage] = initUsage eAttrs.CGREvent.Event[utils.SetupTime] = args.CGREvent.Event[utils.SetupTime] eAttrs.CGREvent.Event[utils.AnswerTime] = args.CGREvent.Event[utils.AnswerTime] @@ -751,7 +751,7 @@ func testDspSessionReplicate(t *testing.T) { } else if reply != utils.OK { t.Error("Reply: ", reply) } - allEngine.loadData(t, path.Join(*dataDir, "tariffplans", "testit")) + allEngine.loadData(t, path.Join(*utils.DataDir, "tariffplans", "testit")) testDspSessionAddBalacne(t) testDspSessionAuthorize(t) testDspSessionInit(t) @@ -883,7 +883,7 @@ func testDspSessionForceDisconect(t *testing.T) { allEngine.startEngine(t) allEngine.initDataDb(t) allEngine.resetStorDb(t) - allEngine.loadData(t, path.Join(*dataDir, "tariffplans", "testit")) + allEngine.loadData(t, path.Join(*utils.DataDir, "tariffplans", "testit")) testDspSessionAddBalacne(t) testDspSessionAuthorize(t) testDspSessionInit(t) diff --git a/dispatchers/stats_it_test.go b/dispatchers/stats_it_test.go index 10c30e5dd..89e4b3797 100644 --- a/dispatchers/stats_it_test.go +++ b/dispatchers/stats_it_test.go @@ -44,7 +44,7 @@ var sTestsDspSts = []func(t *testing.T){ // Test start here func TestDspStatS(t *testing.T) { var config1, config2, config3 string - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: t.SkipNow() case utils.MetaMySQL: @@ -62,7 +62,7 @@ func TestDspStatS(t *testing.T) { } dispDIR := "dispatchers" - if *encoding == utils.MetaGOB { + if *utils.Encoding == utils.MetaGOB { dispDIR += "_gob" } testDsp(t, sTestsDspSts, "TestDspStatS", config1, config2, config3, "tutorial", "oldtutorial", dispDIR) diff --git a/dispatchers/thresholds_it_test.go b/dispatchers/thresholds_it_test.go index a3da35482..3d8eb929c 100644 --- a/dispatchers/thresholds_it_test.go +++ b/dispatchers/thresholds_it_test.go @@ -45,7 +45,7 @@ var sTestsDspTh = []func(t *testing.T){ // Test start here func TestDspThresholdS(t *testing.T) { var config1, config2, config3 string - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: t.SkipNow() case utils.MetaMySQL: @@ -63,7 +63,7 @@ func TestDspThresholdS(t *testing.T) { } dispDIR := "dispatchers" - if *encoding == utils.MetaGOB { + if *utils.Encoding == utils.MetaGOB { dispDIR += "_gob" } testDsp(t, sTestsDspTh, "TestDspThresholdS", config1, config2, config3, "tutorial", "oldtutorial", dispDIR) diff --git a/ees/amqp_it_test.go b/ees/amqp_it_test.go index 99122d5cb..070367cc9 100644 --- a/ees/amqp_it_test.go +++ b/ees/amqp_it_test.go @@ -67,7 +67,7 @@ func TestAMQPExport(t *testing.T) { func testAMQPLoadConfig(t *testing.T) { var err error - amqpCfgPath = path.Join(*dataDir, "conf", "samples", amqpConfDir) + amqpCfgPath = path.Join(*utils.DataDir, "conf", "samples", amqpConfDir) if amqpCfg, err = config.NewCGRConfigFromPath(amqpCfgPath); err != nil { t.Error(err) } @@ -91,7 +91,7 @@ func testAMQPResetStorDb(t *testing.T) { } func testAMQPStartEngine(t *testing.T) { - if _, err := engine.StopStartEngine(amqpCfgPath, *waitRater); err != nil { + if _, err := engine.StopStartEngine(amqpCfgPath, *utils.WaitRater); err != nil { t.Fatal(err) } } diff --git a/ees/amqpv1_it_test.go b/ees/amqpv1_it_test.go index 1892bf35a..7702ed237 100644 --- a/ees/amqpv1_it_test.go +++ b/ees/amqpv1_it_test.go @@ -68,7 +68,7 @@ func TestAMQPv1Export(t *testing.T) { func testAMQPv1LoadConfig(t *testing.T) { var err error - amqpv1CfgPath = path.Join(*dataDir, "conf", "samples", amqpv1ConfDir) + amqpv1CfgPath = path.Join(*utils.DataDir, "conf", "samples", amqpv1ConfDir) if amqpv1Cfg, err = config.NewCGRConfigFromPath(amqpv1CfgPath); err != nil { t.Error(err) } @@ -97,7 +97,7 @@ func testAMQPv1ResetStorDB(t *testing.T) { } func testAMQPv1StartEngine(t *testing.T) { - if _, err := engine.StopStartEngine(amqpv1CfgPath, *waitRater); err != nil { + if _, err := engine.StopStartEngine(amqpv1CfgPath, *utils.WaitRater); err != nil { t.Fatal(err) } } diff --git a/ees/elastic_it_test.go b/ees/elastic_it_test.go index a21cf55fc..c34a6b8e2 100644 --- a/ees/elastic_it_test.go +++ b/ees/elastic_it_test.go @@ -79,7 +79,7 @@ func TestElasticExport(t *testing.T) { func testElasticLoadConfig(t *testing.T) { var err error - elasticCfgPath = path.Join(*dataDir, "conf", "samples", elasticConfigDir) + elasticCfgPath = path.Join(*utils.DataDir, "conf", "samples", elasticConfigDir) if elasticCfg, err = config.NewCGRConfigFromPath(elasticCfgPath); err != nil { t.Error(err) } @@ -98,7 +98,7 @@ func testElasticResetStorDb(t *testing.T) { } func testElasticStartEngine(t *testing.T) { - if _, err := engine.StopStartEngine(elasticCfgPath, *waitRater); err != nil { + if _, err := engine.StopStartEngine(elasticCfgPath, *utils.WaitRater); err != nil { t.Fatal(err) } } diff --git a/ees/filecsv_it_test.go b/ees/filecsv_it_test.go index 218e6dd91..1f6e3ef37 100644 --- a/ees/filecsv_it_test.go +++ b/ees/filecsv_it_test.go @@ -75,7 +75,7 @@ func TestCsvExport(t *testing.T) { func testCsvLoadConfig(t *testing.T) { var err error - csvCfgPath = path.Join(*dataDir, "conf", "samples", csvConfigDir) + csvCfgPath = path.Join(*utils.DataDir, "conf", "samples", csvConfigDir) if csvCfg, err = config.NewCGRConfigFromPath(csvCfgPath); err != nil { t.Error(err) } @@ -94,7 +94,7 @@ func testCsvResetStorDb(t *testing.T) { } func testCsvStartEngine(t *testing.T) { - if _, err := engine.StopStartEngine(csvCfgPath, *waitRater); err != nil { + if _, err := engine.StopStartEngine(csvCfgPath, *utils.WaitRater); err != nil { t.Fatal(err) } } diff --git a/ees/filefwv_it_test.go b/ees/filefwv_it_test.go index 858aadcc4..ac2b28d83 100644 --- a/ees/filefwv_it_test.go +++ b/ees/filefwv_it_test.go @@ -66,7 +66,7 @@ func TestFwvExport(t *testing.T) { func testFwvLoadConfig(t *testing.T) { var err error - fwvCfgPath = path.Join(*dataDir, "conf", "samples", fwvConfigDir) + fwvCfgPath = path.Join(*utils.DataDir, "conf", "samples", fwvConfigDir) if fwvCfg, err = config.NewCGRConfigFromPath(fwvCfgPath); err != nil { t.Error(err) } @@ -85,7 +85,7 @@ func testFwvResetStorDb(t *testing.T) { } func testFwvStartEngine(t *testing.T) { - if _, err := engine.StopStartEngine(fwvCfgPath, *waitRater); err != nil { + if _, err := engine.StopStartEngine(fwvCfgPath, *utils.WaitRater); err != nil { t.Fatal(err) } } diff --git a/ees/httppost_it_test.go b/ees/httppost_it_test.go index af454ba1c..e5fc96aa7 100644 --- a/ees/httppost_it_test.go +++ b/ees/httppost_it_test.go @@ -68,7 +68,7 @@ func TestHTTPPostExport(t *testing.T) { func testHTTPPostLoadConfig(t *testing.T) { var err error - httpPostCfgPath = path.Join(*dataDir, "conf", "samples", httpPostConfigDir) + httpPostCfgPath = path.Join(*utils.DataDir, "conf", "samples", httpPostConfigDir) if httpPostCfg, err = config.NewCGRConfigFromPath(httpPostCfgPath); err != nil { t.Error(err) } @@ -87,7 +87,7 @@ func testHTTPPostResetStorDb(t *testing.T) { } func testHTTPPostStartEngine(t *testing.T) { - if _, err := engine.StopStartEngine(httpPostCfgPath, *waitRater); err != nil { + if _, err := engine.StopStartEngine(httpPostCfgPath, *utils.WaitRater); err != nil { t.Fatal(err) } } diff --git a/ees/kafka_it_test.go b/ees/kafka_it_test.go index c8129902b..4223d7e4c 100644 --- a/ees/kafka_it_test.go +++ b/ees/kafka_it_test.go @@ -71,7 +71,7 @@ func TestKafkaExport(t *testing.T) { func testKafkaLoadConfig(t *testing.T) { var err error - kafkaCfgPath = path.Join(*dataDir, "conf", "samples", kafkaConfigDir) + kafkaCfgPath = path.Join(*utils.DataDir, "conf", "samples", kafkaConfigDir) if kafkaCfg, err = config.NewCGRConfigFromPath(kafkaCfgPath); err != nil { t.Error(err) } @@ -90,7 +90,7 @@ func testKafkaResetStorDB(t *testing.T) { } func testKafkaStartEngine(t *testing.T) { - if _, err := engine.StopStartEngine(kafkaCfgPath, *waitRater); err != nil { + if _, err := engine.StopStartEngine(kafkaCfgPath, *utils.WaitRater); err != nil { t.Fatal(err) } } diff --git a/ees/lib_test.go b/ees/lib_test.go index 9cc31703f..8be365b50 100644 --- a/ees/lib_test.go +++ b/ees/lib_test.go @@ -20,7 +20,6 @@ package ees import ( "errors" - "flag" "os" "testing" @@ -32,14 +31,8 @@ import ( "github.com/cgrates/cgrates/utils" ) -var ( - dataDir = flag.String("data_dir", "/usr/share/cgrates", "CGR data dir path here") - waitRater = flag.Int("wait_rater", 100, "Number of milliseconds to wait for rater to start and cache") - encoding = flag.String("rpc", utils.MetaJSON, "what encoding would be used for rpc communication") -) - func newRPCClient(cfg *config.ListenCfg) (c *birpc.Client, err error) { - switch *encoding { + switch *utils.Encoding { case utils.MetaJSON: return jsonrpc.Dial(utils.TCP, cfg.RPCJSONListen) case utils.MetaGOB: diff --git a/ees/nats_it_test.go b/ees/nats_it_test.go index bd5344f8d..ba348d0b7 100644 --- a/ees/nats_it_test.go +++ b/ees/nats_it_test.go @@ -46,7 +46,7 @@ func TestNatsEEJetStream(t *testing.T) { defer cmd.Process.Kill() testCreateDirectory(t) - cgrCfg, err := config.NewCGRConfigFromPath(path.Join(*dataDir, "conf", "samples", "ees")) + cgrCfg, err := config.NewCGRConfigFromPath(path.Join(*utils.DataDir, "conf", "samples", "ees")) if err != nil { t.Fatal(err) } @@ -137,7 +137,7 @@ func TestNatsEE(t *testing.T) { defer cmd.Process.Kill() testCreateDirectory(t) - cgrCfg, err := config.NewCGRConfigFromPath(path.Join(*dataDir, "conf", "samples", "ees")) + cgrCfg, err := config.NewCGRConfigFromPath(path.Join(*utils.DataDir, "conf", "samples", "ees")) if err != nil { t.Fatal(err) } diff --git a/ees/posterjsonmap_it_test.go b/ees/posterjsonmap_it_test.go index 7806ca176..3593fb638 100644 --- a/ees/posterjsonmap_it_test.go +++ b/ees/posterjsonmap_it_test.go @@ -68,7 +68,7 @@ func TestHTTPJsonMapExport(t *testing.T) { func testHTTPJsonMapLoadConfig(t *testing.T) { var err error - httpJSONMapCfgPath = path.Join(*dataDir, "conf", "samples", httpJSONMapConfigDir) + httpJSONMapCfgPath = path.Join(*utils.DataDir, "conf", "samples", httpJSONMapConfigDir) if httpJSONMapCfg, err = config.NewCGRConfigFromPath(httpJSONMapCfgPath); err != nil { t.Error(err) } @@ -87,7 +87,7 @@ func testHTTPJsonMapResetStorDb(t *testing.T) { } func testHTTPJsonMapStartEngine(t *testing.T) { - if _, err := engine.StopStartEngine(httpJSONMapCfgPath, *waitRater); err != nil { + if _, err := engine.StopStartEngine(httpJSONMapCfgPath, *utils.WaitRater); err != nil { t.Fatal(err) } } diff --git a/ees/s3_it_test.go b/ees/s3_it_test.go index 45edb89d3..e593f8f02 100644 --- a/ees/s3_it_test.go +++ b/ees/s3_it_test.go @@ -73,7 +73,7 @@ func TestS3Export(t *testing.T) { func testS3LoadConfig(t *testing.T) { var err error - s3CfgPath = path.Join(*dataDir, "conf", "samples", s3ConfDir) + s3CfgPath = path.Join(*utils.DataDir, "conf", "samples", s3ConfDir) if s3Cfg, err = config.NewCGRConfigFromPath(s3CfgPath); err != nil { t.Error(err) } @@ -98,7 +98,7 @@ func testS3ResetStorDb(t *testing.T) { } func testS3StartEngine(t *testing.T) { - if _, err := engine.StopStartEngine(s3CfgPath, *waitRater); err != nil { + if _, err := engine.StopStartEngine(s3CfgPath, *utils.WaitRater); err != nil { t.Fatal(err) } } diff --git a/ees/sql_it_test.go b/ees/sql_it_test.go index 978fa528c..f3355191f 100644 --- a/ees/sql_it_test.go +++ b/ees/sql_it_test.go @@ -119,7 +119,7 @@ func testSqlEeCreateTable(t *testing.T) { func testSqlEeLoadConfig(t *testing.T) { var err error - sqlEeCfgPath = path.Join(*dataDir, "conf", "samples", sqlEeConfigDir) + sqlEeCfgPath = path.Join(*utils.DataDir, "conf", "samples", sqlEeConfigDir) if sqlEeCfg, err = config.NewCGRConfigFromPath(sqlEeCfgPath); err != nil { t.Error(err) } @@ -132,7 +132,7 @@ func testSqlEeResetDataDB(t *testing.T) { } func testSqlEeStartEngine(t *testing.T) { - if _, err := engine.StopStartEngine(sqlEeCfgPath, *waitRater); err != nil { + if _, err := engine.StopStartEngine(sqlEeCfgPath, *utils.WaitRater); err != nil { t.Fatal(err) } } diff --git a/ees/sqs_it_test.go b/ees/sqs_it_test.go index 9382c9170..a4a40922c 100644 --- a/ees/sqs_it_test.go +++ b/ees/sqs_it_test.go @@ -73,7 +73,7 @@ func TestSQSExport(t *testing.T) { func testSQSLoadConfig(t *testing.T) { var err error - sqsCfgPath = path.Join(*dataDir, "conf", "samples", sqsConfDir) + sqsCfgPath = path.Join(*utils.DataDir, "conf", "samples", sqsConfDir) if sqsCfg, err = config.NewCGRConfigFromPath(sqsCfgPath); err != nil { t.Error(err) } @@ -98,7 +98,7 @@ func testSQSResetStorDb(t *testing.T) { } func testSQSStartEngine(t *testing.T) { - if _, err := engine.StopStartEngine(sqsCfgPath, *waitRater); err != nil { + if _, err := engine.StopStartEngine(sqsCfgPath, *utils.WaitRater); err != nil { t.Fatal(err) } } diff --git a/ees/virtual_ee_it_test.go b/ees/virtual_ee_it_test.go index eca784b5e..88ef0d590 100644 --- a/ees/virtual_ee_it_test.go +++ b/ees/virtual_ee_it_test.go @@ -68,7 +68,7 @@ func TestVirtualExport(t *testing.T) { func testVirtLoadConfig(t *testing.T) { var err error - virtCfgPath = path.Join(*dataDir, "conf", "samples", virtConfigDir) + virtCfgPath = path.Join(*utils.DataDir, "conf", "samples", virtConfigDir) if virtCfg, err = config.NewCGRConfigFromPath(virtCfgPath); err != nil { t.Error(err) } @@ -87,7 +87,7 @@ func testVirtResetStorDb(t *testing.T) { } func testVirtStartEngine(t *testing.T) { - if _, err := engine.StopStartEngine(virtCfgPath, *waitRater); err != nil { + if _, err := engine.StopStartEngine(virtCfgPath, *utils.WaitRater); err != nil { t.Fatal(err) } } diff --git a/engine/lib_test.go b/engine/lib_test.go index dbd8c4895..76a8b31e4 100644 --- a/engine/lib_test.go +++ b/engine/lib_test.go @@ -20,7 +20,6 @@ package engine import ( "errors" - "flag" "github.com/cgrates/birpc" "github.com/cgrates/birpc/jsonrpc" @@ -28,15 +27,8 @@ import ( "github.com/cgrates/cgrates/utils" ) -var ( - dataDir = flag.String("data_dir", "/usr/share/cgrates", "CGR data dir path here") - waitRater = flag.Int("wait_rater", 100, "Number of miliseconds to wait for rater to start and cache") - encoding = flag.String("rpc", utils.MetaJSON, "what encoding whould be uused for rpc comunication") - dbType = flag.String("dbtype", utils.MetaInternal, "The type of DataBase (Internal/Mongo/mySql)") -) - func newRPCClient(cfg *config.ListenCfg) (c *birpc.Client, err error) { - switch *encoding { + switch *utils.Encoding { case utils.MetaJSON: return jsonrpc.Dial(utils.TCP, cfg.RPCJSONListen) case utils.MetaGOB: diff --git a/engine/z_actions2_it_test.go b/engine/z_actions2_it_test.go index 0ce5f062f..081b47aa2 100644 --- a/engine/z_actions2_it_test.go +++ b/engine/z_actions2_it_test.go @@ -55,7 +55,7 @@ var sTestsActions = []func(t *testing.T){ } func TestActionsITRemoveSMCost(t *testing.T) { - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: t.SkipNow() case utils.MetaMySQL: @@ -67,7 +67,7 @@ func TestActionsITRemoveSMCost(t *testing.T) { default: t.Fatal("Unknown Database type") } - if *encoding == utils.MetaGOB { + if *utils.Encoding == utils.MetaGOB { actsCfgDir += "_gob" } @@ -78,7 +78,7 @@ func TestActionsITRemoveSMCost(t *testing.T) { func testActionsInitCfg(t *testing.T) { var err error - actsCfgPath = path.Join(*dataDir, "conf", "samples", actsCfgDir) + actsCfgPath = path.Join(*utils.DataDir, "conf", "samples", actsCfgDir) actsCfg, err = config.NewCGRConfigFromPath(actsCfgPath) if err != nil { t.Error(err) @@ -86,7 +86,7 @@ func testActionsInitCfg(t *testing.T) { } func testActionsInitCdrsStore(t *testing.T) { - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: actsCdrStore = NewInternalDB(nil, nil, true, actsCfg.DataDbCfg().Items) case utils.MetaMySQL: @@ -126,7 +126,7 @@ func testActionsResetStorDb(t *testing.T) { // Start CGR Engine func testActionsStartEngine(t *testing.T) { - if _, err := StopStartEngine(actsCfgPath, *waitRater); err != nil { + if _, err := StopStartEngine(actsCfgPath, *utils.WaitRater); err != nil { t.Fatal(err) } } diff --git a/engine/z_actions_it_test.go b/engine/z_actions_it_test.go index 75275c8d4..03611c458 100644 --- a/engine/z_actions_it_test.go +++ b/engine/z_actions_it_test.go @@ -69,7 +69,7 @@ var ( ) func TestActionsit(t *testing.T) { - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: actionsConfigDIR = "actions_internal" case utils.MetaMySQL: @@ -81,7 +81,7 @@ func TestActionsit(t *testing.T) { default: t.Fatal("Unknown Database type") } - if *encoding == utils.MetaGOB { + if *utils.Encoding == utils.MetaGOB { actionsConfigDIR += "_gob" } @@ -91,7 +91,7 @@ func TestActionsit(t *testing.T) { } func testActionsitInitCfg(t *testing.T) { - actsLclCfgPath = path.Join(*dataDir, "conf", "samples", actionsConfigDIR) + actsLclCfgPath = path.Join(*utils.DataDir, "conf", "samples", actionsConfigDIR) // Init config first var err error actsLclCfg, err = config.NewCGRConfigFromPath(actsLclCfgPath) @@ -111,7 +111,7 @@ func testActionsitInitCdrDb(t *testing.T) { // Finds cgr-engine executable and starts it with default configuration func testActionsitStartEngine(t *testing.T) { - if _, err := StopStartEngine(actsLclCfgPath, *waitRater); err != nil { + if _, err := StopStartEngine(actsLclCfgPath, *utils.WaitRater); err != nil { t.Fatal(err) } } @@ -916,7 +916,7 @@ func testActionsitresetAccountCDR(t *testing.T) { } func testActionsitStopCgrEngine(t *testing.T) { - if err := KillEngine(*waitRater); err != nil { + if err := KillEngine(*utils.WaitRater); err != nil { t.Error(err) } } diff --git a/engine/z_datamanager_it_test.go b/engine/z_datamanager_it_test.go index c584554a6..8aa0328b9 100644 --- a/engine/z_datamanager_it_test.go +++ b/engine/z_datamanager_it_test.go @@ -46,7 +46,7 @@ func TestDMitinitDB(t *testing.T) { var dataDB DataDB var err error - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: t.SkipNow() case utils.MetaMySQL: @@ -58,7 +58,7 @@ func TestDMitinitDB(t *testing.T) { t.Fatal("Could not connect to Redis", err.Error()) } case utils.MetaMongo: - cdrsMongoCfgPath := path.Join(*dataDir, "conf", "samples", "tutmongo") + cdrsMongoCfgPath := path.Join(*utils.DataDir, "conf", "samples", "tutmongo") mgoITCfg, err := config.NewCGRConfigFromPath(cdrsMongoCfgPath) if err != nil { t.Fatal(err) @@ -79,7 +79,7 @@ func TestDMitinitDB(t *testing.T) { dm2 = NewDataManager(dataDB, config.CgrConfig().CacheCfg(), nil) for _, stest := range sTestsDMit { - t.Run(*dbType, stest) + t.Run(*utils.DBType, stest) } } diff --git a/engine/z_filterindexer_it_test.go b/engine/z_filterindexer_it_test.go index 8b6c0ec2e..15e90b7f1 100644 --- a/engine/z_filterindexer_it_test.go +++ b/engine/z_filterindexer_it_test.go @@ -91,7 +91,7 @@ var sTests = []func(t *testing.T){ func TestFilterIndexerIT(t *testing.T) { cfg := config.NewDefaultCGRConfig() - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: dataManager = NewDataManager(NewInternalDB(nil, nil, true, cfg.DataDbCfg().Items), config.CgrConfig().CacheCfg(), nil) @@ -107,7 +107,7 @@ func TestFilterIndexerIT(t *testing.T) { defer redisDB.Close() dataManager = NewDataManager(redisDB, config.CgrConfig().CacheCfg(), nil) case utils.MetaMongo: - cdrsMongoCfgPath := path.Join(*dataDir, "conf", "samples", "tutmongo") + cdrsMongoCfgPath := path.Join(*utils.DataDir, "conf", "samples", "tutmongo") mgoITCfg, err := config.NewCGRConfigFromPath(cdrsMongoCfgPath) if err != nil { t.Fatal(err) @@ -129,7 +129,7 @@ func TestFilterIndexerIT(t *testing.T) { t.Fatal("Unknown Database type") } for _, stest := range sTests { - t.Run(*dbType, stest) + t.Run(*utils.DBType, stest) } } diff --git a/engine/z_loader_it_test.go b/engine/z_loader_it_test.go index 3db28b8dc..e425a8d49 100644 --- a/engine/z_loader_it_test.go +++ b/engine/z_loader_it_test.go @@ -58,7 +58,7 @@ var ( ) func TestLoaderIT(t *testing.T) { - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: loaderConfigDIR = "tutinternal" case utils.MetaMySQL: @@ -77,7 +77,7 @@ func TestLoaderIT(t *testing.T) { } func testLoaderITInitConfig(t *testing.T) { - loaderCfgPath = path.Join(*dataDir, "conf", "samples", loaderConfigDIR) + loaderCfgPath = path.Join(*utils.DataDir, "conf", "samples", loaderConfigDIR) lCfg, err = config.NewCGRConfigFromPath(loaderCfgPath) if err != nil { t.Error(err) @@ -121,10 +121,10 @@ func testLoaderITInitStoreDB(t *testing.T) { storDb = db // Creating the table serves also as reset since there is a drop prior to create dbdir := "mysql" - if *dbType == utils.MetaPostgres { + if *utils.DBType == utils.MetaPostgres { dbdir = "postgres" } - if err := db.Flush(path.Join(*dataDir, "storage", dbdir)); err != nil { + if err := db.Flush(path.Join(*utils.DataDir, "storage", dbdir)); err != nil { t.Error("Error on db creation: ", err.Error()) return // No point in going further } @@ -134,11 +134,11 @@ func testLoaderITInitStoreDB(t *testing.T) { func testLoaderITRemoveLoad(t *testing.T) { var err error /*for fn, v := range FileValidators { - if err = ValidateCSVData(path.Join(*dataDir, "tariffplans", *tpCsvScenario, fn), v.Rule); err != nil { + if err = ValidateCSVData(path.Join(*utils.DataDir, "tariffplans", *tpCsvScenario, fn), v.Rule); err != nil { t.Error("Failed validating data: ", err.Error()) } }*/ - csvStorage, err := NewFileCSVStorage(utils.CSVSep, path.Join(*dataDir, "tariffplans", *tpCsvScenario)) + csvStorage, err := NewFileCSVStorage(utils.CSVSep, path.Join(*utils.DataDir, "tariffplans", *tpCsvScenario)) if err != nil { t.Fatal(err) } @@ -216,11 +216,11 @@ func testLoaderITRemoveLoad(t *testing.T) { func testLoaderITLoadFromCSV(t *testing.T) { var err error /*for fn, v := range FileValidators { - if err = ValidateCSVData(path.Join(*dataDir, "tariffplans", *tpCsvScenario, fn), v.Rule); err != nil { + if err = ValidateCSVData(path.Join(*utils.DataDir, "tariffplans", *tpCsvScenario, fn), v.Rule); err != nil { t.Error("Failed validating data: ", err.Error()) } }*/ - csvStorage, err := NewFileCSVStorage(utils.CSVSep, path.Join(*dataDir, "tariffplans", *tpCsvScenario)) + csvStorage, err := NewFileCSVStorage(utils.CSVSep, path.Join(*utils.DataDir, "tariffplans", *tpCsvScenario)) if err != nil { t.Fatal(err) } @@ -512,7 +512,7 @@ func testLoaderITImportToStorDb(t *testing.T) { csvImporter := TPCSVImporter{ TPid: utils.TestSQL, StorDb: storDb, - DirPath: path.Join(*dataDir, "tariffplans", *tpCsvScenario), + DirPath: path.Join(*utils.DataDir, "tariffplans", *tpCsvScenario), Sep: utils.CSVSep, Verbose: false, ImportId: utils.TestSQL} diff --git a/engine/z_onstor_it_test.go b/engine/z_onstor_it_test.go index e616c884a..6b8829ec3 100644 --- a/engine/z_onstor_it_test.go +++ b/engine/z_onstor_it_test.go @@ -86,7 +86,7 @@ var ( func TestOnStorIT(t *testing.T) { cfg := config.NewDefaultCGRConfig() - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: onStor = NewDataManager(NewInternalDB(nil, nil, true, cfg.DataDbCfg().Items), config.CgrConfig().CacheCfg(), nil) @@ -101,7 +101,7 @@ func TestOnStorIT(t *testing.T) { onStorCfg = cfg.DataDbCfg().Name onStor = NewDataManager(rdsITdb, config.CgrConfig().CacheCfg(), nil) case utils.MetaMongo: - cdrsMongoCfgPath := path.Join(*dataDir, "conf", "samples", "cdrsv2mongo") + cdrsMongoCfgPath := path.Join(*utils.DataDir, "conf", "samples", "cdrsv2mongo") mgoITCfg, err := config.NewCGRConfigFromPath(cdrsMongoCfgPath) if err != nil { t.Fatal(err) @@ -122,7 +122,7 @@ func TestOnStorIT(t *testing.T) { } for _, stest := range sTestsOnStorIT { - t.Run(*dbType, stest) + t.Run(*utils.DBType, stest) } } diff --git a/engine/z_storage_cdrs_it_test.go b/engine/z_storage_cdrs_it_test.go index 51c2b93a3..b2f117d8c 100644 --- a/engine/z_storage_cdrs_it_test.go +++ b/engine/z_storage_cdrs_it_test.go @@ -35,7 +35,7 @@ import ( func TestITCDRs(t *testing.T) { var cdrsConfigDIR string - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: cdrsConfigDIR = "internal" case utils.MetaMySQL: @@ -48,7 +48,7 @@ func TestITCDRs(t *testing.T) { t.Fatal("Unknown Database type") } - cfg, err := config.NewCGRConfigFromPath(path.Join(*dataDir, "conf", "samples", "storage", cdrsConfigDIR)) + cfg, err := config.NewCGRConfigFromPath(path.Join(*utils.DataDir, "conf", "samples", "storage", cdrsConfigDIR)) if err != nil { t.Error(err) } @@ -457,7 +457,7 @@ func testGetCDRs(cfg *config.CGRConfig) error { if err := cdrStorage.SetCDR(cdr, false); err != nil { return fmt.Errorf("testGetCDRs #4 CDR: %+v, err: %v", cdr, err) } - if *dbType == utils.MetaMySQL || *dbType == utils.MetaPostgres { + if *utils.DBType == utils.MetaMySQL || *utils.DBType == utils.MetaPostgres { cdr.OrderID = int64(i + 1) } } @@ -828,7 +828,7 @@ func testGetCDRs(cfg *config.CGRConfig) error { for i, cdr := range CDRs { cdr.SetupTime = cdr.SetupTime.UTC() cdr.AnswerTime = cdr.AnswerTime.UTC() - if *dbType == utils.MetaMongo { + if *utils.DBType == utils.MetaMongo { cdrs[i].OrderID = cdr.OrderID } } @@ -843,7 +843,7 @@ func testGetCDRs(cfg *config.CGRConfig) error { for i, cdr := range CDRs { cdr.SetupTime = cdr.SetupTime.UTC() cdr.AnswerTime = cdr.AnswerTime.UTC() - if *dbType == utils.MetaMongo { + if *utils.DBType == utils.MetaMongo { cdrs[i].OrderID = cdr.OrderID } } @@ -858,7 +858,7 @@ func testGetCDRs(cfg *config.CGRConfig) error { for i, cdr := range CDRs { cdr.SetupTime = cdr.SetupTime.UTC() cdr.AnswerTime = cdr.AnswerTime.UTC() - if *dbType == utils.MetaMongo { + if *utils.DBType == utils.MetaMongo { cdrs[i+2].OrderID = cdr.OrderID } } diff --git a/engine/z_stordb_it_test.go b/engine/z_stordb_it_test.go index 4d7818911..0fbbdaa19 100644 --- a/engine/z_stordb_it_test.go +++ b/engine/z_stordb_it_test.go @@ -74,13 +74,13 @@ var sTestsStorDBit = []func(t *testing.T){ func TestStorDBit(t *testing.T) { //var stestName string - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: storDBCfg = config.NewDefaultCGRConfig() config.SetCgrConfig(storDBCfg) storDB = NewInternalDB(nil, nil, false, storDBCfg.DataDbCfg().Items) case utils.MetaMySQL: - if storDBCfg, err = config.NewCGRConfigFromPath(path.Join(*dataDir, "conf", "samples", "storage", "mysql")); err != nil { + if storDBCfg, err = config.NewCGRConfigFromPath(path.Join(*utils.DataDir, "conf", "samples", "storage", "mysql")); err != nil { t.Fatal(err) } if storDB, err = NewMySQLStorage(storDBCfg.StorDbCfg().Host, @@ -91,7 +91,7 @@ func TestStorDBit(t *testing.T) { } storDB.(*SQLStorage).db.Config.Logger = logger.Default.LogMode(logger.Silent) case utils.MetaMongo: - if storDBCfg, err = config.NewCGRConfigFromPath(path.Join(*dataDir, "conf", "samples", "storage", "mongo")); err != nil { + if storDBCfg, err = config.NewCGRConfigFromPath(path.Join(*utils.DataDir, "conf", "samples", "storage", "mongo")); err != nil { t.Fatal(err) } if storDB, err = NewMongoStorage("mongodb", storDBCfg.StorDbCfg().Host, @@ -102,7 +102,7 @@ func TestStorDBit(t *testing.T) { t.Fatal(err) } case utils.MetaPostgres: - if storDBCfg, err = config.NewCGRConfigFromPath(path.Join(*dataDir, "conf", "samples", "storage", "postgres")); err != nil { + if storDBCfg, err = config.NewCGRConfigFromPath(path.Join(*utils.DataDir, "conf", "samples", "storage", "postgres")); err != nil { t.Fatal(err) } if storDB, err = NewPostgresStorage(storDBCfg.StorDbCfg().Host, diff --git a/engine/z_versions_it_test.go b/engine/z_versions_it_test.go index 303def5f8..733389278 100644 --- a/engine/z_versions_it_test.go +++ b/engine/z_versions_it_test.go @@ -74,7 +74,7 @@ var ( ) func TestVersionsIT(t *testing.T) { - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: t.SkipNow() case utils.MetaMySQL: @@ -93,7 +93,7 @@ func TestVersionsIT(t *testing.T) { } func testInitConfig(t *testing.T) { - if versionCfg, err = config.NewCGRConfigFromPath(path.Join(*dataDir, "conf", "samples", versionsConfigDIR)); err != nil { + if versionCfg, err = config.NewCGRConfigFromPath(path.Join(*utils.DataDir, "conf", "samples", versionsConfigDIR)); err != nil { t.Fatal(err) } } diff --git a/ers/ers_reload_it_test.go b/ers/ers_reload_it_test.go index 3d23ebb62..a1294e949 100644 --- a/ers/ers_reload_it_test.go +++ b/ers/ers_reload_it_test.go @@ -54,7 +54,7 @@ var ( ) func TestERsReload(t *testing.T) { - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: ersReloadConfigDIR = "disabled_internal" case utils.MetaMySQL: @@ -74,7 +74,7 @@ func TestERsReload(t *testing.T) { func testReloadITInitConfig(t *testing.T) { var err error - reloadCfgPath = path.Join(*dataDir, "conf", "samples", "ers_reload", ersReloadConfigDIR) + reloadCfgPath = path.Join(*utils.DataDir, "conf", "samples", "ers_reload", ersReloadConfigDIR) if reloadCfg, err = config.NewCGRConfigFromPath(reloadCfgPath); err != nil { t.Fatal("Got config error: ", err.Error()) } @@ -107,7 +107,7 @@ func testReloadITCreateCdrDirs(t *testing.T) { } func testReloadITStartEngine(t *testing.T) { - if _, err := engine.StopStartEngine(reloadCfgPath, *waitRater); err != nil { + if _, err := engine.StopStartEngine(reloadCfgPath, *utils.WaitRater); err != nil { t.Fatal(err) } } @@ -132,7 +132,7 @@ func testReloadVerifyDisabledReaders(t *testing.T) { func testReloadReloadConfigFromPath(t *testing.T) { var reply string if err := reloadRPC.Call(context.Background(), utils.ConfigSv1ReloadConfig, &config.ReloadArgs{ - Path: path.Join(*dataDir, "conf", "samples", "ers_reload", "first_reload"), + Path: path.Join(*utils.DataDir, "conf", "samples", "ers_reload", "first_reload"), Section: config.ERsJson, }, &reply); err != nil { t.Error(err) @@ -163,7 +163,7 @@ func testReloadVerifyFirstReload(t *testing.T) { } func testReloadITKillEngine(t *testing.T) { - if err := engine.KillEngine(*waitRater); err != nil { + if err := engine.KillEngine(*utils.WaitRater); err != nil { t.Error(err) } } diff --git a/ers/filecsv_it_test.go b/ers/filecsv_it_test.go index ff7ebd8c7..064929c78 100644 --- a/ers/filecsv_it_test.go +++ b/ers/filecsv_it_test.go @@ -86,7 +86,7 @@ accid23;*rated;cgrates.org;1001;086517174963;2013-02-03 19:54:00;26;val_extra3;" ) func TestCsvReadFile(t *testing.T) { - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: csvCfgDIR = "ers_internal" case utils.MetaMySQL: @@ -106,7 +106,7 @@ func TestCsvReadFile(t *testing.T) { func testCsvITInitConfig(t *testing.T) { var err error - csvCfgPath = path.Join(*dataDir, "conf", "samples", csvCfgDIR) + csvCfgPath = path.Join(*utils.DataDir, "conf", "samples", csvCfgDIR) if csvCfg, err = config.NewCGRConfigFromPath(csvCfgPath); err != nil { t.Fatal("Got config error: ", err.Error()) } @@ -127,7 +127,7 @@ func testCsvITResetDataDb(t *testing.T) { } func testCsvITStartEngine(t *testing.T) { - if _, err := engine.StopStartEngine(csvCfgPath, *waitRater); err != nil { + if _, err := engine.StopStartEngine(csvCfgPath, *utils.WaitRater); err != nil { t.Fatal(err) } } @@ -143,7 +143,7 @@ func testCsvITRpcConn(t *testing.T) { func testCsvITLoadTPFromFolder(t *testing.T) { attrs := &utils.AttrLoadTpFromFolder{ - FolderPath: path.Join(*dataDir, "tariffplans", "testit")} + FolderPath: path.Join(*utils.DataDir, "tariffplans", "testit")} var loadInst utils.LoadInstance if err := csvRPC.Call(context.Background(), utils.APIerSv2LoadTariffPlanFromFolder, attrs, &loadInst); err != nil { @@ -371,7 +371,7 @@ func testCsvITAnalyzeReaderWithFilter(t *testing.T) { } func testCsvITKillEngine(t *testing.T) { - if err := engine.KillEngine(*waitRater); err != nil { + if err := engine.KillEngine(*utils.WaitRater); err != nil { t.Error(err) } } diff --git a/ers/filefwv_it_test.go b/ers/filefwv_it_test.go index 76b87d5b0..1ffaacf92 100644 --- a/ers/filefwv_it_test.go +++ b/ers/filefwv_it_test.go @@ -59,7 +59,7 @@ var ( ) func TestFWVReadFile(t *testing.T) { - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: fwvCfgDIR = "ers_internal" case utils.MetaMySQL: @@ -79,7 +79,7 @@ func TestFWVReadFile(t *testing.T) { func testFWVITInitConfig(t *testing.T) { var err error - fwvCfgPath = path.Join(*dataDir, "conf", "samples", fwvCfgDIR) + fwvCfgPath = path.Join(*utils.DataDir, "conf", "samples", fwvCfgDIR) if fwvCfg, err = config.NewCGRConfigFromPath(fwvCfgPath); err != nil { t.Fatal("Got config error: ", err.Error()) } @@ -100,7 +100,7 @@ func testFWVITResetDataDb(t *testing.T) { } func testFWVITStartEngine(t *testing.T) { - if _, err := engine.StopStartEngine(fwvCfgPath, *waitRater); err != nil { + if _, err := engine.StopStartEngine(fwvCfgPath, *utils.WaitRater); err != nil { t.Fatal(err) } } @@ -201,7 +201,7 @@ func testFWVITAnalyseCDRs(t *testing.T) { } func testFWVITKillEngine(t *testing.T) { - if err := engine.KillEngine(*waitRater); err != nil { + if err := engine.KillEngine(*utils.WaitRater); err != nil { t.Error(err) } } diff --git a/ers/filejson_it_test.go b/ers/filejson_it_test.go index 5ac9faaff..b127e042a 100644 --- a/ers/filejson_it_test.go +++ b/ers/filejson_it_test.go @@ -75,7 +75,7 @@ var ( ) func TestJSONReadFile(t *testing.T) { - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: jsonCfgDIR = "ers_internal" case utils.MetaMySQL: @@ -95,7 +95,7 @@ func TestJSONReadFile(t *testing.T) { func testJSONInitConfig(t *testing.T) { var err error - jsonCfgPath = path.Join(*dataDir, "conf", "samples", jsonCfgDIR) + jsonCfgPath = path.Join(*utils.DataDir, "conf", "samples", jsonCfgDIR) if jsonCfg, err = config.NewCGRConfigFromPath(jsonCfgPath); err != nil { t.Fatal("Got config error: ", err.Error()) } @@ -116,7 +116,7 @@ func testJSONResetDataDb(t *testing.T) { } func testJSONStartEngine(t *testing.T) { - if _, err := engine.StopStartEngine(jsonCfgPath, *waitRater); err != nil { + if _, err := engine.StopStartEngine(jsonCfgPath, *utils.WaitRater); err != nil { t.Fatal(err) } } @@ -225,7 +225,7 @@ func testJSONVerify(t *testing.T) { } func testJSONKillEngine(t *testing.T) { - if err := engine.KillEngine(*waitRater); err != nil { + if err := engine.KillEngine(*utils.WaitRater); err != nil { t.Error(err) } } diff --git a/ers/filexml_it_test.go b/ers/filexml_it_test.go index d4395db39..18895e638 100644 --- a/ers/filexml_it_test.go +++ b/ers/filexml_it_test.go @@ -61,7 +61,7 @@ var ( ) func TestXMLReadFile(t *testing.T) { - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: xmlCfgDIR = "ers_internal" case utils.MetaMySQL: @@ -80,7 +80,7 @@ func TestXMLReadFile(t *testing.T) { func testXMLITInitConfig(t *testing.T) { var err error - xmlCfgPath = path.Join(*dataDir, "conf", "samples", xmlCfgDIR) + xmlCfgPath = path.Join(*utils.DataDir, "conf", "samples", xmlCfgDIR) if xmlCfg, err = config.NewCGRConfigFromPath(xmlCfgPath); err != nil { t.Fatal("Got config error: ", err.Error()) } @@ -101,7 +101,7 @@ func testXMLITResetDataDb(t *testing.T) { } func testXMLITStartEngine(t *testing.T) { - if _, err := engine.StopStartEngine(xmlCfgPath, *waitRater); err != nil { + if _, err := engine.StopStartEngine(xmlCfgPath, *utils.WaitRater); err != nil { t.Fatal(err) } } @@ -117,7 +117,7 @@ func testXMLITRpcConn(t *testing.T) { func testXMLITLoadTPFromFolder(t *testing.T) { attrs := &utils.AttrLoadTpFromFolder{ - FolderPath: path.Join(*dataDir, "tariffplans", "testit")} + FolderPath: path.Join(*utils.DataDir, "tariffplans", "testit")} var loadInst utils.LoadInstance if err := xmlRPC.Call(context.Background(), utils.APIerSv2LoadTariffPlanFromFolder, attrs, &loadInst); err != nil { @@ -335,7 +335,7 @@ func testXMLITEmptyRootPathCaseCheckCDRs(t *testing.T) { } func testXMLITKillEngine(t *testing.T) { - if err := engine.KillEngine(*waitRater); err != nil { + if err := engine.KillEngine(*utils.WaitRater); err != nil { t.Error(err) } } diff --git a/ers/flatstore_it_test.go b/ers/flatstore_it_test.go index d6c51aa03..fd2a70f61 100644 --- a/ers/flatstore_it_test.go +++ b/ers/flatstore_it_test.go @@ -102,7 +102,7 @@ BYE|3111f3c9|49ca4c42|a58ebaae40d08d6757d8424fb09c4c54@0:0:0:0:0:0:0:0|200|OK|14 ) func TestFlatstoreFile(t *testing.T) { - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: flatstoreCfgDIR = "ers_internal" case utils.MetaMySQL: @@ -121,7 +121,7 @@ func TestFlatstoreFile(t *testing.T) { func testFlatstoreITInitConfig(t *testing.T) { var err error - flatstoreCfgPath = path.Join(*dataDir, "conf", "samples", flatstoreCfgDIR) + flatstoreCfgPath = path.Join(*utils.DataDir, "conf", "samples", flatstoreCfgDIR) if flatstoreCfg, err = config.NewCGRConfigFromPath(flatstoreCfgPath); err != nil { t.Fatal("Got config error: ", err.Error()) } @@ -142,7 +142,7 @@ func testFlatstoreITResetDataDb(t *testing.T) { } func testFlatstoreITStartEngine(t *testing.T) { - if _, err := engine.StopStartEngine(flatstoreCfgPath, *waitRater); err != nil { + if _, err := engine.StopStartEngine(flatstoreCfgPath, *utils.WaitRater); err != nil { t.Fatal(err) } } @@ -327,7 +327,7 @@ func testFlatstoreITAnalyseCDRs3(t *testing.T) { } func testFlatstoreITKillEngine(t *testing.T) { - if err := engine.KillEngine(*waitRater); err != nil { + if err := engine.KillEngine(*utils.WaitRater); err != nil { t.Error(err) } } diff --git a/ers/lib_test.go b/ers/lib_test.go index b3d8821d3..385150d07 100644 --- a/ers/lib_test.go +++ b/ers/lib_test.go @@ -20,7 +20,6 @@ package ers import ( "errors" - "flag" "os" "testing" @@ -30,15 +29,8 @@ import ( "github.com/cgrates/cgrates/utils" ) -var ( - dataDir = flag.String("data_dir", "/usr/share/cgrates", "CGR data dir path here") - waitRater = flag.Int("wait_rater", 100, "Number of miliseconds to wait for rater to start and cache") - encoding = flag.String("rpc", utils.MetaJSON, "what encoding whould be uused for rpc comunication") - dbType = flag.String("dbtype", utils.MetaInternal, "The type of DataBase (Internal/Mongo/mySql)") -) - func newRPCClient(cfg *config.ListenCfg) (c *birpc.Client, err error) { - switch *encoding { + switch *utils.Encoding { case utils.MetaJSON: return jsonrpc.Dial(utils.TCP, cfg.RPCJSONListen) case utils.MetaGOB: diff --git a/ers/nats_it_test.go b/ers/nats_it_test.go index e0a887977..dcde71061 100644 --- a/ers/nats_it_test.go +++ b/ers/nats_it_test.go @@ -40,7 +40,7 @@ import ( ) func TestNatsConcurrentReaders(t *testing.T) { - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: case utils.MetaMySQL, utils.MetaMongo, utils.MetaPostgres: t.SkipNow() @@ -48,7 +48,7 @@ func TestNatsConcurrentReaders(t *testing.T) { t.Fatal("unsupported dbtype value") } - cfgPath := path.Join(*dataDir, "conf", "samples", "ers_nats") + cfgPath := path.Join(*utils.DataDir, "conf", "samples", "ers_nats") cfg, err := config.NewCGRConfigFromPath(cfgPath) if err != nil { t.Fatal("could not init cfg", err.Error()) @@ -181,7 +181,7 @@ var natsCfg string = `{ }` func TestNatsNormalTT(t *testing.T) { - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: case utils.MetaMySQL, utils.MetaMongo, utils.MetaPostgres: t.SkipNow() @@ -315,12 +315,12 @@ resolver_preload: { t.Fatal(err) } - if _, err = engine.StartEngine(cfgPath, *waitRater); err != nil { + if _, err = engine.StartEngine(cfgPath, *utils.WaitRater); err != nil { t.Fatal(err) } t.Cleanup(func() { - engine.KillEngine(*waitRater) + engine.KillEngine(*utils.WaitRater) nc.Close() }) @@ -356,7 +356,7 @@ resolver_preload: { } func TestNatsJetStreamTT(t *testing.T) { - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: case utils.MetaMySQL, utils.MetaMongo, utils.MetaPostgres: t.SkipNow() @@ -516,10 +516,10 @@ system_account:AAFIBB6C56ROU5XRVJLJYR3BTGGYK3HJGHEHQV7L7QZMTT3ZRBLHBS7F } defer js.DeleteStream(context.Background(), "stream") - if _, err = engine.StartEngine(cfgPath, *waitRater); err != nil { + if _, err = engine.StartEngine(cfgPath, *utils.WaitRater); err != nil { t.Fatal(err) } - defer engine.KillEngine(*waitRater) + defer engine.KillEngine(*utils.WaitRater) client, err := newRPCClient(cfg.ListenCfg()) if err != nil { diff --git a/ers/partial_csv_it_test.go b/ers/partial_csv_it_test.go index 88dced705..876de4dc0 100644 --- a/ers/partial_csv_it_test.go +++ b/ers/partial_csv_it_test.go @@ -71,7 +71,7 @@ var ( ) func TestPartReadFile(t *testing.T) { - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: partCfgDIR = "ers_internal" case utils.MetaMySQL: @@ -90,7 +90,7 @@ func TestPartReadFile(t *testing.T) { func testPartITInitConfig(t *testing.T) { var err error - partCfgPath = path.Join(*dataDir, "conf", "samples", partCfgDIR) + partCfgPath = path.Join(*utils.DataDir, "conf", "samples", partCfgDIR) if partCfg, err = config.NewCGRConfigFromPath(partCfgPath); err != nil { t.Fatal("Got config error: ", err.Error()) } @@ -111,7 +111,7 @@ func testPartITResetDataDb(t *testing.T) { } func testPartITStartEngine(t *testing.T) { - if _, err := engine.StopStartEngine(partCfgPath, *waitRater); err != nil { + if _, err := engine.StopStartEngine(partCfgPath, *utils.WaitRater); err != nil { t.Fatal(err) } } @@ -223,7 +223,7 @@ func testPartITAnalyseCDRs(t *testing.T) { } func testPartITKillEngine(t *testing.T) { - if err := engine.KillEngine(*waitRater); err != nil { + if err := engine.KillEngine(*utils.WaitRater); err != nil { t.Error(err) } } diff --git a/ers/sql_it_test.go b/ers/sql_it_test.go index b6d1c87e1..9b42a697e 100644 --- a/ers/sql_it_test.go +++ b/ers/sql_it_test.go @@ -77,7 +77,7 @@ var ( ) func TestSQL(t *testing.T) { - // sqlCfgPath = path.Join(*dataDir, "conf", "samples", "ers_reload", "disabled") + // sqlCfgPath = path.Join(*utils.DataDir, "conf", "samples", "ers_reload", "disabled") for _, test := range sqlTests { t.Run("TestSQL", test) } @@ -358,7 +358,7 @@ func TestSQLReaderServeBadTypeErr(t *testing.T) { } func TestSQL2(t *testing.T) { - // sqlCfgPath = path.Join(*dataDir, "conf", "samples", "ers_reload", "disabled") + // sqlCfgPath = path.Join(*utils.DataDir, "conf", "samples", "ers_reload", "disabled") for _, test := range sqlTests2 { t.Run("TestSQL", test) } diff --git a/general_tests/a1_it_test.go b/general_tests/a1_it_test.go index 6766d9be3..1deef43b6 100644 --- a/general_tests/a1_it_test.go +++ b/general_tests/a1_it_test.go @@ -59,7 +59,7 @@ var ( ) func TestA1It(t *testing.T) { - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: a1ConfigDir = "tutinternal" case utils.MetaMySQL: @@ -78,7 +78,7 @@ func TestA1It(t *testing.T) { } func testA1itLoadConfig(t *testing.T) { - a1CfgPath = path.Join(*dataDir, "conf", "samples", a1ConfigDir) + a1CfgPath = path.Join(*utils.DataDir, "conf", "samples", a1ConfigDir) if a1Cfg, err = config.NewCGRConfigFromPath(a1CfgPath); err != nil { t.Error(err) } @@ -97,7 +97,7 @@ func testA1itResetStorDb(t *testing.T) { } func testA1itStartEngine(t *testing.T) { - if _, err := engine.StopStartEngine(a1CfgPath, *waitRater); err != nil { + if _, err := engine.StopStartEngine(a1CfgPath, *utils.WaitRater); err != nil { t.Fatal(err) } } @@ -112,7 +112,7 @@ func testA1itRPCConn(t *testing.T) { func testA1itLoadTPFromFolder(t *testing.T) { var reply string - attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*dataDir, "tariffplans", "test", "a1")} + attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*utils.DataDir, "tariffplans", "test", "a1")} if err := a1rpc.Call(context.Background(), utils.APIerSv1LoadTariffPlanFromFolder, attrs, &reply); err != nil { t.Error(err) } else if reply != utils.OK { diff --git a/general_tests/accounts_it_test.go b/general_tests/accounts_it_test.go index 2b7524a7b..bb3ab168c 100644 --- a/general_tests/accounts_it_test.go +++ b/general_tests/accounts_it_test.go @@ -64,7 +64,7 @@ var ( // Test start here func TestAccIT(t *testing.T) { - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: accConfDIR = "tutinternal" case utils.MetaMySQL: @@ -84,7 +84,7 @@ func TestAccIT(t *testing.T) { func testV1AccLoadConfig(t *testing.T) { var err error - accCfgPath = path.Join(*dataDir, "conf", "samples", accConfDIR) + accCfgPath = path.Join(*utils.DataDir, "conf", "samples", accConfDIR) if accCfg, err = config.NewCGRConfigFromPath(accCfgPath); err != nil { t.Error(err) } @@ -128,7 +128,7 @@ func testV1AccGetAccountBeforeSet(t *testing.T) { func testV1AccLoadTarrifPlans(t *testing.T) { var reply string - attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*dataDir, "tariffplans", "testit")} + attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*utils.DataDir, "tariffplans", "testit")} if err := accRpc.Call(context.Background(), utils.APIerSv1LoadTariffPlanFromFolder, attrs, &reply); err != nil { t.Error(err) } else if reply != utils.OK { diff --git a/general_tests/accountswiththresholds_it_test.go b/general_tests/accountswiththresholds_it_test.go index 35a71d3e8..832aeceb3 100644 --- a/general_tests/accountswiththresholds_it_test.go +++ b/general_tests/accountswiththresholds_it_test.go @@ -61,7 +61,7 @@ var ( // Test starts here func TestAccWThdIT(t *testing.T) { - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: accWThdConfDIR = "tutinternal" case utils.MetaMySQL: @@ -81,7 +81,7 @@ func TestAccWThdIT(t *testing.T) { func testAccWThdLoadConfig(t *testing.T) { var err error - accWThdCfgPath = path.Join(*dataDir, "conf", "samples", accWThdConfDIR) + accWThdCfgPath = path.Join(*utils.DataDir, "conf", "samples", accWThdConfDIR) if accWThdCfg, err = config.NewCGRConfigFromPath(accWThdCfgPath); err != nil { t.Error(err) } diff --git a/general_tests/all_cfg_sect_rld_it_test.go b/general_tests/all_cfg_sect_rld_it_test.go index f74e20906..e4bdb2f3e 100644 --- a/general_tests/all_cfg_sect_rld_it_test.go +++ b/general_tests/all_cfg_sect_rld_it_test.go @@ -103,7 +103,7 @@ var ( ) func TestSectChange(t *testing.T) { - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: testSectCfgDir = "reload_sect_internal" case utils.MetaMySQL: @@ -121,7 +121,7 @@ func TestSectChange(t *testing.T) { } func testSectLoadConfig(t *testing.T) { - testSectCfgPath = path.Join(*dataDir, "conf", "samples", testSectCfgDir) + testSectCfgPath = path.Join(*utils.DataDir, "conf", "samples", testSectCfgDir) if testSectCfg, err = config.NewCGRConfigFromPath(testSectCfgPath); err != nil { t.Error(err) } @@ -143,7 +143,7 @@ func testSectStartEngine(t *testing.T) { if err := os.MkdirAll("/var/spool/cgrates/analyzers", 0755); err != nil { t.Error(err) } - if _, err := engine.StopStartEngine(testSectCfgPath, *waitRater); err != nil { + if _, err := engine.StopStartEngine(testSectCfgPath, *utils.WaitRater); err != nil { t.Fatal(err) } } @@ -1133,7 +1133,7 @@ func testSectConfigSReloadLoaders(t *testing.T) { var reply string if err := testSectRPC.Call(context.Background(), utils.ConfigSv1ReloadConfig, &config.ReloadArgs{ Tenant: "cgrates.org", - Path: path.Join(*dataDir, "conf", "samples", "tutinternal"), + Path: path.Join(*utils.DataDir, "conf", "samples", "tutinternal"), Section: config.LoaderJson, }, &reply); err != nil { t.Error(err) @@ -1498,7 +1498,7 @@ func testSectStopCgrEngine(t *testing.T) { if err := os.RemoveAll("/var/spool/cgrates/analyzers"); err != nil { t.Error(err) } - if err := engine.KillEngine(*waitRater); err != nil { + if err := engine.KillEngine(*utils.WaitRater); err != nil { t.Error(err) } } diff --git a/general_tests/api_escape_char_it_test.go b/general_tests/api_escape_char_it_test.go index 7dd717ca5..466c7ffbe 100644 --- a/general_tests/api_escape_char_it_test.go +++ b/general_tests/api_escape_char_it_test.go @@ -60,7 +60,7 @@ func TestEscapeCharacters(t *testing.T) { // Encoding: *encoding, ConfigJSON: content, } - client, _, shutdown, err := testEnv.Setup(t, *waitRater) + client, _, shutdown, err := testEnv.Setup(t, *utils.WaitRater) if err != nil { t.Fatal(err) } diff --git a/general_tests/attributes_filters_index_it_test.go b/general_tests/attributes_filters_index_it_test.go index 93be8af57..b29758447 100644 --- a/general_tests/attributes_filters_index_it_test.go +++ b/general_tests/attributes_filters_index_it_test.go @@ -57,7 +57,7 @@ var ( ) func TestAttributeFilterSIT(t *testing.T) { - switch *dbType { + switch *utils.DBType { case utils.MetaMySQL: alsPrfFltrConfigDIR = "attributes_mysql" case utils.MetaMongo: @@ -74,12 +74,12 @@ func TestAttributeFilterSIT(t *testing.T) { func testAttributeFltrSInitCfg(t *testing.T) { var err error - attrFltrCfgPath = path.Join(*dataDir, "conf", "samples", alsPrfFltrConfigDIR) + attrFltrCfgPath = path.Join(*utils.DataDir, "conf", "samples", alsPrfFltrConfigDIR) attrFltrCfg, err = config.NewCGRConfigFromPath(attrFltrCfgPath) if err != nil { t.Error(err) } - attrFltrCfg.DataFolderPath = *dataDir // Share DataFolderPath through config towards StoreDb for Flush() + attrFltrCfg.DataFolderPath = *utils.DataDir // Share DataFolderPath through config towards StoreDb for Flush() } func testAttributeFltrSInitDataDb(t *testing.T) { @@ -97,7 +97,7 @@ func testAttributeFltrSResetStorDb(t *testing.T) { // Start CGR Engine func testAttributeFltrSStartEngine(t *testing.T) { - if _, err := engine.StopStartEngine(attrFltrCfgPath, *waitRater); err != nil { + if _, err := engine.StopStartEngine(attrFltrCfgPath, *utils.WaitRater); err != nil { t.Fatal(err) } } diff --git a/general_tests/attributes_it_test.go b/general_tests/attributes_it_test.go index ef3284e50..ce084524c 100644 --- a/general_tests/attributes_it_test.go +++ b/general_tests/attributes_it_test.go @@ -62,7 +62,7 @@ var ( ) func TestAttributeSIT(t *testing.T) { - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: alsPrfConfigDIR = "tutinternal" case utils.MetaMySQL: @@ -81,12 +81,12 @@ func TestAttributeSIT(t *testing.T) { func testAttributeSInitCfg(t *testing.T) { var err error - attrCfgPath = path.Join(*dataDir, "conf", "samples", alsPrfConfigDIR) + attrCfgPath = path.Join(*utils.DataDir, "conf", "samples", alsPrfConfigDIR) attrCfg, err = config.NewCGRConfigFromPath(attrCfgPath) if err != nil { t.Error(err) } - attrCfg.DataFolderPath = *dataDir // Share DataFolderPath through config towards StoreDb for Flush() + attrCfg.DataFolderPath = *utils.DataDir // Share DataFolderPath through config towards StoreDb for Flush() } func testAttributeSInitDataDb(t *testing.T) { @@ -104,7 +104,7 @@ func testAttributeSResetStorDb(t *testing.T) { // Start CGR Engine func testAttributeSStartEngine(t *testing.T) { - if _, err := engine.StopStartEngine(attrCfgPath, *waitRater); err != nil { + if _, err := engine.StopStartEngine(attrCfgPath, *utils.WaitRater); err != nil { t.Fatal(err) } } @@ -120,7 +120,7 @@ func testAttributeSRPCConn(t *testing.T) { func testAttributeSLoadFromFolder(t *testing.T) { var reply string - attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*dataDir, "tariffplans", "testit")} + attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*utils.DataDir, "tariffplans", "testit")} if err := attrRPC.Call(context.Background(), utils.APIerSv1LoadTariffPlanFromFolder, attrs, &reply); err != nil { t.Error(err) } @@ -1058,7 +1058,7 @@ func testAttributeSStopEngine(t *testing.T) { } func TestAttributesDestinationFilters(t *testing.T) { - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: case utils.MetaMySQL, utils.MetaMongo, utils.MetaPostgres: t.SkipNow() @@ -1122,7 +1122,7 @@ cgrates.org,FLTR_DESTINATION_MATCH,*destinations,~*req.Destination,DST_10,`, ConfigJSON: content, TpFiles: tpFiles, } - client, _, shutdown, err := testEnv.Setup(t, *waitRater) + client, _, shutdown, err := testEnv.Setup(t, *utils.WaitRater) if err != nil { t.Fatal(err) } @@ -1265,7 +1265,7 @@ cgrates.org,FLTR_DESTINATION_MATCH,*destinations,~*req.Destination,DST_10,`, } func TestAttributesArith(t *testing.T) { - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: case utils.MetaMySQL, utils.MetaMongo, utils.MetaPostgres: t.SkipNow() @@ -1313,7 +1313,7 @@ cgrates.org,ATTR_ARITH,,,,,*req.MultiplyBetweenVariables,*multiply,~*req.Elem1;~ ConfigJSON: content, TpFiles: tpFiles, } - client, _, shutdown, err := testEnv.Setup(t, *waitRater) + client, _, shutdown, err := testEnv.Setup(t, *utils.WaitRater) if err != nil { t.Fatal(err) } diff --git a/general_tests/attributeswithdataconverters_it_test.go b/general_tests/attributeswithdataconverters_it_test.go index 1c787980e..6a93e9e41 100644 --- a/general_tests/attributeswithdataconverters_it_test.go +++ b/general_tests/attributeswithdataconverters_it_test.go @@ -56,7 +56,7 @@ var ( ) func TestAttrWDcIT(t *testing.T) { - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: attrWDcConfDIR = "tutinternal" case utils.MetaMySQL: @@ -76,7 +76,7 @@ func TestAttrWDcIT(t *testing.T) { func testAttrWDcInitCfg(t *testing.T) { var err error - attrWDcCfgPath = path.Join(*dataDir, "conf", "samples", attrWDcConfDIR) + attrWDcCfgPath = path.Join(*utils.DataDir, "conf", "samples", attrWDcConfDIR) attrWDcCfg, err = config.NewCGRConfigFromPath(attrWDcCfgPath) if err != nil { t.Error(err) @@ -96,7 +96,7 @@ func testAttrWDcResetStorDb(t *testing.T) { } func testAttrWDcStartEngine(t *testing.T) { - if _, err := engine.StopStartEngine(attrWDcCfgPath, *waitRater); err != nil { + if _, err := engine.StopStartEngine(attrWDcCfgPath, *utils.WaitRater); err != nil { t.Fatal(err) } } @@ -111,7 +111,7 @@ func testAttrWDcRPCConn(t *testing.T) { func testAttrWDcLoadFromFolder(t *testing.T) { var reply string - attrs := utils.AttrLoadTpFromFolder{FolderPath: path.Join(*dataDir, "tariffplans", "dataconverters")} + attrs := utils.AttrLoadTpFromFolder{FolderPath: path.Join(*utils.DataDir, "tariffplans", "dataconverters")} if err := attrWDcRpc.Call(context.Background(), utils.APIerSv1LoadTariffPlanFromFolder, attrs, &reply); err != nil { t.Error(err) } diff --git a/general_tests/authorize_event_sms_data_it_test.go b/general_tests/authorize_event_sms_data_it_test.go index 82fab9092..2052eb831 100644 --- a/general_tests/authorize_event_sms_data_it_test.go +++ b/general_tests/authorize_event_sms_data_it_test.go @@ -32,7 +32,7 @@ import ( func TestSSv1AuthorizeEventSMS(t *testing.T) { var cfgDir string - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: cfgDir = "sessions_internal" case utils.MetaMySQL: @@ -46,10 +46,10 @@ func TestSSv1AuthorizeEventSMS(t *testing.T) { } testEnv := TestEnvironment{ Name: "TestSSv1AuthorizeEventSMS", - ConfigPath: path.Join(*dataDir, "conf", "samples", cfgDir), - TpPath: path.Join(*dataDir, "tariffplans", "testit"), + ConfigPath: path.Join(*utils.DataDir, "conf", "samples", cfgDir), + TpPath: path.Join(*utils.DataDir, "tariffplans", "testit"), } - client, _, shutdown, err := testEnv.Setup(t, *waitRater) + client, _, shutdown, err := testEnv.Setup(t, *utils.WaitRater) if err != nil { t.Fatal(err) } diff --git a/general_tests/balance_it_test.go b/general_tests/balance_it_test.go index 809449463..5e31eca1d 100644 --- a/general_tests/balance_it_test.go +++ b/general_tests/balance_it_test.go @@ -44,7 +44,7 @@ import ( // 4. Verify that the account's *sms balance is the same as it was in step 2 and that the *monetary balance has not been touched // at all. func TestBalanceBlocker(t *testing.T) { - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: case utils.MetaMySQL, utils.MetaMongo, utils.MetaPostgres: t.SkipNow() @@ -110,7 +110,7 @@ cgrates.org,sms,1001,2014-01-14T00:00:00Z,RP_ANY,`, ConfigJSON: content, TpFiles: tpFiles, } - client, _, shutdown, err := testEnv.Setup(t, *waitRater) + client, _, shutdown, err := testEnv.Setup(t, *utils.WaitRater) if err != nil { t.Fatal(err) } @@ -274,7 +274,7 @@ cgrates.org,sms,1001,2014-01-14T00:00:00Z,RP_ANY,`, // voiceFactor is 2) and then also check if it applies correctly for refund (similar // to step 4). func TestBalanceFactor(t *testing.T) { - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: case utils.MetaMySQL, utils.MetaMongo, utils.MetaPostgres: t.SkipNow() @@ -359,7 +359,7 @@ cgrates.org,call,1001,2014-01-14T00:00:00Z,RP_VOICE,`, ConfigJSON: content, TpFiles: tpFiles, } - client, _, shutdown, err := testEnv.Setup(t, *waitRater) + client, _, shutdown, err := testEnv.Setup(t, *utils.WaitRater) if err != nil { t.Fatal(err) } @@ -733,7 +733,7 @@ cgrates.org,call,1001,2014-01-14T00:00:00Z,RP_VOICE,`, // 2. Set 3 action bundles with "*topup_reset", "*remove_balance" and "*remove_expired" actions, each coupled with a "*cdrlog" action. // 3. Retrieve the CDRs and check whether the their fields are set correctly. func TestBalanceCDRLog(t *testing.T) { - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: case utils.MetaMySQL, utils.MetaMongo, utils.MetaPostgres: t.SkipNow() @@ -795,7 +795,7 @@ ACT_TOPUP_SMS,*topup_reset,,,balance_sms,*sms,,*any,,,*unlimited,,1000,10,false, ConfigJSON: content, TpFiles: tpFiles, } - client, _, shutdown, err := testEnv.Setup(t, *waitRater) + client, _, shutdown, err := testEnv.Setup(t, *utils.WaitRater) if err != nil { t.Fatal(err) } diff --git a/general_tests/birpc_benchmark_test.go b/general_tests/birpc_benchmark_test.go index 58a84d490..af4c729dd 100644 --- a/general_tests/birpc_benchmark_test.go +++ b/general_tests/birpc_benchmark_test.go @@ -44,7 +44,7 @@ import ( ) func BenchmarkRPCCalls(b *testing.B) { - benchCfgPath := path.Join(*dataDir, "conf", "samples", "sessions_internal") + benchCfgPath := path.Join(*utils.DataDir, "conf", "samples", "sessions_internal") benchCfg, err := config.NewCGRConfigFromPath(benchCfgPath) if err != nil { b.Fatal(err) diff --git a/general_tests/broadcast_client_it_test.go b/general_tests/broadcast_client_it_test.go index b58d2add0..b04b98216 100644 --- a/general_tests/broadcast_client_it_test.go +++ b/general_tests/broadcast_client_it_test.go @@ -58,7 +58,7 @@ var ( ) func TestBrodcastRPC(t *testing.T) { - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: brodcastInternalCfgDIR = "tutinternal" case utils.MetaMySQL: @@ -79,11 +79,11 @@ func TestBrodcastRPC(t *testing.T) { // test for 0 balance with session terminate with 1s usage func testbrodcastItLoadConfig(t *testing.T) { var err error - brodcastCfgPath = path.Join(*dataDir, "conf", "samples", "internal_broadcast_replication") + brodcastCfgPath = path.Join(*utils.DataDir, "conf", "samples", "internal_broadcast_replication") if brodcastCfg, err = config.NewCGRConfigFromPath(brodcastCfgPath); err != nil { t.Error(err) } - brodcastInternalCfgPath = path.Join(*dataDir, "conf", "samples", brodcastInternalCfgDIR) + brodcastInternalCfgPath = path.Join(*utils.DataDir, "conf", "samples", brodcastInternalCfgDIR) if brodcastInternalCfg, err = config.NewCGRConfigFromPath(brodcastInternalCfgPath); err != nil { t.Error(err) } @@ -102,10 +102,10 @@ func testbrodcastItResetStorDb(t *testing.T) { } func testbrodcastItStartEngine(t *testing.T) { - if _, err := engine.StopStartEngine(brodcastCfgPath, *waitRater); err != nil { + if _, err := engine.StopStartEngine(brodcastCfgPath, *utils.WaitRater); err != nil { t.Fatal(err) } - if _, err := engine.StartEngine(brodcastInternalCfgPath, *waitRater); err != nil { + if _, err := engine.StartEngine(brodcastInternalCfgPath, *utils.WaitRater); err != nil { t.Fatal(err) } } @@ -124,7 +124,7 @@ func testbrodcastItRPCConn(t *testing.T) { func testbrodcastItLoadFromFolder(t *testing.T) { var reply string - attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*dataDir, "tariffplans", "tutorial")} + attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*utils.DataDir, "tariffplans", "tutorial")} if err := brodcastRPC.Call(context.Background(), utils.APIerSv1LoadTariffPlanFromFolder, attrs, &reply); err != nil { t.Error(err) } diff --git a/general_tests/cacherpl_filter_update_it_test.go b/general_tests/cacherpl_filter_update_it_test.go index 92d5ac1df..e21b6d3a4 100644 --- a/general_tests/cacherpl_filter_update_it_test.go +++ b/general_tests/cacherpl_filter_update_it_test.go @@ -81,7 +81,7 @@ var ( ) func TestFilterUpdateIT(t *testing.T) { - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: t.SkipNow() case utils.MetaMySQL: @@ -97,17 +97,17 @@ func TestFilterUpdateIT(t *testing.T) { } for _, stest1 := range sTestsFilterUpdate { - t.Run(*dbType, stest1) + t.Run(*utils.DBType, stest1) } } // Init Config func testFilterUpdateInitCfg(t *testing.T) { - fltrUpdateCfgPath1 = path.Join(*dataDir, "conf", "samples", "cache_replicate", fltrUpdateCfgDIR1) + fltrUpdateCfgPath1 = path.Join(*utils.DataDir, "conf", "samples", "cache_replicate", fltrUpdateCfgDIR1) if fltrUpdateCfg1, err = config.NewCGRConfigFromPath(fltrUpdateCfgPath1); err != nil { t.Fatal(err) } - fltrUpdateCfgPath2 = path.Join(*dataDir, "conf", "samples", fltrUpdateCfgDIR2) + fltrUpdateCfgPath2 = path.Join(*utils.DataDir, "conf", "samples", fltrUpdateCfgDIR2) if fltrUpdateCfg2, err = config.NewCGRConfigFromPath(fltrUpdateCfgPath2); err != nil { t.Fatal(err) } @@ -125,10 +125,10 @@ func testFilterUpdateResetDB(t *testing.T) { // Start CGR Engine func testFilterUpdateStartEngine(t *testing.T) { - if _, err = engine.StopStartEngine(fltrUpdateCfgPath1, *waitRater); err != nil { + if _, err = engine.StopStartEngine(fltrUpdateCfgPath1, *utils.WaitRater); err != nil { t.Fatal(err) } - if testEng1, err = engine.StartEngine(fltrUpdateCfgPath2, *waitRater); err != nil { + if testEng1, err = engine.StartEngine(fltrUpdateCfgPath2, *utils.WaitRater); err != nil { t.Fatal(err) } diff --git a/general_tests/cacherpl_it_test.go b/general_tests/cacherpl_it_test.go index 9ae2ada75..c4b296a6d 100644 --- a/general_tests/cacherpl_it_test.go +++ b/general_tests/cacherpl_it_test.go @@ -76,7 +76,7 @@ var ( ) func TestCacheReplications(t *testing.T) { - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: t.SkipNow() case utils.MetaMySQL: @@ -94,7 +94,7 @@ func TestCacheReplications(t *testing.T) { } func TestCacheReplicationActiveActive(t *testing.T) { - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: t.SkipNow() case utils.MetaMySQL: @@ -112,19 +112,19 @@ func TestCacheReplicationActiveActive(t *testing.T) { func testCacheRplInitCfg(t *testing.T) { var err error - dspEngine1CfgPath = path.Join(*dataDir, "conf", "samples", "cache_replicate", "dispatcher_engine") + dspEngine1CfgPath = path.Join(*utils.DataDir, "conf", "samples", "cache_replicate", "dispatcher_engine") dspEngine1Cfg, err = config.NewCGRConfigFromPath(dspEngine1CfgPath) if err != nil { t.Error(err) } - dspEngine2CfgPath = path.Join(*dataDir, "conf", "samples", "cache_replicate", "dispatcher_engine2") + dspEngine2CfgPath = path.Join(*utils.DataDir, "conf", "samples", "cache_replicate", "dispatcher_engine2") dspEngine2Cfg, err = config.NewCGRConfigFromPath(dspEngine2CfgPath) if err != nil { t.Error(err) } - engine1CfgPath = path.Join(*dataDir, "conf", "samples", "cache_replicate", "engine1") + engine1CfgPath = path.Join(*utils.DataDir, "conf", "samples", "cache_replicate", "engine1") engine1Cfg, err = config.NewCGRConfigFromPath(engine1CfgPath) if err != nil { t.Error(err) @@ -133,19 +133,19 @@ func testCacheRplInitCfg(t *testing.T) { func testCacheRplAAInitCfg(t *testing.T) { var err error - dspEngine1CfgPath = path.Join(*dataDir, "conf", "samples", "cache_rpl_active_active", "dispatcher_engine") + dspEngine1CfgPath = path.Join(*utils.DataDir, "conf", "samples", "cache_rpl_active_active", "dispatcher_engine") dspEngine1Cfg, err = config.NewCGRConfigFromPath(dspEngine1CfgPath) if err != nil { t.Error(err) } - dspEngine2CfgPath = path.Join(*dataDir, "conf", "samples", "cache_rpl_active_active", "dispatcher_engine2") + dspEngine2CfgPath = path.Join(*utils.DataDir, "conf", "samples", "cache_rpl_active_active", "dispatcher_engine2") dspEngine2Cfg, err = config.NewCGRConfigFromPath(dspEngine2CfgPath) if err != nil { t.Error(err) } - engine1CfgPath = path.Join(*dataDir, "conf", "samples", "cache_rpl_active_active", "engine1") + engine1CfgPath = path.Join(*utils.DataDir, "conf", "samples", "cache_rpl_active_active", "engine1") engine1Cfg, err = config.NewCGRConfigFromPath(engine1CfgPath) if err != nil { t.Error(err) @@ -162,13 +162,13 @@ func testCacheRplInitDataDb(t *testing.T) { } func testCacheRplStartEngine(t *testing.T) { - if _, err := engine.StopStartEngine(dspEngine1CfgPath, *waitRater); err != nil { + if _, err := engine.StopStartEngine(dspEngine1CfgPath, *utils.WaitRater); err != nil { t.Fatal(err) } - if _, err := engine.StartEngine(dspEngine2CfgPath, *waitRater); err != nil { + if _, err := engine.StartEngine(dspEngine2CfgPath, *utils.WaitRater); err != nil { t.Fatal(err) } - if _, err := engine.StartEngine(engine1CfgPath, *waitRater); err != nil { + if _, err := engine.StartEngine(engine1CfgPath, *utils.WaitRater); err != nil { t.Fatal(err) } } @@ -197,7 +197,7 @@ func testCacheRplAddData(t *testing.T) { t.Error(err) } loader := exec.Command(loaderPath, "-config_path", dspEngine1CfgPath, "-path", - path.Join(*dataDir, "tariffplans", "cache_replications", "dispatcher_engine")) + path.Join(*utils.DataDir, "tariffplans", "cache_replications", "dispatcher_engine")) if err := loader.Start(); err != nil { t.Error(err) @@ -217,7 +217,7 @@ func testCacheRplAddData(t *testing.T) { t.Error(err) } loader := exec.Command(loaderPath, "-config_path", dspEngine2CfgPath, "-path", - path.Join(*dataDir, "tariffplans", "cache_replications", "dispatcher_engine2")) + path.Join(*utils.DataDir, "tariffplans", "cache_replications", "dispatcher_engine2")) if err := loader.Start(); err != nil { t.Error(err) @@ -256,7 +256,7 @@ func testCacheRplAAAddData(t *testing.T) { t.Error(err) } loader := exec.Command(loaderPath, "-config_path", dspEngine1CfgPath, "-path", - path.Join(*dataDir, "tariffplans", "cache_rpl_active_active", "dispatcher_engine")) + path.Join(*utils.DataDir, "tariffplans", "cache_rpl_active_active", "dispatcher_engine")) if err := loader.Start(); err != nil { t.Error(err) @@ -276,7 +276,7 @@ func testCacheRplAAAddData(t *testing.T) { t.Error(err) } loader := exec.Command(loaderPath, "-config_path", dspEngine2CfgPath, "-path", - path.Join(*dataDir, "tariffplans", "cache_rpl_active_active", "dispatcher_engine2")) + path.Join(*utils.DataDir, "tariffplans", "cache_rpl_active_active", "dispatcher_engine2")) if err := loader.Start(); err != nil { t.Error(err) @@ -632,7 +632,7 @@ func testCacheRplCheckLoadReplication(t *testing.T) { } func testCacheRplStopEngine(t *testing.T) { - if err := engine.KillEngine(*waitRater); err != nil { + if err := engine.KillEngine(*utils.WaitRater); err != nil { t.Error(err) } } diff --git a/general_tests/cdrlog_ees_it_test.go b/general_tests/cdrlog_ees_it_test.go index a54a4cd7e..f4f590eef 100644 --- a/general_tests/cdrlog_ees_it_test.go +++ b/general_tests/cdrlog_ees_it_test.go @@ -32,7 +32,7 @@ import ( ) func TestCdrLogEes(t *testing.T) { - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: case utils.MetaMySQL, utils.MetaMongo, utils.MetaPostgres: t.SkipNow() @@ -186,7 +186,7 @@ func TestCdrLogEes(t *testing.T) { ConfigJSON: content, TpFiles: map[string]string{}, } - client, _, shutdown, err := testEnv.Setup(t, *waitRater) + client, _, shutdown, err := testEnv.Setup(t, *utils.WaitRater) if err != nil { t.Fatal(err) } diff --git a/general_tests/cdrs_exp_it_test.go b/general_tests/cdrs_exp_it_test.go index 4c5679ac5..4119e2148 100644 --- a/general_tests/cdrs_exp_it_test.go +++ b/general_tests/cdrs_exp_it_test.go @@ -1,5 +1,4 @@ //go:build integration -// +build integration /* Real-time Online/Offline Charging System (OCS) for Telecom & ISP environments @@ -114,7 +113,7 @@ var ( ) func TestCDRsExp(t *testing.T) { - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: cdrsExpCfgDir = "cdrsexport_internal" case utils.MetaMySQL: @@ -134,7 +133,7 @@ func TestCDRsExp(t *testing.T) { func testCDRsExpInitConfig(t *testing.T) { var err error - cdrsExpCfgPath = path.Join(*dataDir, "conf", "samples", cdrsExpCfgDir) + cdrsExpCfgPath = path.Join(*utils.DataDir, "conf", "samples", cdrsExpCfgDir) if cdrsExpCfg, err = config.NewCGRConfigFromPath(cdrsExpCfgPath); err != nil { t.Fatal(err) } @@ -209,7 +208,7 @@ func testCDRsExpPrepareAMQP(t *testing.T) { func testCDRsExpStartEngine(t *testing.T) { runtime.Gosched() - if _, err := engine.StopStartEngine(cdrsExpCfgPath, *waitRater); err != nil { + if _, err := engine.StopStartEngine(cdrsExpCfgPath, *utils.WaitRater); err != nil { t.Fatal(err) } } diff --git a/general_tests/cdrs_internal_it_test.go b/general_tests/cdrs_internal_it_test.go index 1d80e6e90..fb5b7fbc9 100644 --- a/general_tests/cdrs_internal_it_test.go +++ b/general_tests/cdrs_internal_it_test.go @@ -53,7 +53,7 @@ var ( // This test is valid only for internal // to test the ttl for cdrs func TestCdrsIntIT(t *testing.T) { - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: cdrsIntCfgDIR = "internal_ttl_internal" case utils.MetaMySQL: @@ -72,7 +72,7 @@ func TestCdrsIntIT(t *testing.T) { func testCdrsIntInitCfg(t *testing.T) { var err error - cdrsIntCfgPath = path.Join(*dataDir, "conf", "samples", cdrsIntCfgDIR) + cdrsIntCfgPath = path.Join(*utils.DataDir, "conf", "samples", cdrsIntCfgDIR) cdrsIntCfg, err = config.NewCGRConfigFromPath(cdrsIntCfgPath) if err != nil { t.Error(err) @@ -80,7 +80,7 @@ func testCdrsIntInitCfg(t *testing.T) { } func testCdrsIntStartEngine(t *testing.T) { - if _, err := engine.StopStartEngine(cdrsIntCfgPath, *waitRater); err != nil { + if _, err := engine.StopStartEngine(cdrsIntCfgPath, *utils.WaitRater); err != nil { t.Fatal(err) } } @@ -133,7 +133,7 @@ func testCdrsIntTestTTL(t *testing.T) { } func testCdrsIntStopEngine(t *testing.T) { - if err := engine.KillEngine(*waitRater); err != nil { + if err := engine.KillEngine(*utils.WaitRater); err != nil { t.Error(err) } } diff --git a/general_tests/cdrs_it_test.go b/general_tests/cdrs_it_test.go index d557d5579..3336a431b 100644 --- a/general_tests/cdrs_it_test.go +++ b/general_tests/cdrs_it_test.go @@ -80,7 +80,7 @@ var ( // Tests starting here func TestCDRsIT(t *testing.T) { - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: cdrsConfDIR = "cdrsv2internal" case utils.MetaMySQL: @@ -100,9 +100,9 @@ func TestCDRsIT(t *testing.T) { func testV2CDRsInitConfig(t *testing.T) { var err error - cdrsCfgPath = path.Join(*dataDir, "conf", "samples", cdrsConfDIR) - if *encoding == utils.MetaGOB { - cdrsCfgPath = path.Join(*dataDir, "conf", "samples", cdrsConfDIR+"_gob") + cdrsCfgPath = path.Join(*utils.DataDir, "conf", "samples", cdrsConfDIR) + if *utils.Encoding == utils.MetaGOB { + cdrsCfgPath = path.Join(*utils.DataDir, "conf", "samples", cdrsConfDIR+"_gob") } if cdrsCfg, err = config.NewCGRConfigFromPath(cdrsCfgPath); err != nil { t.Fatal("Got config error: ", err.Error()) @@ -123,7 +123,7 @@ func testV2CDRsInitCdrDb(t *testing.T) { } func testV2CDRsStartEngine(t *testing.T) { - if _, err := engine.StopStartEngine(cdrsCfgPath, *waitRater); err != nil { + if _, err := engine.StopStartEngine(cdrsCfgPath, *utils.WaitRater); err != nil { t.Fatal(err) } } @@ -140,10 +140,10 @@ func testV2CDRsLoadTariffPlanFromFolder(t *testing.T) { var loadInst utils.LoadInstance if err := cdrsRpc.Call(context.Background(), utils.APIerSv2LoadTariffPlanFromFolder, &utils.AttrLoadTpFromFolder{FolderPath: path.Join( - *dataDir, "tariffplans", "testit")}, &loadInst); err != nil { + *utils.DataDir, "tariffplans", "testit")}, &loadInst); err != nil { t.Error(err) } - time.Sleep(time.Duration(*waitRater) * time.Millisecond) // Give time for scheduler to execute topups + time.Sleep(time.Duration(*utils.WaitRater) * time.Millisecond) // Give time for scheduler to execute topups var resp string if err := cdrsRpc.Call(context.Background(), utils.APIerSv1RemoveChargerProfile, &utils.TenantID{Tenant: "cgrates.org", ID: "SupplierCharges"}, &resp); err != nil { @@ -754,7 +754,7 @@ func testV2CDRsGetCdrs7(t *testing.T) { } func testV2CDRsKillEngine(t *testing.T) { - if err := engine.KillEngine(*waitRater); err != nil { + if err := engine.KillEngine(*utils.WaitRater); err != nil { t.Error(err) } } diff --git a/general_tests/cdrs_onlexp_it_test.go b/general_tests/cdrs_onlexp_it_test.go index ca8336f33..0806383b5 100644 --- a/general_tests/cdrs_onlexp_it_test.go +++ b/general_tests/cdrs_onlexp_it_test.go @@ -70,7 +70,7 @@ var ( ) func TestCDRsOnExp(t *testing.T) { - switch *dbType { + switch *utils.DBType { case utils.MetaInternal, utils.MetaPostgres: t.SkipNow() case utils.MetaMySQL: @@ -84,17 +84,17 @@ func TestCDRsOnExp(t *testing.T) { } for _, stest := range sTestsCDRsOnExp { - t.Run(*dbType, stest) + t.Run(*utils.DBType, stest) } } func testCDRsOnExpInitConfig(t *testing.T) { var err error - cdrsMasterCfgPath = path.Join(*dataDir, "conf", "samples", cdrsMasterCfgDIR) + cdrsMasterCfgPath = path.Join(*utils.DataDir, "conf", "samples", cdrsMasterCfgDIR) if cdrsMasterCfg, err = config.NewCGRConfigFromPath(cdrsMasterCfgPath); err != nil { t.Fatal("Got config error: ", err.Error()) } - cdrsSlaveCfgPath = path.Join(*dataDir, "conf", "samples", cdrsSlaveCfgDIR) + cdrsSlaveCfgPath = path.Join(*utils.DataDir, "conf", "samples", cdrsSlaveCfgDIR) if cdrsSlaveCfg, err = config.NewCGRConfigFromPath(cdrsSlaveCfgPath); err != nil { t.Fatal("Got config error: ", err.Error()) } @@ -125,13 +125,13 @@ func testCDRsOnExpInitCdrDb(t *testing.T) { } func testCDRsOnExpStartMasterEngine(t *testing.T) { - if _, err := engine.StopStartEngine(cdrsMasterCfgPath, *waitRater); err != nil { + if _, err := engine.StopStartEngine(cdrsMasterCfgPath, *utils.WaitRater); err != nil { t.Fatal(err) } } func testCDRsOnExpStartSlaveEngine(t *testing.T) { - if _, err := engine.StartEngine(cdrsSlaveCfgPath, *waitRater); err != nil { + if _, err := engine.StartEngine(cdrsSlaveCfgPath, *utils.WaitRater); err != nil { t.Fatal(err) } } @@ -245,7 +245,7 @@ func testCDRsOnExpDisableOnlineExport(t *testing.T) { } else if reply != utils.OK { t.Error("Unexpected reply received: ", reply) } - time.Sleep(time.Duration(*waitRater) * time.Millisecond) + time.Sleep(time.Duration(*utils.WaitRater) * time.Millisecond) filesInDir, _ := os.ReadDir(cdrsMasterCfg.GeneralCfg().FailedPostsDir) if len(filesInDir) != 0 { t.Fatalf("Should be no files in directory: %s", cdrsMasterCfg.GeneralCfg().FailedPostsDir) @@ -288,7 +288,7 @@ func testCDRsOnExpHttpCdrReplication(t *testing.T) { }, &reply); err == nil || err.Error() != utils.ErrPartiallyExecuted.Error() { t.Error("Unexpected error: ", err) } - time.Sleep(time.Duration(*waitRater) * time.Millisecond) + time.Sleep(time.Duration(*utils.WaitRater) * time.Millisecond) cdrsSlaveRpc, err := rpcclient.NewRPCClient(context.Background(), utils.TCP, "127.0.0.1:12012", false, "", "", "", 1, 1, 0, utils.FibDuration, time.Second, 2*time.Second, rpcclient.JSONrpc, nil, false, nil) if err != nil { @@ -407,7 +407,7 @@ func testCDRsOnExpAMQPReplication(t *testing.T) { }, &reply); err == nil || err.Error() != utils.ErrPartiallyExecuted.Error() { t.Error("Unexpected error: ", err) } - time.Sleep(time.Duration(*waitRater) * time.Millisecond) + time.Sleep(time.Duration(*utils.WaitRater) * time.Millisecond) if conn, err = amqp.Dial("amqp://guest:guest@localhost:5672/"); err != nil { t.Fatal(err) } diff --git a/general_tests/cdrs_post_failover_it_test.go b/general_tests/cdrs_post_failover_it_test.go index e97fa13b0..e15c732a4 100644 --- a/general_tests/cdrs_post_failover_it_test.go +++ b/general_tests/cdrs_post_failover_it_test.go @@ -57,7 +57,7 @@ var ( // Tests starting here func TestCDRsPostFailoverIT(t *testing.T) { - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: cdrsPostFailConfDIR = "cdrsv_failover_internal" case utils.MetaMySQL: @@ -77,7 +77,7 @@ func TestCDRsPostFailoverIT(t *testing.T) { func testCDRsPostFailoverInitConfig(t *testing.T) { var err error - cdrsPostFailCfgPath = path.Join(*dataDir, "conf", "samples", cdrsPostFailConfDIR) + cdrsPostFailCfgPath = path.Join(*utils.DataDir, "conf", "samples", cdrsPostFailConfDIR) if cdrsPostFailCfg, err = config.NewCGRConfigFromPath(cdrsPostFailCfgPath); err != nil { t.Fatal("Got config error: ", err.Error()) } @@ -103,7 +103,7 @@ func testCDRsPostFailoverInitCdrDb(t *testing.T) { } func testCDRsPostFailoverStartEngine(t *testing.T) { - if _, err := engine.StopStartEngine(cdrsPostFailCfgPath, *waitRater); err != nil { + if _, err := engine.StopStartEngine(cdrsPostFailCfgPath, *utils.WaitRater); err != nil { t.Fatal(err) } } @@ -120,10 +120,10 @@ func testCDRsPostFailoverLoadTariffPlanFromFolder(t *testing.T) { var loadInst utils.LoadInstance if err := cdrsPostFailRpc.Call(context.Background(), utils.APIerSv2LoadTariffPlanFromFolder, &utils.AttrLoadTpFromFolder{FolderPath: path.Join( - *dataDir, "tariffplans", "testit")}, &loadInst); err != nil { + *utils.DataDir, "tariffplans", "testit")}, &loadInst); err != nil { t.Error(err) } - time.Sleep(time.Duration(*waitRater) * time.Millisecond) // Give time for scheduler to execute topups + time.Sleep(time.Duration(*utils.WaitRater) * time.Millisecond) // Give time for scheduler to execute topups var resp string if err := cdrsPostFailRpc.Call(context.Background(), utils.APIerSv1RemoveChargerProfile, &utils.TenantID{Tenant: "cgrates.org", ID: "SupplierCharges"}, &resp); err != nil { @@ -216,7 +216,7 @@ func testCDRsPostFailoverKillEngine(t *testing.T) { if err = os.RemoveAll(cdrsPostFailCfg.GeneralCfg().FailedPostsDir); err != nil { t.Error(err) } - if err := engine.KillEngine(*waitRater); err != nil { + if err := engine.KillEngine(*utils.WaitRater); err != nil { t.Error(err) } } diff --git a/general_tests/cdrs_processevent_it_test.go b/general_tests/cdrs_processevent_it_test.go index 17047171f..e017f1223 100644 --- a/general_tests/cdrs_processevent_it_test.go +++ b/general_tests/cdrs_processevent_it_test.go @@ -68,7 +68,7 @@ var ( ) func TestCDRsITPE(t *testing.T) { - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: pecdrsConfDIR = "cdrsv1processevent" case utils.MetaMySQL: @@ -87,7 +87,7 @@ func TestCDRsITPE(t *testing.T) { func testV1CDRsInitConfig(t *testing.T) { var err error - pecdrsCfgPath = path.Join(*dataDir, "conf", "samples", pecdrsConfDIR) + pecdrsCfgPath = path.Join(*utils.DataDir, "conf", "samples", pecdrsConfDIR) if pecdrsCfg, err = config.NewCGRConfigFromPath(pecdrsCfgPath); err != nil { t.Fatal("Got config error: ", err.Error()) } @@ -114,7 +114,7 @@ func testV1CDRsStartEngine(t *testing.T) { if err := os.MkdirAll(pecdrsCfg.GeneralCfg().FailedPostsDir, 0755); err != nil { t.Fatal(err) } - if _, err := engine.StopStartEngine(pecdrsCfgPath, *waitRater); err != nil { + if _, err := engine.StopStartEngine(pecdrsCfgPath, *utils.WaitRater); err != nil { t.Fatal(err) } } @@ -131,10 +131,10 @@ func testV1CDRsLoadTariffPlanFromFolder(t *testing.T) { var loadInst string if err := pecdrsRpc.Call(context.Background(), utils.APIerSv1LoadTariffPlanFromFolder, &utils.AttrLoadTpFromFolder{FolderPath: path.Join( - *dataDir, "tariffplans", "testit")}, &loadInst); err != nil { + *utils.DataDir, "tariffplans", "testit")}, &loadInst); err != nil { t.Error(err) } - time.Sleep(time.Duration(*waitRater) * time.Millisecond) + time.Sleep(time.Duration(*utils.WaitRater) * time.Millisecond) } func testV1CDRsProcessEventAttrS(t *testing.T) { @@ -661,7 +661,7 @@ func testV1CDRsV2ProcessEventRalS(t *testing.T) { } reply[0].Event["CostDetails"] = nil expRply[0].Event["CGRID"] = reply[0].Event["CGRID"] - if *encoding == utils.MetaGOB { // gob encoding encodes 0 values of pointers to nil + if *utils.Encoding == utils.MetaGOB { // gob encoding encodes 0 values of pointers to nil expRply[0].Flags = nil if utils.ToJSON(expRply) != utils.ToJSON(reply) { t.Errorf("Expected %s, received: %s ", utils.ToJSON(expRply), utils.ToJSON(reply)) @@ -692,7 +692,7 @@ func testV1CDRsV2ProcessEventRalS(t *testing.T) { expRply[0].Event["Cost"] = 0.0102 expRply[0].Flags = append(expRply[0].Flags, utils.MetaRefund) reply[0].Event["CostDetails"] = nil - if *encoding == utils.MetaGOB { // gob encoding encodes 0 values of pointers to nil + if *utils.Encoding == utils.MetaGOB { // gob encoding encodes 0 values of pointers to nil if utils.ToJSON(expRply) != utils.ToJSON(reply) { t.Errorf("Expected %s, received: %s ", utils.ToJSON(expRply), utils.ToJSON(reply)) } @@ -707,7 +707,7 @@ func testV1CDRsV2ProcessEventRalS(t *testing.T) { t.Error(err) } reply[0].Event["CostDetails"] = nil - if *encoding == utils.MetaGOB { // gob encoding encodes 0 values of pointers to nil + if *utils.Encoding == utils.MetaGOB { // gob encoding encodes 0 values of pointers to nil if utils.ToJSON(expRply) != utils.ToJSON(reply) { t.Errorf("Expected %s, received: %s ", utils.ToJSON(expRply), utils.ToJSON(reply)) } @@ -719,7 +719,7 @@ func testV1CDRsV2ProcessEventRalS(t *testing.T) { } func testV1CDRsKillEngine(t *testing.T) { - if err := engine.KillEngine(*waitRater); err != nil { + if err := engine.KillEngine(*utils.WaitRater); err != nil { t.Error(err) } } diff --git a/general_tests/cgrloader_it_test.go b/general_tests/cgrloader_it_test.go index 840f8a813..ab642c621 100644 --- a/general_tests/cgrloader_it_test.go +++ b/general_tests/cgrloader_it_test.go @@ -59,7 +59,7 @@ func TestCGRLoader(t *testing.T) { t.SkipNow() return } - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: t.SkipNow() case utils.MetaMySQL: @@ -78,7 +78,7 @@ func TestCGRLoader(t *testing.T) { func testCGRLoaderInitConfig(t *testing.T) { var err error - cgrloaderCfgPath = path.Join(*dataDir, "conf", "samples", cgrloaderConfDIR) + cgrloaderCfgPath = path.Join(*utils.DataDir, "conf", "samples", cgrloaderConfDIR) if cgrloaderCfg, err = config.NewCGRConfigFromPath(cgrloaderCfgPath); err != nil { t.Fatal("Got config error: ", err.Error()) } @@ -97,7 +97,7 @@ func testCGRLoaderInitCdrDb(t *testing.T) { } func testCGRLoaderStartEngine(t *testing.T) { - if _, err := engine.StopStartEngine(cgrloaderCfgPath, *waitRater); err != nil { + if _, err := engine.StopStartEngine(cgrloaderCfgPath, *utils.WaitRater); err != nil { t.Fatal(err) } } @@ -137,7 +137,7 @@ func testCGRLoaderGetData(t *testing.T) { } func testCGRLoaderKillEngine(t *testing.T) { - if err := engine.KillEngine(*waitRater); err != nil { + if err := engine.KillEngine(*utils.WaitRater); err != nil { t.Error(err) } } diff --git a/general_tests/data_it_test.go b/general_tests/data_it_test.go index 8fb9e803a..938059bef 100644 --- a/general_tests/data_it_test.go +++ b/general_tests/data_it_test.go @@ -63,7 +63,7 @@ var ( // Test start here func TestDataIT(t *testing.T) { - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: dataConfDIR = "tutinternal" case utils.MetaMySQL: @@ -82,7 +82,7 @@ func TestDataIT(t *testing.T) { func testV1DataLoadConfig(t *testing.T) { var err error - dataCfgPath = path.Join(*dataDir, "conf", "samples", dataConfDIR) + dataCfgPath = path.Join(*utils.DataDir, "conf", "samples", dataConfDIR) if dataCfg, err = config.NewCGRConfigFromPath(dataCfgPath); err != nil { t.Error(err) } @@ -126,7 +126,7 @@ func testV1DataGetAccountBeforeSet(t *testing.T) { func testV1DataLoadTarrifPlans(t *testing.T) { var reply string - attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*dataDir, "tariffplans", "testData")} + attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*utils.DataDir, "tariffplans", "testData")} if err := dataRpc.Call(context.Background(), utils.APIerSv1LoadTariffPlanFromFolder, attrs, &reply); err != nil { t.Error(err) } else if reply != utils.OK { diff --git a/general_tests/dest_management_it_test.go b/general_tests/dest_management_it_test.go index 00de08b90..0f5663db2 100644 --- a/general_tests/dest_management_it_test.go +++ b/general_tests/dest_management_it_test.go @@ -67,14 +67,14 @@ func TestDestManag(t *testing.T) { } } func testDestManagInitCfg(t *testing.T) { - destCfgPath = path.Join(*dataDir, "conf", "samples", "tutmysql") + destCfgPath = path.Join(*utils.DataDir, "conf", "samples", "tutmysql") // Init config first var err error destCfg, err = config.NewCGRConfigFromPath(destCfgPath) if err != nil { t.Error(err) } - destCfg.DataFolderPath = *dataDir // Share DataFolderPath through config towards StoreDb for Flush() + destCfg.DataFolderPath = *utils.DataDir // Share DataFolderPath through config towards StoreDb for Flush() config.SetCgrConfig(destCfg) } @@ -94,7 +94,7 @@ func testDestManagResetStorDb(t *testing.T) { // Start CGR Engine func testDestManagStartEngine(t *testing.T) { - if _, err := engine.StopStartEngine(destCfgPath, *waitRater); err != nil { + if _, err := engine.StopStartEngine(destCfgPath, *utils.WaitRater); err != nil { t.Fatal(err) } } @@ -110,12 +110,12 @@ func testDestManagRpcConn(t *testing.T) { // Load the tariff plan, creating accounts and their balances func testDestManagLoadTariffPlanFromFolderAll(t *testing.T) { - attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*dataDir, "tariffplans", "test", "destinations", "alldests")} + attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*utils.DataDir, "tariffplans", "test", "destinations", "alldests")} var destLoadInst utils.LoadInstance if err := destRPC.Call(context.Background(),utils.APIerSv2LoadTariffPlanFromFolder, attrs, &destLoadInst); err != nil { t.Error(err) } - time.Sleep(time.Duration(*waitRater) * time.Millisecond) // Give time for scheduler to execute topups + time.Sleep(time.Duration(*utils.WaitRater) * time.Millisecond) // Give time for scheduler to execute topups } @@ -137,12 +137,12 @@ func testDestManagAllDestinationLoaded(t *testing.T) { func testDestManagLoadTariffPlanFromFolderRemoveSome(t *testing.T) { - attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*dataDir, "tariffplans", "test", "destinations", "removesome")} + attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*utils.DataDir, "tariffplans", "test", "destinations", "removesome")} var destLoadInst utils.LoadInstance if err := destRPC.Call(context.Background(),utils.APIerSv2LoadTariffPlanFromFolder, attrs, &destLoadInst); err != nil { t.Error(err) } - time.Sleep(time.Duration(*waitRater) * time.Millisecond) // Give time for scheduler to execute topups + time.Sleep(time.Duration(*utils.WaitRater) * time.Millisecond) // Give time for scheduler to execute topups } func testDestManagRemoveSomeDestinationLoaded(t *testing.T) { @@ -162,12 +162,12 @@ func testDestManagRemoveSomeDestinationLoaded(t *testing.T) { } func testDestManagLoadTariffPlanFromFolderRemoveSomeFlush(t *testing.T) { - attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*dataDir, "tariffplans", "test", "destinations", "removesome"), FlushDb: true} + attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*utils.DataDir, "tariffplans", "test", "destinations", "removesome"), FlushDb: true} var destLoadInst utils.LoadInstance if err := destRPC.Call(context.Background(),utils.APIerSv2LoadTariffPlanFromFolder, attrs, &destLoadInst); err != nil { t.Error(err) } - time.Sleep(time.Duration(*waitRater) * time.Millisecond) // Give time for scheduler to execute topups + time.Sleep(time.Duration(*utils.WaitRater) * time.Millisecond) // Give time for scheduler to execute topups } func testDestManagRemoveSomeFlushDestinationLoaded(t *testing.T) { @@ -187,12 +187,12 @@ func testDestManagRemoveSomeFlushDestinationLoaded(t *testing.T) { } func testDestManagLoadTariffPlanFromFolderAddBack(t *testing.T) { - attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*dataDir, "tariffplans", "test", "destinations", "addback")} + attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*utils.DataDir, "tariffplans", "test", "destinations", "addback")} var destLoadInst utils.LoadInstance if err := destRPC.Call(context.Background(),utils.APIerSv2LoadTariffPlanFromFolder, attrs, &destLoadInst); err != nil { t.Error(err) } - time.Sleep(time.Duration(*waitRater) * time.Millisecond) // Give time for scheduler to execute topups + time.Sleep(time.Duration(*utils.WaitRater) * time.Millisecond) // Give time for scheduler to execute topups } func testDestManagAddBackDestinationLoaded(t *testing.T) { @@ -212,12 +212,12 @@ func testDestManagAddBackDestinationLoaded(t *testing.T) { } func testDestManagLoadTariffPlanFromFolderAddOne(t *testing.T) { - attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*dataDir, "tariffplans", "test", "destinations", "addone")} + attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*utils.DataDir, "tariffplans", "test", "destinations", "addone")} var destLoadInst utils.LoadInstance if err := destRPC.Call(context.Background(),utils.APIerSv2LoadTariffPlanFromFolder, attrs, &destLoadInst); err != nil { t.Error(err) } - time.Sleep(time.Duration(*waitRater) * time.Millisecond) // Give time for scheduler to execute topups + time.Sleep(time.Duration(*utils.WaitRater) * time.Millisecond) // Give time for scheduler to execute topups } func testDestManagAddOneDestinationLoaded(t *testing.T) { @@ -246,12 +246,12 @@ func testDestManagCacheWithGetCache(t *testing.T) { } else if reply != utils.OK { t.Errorf("Calling APIerSv1.ReloadCache received: %+v", reply) } - attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*dataDir, "tariffplans", "test", "destinations", "cacheall"), FlushDb: true} + attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*utils.DataDir, "tariffplans", "test", "destinations", "cacheall"), FlushDb: true} var destLoadInst utils.LoadInstance if err := destRPC.Call(context.Background(),utils.APIerSv2LoadTariffPlanFromFolder, attrs, &destLoadInst); err != nil { t.Error(err) } - time.Sleep(time.Duration(*waitRater) * time.Millisecond) // Give time for scheduler to execute topups + time.Sleep(time.Duration(*utils.WaitRater) * time.Millisecond) // Give time for scheduler to execute topups dests := make([]*engine.Destination, 0) if err := destRPC.Call(context.Background(),utils.APIerSv2GetDestinations, &v2.AttrGetDestinations{DestinationIDs: []string{}}, &dests); err != nil { @@ -267,11 +267,11 @@ func testDestManagCacheWithGetCache(t *testing.T) { t.Errorf("Calling APIerSv1.GetCacheStats received: %+v", rcvStats) } - attrs = &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*dataDir, "tariffplans", "test", "destinations", "cacheone"), FlushDb: true} + attrs = &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*utils.DataDir, "tariffplans", "test", "destinations", "cacheone"), FlushDb: true} if err := destRPC.Call(context.Background(),utils.APIerSv2LoadTariffPlanFromFolder, attrs, &destLoadInst); err != nil { t.Error(err) } - time.Sleep(time.Duration(*waitRater) * time.Millisecond) // Give time for scheduler to execute topups + time.Sleep(time.Duration(*utils.WaitRater) * time.Millisecond) // Give time for scheduler to execute topups dests = make([]*engine.Destination, 0) if err := destRPC.Call(context.Background(),utils.APIerSv2GetDestinations, &v2.AttrGetDestinations{DestinationIDs: []string{}}, &dests); err != nil { @@ -297,12 +297,12 @@ func testDestManagCacheWithGetCost(t *testing.T) { } else if reply != utils.OK { t.Errorf("Calling APIerSv1.ReloadCache received: %+v", reply) } - attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*dataDir, "tariffplans", "test", "destinations", "cacheall"), FlushDb: true} + attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*utils.DataDir, "tariffplans", "test", "destinations", "cacheall"), FlushDb: true} var destLoadInst utils.LoadInstance if err := destRPC.Call(context.Background(),utils.APIerSv2LoadTariffPlanFromFolder, attrs, &destLoadInst); err != nil { t.Error(err) } - time.Sleep(time.Duration(*waitRater) * time.Millisecond) // Give time for scheduler to execute topups + time.Sleep(time.Duration(*utils.WaitRater) * time.Millisecond) // Give time for scheduler to execute topups dests := make([]*engine.Destination, 0) if err := destRPC.Call(context.Background(),utils.APIerSv2GetDestinations, &v2.AttrGetDestinations{DestinationIDs: []string{}}, &dests); err != nil { @@ -326,11 +326,11 @@ func testDestManagCacheWithGetCost(t *testing.T) { t.Error("Empty loadId received, loadInstance: ", utils.ToIJSON(cc)) } - attrs = &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*dataDir, "tariffplans", "test", "destinations", "cacheone"), FlushDb: true} + attrs = &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*utils.DataDir, "tariffplans", "test", "destinations", "cacheone"), FlushDb: true} if err := destRPC.Call(context.Background(),utils.APIerSv2LoadTariffPlanFromFolder, attrs, &destLoadInst); err != nil { t.Error(err) } - time.Sleep(time.Duration(*waitRater) * time.Millisecond) // Give time for scheduler to execute topups + time.Sleep(time.Duration(*utils.WaitRater) * time.Millisecond) // Give time for scheduler to execute topups dests = make([]*engine.Destination, 0) if err := destRPC.Call(context.Background(),utils.APIerSv2GetDestinations, &v2.AttrGetDestinations{DestinationIDs: []string{}}, &dests); err != nil { diff --git a/general_tests/destination_combined_it_test.go b/general_tests/destination_combined_it_test.go index 7996a9b64..a59bf3fb5 100644 --- a/general_tests/destination_combined_it_test.go +++ b/general_tests/destination_combined_it_test.go @@ -48,7 +48,7 @@ var sTestsTutorials2 = []func(t *testing.T){ } func TestDestinationCombines(t *testing.T) { - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: tutorialConfDIR = "tutinternal" case utils.MetaMySQL: @@ -68,7 +68,7 @@ func TestDestinationCombines(t *testing.T) { func testDestinationLoadConfig(t *testing.T) { var err error - tutorialCfgPath = path.Join(*dataDir, "conf", "samples", tutorialConfDIR) + tutorialCfgPath = path.Join(*utils.DataDir, "conf", "samples", tutorialConfDIR) if tutorialCfg, err = config.NewCGRConfigFromPath(tutorialCfgPath); err != nil { t.Error(err) } @@ -101,7 +101,7 @@ func testDestinationRpcConn(t *testing.T) { func testDestinationFromFolder(t *testing.T) { var reply string - attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*dataDir, "tariffplans", "tp_destination_with_any")} + attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*utils.DataDir, "tariffplans", "tp_destination_with_any")} if err := tutorialRpc.Call(context.Background(), utils.APIerSv1LoadTariffPlanFromFolder, attrs, &reply); err != nil { t.Error(err) } diff --git a/general_tests/dispatcher_opts_it_test.go b/general_tests/dispatcher_opts_it_test.go index e33c1a795..08f466dd2 100644 --- a/general_tests/dispatcher_opts_it_test.go +++ b/general_tests/dispatcher_opts_it_test.go @@ -114,7 +114,7 @@ func TestDispatcherOpts(t *testing.T) { func testDispatcherCgr1InitCfg(t *testing.T) { cfg1ConfigDIR = "dispatcher_opts_host1" var err error - cfg1CfgPath = path.Join(*dataDir, "conf", "samples", cfg1ConfigDIR) + cfg1CfgPath = path.Join(*utils.DataDir, "conf", "samples", cfg1ConfigDIR) cfg1Cfg, err = config.NewCGRConfigFromPath(cfg1CfgPath) if err != nil { t.Error(err) @@ -129,7 +129,7 @@ func testDispatcherCgr1InitDataDb(t *testing.T) { // Start CGR Engine woth Dispatcher enabled func testDispatcherCgr1StartEngine(t *testing.T) { - if _, err := engine.StartEngine(cfg1CfgPath, *waitRater); err != nil { + if _, err := engine.StartEngine(cfg1CfgPath, *utils.WaitRater); err != nil { t.Fatal(err) } } @@ -145,7 +145,7 @@ func testDispatcherCgr1RPCConn(t *testing.T) { func testDispatcherCgr2InitCfg(t *testing.T) { cfg2ConfigDIR = "dispatcher_opts_host2" //changed with the cfg with dispatcher on var err error - cfg2CfgPath = path.Join(*dataDir, "conf", "samples", cfg2ConfigDIR) + cfg2CfgPath = path.Join(*utils.DataDir, "conf", "samples", cfg2ConfigDIR) cfg2OptsCfg, err = config.NewCGRConfigFromPath(cfg2CfgPath) if err != nil { t.Error(err) @@ -154,7 +154,7 @@ func testDispatcherCgr2InitCfg(t *testing.T) { // Start CGR Engine woth Dispatcher enabled func testDispatcherCgr2StartEngine(t *testing.T) { - if _, err := engine.StartEngine(cfg2CfgPath, *waitRater); err != nil { + if _, err := engine.StartEngine(cfg2CfgPath, *utils.WaitRater); err != nil { t.Fatal(err) } } @@ -267,7 +267,7 @@ func testDispatcherGetItemBothEnginesFirstAttempt(t *testing.T) { func testDispatcherSetterInitCfg(t *testing.T) { setterConfigDIR = "dispatcher_opts_setter" var err error - setterCfgPath = path.Join(*dataDir, "conf", "samples", setterConfigDIR) + setterCfgPath = path.Join(*utils.DataDir, "conf", "samples", setterConfigDIR) setterCfg, err = config.NewCGRConfigFromPath(setterCfgPath) if err != nil { t.Error(err) @@ -275,7 +275,7 @@ func testDispatcherSetterInitCfg(t *testing.T) { } func testDispatcherSetterStartEngine(t *testing.T) { - if _, err := engine.StartEngine(setterCfgPath, *waitRater); err != nil { + if _, err := engine.StartEngine(setterCfgPath, *utils.WaitRater); err != nil { t.Fatal(err) } } @@ -818,13 +818,13 @@ func testDispatcherCheckCacheAfterSetDispatcherDSP2(t *testing.T) { } func testDispatcherCgr1StopEngine(t *testing.T) { - if err := engine.KillEngine(*waitRater); err != nil { + if err := engine.KillEngine(*utils.WaitRater); err != nil { t.Error(err) } } func testDispatcherCgr2StopEngine(t *testing.T) { - if err := engine.KillEngine(*waitRater); err != nil { + if err := engine.KillEngine(*utils.WaitRater); err != nil { t.Error(err) } } diff --git a/general_tests/doubleremove_it_test.go b/general_tests/doubleremove_it_test.go index cdaf3ec8f..6b78e40cf 100644 --- a/general_tests/doubleremove_it_test.go +++ b/general_tests/doubleremove_it_test.go @@ -57,7 +57,7 @@ var ( // Test start here func TestDoubleRemoveIT(t *testing.T) { - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: doubleRemoveDIR = "tutinternal" case utils.MetaMySQL: @@ -77,7 +77,7 @@ func TestDoubleRemoveIT(t *testing.T) { func testdoubleRemoveLoadConfig(t *testing.T) { var err error - doubleRemovePath = path.Join(*dataDir, "conf", "samples", doubleRemoveDIR) + doubleRemovePath = path.Join(*utils.DataDir, "conf", "samples", doubleRemoveDIR) if doubleRemove, err = config.NewCGRConfigFromPath(doubleRemovePath); err != nil { t.Error(err) } @@ -90,7 +90,7 @@ func testdoubleRemoveInitDataDb(t *testing.T) { } func testdoubleRemoveStartEngine(t *testing.T) { - if _, err := engine.StopStartEngine(doubleRemovePath, *waitRater); err != nil { + if _, err := engine.StopStartEngine(doubleRemovePath, *utils.WaitRater); err != nil { t.Fatal(err) } } diff --git a/general_tests/ees_it_test.go b/general_tests/ees_it_test.go index 3b6e1687a..596dd42f2 100644 --- a/general_tests/ees_it_test.go +++ b/general_tests/ees_it_test.go @@ -41,7 +41,7 @@ import ( // 3. Send an event with CGRID and RequestType *rated in a request to EeSv1.ProcessEvent. // 4. Verify that first export has RequestType *prepaid, while the second one has *rated. func TestEEsExportEventChanges(t *testing.T) { - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: case utils.MetaMySQL, utils.MetaMongo, utils.MetaPostgres: t.SkipNow() @@ -123,7 +123,7 @@ func TestEEsExportEventChanges(t *testing.T) { Name: "TestEEsExportEventChanges", ConfigJSON: content, } - client, _, shutdown, err := testEnv.Setup(t, *waitRater) + client, _, shutdown, err := testEnv.Setup(t, *utils.WaitRater) if err != nil { t.Fatal(err) } diff --git a/general_tests/export_it_test.go b/general_tests/export_it_test.go index fff70511f..57333020e 100644 --- a/general_tests/export_it_test.go +++ b/general_tests/export_it_test.go @@ -67,7 +67,7 @@ var ( ) func TestExport(t *testing.T) { - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: expCfgDir = "tutinternal" case utils.MetaMySQL: @@ -86,7 +86,7 @@ func TestExport(t *testing.T) { } func testExpLoadConfig(t *testing.T) { - expCfgPath = path.Join(*dataDir, "conf", "samples", expCfgDir) + expCfgPath = path.Join(*utils.DataDir, "conf", "samples", expCfgDir) if expCfg, err = config.NewCGRConfigFromPath(expCfgPath); err != nil { t.Error(err) } @@ -105,7 +105,7 @@ func testExpResetStorDb(t *testing.T) { } func testExpStartEngine(t *testing.T) { - if _, err := engine.StopStartEngine(expCfgPath, *waitRater); err != nil { + if _, err := engine.StopStartEngine(expCfgPath, *utils.WaitRater); err != nil { t.Fatal(err) } } @@ -120,7 +120,7 @@ func testExpRPCConn(t *testing.T) { func testExpLoadTPFromFolder(t *testing.T) { var reply string - attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*dataDir, "tariffplans", "testit")} + attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*utils.DataDir, "tariffplans", "testit")} if err := expRpc.Call(context.Background(), utils.APIerSv1LoadTariffPlanFromFolder, attrs, &reply); err != nil { t.Error(err) } else if reply != utils.OK { @@ -174,7 +174,7 @@ func testExpVerifyAttributes(t *testing.T) { t.Fatal(err) } reply.Compile() - if *encoding == utils.MetaGOB { + if *utils.Encoding == utils.MetaGOB { for _, v := range exp.Attributes { v.FilterIDs = nil } @@ -248,7 +248,7 @@ func testExpVerifyResources(t *testing.T) { Weight: 10, ThresholdIDs: []string{}, } - if *encoding == utils.MetaGOB { + if *utils.Encoding == utils.MetaGOB { rPrf.ThresholdIDs = nil } var reply *engine.ResourceProfile @@ -353,7 +353,7 @@ func testExpVerifyRoutes(t *testing.T) { &utils.TenantID{Tenant: "cgrates.org", ID: "ROUTE_ACNT_1001"}, &reply); err != nil { t.Fatal(err) } - if *encoding == utils.MetaGOB { + if *utils.Encoding == utils.MetaGOB { splPrf.SortingParameters = nil splPrf2.SortingParameters = nil } diff --git a/general_tests/fallback_depth_it_test.go b/general_tests/fallback_depth_it_test.go index 05494561d..7746a18a3 100644 --- a/general_tests/fallback_depth_it_test.go +++ b/general_tests/fallback_depth_it_test.go @@ -64,7 +64,7 @@ The test steps are as follows: */ func TestFallbackDepth(t *testing.T) { - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: case utils.MetaMySQL, utils.MetaMongo, utils.MetaPostgres: t.SkipNow() @@ -139,7 +139,7 @@ cgrates.org,call,FallbackSubject4,2014-01-01T00:00:00Z,RP_ANY,`, TpFiles: tpFiles, LogBuffer: buf, } - client, _, shutdown, err := testEnv.Setup(t, *waitRater) + client, _, shutdown, err := testEnv.Setup(t, *utils.WaitRater) if err != nil { t.Fatal(err) } diff --git a/general_tests/filtered_replication_it_test.go b/general_tests/filtered_replication_it_test.go index fcdecb83f..570f01bae 100644 --- a/general_tests/filtered_replication_it_test.go +++ b/general_tests/filtered_replication_it_test.go @@ -75,7 +75,7 @@ var ( // Test start here func TestFilteredReplication(t *testing.T) { - switch *dbType { + switch *utils.DBType { case utils.MetaMySQL: fltrRplDB = "redis" case utils.MetaMongo: @@ -93,9 +93,9 @@ func TestFilteredReplication(t *testing.T) { func testFltrRplInitCfg(t *testing.T) { var err error - fltrRplInternalCfgPath = path.Join(*dataDir, "conf", "samples", "filtered_replication", "internal") - fltrRplEngine1CfgPath = path.Join(*dataDir, "conf", "samples", "filtered_replication", "engine1_"+fltrRplDB) - fltrRplEngine2CfgPath = path.Join(*dataDir, "conf", "samples", "filtered_replication", "engine2_"+fltrRplDB) + fltrRplInternalCfgPath = path.Join(*utils.DataDir, "conf", "samples", "filtered_replication", "internal") + fltrRplEngine1CfgPath = path.Join(*utils.DataDir, "conf", "samples", "filtered_replication", "engine1_"+fltrRplDB) + fltrRplEngine2CfgPath = path.Join(*utils.DataDir, "conf", "samples", "filtered_replication", "engine2_"+fltrRplDB) if fltrRplInternalCfg, err = config.NewCGRConfigFromPath(fltrRplInternalCfgPath); err != nil { t.Fatal(err) @@ -127,22 +127,22 @@ func testFltrRplInitDBs(t *testing.T) { } func testFltrRplStartEngine(t *testing.T) { - if _, err := engine.StopStartEngine(fltrRplInternalCfgPath, *waitRater); err != nil { + if _, err := engine.StopStartEngine(fltrRplInternalCfgPath, *utils.WaitRater); err != nil { t.Fatal(err) } - if _, err := engine.StartEngine(fltrRplEngine1CfgPath, *waitRater); err != nil { + if _, err := engine.StartEngine(fltrRplEngine1CfgPath, *utils.WaitRater); err != nil { t.Fatal(err) } - if _, err := engine.StartEngine(fltrRplEngine2CfgPath, *waitRater); err != nil { + if _, err := engine.StartEngine(fltrRplEngine2CfgPath, *utils.WaitRater); err != nil { t.Fatal(err) } } func testFltrRplRPCConn(t *testing.T) { var err error - tmp := *encoding + tmp := *utils.Encoding // run only under *gob encoding - *encoding = utils.MetaGOB + *utils.Encoding = utils.MetaGOB if fltrRplInternalRPC, err = newRPCClient(fltrRplInternalCfg.ListenCfg()); err != nil { t.Fatal(err) } @@ -152,7 +152,7 @@ func testFltrRplRPCConn(t *testing.T) { if fltrRplEngine2RPC, err = newRPCClient(fltrRplEngine2Cfg.ListenCfg()); err != nil { t.Fatal(err) } - *encoding = tmp + *utils.Encoding = tmp } func testFltrRplAttributeProfile(t *testing.T) { diff --git a/general_tests/filterhttp_it_test.go b/general_tests/filterhttp_it_test.go index 5934f60e7..2784f469e 100644 --- a/general_tests/filterhttp_it_test.go +++ b/general_tests/filterhttp_it_test.go @@ -35,7 +35,7 @@ import ( ) func TestFilterHTTP(t *testing.T) { - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: case utils.MetaMySQL, utils.MetaMongo, utils.MetaPostgres: t.SkipNow() @@ -171,7 +171,7 @@ cgrates.org,ATTR_DEST,*any,FLTR_DST_1002;FLTR_DEST,,,*req.Supplier,*constant,Sup ConfigJSON: content, TpFiles: tpFiles, } - client, _, shutdown, err := testEnv.Setup(t, *waitRater) + client, _, shutdown, err := testEnv.Setup(t, *utils.WaitRater) if err != nil { t.Fatal(err) } diff --git a/general_tests/filters_it_test.go b/general_tests/filters_it_test.go index bd962c7d7..cc203c452 100644 --- a/general_tests/filters_it_test.go +++ b/general_tests/filters_it_test.go @@ -69,7 +69,7 @@ var ( // Test start here func TestFltrIT(t *testing.T) { - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: fltrConfDIR = "filters_internal" case utils.MetaMySQL: @@ -89,9 +89,9 @@ func TestFltrIT(t *testing.T) { func testV1FltrLoadConfig(t *testing.T) { var err error - fltrCfgPath = path.Join(*dataDir, "conf", "samples", fltrConfDIR) - if *encoding == utils.MetaGOB { - cdrsCfgPath = path.Join(*dataDir, "conf", "samples", fltrConfDIR+"_gob") + fltrCfgPath = path.Join(*utils.DataDir, "conf", "samples", fltrConfDIR) + if *utils.Encoding == utils.MetaGOB { + cdrsCfgPath = path.Join(*utils.DataDir, "conf", "samples", fltrConfDIR+"_gob") } if fltrCfg, err = config.NewCGRConfigFromPath(fltrCfgPath); err != nil { t.Error(err) @@ -100,7 +100,7 @@ func testV1FltrLoadConfig(t *testing.T) { } func testV1FltrInitDataDb(t *testing.T) { - if *dbType == utils.MetaInternal && fltrInternalRestart { + if *utils.DBType == utils.MetaInternal && fltrInternalRestart { testV1FltrStopEngine(t) testV1FltrStartEngine(t) testV1FltrRpcConn(t) @@ -134,7 +134,7 @@ func testV1FltrRpcConn(t *testing.T) { func testV1FltrLoadTarrifPlans(t *testing.T) { var reply string - attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*dataDir, "tariffplans", "testit")} + attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*utils.DataDir, "tariffplans", "testit")} if err := fltrRpc.Call(context.Background(), utils.APIerSv1LoadTariffPlanFromFolder, attrs, &reply); err != nil { t.Error(err) } else if reply != utils.OK { diff --git a/general_tests/fltr_sep_it_test.go b/general_tests/fltr_sep_it_test.go index f25242355..da295a67c 100644 --- a/general_tests/fltr_sep_it_test.go +++ b/general_tests/fltr_sep_it_test.go @@ -56,7 +56,7 @@ var ( // Test start here func TestFltrSepIT(t *testing.T) { - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: fltrSepConfDIR = "tutinternal" case utils.MetaMySQL: @@ -76,7 +76,7 @@ func TestFltrSepIT(t *testing.T) { func testFltrSepLoadConfig(t *testing.T) { var err error - fltrSepCfgPath = path.Join(*dataDir, "conf", "samples", fltrSepConfDIR) + fltrSepCfgPath = path.Join(*utils.DataDir, "conf", "samples", fltrSepConfDIR) if fltrSepCfg, err = config.NewCGRConfigFromPath(fltrSepCfgPath); err != nil { t.Error(err) } @@ -111,7 +111,7 @@ func testFltrSepRpcConn(t *testing.T) { func testFltrSepLoadTarrifPlans(t *testing.T) { var reply string - attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*dataDir, "tariffplans", "fltr_sep")} + attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*utils.DataDir, "tariffplans", "fltr_sep")} if err := fltrSepRPC.Call(context.Background(), utils.APIerSv1LoadTariffPlanFromFolder, attrs, &reply); err != nil { t.Error(err) } else if reply != utils.OK { diff --git a/general_tests/fraud_detection_it_test.go b/general_tests/fraud_detection_it_test.go index 6f7e7b576..e3962ad18 100644 --- a/general_tests/fraud_detection_it_test.go +++ b/general_tests/fraud_detection_it_test.go @@ -64,7 +64,7 @@ var ( ) func TestFraudIT(t *testing.T) { - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: fraudConfDIR = "fraud_internal" case utils.MetaMySQL: @@ -96,7 +96,7 @@ func testFraudRemoveFolders(t *testing.T) { func testFraudLoadConfig(t *testing.T) { var err error - fraudCfgPath = path.Join(*dataDir, "conf", "samples", fraudConfDIR) + fraudCfgPath = path.Join(*utils.DataDir, "conf", "samples", fraudConfDIR) if fraudCfg, err = config.NewCGRConfigFromPath(fraudCfgPath); err != nil { t.Error(err) } diff --git a/general_tests/get_account_cost_it_test.go b/general_tests/get_account_cost_it_test.go index f2ae44fc7..012a45750 100644 --- a/general_tests/get_account_cost_it_test.go +++ b/general_tests/get_account_cost_it_test.go @@ -38,10 +38,10 @@ func TestGetAccountCost(t *testing.T) { testEnv := TestEnvironment{ Name: "TestGetAccountCost", // Encoding: *encoding, - ConfigPath: path.Join(*dataDir, "conf", "samples", "rerate_cdrs_mysql"), - TpPath: path.Join(*dataDir, "tariffplans", "reratecdrs"), + ConfigPath: path.Join(*utils.DataDir, "conf", "samples", "rerate_cdrs_mysql"), + TpPath: path.Join(*utils.DataDir, "tariffplans", "reratecdrs"), } - client, _, shutdown, err := testEnv.Setup(t, *waitRater) + client, _, shutdown, err := testEnv.Setup(t, *utils.WaitRater) if err != nil { t.Fatal(err) } diff --git a/general_tests/gocs_it_test.go b/general_tests/gocs_it_test.go index 6ebe02e31..604f35c1f 100644 --- a/general_tests/gocs_it_test.go +++ b/general_tests/gocs_it_test.go @@ -71,15 +71,15 @@ func TestGOCSIT(t *testing.T) { // Init Config func testGOCSInitCfg(t *testing.T) { - auCfgPath = path.Join(*dataDir, "conf", "samples", "gocs", "au_site") + auCfgPath = path.Join(*utils.DataDir, "conf", "samples", "gocs", "au_site") if auCfg, err = config.NewCGRConfigFromPath(auCfgPath); err != nil { t.Fatal(err) } - usCfgPath = path.Join(*dataDir, "conf", "samples", "gocs", "us_site") + usCfgPath = path.Join(*utils.DataDir, "conf", "samples", "gocs", "us_site") if usCfg, err = config.NewCGRConfigFromPath(usCfgPath); err != nil { t.Fatal(err) } - dspCfgPath = path.Join(*dataDir, "conf", "samples", "gocs", "dsp_site") + dspCfgPath = path.Join(*utils.DataDir, "conf", "samples", "gocs", "dsp_site") if dspCfg, err = config.NewCGRConfigFromPath(dspCfgPath); err != nil { t.Fatal(err) } @@ -110,13 +110,13 @@ func testGOCSResetDB(t *testing.T) { // Start CGR Engine func testGOCSStartEngine(t *testing.T) { - if usEngine, err = engine.StopStartEngine(usCfgPath, *waitRater); err != nil { + if usEngine, err = engine.StopStartEngine(usCfgPath, *utils.WaitRater); err != nil { t.Fatal(err) } - if auEngine, err = engine.StartEngine(auCfgPath, *waitRater); err != nil { + if auEngine, err = engine.StartEngine(auCfgPath, *utils.WaitRater); err != nil { t.Fatal(err) } - if dspEngine, err = engine.StartEngine(dspCfgPath, *waitRater); err != nil { + if dspEngine, err = engine.StartEngine(dspCfgPath, *utils.WaitRater); err != nil { t.Fatal(err) } time.Sleep(10 * time.Millisecond) @@ -177,7 +177,7 @@ func testGOCSLoadData(t *testing.T) { if err != nil { t.Error(err) } - loader := exec.Command(loaderPath, "-config_path", dspCfgPath, "-path", path.Join(*dataDir, "tariffplans", "gocs", "dsp_site")) + loader := exec.Command(loaderPath, "-config_path", dspCfgPath, "-path", path.Join(*utils.DataDir, "tariffplans", "gocs", "dsp_site")) if err := loader.Start(); err != nil { t.Error(err) @@ -217,7 +217,7 @@ func testGOCSLoadData(t *testing.T) { } else if rply := acnt.BalanceMap[utils.MetaVoice].GetTotalValue(); rply != expectedVoice { t.Errorf("Expecting: %v, received: %v", expectedVoice, rply) } - time.Sleep(time.Duration(*waitRater) * time.Millisecond) // Give time for scheduler to execute topups on au_site + time.Sleep(time.Duration(*utils.WaitRater) * time.Millisecond) // Give time for scheduler to execute topups on au_site } func testGOCSAuthSession(t *testing.T) { diff --git a/general_tests/kafka_ssl_it_test.go b/general_tests/kafka_ssl_it_test.go index 00436847b..3aa6af52d 100644 --- a/general_tests/kafka_ssl_it_test.go +++ b/general_tests/kafka_ssl_it_test.go @@ -86,7 +86,7 @@ func TestKafkaSSL(t *testing.T) { func testKafkaSSLLoadConfig(t *testing.T) { var err error - kafkaSSLCfgPath = path.Join(*dataDir, "conf", "samples", kafkaSSLConfigDir) + kafkaSSLCfgPath = path.Join(*utils.DataDir, "conf", "samples", kafkaSSLConfigDir) if kafkaSSLCfg, err = config.NewCGRConfigFromPath(kafkaSSLCfgPath); err != nil { t.Error(err) } @@ -99,7 +99,7 @@ func testKafkaSSLResetDataDB(t *testing.T) { } func testKafkaSSLStartEngine(t *testing.T) { - if _, err := engine.StopStartEngine(kafkaSSLCfgPath, *waitRater); err != nil { + if _, err := engine.StopStartEngine(kafkaSSLCfgPath, *utils.WaitRater); err != nil { t.Fatal(err) } } @@ -174,7 +174,7 @@ func testKafkaSSLVerifyProcessedExport(t *testing.T) { } func testKafkaSSLStopEngine(t *testing.T) { - if err := engine.KillEngine(*waitRater); err != nil { + if err := engine.KillEngine(*utils.WaitRater); err != nil { t.Error(err) } } diff --git a/general_tests/lib_test.go b/general_tests/lib_test.go index 7f2346e76..f6e8669f9 100644 --- a/general_tests/lib_test.go +++ b/general_tests/lib_test.go @@ -19,7 +19,6 @@ package general_tests import ( "errors" - "flag" "fmt" "io" "math/rand" @@ -39,15 +38,11 @@ import ( ) var ( - dataDir = flag.String("data_dir", "/usr/share/cgrates", "CGR data dir path here") - waitRater = flag.Int("wait_rater", 500, "Number of milliseconds to wait for rater to start and cache") - encoding = flag.String("rpc", utils.MetaJSON, "what encoding would be used for rpc communication") - dbType = flag.String("dbtype", utils.MetaInternal, "The type of DataBase (Internal/Mongo/mySql)") - err error + err error ) func newRPCClient(cfg *config.ListenCfg) (c *birpc.Client, err error) { - switch *encoding { + switch *utils.Encoding { case utils.MetaJSON: return jsonrpc.Dial(utils.TCP, cfg.RPCJSONListen) case utils.MetaGOB: diff --git a/general_tests/libengine_it_test.go b/general_tests/libengine_it_test.go index 0b009f501..d7b9f001a 100644 --- a/general_tests/libengine_it_test.go +++ b/general_tests/libengine_it_test.go @@ -49,7 +49,7 @@ var ( ) func TestLibEngineIT(t *testing.T) { - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: libengConfigDIR = "tutinternal" case utils.MetaMySQL: @@ -68,7 +68,7 @@ func TestLibEngineIT(t *testing.T) { } func testLibengITInitCfg(t *testing.T) { - libengCfgPath = path.Join(*dataDir, "conf", "samples", libengConfigDIR) + libengCfgPath = path.Join(*utils.DataDir, "conf", "samples", libengConfigDIR) var err error libengCfg, err = config.NewCGRConfigFromPath(libengCfgPath) if err != nil { @@ -89,7 +89,7 @@ func testLibengITInitStorDb(t *testing.T) { } func testLibengITStartEngine(t *testing.T) { - if _, err := engine.StopStartEngine(libengCfgPath, *waitRater); err != nil { + if _, err := engine.StopStartEngine(libengCfgPath, *utils.WaitRater); err != nil { t.Fatal(err) } } @@ -129,7 +129,7 @@ func testLibengITRPCConnection(t *testing.T) { } func testLibengITStopEngine(t *testing.T) { - if err := engine.KillEngine(*waitRater); err != nil { + if err := engine.KillEngine(*utils.WaitRater); err != nil { t.Error(err) } } diff --git a/general_tests/loader_nocontext_it_test.go b/general_tests/loader_nocontext_it_test.go index e0e3b0fef..a090c330d 100644 --- a/general_tests/loader_nocontext_it_test.go +++ b/general_tests/loader_nocontext_it_test.go @@ -66,7 +66,7 @@ var ( ) func TestLoaderNoContextIT(t *testing.T) { - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: ldrCtxConfDIR = "tutinternal" case utils.MetaMySQL: @@ -86,7 +86,7 @@ func TestLoaderNoContextIT(t *testing.T) { func testLoaderNoContextLoadConfig(t *testing.T) { var err error - ldrCtxCfgPath = path.Join(*dataDir, "conf", "samples", ldrCtxConfDIR) + ldrCtxCfgPath = path.Join(*utils.DataDir, "conf", "samples", ldrCtxConfDIR) if ldrCtxCfg, err = config.NewCGRConfigFromPath(ldrCtxCfgPath); err != nil { t.Error(err) } diff --git a/general_tests/loaders_internal_indexes_it_test.go b/general_tests/loaders_internal_indexes_it_test.go index f3cd15044..b97cb852e 100644 --- a/general_tests/loaders_internal_indexes_it_test.go +++ b/general_tests/loaders_internal_indexes_it_test.go @@ -38,7 +38,7 @@ import ( var ( loadersIDBIdxCfgDir string loadersIDBIdxCfgPath string - loadersIDBIdxCfgPathInternal = path.Join(*dataDir, "conf", "samples", "loaders_indexes_internal_db") + loadersIDBIdxCfgPathInternal = path.Join(*utils.DataDir, "conf", "samples", "loaders_indexes_internal_db") loadersIDBIdxCfg, loadersIDBIdxCfgInternal *config.CGRConfig loadersIDBIdxRPC, loadersIDBIdxRPCInternal *birpc.Client @@ -55,7 +55,7 @@ var ( ) func TestLoadersIDBIdxIt(t *testing.T) { - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: loadersIDBIdxCfgDir = "tutinternal" case utils.MetaMySQL: @@ -73,7 +73,7 @@ func TestLoadersIDBIdxIt(t *testing.T) { } func testLoadersIDBIdxItLoadConfig(t *testing.T) { - loadersIDBIdxCfgPath = path.Join(*dataDir, "conf", "samples", loadersIDBIdxCfgDir) + loadersIDBIdxCfgPath = path.Join(*utils.DataDir, "conf", "samples", loadersIDBIdxCfgDir) if loadersIDBIdxCfg, err = config.NewCGRConfigFromPath(loadersIDBIdxCfgPath); err != nil { t.Error(err) } @@ -92,10 +92,10 @@ func testLoadersIDBIdxItDB(t *testing.T) { } func testLoadersIDBIdxItStartEngines(t *testing.T) { - if _, err := engine.StopStartEngine(loadersIDBIdxCfgPath, *waitRater); err != nil { + if _, err := engine.StopStartEngine(loadersIDBIdxCfgPath, *utils.WaitRater); err != nil { t.Fatal(err) } - if _, err := engine.StartEngine(loadersIDBIdxCfgPathInternal, *waitRater); err != nil { + if _, err := engine.StartEngine(loadersIDBIdxCfgPathInternal, *utils.WaitRater); err != nil { t.Fatal(err) } } @@ -113,7 +113,7 @@ func testLoadersIDBIdxItRPCConn(t *testing.T) { func testLoadersIDBIdxItLoad(t *testing.T) { var loadInst utils.LoadInstance if err := loadersIDBIdxRPCInternal.Call(context.Background(), utils.APIerSv2LoadTariffPlanFromFolder, - &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*dataDir, "tariffplans", "tutorial")}, + &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*utils.DataDir, "tariffplans", "tutorial")}, &loadInst); err != nil { t.Error(err) } diff --git a/general_tests/oldtutorial_it_test.go b/general_tests/oldtutorial_it_test.go index 6212522ca..46d5c7939 100644 --- a/general_tests/oldtutorial_it_test.go +++ b/general_tests/oldtutorial_it_test.go @@ -43,14 +43,14 @@ package general_tests // var loadInst utils.LoadInstance // Share load information between tests // func TestTutITInitCfg(t *testing.T) { -// tutLocalCfgPath = path.Join(**dataDir, "conf", "samples", "tutmysql") +// tutLocalCfgPath = path.Join(*utils.DataDir, "conf", "samples", "tutmysql") // // Init config first // var err error // tutFsLocalCfg, err = config.NewCGRConfigFromPath(tutLocalCfgPath) // if err != nil { // t.Error(err) // } -// tutFsLocalCfg.DataFolderPath = **dataDir // Share DataFolderPath through config towards StoreDb for Flush() +// tutFsLocalCfg.DataFolderPath = *utils.DataDir // Share DataFolderPath through config towards StoreDb for Flush() // config.SetCgrConfig(tutFsLocalCfg) // } @@ -70,7 +70,7 @@ package general_tests // // Start CGR Engine // func TestTutITStartEngine(t *testing.T) { -// if _, err := engine.StopStartEngine(tutLocalCfgPath, **waitRater); err != nil { +// if _, err := engine.StopStartEngine(tutLocalCfgPath, *utils.WaitRater); err != nil { // t.Fatal(err) // } // } @@ -86,11 +86,11 @@ package general_tests // // Load the tariff plan, creating accounts and their balances // func TestTutITLoadTariffPlanFromFolder(t *testing.T) { -// attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(**dataDir, "tariffplans", "oldtutorial")} +// attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*utils.DataDir, "tariffplans", "oldtutorial")} // if err := tutLocalRpc.Call(context.Background(),utils.APIerSv2LoadTariffPlanFromFolder, attrs, &loadInst); err != nil { // t.Error(err) // } -// time.Sleep(100*time.Millisecond + time.Duration(**waitRater)*time.Millisecond) // Give time for scheduler to execute topups +// time.Sleep(100*time.Millisecond + time.Duration(**utils.WaitRater)*time.Millisecond) // Give time for scheduler to execute topups // } // // Check loaded stats @@ -574,7 +574,7 @@ package general_tests // } else if reply != utils.OK { // t.Error("Unexpected reply received: ", reply) // } -// time.Sleep(time.Duration(**waitRater) * time.Millisecond) +// time.Sleep(time.Duration(**utils.WaitRater) * time.Millisecond) // eCdr := &engine.ExternalCDR{CGRID: "63a8d2bfeca2cfb790826c3ec461696d6574cfde", OrderID: 2, // ToR: utils.VOICE, // OriginID: "testextcdr2", OriginHost: "192.168.1.1", Source: utils.UNIT_TEST, RequestType: utils.MetaRated, @@ -643,7 +643,7 @@ package general_tests // } else if reply != utils.OK { // t.Error("Unexpected reply received: ", reply) // } -// time.Sleep(time.Duration(**waitRater) * time.Millisecond) +// time.Sleep(time.Duration(**utils.WaitRater) * time.Millisecond) // var cdrs []*engine.ExternalCDR // req := utils.RPCCDRsFilter{RunIDs: []string{utils.MetaDefault}, Accounts: []string{cdr.Account}, DestinationPrefixes: []string{cdr.Destination}} // if err := tutLocalRpc.Call(context.Background(),utils.APIerSv2GetCDRs, req, &cdrs); err != nil { @@ -669,7 +669,7 @@ package general_tests // } else if reply != utils.OK { // t.Error("Unexpected reply received: ", reply) // } -// time.Sleep(time.Duration(**waitRater) * time.Millisecond) // Give time for CDR to be processed +// time.Sleep(time.Duration(**utils.WaitRater) * time.Millisecond) // Give time for CDR to be processed // req = utils.RPCCDRsFilter{RunIDs: []string{utils.MetaDefault}, Accounts: []string{cdr2.Account}, DestinationPrefixes: []string{cdr2.Destination}} // if err := tutLocalRpc.Call(context.Background(),utils.APIerSv2GetCDRs, req, &cdrs); err != nil { // t.Error("Unexpected error: ", err.Error()) @@ -694,7 +694,7 @@ package general_tests // } else if reply != utils.OK { // t.Error("Unexpected reply received: ", reply) // } -// time.Sleep(time.Duration(**waitRater) * time.Millisecond) // Give time for CDR to be processed +// time.Sleep(time.Duration(**utils.WaitRater) * time.Millisecond) // Give time for CDR to be processed // req = utils.RPCCDRsFilter{RunIDs: []string{utils.MetaDefault}, Accounts: []string{cdr3.Account}, DestinationPrefixes: []string{cdr3.Destination}} // if err := tutLocalRpc.Call(context.Background(),utils.APIerSv2GetCDRs, req, &cdrs); err != nil { // t.Error("Unexpected error: ", err.Error()) @@ -1169,7 +1169,7 @@ package general_tests // Offset int // Set the item offset // Limit int // Limit number of items retrieved // } -// time.Sleep(time.Duration(**waitRater) * time.Millisecond) // Give time for scheduler to execute topups +// time.Sleep(time.Duration(**utils.WaitRater) * time.Millisecond) // Give time for scheduler to execute topups // var acnts []*engine.Account // if err := tutLocalRpc.Call("APIerSv2.GetAccounts", utils.AttrGetAccounts{Tenant: attrs.Tenant, AccountIds: []string{attrs.Account}}, &acnts); err != nil { // t.Error(err) @@ -1231,7 +1231,7 @@ package general_tests // } else if reply != utils.OK { // t.Errorf("Calling APIerSv2.SetAccount received: %s", reply) // } -// time.Sleep(100*time.Millisecond + time.Duration(**waitRater)*time.Millisecond) // Give time for scheduler to execute topups +// time.Sleep(100*time.Millisecond + time.Duration(**utils.WaitRater)*time.Millisecond) // Give time for scheduler to execute topups // if err := tutLocalRpc.Call("APIerSv2.GetAccounts", utils.AttrGetAccounts{Tenant: attrs.Tenant, AccountIds: []string{attrs.Account}}, &acnts); err != nil { // t.Error(err) // } else if len(acnts) != 1 { @@ -1354,7 +1354,7 @@ package general_tests // } else if reply != utils.OK { // t.Error("Unexpected reply received: ", reply) // } -// time.Sleep(time.Duration(**waitRater) * time.Millisecond) // Give time for CDR to be processed +// time.Sleep(time.Duration(**utils.WaitRater) * time.Millisecond) // Give time for CDR to be processed // var cdrs []*engine.ExternalCDR // req := utils.RPCCDRsFilter{RunIDs: []string{utils.MetaDefault}, CGRIDs: []string{cdr.CGRID}} // if err := tutLocalRpc.Call(context.Background(),utils.APIerSv2GetCDRs, req, &cdrs); err != nil { diff --git a/general_tests/poster_it_test.go b/general_tests/poster_it_test.go index d11ead890..9f411a9cc 100644 --- a/general_tests/poster_it_test.go +++ b/general_tests/poster_it_test.go @@ -61,7 +61,7 @@ var ( ) func TestPosterIT(t *testing.T) { - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: pstrConfigDIR = "actions_internal" case utils.MetaMySQL: @@ -73,7 +73,7 @@ func TestPosterIT(t *testing.T) { default: t.Fatal("Unknown Database type") } - if *encoding == utils.MetaGOB { + if *utils.Encoding == utils.MetaGOB { pstrConfigDIR += "_gob" } @@ -83,7 +83,7 @@ func TestPosterIT(t *testing.T) { } func testPosterITInitCfg(t *testing.T) { - pstrCfgPath = path.Join(*dataDir, "conf", "samples", pstrConfigDIR) + pstrCfgPath = path.Join(*utils.DataDir, "conf", "samples", pstrConfigDIR) var err error pstrCfg, err = config.NewCGRConfigFromPath(pstrCfgPath) if err != nil { @@ -109,7 +109,7 @@ func testPosterITStartEngine(t *testing.T) { if err := os.MkdirAll(pstrCfg.GeneralCfg().FailedPostsDir, 0755); err != nil { t.Fatal(err) } - if _, err := engine.StopStartEngine(pstrCfgPath, *waitRater); err != nil { + if _, err := engine.StopStartEngine(pstrCfgPath, *utils.WaitRater); err != nil { t.Fatal(err) } } @@ -344,7 +344,7 @@ func testPosterITKafka(t *testing.T) { } func testPosterITStopCgrEngine(t *testing.T) { - if err := engine.KillEngine(*waitRater); err != nil { + if err := engine.KillEngine(*utils.WaitRater); err != nil { t.Error(err) } } diff --git a/general_tests/redis_cluster_it_test.go b/general_tests/redis_cluster_it_test.go index 86255a61d..2fc710acf 100644 --- a/general_tests/redis_cluster_it_test.go +++ b/general_tests/redis_cluster_it_test.go @@ -68,8 +68,8 @@ var ( clsrConfig *config.CGRConfig clsrRPC *birpc.Client - clsrNodeCfgPath = path.Join(*dataDir, "redisCluster", "node%v.conf") - clsrEngineCfgPath = path.Join(*dataDir, "conf", "samples", "redisCluster") + clsrNodeCfgPath = path.Join(*utils.DataDir, "redisCluster", "node%v.conf") + clsrEngineCfgPath = path.Join(*utils.DataDir, "conf", "samples", "redisCluster") clsrNodes = make(map[string]*exec.Cmd) clsrOutput = make(map[string]*bytes.Buffer) // in order to debug if something is not working clsrNoNodes = 6 // this is the minimum number of nodes for a cluster with 1 replica for each master @@ -115,7 +115,7 @@ func TestRedisCluster(t *testing.T) { if !*clsrRedisFlag { t.SkipNow() } - switch *dbType { + switch *utils.DBType { case utils.MetaMySQL: case utils.MetaInternal, utils.MetaMongo, @@ -165,7 +165,7 @@ func testClsrInitConfig(t *testing.T) { if err != nil { t.Error(err) } - clsrConfig.DataFolderPath = *dataDir // Share DataFolderPath through config towards StoreDb for Flush() + clsrConfig.DataFolderPath = *utils.DataDir // Share DataFolderPath through config towards StoreDb for Flush() } func testClsrFlushDb(t *testing.T) { diff --git a/general_tests/redis_tls_it_test.go b/general_tests/redis_tls_it_test.go index 0cde03c82..83cca2696 100644 --- a/general_tests/redis_tls_it_test.go +++ b/general_tests/redis_tls_it_test.go @@ -38,7 +38,7 @@ import ( var ( redisTLS = flag.Bool("redisTLS", false, "Run tests with redis tls") redisTLSServer *exec.Cmd - redisTLSEngineCfg = path.Join(*dataDir, "conf", "samples", "redisTLS") + redisTLSEngineCfg = path.Join(*utils.DataDir, "conf", "samples", "redisTLS") redisTLSCfg *config.CGRConfig redisTLSRPC *birpc.Client diff --git a/general_tests/rerate_cdrs_it_test.go b/general_tests/rerate_cdrs_it_test.go index c8b166392..0fbe0a4e5 100644 --- a/general_tests/rerate_cdrs_it_test.go +++ b/general_tests/rerate_cdrs_it_test.go @@ -34,7 +34,7 @@ import ( func TestRerateCDRs(t *testing.T) { var cfgDir string - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: cfgDir = "rerate_cdrs_internal" case utils.MetaMySQL: @@ -49,10 +49,10 @@ func TestRerateCDRs(t *testing.T) { testEnv := TestEnvironment{ Name: "TestRerateCDRs", // Encoding: *encoding, - ConfigPath: path.Join(*dataDir, "conf", "samples", cfgDir), - TpPath: path.Join(*dataDir, "tariffplans", "reratecdrs"), + ConfigPath: path.Join(*utils.DataDir, "conf", "samples", cfgDir), + TpPath: path.Join(*utils.DataDir, "tariffplans", "reratecdrs"), } - client, _, shutdown, err := testEnv.Setup(t, *waitRater) + client, _, shutdown, err := testEnv.Setup(t, *utils.WaitRater) if err != nil { t.Fatal(err) } diff --git a/general_tests/rerate_ers_cdrs_it_test.go b/general_tests/rerate_ers_cdrs_it_test.go index 74e22823e..6f53499e8 100644 --- a/general_tests/rerate_ers_cdrs_it_test.go +++ b/general_tests/rerate_ers_cdrs_it_test.go @@ -95,7 +95,7 @@ func testRerateCDRsERsDeleteFolders(t *testing.T) { func testRerateCDRsERsLoadConfig(t *testing.T) { var err error - rrErsCdrsCfgPath = path.Join(*dataDir, "conf", "samples", "ers_rerate") + rrErsCdrsCfgPath = path.Join(*utils.DataDir, "conf", "samples", "ers_rerate") if rrErsCdrsCfg, err = config.NewCGRConfigFromPath(rrErsCdrsCfgPath); err != nil { t.Error(err) } @@ -130,7 +130,7 @@ func testRerateCDRsERsRPCConn(t *testing.T) { func testRerateCDRsERsLoadTP(t *testing.T) { var reply string - attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*dataDir, "tariffplans", "reratecdrs")} + attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*utils.DataDir, "tariffplans", "reratecdrs")} if err := rrErsCdrsRPC.Call(context.Background(), utils.APIerSv1LoadTariffPlanFromFolder, attrs, &reply); err != nil { t.Error(err) } else if reply != utils.OK { diff --git a/general_tests/rerate_exp_it_test.go b/general_tests/rerate_exp_it_test.go index af1c23d0d..38e9a66d3 100644 --- a/general_tests/rerate_exp_it_test.go +++ b/general_tests/rerate_exp_it_test.go @@ -73,7 +73,7 @@ var ( ) func TestRerateExpIT(t *testing.T) { - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: ng1ConfDIR = "rerate_exp_engine1_internal" ng2ConfDIR = "rerate_exp_engine2_internal" @@ -96,11 +96,11 @@ func TestRerateExpIT(t *testing.T) { func testRerateExpLoadConfig(t *testing.T) { var err error - ng1CfgPath = path.Join(*dataDir, "conf", "samples", "rerate_exp_multiple_engines", ng1ConfDIR) + ng1CfgPath = path.Join(*utils.DataDir, "conf", "samples", "rerate_exp_multiple_engines", ng1ConfDIR) if ng1Cfg, err = config.NewCGRConfigFromPath(ng1CfgPath); err != nil { t.Error(err) } - ng2CfgPath = path.Join(*dataDir, "conf", "samples", "rerate_exp_multiple_engines", ng2ConfDIR) + ng2CfgPath = path.Join(*utils.DataDir, "conf", "samples", "rerate_exp_multiple_engines", ng2ConfDIR) if ng2Cfg, err = config.NewCGRConfigFromPath(ng2CfgPath); err != nil { t.Error(err) } @@ -148,7 +148,7 @@ func testRerateExpRPCConn(t *testing.T) { func testRerateExpLoadTP(t *testing.T) { var reply string - attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*dataDir, "tariffplans", "reratecdrs")} + attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*utils.DataDir, "tariffplans", "reratecdrs")} if err := ng1RPC.Call(context.Background(), utils.APIerSv1LoadTariffPlanFromFolder, attrs, &reply); err != nil { t.Error(err) } else if reply != utils.OK { diff --git a/general_tests/resourcesv1_it_test.go b/general_tests/resourcesv1_it_test.go index b359a6e99..54efea3ee 100644 --- a/general_tests/resourcesv1_it_test.go +++ b/general_tests/resourcesv1_it_test.go @@ -53,7 +53,7 @@ var ( // Test start here func TestRsV1IT(t *testing.T) { - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: rlsV1ConfDIR = "tutinternal" case utils.MetaMySQL: @@ -72,7 +72,7 @@ func TestRsV1IT(t *testing.T) { func testV1RsLoadConfig(t *testing.T) { var err error - rlsV1CfgPath = path.Join(*dataDir, "conf", "samples", rlsV1ConfDIR) + rlsV1CfgPath = path.Join(*utils.DataDir, "conf", "samples", rlsV1ConfDIR) if rlsV1Cfg, err = config.NewCGRConfigFromPath(rlsV1CfgPath); err != nil { t.Error(err) } @@ -92,7 +92,7 @@ func testV1RsResetStorDb(t *testing.T) { } func testV1RsStartEngine(t *testing.T) { - if _, err := engine.StopStartEngine(rlsV1CfgPath, *waitRater); err != nil { + if _, err := engine.StopStartEngine(rlsV1CfgPath, *utils.WaitRater); err != nil { t.Fatal(err) } } @@ -225,7 +225,7 @@ func testV1RsAuthorize(t *testing.T) { } func testV1RsStopEngine(t *testing.T) { - if err := engine.KillEngine(*waitRater); err != nil { + if err := engine.KillEngine(*utils.WaitRater); err != nil { t.Error(err) } } diff --git a/general_tests/route_it_test.go b/general_tests/route_it_test.go index 2cc791d69..07e8ad604 100644 --- a/general_tests/route_it_test.go +++ b/general_tests/route_it_test.go @@ -67,7 +67,7 @@ var ( // Test start here func TestRouteSV1IT(t *testing.T) { - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: splSv1ConfDIR = "tutinternal" case utils.MetaMySQL: @@ -86,7 +86,7 @@ func TestRouteSV1IT(t *testing.T) { func testV1SplSLoadConfig(t *testing.T) { var err error - splSv1CfgPath = path.Join(*dataDir, "conf", "samples", splSv1ConfDIR) + splSv1CfgPath = path.Join(*utils.DataDir, "conf", "samples", splSv1ConfDIR) if splSv1Cfg, err = config.NewCGRConfigFromPath(splSv1CfgPath); err != nil { t.Error(err) } @@ -106,7 +106,7 @@ func testV1SplSResetStorDb(t *testing.T) { } func testV1SplSStartEngine(t *testing.T) { - if _, err := engine.StopStartEngine(splSv1CfgPath, *waitRater); err != nil { + if _, err := engine.StopStartEngine(splSv1CfgPath, *utils.WaitRater); err != nil { t.Fatal(err) } } @@ -121,7 +121,7 @@ func testV1SplSRpcConn(t *testing.T) { func testV1SplSFromFolder(t *testing.T) { var reply string - attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*dataDir, "tariffplans", "testit")} + attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*utils.DataDir, "tariffplans", "testit")} if err := splSv1Rpc.Call(context.Background(), utils.APIerSv1LoadTariffPlanFromFolder, attrs, &reply); err != nil { t.Error(err) } diff --git a/general_tests/routes_cases_it_test.go b/general_tests/routes_cases_it_test.go index a002e7afe..f787bc950 100644 --- a/general_tests/routes_cases_it_test.go +++ b/general_tests/routes_cases_it_test.go @@ -80,7 +80,7 @@ var ( // Test start here func TestRoutesCaseV1IT(t *testing.T) { - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: rtsCaseSv1ConfDIR = "tutinternal" case utils.MetaMySQL: @@ -99,7 +99,7 @@ func TestRoutesCaseV1IT(t *testing.T) { func testV1RtsCaseLoadConfig(t *testing.T) { var err error - rtsCaseSv1CfgPath = path.Join(*dataDir, "conf", "samples", rtsCaseSv1ConfDIR) + rtsCaseSv1CfgPath = path.Join(*utils.DataDir, "conf", "samples", rtsCaseSv1ConfDIR) if rtsCaseSv1Cfg, err = config.NewCGRConfigFromPath(rtsCaseSv1CfgPath); err != nil { t.Error(err) } @@ -119,7 +119,7 @@ func testV1RtsCaseResetStorDb(t *testing.T) { } func testV1RtsCaseStartEngine(t *testing.T) { - if _, err := engine.StopStartEngine(rtsCaseSv1CfgPath, *waitRater); err != nil { + if _, err := engine.StopStartEngine(rtsCaseSv1CfgPath, *utils.WaitRater); err != nil { t.Fatal(err) } } @@ -134,7 +134,7 @@ func testV1RtsCaseRpcConn(t *testing.T) { func testV1RtsCaseFromFolder(t *testing.T) { var reply string - attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*dataDir, "tariffplans", "tutroutes")} + attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*utils.DataDir, "tariffplans", "tutroutes")} if err := rtsCaseSv1Rpc.Call(context.Background(), utils.APIerSv1LoadTariffPlanFromFolder, attrs, &reply); err != nil { t.Error(err) } diff --git a/general_tests/rpccaching_it_test.go b/general_tests/rpccaching_it_test.go index a08c714a7..0579f63dd 100644 --- a/general_tests/rpccaching_it_test.go +++ b/general_tests/rpccaching_it_test.go @@ -72,7 +72,7 @@ var ( // Test start here func TestRPCMethods(t *testing.T) { - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: t.SkipNow() case utils.MetaMySQL: @@ -92,7 +92,7 @@ func TestRPCMethods(t *testing.T) { func testRPCMethodsLoadConfig(t *testing.T) { var err error - rpcCfgPath = path.Join(*dataDir, "conf", "samples", rpcConfDIR) + rpcCfgPath = path.Join(*utils.DataDir, "conf", "samples", rpcConfDIR) if rpcCfg, err = config.NewCGRConfigFromPath(rpcCfgPath); err != nil { t.Error(err) } @@ -112,7 +112,7 @@ func testRPCMethodsResetStorDb(t *testing.T) { } func testRPCMethodsStartEngine(t *testing.T) { - if _, err := engine.StopStartEngine(rpcCfgPath, *waitRater); err != nil { + if _, err := engine.StopStartEngine(rpcCfgPath, *utils.WaitRater); err != nil { t.Fatal(err) } } @@ -127,7 +127,7 @@ func testRPCMethodsRpcConn(t *testing.T) { func testRPCMethodsFromFolder(t *testing.T) { var reply string - attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*dataDir, "tariffplans", "testit")} + attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*utils.DataDir, "tariffplans", "testit")} if err := rpcRpc.Call(context.Background(), utils.APIerSv1LoadTariffPlanFromFolder, attrs, &reply); err != nil { t.Error(err) } @@ -812,11 +812,11 @@ func testRPCMethodsCdrsStoreSessionCost(t *testing.T) { // Load the tariff plan, creating accounts and their balances func testRPCMethodsLoadData(t *testing.T) { - attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*dataDir, "tariffplans", "testtp")} + attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*utils.DataDir, "tariffplans", "testtp")} if err := rpcRpc.Call(context.Background(), utils.APIerSv2LoadTariffPlanFromFolder, attrs, &tpLoadInst); err != nil { t.Error(err) } - time.Sleep(time.Duration(*waitRater) * time.Millisecond) // Give time for scheduler to execute topups + time.Sleep(time.Duration(*utils.WaitRater) * time.Millisecond) // Give time for scheduler to execute topups } func testRPCMethodsResponderDebit(t *testing.T) { diff --git a/general_tests/rpcclient_it_test.go b/general_tests/rpcclient_it_test.go index f620f405c..e75584876 100644 --- a/general_tests/rpcclient_it_test.go +++ b/general_tests/rpcclient_it_test.go @@ -75,7 +75,7 @@ var sTestRPCITLcl = []func(t *testing.T){ } func TestRPCITLcl(t *testing.T) { - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: rpcITCfgDIR1 = "multiral1_internal" rpcITCfgDIR2 = "multiral2_internal" @@ -91,13 +91,13 @@ func TestRPCITLcl(t *testing.T) { t.Fatal("Unknown Database type") } for _, stest := range sTestRPCITLcl { - t.Run(*dbType, stest) + t.Run(*utils.DBType, stest) } } func testRPCITLclInitCfg(t *testing.T) { - rpcITCfgPath1 = path.Join(*dataDir, "conf", "samples", rpcITCfgDIR1) - rpcITCfgPath2 = path.Join(*dataDir, "conf", "samples", rpcITCfgDIR2) + rpcITCfgPath1 = path.Join(*utils.DataDir, "conf", "samples", rpcITCfgDIR1) + rpcITCfgPath2 = path.Join(*utils.DataDir, "conf", "samples", rpcITCfgDIR2) rpcITCfg1, err = config.NewCGRConfigFromPath(rpcITCfgPath1) if err != nil { t.Error(err) @@ -112,7 +112,7 @@ func testRPCITLclInitCfg(t *testing.T) { } func testRPCITLclStartSecondEngine(t *testing.T) { - if ral2, err = engine.StopStartEngine(rpcITCfgPath2, *waitRater); err != nil { + if ral2, err = engine.StopStartEngine(rpcITCfgPath2, *utils.WaitRater); err != nil { t.Fatal(err) } } @@ -151,7 +151,7 @@ func testRPCITLclStatusSecondEngine(t *testing.T) { // Start first engine func testRPCITLclStartFirstEngine(t *testing.T) { - if ral1, err = engine.StartEngine(rpcITCfgPath1, *waitRater); err != nil { + if ral1, err = engine.StartEngine(rpcITCfgPath1, *utils.WaitRater); err != nil { t.Fatal(err) } } @@ -178,7 +178,7 @@ func testRPCITLclStatusFirstFailover(t *testing.T) { if err := ral1.Process.Kill(); err != nil { // Kill the first RAL t.Error(err) } - time.Sleep(time.Duration(*waitRater) * time.Millisecond) + time.Sleep(time.Duration(*utils.WaitRater) * time.Millisecond) var status map[string]any if err := rpcPoolFirst.Call(context.Background(), utils.CoreSv1Status, utils.TenantWithAPIOpts{}, &status); err != nil { t.Error(err) @@ -195,7 +195,7 @@ func testRPCITLclStatusFirstFailover(t *testing.T) { } func testRPCITLclStatusFirstFailback(t *testing.T) { - if ral1, err = engine.StartEngine(rpcITCfgPath1, *waitRater); err != nil { + if ral1, err = engine.StartEngine(rpcITCfgPath1, *utils.WaitRater); err != nil { t.Fatal(err) } var status map[string]any @@ -253,7 +253,7 @@ func testRPCITLclBcastStatusNoRals1(t *testing.T) { if err := ral1.Process.Kill(); err != nil { // Kill the first RAL t.Error(err) } - time.Sleep(time.Duration(*waitRater) * time.Millisecond) + time.Sleep(time.Duration(*utils.WaitRater) * time.Millisecond) var status map[string]any if err := rpcPoolBroadcast.Call(context.Background(), utils.CoreSv1Status, utils.TenantWithAPIOpts{}, &status); err != nil { t.Error(err) @@ -271,7 +271,7 @@ func testRPCITLclBcastStatusBcastNoRals(t *testing.T) { if err := ral2.Process.Kill(); err != nil { // Kill the first RAL t.Error(err) } - time.Sleep(time.Duration(*waitRater) * time.Millisecond) + time.Sleep(time.Duration(*utils.WaitRater) * time.Millisecond) var status map[string]any if err := rpcPoolBroadcast.Call(context.Background(), utils.CoreSv1Status, utils.TenantWithAPIOpts{}, &status); err == nil { t.Error("Should get error") @@ -279,7 +279,7 @@ func testRPCITLclBcastStatusBcastNoRals(t *testing.T) { } func testRPCITLclBcastStatusRALs2Up(t *testing.T) { - if ral2, err = engine.StartEngine(rpcITCfgPath2, *waitRater); err != nil { + if ral2, err = engine.StartEngine(rpcITCfgPath2, *utils.WaitRater); err != nil { t.Fatal(err) } var status map[string]any @@ -296,7 +296,7 @@ func testRPCITLclBcastStatusRALs2Up(t *testing.T) { } func testRPCITLclStatusBcastRALs1Up(t *testing.T) { - if ral1, err = engine.StartEngine(rpcITCfgPath1, *waitRater); err != nil { + if ral1, err = engine.StartEngine(rpcITCfgPath1, *utils.WaitRater); err != nil { t.Fatal(err) } var status map[string]any @@ -321,7 +321,7 @@ func TestRPCITStatusBcastCmd(t *testing.T) { t.Errorf("Received unexpected stats: %+v", stats) } var loadInst utils.LoadInstance - attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(**dataDir, "tariffplans", "oldtutorial")} + attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*utils.DataDir, "tariffplans", "oldtutorial")} if err := rpcRAL1.Call(context.Background(),utils.APIerSv2LoadTariffPlanFromFolder, attrs, &loadInst); err != nil { t.Error(err) } else if loadInst.RatingLoadID == "" || loadInst.AccountingLoadID == "" { diff --git a/general_tests/rpsubj_set_it_test.go b/general_tests/rpsubj_set_it_test.go index 8afe68646..42bd4326a 100644 --- a/general_tests/rpsubj_set_it_test.go +++ b/general_tests/rpsubj_set_it_test.go @@ -30,7 +30,7 @@ import ( ) func TestRatingSubjectSet(t *testing.T) { - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: case utils.MetaMySQL, utils.MetaMongo, utils.MetaPostgres: t.SkipNow() @@ -91,7 +91,7 @@ cgrates.org,data,RPF_DATA,2022-01-14T00:00:00Z,RP_DATA,`, ConfigJSON: content, TpFiles: tpFiles, } - client, _, shutdown, err := testEnv.Setup(t, *waitRater) + client, _, shutdown, err := testEnv.Setup(t, *utils.WaitRater) if err != nil { t.Fatal(err) } @@ -157,7 +157,7 @@ cgrates.org,data,RPF_DATA,2022-01-14T00:00:00Z,RP_DATA,`, } func TestRatingSubjectSetDefault(t *testing.T) { - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: case utils.MetaMySQL, utils.MetaMongo, utils.MetaPostgres: t.SkipNow() @@ -225,7 +225,7 @@ cgrates.org,data,1001,2022-01-14T00:00:00Z,RP_DATA,`, ConfigJSON: content, TpFiles: tpFiles, } - client, _, shutdown, err := testEnv.Setup(t, *waitRater) + client, _, shutdown, err := testEnv.Setup(t, *utils.WaitRater) if err != nil { t.Fatal(err) } diff --git a/general_tests/sentinel_it_test.go b/general_tests/sentinel_it_test.go index fda87c25a..981ba326c 100644 --- a/general_tests/sentinel_it_test.go +++ b/general_tests/sentinel_it_test.go @@ -38,11 +38,11 @@ import ( ) var ( - node1ConfigPath = path.Join(*dataDir, "redisSentinel", "node1.conf") - node2ConfigPath = path.Join(*dataDir, "redisSentinel", "node2.conf") - sentinel1ConfigPath = path.Join(*dataDir, "redisSentinel", "sentinel1.conf") - sentinel2ConfigPath = path.Join(*dataDir, "redisSentinel", "sentinel2.conf") - engineConfigPath = path.Join(*dataDir, "conf", "samples", "redisSentinel") + node1ConfigPath = path.Join(*utils.DataDir, "redisSentinel", "node1.conf") + node2ConfigPath = path.Join(*utils.DataDir, "redisSentinel", "node2.conf") + sentinel1ConfigPath = path.Join(*utils.DataDir, "redisSentinel", "sentinel1.conf") + sentinel2ConfigPath = path.Join(*utils.DataDir, "redisSentinel", "sentinel2.conf") + engineConfigPath = path.Join(*utils.DataDir, "conf", "samples", "redisSentinel") sentinelConfig *config.CGRConfig sentinelRPC *birpc.Client node1Exec *exec.Cmd @@ -74,7 +74,7 @@ func TestRedisSentinel(t *testing.T) { if !*redisSentinel { return } - switch *dbType { + switch *utils.DBType { case utils.MetaMySQL: case utils.MetaInternal, utils.MetaMongo, diff --git a/general_tests/session2_it_test.go b/general_tests/session2_it_test.go index da52de941..7bde503bb 100644 --- a/general_tests/session2_it_test.go +++ b/general_tests/session2_it_test.go @@ -58,7 +58,7 @@ var ( ) func TestSes2It(t *testing.T) { - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: ses2CfgDir = "tutinternal" case utils.MetaMySQL: @@ -76,7 +76,7 @@ func TestSes2It(t *testing.T) { } func testSes2ItLoadConfig(t *testing.T) { - ses2CfgPath = path.Join(*dataDir, "conf", "samples", ses2CfgDir) + ses2CfgPath = path.Join(*utils.DataDir, "conf", "samples", ses2CfgDir) if ses2Cfg, err = config.NewCGRConfigFromPath(ses2CfgPath); err != nil { t.Error(err) } @@ -95,7 +95,7 @@ func testSes2ItResetStorDb(t *testing.T) { } func testSes2ItStartEngine(t *testing.T) { - if _, err := engine.StopStartEngine(ses2CfgPath, *waitRater); err != nil { + if _, err := engine.StopStartEngine(ses2CfgPath, *utils.WaitRater); err != nil { t.Fatal(err) } } @@ -110,7 +110,7 @@ func testSes2ItRPCConn(t *testing.T) { func testSes2ItLoadFromFolder(t *testing.T) { var reply string - attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*dataDir, "tariffplans", "tutorial")} + attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*utils.DataDir, "tariffplans", "tutorial")} if err := ses2RPC.Call(context.Background(), utils.APIerSv1LoadTariffPlanFromFolder, attrs, &reply); err != nil { t.Error(err) } diff --git a/general_tests/session3_it_test.go b/general_tests/session3_it_test.go index 2ddacfe3d..2e099fea0 100644 --- a/general_tests/session3_it_test.go +++ b/general_tests/session3_it_test.go @@ -65,7 +65,7 @@ var ( ) func TestSes3ItSessions(t *testing.T) { - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: ses3CfgDir = "sessions_internal" case utils.MetaMySQL: @@ -83,7 +83,7 @@ func TestSes3ItSessions(t *testing.T) { } func testSes3ItLoadConfig(t *testing.T) { - ses3CfgPath = path.Join(*dataDir, "conf", "samples", ses3CfgDir) + ses3CfgPath = path.Join(*utils.DataDir, "conf", "samples", ses3CfgDir) if ses3Cfg, err = config.NewCGRConfigFromPath(ses3CfgPath); err != nil { t.Error(err) } @@ -102,7 +102,7 @@ func testSes3ItResetStorDb(t *testing.T) { } func testSes3ItStartEngine(t *testing.T) { - if _, err := engine.StopStartEngine(ses3CfgPath, *waitRater); err != nil { + if _, err := engine.StopStartEngine(ses3CfgPath, *utils.WaitRater); err != nil { t.Fatal(err) } } @@ -117,7 +117,7 @@ func testSes3ItRPCConn(t *testing.T) { func testSes3ItLoadFromFolder(t *testing.T) { var reply string - attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*dataDir, "tariffplans", "testit")} + attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*utils.DataDir, "tariffplans", "testit")} if err := ses3RPC.Call(context.Background(), utils.APIerSv1LoadTariffPlanFromFolder, attrs, &reply); err != nil { t.Error(err) } @@ -195,7 +195,7 @@ func testSes3ItProcessEvent(t *testing.T) { }, }, } - if *encoding == utils.MetaGOB { + if *utils.Encoding == utils.MetaGOB { eAttrs.CGREvent.Event[utils.Usage] = 5 * time.Minute eAttrs.CGREvent.Event[utils.SetupTime], _ = utils.IfaceAsTime("2018-01-07T17:00:00Z", "") eAttrs.CGREvent.Event[utils.AnswerTime], _ = utils.IfaceAsTime("2018-01-07T17:00:10Z", "") diff --git a/general_tests/session4_it_test.go b/general_tests/session4_it_test.go index f66e3dfde..1796ffd22 100644 --- a/general_tests/session4_it_test.go +++ b/general_tests/session4_it_test.go @@ -55,7 +55,7 @@ var ( ) func TestSes4ItSessions(t *testing.T) { - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: ses4CfgDir = "sessions_internal" case utils.MetaMySQL: @@ -73,7 +73,7 @@ func TestSes4ItSessions(t *testing.T) { } func testSes4ItLoadConfig(t *testing.T) { - ses4CfgPath = path.Join(*dataDir, "conf", "samples", ses4CfgDir) + ses4CfgPath = path.Join(*utils.DataDir, "conf", "samples", ses4CfgDir) if ses4Cfg, err = config.NewCGRConfigFromPath(ses4CfgPath); err != nil { t.Error(err) } @@ -92,7 +92,7 @@ func testSes4ItResetStorDb(t *testing.T) { } func testSes4ItStartEngine(t *testing.T) { - if _, err := engine.StopStartEngine(ses4CfgPath, *waitRater); err != nil { + if _, err := engine.StopStartEngine(ses4CfgPath, *utils.WaitRater); err != nil { t.Fatal(err) } } @@ -107,7 +107,7 @@ func testSes4ItRPCConn(t *testing.T) { func testSes4ItLoadFromFolder(t *testing.T) { var reply string - attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*dataDir, "tariffplans", "testit")} + attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*utils.DataDir, "tariffplans", "testit")} if err := ses4RPC.Call(context.Background(), utils.APIerSv1LoadTariffPlanFromFolder, attrs, &reply); err != nil { t.Error(err) } diff --git a/general_tests/session_graceful_shutdown_it_test.go b/general_tests/session_graceful_shutdown_it_test.go index b9d3af41d..394bf2aff 100644 --- a/general_tests/session_graceful_shutdown_it_test.go +++ b/general_tests/session_graceful_shutdown_it_test.go @@ -63,7 +63,7 @@ var ( ) func TestSessionSRplcGracefulShutdown(t *testing.T) { - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: smgRplcCfgDIR1 = "rplcTestGracefulShutdown1_internal" smgRplcCfgDIR2 = "rplcTestGracefulShutdown2_internal" @@ -80,17 +80,17 @@ func TestSessionSRplcGracefulShutdown(t *testing.T) { } for _, stest1 := range sTestsSession1 { - t.Run(*dbType, stest1) + t.Run(*utils.DBType, stest1) } } // Init Config func testSessionSRplcInitCfg(t *testing.T) { - smgRplcCfgPath1 = path.Join(*dataDir, "conf", "samples", "sessions_replication", smgRplcCfgDIR1) + smgRplcCfgPath1 = path.Join(*utils.DataDir, "conf", "samples", "sessions_replication", smgRplcCfgDIR1) if smgRplCfg1, err = config.NewCGRConfigFromPath(smgRplcCfgPath1); err != nil { t.Fatal(err) } - smgRplcCfgPath2 = path.Join(*dataDir, "conf", "samples", "sessions_replication", smgRplcCfgDIR2) + smgRplcCfgPath2 = path.Join(*utils.DataDir, "conf", "samples", "sessions_replication", smgRplcCfgDIR2) if smgRplCfg2, err = config.NewCGRConfigFromPath(smgRplcCfgPath2); err != nil { t.Fatal(err) } @@ -108,10 +108,10 @@ func testSessionSRplcResetDB(t *testing.T) { // Start CGR Engine func testSessionSRplcStartEngine(t *testing.T) { - if _, err = engine.StopStartEngine(smgRplcCfgPath1, *waitRater); err != nil { + if _, err = engine.StopStartEngine(smgRplcCfgPath1, *utils.WaitRater); err != nil { t.Fatal(err) } - if testEngine1, err = engine.StartEngine(smgRplcCfgPath2, *waitRater); err != nil { + if testEngine1, err = engine.StartEngine(smgRplcCfgPath2, *utils.WaitRater); err != nil { t.Fatal(err) } diff --git a/general_tests/session_it_test.go b/general_tests/session_it_test.go index 936e486a2..c674b6d4f 100644 --- a/general_tests/session_it_test.go +++ b/general_tests/session_it_test.go @@ -56,7 +56,7 @@ var ( ) func TestSesIt(t *testing.T) { - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: sesCfgDIR = "tutinternal" case utils.MetaMySQL: @@ -75,7 +75,7 @@ func TestSesIt(t *testing.T) { // test for 0 balance with session terminate with 1s usage func testSesItLoadConfig(t *testing.T) { - sesCfgPath = path.Join(*dataDir, "conf", "samples", sesCfgDIR) + sesCfgPath = path.Join(*utils.DataDir, "conf", "samples", sesCfgDIR) if sesCfg, err = config.NewCGRConfigFromPath(sesCfgPath); err != nil { t.Error(err) } @@ -94,7 +94,7 @@ func testSesItResetStorDb(t *testing.T) { } func testSesItStartEngine(t *testing.T) { - if _, err := engine.StopStartEngine(sesCfgPath, *waitRater); err != nil { + if _, err := engine.StopStartEngine(sesCfgPath, *utils.WaitRater); err != nil { t.Fatal(err) } } @@ -109,7 +109,7 @@ func testSesItRPCConn(t *testing.T) { func testSesItLoadFromFolder(t *testing.T) { var reply string - attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*dataDir, "tariffplans", "testit")} + attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*utils.DataDir, "tariffplans", "testit")} if err := sesRPC.Call(context.Background(), utils.APIerSv1LoadTariffPlanFromFolder, attrs, &reply); err != nil { t.Error(err) } diff --git a/general_tests/session_money_rating_subject_it_test.go b/general_tests/session_money_rating_subject_it_test.go index 79195a8d1..ef1c3af64 100644 --- a/general_tests/session_money_rating_subject_it_test.go +++ b/general_tests/session_money_rating_subject_it_test.go @@ -75,7 +75,7 @@ var ( ) func TestSesMRSItMoney(t *testing.T) { - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: sesMRSCfgDIR = "sessions_internal" case utils.MetaMySQL: @@ -94,7 +94,7 @@ func TestSesMRSItMoney(t *testing.T) { // test for 0 balance with sesMRSsion terminate with 1s usage func testSesMRSItLoadConfig(t *testing.T) { - sesMRSCfgPath = path.Join(*dataDir, "conf", "samples", sesMRSCfgDIR) + sesMRSCfgPath = path.Join(*utils.DataDir, "conf", "samples", sesMRSCfgDIR) if sesMRSCfg, err = config.NewCGRConfigFromPath(sesMRSCfgPath); err != nil { t.Error(err) } @@ -113,7 +113,7 @@ func testSesMRSItResetStorDb(t *testing.T) { } func testSesMRSItStartEngine(t *testing.T) { - if _, err := engine.StopStartEngine(sesMRSCfgPath, *waitRater); err != nil { + if _, err := engine.StopStartEngine(sesMRSCfgPath, *utils.WaitRater); err != nil { t.Fatal(err) } } diff --git a/general_tests/session_nonereq_it_test.go b/general_tests/session_nonereq_it_test.go index 8be52e971..7b69951de 100644 --- a/general_tests/session_nonereq_it_test.go +++ b/general_tests/session_nonereq_it_test.go @@ -56,7 +56,7 @@ var ( ) func TestSesNoneReqTypeItSessions(t *testing.T) { - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: sesNoneReqTypeCfgDir = "tutinternal" case utils.MetaMySQL: @@ -74,7 +74,7 @@ func TestSesNoneReqTypeItSessions(t *testing.T) { } func testSesNoneReqTypeItLoadConfig(t *testing.T) { - sesNoneReqTypeCfgPath = path.Join(*dataDir, "conf", "samples", sesNoneReqTypeCfgDir) + sesNoneReqTypeCfgPath = path.Join(*utils.DataDir, "conf", "samples", sesNoneReqTypeCfgDir) if sesNoneReqTypeCfg, err = config.NewCGRConfigFromPath(sesNoneReqTypeCfgPath); err != nil { t.Error(err) } @@ -93,7 +93,7 @@ func testSesNoneReqTypeItResetStorDb(t *testing.T) { } func testSesNoneReqTypeItStartEngine(t *testing.T) { - if _, err := engine.StopStartEngine(sesNoneReqTypeCfgPath, *waitRater); err != nil { + if _, err := engine.StopStartEngine(sesNoneReqTypeCfgPath, *utils.WaitRater); err != nil { t.Fatal(err) } } diff --git a/general_tests/session_refund_expired_it_test.go b/general_tests/session_refund_expired_it_test.go index 2adfb7417..4f595824f 100644 --- a/general_tests/session_refund_expired_it_test.go +++ b/general_tests/session_refund_expired_it_test.go @@ -78,7 +78,7 @@ var ( ) func TestSesExpIt(t *testing.T) { - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: sesExpCfgDIR = "sessions_internal" case utils.MetaMySQL: @@ -97,7 +97,7 @@ func TestSesExpIt(t *testing.T) { // test for 0 balance with sesExpsion terminate with 1s usage func testSesExpItLoadConfig(t *testing.T) { - sesExpCfgPath = path.Join(*dataDir, "conf", "samples", sesExpCfgDIR) + sesExpCfgPath = path.Join(*utils.DataDir, "conf", "samples", sesExpCfgDIR) if sesExpCfg, err = config.NewCGRConfigFromPath(sesExpCfgPath); err != nil { t.Error(err) } @@ -116,7 +116,7 @@ func testSesExpItResetStorDb(t *testing.T) { } func testSesExpItStartEngine(t *testing.T) { - if _, err := engine.StopStartEngine(sesExpCfgPath, *waitRater); err != nil { + if _, err := engine.StopStartEngine(sesExpCfgPath, *utils.WaitRater); err != nil { t.Fatal(err) } } diff --git a/general_tests/session_replications_automaticdebit_it_test.go b/general_tests/session_replications_automaticdebit_it_test.go index 70bb83d5d..841995f84 100644 --- a/general_tests/session_replications_automaticdebit_it_test.go +++ b/general_tests/session_replications_automaticdebit_it_test.go @@ -57,7 +57,7 @@ var ( ) func TestSessionSRpl(t *testing.T) { - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: t.SkipNow() case utils.MetaMySQL: @@ -73,7 +73,7 @@ func TestSessionSRpl(t *testing.T) { } for _, stest := range sTestsSession { - t.Run(*dbType, stest) + t.Run(*utils.DBType, stest) } } @@ -111,11 +111,11 @@ func testSessionSRplAddVoiceBalance(t *testing.T) { // Init Config func testSessionSRplInitCfg(t *testing.T) { - smgRplcMasterCfgPath = path.Join(*dataDir, "conf", "samples", "sessions_replication", smgRplcMasterCfgDIR) + smgRplcMasterCfgPath = path.Join(*utils.DataDir, "conf", "samples", "sessions_replication", smgRplcMasterCfgDIR) if smgRplcMasterCfg, err = config.NewCGRConfigFromPath(smgRplcMasterCfgPath); err != nil { t.Fatal(err) } - smgRplcSlaveCfgPath = path.Join(*dataDir, "conf", "samples", "sessions_replication", smgRplcSlaveCfgDIR) + smgRplcSlaveCfgPath = path.Join(*utils.DataDir, "conf", "samples", "sessions_replication", smgRplcSlaveCfgDIR) if smgRplcSlaveCfg, err = config.NewCGRConfigFromPath(smgRplcSlaveCfgPath); err != nil { t.Fatal(err) } @@ -133,10 +133,10 @@ func testSessionSRplResetDB(t *testing.T) { // Start CGR Engine func testSessionSRplStartEngine(t *testing.T) { - if _, err = engine.StopStartEngine(smgRplcSlaveCfgPath, *waitRater); err != nil { + if _, err = engine.StopStartEngine(smgRplcSlaveCfgPath, *utils.WaitRater); err != nil { t.Fatal(err) } - if masterEngine, err = engine.StartEngine(smgRplcMasterCfgPath, *waitRater); err != nil { + if masterEngine, err = engine.StartEngine(smgRplcMasterCfgPath, *utils.WaitRater); err != nil { t.Fatal(err) } @@ -154,12 +154,12 @@ func testSessionSRplApierRpcConn(t *testing.T) { // Load the tariff plan, creating accounts and their balances func testSessionSRplTPFromFolder(t *testing.T) { - attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*dataDir, "tariffplans", "oldtutorial")} + attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*utils.DataDir, "tariffplans", "oldtutorial")} var loadInst utils.LoadInstance if err := smgRplcMstrRPC.Call(context.Background(), utils.APIerSv2LoadTariffPlanFromFolder, attrs, &loadInst); err != nil { t.Error(err) } - time.Sleep(time.Duration(*waitRater) * time.Millisecond) // Give time for scheduler to execute topups + time.Sleep(time.Duration(*utils.WaitRater) * time.Millisecond) // Give time for scheduler to execute topups } func testSessionSRplInitiate(t *testing.T) { @@ -378,7 +378,7 @@ func testSessionSRplTerminate(t *testing.T) { if err := smgRplcSlvRPC.Call(context.Background(), utils.SessionSv1TerminateSession, args, &reply); err != nil { t.Error(err) } - time.Sleep(time.Duration(*waitRater) * time.Millisecond) // Wait for the sessions to be populated + time.Sleep(time.Duration(*utils.WaitRater) * time.Millisecond) // Wait for the sessions to be populated var aSessions []*sessions.ExternalSession //check if the session was terminated on slave diff --git a/general_tests/session_rounding_it_test.go b/general_tests/session_rounding_it_test.go index f52c353db..136166380 100644 --- a/general_tests/session_rounding_it_test.go +++ b/general_tests/session_rounding_it_test.go @@ -98,7 +98,7 @@ var ( ) func TestSesRndIt(t *testing.T) { - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: sesRndCfgDIR = "sessions_internal" case utils.MetaMySQL: @@ -153,7 +153,7 @@ func testSesRndItPreparePrepaidDOWN(t *testing.T) { // test for 0 balance with sesRndsion terminate with 1s usage func testSesRndItLoadConfig(t *testing.T) { - sesRndCfgPath = path.Join(*dataDir, "conf", "samples", sesRndCfgDIR) + sesRndCfgPath = path.Join(*utils.DataDir, "conf", "samples", sesRndCfgDIR) if sesRndCfg, err = config.NewCGRConfigFromPath(sesRndCfgPath); err != nil { t.Error(err) } @@ -172,7 +172,7 @@ func testSesRndItResetStorDb(t *testing.T) { } func testSesRndItStartEngine(t *testing.T) { - if _, err := engine.StopStartEngine(sesRndCfgPath, *waitRater); err != nil { + if _, err := engine.StopStartEngine(sesRndCfgPath, *utils.WaitRater); err != nil { t.Fatal(err) } } diff --git a/general_tests/session_rpl_prepaid_it_test.go b/general_tests/session_rpl_prepaid_it_test.go index 016097809..1839e15fe 100644 --- a/general_tests/session_rpl_prepaid_it_test.go +++ b/general_tests/session_rpl_prepaid_it_test.go @@ -51,7 +51,7 @@ var ( ) func TestSeSRplPrepaid(t *testing.T) { - switch *dbType { + switch *utils.DBType { case utils.MetaMySQL: sesRplPrePaidCfgDIR = "tutmysql" case utils.MetaMongo: @@ -62,12 +62,12 @@ func TestSeSRplPrepaid(t *testing.T) { t.Fatal("Unknown Database type") } for _, stest := range sesRplPrePaidTests { - t.Run(*dbType, stest) + t.Run(*utils.DBType, stest) } } func testSeSRplPrepaidInitCfg(t *testing.T) { - sesRplPrePaidCfgPath = path.Join(*dataDir, "conf", "samples", sesRplPrePaidCfgDIR) + sesRplPrePaidCfgPath = path.Join(*utils.DataDir, "conf", "samples", sesRplPrePaidCfgDIR) if sesRplPrePaidCfg, err = config.NewCGRConfigFromPath(sesRplPrePaidCfgPath); err != nil { t.Fatal(err) } @@ -85,7 +85,7 @@ func testSeSRplPrepaidResetDB(t *testing.T) { // Start CGR Engine func testSeSRplPrepaidStartEngine(t *testing.T) { - if _, err := engine.StopStartEngine(sesRplPrePaidCfgPath, *waitRater); err != nil { + if _, err := engine.StopStartEngine(sesRplPrePaidCfgPath, *utils.WaitRater); err != nil { t.Fatal(err) } } diff --git a/general_tests/sessionpause_it_test.go b/general_tests/sessionpause_it_test.go index 40ebb0996..558a8e0d3 100644 --- a/general_tests/sessionpause_it_test.go +++ b/general_tests/sessionpause_it_test.go @@ -60,7 +60,7 @@ var ( ) func TestSesPauseItSessions(t *testing.T) { - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: sesPauseCfgDir = "tutinternal" case utils.MetaMySQL: @@ -78,7 +78,7 @@ func TestSesPauseItSessions(t *testing.T) { } func testSesPauseItLoadConfig(t *testing.T) { - sesPauseCfgPath = path.Join(*dataDir, "conf", "samples", sesPauseCfgDir) + sesPauseCfgPath = path.Join(*utils.DataDir, "conf", "samples", sesPauseCfgDir) if sesPauseCfg, err = config.NewCGRConfigFromPath(sesPauseCfgPath); err != nil { t.Error(err) } @@ -97,7 +97,7 @@ func testSesPauseItResetStorDb(t *testing.T) { } func testSesPauseItStartEngine(t *testing.T) { - if _, err := engine.StopStartEngine(sesPauseCfgPath, *waitRater); err != nil { + if _, err := engine.StopStartEngine(sesPauseCfgPath, *utils.WaitRater); err != nil { t.Fatal(err) } } @@ -112,7 +112,7 @@ func testSesPauseItRPCConn(t *testing.T) { func testSesPauseItLoadFromFolder(t *testing.T) { var reply string - attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*dataDir, "tariffplans", "tutorial")} + attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*utils.DataDir, "tariffplans", "tutorial")} if err := sesPauseRPC.Call(context.Background(), utils.APIerSv1LoadTariffPlanFromFolder, attrs, &reply); err != nil { t.Error(err) } diff --git a/general_tests/sessionrefund_it_test.go b/general_tests/sessionrefund_it_test.go index ac6484dc7..bf88013ed 100644 --- a/general_tests/sessionrefund_it_test.go +++ b/general_tests/sessionrefund_it_test.go @@ -59,7 +59,7 @@ var ( ) func TestSrIt(t *testing.T) { - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: srCfgDIR = "tutinternal" case utils.MetaMySQL: @@ -77,7 +77,7 @@ func TestSrIt(t *testing.T) { } func testSrItLoadConfig(t *testing.T) { - srCfgPath = path.Join(*dataDir, "conf", "samples", srCfgDIR) + srCfgPath = path.Join(*utils.DataDir, "conf", "samples", srCfgDIR) if srCfg, err = config.NewCGRConfigFromPath(srCfgPath); err != nil { t.Error(err) } @@ -96,7 +96,7 @@ func testSrItResetStorDb(t *testing.T) { } func testSrItStartEngine(t *testing.T) { - if _, err := engine.StopStartEngine(srCfgPath, *waitRater); err != nil { + if _, err := engine.StopStartEngine(srCfgPath, *utils.WaitRater); err != nil { t.Fatal(err) } } @@ -111,7 +111,7 @@ func testSrItRPCConn(t *testing.T) { func testSrItLoadFromFolder(t *testing.T) { var reply string - attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*dataDir, "tariffplans", "oldtutorial")} + attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*utils.DataDir, "tariffplans", "oldtutorial")} if err := srrpc.Call(context.Background(), utils.APIerSv1LoadTariffPlanFromFolder, attrs, &reply); err != nil { t.Error(err) } diff --git a/general_tests/sessionroutes_it_test.go b/general_tests/sessionroutes_it_test.go index 518f19403..2a92c140b 100644 --- a/general_tests/sessionroutes_it_test.go +++ b/general_tests/sessionroutes_it_test.go @@ -58,7 +58,7 @@ var ( ) func TestSesRoutesItSessions(t *testing.T) { - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: sesRoutesCfgDir = "tutinternal" case utils.MetaMySQL: @@ -76,7 +76,7 @@ func TestSesRoutesItSessions(t *testing.T) { } func testSesRoutesItLoadConfig(t *testing.T) { - sesRoutesCfgPath = path.Join(*dataDir, "conf", "samples", sesRoutesCfgDir) + sesRoutesCfgPath = path.Join(*utils.DataDir, "conf", "samples", sesRoutesCfgDir) if sesRoutesCfg, err = config.NewCGRConfigFromPath(sesRoutesCfgPath); err != nil { t.Error(err) } @@ -95,7 +95,7 @@ func testSesRoutesItResetStorDb(t *testing.T) { } func testSesRoutesItStartEngine(t *testing.T) { - if _, err := engine.StopStartEngine(sesRoutesCfgPath, *waitRater); err != nil { + if _, err := engine.StopStartEngine(sesRoutesCfgPath, *utils.WaitRater); err != nil { t.Fatal(err) } } @@ -110,7 +110,7 @@ func testSesRoutesItRPCConn(t *testing.T) { func testSesRoutesItLoadFromFolder(t *testing.T) { var reply string - attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*dataDir, "tariffplans", "testit")} + attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*utils.DataDir, "tariffplans", "testit")} if err := sesRoutesRPC.Call(context.Background(), utils.APIerSv1LoadTariffPlanFromFolder, attrs, &reply); err != nil { t.Error(err) } diff --git a/general_tests/sessions_benchmark_it_test.go b/general_tests/sessions_benchmark_it_test.go index ce7b41df0..a7e4e328d 100644 --- a/general_tests/sessions_benchmark_it_test.go +++ b/general_tests/sessions_benchmark_it_test.go @@ -57,7 +57,7 @@ var ( ) func TestSesPIt(t *testing.T) { - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: sesPCfgDir = "tutinternal" case utils.MetaMySQL: @@ -75,7 +75,7 @@ func TestSesPIt(t *testing.T) { } func testSesPItLoadConfig(t *testing.T) { - sesPCfgPath = path.Join(*dataDir, "conf", "samples", sesPCfgDir) + sesPCfgPath = path.Join(*utils.DataDir, "conf", "samples", sesPCfgDir) if sesPCfg, err = config.NewCGRConfigFromPath(sesPCfgPath); err != nil { t.Error(err) } @@ -94,7 +94,7 @@ func testSesPItResetStorDB(t *testing.T) { } func testSesPItStartEngine(t *testing.T) { - if _, err := engine.StopStartEngine(sesPCfgPath, *waitRater); err != nil { + if _, err := engine.StopStartEngine(sesPCfgPath, *utils.WaitRater); err != nil { t.Fatal(err) } } diff --git a/general_tests/sessions_concur_test.go b/general_tests/sessions_concur_test.go index e9283d17a..5abe6230b 100644 --- a/general_tests/sessions_concur_test.go +++ b/general_tests/sessions_concur_test.go @@ -80,7 +80,7 @@ package general_tests // } // func testSCncrInitConfig(t *testing.T) { -// sCncrCfgPath = path.Join(*dataDir, "conf", "samples", sCncrCfgDIR) +// sCncrCfgPath = path.Join(*utils.DataDir, "conf", "samples", sCncrCfgDIR) // if sCncrCfg, err = config.NewCGRConfigFromPath(sCncrCfgPath); err != nil { // t.Fatal(err) // } @@ -100,7 +100,7 @@ package general_tests // } // func testSCncrStartEngine(t *testing.T) { -// if _, err := engine.StopStartEngine(sCncrCfgPath, *waitRater); err != nil { +// if _, err := engine.StopStartEngine(sCncrCfgPath, *utils.WaitRater); err != nil { // t.Fatal(err) // } // } @@ -115,7 +115,7 @@ package general_tests // } // func testSCncrKillEngine(t *testing.T) { -// if err := engine.KillEngine(*waitRater); err != nil { +// if err := engine.KillEngine(*utils.WaitRater); err != nil { // t.Error(err) // } // } @@ -124,7 +124,7 @@ package general_tests // var loadInst string // if err := sCncrRPC.Call(context.Background(), utils.APIerSv1LoadTariffPlanFromFolder, // &utils.AttrLoadTpFromFolder{FolderPath: path.Join( -// *dataDir, "tariffplans", "tp1cnt")}, &loadInst); err != nil { +// *utils.DataDir, "tariffplans", "tp1cnt")}, &loadInst); err != nil { // t.Error(err) // } // attrPrfl := &v2.AttributeWithAPIOpts{ diff --git a/general_tests/sessions_message_it_test.go b/general_tests/sessions_message_it_test.go index e7eaaf815..48b54b3c2 100644 --- a/general_tests/sessions_message_it_test.go +++ b/general_tests/sessions_message_it_test.go @@ -55,7 +55,7 @@ var ( ) func TestSesMFDIt(t *testing.T) { - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: sesMFDCfgDir = "sessions_internal" case utils.MetaMySQL: @@ -73,7 +73,7 @@ func TestSesMFDIt(t *testing.T) { } func testSesMFDItLoadConfig(t *testing.T) { - sesMFDCfgPath = path.Join(*dataDir, "conf", "samples", sesMFDCfgDir) + sesMFDCfgPath = path.Join(*utils.DataDir, "conf", "samples", sesMFDCfgDir) if sesMFDCfg, err = config.NewCGRConfigFromPath(sesMFDCfgPath); err != nil { t.Error(err) } @@ -92,7 +92,7 @@ func testSesMFDItResetStorDb(t *testing.T) { } func testSesMFDItStartEngine(t *testing.T) { - if _, err := engine.StopStartEngine(sesMFDCfgPath, *waitRater); err != nil { + if _, err := engine.StopStartEngine(sesMFDCfgPath, *utils.WaitRater); err != nil { t.Fatal(err) } } diff --git a/general_tests/sessions_tnt_change_cdr_it_test.go b/general_tests/sessions_tnt_change_cdr_it_test.go index 50c810cf5..9a72be41e 100644 --- a/general_tests/sessions_tnt_change_cdr_it_test.go +++ b/general_tests/sessions_tnt_change_cdr_it_test.go @@ -56,7 +56,7 @@ var ( ) func TestSesCdrsTntChange(t *testing.T) { - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: sesTntChngCfgDir = "tutinternal" case utils.MetaMySQL: @@ -74,7 +74,7 @@ func TestSesCdrsTntChange(t *testing.T) { } func testSesTntChngCdrsLoadConfig(t *testing.T) { - sesTntChngCfgPath = path.Join(*dataDir, "conf", "samples", sesTntChngCfgDir) + sesTntChngCfgPath = path.Join(*utils.DataDir, "conf", "samples", sesTntChngCfgDir) if sesTntChngCfg, err = config.NewCGRConfigFromPath(sesTntChngCfgPath); err != nil { t.Error(err) } @@ -93,7 +93,7 @@ func testSesTntChngCdrsResetStorDb(t *testing.T) { } func testSesTntChngCdrsStartEngine(t *testing.T) { - if _, err := engine.StopStartEngine(sesTntChngCfgPath, *waitRater); err != nil { + if _, err := engine.StopStartEngine(sesTntChngCfgPath, *utils.WaitRater); err != nil { t.Fatal(err) } } diff --git a/general_tests/sessions_tnt_change_it_test.go b/general_tests/sessions_tnt_change_it_test.go index 34a81c909..aae8a26f2 100644 --- a/general_tests/sessions_tnt_change_it_test.go +++ b/general_tests/sessions_tnt_change_it_test.go @@ -56,7 +56,7 @@ var ( ) func TestSesTntChange(t *testing.T) { - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: sesTntChngCfgDir = "tutinternal" case utils.MetaMySQL: @@ -74,7 +74,7 @@ func TestSesTntChange(t *testing.T) { } func testSesTntChngLoadConfig(t *testing.T) { - sesTntChngCfgPath = path.Join(*dataDir, "conf", "samples", sesTntChngCfgDir) + sesTntChngCfgPath = path.Join(*utils.DataDir, "conf", "samples", sesTntChngCfgDir) if sesTntChngCfg, err = config.NewCGRConfigFromPath(sesTntChngCfgPath); err != nil { t.Error(err) } @@ -93,7 +93,7 @@ func testSesTntChngResetStorDb(t *testing.T) { } func testSesTntChngStartEngine(t *testing.T) { - if _, err := engine.StopStartEngine(sesTntChngCfgPath, *waitRater); err != nil { + if _, err := engine.StopStartEngine(sesTntChngCfgPath, *utils.WaitRater); err != nil { t.Fatal(err) } } diff --git a/general_tests/set_rmv_prfl_dlay_it_test.go b/general_tests/set_rmv_prfl_dlay_it_test.go index e9761e613..59126cef0 100644 --- a/general_tests/set_rmv_prfl_dlay_it_test.go +++ b/general_tests/set_rmv_prfl_dlay_it_test.go @@ -35,7 +35,7 @@ import ( func TestSetRemoveProfilesWithCachingDelay(t *testing.T) { var cfgDir string - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: t.SkipNow() case utils.MetaMySQL: @@ -50,10 +50,10 @@ func TestSetRemoveProfilesWithCachingDelay(t *testing.T) { testEnv := TestEnvironment{ Name: "TestSetRemoveProfilesWithCachingDelay", // Encoding: *encoding, - ConfigPath: path.Join(*dataDir, "conf", "samples", cfgDir), - TpPath: path.Join(*dataDir, "tariffplans", "tutorial"), + ConfigPath: path.Join(*utils.DataDir, "conf", "samples", cfgDir), + TpPath: path.Join(*utils.DataDir, "tariffplans", "tutorial"), } - client, _, shutdown, err := testEnv.Setup(t, *waitRater) + client, _, shutdown, err := testEnv.Setup(t, *utils.WaitRater) if err != nil { t.Fatal(err) } @@ -61,7 +61,7 @@ func TestSetRemoveProfilesWithCachingDelay(t *testing.T) { t.Run("RemoveTPFromFolder", func(t *testing.T) { var reply string - attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*dataDir, "tariffplans", "tutorial")} + attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*utils.DataDir, "tariffplans", "tutorial")} startTime := time.Now() if err := client.Call(context.Background(), utils.APIerSv1RemoveTPFromFolder, attrs, &reply); err != nil { t.Error(err) @@ -410,7 +410,7 @@ func TestSetRemoveProfilesWithCachingDelay(t *testing.T) { t.Run("V2LoadTariffPlanFromFolder", func(t *testing.T) { attrs := &utils.AttrLoadTpFromFolder{ - FolderPath: path.Join(*dataDir, "tariffplans", "tutorial"), + FolderPath: path.Join(*utils.DataDir, "tariffplans", "tutorial"), } exp := utils.LoadInstance{} diff --git a/general_tests/shared_subject_it_test.go b/general_tests/shared_subject_it_test.go index 5f0379129..84b481cf5 100644 --- a/general_tests/shared_subject_it_test.go +++ b/general_tests/shared_subject_it_test.go @@ -47,7 +47,7 @@ import ( // - attaches the rating profile via changing the event subject using an attribute profile // - sets up needed filters in order to select the correct pricing for the situation. func TestSharedSubject(t *testing.T) { - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: case utils.MetaMySQL, utils.MetaMongo, utils.MetaPostgres: t.SkipNow() @@ -127,7 +127,7 @@ cgrates.org,call,Subject2,2014-01-14T00:00:00Z,RP_Subject2,`, ConfigJSON: content, TpFiles: tpFiles, } - client, _, shutdown, err := testEnv.Setup(t, *waitRater) + client, _, shutdown, err := testEnv.Setup(t, *utils.WaitRater) if err != nil { t.Fatal(err) } diff --git a/general_tests/suretax_it_test.go b/general_tests/suretax_it_test.go index b810e0632..a652ef2d7 100644 --- a/general_tests/suretax_it_test.go +++ b/general_tests/suretax_it_test.go @@ -92,7 +92,7 @@ func testSTIResetStorDb(t *testing.T) { // Start CGR Engine func testSTIStartEngine(t *testing.T) { - if _, err := engine.StopStartEngine(*configDir, *waitRater); err != nil { + if _, err := engine.StopStartEngine(*configDir, *utils.WaitRater); err != nil { t.Fatal(err) } } @@ -114,7 +114,7 @@ func testSTILoadTariffPlanFromFolder(t *testing.T) { } else if stiLoadInst.RatingLoadID == "" || stiLoadInst.AccountingLoadID == "" { t.Error("Empty loadId received, loadInstance: ", stiLoadInst) } - time.Sleep(time.Duration(*waitRater) * time.Millisecond) // Give time for scheduler to execute topups + time.Sleep(time.Duration(*utils.WaitRater) * time.Millisecond) // Give time for scheduler to execute topups } // Check loaded stats diff --git a/general_tests/tls_it_test.go b/general_tests/tls_it_test.go index 645b7c115..b1115f2cc 100644 --- a/general_tests/tls_it_test.go +++ b/general_tests/tls_it_test.go @@ -62,9 +62,9 @@ func TestTLS(t *testing.T) { func testTLSLoadConfig(t *testing.T) { var err error - tlsCfgPath = path.Join(*dataDir, "conf", "samples", tlsConfDIR) - if *encoding == utils.MetaGOB { - tlsCfgPath = path.Join(*dataDir, "conf", "samples", tlsConfDIR+"_gob") + tlsCfgPath = path.Join(*utils.DataDir, "conf", "samples", tlsConfDIR) + if *utils.Encoding == utils.MetaGOB { + tlsCfgPath = path.Join(*utils.DataDir, "conf", "samples", tlsConfDIR+"_gob") } if tlsCfg, err = config.NewCGRConfigFromPath(tlsCfgPath); err != nil { t.Error(err) diff --git a/general_tests/tp_it_test.go b/general_tests/tp_it_test.go index af9d76be3..fb84be22c 100644 --- a/general_tests/tp_it_test.go +++ b/general_tests/tp_it_test.go @@ -65,7 +65,7 @@ var ( ) func TestTp(t *testing.T) { - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: tpCfgDIR = "tutinternal" case utils.MetaMySQL: @@ -82,7 +82,7 @@ func TestTp(t *testing.T) { } } func testTpInitCfg(t *testing.T) { - tpCfgPath = path.Join(*dataDir, "conf", "samples", tpCfgDIR) + tpCfgPath = path.Join(*utils.DataDir, "conf", "samples", tpCfgDIR) // Init config first var err error tpCfg, err = config.NewCGRConfigFromPath(tpCfgPath) @@ -123,11 +123,11 @@ func testTpRpcConn(t *testing.T) { // Load the tariff plan, creating accounts and their balances func testTpLoadTariffPlanFromFolder(t *testing.T) { - attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*dataDir, "tariffplans", "testtp")} + attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*utils.DataDir, "tariffplans", "testtp")} if err := tpRPC.Call(context.Background(), utils.APIerSv2LoadTariffPlanFromFolder, attrs, &tpLoadInst); err != nil { t.Error(err) } - time.Sleep(time.Duration(*waitRater) * time.Millisecond) // Give time for scheduler to execute topups + time.Sleep(time.Duration(*utils.WaitRater) * time.Millisecond) // Give time for scheduler to execute topups } func testTpBalanceCounter(t *testing.T) { diff --git a/general_tests/transfer_balance_it_test.go b/general_tests/transfer_balance_it_test.go index f0db4e920..f3d12fbed 100644 --- a/general_tests/transfer_balance_it_test.go +++ b/general_tests/transfer_balance_it_test.go @@ -38,7 +38,7 @@ import ( // 4. Check the balances; the source balance should now have 6 units while the destination balance should have 14. func TestTransferBalance(t *testing.T) { - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: case utils.MetaMySQL, utils.MetaMongo, utils.MetaPostgres: t.SkipNow() @@ -91,7 +91,7 @@ ACT_TRANSFER,*transfer_balance,"{""DestinationAccountID"":""cgrates.org:ACC_DEST ConfigJSON: content, TpFiles: tpFiles, } - client, _, shutdown, err := testEnv.Setup(t, *waitRater) + client, _, shutdown, err := testEnv.Setup(t, *utils.WaitRater) if err != nil { t.Fatal(err) } diff --git a/general_tests/tut_smgeneric_it_test.go b/general_tests/tut_smgeneric_it_test.go index 99ccd28dd..eab1fc4e2 100644 --- a/general_tests/tut_smgeneric_it_test.go +++ b/general_tests/tut_smgeneric_it_test.go @@ -55,7 +55,7 @@ var ( ) func TestTutSMG(t *testing.T) { - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: t.SkipNow() case utils.MetaMySQL: @@ -74,7 +74,7 @@ func TestTutSMG(t *testing.T) { } func testTutSMGInitCfg(t *testing.T) { - tutSMGCfgPath = path.Join(*dataDir, "conf", "samples", tutSMGCfgDIR) + tutSMGCfgPath = path.Join(*utils.DataDir, "conf", "samples", tutSMGCfgDIR) // Init config first var err error tutSMGCfg, err = config.NewCGRConfigFromPath(tutSMGCfgPath) @@ -99,7 +99,7 @@ func testTutSMGResetStorDb(t *testing.T) { // Start CGR Engine func testTutSMGStartEngine(t *testing.T) { - if _, err := engine.StopStartEngine(tutSMGCfgPath, *waitRater); err != nil { + if _, err := engine.StopStartEngine(tutSMGCfgPath, *utils.WaitRater); err != nil { t.Fatal(err) } } @@ -115,11 +115,11 @@ func testTutSMGRpcConn(t *testing.T) { // Load the tariff plan, creating accounts and their balances func testTutSMGLoadTariffPlanFromFolder(t *testing.T) { - attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*dataDir, "tariffplans", "oldtutorial")} + attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*utils.DataDir, "tariffplans", "oldtutorial")} if err := tutSMGRpc.Call(context.Background(), utils.APIerSv2LoadTariffPlanFromFolder, attrs, &smgLoadInst); err != nil { t.Error(err) } - time.Sleep(time.Duration(*waitRater) * time.Millisecond) // Give time for scheduler to execute topups + time.Sleep(time.Duration(*utils.WaitRater) * time.Millisecond) // Give time for scheduler to execute topups } // Check loaded stats diff --git a/general_tests/tutorial2_calls_test.go b/general_tests/tutorial2_calls_test.go index 2d092c582..c9ee816b3 100644 --- a/general_tests/tutorial2_calls_test.go +++ b/general_tests/tutorial2_calls_test.go @@ -96,7 +96,7 @@ package general_tests // t.Error("Invalid option") // } -// tutorial2CallsCfg.DataFolderPath = *dataDir // Share DataFolderPath through config towards StoreDb for Flush() +// tutorial2CallsCfg.DataFolderPath = *utils.DataDir // Share DataFolderPath through config towards StoreDb for Flush() // config.SetCgrConfig(tutorial2CallsCfg) // } @@ -129,7 +129,7 @@ package general_tests // // Start CGR Engine // func testTutorial2CallStartEngine(t *testing.T) { -// engine.KillProcName("cgr-engine", *waitRater) +// engine.KillProcName("cgr-engine", *utils.WaitRater) // switch tutorial2OptConf { // case utils.Freeswitch: // if err := engine.CallScript(path.Join(*tutorial2FSConfig, "cgrates", "etc", "init.d", "cgrates"), "start", 100); err != nil { @@ -165,11 +165,11 @@ package general_tests // // Load the tariff plan, creating accounts and their balances // func testTutorial2CallLoadTariffPlanFromFolder(t *testing.T) { // var reply string -// attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*dataDir, "tariffplans", "tutorial")} +// attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*utils.DataDir, "tariffplans", "tutorial")} // if err := tutorial2CallsRpc.Call(context.Background(),utils.APIerSv1LoadTariffPlanFromFolder, attrs, &reply); err != nil { // t.Error(err) // } -// time.Sleep(time.Duration(*waitRater) * time.Millisecond) // Give time for scheduler to execute topups +// time.Sleep(time.Duration(*utils.WaitRater) * time.Millisecond) // Give time for scheduler to execute topups // } // // Make sure account was debited properly @@ -269,7 +269,7 @@ package general_tests // Username: "1002", Password: "CGRateS.org", Realm: "*", Registrar: "sip:127.0.0.1:5080"}, // } // if tutorial2CallsPjSuaListener, err = engine.StartPjsuaListener( -// acnts, 5070, time.Duration(*waitRater)*time.Millisecond); err != nil { +// acnts, 5070, time.Duration(*utils.WaitRater)*time.Millisecond); err != nil { // t.Fatal(err) // } // time.Sleep(3 * time.Second) diff --git a/general_tests/tutorial2_it_test.go b/general_tests/tutorial2_it_test.go index 48959c9b6..d7b99823b 100644 --- a/general_tests/tutorial2_it_test.go +++ b/general_tests/tutorial2_it_test.go @@ -56,7 +56,7 @@ var sTutTests = []func(t *testing.T){ // Test start here func TestTutorial2(t *testing.T) { - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: tutCfgDir = "tutinternal" case utils.MetaMySQL: @@ -68,7 +68,7 @@ func TestTutorial2(t *testing.T) { default: t.Fatal("Unknown Database type") } - if *encoding == utils.MetaGOB { + if *utils.Encoding == utils.MetaGOB { tutCfgDir += "_gob" } @@ -79,7 +79,7 @@ func TestTutorial2(t *testing.T) { func testTutLoadConfig(t *testing.T) { var err error - tutCfgPath = path.Join(*dataDir, "conf", "samples", tutCfgDir) + tutCfgPath = path.Join(*utils.DataDir, "conf", "samples", tutCfgDir) if tutCfg, err = config.NewCGRConfigFromPath(tutCfgPath); err != nil { t.Error(err) } @@ -117,7 +117,7 @@ func testTutRpcConn(t *testing.T) { func testTutFromFolder(t *testing.T) { var reply string attrs := &utils.AttrLoadTpFromFolder{ - FolderPath: path.Join(*dataDir, "tariffplans", "tutorial2")} + FolderPath: path.Join(*utils.DataDir, "tariffplans", "tutorial2")} if err := tutRpc.Call(context.Background(), utils.APIerSv1LoadTariffPlanFromFolder, attrs, &reply); err != nil { t.Error(err) diff --git a/general_tests/tutorial_calls_test.go b/general_tests/tutorial_calls_test.go index 4297440e0..5df0c6faf 100644 --- a/general_tests/tutorial_calls_test.go +++ b/general_tests/tutorial_calls_test.go @@ -142,7 +142,7 @@ func testCallInitCfg(t *testing.T) { t.Error("Invalid option") } - tutorialCallsCfg.DataFolderPath = *dataDir // Share DataFolderPath through config towards StoreDb for Flush() + tutorialCallsCfg.DataFolderPath = *utils.DataDir // Share DataFolderPath through config towards StoreDb for Flush() config.SetCgrConfig(tutorialCallsCfg) } @@ -190,7 +190,7 @@ func testCallStartFS(t *testing.T) { // Start CGR Engine func testCallStartEngine(t *testing.T) { - engine.KillProcName("cgr-engine", *waitRater) + engine.KillProcName("cgr-engine", *utils.WaitRater) switch optConf { case utils.Freeswitch: if err := engine.CallScript(path.Join(*fsConfig, "cgrates", "etc", "init.d", "cgrates"), "start", 100); err != nil { @@ -253,11 +253,11 @@ func testCallRpcConn(t *testing.T) { // Load the tariff plan, creating accounts and their balances func testCallLoadTariffPlanFromFolder(t *testing.T) { var reply string - attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*dataDir, "tariffplans", "tutorial")} + attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*utils.DataDir, "tariffplans", "tutorial")} if err := tutorialCallsRpc.Call(context.Background(), utils.APIerSv1LoadTariffPlanFromFolder, attrs, &reply); err != nil { t.Error(err) } - time.Sleep(time.Duration(*waitRater) * time.Millisecond) // Give time for scheduler to execute topups + time.Sleep(time.Duration(*utils.WaitRater) * time.Millisecond) // Give time for scheduler to execute topups } // Make sure account was debited properly @@ -366,7 +366,7 @@ func testCallStartPjsuaListener(t *testing.T) { Username: "1003", Password: "CGRateS.org", Realm: "*", Registrar: "sip:127.0.0.1:5080"}, } if tutorialCallsPjSuaListener, err = engine.StartPjsuaListener( - acnts, 5070, time.Duration(*waitRater)*time.Millisecond); err != nil { + acnts, 5070, time.Duration(*utils.WaitRater)*time.Millisecond); err != nil { t.Fatal(err) } time.Sleep(3 * time.Second) diff --git a/general_tests/tutorial_it_test.go b/general_tests/tutorial_it_test.go index 55b9eb8b5..ce2c956a8 100644 --- a/general_tests/tutorial_it_test.go +++ b/general_tests/tutorial_it_test.go @@ -66,7 +66,7 @@ func TestTutorialMongoAtlas(t *testing.T) { } func TestTutorial(t *testing.T) { - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: tutorialConfDIR = "tutinternal" case utils.MetaMySQL: @@ -85,7 +85,7 @@ func TestTutorial(t *testing.T) { func testTutorialLoadConfig(t *testing.T) { var err error - tutorialCfgPath = path.Join(*dataDir, "conf", "samples", tutorialConfDIR) + tutorialCfgPath = path.Join(*utils.DataDir, "conf", "samples", tutorialConfDIR) if tutorialCfg, err = config.NewCGRConfigFromPath(tutorialCfgPath); err != nil { t.Error(err) } @@ -122,7 +122,7 @@ func testTutorialRpcConn(t *testing.T) { func testTutorialFromFolder(t *testing.T) { var reply string - attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*dataDir, "tariffplans", "tutorial")} + attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*utils.DataDir, "tariffplans", "tutorial")} if err := tutorialRpc.Call(context.Background(), utils.APIerSv1LoadTariffPlanFromFolder, attrs, &reply); err != nil { t.Error(err) } diff --git a/general_tests/twoengines_it_test.go b/general_tests/twoengines_it_test.go index 6d55fe5f7..241d30141 100644 --- a/general_tests/twoengines_it_test.go +++ b/general_tests/twoengines_it_test.go @@ -66,11 +66,11 @@ func TestTwoEngines(t *testing.T) { } func testTwoEnginesInitConfig(t *testing.T) { - engineOneCfgPath = path.Join(*dataDir, "conf", "samples", "twoengines", "engine1") + engineOneCfgPath = path.Join(*utils.DataDir, "conf", "samples", "twoengines", "engine1") if engineOneCfg, err = config.NewCGRConfigFromPath(engineOneCfgPath); err != nil { t.Fatal(err) } - engineTwoCfgPath = path.Join(*dataDir, "conf", "samples", "twoengines", "engine2") + engineTwoCfgPath = path.Join(*utils.DataDir, "conf", "samples", "twoengines", "engine2") if engineTwoCfg, err = config.NewCGRConfigFromPath(engineTwoCfgPath); err != nil { t.Fatal(err) } @@ -87,10 +87,10 @@ func testTwoEnginesInitStorDB(t *testing.T) { } } func testTwoEnginesStartEngine(t *testing.T) { - if _, err := engine.StopStartEngine(engineOneCfgPath, *waitRater); err != nil { + if _, err := engine.StopStartEngine(engineOneCfgPath, *utils.WaitRater); err != nil { t.Fatal(err) } - if _, err := engine.StartEngine(engineTwoCfgPath, *waitRater); err != nil { + if _, err := engine.StartEngine(engineTwoCfgPath, *utils.WaitRater); err != nil { t.Fatal(err) } } @@ -268,7 +268,7 @@ func testTwoEnginesUpdateThreshold(t *testing.T) { } func testTwoEnginesKillEngines(t *testing.T) { - if err := engine.KillEngine(*waitRater); err != nil { + if err := engine.KillEngine(*utils.WaitRater); err != nil { t.Error(err) } } diff --git a/loaders/lib_test.go b/loaders/lib_test.go index f8c757d81..66ebed93b 100644 --- a/loaders/lib_test.go +++ b/loaders/lib_test.go @@ -21,7 +21,6 @@ package loaders import ( "encoding/csv" "errors" - "flag" "io" "strings" "testing" @@ -36,19 +35,12 @@ import ( "github.com/cgrates/cgrates/utils" ) -var ( - waitRater = flag.Int("wait_rater", 200, "Number of miliseconds to wait for rater to start and cache") - dataDir = flag.String("data_dir", "/usr/share/cgrates", "CGR data dir path here") - encoding = flag.String("rpc", utils.MetaJSON, "what encoding whould be used for rpc comunication") - dbType = flag.String("dbtype", utils.MetaInternal, "The type of DataBase (Internal/Mongo/mySql)") -) - var loaderPaths = []string{"/tmp/In", "/tmp/Out", "/tmp/LoaderIn", "/tmp/SubpathWithoutMove", "/tmp/SubpathLoaderWithMove", "/tmp/SubpathOut", "/tmp/templateLoaderIn", "/tmp/templateLoaderOut", "/tmp/customSepLoaderIn", "/tmp/customSepLoaderOut"} func newRPCClient(cfg *config.ListenCfg) (c *birpc.Client, err error) { - switch *encoding { + switch *utils.Encoding { case utils.MetaJSON: return jsonrpc.Dial(utils.TCP, cfg.RPCJSONListen) case utils.MetaGOB: diff --git a/loaders/loader_it_test.go b/loaders/loader_it_test.go index 9f1458b3b..93a574e85 100644 --- a/loaders/loader_it_test.go +++ b/loaders/loader_it_test.go @@ -94,7 +94,7 @@ var ( // Test start here func TestLoaderIT(t *testing.T) { - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: loaderCfgDIR = "tutinternal" case utils.MetaMySQL: @@ -114,7 +114,7 @@ func TestLoaderIT(t *testing.T) { func testLoaderInitCfg(t *testing.T) { var err error - loaderCfgPath = path.Join(*dataDir, "conf", "samples", "loaders", loaderCfgDIR) + loaderCfgPath = path.Join(*utils.DataDir, "conf", "samples", "loaders", loaderCfgDIR) loaderCfg, err = config.NewCGRConfigFromPath(loaderCfgPath) if err != nil { t.Fatal(err) @@ -209,7 +209,7 @@ func testLoaderCheckAttributes(t *testing.T) { Blocker: true, Weight: 20, } - if *encoding == utils.MetaGOB { // gob threats empty slices as nil values + if *utils.Encoding == utils.MetaGOB { // gob threats empty slices as nil values eAttrPrf.Attributes[1].FilterIDs = nil } var reply *engine.AttributeProfile @@ -387,7 +387,7 @@ func testLoaderCheckForCustomSep(t *testing.T) { }, }, } - if *encoding == utils.MetaGOB { // gob threats empty slices as nil values + if *utils.Encoding == utils.MetaGOB { // gob threats empty slices as nil values eAttrPrf.Attributes[0].FilterIDs = nil } var reply *engine.AttributeProfile diff --git a/migrator/accounts2_it_test.go b/migrator/accounts2_it_test.go index 4e7ea283d..b994d5d68 100644 --- a/migrator/accounts2_it_test.go +++ b/migrator/accounts2_it_test.go @@ -49,12 +49,12 @@ var sTestsAcc2IT = []func(t *testing.T){ func TestAccMigrateWithInternal(t *testing.T) { var err error - acc2PathIn = path.Join(*dataDir, "conf", "samples", "migwithinternal") + acc2PathIn = path.Join(*utils.DataDir, "conf", "samples", "migwithinternal") acc2CfgIn, err = config.NewCGRConfigFromPath(acc2PathIn) if err != nil { t.Fatal(err) } - acc2PathOut = path.Join(*dataDir, "conf", "samples", "migwithinternal") + acc2PathOut = path.Join(*utils.DataDir, "conf", "samples", "migwithinternal") acc2CfgOut, err = config.NewCGRConfigFromPath(acc2PathOut) if err != nil { t.Fatal(err) diff --git a/migrator/accounts_it_test.go b/migrator/accounts_it_test.go index 9735fd24d..c2b3ae5e6 100644 --- a/migrator/accounts_it_test.go +++ b/migrator/accounts_it_test.go @@ -22,7 +22,6 @@ along with this program. If not, see package migrator import ( - "flag" "log" "path" "reflect" @@ -42,7 +41,6 @@ var ( accCfgOut *config.CGRConfig accMigrator *Migrator accAction string - dataDir = flag.String("data_dir", "/usr/share/cgrates", "CGR data dir path here") dbPath = func(dbType string) string { return strings.Trim(dbType, "*") } @@ -56,12 +54,12 @@ var ( func TestAccountMigrateITRedis(t *testing.T) { var err error - accPathIn = path.Join(*dataDir, "conf", "samples", "tutmysql") + accPathIn = path.Join(*utils.DataDir, "conf", "samples", "tutmysql") accCfgIn, err = config.NewCGRConfigFromPath(accPathIn) if err != nil { t.Fatal(err) } - accPathOut = path.Join(*dataDir, "conf", "samples", "tutmysql") + accPathOut = path.Join(*utils.DataDir, "conf", "samples", "tutmysql") accCfgOut, err = config.NewCGRConfigFromPath(accPathOut) if err != nil { t.Fatal(err) @@ -75,12 +73,12 @@ func TestAccountMigrateITRedis(t *testing.T) { func TestAccountMigrateITMongo(t *testing.T) { var err error - accPathIn = path.Join(*dataDir, "conf", "samples", "tutmongo") + accPathIn = path.Join(*utils.DataDir, "conf", "samples", "tutmongo") accCfgIn, err = config.NewCGRConfigFromPath(accPathIn) if err != nil { t.Fatal(err) } - accPathOut = path.Join(*dataDir, "conf", "samples", "tutmongo") + accPathOut = path.Join(*utils.DataDir, "conf", "samples", "tutmongo") accCfgOut, err = config.NewCGRConfigFromPath(accPathOut) if err != nil { t.Fatal(err) @@ -94,12 +92,12 @@ func TestAccountMigrateITMongo(t *testing.T) { func TestAccountITMove(t *testing.T) { var err error - accPathIn = path.Join(*dataDir, "conf", "samples", "tutmongo") + accPathIn = path.Join(*utils.DataDir, "conf", "samples", "tutmongo") accCfgIn, err = config.NewCGRConfigFromPath(accPathIn) if err != nil { t.Fatal(err) } - accPathOut = path.Join(*dataDir, "conf", "samples", "tutmysql") + accPathOut = path.Join(*utils.DataDir, "conf", "samples", "tutmysql") accCfgOut, err = config.NewCGRConfigFromPath(accPathOut) if err != nil { t.Fatal(err) @@ -113,12 +111,12 @@ func TestAccountITMove(t *testing.T) { func TestAccountITMigrateMongo2Redis(t *testing.T) { var err error - accPathIn = path.Join(*dataDir, "conf", "samples", "tutmongo") + accPathIn = path.Join(*utils.DataDir, "conf", "samples", "tutmongo") accCfgIn, err = config.NewCGRConfigFromPath(accPathIn) if err != nil { t.Fatal(err) } - accPathOut = path.Join(*dataDir, "conf", "samples", "tutmysql") + accPathOut = path.Join(*utils.DataDir, "conf", "samples", "tutmysql") accCfgOut, err = config.NewCGRConfigFromPath(accPathOut) if err != nil { t.Fatal(err) @@ -132,12 +130,12 @@ func TestAccountITMigrateMongo2Redis(t *testing.T) { func TestAccountITMoveEncoding(t *testing.T) { var err error - accPathIn = path.Join(*dataDir, "conf", "samples", "tutmongo") + accPathIn = path.Join(*utils.DataDir, "conf", "samples", "tutmongo") accCfgIn, err = config.NewCGRConfigFromPath(accPathIn) if err != nil { t.Fatal(err) } - accPathOut = path.Join(*dataDir, "conf", "samples", "tutmongojson") + accPathOut = path.Join(*utils.DataDir, "conf", "samples", "tutmongojson") accCfgOut, err = config.NewCGRConfigFromPath(accPathOut) if err != nil { t.Fatal(err) @@ -151,12 +149,12 @@ func TestAccountITMoveEncoding(t *testing.T) { func TestAccountITMoveEncoding2(t *testing.T) { var err error - accPathIn = path.Join(*dataDir, "conf", "samples", "tutmysql") + accPathIn = path.Join(*utils.DataDir, "conf", "samples", "tutmysql") accCfgIn, err = config.NewCGRConfigFromPath(accPathIn) if err != nil { t.Fatal(err) } - accPathOut = path.Join(*dataDir, "conf", "samples", "tutmysqljson") + accPathOut = path.Join(*utils.DataDir, "conf", "samples", "tutmysqljson") accCfgOut, err = config.NewCGRConfigFromPath(accPathOut) if err != nil { t.Fatal(err) diff --git a/migrator/action_it_test.go b/migrator/action_it_test.go index 2202f50d7..740940e04 100644 --- a/migrator/action_it_test.go +++ b/migrator/action_it_test.go @@ -49,12 +49,12 @@ var sTestsActIT = []func(t *testing.T){ func TestActionITRedis(t *testing.T) { var err error - actPathIn = path.Join(*dataDir, "conf", "samples", "tutmysql") + actPathIn = path.Join(*utils.DataDir, "conf", "samples", "tutmysql") actCfgIn, err = config.NewCGRConfigFromPath(actPathIn) if err != nil { t.Fatal(err) } - actPathOut = path.Join(*dataDir, "conf", "samples", "tutmysql") + actPathOut = path.Join(*utils.DataDir, "conf", "samples", "tutmysql") actCfgOut, err = config.NewCGRConfigFromPath(actPathOut) if err != nil { t.Fatal(err) @@ -68,12 +68,12 @@ func TestActionITRedis(t *testing.T) { func TestActionITMongo(t *testing.T) { var err error - actPathIn = path.Join(*dataDir, "conf", "samples", "tutmongo") + actPathIn = path.Join(*utils.DataDir, "conf", "samples", "tutmongo") actCfgIn, err = config.NewCGRConfigFromPath(actPathIn) if err != nil { t.Fatal(err) } - actPathOut = path.Join(*dataDir, "conf", "samples", "tutmongo") + actPathOut = path.Join(*utils.DataDir, "conf", "samples", "tutmongo") actCfgOut, err = config.NewCGRConfigFromPath(actPathOut) if err != nil { t.Fatal(err) @@ -87,12 +87,12 @@ func TestActionITMongo(t *testing.T) { func TestActionITMove(t *testing.T) { var err error - actPathIn = path.Join(*dataDir, "conf", "samples", "tutmongo") + actPathIn = path.Join(*utils.DataDir, "conf", "samples", "tutmongo") actCfgIn, err = config.NewCGRConfigFromPath(actPathIn) if err != nil { t.Fatal(err) } - actPathOut = path.Join(*dataDir, "conf", "samples", "tutmysql") + actPathOut = path.Join(*utils.DataDir, "conf", "samples", "tutmysql") actCfgOut, err = config.NewCGRConfigFromPath(actPathOut) if err != nil { t.Fatal(err) @@ -106,12 +106,12 @@ func TestActionITMove(t *testing.T) { func TestActionITMoveEncoding(t *testing.T) { var err error - actPathIn = path.Join(*dataDir, "conf", "samples", "tutmongo") + actPathIn = path.Join(*utils.DataDir, "conf", "samples", "tutmongo") actCfgIn, err = config.NewCGRConfigFromPath(actPathIn) if err != nil { t.Fatal(err) } - actPathOut = path.Join(*dataDir, "conf", "samples", "tutmongojson") + actPathOut = path.Join(*utils.DataDir, "conf", "samples", "tutmongojson") actCfgOut, err = config.NewCGRConfigFromPath(actPathOut) if err != nil { t.Fatal(err) @@ -125,12 +125,12 @@ func TestActionITMoveEncoding(t *testing.T) { func TestActionITMigrateMongo2Redis(t *testing.T) { var err error - actPathIn = path.Join(*dataDir, "conf", "samples", "tutmongo") + actPathIn = path.Join(*utils.DataDir, "conf", "samples", "tutmongo") actCfgIn, err = config.NewCGRConfigFromPath(actPathIn) if err != nil { t.Fatal(err) } - actPathOut = path.Join(*dataDir, "conf", "samples", "tutmysql") + actPathOut = path.Join(*utils.DataDir, "conf", "samples", "tutmysql") actCfgOut, err = config.NewCGRConfigFromPath(actPathOut) if err != nil { t.Fatal(err) @@ -144,12 +144,12 @@ func TestActionITMigrateMongo2Redis(t *testing.T) { func TestActionITMoveEncoding2(t *testing.T) { var err error - actPathIn = path.Join(*dataDir, "conf", "samples", "tutmysql") + actPathIn = path.Join(*utils.DataDir, "conf", "samples", "tutmysql") actCfgIn, err = config.NewCGRConfigFromPath(actPathIn) if err != nil { t.Fatal(err) } - actPathOut = path.Join(*dataDir, "conf", "samples", "tutmysqljson") + actPathOut = path.Join(*utils.DataDir, "conf", "samples", "tutmysqljson") actCfgOut, err = config.NewCGRConfigFromPath(actPathOut) if err != nil { t.Fatal(err) diff --git a/migrator/action_plan_it_test.go b/migrator/action_plan_it_test.go index d63dc7295..4974a4706 100644 --- a/migrator/action_plan_it_test.go +++ b/migrator/action_plan_it_test.go @@ -49,12 +49,12 @@ var sTestsActPlnIT = []func(t *testing.T){ func TestActionPlanITRedis(t *testing.T) { var err error - actPlnPathIn = path.Join(*dataDir, "conf", "samples", "tutmysql") + actPlnPathIn = path.Join(*utils.DataDir, "conf", "samples", "tutmysql") actPlnCfgIn, err = config.NewCGRConfigFromPath(actPlnPathIn) if err != nil { t.Fatal(err) } - actPlnPathOut = path.Join(*dataDir, "conf", "samples", "tutmysql") + actPlnPathOut = path.Join(*utils.DataDir, "conf", "samples", "tutmysql") actPlnCfgOut, err = config.NewCGRConfigFromPath(actPlnPathOut) if err != nil { t.Fatal(err) @@ -68,12 +68,12 @@ func TestActionPlanITRedis(t *testing.T) { func TestActionPlanITMongo(t *testing.T) { var err error - actPlnPathIn = path.Join(*dataDir, "conf", "samples", "tutmongo") + actPlnPathIn = path.Join(*utils.DataDir, "conf", "samples", "tutmongo") actPlnCfgIn, err = config.NewCGRConfigFromPath(actPlnPathIn) if err != nil { t.Fatal(err) } - actPlnPathOut = path.Join(*dataDir, "conf", "samples", "tutmongo") + actPlnPathOut = path.Join(*utils.DataDir, "conf", "samples", "tutmongo") actPlnCfgOut, err = config.NewCGRConfigFromPath(actPlnPathOut) if err != nil { t.Fatal(err) @@ -87,12 +87,12 @@ func TestActionPlanITMongo(t *testing.T) { func TestActionPlanITMove(t *testing.T) { var err error - actPlnPathIn = path.Join(*dataDir, "conf", "samples", "tutmongo") + actPlnPathIn = path.Join(*utils.DataDir, "conf", "samples", "tutmongo") actPlnCfgIn, err = config.NewCGRConfigFromPath(actPlnPathIn) if err != nil { t.Fatal(err) } - actPlnPathOut = path.Join(*dataDir, "conf", "samples", "tutmysql") + actPlnPathOut = path.Join(*utils.DataDir, "conf", "samples", "tutmysql") actPlnCfgOut, err = config.NewCGRConfigFromPath(actPlnPathOut) if err != nil { t.Fatal(err) @@ -106,12 +106,12 @@ func TestActionPlanITMove(t *testing.T) { func TestActionPlanITMigrateMongo2Redis(t *testing.T) { var err error - actPlnPathIn = path.Join(*dataDir, "conf", "samples", "tutmongo") + actPlnPathIn = path.Join(*utils.DataDir, "conf", "samples", "tutmongo") actPlnCfgIn, err = config.NewCGRConfigFromPath(actPlnPathIn) if err != nil { t.Fatal(err) } - actPlnPathOut = path.Join(*dataDir, "conf", "samples", "tutmysql") + actPlnPathOut = path.Join(*utils.DataDir, "conf", "samples", "tutmysql") actPlnCfgOut, err = config.NewCGRConfigFromPath(actPlnPathOut) if err != nil { t.Fatal(err) @@ -125,12 +125,12 @@ func TestActionPlanITMigrateMongo2Redis(t *testing.T) { func TestActionPlanITMoveEncoding(t *testing.T) { var err error - actPlnPathIn = path.Join(*dataDir, "conf", "samples", "tutmongo") + actPlnPathIn = path.Join(*utils.DataDir, "conf", "samples", "tutmongo") actPlnCfgIn, err = config.NewCGRConfigFromPath(actPlnPathIn) if err != nil { t.Fatal(err) } - actPlnPathOut = path.Join(*dataDir, "conf", "samples", "tutmongojson") + actPlnPathOut = path.Join(*utils.DataDir, "conf", "samples", "tutmongojson") actPlnCfgOut, err = config.NewCGRConfigFromPath(actPlnPathOut) if err != nil { t.Fatal(err) @@ -144,12 +144,12 @@ func TestActionPlanITMoveEncoding(t *testing.T) { func TestActionPlanITMoveEncoding2(t *testing.T) { var err error - actPlnPathIn = path.Join(*dataDir, "conf", "samples", "tutmysql") + actPlnPathIn = path.Join(*utils.DataDir, "conf", "samples", "tutmysql") actPlnCfgIn, err = config.NewCGRConfigFromPath(actPlnPathIn) if err != nil { t.Fatal(err) } - actPlnPathOut = path.Join(*dataDir, "conf", "samples", "tutmysqljson") + actPlnPathOut = path.Join(*utils.DataDir, "conf", "samples", "tutmysqljson") actPlnCfgOut, err = config.NewCGRConfigFromPath(actPlnPathOut) if err != nil { t.Fatal(err) diff --git a/migrator/action_trigger_it_test.go b/migrator/action_trigger_it_test.go index d51ef1c54..a0b270802 100644 --- a/migrator/action_trigger_it_test.go +++ b/migrator/action_trigger_it_test.go @@ -50,12 +50,12 @@ var sTestsActTrgIT = []func(t *testing.T){ func TestActionTriggerITRedis(t *testing.T) { var err error - actTrgPathIn = path.Join(*dataDir, "conf", "samples", "tutmysql") + actTrgPathIn = path.Join(*utils.DataDir, "conf", "samples", "tutmysql") actTrgCfgIn, err = config.NewCGRConfigFromPath(actTrgPathIn) if err != nil { t.Fatal(err) } - actTrgPathOut = path.Join(*dataDir, "conf", "samples", "tutmysql") + actTrgPathOut = path.Join(*utils.DataDir, "conf", "samples", "tutmysql") actTrgCfgOut, err = config.NewCGRConfigFromPath(actTrgPathOut) if err != nil { t.Fatal(err) @@ -69,12 +69,12 @@ func TestActionTriggerITRedis(t *testing.T) { func TestActionTriggerITMongo(t *testing.T) { var err error - actTrgPathIn = path.Join(*dataDir, "conf", "samples", "tutmongo") + actTrgPathIn = path.Join(*utils.DataDir, "conf", "samples", "tutmongo") actTrgCfgIn, err = config.NewCGRConfigFromPath(actTrgPathIn) if err != nil { t.Fatal(err) } - actTrgPathOut = path.Join(*dataDir, "conf", "samples", "tutmongo") + actTrgPathOut = path.Join(*utils.DataDir, "conf", "samples", "tutmongo") actTrgCfgOut, err = config.NewCGRConfigFromPath(actTrgPathOut) if err != nil { t.Fatal(err) @@ -88,12 +88,12 @@ func TestActionTriggerITMongo(t *testing.T) { func TestActionTriggerITMove(t *testing.T) { var err error - actTrgPathIn = path.Join(*dataDir, "conf", "samples", "tutmongo") + actTrgPathIn = path.Join(*utils.DataDir, "conf", "samples", "tutmongo") actTrgCfgIn, err = config.NewCGRConfigFromPath(actTrgPathIn) if err != nil { t.Fatal(err) } - actTrgPathOut = path.Join(*dataDir, "conf", "samples", "tutmysql") + actTrgPathOut = path.Join(*utils.DataDir, "conf", "samples", "tutmysql") actTrgCfgOut, err = config.NewCGRConfigFromPath(actTrgPathOut) if err != nil { t.Fatal(err) @@ -107,12 +107,12 @@ func TestActionTriggerITMove(t *testing.T) { func TestActionTriggerITMoveEncoding(t *testing.T) { var err error - actTrgPathIn = path.Join(*dataDir, "conf", "samples", "tutmongo") + actTrgPathIn = path.Join(*utils.DataDir, "conf", "samples", "tutmongo") actTrgCfgIn, err = config.NewCGRConfigFromPath(actTrgPathIn) if err != nil { t.Fatal(err) } - actTrgPathOut = path.Join(*dataDir, "conf", "samples", "tutmongojson") + actTrgPathOut = path.Join(*utils.DataDir, "conf", "samples", "tutmongojson") actTrgCfgOut, err = config.NewCGRConfigFromPath(actTrgPathOut) if err != nil { t.Fatal(err) @@ -126,12 +126,12 @@ func TestActionTriggerITMoveEncoding(t *testing.T) { func TestActionTriggerITMoveEncoding2(t *testing.T) { var err error - actTrgPathIn = path.Join(*dataDir, "conf", "samples", "tutmysql") + actTrgPathIn = path.Join(*utils.DataDir, "conf", "samples", "tutmysql") actTrgCfgIn, err = config.NewCGRConfigFromPath(actTrgPathIn) if err != nil { t.Fatal(err) } - actTrgPathOut = path.Join(*dataDir, "conf", "samples", "tutmysqljson") + actTrgPathOut = path.Join(*utils.DataDir, "conf", "samples", "tutmysqljson") actTrgCfgOut, err = config.NewCGRConfigFromPath(actTrgPathOut) if err != nil { t.Fatal(err) diff --git a/migrator/alias_it_test.go b/migrator/alias_it_test.go index d14139498..00458c525 100644 --- a/migrator/alias_it_test.go +++ b/migrator/alias_it_test.go @@ -48,20 +48,20 @@ var sTestsAlsIT = []func(t *testing.T){ } func TestAliasMigrateITRedis(t *testing.T) { - inPath = path.Join(*dataDir, "conf", "samples", "tutmysql") - outPath = path.Join(*dataDir, "conf", "samples", "tutmysql") + inPath = path.Join(*utils.DataDir, "conf", "samples", "tutmysql") + outPath = path.Join(*utils.DataDir, "conf", "samples", "tutmysql") testStart("TestAliasMigrateITRedis", t) } func TestAliasMigrateITMongo(t *testing.T) { - inPath = path.Join(*dataDir, "conf", "samples", "tutmongo") - outPath = path.Join(*dataDir, "conf", "samples", "tutmongo") + inPath = path.Join(*utils.DataDir, "conf", "samples", "tutmongo") + outPath = path.Join(*utils.DataDir, "conf", "samples", "tutmongo") testStart("TestAliasMigrateITMongo", t) } func TestAliasITMigrateMongo2Redis(t *testing.T) { - inPath = path.Join(*dataDir, "conf", "samples", "tutmongo") - outPath = path.Join(*dataDir, "conf", "samples", "tutmysql") + inPath = path.Join(*utils.DataDir, "conf", "samples", "tutmongo") + outPath = path.Join(*utils.DataDir, "conf", "samples", "tutmysql") testStart("TestAliasITMigrateMongo2Redis", t) } diff --git a/migrator/attributes_it_test.go b/migrator/attributes_it_test.go index fc615e3f4..2dea2171f 100644 --- a/migrator/attributes_it_test.go +++ b/migrator/attributes_it_test.go @@ -68,12 +68,12 @@ var sTestsAttrIT = []func(t *testing.T){ func TestAttributeITRedis(t *testing.T) { var err error - attrPathIn = path.Join(*dataDir, "conf", "samples", "tutmysql") + attrPathIn = path.Join(*utils.DataDir, "conf", "samples", "tutmysql") attrCfgIn, err = config.NewCGRConfigFromPath(attrPathIn) if err != nil { t.Fatal(err) } - attrPathOut = path.Join(*dataDir, "conf", "samples", "tutmysql") + attrPathOut = path.Join(*utils.DataDir, "conf", "samples", "tutmysql") attrCfgOut, err = config.NewCGRConfigFromPath(attrPathOut) if err != nil { t.Fatal(err) @@ -87,12 +87,12 @@ func TestAttributeITRedis(t *testing.T) { func TestAttributeITMongo(t *testing.T) { var err error - attrPathIn = path.Join(*dataDir, "conf", "samples", "tutmongo") + attrPathIn = path.Join(*utils.DataDir, "conf", "samples", "tutmongo") attrCfgIn, err = config.NewCGRConfigFromPath(attrPathIn) if err != nil { t.Fatal(err) } - attrPathOut = path.Join(*dataDir, "conf", "samples", "tutmongo") + attrPathOut = path.Join(*utils.DataDir, "conf", "samples", "tutmongo") attrCfgOut, err = config.NewCGRConfigFromPath(attrPathOut) if err != nil { t.Fatal(err) @@ -106,12 +106,12 @@ func TestAttributeITMongo(t *testing.T) { func TestAttributeITMove1(t *testing.T) { var err error - attrPathIn = path.Join(*dataDir, "conf", "samples", "tutmongo") + attrPathIn = path.Join(*utils.DataDir, "conf", "samples", "tutmongo") attrCfgIn, err = config.NewCGRConfigFromPath(attrPathIn) if err != nil { t.Fatal(err) } - attrPathOut = path.Join(*dataDir, "conf", "samples", "tutmysql") + attrPathOut = path.Join(*utils.DataDir, "conf", "samples", "tutmysql") attrCfgOut, err = config.NewCGRConfigFromPath(attrPathOut) if err != nil { t.Fatal(err) @@ -125,12 +125,12 @@ func TestAttributeITMove1(t *testing.T) { func TestAttributeITMigrateMongo2Redis(t *testing.T) { var err error - attrPathIn = path.Join(*dataDir, "conf", "samples", "tutmongo") + attrPathIn = path.Join(*utils.DataDir, "conf", "samples", "tutmongo") attrCfgIn, err = config.NewCGRConfigFromPath(attrPathIn) if err != nil { t.Fatal(err) } - attrPathOut = path.Join(*dataDir, "conf", "samples", "tutmysql") + attrPathOut = path.Join(*utils.DataDir, "conf", "samples", "tutmysql") attrCfgOut, err = config.NewCGRConfigFromPath(attrPathOut) if err != nil { t.Fatal(err) @@ -144,12 +144,12 @@ func TestAttributeITMigrateMongo2Redis(t *testing.T) { func TestAttributeITMove2(t *testing.T) { var err error - attrPathIn = path.Join(*dataDir, "conf", "samples", "tutmysql") + attrPathIn = path.Join(*utils.DataDir, "conf", "samples", "tutmysql") attrCfgIn, err = config.NewCGRConfigFromPath(attrPathIn) if err != nil { t.Fatal(err) } - attrPathOut = path.Join(*dataDir, "conf", "samples", "tutmongo") + attrPathOut = path.Join(*utils.DataDir, "conf", "samples", "tutmongo") attrCfgOut, err = config.NewCGRConfigFromPath(attrPathOut) if err != nil { t.Fatal(err) @@ -163,12 +163,12 @@ func TestAttributeITMove2(t *testing.T) { func TestAttributeITMoveEncoding(t *testing.T) { var err error - attrPathIn = path.Join(*dataDir, "conf", "samples", "tutmongo") + attrPathIn = path.Join(*utils.DataDir, "conf", "samples", "tutmongo") attrCfgIn, err = config.NewCGRConfigFromPath(attrPathIn) if err != nil { t.Fatal(err) } - attrPathOut = path.Join(*dataDir, "conf", "samples", "tutmongojson") + attrPathOut = path.Join(*utils.DataDir, "conf", "samples", "tutmongojson") attrCfgOut, err = config.NewCGRConfigFromPath(attrPathOut) if err != nil { t.Fatal(err) @@ -182,12 +182,12 @@ func TestAttributeITMoveEncoding(t *testing.T) { func TestAttributeITMoveEncoding2(t *testing.T) { var err error - attrPathIn = path.Join(*dataDir, "conf", "samples", "tutmysql") + attrPathIn = path.Join(*utils.DataDir, "conf", "samples", "tutmysql") attrCfgIn, err = config.NewCGRConfigFromPath(attrPathIn) if err != nil { t.Fatal(err) } - attrPathOut = path.Join(*dataDir, "conf", "samples", "tutmysqljson") + attrPathOut = path.Join(*utils.DataDir, "conf", "samples", "tutmysqljson") attrCfgOut, err = config.NewCGRConfigFromPath(attrPathOut) if err != nil { t.Fatal(err) diff --git a/migrator/cdrs_it_test.go b/migrator/cdrs_it_test.go index b43fcce0d..70478cfbf 100644 --- a/migrator/cdrs_it_test.go +++ b/migrator/cdrs_it_test.go @@ -49,7 +49,7 @@ var sTestsCdrIT = []func(t *testing.T){ func TestCdrITMongo(t *testing.T) { var err error - cdrPathIn = path.Join(*dataDir, "conf", "samples", "tutmongo") + cdrPathIn = path.Join(*utils.DataDir, "conf", "samples", "tutmongo") cdrCfgIn, err = config.NewCGRConfigFromPath(cdrPathIn) if err != nil { t.Error(err) @@ -62,7 +62,7 @@ func TestCdrITMongo(t *testing.T) { func TestCdrITMySql(t *testing.T) { var err error - cdrPathIn = path.Join(*dataDir, "conf", "samples", "tutmysql") + cdrPathIn = path.Join(*utils.DataDir, "conf", "samples", "tutmysql") cdrCfgIn, err = config.NewCGRConfigFromPath(cdrPathIn) if err != nil { t.Error(err) diff --git a/migrator/chargers_it_test.go b/migrator/chargers_it_test.go index c69b7f9ce..e5e6edfbd 100644 --- a/migrator/chargers_it_test.go +++ b/migrator/chargers_it_test.go @@ -50,12 +50,12 @@ var sTestsChrgIT = []func(t *testing.T){ func TestChargersITMove1(t *testing.T) { var err error - chrgPathIn = path.Join(*dataDir, "conf", "samples", "tutmongo") + chrgPathIn = path.Join(*utils.DataDir, "conf", "samples", "tutmongo") chrgCfgIn, err = config.NewCGRConfigFromPath(chrgPathIn) if err != nil { t.Fatal(err) } - chrgPathOut = path.Join(*dataDir, "conf", "samples", "tutmysql") + chrgPathOut = path.Join(*utils.DataDir, "conf", "samples", "tutmysql") chrgCfgOut, err = config.NewCGRConfigFromPath(chrgPathOut) if err != nil { t.Fatal(err) @@ -69,12 +69,12 @@ func TestChargersITMove1(t *testing.T) { func TestChargersITMove2(t *testing.T) { var err error - chrgPathIn = path.Join(*dataDir, "conf", "samples", "tutmysql") + chrgPathIn = path.Join(*utils.DataDir, "conf", "samples", "tutmysql") chrgCfgIn, err = config.NewCGRConfigFromPath(chrgPathIn) if err != nil { t.Fatal(err) } - chrgPathOut = path.Join(*dataDir, "conf", "samples", "tutmongo") + chrgPathOut = path.Join(*utils.DataDir, "conf", "samples", "tutmongo") chrgCfgOut, err = config.NewCGRConfigFromPath(chrgPathOut) if err != nil { t.Fatal(err) @@ -88,12 +88,12 @@ func TestChargersITMove2(t *testing.T) { func TestChargersITMoveEncoding(t *testing.T) { var err error - chrgPathIn = path.Join(*dataDir, "conf", "samples", "tutmongo") + chrgPathIn = path.Join(*utils.DataDir, "conf", "samples", "tutmongo") chrgCfgIn, err = config.NewCGRConfigFromPath(chrgPathIn) if err != nil { t.Fatal(err) } - chrgPathOut = path.Join(*dataDir, "conf", "samples", "tutmongojson") + chrgPathOut = path.Join(*utils.DataDir, "conf", "samples", "tutmongojson") chrgCfgOut, err = config.NewCGRConfigFromPath(chrgPathOut) if err != nil { t.Fatal(err) @@ -107,12 +107,12 @@ func TestChargersITMoveEncoding(t *testing.T) { func TestChargersITMoveEncoding2(t *testing.T) { var err error - chrgPathIn = path.Join(*dataDir, "conf", "samples", "tutmysql") + chrgPathIn = path.Join(*utils.DataDir, "conf", "samples", "tutmysql") chrgCfgIn, err = config.NewCGRConfigFromPath(chrgPathIn) if err != nil { t.Fatal(err) } - chrgPathOut = path.Join(*dataDir, "conf", "samples", "tutmysqljson") + chrgPathOut = path.Join(*utils.DataDir, "conf", "samples", "tutmysqljson") chrgCfgOut, err = config.NewCGRConfigFromPath(chrgPathOut) if err != nil { t.Fatal(err) diff --git a/migrator/derived_chargers_it_test.go b/migrator/derived_chargers_it_test.go index ba0dc2c83..3bc177051 100644 --- a/migrator/derived_chargers_it_test.go +++ b/migrator/derived_chargers_it_test.go @@ -47,20 +47,20 @@ var sTestsDCIT = []func(t *testing.T){ } func TestDerivedChargersVMigrateITRedis(t *testing.T) { - inPath = path.Join(*dataDir, "conf", "samples", "tutmysql") - outPath = path.Join(*dataDir, "conf", "samples", "tutmysql") + inPath = path.Join(*utils.DataDir, "conf", "samples", "tutmysql") + outPath = path.Join(*utils.DataDir, "conf", "samples", "tutmysql") testStartDC("TestDerivedChargersVMigrateITRedis", t) } func TestDerivedChargersVMigrateITMongo(t *testing.T) { - inPath = path.Join(*dataDir, "conf", "samples", "tutmongo") - outPath = path.Join(*dataDir, "conf", "samples", "tutmongo") + inPath = path.Join(*utils.DataDir, "conf", "samples", "tutmongo") + outPath = path.Join(*utils.DataDir, "conf", "samples", "tutmongo") testStartDC("TestDerivedChargersVMigrateITMongo", t) } func TestDerivedChargersVITMigrateMongo2Redis(t *testing.T) { - inPath = path.Join(*dataDir, "conf", "samples", "tutmongo") - outPath = path.Join(*dataDir, "conf", "samples", "tutmysql") + inPath = path.Join(*utils.DataDir, "conf", "samples", "tutmongo") + outPath = path.Join(*utils.DataDir, "conf", "samples", "tutmysql") testStartDC("TestDerivedChargersVITMigrateMongo2Redis", t) } diff --git a/migrator/dispatchers_it_test.go b/migrator/dispatchers_it_test.go index 694b0448a..86ff079b6 100644 --- a/migrator/dispatchers_it_test.go +++ b/migrator/dispatchers_it_test.go @@ -50,12 +50,12 @@ var sTestsDspIT = []func(t *testing.T){ func TestDispatcherITMove1(t *testing.T) { var err error - dspPathIn = path.Join(*dataDir, "conf", "samples", "tutmongo") + dspPathIn = path.Join(*utils.DataDir, "conf", "samples", "tutmongo") dspCfgIn, err = config.NewCGRConfigFromPath(dspPathIn) if err != nil { t.Fatal(err) } - dspPathOut = path.Join(*dataDir, "conf", "samples", "tutmysql") + dspPathOut = path.Join(*utils.DataDir, "conf", "samples", "tutmysql") dspCfgOut, err = config.NewCGRConfigFromPath(dspPathOut) if err != nil { t.Fatal(err) @@ -69,12 +69,12 @@ func TestDispatcherITMove1(t *testing.T) { func TestDispatcherITMove2(t *testing.T) { var err error - dspPathIn = path.Join(*dataDir, "conf", "samples", "tutmysql") + dspPathIn = path.Join(*utils.DataDir, "conf", "samples", "tutmysql") dspCfgIn, err = config.NewCGRConfigFromPath(dspPathIn) if err != nil { t.Fatal(err) } - dspPathOut = path.Join(*dataDir, "conf", "samples", "tutmongo") + dspPathOut = path.Join(*utils.DataDir, "conf", "samples", "tutmongo") dspCfgOut, err = config.NewCGRConfigFromPath(dspPathOut) if err != nil { t.Fatal(err) @@ -88,12 +88,12 @@ func TestDispatcherITMove2(t *testing.T) { func TestDispatcherITMoveEncoding(t *testing.T) { var err error - dspPathIn = path.Join(*dataDir, "conf", "samples", "tutmongo") + dspPathIn = path.Join(*utils.DataDir, "conf", "samples", "tutmongo") dspCfgIn, err = config.NewCGRConfigFromPath(dspPathIn) if err != nil { t.Fatal(err) } - dspPathOut = path.Join(*dataDir, "conf", "samples", "tutmongojson") + dspPathOut = path.Join(*utils.DataDir, "conf", "samples", "tutmongojson") dspCfgOut, err = config.NewCGRConfigFromPath(dspPathOut) if err != nil { t.Fatal(err) @@ -107,12 +107,12 @@ func TestDispatcherITMoveEncoding(t *testing.T) { func TestDispatcherITMoveEncoding2(t *testing.T) { var err error - dspPathIn = path.Join(*dataDir, "conf", "samples", "tutmysql") + dspPathIn = path.Join(*utils.DataDir, "conf", "samples", "tutmysql") dspCfgIn, err = config.NewCGRConfigFromPath(dspPathIn) if err != nil { t.Fatal(err) } - dspPathOut = path.Join(*dataDir, "conf", "samples", "tutmysqljson") + dspPathOut = path.Join(*utils.DataDir, "conf", "samples", "tutmysqljson") dspCfgOut, err = config.NewCGRConfigFromPath(dspPathOut) if err != nil { t.Fatal(err) diff --git a/migrator/filters_it_test.go b/migrator/filters_it_test.go index 118b6bb5c..0d008768d 100644 --- a/migrator/filters_it_test.go +++ b/migrator/filters_it_test.go @@ -50,38 +50,38 @@ var sTestsFltrIT = []func(t *testing.T){ } func TestFiltersMigrateITRedis(t *testing.T) { - inPath = path.Join(*dataDir, "conf", "samples", "tutmysql") - outPath = path.Join(*dataDir, "conf", "samples", "tutmysql") + inPath = path.Join(*utils.DataDir, "conf", "samples", "tutmysql") + outPath = path.Join(*utils.DataDir, "conf", "samples", "tutmysql") testFltrStart("TestFiltersMigrateITRedis", utils.Migrate, t) } func TestFiltersMigrateITMongo(t *testing.T) { - inPath = path.Join(*dataDir, "conf", "samples", "tutmongo") - outPath = path.Join(*dataDir, "conf", "samples", "tutmongo") + inPath = path.Join(*utils.DataDir, "conf", "samples", "tutmongo") + outPath = path.Join(*utils.DataDir, "conf", "samples", "tutmongo") testFltrStart("TestFiltersMigrateITMongo", utils.Migrate, t) } func TestFiltersITMove(t *testing.T) { - inPath = path.Join(*dataDir, "conf", "samples", "tutmongo") - outPath = path.Join(*dataDir, "conf", "samples", "tutmysql") + inPath = path.Join(*utils.DataDir, "conf", "samples", "tutmongo") + outPath = path.Join(*utils.DataDir, "conf", "samples", "tutmysql") testFltrStart("TestFiltersITMove", utils.Move, t) } func TestFiltersITMigrateMongo2Redis(t *testing.T) { - inPath = path.Join(*dataDir, "conf", "samples", "tutmongo") - outPath = path.Join(*dataDir, "conf", "samples", "tutmysql") + inPath = path.Join(*utils.DataDir, "conf", "samples", "tutmongo") + outPath = path.Join(*utils.DataDir, "conf", "samples", "tutmysql") testFltrStart("TestFiltersITMigrateMongo2Redis", utils.Migrate, t) } func TestFiltersITMoveEncoding(t *testing.T) { - inPath = path.Join(*dataDir, "conf", "samples", "tutmongo") - outPath = path.Join(*dataDir, "conf", "samples", "tutmongojson") + inPath = path.Join(*utils.DataDir, "conf", "samples", "tutmongo") + outPath = path.Join(*utils.DataDir, "conf", "samples", "tutmongojson") testFltrStart("TestFiltersITMoveEncoding", utils.Move, t) } func TestFiltersITMoveEncoding2(t *testing.T) { - inPath = path.Join(*dataDir, "conf", "samples", "tutmysql") - outPath = path.Join(*dataDir, "conf", "samples", "tutmysqljson") + inPath = path.Join(*utils.DataDir, "conf", "samples", "tutmysql") + outPath = path.Join(*utils.DataDir, "conf", "samples", "tutmysqljson") testFltrStart("TestFiltersITMoveEncoding2", utils.Move, t) } diff --git a/migrator/load_ids_it_test.go b/migrator/load_ids_it_test.go index 8d1c278db..e62ceba06 100644 --- a/migrator/load_ids_it_test.go +++ b/migrator/load_ids_it_test.go @@ -44,18 +44,18 @@ var sTestsLoadIdsIT = []func(t *testing.T){ } func TestLoadIDsMigrateITRedis(t *testing.T) { - inPath = path.Join(*dataDir, "conf", "samples", "tutmysql") + inPath = path.Join(*utils.DataDir, "conf", "samples", "tutmysql") testLoadIdsStart("TestLoadIDsMigrateITRedis", t) } func TestLoadIDsMigrateITMongo(t *testing.T) { - inPath = path.Join(*dataDir, "conf", "samples", "tutmongo") + inPath = path.Join(*utils.DataDir, "conf", "samples", "tutmongo") testLoadIdsStart("TestLoadIDsMigrateITMongo", t) } func TestLoadIDsITMigrateMongo2Redis(t *testing.T) { - inPath = path.Join(*dataDir, "conf", "samples", "tutmongo") - outPath = path.Join(*dataDir, "conf", "samples", "tutmysql") + inPath = path.Join(*utils.DataDir, "conf", "samples", "tutmongo") + outPath = path.Join(*utils.DataDir, "conf", "samples", "tutmysql") testLoadIdsStart("TestLoadIDsITMigrateMongo2Redis", t) } diff --git a/migrator/rating_plan_it_test.go b/migrator/rating_plan_it_test.go index f3b61db35..d224989e1 100644 --- a/migrator/rating_plan_it_test.go +++ b/migrator/rating_plan_it_test.go @@ -49,12 +49,12 @@ var sTestsRtPlIT = []func(t *testing.T){ func TestRatingPlanITMove1(t *testing.T) { var err error - rtplPathIn = path.Join(*dataDir, "conf", "samples", "tutmongo") + rtplPathIn = path.Join(*utils.DataDir, "conf", "samples", "tutmongo") rtplCfgIn, err = config.NewCGRConfigFromPath(rtplPathIn) if err != nil { t.Fatal(err) } - rtplPathOut = path.Join(*dataDir, "conf", "samples", "tutmysql") + rtplPathOut = path.Join(*utils.DataDir, "conf", "samples", "tutmysql") rtplCfgOut, err = config.NewCGRConfigFromPath(rtplPathOut) if err != nil { t.Fatal(err) @@ -68,12 +68,12 @@ func TestRatingPlanITMove1(t *testing.T) { func TestRatingPlanITMove2(t *testing.T) { var err error - rtplPathIn = path.Join(*dataDir, "conf", "samples", "tutmysql") + rtplPathIn = path.Join(*utils.DataDir, "conf", "samples", "tutmysql") rtplCfgIn, err = config.NewCGRConfigFromPath(rtplPathIn) if err != nil { t.Fatal(err) } - rtplPathOut = path.Join(*dataDir, "conf", "samples", "tutmongo") + rtplPathOut = path.Join(*utils.DataDir, "conf", "samples", "tutmongo") rtplCfgOut, err = config.NewCGRConfigFromPath(rtplPathOut) if err != nil { t.Fatal(err) @@ -87,12 +87,12 @@ func TestRatingPlanITMove2(t *testing.T) { func TestRatingPlanITMoveEncoding(t *testing.T) { var err error - rtplPathIn = path.Join(*dataDir, "conf", "samples", "tutmongo") + rtplPathIn = path.Join(*utils.DataDir, "conf", "samples", "tutmongo") rtplCfgIn, err = config.NewCGRConfigFromPath(rtplPathIn) if err != nil { t.Fatal(err) } - rtplPathOut = path.Join(*dataDir, "conf", "samples", "tutmongojson") + rtplPathOut = path.Join(*utils.DataDir, "conf", "samples", "tutmongojson") rtplCfgOut, err = config.NewCGRConfigFromPath(rtplPathOut) if err != nil { t.Fatal(err) @@ -106,12 +106,12 @@ func TestRatingPlanITMoveEncoding(t *testing.T) { func TestRatingPlanITMoveEncoding2(t *testing.T) { var err error - rtplPathIn = path.Join(*dataDir, "conf", "samples", "tutmysql") + rtplPathIn = path.Join(*utils.DataDir, "conf", "samples", "tutmysql") rtplCfgIn, err = config.NewCGRConfigFromPath(rtplPathIn) if err != nil { t.Fatal(err) } - rtplPathOut = path.Join(*dataDir, "conf", "samples", "tutmysqljson") + rtplPathOut = path.Join(*utils.DataDir, "conf", "samples", "tutmysqljson") rtplCfgOut, err = config.NewCGRConfigFromPath(rtplPathOut) if err != nil { t.Fatal(err) diff --git a/migrator/rating_profile_it_test.go b/migrator/rating_profile_it_test.go index 7da01bf22..a746c0c31 100644 --- a/migrator/rating_profile_it_test.go +++ b/migrator/rating_profile_it_test.go @@ -50,12 +50,12 @@ var sTestsRtPrfIT = []func(t *testing.T){ func TestRatingProfileITMove1(t *testing.T) { var err error - rtprflPathIn = path.Join(*dataDir, "conf", "samples", "tutmongo") + rtprflPathIn = path.Join(*utils.DataDir, "conf", "samples", "tutmongo") rtprflCfgIn, err = config.NewCGRConfigFromPath(rtprflPathIn) if err != nil { t.Fatal(err) } - rtprflPathOut = path.Join(*dataDir, "conf", "samples", "tutmysql") + rtprflPathOut = path.Join(*utils.DataDir, "conf", "samples", "tutmysql") rtprflCfgOut, err = config.NewCGRConfigFromPath(rtprflPathOut) if err != nil { t.Fatal(err) @@ -69,12 +69,12 @@ func TestRatingProfileITMove1(t *testing.T) { func TestRatingProfileITMove2(t *testing.T) { var err error - rtprflPathIn = path.Join(*dataDir, "conf", "samples", "tutmysql") + rtprflPathIn = path.Join(*utils.DataDir, "conf", "samples", "tutmysql") rtprflCfgIn, err = config.NewCGRConfigFromPath(rtprflPathIn) if err != nil { t.Fatal(err) } - rtprflPathOut = path.Join(*dataDir, "conf", "samples", "tutmongo") + rtprflPathOut = path.Join(*utils.DataDir, "conf", "samples", "tutmongo") rtprflCfgOut, err = config.NewCGRConfigFromPath(rtprflPathOut) if err != nil { t.Fatal(err) @@ -88,12 +88,12 @@ func TestRatingProfileITMove2(t *testing.T) { func TestRatingProfileITMoveEncoding(t *testing.T) { var err error - rtprflPathIn = path.Join(*dataDir, "conf", "samples", "tutmongo") + rtprflPathIn = path.Join(*utils.DataDir, "conf", "samples", "tutmongo") rtprflCfgIn, err = config.NewCGRConfigFromPath(rtprflPathIn) if err != nil { t.Fatal(err) } - rtprflPathOut = path.Join(*dataDir, "conf", "samples", "tutmongojson") + rtprflPathOut = path.Join(*utils.DataDir, "conf", "samples", "tutmongojson") rtprflCfgOut, err = config.NewCGRConfigFromPath(rtprflPathOut) if err != nil { t.Fatal(err) @@ -107,12 +107,12 @@ func TestRatingProfileITMoveEncoding(t *testing.T) { func TestRatingProfileITMoveEncoding2(t *testing.T) { var err error - rtprflPathIn = path.Join(*dataDir, "conf", "samples", "tutmysql") + rtprflPathIn = path.Join(*utils.DataDir, "conf", "samples", "tutmysql") rtprflCfgIn, err = config.NewCGRConfigFromPath(rtprflPathIn) if err != nil { t.Fatal(err) } - rtprflPathOut = path.Join(*dataDir, "conf", "samples", "tutmysqljson") + rtprflPathOut = path.Join(*utils.DataDir, "conf", "samples", "tutmysqljson") rtprflCfgOut, err = config.NewCGRConfigFromPath(rtprflPathOut) if err != nil { t.Fatal(err) diff --git a/migrator/resource_it_test.go b/migrator/resource_it_test.go index 78f6f4303..9bfa547a2 100644 --- a/migrator/resource_it_test.go +++ b/migrator/resource_it_test.go @@ -50,12 +50,12 @@ var sTestsResIT = []func(t *testing.T){ func TestResourceITMove1(t *testing.T) { var err error - resPathIn = path.Join(*dataDir, "conf", "samples", "tutmongo") + resPathIn = path.Join(*utils.DataDir, "conf", "samples", "tutmongo") resCfgIn, err = config.NewCGRConfigFromPath(resPathIn) if err != nil { t.Fatal(err) } - resPathOut = path.Join(*dataDir, "conf", "samples", "tutmysql") + resPathOut = path.Join(*utils.DataDir, "conf", "samples", "tutmysql") resCfgOut, err = config.NewCGRConfigFromPath(resPathOut) if err != nil { t.Fatal(err) @@ -69,12 +69,12 @@ func TestResourceITMove1(t *testing.T) { func TestResourceITMove2(t *testing.T) { var err error - resPathIn = path.Join(*dataDir, "conf", "samples", "tutmysql") + resPathIn = path.Join(*utils.DataDir, "conf", "samples", "tutmysql") resCfgIn, err = config.NewCGRConfigFromPath(resPathIn) if err != nil { t.Fatal(err) } - resPathOut = path.Join(*dataDir, "conf", "samples", "tutmongo") + resPathOut = path.Join(*utils.DataDir, "conf", "samples", "tutmongo") resCfgOut, err = config.NewCGRConfigFromPath(resPathOut) if err != nil { t.Fatal(err) @@ -88,12 +88,12 @@ func TestResourceITMove2(t *testing.T) { func TestResourceITMoveEncoding(t *testing.T) { var err error - resPathIn = path.Join(*dataDir, "conf", "samples", "tutmongo") + resPathIn = path.Join(*utils.DataDir, "conf", "samples", "tutmongo") resCfgIn, err = config.NewCGRConfigFromPath(resPathIn) if err != nil { t.Fatal(err) } - resPathOut = path.Join(*dataDir, "conf", "samples", "tutmongojson") + resPathOut = path.Join(*utils.DataDir, "conf", "samples", "tutmongojson") resCfgOut, err = config.NewCGRConfigFromPath(resPathOut) if err != nil { t.Fatal(err) @@ -107,12 +107,12 @@ func TestResourceITMoveEncoding(t *testing.T) { func TestResourceITMoveEncoding2(t *testing.T) { var err error - resPathIn = path.Join(*dataDir, "conf", "samples", "tutmysql") + resPathIn = path.Join(*utils.DataDir, "conf", "samples", "tutmysql") resCfgIn, err = config.NewCGRConfigFromPath(resPathIn) if err != nil { t.Fatal(err) } - resPathOut = path.Join(*dataDir, "conf", "samples", "tutmysqljson") + resPathOut = path.Join(*utils.DataDir, "conf", "samples", "tutmysqljson") resCfgOut, err = config.NewCGRConfigFromPath(resPathOut) if err != nil { t.Fatal(err) diff --git a/migrator/routes_it_test.go b/migrator/routes_it_test.go index e06026221..1e1f1a774 100644 --- a/migrator/routes_it_test.go +++ b/migrator/routes_it_test.go @@ -49,12 +49,12 @@ var sTestsSupIT = []func(t *testing.T){ func TestSuppliersITMove1(t *testing.T) { var err error - supPathIn = path.Join(*dataDir, "conf", "samples", "tutmongo") + supPathIn = path.Join(*utils.DataDir, "conf", "samples", "tutmongo") supCfgIn, err = config.NewCGRConfigFromPath(supPathIn) if err != nil { t.Fatal(err) } - supPathOut = path.Join(*dataDir, "conf", "samples", "tutmysql") + supPathOut = path.Join(*utils.DataDir, "conf", "samples", "tutmysql") supCfgOut, err = config.NewCGRConfigFromPath(supPathOut) if err != nil { t.Fatal(err) @@ -68,12 +68,12 @@ func TestSuppliersITMove1(t *testing.T) { func TestSuppliersITMove2(t *testing.T) { var err error - supPathIn = path.Join(*dataDir, "conf", "samples", "tutmysql") + supPathIn = path.Join(*utils.DataDir, "conf", "samples", "tutmysql") supCfgIn, err = config.NewCGRConfigFromPath(supPathIn) if err != nil { t.Fatal(err) } - supPathOut = path.Join(*dataDir, "conf", "samples", "tutmongo") + supPathOut = path.Join(*utils.DataDir, "conf", "samples", "tutmongo") supCfgOut, err = config.NewCGRConfigFromPath(supPathOut) if err != nil { t.Fatal(err) @@ -87,12 +87,12 @@ func TestSuppliersITMove2(t *testing.T) { func TestSuppliersITMoveEncoding(t *testing.T) { var err error - supPathIn = path.Join(*dataDir, "conf", "samples", "tutmongo") + supPathIn = path.Join(*utils.DataDir, "conf", "samples", "tutmongo") supCfgIn, err = config.NewCGRConfigFromPath(supPathIn) if err != nil { t.Fatal(err) } - supPathOut = path.Join(*dataDir, "conf", "samples", "tutmongojson") + supPathOut = path.Join(*utils.DataDir, "conf", "samples", "tutmongojson") supCfgOut, err = config.NewCGRConfigFromPath(supPathOut) if err != nil { t.Fatal(err) @@ -106,12 +106,12 @@ func TestSuppliersITMoveEncoding(t *testing.T) { func TestSuppliersITMoveEncoding2(t *testing.T) { var err error - supPathIn = path.Join(*dataDir, "conf", "samples", "tutmysql") + supPathIn = path.Join(*utils.DataDir, "conf", "samples", "tutmysql") supCfgIn, err = config.NewCGRConfigFromPath(supPathIn) if err != nil { t.Fatal(err) } - supPathOut = path.Join(*dataDir, "conf", "samples", "tutmysqljson") + supPathOut = path.Join(*utils.DataDir, "conf", "samples", "tutmysqljson") supCfgOut, err = config.NewCGRConfigFromPath(supPathOut) if err != nil { t.Fatal(err) diff --git a/migrator/session_costs_it_test.go b/migrator/session_costs_it_test.go index a1d710310..082cf00bd 100644 --- a/migrator/session_costs_it_test.go +++ b/migrator/session_costs_it_test.go @@ -49,12 +49,12 @@ var sTestssCostIT = []func(t *testing.T){ func TestSessionCostITMongo(t *testing.T) { var err error - sCostPathIn = path.Join(*dataDir, "conf", "samples", "tutmongo") + sCostPathIn = path.Join(*utils.DataDir, "conf", "samples", "tutmongo") sCostCfgIn, err = config.NewCGRConfigFromPath(sCostPathIn) if err != nil { t.Error(err) } - sCostPathOut = path.Join(*dataDir, "conf", "samples", "tutmongojson") + sCostPathOut = path.Join(*utils.DataDir, "conf", "samples", "tutmongojson") sCostCfgOut, err = config.NewCGRConfigFromPath(sCostPathOut) if err != nil { t.Error(err) @@ -67,12 +67,12 @@ func TestSessionCostITMongo(t *testing.T) { func TestSessionCostITMySql(t *testing.T) { var err error - sCostPathIn = path.Join(*dataDir, "conf", "samples", "tutmysql") + sCostPathIn = path.Join(*utils.DataDir, "conf", "samples", "tutmysql") sCostCfgIn, err = config.NewCGRConfigFromPath(sCostPathIn) if err != nil { t.Error(err) } - sCostPathOut = path.Join(*dataDir, "conf", "samples", "tutmysql") + sCostPathOut = path.Join(*utils.DataDir, "conf", "samples", "tutmysql") sCostCfgOut, err = config.NewCGRConfigFromPath(sCostPathOut) if err != nil { t.Error(err) diff --git a/migrator/sharedgroup_it_test.go b/migrator/sharedgroup_it_test.go index 38d8b196e..57f778444 100644 --- a/migrator/sharedgroup_it_test.go +++ b/migrator/sharedgroup_it_test.go @@ -49,12 +49,12 @@ var sTestsShrGrpIT = []func(t *testing.T){ func TestSharedGroupITRedis(t *testing.T) { var err error - shrGrpPathIn = path.Join(*dataDir, "conf", "samples", "tutmysql") + shrGrpPathIn = path.Join(*utils.DataDir, "conf", "samples", "tutmysql") shrGrpCfgIn, err = config.NewCGRConfigFromPath(shrGrpPathIn) if err != nil { t.Fatal(err) } - shrGrpPathOut = path.Join(*dataDir, "conf", "samples", "tutmysql") + shrGrpPathOut = path.Join(*utils.DataDir, "conf", "samples", "tutmysql") shrGrpCfgOut, err = config.NewCGRConfigFromPath(shrGrpPathOut) if err != nil { t.Fatal(err) @@ -68,12 +68,12 @@ func TestSharedGroupITRedis(t *testing.T) { func TestSharedGroupITMongo(t *testing.T) { var err error - shrGrpPathIn = path.Join(*dataDir, "conf", "samples", "tutmongo") + shrGrpPathIn = path.Join(*utils.DataDir, "conf", "samples", "tutmongo") shrGrpCfgIn, err = config.NewCGRConfigFromPath(shrGrpPathIn) if err != nil { t.Fatal(err) } - shrGrpPathOut = path.Join(*dataDir, "conf", "samples", "tutmongo") + shrGrpPathOut = path.Join(*utils.DataDir, "conf", "samples", "tutmongo") shrGrpCfgOut, err = config.NewCGRConfigFromPath(shrGrpPathOut) if err != nil { t.Fatal(err) @@ -87,12 +87,12 @@ func TestSharedGroupITMongo(t *testing.T) { func TestSharedGroupITMove(t *testing.T) { var err error - shrGrpPathIn = path.Join(*dataDir, "conf", "samples", "tutmongo") + shrGrpPathIn = path.Join(*utils.DataDir, "conf", "samples", "tutmongo") shrGrpCfgIn, err = config.NewCGRConfigFromPath(shrGrpPathIn) if err != nil { t.Fatal(err) } - shrGrpPathOut = path.Join(*dataDir, "conf", "samples", "tutmysql") + shrGrpPathOut = path.Join(*utils.DataDir, "conf", "samples", "tutmysql") shrGrpCfgOut, err = config.NewCGRConfigFromPath(shrGrpPathOut) if err != nil { t.Fatal(err) @@ -106,12 +106,12 @@ func TestSharedGroupITMove(t *testing.T) { func TestSharedGroupITMoveEncoding(t *testing.T) { var err error - shrGrpPathIn = path.Join(*dataDir, "conf", "samples", "tutmongo") + shrGrpPathIn = path.Join(*utils.DataDir, "conf", "samples", "tutmongo") shrGrpCfgIn, err = config.NewCGRConfigFromPath(shrGrpPathIn) if err != nil { t.Fatal(err) } - shrGrpPathOut = path.Join(*dataDir, "conf", "samples", "tutmongojson") + shrGrpPathOut = path.Join(*utils.DataDir, "conf", "samples", "tutmongojson") shrGrpCfgOut, err = config.NewCGRConfigFromPath(shrGrpPathOut) if err != nil { t.Fatal(err) @@ -125,12 +125,12 @@ func TestSharedGroupITMoveEncoding(t *testing.T) { func TestSharedGroupITMoveEncoding2(t *testing.T) { var err error - shrGrpPathIn = path.Join(*dataDir, "conf", "samples", "tutmysql") + shrGrpPathIn = path.Join(*utils.DataDir, "conf", "samples", "tutmysql") shrGrpCfgIn, err = config.NewCGRConfigFromPath(shrGrpPathIn) if err != nil { t.Fatal(err) } - shrGrpPathOut = path.Join(*dataDir, "conf", "samples", "tutmysqljson") + shrGrpPathOut = path.Join(*utils.DataDir, "conf", "samples", "tutmysqljson") shrGrpCfgOut, err = config.NewCGRConfigFromPath(shrGrpPathOut) if err != nil { t.Fatal(err) diff --git a/migrator/stats_it_test.go b/migrator/stats_it_test.go index 1734374e3..19e09ee93 100644 --- a/migrator/stats_it_test.go +++ b/migrator/stats_it_test.go @@ -51,12 +51,12 @@ var sTestsStsIT = []func(t *testing.T){ func TestStatsQueueITRedis(t *testing.T) { var err error - stsPathIn = path.Join(*dataDir, "conf", "samples", "tutmysql") + stsPathIn = path.Join(*utils.DataDir, "conf", "samples", "tutmysql") stsCfgIn, err = config.NewCGRConfigFromPath(stsPathIn) if err != nil { t.Fatal(err) } - stsPathOut = path.Join(*dataDir, "conf", "samples", "tutmysql") + stsPathOut = path.Join(*utils.DataDir, "conf", "samples", "tutmysql") stsCfgOut, err = config.NewCGRConfigFromPath(stsPathOut) if err != nil { t.Fatal(err) @@ -70,12 +70,12 @@ func TestStatsQueueITRedis(t *testing.T) { func TestStatsQueueITMongo(t *testing.T) { var err error - stsPathIn = path.Join(*dataDir, "conf", "samples", "tutmongo") + stsPathIn = path.Join(*utils.DataDir, "conf", "samples", "tutmongo") stsCfgIn, err = config.NewCGRConfigFromPath(stsPathIn) if err != nil { t.Fatal(err) } - stsPathOut = path.Join(*dataDir, "conf", "samples", "tutmongo") + stsPathOut = path.Join(*utils.DataDir, "conf", "samples", "tutmongo") stsCfgOut, err = config.NewCGRConfigFromPath(stsPathOut) if err != nil { t.Fatal(err) @@ -89,12 +89,12 @@ func TestStatsQueueITMongo(t *testing.T) { func TestStatsQueueITMove(t *testing.T) { var err error - stsPathIn = path.Join(*dataDir, "conf", "samples", "tutmongo") + stsPathIn = path.Join(*utils.DataDir, "conf", "samples", "tutmongo") stsCfgIn, err = config.NewCGRConfigFromPath(stsPathIn) if err != nil { t.Fatal(err) } - stsPathOut = path.Join(*dataDir, "conf", "samples", "tutmysql") + stsPathOut = path.Join(*utils.DataDir, "conf", "samples", "tutmysql") stsCfgOut, err = config.NewCGRConfigFromPath(stsPathOut) if err != nil { t.Fatal(err) diff --git a/migrator/thresholds_it_test.go b/migrator/thresholds_it_test.go index b6d1b675c..7b3980d67 100644 --- a/migrator/thresholds_it_test.go +++ b/migrator/thresholds_it_test.go @@ -50,12 +50,12 @@ var sTestsTrsIT = []func(t *testing.T){ func TestThresholdsITRedis(t *testing.T) { var err error - trsPathIn = path.Join(*dataDir, "conf", "samples", "tutmysql") + trsPathIn = path.Join(*utils.DataDir, "conf", "samples", "tutmysql") trsCfgIn, err = config.NewCGRConfigFromPath(trsPathIn) if err != nil { t.Fatal(err) } - trsPathOut = path.Join(*dataDir, "conf", "samples", "tutmysql") + trsPathOut = path.Join(*utils.DataDir, "conf", "samples", "tutmysql") trsCfgOut, err = config.NewCGRConfigFromPath(trsPathOut) if err != nil { t.Fatal(err) @@ -69,12 +69,12 @@ func TestThresholdsITRedis(t *testing.T) { func TestThresholdsITMongo(t *testing.T) { var err error - trsPathIn = path.Join(*dataDir, "conf", "samples", "tutmongo") + trsPathIn = path.Join(*utils.DataDir, "conf", "samples", "tutmongo") trsCfgIn, err = config.NewCGRConfigFromPath(trsPathIn) if err != nil { t.Fatal(err) } - trsPathOut = path.Join(*dataDir, "conf", "samples", "tutmongo") + trsPathOut = path.Join(*utils.DataDir, "conf", "samples", "tutmongo") trsCfgOut, err = config.NewCGRConfigFromPath(trsPathOut) if err != nil { t.Fatal(err) @@ -88,12 +88,12 @@ func TestThresholdsITMongo(t *testing.T) { func TestThresholdsITMove(t *testing.T) { var err error - trsPathIn = path.Join(*dataDir, "conf", "samples", "tutmongo") + trsPathIn = path.Join(*utils.DataDir, "conf", "samples", "tutmongo") trsCfgIn, err = config.NewCGRConfigFromPath(trsPathIn) if err != nil { t.Fatal(err) } - trsPathOut = path.Join(*dataDir, "conf", "samples", "tutmysql") + trsPathOut = path.Join(*utils.DataDir, "conf", "samples", "tutmysql") trsCfgOut, err = config.NewCGRConfigFromPath(trsPathOut) if err != nil { t.Fatal(err) @@ -107,12 +107,12 @@ func TestThresholdsITMove(t *testing.T) { func TestThresholdsITMoveEncoding(t *testing.T) { var err error - trsPathIn = path.Join(*dataDir, "conf", "samples", "tutmongo") + trsPathIn = path.Join(*utils.DataDir, "conf", "samples", "tutmongo") trsCfgIn, err = config.NewCGRConfigFromPath(trsPathIn) if err != nil { t.Fatal(err) } - trsPathOut = path.Join(*dataDir, "conf", "samples", "tutmongojson") + trsPathOut = path.Join(*utils.DataDir, "conf", "samples", "tutmongojson") trsCfgOut, err = config.NewCGRConfigFromPath(trsPathOut) if err != nil { t.Fatal(err) @@ -126,12 +126,12 @@ func TestThresholdsITMoveEncoding(t *testing.T) { func TestThresholdsITMoveEncoding2(t *testing.T) { var err error - trsPathIn = path.Join(*dataDir, "conf", "samples", "tutmysql") + trsPathIn = path.Join(*utils.DataDir, "conf", "samples", "tutmysql") trsCfgIn, err = config.NewCGRConfigFromPath(trsPathIn) if err != nil { t.Fatal(err) } - trsPathOut = path.Join(*dataDir, "conf", "samples", "tutmysqljson") + trsPathOut = path.Join(*utils.DataDir, "conf", "samples", "tutmysqljson") trsCfgOut, err = config.NewCGRConfigFromPath(trsPathOut) if err != nil { t.Fatal(err) diff --git a/migrator/tp_account_actions_it_test.go b/migrator/tp_account_actions_it_test.go index 6bce18055..140f31fd7 100644 --- a/migrator/tp_account_actions_it_test.go +++ b/migrator/tp_account_actions_it_test.go @@ -58,12 +58,12 @@ func TestTpAccActMove(t *testing.T) { func testTpAccActITConnect(t *testing.T) { var err error - tpAccActPathIn = path.Join(*dataDir, "conf", "samples", "tutmongo") + tpAccActPathIn = path.Join(*utils.DataDir, "conf", "samples", "tutmongo") tpAccActCfgIn, err = config.NewCGRConfigFromPath(tpAccActPathIn) if err != nil { t.Fatal(err) } - tpAccActPathOut = path.Join(*dataDir, "conf", "samples", "tutmysql") + tpAccActPathOut = path.Join(*utils.DataDir, "conf", "samples", "tutmysql") tpAccActCfgOut, err = config.NewCGRConfigFromPath(tpAccActPathOut) if err != nil { t.Fatal(err) diff --git a/migrator/tp_action_plans_it_test.go b/migrator/tp_action_plans_it_test.go index 1796cc679..699f63733 100644 --- a/migrator/tp_action_plans_it_test.go +++ b/migrator/tp_action_plans_it_test.go @@ -58,12 +58,12 @@ func TestTpActPlnMove(t *testing.T) { func testTpActPlnITConnect(t *testing.T) { var err error - tpActPlnPathIn = path.Join(*dataDir, "conf", "samples", "tutmongo") + tpActPlnPathIn = path.Join(*utils.DataDir, "conf", "samples", "tutmongo") tpActPlnCfgIn, err = config.NewCGRConfigFromPath(tpActPlnPathIn) if err != nil { t.Fatal(err) } - tpActPlnPathOut = path.Join(*dataDir, "conf", "samples", "tutmysql") + tpActPlnPathOut = path.Join(*utils.DataDir, "conf", "samples", "tutmysql") tpActPlnCfgOut, err = config.NewCGRConfigFromPath(tpActPlnPathOut) if err != nil { t.Fatal(err) diff --git a/migrator/tp_action_triggers_it_test.go b/migrator/tp_action_triggers_it_test.go index 0b8746e21..40ddeb044 100644 --- a/migrator/tp_action_triggers_it_test.go +++ b/migrator/tp_action_triggers_it_test.go @@ -58,12 +58,12 @@ func TestTpActTrgMove(t *testing.T) { func testTpActTrgITConnect(t *testing.T) { var err error - tpActTrgPathIn = path.Join(*dataDir, "conf", "samples", "tutmongo") + tpActTrgPathIn = path.Join(*utils.DataDir, "conf", "samples", "tutmongo") tpActTrgCfgIn, err = config.NewCGRConfigFromPath(tpActTrgPathIn) if err != nil { t.Fatal(err) } - tpActTrgPathOut = path.Join(*dataDir, "conf", "samples", "tutmysql") + tpActTrgPathOut = path.Join(*utils.DataDir, "conf", "samples", "tutmysql") tpActTrgCfgOut, err = config.NewCGRConfigFromPath(tpActTrgPathOut) if err != nil { t.Fatal(err) diff --git a/migrator/tp_actions_it_test.go b/migrator/tp_actions_it_test.go index b2ab9ebb5..a4fff1c6c 100644 --- a/migrator/tp_actions_it_test.go +++ b/migrator/tp_actions_it_test.go @@ -58,12 +58,12 @@ func TestTpActMove(t *testing.T) { func testTpActITConnect(t *testing.T) { var err error - tpActPathIn = path.Join(*dataDir, "conf", "samples", "tutmongo") + tpActPathIn = path.Join(*utils.DataDir, "conf", "samples", "tutmongo") tpActCfgIn, err = config.NewCGRConfigFromPath(tpActPathIn) if err != nil { t.Fatal(err) } - tpActPathOut = path.Join(*dataDir, "conf", "samples", "tutmysql") + tpActPathOut = path.Join(*utils.DataDir, "conf", "samples", "tutmysql") tpActCfgOut, err = config.NewCGRConfigFromPath(tpActPathOut) if err != nil { t.Fatal(err) diff --git a/migrator/tp_destination_rates_it_test.go b/migrator/tp_destination_rates_it_test.go index 19413d184..b0903064b 100644 --- a/migrator/tp_destination_rates_it_test.go +++ b/migrator/tp_destination_rates_it_test.go @@ -58,12 +58,12 @@ func TestTpDstRtMove(t *testing.T) { func testTpDstRtITConnect(t *testing.T) { var err error - tpDstRtPathIn = path.Join(*dataDir, "conf", "samples", "tutmongo") + tpDstRtPathIn = path.Join(*utils.DataDir, "conf", "samples", "tutmongo") tpDstRtCfgIn, err = config.NewCGRConfigFromPath(tpDstRtPathIn) if err != nil { t.Fatal(err) } - tpDstRtPathOut = path.Join(*dataDir, "conf", "samples", "tutmysql") + tpDstRtPathOut = path.Join(*utils.DataDir, "conf", "samples", "tutmysql") tpDstRtCfgOut, err = config.NewCGRConfigFromPath(tpDstRtPathOut) if err != nil { t.Fatal(err) diff --git a/migrator/tp_destinations_it_test.go b/migrator/tp_destinations_it_test.go index 133b4d875..c72bf71bc 100644 --- a/migrator/tp_destinations_it_test.go +++ b/migrator/tp_destinations_it_test.go @@ -58,12 +58,12 @@ func TestTpDstMove(t *testing.T) { func testTpDstITConnect(t *testing.T) { var err error - tpDstPathIn = path.Join(*dataDir, "conf", "samples", "tutmongo") + tpDstPathIn = path.Join(*utils.DataDir, "conf", "samples", "tutmongo") tpDstCfgIn, err = config.NewCGRConfigFromPath(tpDstPathIn) if err != nil { t.Fatal(err) } - tpDstPathOut = path.Join(*dataDir, "conf", "samples", "tutmysql") + tpDstPathOut = path.Join(*utils.DataDir, "conf", "samples", "tutmysql") tpDstCfgOut, err = config.NewCGRConfigFromPath(tpDstPathOut) if err != nil { t.Fatal(err) diff --git a/migrator/tp_dispatchers_it_test.go b/migrator/tp_dispatchers_it_test.go index 23ad354b3..cf8ee1076 100644 --- a/migrator/tp_dispatchers_it_test.go +++ b/migrator/tp_dispatchers_it_test.go @@ -58,12 +58,12 @@ func TestTpDispMove(t *testing.T) { func testTpDispITConnect(t *testing.T) { var err error - tpDispPathIn = path.Join(*dataDir, "conf", "samples", "tutmongo") + tpDispPathIn = path.Join(*utils.DataDir, "conf", "samples", "tutmongo") tpDispCfgIn, err = config.NewCGRConfigFromPath(tpDispPathIn) if err != nil { t.Fatal(err) } - tpDispPathOut = path.Join(*dataDir, "conf", "samples", "tutmysql") + tpDispPathOut = path.Join(*utils.DataDir, "conf", "samples", "tutmysql") tpDispCfgOut, err = config.NewCGRConfigFromPath(tpDispPathOut) if err != nil { t.Fatal(err) diff --git a/migrator/tp_filters_it_test.go b/migrator/tp_filters_it_test.go index bcad55812..9588163f1 100644 --- a/migrator/tp_filters_it_test.go +++ b/migrator/tp_filters_it_test.go @@ -58,12 +58,12 @@ func TestTpFltrMove(t *testing.T) { func testTpFltrITConnect(t *testing.T) { var err error - tpFltrPathIn = path.Join(*dataDir, "conf", "samples", "tutmongo") + tpFltrPathIn = path.Join(*utils.DataDir, "conf", "samples", "tutmongo") tpFltrCfgIn, err = config.NewCGRConfigFromPath(tpFltrPathIn) if err != nil { t.Fatal(err) } - tpFltrPathOut = path.Join(*dataDir, "conf", "samples", "tutmysql") + tpFltrPathOut = path.Join(*utils.DataDir, "conf", "samples", "tutmysql") tpFltrCfgOut, err = config.NewCGRConfigFromPath(tpFltrPathOut) if err != nil { t.Fatal(err) diff --git a/migrator/tp_rates_it_test.go b/migrator/tp_rates_it_test.go index 581239669..2219dffad 100644 --- a/migrator/tp_rates_it_test.go +++ b/migrator/tp_rates_it_test.go @@ -58,12 +58,12 @@ func TestTpRatesMove(t *testing.T) { func testTpRatesITConnect(t *testing.T) { var err error - tpRatesPathIn = path.Join(*dataDir, "conf", "samples", "tutmongo") + tpRatesPathIn = path.Join(*utils.DataDir, "conf", "samples", "tutmongo") tpRatesCfgIn, err = config.NewCGRConfigFromPath(tpRatesPathIn) if err != nil { t.Fatal(err) } - tpRatesPathOut = path.Join(*dataDir, "conf", "samples", "tutmysql") + tpRatesPathOut = path.Join(*utils.DataDir, "conf", "samples", "tutmysql") tpRatesCfgOut, err = config.NewCGRConfigFromPath(tpRatesPathOut) if err != nil { t.Fatal(err) diff --git a/migrator/tp_rating_plans_it_test.go b/migrator/tp_rating_plans_it_test.go index a2bb59830..7177d5f09 100644 --- a/migrator/tp_rating_plans_it_test.go +++ b/migrator/tp_rating_plans_it_test.go @@ -58,12 +58,12 @@ func TestTpRatPlnMove(t *testing.T) { func testTpRatPlnITConnect(t *testing.T) { var err error - tpRatPlnPathIn = path.Join(*dataDir, "conf", "samples", "tutmongo") + tpRatPlnPathIn = path.Join(*utils.DataDir, "conf", "samples", "tutmongo") tpRatPlnCfgIn, err = config.NewCGRConfigFromPath(tpRatPlnPathIn) if err != nil { t.Fatal(err) } - tpRatPlnPathOut = path.Join(*dataDir, "conf", "samples", "tutmysql") + tpRatPlnPathOut = path.Join(*utils.DataDir, "conf", "samples", "tutmysql") tpRatPlnCfgOut, err = config.NewCGRConfigFromPath(tpRatPlnPathOut) if err != nil { t.Fatal(err) diff --git a/migrator/tp_rating_profiles_it_test.go b/migrator/tp_rating_profiles_it_test.go index 0578e36fc..4b371fa13 100644 --- a/migrator/tp_rating_profiles_it_test.go +++ b/migrator/tp_rating_profiles_it_test.go @@ -58,12 +58,12 @@ func TestTpRatPrfMove(t *testing.T) { func testTpRatPrfITConnect(t *testing.T) { var err error - tpRatPrfPathIn = path.Join(*dataDir, "conf", "samples", "tutmongo") + tpRatPrfPathIn = path.Join(*utils.DataDir, "conf", "samples", "tutmongo") tpRatPrfCfgIn, err = config.NewCGRConfigFromPath(tpRatPrfPathIn) if err != nil { t.Fatal(err) } - tpRatPrfPathOut = path.Join(*dataDir, "conf", "samples", "tutmysql") + tpRatPrfPathOut = path.Join(*utils.DataDir, "conf", "samples", "tutmysql") tpRatPrfCfgOut, err = config.NewCGRConfigFromPath(tpRatPrfPathOut) if err != nil { t.Fatal(err) diff --git a/migrator/tp_resources_it_test.go b/migrator/tp_resources_it_test.go index b239de554..fb09763db 100644 --- a/migrator/tp_resources_it_test.go +++ b/migrator/tp_resources_it_test.go @@ -59,12 +59,12 @@ func TestTpResMove(t *testing.T) { func testTpResITConnect(t *testing.T) { var err error - tpResPathIn = path.Join(*dataDir, "conf", "samples", "tutmongo") + tpResPathIn = path.Join(*utils.DataDir, "conf", "samples", "tutmongo") tpResCfgIn, err = config.NewCGRConfigFromPath(tpResPathIn) if err != nil { t.Fatal(err) } - tpResPathOut = path.Join(*dataDir, "conf", "samples", "tutmysql") + tpResPathOut = path.Join(*utils.DataDir, "conf", "samples", "tutmysql") tpResCfgOut, err = config.NewCGRConfigFromPath(tpResPathOut) if err != nil { t.Fatal(err) diff --git a/migrator/tp_routes_it_test.go b/migrator/tp_routes_it_test.go index ea1a8b434..fcf647fb0 100644 --- a/migrator/tp_routes_it_test.go +++ b/migrator/tp_routes_it_test.go @@ -59,12 +59,12 @@ func TestTpSplMove(t *testing.T) { func testTpSplITConnect(t *testing.T) { var err error - tpSplPathIn = path.Join(*dataDir, "conf", "samples", "tutmongo") + tpSplPathIn = path.Join(*utils.DataDir, "conf", "samples", "tutmongo") tpSplCfgIn, err = config.NewCGRConfigFromPath(tpSplPathIn) if err != nil { t.Fatal(err) } - tpSplPathOut = path.Join(*dataDir, "conf", "samples", "tutmysql") + tpSplPathOut = path.Join(*utils.DataDir, "conf", "samples", "tutmysql") tpSplCfgOut, err = config.NewCGRConfigFromPath(tpSplPathOut) if err != nil { t.Fatal(err) diff --git a/migrator/tp_shared_groups_it_test.go b/migrator/tp_shared_groups_it_test.go index 280440140..503475d55 100644 --- a/migrator/tp_shared_groups_it_test.go +++ b/migrator/tp_shared_groups_it_test.go @@ -58,12 +58,12 @@ func TestTpShrGrMove(t *testing.T) { func testTpShrGrITConnect(t *testing.T) { var err error - tpShrGrPathIn = path.Join(*dataDir, "conf", "samples", "tutmongo") + tpShrGrPathIn = path.Join(*utils.DataDir, "conf", "samples", "tutmongo") tpShrGrCfgIn, err = config.NewCGRConfigFromPath(tpShrGrPathIn) if err != nil { t.Fatal(err) } - tpShrGrPathOut = path.Join(*dataDir, "conf", "samples", "tutmysql") + tpShrGrPathOut = path.Join(*utils.DataDir, "conf", "samples", "tutmysql") tpShrGrCfgOut, err = config.NewCGRConfigFromPath(tpShrGrPathOut) if err != nil { t.Fatal(err) diff --git a/migrator/tp_stats_it_test.go b/migrator/tp_stats_it_test.go index cfa196d2c..b46095cda 100644 --- a/migrator/tp_stats_it_test.go +++ b/migrator/tp_stats_it_test.go @@ -58,12 +58,12 @@ func TestTpStatsMove(t *testing.T) { func testTpStatsITConnect(t *testing.T) { var err error - tpStatsPathIn = path.Join(*dataDir, "conf", "samples", "tutmongo") + tpStatsPathIn = path.Join(*utils.DataDir, "conf", "samples", "tutmongo") tpStatsCfgIn, err = config.NewCGRConfigFromPath(tpStatsPathIn) if err != nil { t.Fatal(err) } - tpStatsPathOut = path.Join(*dataDir, "conf", "samples", "tutmysql") + tpStatsPathOut = path.Join(*utils.DataDir, "conf", "samples", "tutmysql") tpStatsCfgOut, err = config.NewCGRConfigFromPath(tpStatsPathOut) if err != nil { t.Fatal(err) diff --git a/migrator/tp_thresholds_it_test.go b/migrator/tp_thresholds_it_test.go index 77c2a3ea1..ba7e207d0 100644 --- a/migrator/tp_thresholds_it_test.go +++ b/migrator/tp_thresholds_it_test.go @@ -59,12 +59,12 @@ func TestTpTresMove(t *testing.T) { func testTpTresITConnect(t *testing.T) { var err error - tpTresPathIn = path.Join(*dataDir, "conf", "samples", "tutmongo") + tpTresPathIn = path.Join(*utils.DataDir, "conf", "samples", "tutmongo") tpTresCfgIn, err = config.NewCGRConfigFromPath(tpTresPathIn) if err != nil { t.Fatal(err) } - tpTresPathOut = path.Join(*dataDir, "conf", "samples", "tutmysql") + tpTresPathOut = path.Join(*utils.DataDir, "conf", "samples", "tutmysql") tpTresCfgOut, err = config.NewCGRConfigFromPath(tpTresPathOut) if err != nil { t.Fatal(err) diff --git a/migrator/tp_timings_it_test.go b/migrator/tp_timings_it_test.go index 91ff1d07d..350cea94b 100644 --- a/migrator/tp_timings_it_test.go +++ b/migrator/tp_timings_it_test.go @@ -58,12 +58,12 @@ func TestTpTimMove(t *testing.T) { func testTpTimITConnect(t *testing.T) { var err error - tpTimPathIn = path.Join(*dataDir, "conf", "samples", "tutmongo") + tpTimPathIn = path.Join(*utils.DataDir, "conf", "samples", "tutmongo") tpTimCfgIn, err = config.NewCGRConfigFromPath(tpTimPathIn) if err != nil { t.Fatal(err) } - tpTimPathOut = path.Join(*dataDir, "conf", "samples", "tutmysql") + tpTimPathOut = path.Join(*utils.DataDir, "conf", "samples", "tutmysql") tpTimCfgOut, err = config.NewCGRConfigFromPath(tpTimPathOut) if err != nil { t.Fatal(err) diff --git a/migrator/user_it_test.go b/migrator/user_it_test.go index 1414f6c51..b8b4c62e0 100644 --- a/migrator/user_it_test.go +++ b/migrator/user_it_test.go @@ -46,18 +46,18 @@ var sTestsUsrIT = []func(t *testing.T){ } func TestUserMigrateITRedis(t *testing.T) { - inPath := path.Join(*dataDir, "conf", "samples", "tutmysql") + inPath := path.Join(*utils.DataDir, "conf", "samples", "tutmysql") testUsrStart("TestUserMigrateITRedis", inPath, inPath, t) } func TestUserMigrateITMongo(t *testing.T) { - inPath := path.Join(*dataDir, "conf", "samples", "tutmongo") + inPath := path.Join(*utils.DataDir, "conf", "samples", "tutmongo") testUsrStart("TestUserMigrateITMongo", inPath, inPath, t) } func TestUserITMigrateMongo2Redis(t *testing.T) { - inPath := path.Join(*dataDir, "conf", "samples", "tutmongo") - outPath := path.Join(*dataDir, "conf", "samples", "tutmysql") + inPath := path.Join(*utils.DataDir, "conf", "samples", "tutmongo") + outPath := path.Join(*utils.DataDir, "conf", "samples", "tutmysql") testUsrStart("TestUserITMigrateMongo2Redis", inPath, outPath, t) } diff --git a/migrator/versions_it_test.go b/migrator/versions_it_test.go index 758c21df4..0bd1a550b 100644 --- a/migrator/versions_it_test.go +++ b/migrator/versions_it_test.go @@ -46,7 +46,7 @@ var sTestsVrsIT = []func(t *testing.T){ func TestVersionITRedis(t *testing.T) { var err error - vrsPath = path.Join(*dataDir, "conf", "samples", "tutmysql") + vrsPath = path.Join(*utils.DataDir, "conf", "samples", "tutmysql") vrsCfg, err = config.NewCGRConfigFromPath(vrsPath) if err != nil { t.Fatal(err) @@ -60,7 +60,7 @@ func TestVersionITRedis(t *testing.T) { func TestVersionITMongo(t *testing.T) { var err error - vrsPath = path.Join(*dataDir, "conf", "samples", "tutmongo") + vrsPath = path.Join(*utils.DataDir, "conf", "samples", "tutmongo") vrsCfg, err = config.NewCGRConfigFromPath(vrsPath) if err != nil { t.Fatal(err) diff --git a/registrarc/lib_test.go b/registrarc/lib_test.go index c99378ff5..335cc8f85 100644 --- a/registrarc/lib_test.go +++ b/registrarc/lib_test.go @@ -19,7 +19,6 @@ package registrarc import ( "errors" - "flag" "github.com/cgrates/birpc" "github.com/cgrates/birpc/jsonrpc" @@ -27,15 +26,8 @@ import ( "github.com/cgrates/cgrates/utils" ) -var ( - dataDir = flag.String("data_dir", "/usr/share/cgrates", "CGR data dir path here") - waitRater = flag.Int("wait_rater", 100, "Number of milliseconds to wait for rater to start and cache") - encoding = flag.String("rpc", utils.MetaJSON, "what encoding would be used for rpc communication") - dbType = flag.String("dbtype", utils.MetaInternal, "The type of DataBase (Internal/Mongo/mySql)") -) - func newRPCClient(cfg *config.ListenCfg) (c *birpc.Client, err error) { - switch *encoding { + switch *utils.Encoding { case utils.MetaJSON: return jsonrpc.Dial(utils.TCP, cfg.RPCJSONListen) case utils.MetaGOB: diff --git a/registrarc/registarc_defaultid_it_test.go b/registrarc/registarc_defaultid_it_test.go index 1a405b47d..5c735a8a5 100644 --- a/registrarc/registarc_defaultid_it_test.go +++ b/registrarc/registarc_defaultid_it_test.go @@ -39,7 +39,7 @@ var ( ) func TestDspNodeHosts(t *testing.T) { - switch *dbType { + switch *utils.DBType { case utils.MetaMySQL: node1Dir = "registrarc_node_id" dspNodeDir = "registrars_node_id" @@ -54,8 +54,8 @@ func TestDspNodeHosts(t *testing.T) { } func testDsphNodeInitCfg(t *testing.T) { - dspNodeCfgPath = path.Join(*dataDir, "conf", "samples", "registrarc", dspNodeDir) - node1CfgPath = path.Join(*dataDir, "conf", "samples", "registrarc", node1Dir) + dspNodeCfgPath = path.Join(*utils.DataDir, "conf", "samples", "registrarc", dspNodeDir) + node1CfgPath = path.Join(*utils.DataDir, "conf", "samples", "registrarc", node1Dir) var err error if dspNodeCfg, err = config.NewCGRConfigFromPath(dspNodeCfgPath); err != nil { t.Error(err) @@ -73,7 +73,7 @@ func testDsphNodeInitDB(t *testing.T) { func testDsphNodeStartEngine(t *testing.T) { var err error - if dspNodeCmd, err = engine.StopStartEngine(dspNodeCfgPath, *waitRater); err != nil { + if dspNodeCmd, err = engine.StopStartEngine(dspNodeCfgPath, *utils.WaitRater); err != nil { t.Fatal(err) } dspNodeRPC, err = newRPCClient(dspNodeCfg.ListenCfg()) // We connect over JSON so we can also troubleshoot if needed @@ -83,7 +83,7 @@ func testDsphNodeStartEngine(t *testing.T) { } func testDsphNodeLoadData(t *testing.T) { - loader := exec.Command("cgr-loader", "-config_path", dspNodeCfgPath, "-path", path.Join(*dataDir, "tariffplans", "registrarc2"), "-caches_address=") + loader := exec.Command("cgr-loader", "-config_path", dspNodeCfgPath, "-path", path.Join(*utils.DataDir, "tariffplans", "registrarc2"), "-caches_address=") output := bytes.NewBuffer(nil) outerr := bytes.NewBuffer(nil) loader.Stdout = output @@ -115,7 +115,7 @@ func testDsphNodeBeforeDsphStart(t *testing.T) { func testDsphNodeStartAll(t *testing.T) { var err error - if node1Cmd, err = engine.StartEngine(node1CfgPath, *waitRater); err != nil { + if node1Cmd, err = engine.StartEngine(node1CfgPath, *utils.WaitRater); err != nil { t.Fatal(err) } if nodeID, err := testDsphNodeGetNodeID(); err != nil { @@ -137,7 +137,7 @@ func testDsphNodeStopEngines(t *testing.T) { } func testDsphNodeStopDispatcher(t *testing.T) { - if err := engine.KillEngine(*waitRater); err != nil { + if err := engine.KillEngine(*utils.WaitRater); err != nil { t.Error(err) } } diff --git a/registrarc/registrarc_it_test.go b/registrarc/registrarc_it_test.go index c39191414..5c632c93e 100644 --- a/registrarc/registrarc_it_test.go +++ b/registrarc/registrarc_it_test.go @@ -65,7 +65,7 @@ var ( ) func TestDspHosts(t *testing.T) { - switch *dbType { + switch *utils.DBType { case utils.MetaMySQL: allDir = "all_mysql" all2Dir = "all2_mysql" @@ -85,9 +85,9 @@ func TestDspHosts(t *testing.T) { } func testDsphInitCfg(t *testing.T) { - dspCfgPath = path.Join(*dataDir, "conf", "samples", "registrarc", dspDir) - allCfgPath = path.Join(*dataDir, "conf", "samples", "registrarc", allDir) - all2CfgPath = path.Join(*dataDir, "conf", "samples", "registrarc", all2Dir) + dspCfgPath = path.Join(*utils.DataDir, "conf", "samples", "registrarc", dspDir) + allCfgPath = path.Join(*utils.DataDir, "conf", "samples", "registrarc", allDir) + all2CfgPath = path.Join(*utils.DataDir, "conf", "samples", "registrarc", all2Dir) var err error if dspCfg, err = config.NewCGRConfigFromPath(dspCfgPath); err != nil { t.Error(err) @@ -105,7 +105,7 @@ func testDsphInitDB(t *testing.T) { func testDsphStartEngine(t *testing.T) { var err error - if dspCmd, err = engine.StopStartEngine(dspCfgPath, *waitRater); err != nil { + if dspCmd, err = engine.StopStartEngine(dspCfgPath, *utils.WaitRater); err != nil { t.Fatal(err) } dspRPC, err = newRPCClient(dspCfg.ListenCfg()) // We connect over JSON so we can also troubleshoot if needed @@ -115,7 +115,7 @@ func testDsphStartEngine(t *testing.T) { } func testDsphLoadData(t *testing.T) { - loader := exec.Command("cgr-loader", "-config_path", dspCfgPath, "-path", path.Join(*dataDir, "tariffplans", "registrarc"), "-caches_address=") + loader := exec.Command("cgr-loader", "-config_path", dspCfgPath, "-path", path.Join(*utils.DataDir, "tariffplans", "registrarc"), "-caches_address=") output := bytes.NewBuffer(nil) outerr := bytes.NewBuffer(nil) loader.Stdout = output @@ -147,7 +147,7 @@ func testDsphBeforeDsphStart(t *testing.T) { func testDsphStartAll2(t *testing.T) { var err error - if all2Cmd, err = engine.StartEngine(all2CfgPath, *waitRater); err != nil { + if all2Cmd, err = engine.StartEngine(all2CfgPath, *utils.WaitRater); err != nil { t.Fatal(err) } if nodeID, err := testDsphGetNodeID(); err != nil { @@ -159,7 +159,7 @@ func testDsphStartAll2(t *testing.T) { func testDsphStartAll(t *testing.T) { var err error - if allCmd, err = engine.StartEngine(allCfgPath, *waitRater); err != nil { + if allCmd, err = engine.StartEngine(allCfgPath, *utils.WaitRater); err != nil { t.Fatal(err) } if nodeID, err := testDsphGetNodeID(); err != nil { @@ -183,7 +183,7 @@ func testDsphStopEngines(t *testing.T) { } func testDsphStopDispatcher(t *testing.T) { - if err := engine.KillEngine(*waitRater); err != nil { + if err := engine.KillEngine(*utils.WaitRater); err != nil { t.Error(err) } } diff --git a/registrarc/registrarcrpc_it_test.go b/registrarc/registrarcrpc_it_test.go index 7b38cc6c0..fc8e3f2c7 100644 --- a/registrarc/registrarcrpc_it_test.go +++ b/registrarc/registrarcrpc_it_test.go @@ -64,7 +64,7 @@ var ( ) func TestRPCHosts(t *testing.T) { - switch *dbType { + switch *utils.DBType { case utils.MetaMySQL: rpcDir = "registrarc_rpc_mysql" rpcsDir = "registrars_rpc_mysql" @@ -82,8 +82,8 @@ func TestRPCHosts(t *testing.T) { } func testRPCInitCfg(t *testing.T) { - rpcCfgPath = path.Join(*dataDir, "conf", "samples", "registrarc", rpcDir) - rpcsCfgPath = path.Join(*dataDir, "conf", "samples", "registrarc", rpcsDir) + rpcCfgPath = path.Join(*utils.DataDir, "conf", "samples", "registrarc", rpcDir) + rpcsCfgPath = path.Join(*utils.DataDir, "conf", "samples", "registrarc", rpcsDir) var err error if rpcsCfg, err = config.NewCGRConfigFromPath(rpcsCfgPath); err != nil { t.Error(err) @@ -101,7 +101,7 @@ func testRPCInitDB(t *testing.T) { func testRPCStartEngine(t *testing.T) { var err error - if _, err = engine.StopStartEngine(rpcsCfgPath, *waitRater); err != nil { + if _, err = engine.StopStartEngine(rpcsCfgPath, *utils.WaitRater); err != nil { t.Fatal(err) } rpcsRPC, err = newRPCClient(rpcsCfg.ListenCfg()) @@ -112,7 +112,7 @@ func testRPCStartEngine(t *testing.T) { func testRPCLoadData(t *testing.T) { var reply string - attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*dataDir, "tariffplans", "testit")} + attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*utils.DataDir, "tariffplans", "testit")} if err := rpcsRPC.Call(context.Background(), utils.APIerSv1LoadTariffPlanFromFolder, attrs, &reply); err != nil { t.Error(err) } @@ -136,7 +136,7 @@ func testRPCChargerSNoAttr(t *testing.T) { func testRPCStartRegc(t *testing.T) { var err error - if rpcCMD, err = engine.StartEngine(rpcCfgPath, *waitRater); err != nil { + if rpcCMD, err = engine.StartEngine(rpcCfgPath, *utils.WaitRater); err != nil { t.Fatal(err) } time.Sleep(time.Second) @@ -222,7 +222,7 @@ func testRPCStopEngines(t *testing.T) { } func testRPCStopRegs(t *testing.T) { - if err := engine.KillEngine(*waitRater); err != nil { + if err := engine.KillEngine(*utils.WaitRater); err != nil { t.Error(err) } } diff --git a/sessions/lib_test.go b/sessions/lib_test.go index 761019364..6964e8848 100644 --- a/sessions/lib_test.go +++ b/sessions/lib_test.go @@ -20,7 +20,6 @@ package sessions import ( "errors" - "flag" "github.com/cgrates/birpc" "github.com/cgrates/birpc/jsonrpc" @@ -28,15 +27,8 @@ import ( "github.com/cgrates/cgrates/utils" ) -var ( - dataDir = flag.String("data_dir", "/usr/share/cgrates", "CGR data dir path here") - waitRater = flag.Int("wait_rater", 500, "Number of miliseconds to wait for rater to start and cache") - encoding = flag.String("rpc", utils.MetaJSON, "what encoding whould be uused for rpc comunication") - dbType = flag.String("dbtype", utils.MetaInternal, "The type of DataBase (Internal/Mongo/mySql)") -) - func newRPCClient(cfg *config.ListenCfg) (c *birpc.Client, err error) { - switch *encoding { + switch *utils.Encoding { case utils.MetaJSON: return jsonrpc.Dial(utils.TCP, cfg.RPCJSONListen) case utils.MetaGOB: diff --git a/sessions/sessions_bench_test.go b/sessions/sessions_bench_test.go index cddd75516..6ca6e880b 100644 --- a/sessions/sessions_bench_test.go +++ b/sessions/sessions_bench_test.go @@ -50,7 +50,7 @@ var ( func startRPC() { var err error sBenchCfg, err = config.NewCGRConfigFromPath( - path.Join(*dataDir, "conf", "samples", "tutmongo")) + path.Join(*utils.DataDir, "conf", "samples", "tutmongo")) if err != nil { log.Fatal(err) } @@ -67,7 +67,7 @@ func loadTP() { log.Fatal(err) } attrs := &utils.AttrLoadTpFromFolder{ - FolderPath: path.Join(*dataDir, "tariffplans", "tutorial")} + FolderPath: path.Join(*utils.DataDir, "tariffplans", "tutorial")} var tpLoadInst utils.LoadInstance if err := sBenchRPC.Call(context.Background(), utils.APIerSv2LoadTariffPlanFromFolder, attrs, &tpLoadInst); err != nil { @@ -195,7 +195,7 @@ func BenchmarkEncodingJSON(b *testing.B) { } var err error sBenchCfg, err = config.NewCGRConfigFromPath( - path.Join(*dataDir, "conf", "samples", "tutmongo")) + path.Join(*utils.DataDir, "conf", "samples", "tutmongo")) if err != nil { log.Fatal(err) } @@ -217,7 +217,7 @@ func BenchmarkEncodingGOB(b *testing.B) { } var err error sBenchCfg, err = config.NewCGRConfigFromPath( - path.Join(*dataDir, "conf", "samples", "tutmongo")) + path.Join(*utils.DataDir, "conf", "samples", "tutmongo")) if err != nil { log.Fatal(err) } diff --git a/sessions/sessions_birpc_it_test.go b/sessions/sessions_birpc_it_test.go index e0f0da31c..150e3fe84 100644 --- a/sessions/sessions_birpc_it_test.go +++ b/sessions/sessions_birpc_it_test.go @@ -55,7 +55,7 @@ var ( // Tests starts here func TestSessionsBiRPC(t *testing.T) { - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: sessionsBiRPCCfgDIR = "smg_automatic_debits_internal" case utils.MetaMySQL: @@ -82,7 +82,7 @@ func (*smock) DisconnectSession(ctx *context.Context, } func testSessionsBiRPCInitCfg(t *testing.T) { - sessionsBiRPCCfgPath = path.Join(*dataDir, "conf", "samples", sessionsBiRPCCfgDIR) + sessionsBiRPCCfgPath = path.Join(*utils.DataDir, "conf", "samples", sessionsBiRPCCfgDIR) // Init config first sessionsBiRPCCfg, err = config.NewCGRConfigFromPath(sessionsBiRPCCfgPath) if err != nil { @@ -106,7 +106,7 @@ func testSessionsBiRPCResetStorDb(t *testing.T) { // Start CGR Engine func testSessionsBiRPCStartEngine(t *testing.T) { - if _, err := engine.StopStartEngine(sessionsBiRPCCfgPath, *waitRater); err != nil { + if _, err := engine.StopStartEngine(sessionsBiRPCCfgPath, *utils.WaitRater); err != nil { t.Fatal(err) } } @@ -134,12 +134,12 @@ func testSessionsBiRPCApierRpcConn(t *testing.T) { // Load the tariff plan, creating accounts and their balances func testSessionsBiRPCTPFromFolder(t *testing.T) { - attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*dataDir, "tariffplans", "oldtutorial")} + attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*utils.DataDir, "tariffplans", "oldtutorial")} var loadInst utils.LoadInstance if err := sessionsRPC.Call(context.Background(), utils.APIerSv2LoadTariffPlanFromFolder, attrs, &loadInst); err != nil { t.Error(err) } - time.Sleep(time.Duration(*waitRater) * time.Millisecond) // Give time for scheduler to execute topups + time.Sleep(time.Duration(*utils.WaitRater) * time.Millisecond) // Give time for scheduler to execute topups } func testSessionsBiRPCSessionAutomaticDisconnects(t *testing.T) { @@ -390,7 +390,7 @@ func testSessionsBiRPCStopCgrEngine(t *testing.T) { if err := sessionsBiRPC.Close(); err != nil { // Close the connection so we don't get EOF warnings from client t.Error(err) } - if err := engine.KillEngine(*waitRater); err != nil { + if err := engine.KillEngine(*utils.WaitRater); err != nil { t.Error(err) } } diff --git a/sessions/sessions_data_it_test.go b/sessions/sessions_data_it_test.go index a674d7001..d1283684e 100644 --- a/sessions/sessions_data_it_test.go +++ b/sessions/sessions_data_it_test.go @@ -58,7 +58,7 @@ var ( // Tests starts here func TestSessionsData(t *testing.T) { - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: dataCfgDIR = "sessions_internal" case utils.MetaMySQL: @@ -77,7 +77,7 @@ func TestSessionsData(t *testing.T) { // Init config first func testSessionsDataInitCfg(t *testing.T) { - dataCfgPath = path.Join(*dataDir, "conf", "samples", dataCfgDIR) + dataCfgPath = path.Join(*utils.DataDir, "conf", "samples", dataCfgDIR) var err error dataCfg, err = config.NewCGRConfigFromPath(dataCfgPath) if err != nil { @@ -101,7 +101,7 @@ func testSessionsDataResetStorDb(t *testing.T) { // Start CGR Engine func testSessionsDataStartEngine(t *testing.T) { - if _, err := engine.StopStartEngine(dataCfgPath, *waitRater); err != nil { + if _, err := engine.StopStartEngine(dataCfgPath, *utils.WaitRater); err != nil { t.Fatal(err) } } @@ -117,12 +117,12 @@ func testSessionsDataApierRpcConn(t *testing.T) { // Load the tariff plan, creating accounts and their balances func testSessionsDataTPFromFolder(t *testing.T) { - attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*dataDir, "tariffplans", "oldtutorial")} + attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*utils.DataDir, "tariffplans", "oldtutorial")} var loadInst utils.LoadInstance if err := sDataRPC.Call(context.Background(), utils.APIerSv2LoadTariffPlanFromFolder, attrs, &loadInst); err != nil { t.Error(err) } - time.Sleep(time.Duration(*waitRater) * time.Millisecond) // Give time for scheduler to execute topups + time.Sleep(time.Duration(*utils.WaitRater) * time.Millisecond) // Give time for scheduler to execute topups } func testSessionsDataLastUsedData(t *testing.T) { @@ -926,7 +926,7 @@ func testSessionsDataMultipleDataNoUsage(t *testing.T) { if err := sDataRPC.Call(context.Background(), utils.SessionSv1UpdateSession, updateArgs, &updateRpl); err != nil { t.Fatal(err) } - if *encoding != utils.MetaGOB { + if *utils.Encoding != utils.MetaGOB { if updateRpl.MaxUsage.Nanoseconds() != usage { t.Errorf("Expected: %+v, received: %+v", usage, updateRpl.MaxUsage.Nanoseconds()) } diff --git a/sessions/sessions_it_test.go b/sessions/sessions_it_test.go index 68c8e804c..8531a28c8 100644 --- a/sessions/sessions_it_test.go +++ b/sessions/sessions_it_test.go @@ -55,7 +55,7 @@ var ( ) func TestSessionsIt(t *testing.T) { - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: sItCfgDIR = "sessions_internal" case utils.MetaMySQL: @@ -74,7 +74,7 @@ func TestSessionsIt(t *testing.T) { // Init config firs func testSessionsItInitCfg(t *testing.T) { - sItCfgPath = path.Join(*dataDir, "conf", "samples", sItCfgDIR) + sItCfgPath = path.Join(*utils.DataDir, "conf", "samples", sItCfgDIR) var err error sItCfg, err = config.NewCGRConfigFromPath(sItCfgPath) if err != nil { @@ -98,7 +98,7 @@ func testSessionsItResetStorDb(t *testing.T) { // Start CGR Engine func testSessionsItStartEngine(t *testing.T) { - if _, err := engine.StopStartEngine(sItCfgPath, *waitRater); err != nil { + if _, err := engine.StopStartEngine(sItCfgPath, *utils.WaitRater); err != nil { t.Fatal(err) } } @@ -114,12 +114,12 @@ func testSessionsItApierRpcConn(t *testing.T) { // Load the tariff plan, creating accounts and their balances func testSessionsItTPFromFolder(t *testing.T) { - attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*dataDir, "tariffplans", "tutorial")} + attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*utils.DataDir, "tariffplans", "tutorial")} var loadInst utils.LoadInstance if err := sItRPC.Call(context.Background(), utils.APIerSv2LoadTariffPlanFromFolder, attrs, &loadInst); err != nil { t.Error(err) } - time.Sleep(time.Duration(*waitRater) * time.Millisecond) // Give time for scheduler to execute topups + time.Sleep(time.Duration(*utils.WaitRater) * time.Millisecond) // Give time for scheduler to execute topups } func testSessionsItTerminatNonexist(t *testing.T) { @@ -482,7 +482,7 @@ func testSessionsItEventCostCompressing(t *testing.T) { } func testSessionsItStopCgrEngine(t *testing.T) { - if err := engine.KillEngine(*waitRater); err != nil { + if err := engine.KillEngine(*utils.WaitRater); err != nil { t.Error(err) } } diff --git a/sessions/sessions_rpl_it_test.go b/sessions/sessions_rpl_it_test.go index 6c2b7dc4d..2b952e26a 100644 --- a/sessions/sessions_rpl_it_test.go +++ b/sessions/sessions_rpl_it_test.go @@ -55,7 +55,7 @@ var ( ) func TestSessionSRpl(t *testing.T) { - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: t.SkipNow() case utils.MetaMySQL: @@ -69,21 +69,21 @@ func TestSessionSRpl(t *testing.T) { default: t.Fatal("Unknown Database type") } - if *encoding == utils.MetaGOB { + if *utils.Encoding == utils.MetaGOB { smgRplcMasterCfgDIR += "_gob" smgRplcSlaveCfgDIR += "_gob" } for _, stest := range SessionsRplTests { - t.Run(*dbType, stest) + t.Run(*utils.DBType, stest) } } func testSessionSRplInitCfg(t *testing.T) { - smgRplcMasterCfgPath = path.Join(*dataDir, "conf", "samples", smgRplcMasterCfgDIR) + smgRplcMasterCfgPath = path.Join(*utils.DataDir, "conf", "samples", smgRplcMasterCfgDIR) if smgRplcMasterCfg, err = config.NewCGRConfigFromPath(smgRplcMasterCfgPath); err != nil { t.Fatal(err) } - smgRplcSlaveCfgPath = path.Join(*dataDir, "conf", "samples", smgRplcSlaveCfgDIR) + smgRplcSlaveCfgPath = path.Join(*utils.DataDir, "conf", "samples", smgRplcSlaveCfgDIR) if smgRplcSlaveCfg, err = config.NewCGRConfigFromPath(smgRplcSlaveCfgPath); err != nil { t.Fatal(err) } @@ -101,10 +101,10 @@ func testSessionSRplResetDB(t *testing.T) { // Start CGR Engine func testSessionSRplStartEngine(t *testing.T) { - if _, err := engine.StopStartEngine(smgRplcSlaveCfgPath, *waitRater); err != nil { // Start slave before master + if _, err := engine.StopStartEngine(smgRplcSlaveCfgPath, *utils.WaitRater); err != nil { // Start slave before master t.Fatal(err) } - if _, err := engine.StartEngine(smgRplcMasterCfgPath, *waitRater); err != nil { + if _, err := engine.StartEngine(smgRplcMasterCfgPath, *utils.WaitRater); err != nil { t.Fatal(err) } } @@ -121,12 +121,12 @@ func testSessionSRplApierRpcConn(t *testing.T) { // Load the tariff plan, creating accounts and their balances func testSessionSRplTPFromFolder(t *testing.T) { - attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*dataDir, "tariffplans", "oldtutorial")} + attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*utils.DataDir, "tariffplans", "oldtutorial")} var loadInst utils.LoadInstance if err := smgRplcMstrRPC.Call(context.Background(), utils.APIerSv2LoadTariffPlanFromFolder, attrs, &loadInst); err != nil { t.Error(err) } - time.Sleep(time.Duration(*waitRater) * time.Millisecond) // Give time for scheduler to execute topups + time.Sleep(time.Duration(*utils.WaitRater) * time.Millisecond) // Give time for scheduler to execute topups } func testSessionSRplInitiate(t *testing.T) { @@ -173,7 +173,7 @@ func testSessionSRplInitiate(t *testing.T) { if initRpl.MaxUsage == nil || *initRpl.MaxUsage != usage { t.Errorf("Expecting : %+v, received: %+v", usage, initRpl.MaxUsage) } - time.Sleep(time.Duration(*waitRater) * time.Millisecond) // Wait for the sessions to be populated + time.Sleep(time.Duration(*utils.WaitRater) * time.Millisecond) // Wait for the sessions to be populated //check if the session was createad as active session on master if err := smgRplcMstrRPC.Call(context.Background(), utils.SessionSv1GetActiveSessions, @@ -238,7 +238,7 @@ func testSessionSRplUpdate(t *testing.T) { t.Errorf("Expecting : %+v, received: %+v", usage, updtRpl.MaxUsage) } - time.Sleep(time.Duration(*waitRater) * time.Millisecond) // Wait for the sessions to be populated + time.Sleep(time.Duration(*utils.WaitRater) * time.Millisecond) // Wait for the sessions to be populated var aSessions []*ExternalSession if err := smgRplcSlvRPC.Call(context.Background(), utils.SessionSv1GetActiveSessions, utils.SessionFilter{ @@ -311,7 +311,7 @@ func testSessionSRplTerminate(t *testing.T) { if err := smgRplcMstrRPC.Call(context.Background(), utils.SessionSv1TerminateSession, args, &reply); err != nil { t.Error(err) } - time.Sleep(time.Duration(*waitRater) * time.Millisecond) // Wait for the sessions to be populated + time.Sleep(time.Duration(*utils.WaitRater) * time.Millisecond) // Wait for the sessions to be populated var aSessions []*ExternalSession //check if the session was terminated on master if err := smgRplcMstrRPC.Call(context.Background(), utils.SessionSv1GetActiveSessions, @@ -341,7 +341,7 @@ func testSessionSRplTerminate(t *testing.T) { } func testSessionSRplManualReplicate(t *testing.T) { - masterProc, err := engine.StopStartEngine(smgRplcMasterCfgPath, *waitRater) + masterProc, err := engine.StopStartEngine(smgRplcMasterCfgPath, *utils.WaitRater) if err != nil { // Kill both and start Master t.Fatal(err) } @@ -412,14 +412,14 @@ func testSessionSRplManualReplicate(t *testing.T) { t.Errorf("Received usage: %v", aSessions[0].Usage) } // Start slave, should not have any active session at beginning - slave, err := engine.StartEngine(smgRplcSlaveCfgPath, *waitRater) + slave, err := engine.StartEngine(smgRplcSlaveCfgPath, *utils.WaitRater) if err != nil { t.Fatal(err) } if err := slave.Process.Kill(); err != nil { // restart the slave t.Error(err) } - if _, err := engine.StartEngine(smgRplcSlaveCfgPath, *waitRater); err != nil { + if _, err := engine.StartEngine(smgRplcSlaveCfgPath, *utils.WaitRater); err != nil { t.Fatal(err) } if smgRplcSlvRPC, err = newRPCClient(smgRplcSlaveCfg.ListenCfg()); err != nil { @@ -438,7 +438,7 @@ func testSessionSRplManualReplicate(t *testing.T) { if err := smgRplcMstrRPC.Call(context.Background(), utils.SessionSv1ReplicateSessions, &argsRepl, &repply); err != nil { t.Error(err) } - time.Sleep(time.Duration(*waitRater) * time.Millisecond) // Wait for the sessions to be populated + time.Sleep(time.Duration(*utils.WaitRater) * time.Millisecond) // Wait for the sessions to be populated if err := smgRplcSlvRPC.Call(context.Background(), utils.SessionSv1GetPassiveSessions, new(utils.SessionFilter), &aSessions); err != nil { t.Error(err) } else if len(aSessions) != 2 { @@ -458,7 +458,7 @@ func testSessionSRplManualReplicate(t *testing.T) { t.Error(err) } // start master - if _, err := engine.StartEngine(smgRplcMasterCfgPath, *waitRater); err != nil { + if _, err := engine.StartEngine(smgRplcMasterCfgPath, *utils.WaitRater); err != nil { t.Fatal(err) } if smgRplcMstrRPC, err = newRPCClient(smgRplcMasterCfg.ListenCfg()); err != nil { @@ -479,7 +479,7 @@ func testSessionSRplManualReplicate(t *testing.T) { if err := smgRplcSlvRPC.Call(context.Background(), utils.SessionSv1ReplicateSessions, &argsRepl, &repply); err != nil { t.Error(err) } - time.Sleep(time.Duration(*waitRater) * time.Millisecond) // Wait for the sessions to be populated + time.Sleep(time.Duration(*utils.WaitRater) * time.Millisecond) // Wait for the sessions to be populated // Master should have no session active/passive if err := smgRplcMstrRPC.Call(context.Background(), utils.SessionSv1GetActiveSessions, new(utils.SessionFilter), &aSessions); err == nil || err.Error() != utils.ErrNotFound.Error() { t.Error(err, aSessions) diff --git a/sessions/sessions_voice_it_test.go b/sessions/sessions_voice_it_test.go index e28313ac8..9ebb363de 100644 --- a/sessions/sessions_voice_it_test.go +++ b/sessions/sessions_voice_it_test.go @@ -60,7 +60,7 @@ var ( ) func TestSessionsVoice(t *testing.T) { - switch *dbType { + switch *utils.DBType { case utils.MetaInternal: voiceCfgDIR = "sessions_internal" case utils.MetaMySQL: @@ -78,7 +78,7 @@ func TestSessionsVoice(t *testing.T) { } func testSessionsVoiceInitCfg(t *testing.T) { - voiceCfgPath = path.Join(*dataDir, "conf", "samples", voiceCfgDIR) + voiceCfgPath = path.Join(*utils.DataDir, "conf", "samples", voiceCfgDIR) // Init config first var err error voiceCfg, err = config.NewCGRConfigFromPath(voiceCfgPath) @@ -103,7 +103,7 @@ func testSessionsVoiceResetStorDb(t *testing.T) { // Start CGR Engine func testSessionsVoiceStartEngine(t *testing.T) { - if _, err := engine.StopStartEngine(voiceCfgPath, *waitRater); err != nil { + if _, err := engine.StopStartEngine(voiceCfgPath, *utils.WaitRater); err != nil { t.Fatal(err) } } @@ -119,12 +119,12 @@ func testSessionsVoiceApierRpcConn(t *testing.T) { // Load the tariff plan, creating accounts and their balances func testSessionsVoiceTPFromFolder(t *testing.T) { - attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*dataDir, "tariffplans", "oldtutorial")} + attrs := &utils.AttrLoadTpFromFolder{FolderPath: path.Join(*utils.DataDir, "tariffplans", "oldtutorial")} var loadInst utils.LoadInstance if err := sessionsRPC.Call(context.Background(), utils.APIerSv2LoadTariffPlanFromFolder, attrs, &loadInst); err != nil { t.Error(err) } - time.Sleep(time.Duration(*waitRater) * time.Millisecond) // Give time for scheduler to execute topups + time.Sleep(time.Duration(*utils.WaitRater) * time.Millisecond) // Give time for scheduler to execute topups } func testSessionsVoiceMonetaryRefund(t *testing.T) { diff --git a/utils/testflag.go b/utils/testflag.go new file mode 100644 index 000000000..ab46f63bf --- /dev/null +++ b/utils/testflag.go @@ -0,0 +1,32 @@ +//go:build integration || flaky || offline || kafka || call || race || performance + +/* +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 utils + +import ( + "flag" +) + +var ( + DataDir = flag.String("data_dir", "/usr/share/cgrates", "Path to the CGR data directory.") + WaitRater = flag.Int("wait_rater", 100, "Time (in ms) to wait for rater initialization.") + Encoding = flag.String("rpc", MetaJSON, "Encoding type for RPC communication (e.g., JSON).") + DBType = flag.String("dbtype", MetaInternal, "Type of database (Internal/Mongo/MySQL/Postgres).") +)