From 57d2500a96c8abad1e42ba907cb44e2c1facc4d4 Mon Sep 17 00:00:00 2001 From: porosnicuadrian Date: Mon, 5 Apr 2021 16:09:44 +0300 Subject: [PATCH] Fixed tests for path sanitizations + new cases in config sanity --- apier/v1/attributes_it_test.go | 4 +- apier/v1/chargers_it_test.go | 4 +- apier/v1/dispatcher_it_test.go | 2 +- apier/v1/replicate_it_test.go | 2 +- apier/v1/resourcesv1_it_test.go | 2 +- apier/v1/routes_it_test.go | 2 +- apier/v1/stats_it_test.go | 2 +- apier/v1/thresholds_it_test.go | 4 +- config/configsanity.go | 228 ++++++++++++++++++++++- engine/z_filterindexer_it_test.go | 4 +- general_tests/accountactions_it_test.go | 231 ------------------------ migrator/resource_it_test.go | 2 +- migrator/routes_it_test.go | 2 +- migrator/user_it_test.go | 2 +- sessions/sessions_voice_it_test.go | 2 +- utils/dataprovider.go | 4 +- 16 files changed, 246 insertions(+), 251 deletions(-) delete mode 100644 general_tests/accountactions_it_test.go diff --git a/apier/v1/attributes_it_test.go b/apier/v1/attributes_it_test.go index fc5762bba..7c88342f6 100644 --- a/apier/v1/attributes_it_test.go +++ b/apier/v1/attributes_it_test.go @@ -775,9 +775,9 @@ func testAttributeSSetAlsPrfBrokenReference(t *testing.T) { }, } var result string - expErr := "SERVER_ERROR: broken reference to filter: FLTR_ACNT_danBroken for item with ID: cgrates.org:ApierTest" + expErr := "SERVER_ERROR: broken reference to filter: for item with ID: cgrates.org:ApierTest" if err := attrSRPC.Call(utils.APIerSv1SetAttributeProfile, alsPrf, &result); err == nil || err.Error() != expErr { - t.Fatalf("Expected error: %q, received: %v", expErr, err) + t.Fatalf("Expected error: %q, received: %q", expErr, err) } var reply *engine.AttributeProfile if err := attrSRPC.Call(utils.APIerSv1GetAttributeProfile, diff --git a/apier/v1/chargers_it_test.go b/apier/v1/chargers_it_test.go index 17ee2511a..12915dbfd 100644 --- a/apier/v1/chargers_it_test.go +++ b/apier/v1/chargers_it_test.go @@ -396,7 +396,7 @@ func testChargerSSetChargerProfile(t *testing.T) { }, } var result string - expErr := "SERVER_ERROR: broken reference to filter: *wrong:inline for item with ID: cgrates.org:ApierTest" + expErr := "SERVER_ERROR: broken reference to filter: <*wrong:inline> for item with ID: cgrates.org:ApierTest" if err := chargerRPC.Call(utils.APIerSv1SetChargerProfile, chargerProfile, &result); err == nil || err.Error() != expErr { t.Fatalf("Expected error: %q, received: %v", expErr, err) } @@ -407,7 +407,7 @@ func testChargerSSetChargerProfile(t *testing.T) { t.Fatal(err) } - chargerProfile.FilterIDs = []string{"*string:~*req.Account:1001", "*string:~Account:1002"} + chargerProfile.FilterIDs = []string{"*string:~*req.Account:1001", "*string:~*opts.Account:1002"} if err := chargerRPC.Call(utils.APIerSv1SetChargerProfile, chargerProfile, &result); err != nil { t.Error(err) } else if result != utils.OK { diff --git a/apier/v1/dispatcher_it_test.go b/apier/v1/dispatcher_it_test.go index 4c130d700..5aebdfbdd 100644 --- a/apier/v1/dispatcher_it_test.go +++ b/apier/v1/dispatcher_it_test.go @@ -155,7 +155,7 @@ func testDispatcherSSetDispatcherProfile(t *testing.T) { }, } - expErr := "SERVER_ERROR: broken reference to filter: *wrong:inline for item with ID: cgrates.org:Dsp1" + expErr := "SERVER_ERROR: broken reference to filter: <*wrong:inline> for item with ID: cgrates.org:Dsp1" if err := dispatcherRPC.Call(utils.APIerSv1SetDispatcherProfile, dispatcherProfile, &reply); err == nil || err.Error() != expErr { diff --git a/apier/v1/replicate_it_test.go b/apier/v1/replicate_it_test.go index 6cd90d974..da39f0949 100644 --- a/apier/v1/replicate_it_test.go +++ b/apier/v1/replicate_it_test.go @@ -571,7 +571,7 @@ func testInternalReplicateITChargerProfile(t *testing.T) { ChargerProfile: &engine.ChargerProfile{ Tenant: "cgrates.org", ID: "ApierTest", - FilterIDs: []string{"*string:~*req.Account:1001", "*string:~Account:1002"}, + FilterIDs: []string{"*string:~*req.Account:1001", "*string:~*opts.Account:1002"}, ActivationInterval: &utils.ActivationInterval{ ActivationTime: time.Date(2014, 7, 14, 14, 35, 0, 0, time.UTC), ExpiryTime: time.Date(2014, 7, 14, 14, 35, 0, 0, time.UTC), diff --git a/apier/v1/resourcesv1_it_test.go b/apier/v1/resourcesv1_it_test.go index 4d4a597cb..b08073754 100644 --- a/apier/v1/resourcesv1_it_test.go +++ b/apier/v1/resourcesv1_it_test.go @@ -696,7 +696,7 @@ func testV1RsSetResourceProfile(t *testing.T) { } var result string - expErr := "SERVER_ERROR: broken reference to filter: *wrong:inline for item with ID: cgrates.org:RES_GR_TEST" + expErr := "SERVER_ERROR: broken reference to filter: <*wrong:inline> for item with ID: cgrates.org:RES_GR_TEST" if err := rlsV1Rpc.Call(utils.APIerSv1SetResourceProfile, rlsConfig, &result); err == nil || err.Error() != expErr { t.Fatalf("Expected error: %q, received: %v", expErr, err) } diff --git a/apier/v1/routes_it_test.go b/apier/v1/routes_it_test.go index 4bac5cb9a..4083654d6 100644 --- a/apier/v1/routes_it_test.go +++ b/apier/v1/routes_it_test.go @@ -885,7 +885,7 @@ func testV1RouteSetRouteProfiles(t *testing.T) { } var result string - expErr := "SERVER_ERROR: broken reference to filter: FLTR_NotFound for item with ID: cgrates.org:TEST_PROFILE1" + expErr := "SERVER_ERROR: broken reference to filter: for item with ID: cgrates.org:TEST_PROFILE1" if err := routeSv1Rpc.Call(utils.APIerSv1SetRouteProfile, routePrf, &result); err == nil || err.Error() != expErr { t.Fatalf("Expected error: %q, received: %v", expErr, err) } diff --git a/apier/v1/stats_it_test.go b/apier/v1/stats_it_test.go index 5829ec406..5b37bffe3 100644 --- a/apier/v1/stats_it_test.go +++ b/apier/v1/stats_it_test.go @@ -462,7 +462,7 @@ func testV1STSSetStatQueueProfile(t *testing.T) { }, } - expErr := "SERVER_ERROR: broken reference to filter: *wrong:inline for item with ID: cgrates.org:TEST_PROFILE1" + expErr := "SERVER_ERROR: broken reference to filter: <*wrong:inline> for item with ID: cgrates.org:TEST_PROFILE1" if err := stsV1Rpc.Call(utils.APIerSv1SetStatQueueProfile, statConfig, &result); err == nil || err.Error() != expErr { t.Fatalf("Expected error: %q, received: %v", expErr, err) } diff --git a/apier/v1/thresholds_it_test.go b/apier/v1/thresholds_it_test.go index 205e69682..5eb11fcfd 100644 --- a/apier/v1/thresholds_it_test.go +++ b/apier/v1/thresholds_it_test.go @@ -452,7 +452,7 @@ func testV1TSSetThresholdProfileBrokenReference(t *testing.T) { Async: true, }, } - expErr := "SERVER_ERROR: broken reference to filter: NonExistingFilter for item with ID: cgrates.org:THD_Test" + expErr := "SERVER_ERROR: broken reference to filter: for item with ID: cgrates.org:THD_Test" if err := tSv1Rpc.Call(utils.APIerSv1SetThresholdProfile, tPrfl, &result); err == nil || err.Error() != expErr { t.Fatalf("Expected error: %q, received: %v", expErr, err) } @@ -518,7 +518,7 @@ func testV1TSSetThresholdProfile(t *testing.T) { func testV1TSUpdateThresholdProfile(t *testing.T) { var result string - tPrfl.FilterIDs = []string{"*string:~Account:1001", "*prefix:~DST:10"} + tPrfl.FilterIDs = []string{"*string:~*req.Account:1001", "*prefix:~*opts.DST:10"} if err := tSv1Rpc.Call(utils.APIerSv1SetThresholdProfile, tPrfl, &result); err != nil { t.Error(err) } else if result != utils.OK { diff --git a/config/configsanity.go b/config/configsanity.go index 0809755c9..e93f8a6f4 100644 --- a/config/configsanity.go +++ b/config/configsanity.go @@ -140,6 +140,17 @@ func (cfg *CGRConfig) checkConfigSanity() error { if field.Path == utils.EmptyString { return fmt.Errorf("<%s> %s for %s at %s", utils.LoaderS, utils.NewErrMandatoryIeMissing(utils.Path), data.Type, field.Tag) } + if err := utils.IsPathValidForExporters(field.Path); err != nil { + return fmt.Errorf("<%s> %s for %s at %s", utils.LoaderS, err, field.Path, utils.Path) + } + for _, val := range field.Value { + if err := utils.IsPathValidForExporters(val.path); err != nil { + return fmt.Errorf("<%s> %s for %s at %s", utils.LoaderS, err, val.path, utils.Values) + } + } + if err := utils.CheckInLineFilter(field.Filters); err != nil { + return fmt.Errorf("<%s> %s for %s at %s", utils.LoaderS, err, field.Filters, utils.Filters) + } } } } @@ -296,6 +307,17 @@ func (cfg *CGRConfig) checkConfigSanity() error { if field.Type != utils.MetaNone && field.Path == utils.EmptyString { return fmt.Errorf("<%s> %s for template %s at %s", utils.DiameterAgent, utils.NewErrMandatoryIeMissing(utils.Path), prf, field.Tag) } + if err := utils.IsPathValidForExporters(field.Path); err != nil { + return fmt.Errorf("<%s> %s for %s at %s", utils.DiameterAgent, err, field.Path, utils.Path) + } + for _, val := range field.Value { + if err := utils.IsPathValidForExporters(val.path); err != nil { + return fmt.Errorf("<%s> %s for %s at %s", utils.DiameterAgent, err, val.path, utils.Values) + } + } + if err := utils.CheckInLineFilter(field.Filters); err != nil { + return fmt.Errorf("<%s> %s for %s at %s", utils.DiameterAgent, err, field.Filters, utils.TemplatesCfg) + } } } for _, req := range cfg.diameterAgentCfg.RequestProcessors { @@ -305,6 +327,17 @@ func (cfg *CGRConfig) checkConfigSanity() error { field.Path == utils.EmptyString { return fmt.Errorf("<%s> %s for %s at %s", utils.DiameterAgent, utils.NewErrMandatoryIeMissing(utils.Path), req.ID, field.Tag) } + if err := utils.IsPathValidForExporters(field.Path); err != nil { + return fmt.Errorf("<%s> %s for %s at %s", utils.DiameterAgent, err, field.Path, utils.Path) + } + for _, val := range field.Value { + if err := utils.IsPathValidForExporters(val.path); err != nil { + return fmt.Errorf("<%s> %s for %s at %s of %s", utils.DiameterAgent, err, val.path, utils.Values, utils.RequestFieldsCfg) + } + } + if err := utils.CheckInLineFilter(field.Filters); err != nil { + return fmt.Errorf("<%s> %s for %s at %s", utils.DiameterAgent, err, field.Filters, utils.RequestFieldsCfg) + } } for _, field := range req.ReplyFields { if field.Type != utils.MetaNone && @@ -312,6 +345,20 @@ func (cfg *CGRConfig) checkConfigSanity() error { field.Path == utils.EmptyString { return fmt.Errorf("<%s> %s for %s at %s", utils.DiameterAgent, utils.NewErrMandatoryIeMissing(utils.Path), req.ID, field.Tag) } + if err := utils.IsPathValidForExporters(field.Path); err != nil { + return fmt.Errorf("<%s> %s for %s at %s", utils.DiameterAgent, err, field.Path, utils.Path) + } + for _, val := range field.Value { + if err := utils.IsPathValidForExporters(val.path); err != nil { + return fmt.Errorf("<%s> %s for %s at %s of %s", utils.DiameterAgent, err, val.path, utils.Values, utils.ReplyFieldsCfg) + } + } + if err := utils.CheckInLineFilter(field.Filters); err != nil { + return fmt.Errorf("<%s> %s for %s at %s", utils.DiameterAgent, err, field.Filters, utils.ReplyFieldsCfg) + } + } + if err := utils.CheckInLineFilter(req.Filters); err != nil { + return fmt.Errorf("<%s> %s for %s at %s", utils.DiameterAgent, err, req.Filters, utils.RequestProcessorsCfg) } } } @@ -334,11 +381,36 @@ func (cfg *CGRConfig) checkConfigSanity() error { if field.Type != utils.MetaNone && field.Path == utils.EmptyString { return fmt.Errorf("<%s> %s for %s at %s", utils.RadiusAgent, utils.NewErrMandatoryIeMissing(utils.Path), req.ID, field.Tag) } + if err := utils.IsPathValidForExporters(field.Path); err != nil { + return fmt.Errorf("<%s> %s for %s at %s", utils.RadiusAgent, err, field.Path, utils.Path) + } + for _, val := range field.Value { + if err := utils.IsPathValidForExporters(val.path); err != nil { + return fmt.Errorf("<%s> %s for %s at %s of %s", utils.RadiusAgent, err, val.path, utils.Values, utils.RequestFieldsCfg) + } + } + if err := utils.CheckInLineFilter(field.Filters); err != nil { + return fmt.Errorf("<%s> %s for %s at %s", utils.RadiusAgent, err, field.Filters, utils.RequestFieldsCfg) + } } for _, field := range req.ReplyFields { if field.Type != utils.MetaNone && field.Path == utils.EmptyString { return fmt.Errorf("<%s> %s for %s at %s", utils.RadiusAgent, utils.NewErrMandatoryIeMissing(utils.Path), req.ID, field.Tag) } + if err := utils.IsPathValidForExporters(field.Path); err != nil { + return fmt.Errorf("<%s> %s for %s at %s", utils.RadiusAgent, err, field.Path, utils.Path) + } + for _, val := range field.Value { + if err := utils.IsPathValidForExporters(val.path); err != nil { + return fmt.Errorf("<%s> %s for %s at %s of %s", utils.RadiusAgent, err, val.path, utils.Values, utils.ReplyFieldsCfg) + } + } + if err := utils.CheckInLineFilter(field.Filters); err != nil { + return fmt.Errorf("<%s> %s for %s at %s", utils.RadiusAgent, err, field.Filters, utils.ReplyFieldsCfg) + } + } + if err := utils.CheckInLineFilter(req.Filters); err != nil { + return fmt.Errorf("<%s> %s for %s at %s", utils.RadiusAgent, err, req.Filters, utils.RequestProcessorsCfg) } } } @@ -361,11 +433,36 @@ func (cfg *CGRConfig) checkConfigSanity() error { if field.Type != utils.MetaNone && field.Path == utils.EmptyString { return fmt.Errorf("<%s> %s for %s at %s", utils.DNSAgent, utils.NewErrMandatoryIeMissing(utils.Path), req.ID, field.Tag) } + if err := utils.IsPathValidForExporters(field.Path); err != nil { + return fmt.Errorf("<%s> %s for %s at %s", utils.DNSAgent, err, field.Path, utils.Path) + } + for _, val := range field.Value { + if err := utils.IsPathValidForExporters(val.path); err != nil { + return fmt.Errorf("<%s> %s for %s at %s of %s", utils.DNSAgent, err, val.path, utils.Values, utils.RequestFieldsCfg) + } + } + if err := utils.CheckInLineFilter(field.Filters); err != nil { + return fmt.Errorf("<%s> %s for %s at %s", utils.DNSAgent, err, field.Filters, utils.RequestFieldsCfg) + } } for _, field := range req.ReplyFields { if field.Type != utils.MetaNone && field.Path == utils.EmptyString { return fmt.Errorf("<%s> %s for %s at %s", utils.DNSAgent, utils.NewErrMandatoryIeMissing(utils.Path), req.ID, field.Tag) } + if err := utils.IsPathValidForExporters(field.Path); err != nil { + return fmt.Errorf("<%s> %s for %s at %s", utils.DNSAgent, err, field.Path, utils.Path) + } + for _, val := range field.Value { + if err := utils.IsPathValidForExporters(val.path); err != nil { + return fmt.Errorf("<%s> %s for %s at %s of %s", utils.DNSAgent, err, val.path, utils.Values, utils.ReplyFieldsCfg) + } + } + if err := utils.CheckInLineFilter(field.Filters); err != nil { + return fmt.Errorf("<%s> %s for %s at %s", utils.DNSAgent, err, field.Filters, utils.ReplyFieldsCfg) + } + } + if err := utils.CheckInLineFilter(req.Filters); err != nil { + return fmt.Errorf("<%s> %s for %s at %s", utils.DNSAgent, err, req.Filters, utils.RequestProcessorsCfg) } } } @@ -392,11 +489,36 @@ func (cfg *CGRConfig) checkConfigSanity() error { if field.Type != utils.MetaNone && field.Path == utils.EmptyString { return fmt.Errorf("<%s> %s for %s at %s", utils.HTTPAgent, utils.NewErrMandatoryIeMissing(utils.Path), req.ID, field.Tag) } + if err := utils.IsPathValidForExporters(field.Path); err != nil { + return fmt.Errorf("<%s> %s for %s at %s", utils.HTTPAgent, err, field.Path, utils.Path) + } + for _, val := range field.Value { + if err := utils.IsPathValidForExporters(val.path); err != nil { + return fmt.Errorf("<%s> %s for %s at %s of %s", utils.HTTPAgent, err, val.path, utils.Values, utils.RequestFieldsCfg) + } + } + if err := utils.CheckInLineFilter(field.Filters); err != nil { + return fmt.Errorf("<%s> %s for %s at %s", utils.HTTPAgent, err, field.Filters, utils.RequestFieldsCfg) + } } for _, field := range req.ReplyFields { if field.Type != utils.MetaNone && field.Path == utils.EmptyString { return fmt.Errorf("<%s> %s for %s at %s", utils.HTTPAgent, utils.NewErrMandatoryIeMissing(utils.Path), req.ID, field.Tag) } + if err := utils.IsPathValidForExporters(field.Path); err != nil { + return fmt.Errorf("<%s> %s for %s at %s", utils.HTTPAgent, err, field.Path, utils.Path) + } + for _, val := range field.Value { + if err := utils.IsPathValidForExporters(val.path); err != nil { + return fmt.Errorf("<%s> %s for %s at %s of %s", utils.HTTPAgent, err, val.path, utils.Values, utils.ReplyFieldsCfg) + } + } + if err := utils.CheckInLineFilter(field.Filters); err != nil { + return fmt.Errorf("<%s> %s for %s at %s", utils.HTTPAgent, err, field.Filters, utils.ReplyFieldsCfg) + } + } + if err := utils.CheckInLineFilter(req.Filters); err != nil { + return fmt.Errorf("<%s> %s for %s at %s", utils.HTTPAgent, err, req.Filters, utils.RequestProcessorsCfg) } } } @@ -420,11 +542,36 @@ func (cfg *CGRConfig) checkConfigSanity() error { if field.Type != utils.MetaNone && field.Path == utils.EmptyString { return fmt.Errorf("<%s> %s for %s at %s", utils.SIPAgent, utils.NewErrMandatoryIeMissing(utils.Path), req.ID, field.Tag) } + if err := utils.IsPathValidForExporters(field.Path); err != nil { + return fmt.Errorf("<%s> %s for %s at %s", utils.SIPAgent, err, field.Path, utils.Path) + } + for _, val := range field.Value { + if err := utils.IsPathValidForExporters(val.path); err != nil { + return fmt.Errorf("<%s> %s for %s at %s of %s", utils.SIPAgent, err, val.path, utils.Values, utils.RequestFieldsCfg) + } + } + if err := utils.CheckInLineFilter(field.Filters); err != nil { + return fmt.Errorf("<%s> %s for %s at %s", utils.SIPAgent, err, field.Filters, utils.RequestFieldsCfg) + } } for _, field := range req.ReplyFields { if field.Type != utils.MetaNone && field.Path == utils.EmptyString { return fmt.Errorf("<%s> %s for %s at %s", utils.SIPAgent, utils.NewErrMandatoryIeMissing(utils.Path), req.ID, field.Tag) } + if err := utils.IsPathValidForExporters(field.Path); err != nil { + return fmt.Errorf("<%s> %s for %s at %s", utils.SIPAgent, err, field.Path, utils.Path) + } + for _, val := range field.Value { + if err := utils.IsPathValidForExporters(val.path); err != nil { + return fmt.Errorf("<%s> %s for %s at %s of %s", utils.SIPAgent, err, val.path, utils.Values, utils.ReplyFieldsCfg) + } + } + if err := utils.CheckInLineFilter(field.Filters); err != nil { + return fmt.Errorf("<%s> %s for %s at %s", utils.SIPAgent, err, field.Filters, utils.ReplyFieldsCfg) + } + } + if err := utils.CheckInLineFilter(req.Filters); err != nil { + return fmt.Errorf("<%s> %s for %s at %s", utils.SIPAgent, err, req.Filters, utils.RequestProcessorsCfg) } } } @@ -527,6 +674,10 @@ func (cfg *CGRConfig) checkConfigSanity() error { return fmt.Errorf("<%s> connection with id: <%s> not defined", utils.SchedulerS, connID) } } + if err := utils.CheckInLineFilter(cfg.schedulerCfg.Filters); err != nil { + return fmt.Errorf("<%s> got %s in %s", utils.SchedulerS, err, utils.Filters) + } + } // EventReader sanity checks if cfg.ersCfg.Enabled { @@ -568,11 +719,60 @@ func (cfg *CGRConfig) checkConfigSanity() error { if field.Type != utils.MetaNone && field.Path == utils.EmptyString { return fmt.Errorf("<%s> %s for %s at %s", utils.ERs, utils.NewErrMandatoryIeMissing(utils.Path), rdr.ID, field.Tag) } + if err := utils.IsPathValidForExporters(field.Path); err != nil { + return fmt.Errorf("<%s> %s for %s at %s", utils.ERs, err, field.Path, utils.Path) + } + if field.Type == utils.MetaVariable || + field.Type == utils.MetaComposed || + field.Type == utils.MetaGroup || + field.Type == utils.MetaUsageDifference || + field.Type == utils.MetaCCUsage || + field.Type == utils.MetaSum || + field.Type == utils.MetaDifference || + field.Type == utils.MetaMultiply || + field.Type == utils.MetaDivide || + field.Type == utils.MetaValueExponent || + field.Type == utils.MetaUnixTimestamp { + for _, val := range field.Value { + if err := utils.IsPathValidForExporters(val.path); err != nil { + return fmt.Errorf("<%s> %s for %s at %s of %s", utils.ERs, err, val.path, utils.Values, utils.CacheDumpFieldsCfg) + } + } + } + if err := utils.CheckInLineFilter(field.Filters); err != nil { + return fmt.Errorf("<%s> %s for %s at %s", utils.ERs, err, field.Filters, utils.CacheDumpFieldsCfg) + } } for _, field := range rdr.Fields { if field.Type != utils.MetaNone && field.Path == utils.EmptyString { return fmt.Errorf("<%s> %s for %s at %s", utils.ERs, utils.NewErrMandatoryIeMissing(utils.Path), rdr.ID, field.Tag) } + if err := utils.IsPathValidForExporters(field.Path); err != nil { + return fmt.Errorf("<%s> %s for %s at %s", utils.ERs, err, field.Path, utils.Path) + } + if field.Type == utils.MetaVariable || + field.Type == utils.MetaComposed || + field.Type == utils.MetaGroup || + field.Type == utils.MetaUsageDifference || + field.Type == utils.MetaCCUsage || + field.Type == utils.MetaSum || + field.Type == utils.MetaDifference || + field.Type == utils.MetaMultiply || + field.Type == utils.MetaDivide || + field.Type == utils.MetaValueExponent || + field.Type == utils.MetaUnixTimestamp { + for _, val := range field.Value { + if err := utils.IsPathValidForExporters(val.path); err != nil { + return fmt.Errorf("<%s> %s for %s at %s of %s", utils.ERs, err, val.path, utils.Values, utils.FieldsCfg) + } + } + } + if err := utils.CheckInLineFilter(field.Filters); err != nil { + return fmt.Errorf("<%s> %s for %s at %s", utils.ERs, err, field.Filters, utils.FieldsCfg) + } + } + if err := utils.CheckInLineFilter(rdr.Filters); err != nil { + return fmt.Errorf("<%s> %s for %s at %s", utils.ERs, err, rdr.Filters, utils.ReadersCfg) } } } @@ -616,6 +816,32 @@ func (cfg *CGRConfig) checkConfigSanity() error { if field.Type != utils.MetaNone && field.Path == utils.EmptyString { return fmt.Errorf("<%s> %s for %s at %s", utils.EEs, utils.NewErrMandatoryIeMissing(utils.Path), exp.ID, field.Tag) } + if err := utils.IsPathValidForExporters(field.Path); err != nil { + return fmt.Errorf("<%s> %s for %s at %s", utils.EEs, err, field.Path, utils.Path) + } + if field.Type == utils.MetaVariable || + field.Type == utils.MetaComposed || + field.Type == utils.MetaGroup || + field.Type == utils.MetaUsageDifference || + field.Type == utils.MetaCCUsage || + field.Type == utils.MetaSum || + field.Type == utils.MetaDifference || + field.Type == utils.MetaMultiply || + field.Type == utils.MetaDivide || + field.Type == utils.MetaValueExponent || + field.Type == utils.MetaUnixTimestamp { + for _, val := range field.Value { + if err := utils.IsPathValidForExporters(val.path); err != nil { + return fmt.Errorf("<%s> %s for %s at %s of %s", utils.EEs, err, val.path, utils.Values, utils.FieldsCfg) + } + } + } + if err := utils.CheckInLineFilter(field.Filters); err != nil { + return fmt.Errorf("<%s> %s for %s at %s", utils.EEs, err, field.Filters, utils.FieldsCfg) + } + } + if err := utils.CheckInLineFilter(exp.Filters); err != nil { + return fmt.Errorf("<%s> %s for %s at %s", utils.EEs, err, exp.Filters, utils.ExportersCfg) } } } @@ -815,7 +1041,7 @@ func (cfg *CGRConfig) checkConfigSanity() error { if !utils.AnzIndexType.Has(cfg.analyzerSCfg.IndexType) { return fmt.Errorf("<%s> unsuported index type: %q", utils.AnalyzerS, cfg.analyzerSCfg.IndexType) } - // TTL and CleanupInterval should allways be biger than zero in order to not keep unecesary logs in index + // TTL and CleanupInterval should always be bigger than zero in order to not keep unnecessary logs in index if cfg.analyzerSCfg.TTL <= 0 { return fmt.Errorf("<%s> the TTL needs to be bigger than 0", utils.AnalyzerS) } diff --git a/engine/z_filterindexer_it_test.go b/engine/z_filterindexer_it_test.go index 5f6a4934b..d249776bb 100644 --- a/engine/z_filterindexer_it_test.go +++ b/engine/z_filterindexer_it_test.go @@ -988,7 +988,7 @@ func testITResourceProfileIndexes(t *testing.T) { { Type: utils.MetaString, Element: "~*req.Destinations", - Values: []string{"DEST_RES1", "~DynamicValue", "DEST_RES2"}, + Values: []string{"DEST_RES1", "~*opts.DynamicValue", "DEST_RES2"}, }, }, } @@ -1011,7 +1011,7 @@ func testITResourceProfileIndexes(t *testing.T) { Stored: true, } - expected := "broken reference to filter: FIRST for item with ID: cgrates.org:RES_PRF1" + expected := "broken reference to filter: for item with ID: cgrates.org:RES_PRF1" if err := dataManager.SetResourceProfile(resPref1, true); err == nil || err.Error() != expected { t.Errorf("Expected %+v, received %+v", expected, err) } diff --git a/general_tests/accountactions_it_test.go b/general_tests/accountactions_it_test.go deleted file mode 100644 index 5b1ffbf66..000000000 --- a/general_tests/accountactions_it_test.go +++ /dev/null @@ -1,231 +0,0 @@ -// +build integration - -/* -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 general_tests - -import ( - "net/rpc" - "path" - "reflect" - "testing" - - "github.com/cgrates/cgrates/config" - "github.com/cgrates/cgrates/engine" - "github.com/cgrates/cgrates/utils" -) - -var ( - accPrfCfgPath string - accPrfCfg *config.CGRConfig - accSRPC *rpc.Client - accPrfConfigDIR string //run tests for specific configuration - - sTestsAccPrf = []func(t *testing.T){ - testAccActionsInitCfg, - testAccActionsInitDataDb, - testAccActionsResetStorDb, - testAccActionsStartEngine, - testAccActionsRPCConn, - testAccActionsExecuteAction, - testAccActionsExecuteAction2, - testAccActionsGetAccountAfterActions, - testAccActionsExecuteAction3, - testAccActionsGetAccountAfterRemActions, - testAccActionsKillEngine, - } -) - -//Test start here -func TestAccActionsIT(t *testing.T) { - switch *dbType { - case utils.MetaInternal: - accPrfConfigDIR = "tutinternal" - case utils.MetaMySQL: - accPrfConfigDIR = "tutmysql" - case utils.MetaMongo: - accPrfConfigDIR = "tutmongo" - case utils.MetaPostgres: - t.SkipNow() - default: - t.Fatal("Unknown Database type") - } - for _, stest := range sTestsAccPrf { - t.Run(accPrfConfigDIR, stest) - } -} - -func testAccActionsInitCfg(t *testing.T) { - var err error - accPrfCfgPath = path.Join(*dataDir, "conf", "samples", accPrfConfigDIR) - if accPrfCfg, err = config.NewCGRConfigFromPath(accPrfCfgPath); err != nil { - t.Error(err) - } -} - -func testAccActionsInitDataDb(t *testing.T) { - if err := engine.InitDataDb(accPrfCfg); err != nil { - t.Fatal(err) - } -} - -// Wipe out the cdr database -func testAccActionsResetStorDb(t *testing.T) { - if err := engine.InitStorDb(accPrfCfg); err != nil { - t.Fatal(err) - } -} - -// Start CGR Engine -func testAccActionsStartEngine(t *testing.T) { - if _, err := engine.StopStartEngine(accPrfCfgPath, *waitRater); err != nil { - t.Fatal(err) - } -} - -// Connect rpc client to rater -func testAccActionsRPCConn(t *testing.T) { - var err error - accSRPC, err = newRPCClient(accPrfCfg.ListenCfg()) // We connect over JSON so we can also troubleshoot if needed - if err != nil { - t.Fatal(err) - } -} - -func testAccActionsExecuteAction(t *testing.T) { - var reply string - if err := accSRPC.Call(utils.ActionSv1ExecuteActions, &utils.ArgActionSv1ScheduleActions{ - CGREvent: &utils.CGREvent{ - Tenant: "cgrates.org", - Event: map[string]interface{}{ - "Account": 1001, - }, - APIOpts: map[string]interface{}{ - "BAL_NEW": true, - "BAL_ADD": true, - }, - }, - }, &reply); err != nil { - t.Error(err) - } else if reply != utils.OK { - t.Error("Unexpected reply returned", reply) - } -} - -func testAccActionsExecuteAction2(t *testing.T) { - var reply string - if err := accSRPC.Call(utils.ActionSv1ExecuteActions, &utils.ArgActionSv1ScheduleActions{ - CGREvent: &utils.CGREvent{ - Tenant: "cgrates.org", - Event: map[string]interface{}{ - "Account": 1001, - }, - APIOpts: map[string]interface{}{ - "BAL_NEW": true, - "BAL_ADD": true, - }, - }, - ActionProfileIDs: []string{"CREATE_ACC"}, - }, &reply); err != nil { - t.Error(err) - } else if reply != utils.OK { - t.Error("Unexpected reply returned", reply) - } -} - -func testAccActionsGetAccountAfterActions(t *testing.T) { - accPrf := &utils.AccountProfile{ - Tenant: "cgrates.org", - ID: "1001", - Balances: map[string]*utils.Balance{ - "MONETARY": { - ID: "MONETARY", - Weights: utils.DynamicWeights{{}}, - Type: utils.MetaConcrete, - Units: utils.NewDecimalFromFloat64(1048576), - CostIncrements: []*utils.CostIncrement{{ - FilterIDs: []string{"*string:~*req.ToR:*data"}, - Increment: utils.NewDecimalFromFloat64(1024), - FixedFee: utils.NewDecimalFromFloat64(0), - RecurrentFee: utils.NewDecimalFromFloat64(0.01), - }}, - }, - "VOICE": { - ID: "VOICE", - FilterIDs: []string{"*string:~*req.ToR:*voice"}, - Weights: utils.DynamicWeights{{Weight: 2}}, - Type: utils.MetaAbstract, - Units: utils.NewDecimalFromFloat64(2 * 10800000000000), - CostIncrements: []*utils.CostIncrement{{ - FilterIDs: []string{"*string:~*req.ToR:*voice"}, - Increment: utils.NewDecimalFromFloat64(1000000000), - FixedFee: utils.NewDecimalFromFloat64(0), - RecurrentFee: utils.NewDecimalFromFloat64(0.01), - }}, - }, - }, - ThresholdIDs: []string{utils.MetaNone}, - } - var result *utils.AccountProfile - if err := accSRPC.Call(utils.APIerSv1GetAccountProfile, &utils.TenantIDWithAPIOpts{ - TenantID: &utils.TenantID{Tenant: "cgrates.org", ID: "1001"}}, &result); err != nil { - t.Error(err) - } else if !reflect.DeepEqual(accPrf, result) { - t.Errorf("Expecting : %s, received: %s", utils.ToJSON(accPrf), utils.ToJSON(result)) - } -} - -func testAccActionsExecuteAction3(t *testing.T) { - var reply string - if err := accSRPC.Call(utils.ActionSv1ExecuteActions, &utils.ArgActionSv1ScheduleActions{ - CGREvent: &utils.CGREvent{ - Tenant: "cgrates.org", - Event: map[string]interface{}{ - "Account": 1001, - }, - }, - ActionProfileIDs: []string{"REM_ACC"}, - }, &reply); err != nil { - t.Error(err) - } else if reply != utils.OK { - t.Error("Unexpected reply returned", reply) - } -} - -func testAccActionsGetAccountAfterRemActions(t *testing.T) { - accPrf := &utils.AccountProfile{ - Tenant: "cgrates.org", - ID: "1001", - Balances: map[string]*utils.Balance{}, - ThresholdIDs: []string{utils.MetaNone}, - } - var result *utils.AccountProfile - if err := accSRPC.Call(utils.APIerSv1GetAccountProfile, &utils.TenantIDWithAPIOpts{ - TenantID: &utils.TenantID{Tenant: "cgrates.org", ID: "1001"}}, &result); err != nil { - t.Error(err) - } else if !reflect.DeepEqual(accPrf, result) { - t.Errorf("Expecting : %s, received: %s", utils.ToJSON(accPrf), utils.ToJSON(result)) - } -} - -func testAccActionsKillEngine(t *testing.T) { - if err := engine.KillEngine(100); err != nil { - t.Error(err) - } -} diff --git a/migrator/resource_it_test.go b/migrator/resource_it_test.go index 9d76a338b..c6aba9d81 100644 --- a/migrator/resource_it_test.go +++ b/migrator/resource_it_test.go @@ -181,7 +181,7 @@ func testResITMigrateAndMove(t *testing.T) { resPrfl := &engine.ResourceProfile{ Tenant: "cgrates.org", ID: "RES1", - FilterIDs: []string{"*string:~Account:1001"}, + FilterIDs: []string{"*string:~*opts.Account:1001"}, UsageTTL: time.Second, Limit: 1, Weight: 10, diff --git a/migrator/routes_it_test.go b/migrator/routes_it_test.go index 5d50e7747..6030ad2fd 100644 --- a/migrator/routes_it_test.go +++ b/migrator/routes_it_test.go @@ -180,7 +180,7 @@ func testSupITMigrateAndMove(t *testing.T) { supPrfl := &engine.RouteProfile{ Tenant: "cgrates.org", ID: "SUP1", - FilterIDs: []string{"*string:~Account:1001"}, + FilterIDs: []string{"*string:~*opts.Account:1001"}, Weight: 10, Sorting: utils.MetaQOS, SortingParameters: []string{}, diff --git a/migrator/user_it_test.go b/migrator/user_it_test.go index fbd1e2be2..50345de28 100644 --- a/migrator/user_it_test.go +++ b/migrator/user_it_test.go @@ -126,7 +126,7 @@ func testUsrITMigrateAndMove(t *testing.T) { Tenant: defaultTenant, ID: "1001", Contexts: []string{utils.MetaAny}, - FilterIDs: []string{"*string:~Account:1002"}, + FilterIDs: []string{"*string:~*req.Account:1002"}, ActivationInterval: nil, Attributes: []*engine.Attribute{ { diff --git a/sessions/sessions_voice_it_test.go b/sessions/sessions_voice_it_test.go index 98c26285d..63a17e97d 100644 --- a/sessions/sessions_voice_it_test.go +++ b/sessions/sessions_voice_it_test.go @@ -831,7 +831,7 @@ func testSessionsVoiceSessionTTL(t *testing.T) { Filters: []string{ fmt.Sprintf("*string:~*req.%s:%s", utils.RunID, utils.MetaDefault), fmt.Sprintf("*string:~*req.%s:%s", utils.OriginID, "12372-1"), - "*string:~no_field:10", + "*string:~*req.no_field:10", }, }, &aSessions); err == nil || err.Error() != utils.ErrNotFound.Error() { diff --git a/utils/dataprovider.go b/utils/dataprovider.go index 3ab0aff03..730446578 100644 --- a/utils/dataprovider.go +++ b/utils/dataprovider.go @@ -97,8 +97,8 @@ func IsPathValidForExporters(path string) (err error) { return nil } paths := strings.Split(path, NestingSep) - for _, path := range paths { - if strings.TrimSpace(path) == EmptyString { + for _, newPath := range paths { + if strings.TrimSpace(newPath) == EmptyString { return errors.New("Empty field path ") } }