From 77ae2a91586939a486a516099e01538f86ce6a79 Mon Sep 17 00:00:00 2001 From: andronache Date: Mon, 26 Apr 2021 16:17:50 +0300 Subject: [PATCH] Coverage in Dispatchers 95.5% --- dispatchers/dispatchers_test.go | 610 ++++++++++++++++++++++++++++++++ engine/datadbmock.go | 4 + engine/filters.go | 2 +- 3 files changed, 615 insertions(+), 1 deletion(-) diff --git a/dispatchers/dispatchers_test.go b/dispatchers/dispatchers_test.go index 37f9c66be..ffdf6070b 100644 --- a/dispatchers/dispatchers_test.go +++ b/dispatchers/dispatchers_test.go @@ -453,3 +453,613 @@ func TestDispatcherServiceCall1(t *testing.T) { t.Errorf("\nExpected <%+v>, \nReceived <%+v>", nil, err) } } + +func TestDispatcherServiceDispatcherProfileForEventErrNil(t *testing.T) { + cfg := config.NewDefaultCGRConfig() + cfg.DispatcherSCfg().IndexedSelects = false + rpcCl := map[string]chan rpcclient.ClientConnector{} + connMng := engine.NewConnManager(cfg, rpcCl) + dataDB := engine.NewInternalDB(nil, nil, true) + dm := engine.NewDataManager(dataDB, nil, connMng) + dsp := &engine.DispatcherProfile{ + Tenant: "cgrates.org", + ID: "123", + Subsystems: []string{utils.MetaAccounts}, + FilterIDs: nil, + ActivationInterval: nil, + Strategy: "", + StrategyParams: nil, + Weight: 0, + Hosts: nil, + } + err := dm.SetDispatcherProfile(dsp, false) + if err != nil { + t.Errorf("\nExpected <%+v>, \nReceived <%+v>", nil, err) + } + dss := NewDispatcherService(dm, cfg, nil, connMng) + ev := &utils.CGREvent{ + Tenant: "cgrates.org", + ID: "123", + Time: nil, + Event: map[string]interface{}{ + utils.AccountField: "1001", + "Password": "CGRateS.org", + "RunID": utils.MetaDefault, + }, + APIOpts: map[string]interface{}{ + utils.Subsys: utils.MetaAccounts, + }, + } + tnt := ev.Tenant + subsys := utils.IfaceAsString(ev.APIOpts[utils.Subsys]) + _, err = dss.dispatcherProfileForEvent(tnt, ev, subsys) + if err != nil { + t.Errorf("\nExpected <%+v>, \nReceived <%+v>", nil, err) + } +} + +func TestDispatcherV1GetProfileForEventReturn(t *testing.T) { + cfg := config.NewDefaultCGRConfig() + cfg.DispatcherSCfg().IndexedSelects = false + rpcCl := map[string]chan rpcclient.ClientConnector{} + connMng := engine.NewConnManager(cfg, rpcCl) + dataDB := engine.NewInternalDB(nil, nil, true) + dm := engine.NewDataManager(dataDB, nil, connMng) + dsp := &engine.DispatcherProfile{ + Tenant: "cgrates.org", + ID: "123", + Subsystems: []string{utils.MetaAccounts}, + FilterIDs: nil, + ActivationInterval: nil, + Strategy: "", + StrategyParams: nil, + Weight: 0, + Hosts: nil, + } + err := dm.SetDispatcherProfile(dsp, false) + if err != nil { + t.Errorf("\nExpected <%+v>, \nReceived <%+v>", nil, err) + } + dss := NewDispatcherService(dm, cfg, nil, connMng) + ev := &utils.CGREvent{ + Tenant: "cgrates.org", + ID: "123", + Time: nil, + Event: map[string]interface{}{ + utils.AccountField: "1001", + "Password": "CGRateS.org", + "RunID": utils.MetaDefault, + }, + APIOpts: map[string]interface{}{ + utils.Subsys: utils.MetaAccounts, + }, + } + tnt := ev.Tenant + subsys := utils.IfaceAsString(ev.APIOpts[utils.Subsys]) + _, err = dss.dispatcherProfileForEvent(tnt, ev, subsys) + if err != nil { + t.Errorf("\nExpected <%+v>, \nReceived <%+v>", nil, err) + } + dPfl := &engine.DispatcherProfile{} + err = dss.V1GetProfileForEvent(ev, dPfl) + expected := "DISPATCHER_ERROR:NOT_FOUND" + if err != nil { + t.Errorf("\nExpected <%+v>, \nReceived <%+v>", expected, err) + } +} + +func TestDispatcherServiceDispatcherProfileForEventErrNotFound(t *testing.T) { + cfg := config.NewDefaultCGRConfig() + cfg.DispatcherSCfg().IndexedSelects = false + rpcCl := map[string]chan rpcclient.ClientConnector{} + connMng := engine.NewConnManager(cfg, rpcCl) + dataDB := engine.NewInternalDB(nil, nil, true) + dm := engine.NewDataManager(dataDB, nil, connMng) + dsp := &engine.DispatcherProfile{ + Tenant: "cgrates.org", + ID: "123", + Subsystems: []string{utils.MetaAccounts}, + FilterIDs: nil, + ActivationInterval: nil, + Strategy: "", + StrategyParams: nil, + Weight: 0, + Hosts: nil, + } + err := dm.SetDispatcherProfile(dsp, false) + if err != nil { + t.Errorf("\nExpected <%+v>, \nReceived <%+v>", nil, err) + } + dss := NewDispatcherService(dm, cfg, nil, connMng) + ev := &utils.CGREvent{ + Tenant: "cgrates.org", + ID: "123", + Time: nil, + Event: map[string]interface{}{ + utils.AccountField: "1001", + "Password": "CGRateS.org", + "RunID": utils.MetaDefault, + }, + APIOpts: map[string]interface{}{ + utils.Subsys: utils.MetaAny, + }, + } + tnt := ev.Tenant + subsys := utils.IfaceAsString(ev.APIOpts[utils.Subsys]) + _, err = dss.dispatcherProfileForEvent(tnt, ev, subsys) + if err == nil || err != utils.ErrNotFound { + t.Errorf("\nExpected <%+v>, \nReceived <%+v>", utils.ErrNotFound, err) + } +} + +func TestDispatcherServiceDispatcherProfileForEventErrNotFound2(t *testing.T) { + cfg := config.NewDefaultCGRConfig() + cfg.DispatcherSCfg().IndexedSelects = false + rpcCl := map[string]chan rpcclient.ClientConnector{} + connMng := engine.NewConnManager(cfg, rpcCl) + dataDB := engine.NewInternalDB(nil, nil, true) + dm := engine.NewDataManager(dataDB, nil, connMng) + dsp := &engine.DispatcherProfile{ + Tenant: "cgrates.org", + ID: "123", + Subsystems: []string{utils.MetaAccounts}, + FilterIDs: nil, + ActivationInterval: nil, + Strategy: "", + StrategyParams: nil, + Weight: 0, + Hosts: nil, + } + err := dm.SetDispatcherProfile(dsp, false) + if err != nil { + t.Errorf("\nExpected <%+v>, \nReceived <%+v>", nil, err) + } + dss := NewDispatcherService(dm, cfg, nil, connMng) + ev := &utils.CGREvent{ + Tenant: "cgrates.org", + ID: "123", + Time: nil, + Event: map[string]interface{}{ + utils.AccountField: "1001", + "Password": "CGRateS.org", + "RunID": utils.MetaDefault, + }, + APIOpts: map[string]interface{}{ + utils.Subsys: utils.MetaAccounts, + }, + } + tnt := "" + subsys := utils.IfaceAsString(ev.APIOpts[utils.Subsys]) + _, err = dss.dispatcherProfileForEvent(tnt, ev, subsys) + if err == nil || err != utils.ErrNotFound { + t.Errorf("\nExpected <%+v>, \nReceived <%+v>", utils.ErrNotFound, err) + } +} + +func TestDispatcherServiceDispatcherProfileForEventErrNotFoundTime(t *testing.T) { + cfg := config.NewDefaultCGRConfig() + cfg.DispatcherSCfg().IndexedSelects = false + rpcCl := map[string]chan rpcclient.ClientConnector{} + connMng := engine.NewConnManager(cfg, rpcCl) + dataDB := engine.NewInternalDB(nil, nil, true) + dm := engine.NewDataManager(dataDB, nil, connMng) + dsp := &engine.DispatcherProfile{ + Tenant: "cgrates.org", + ID: "123", + Subsystems: []string{utils.MetaAccounts}, + FilterIDs: nil, + ActivationInterval: &utils.ActivationInterval{ + ActivationTime: time.Date(1999, 2, 3, 4, 5, 6, 700000000, time.UTC), + ExpiryTime: time.Date(2000, 2, 3, 4, 5, 6, 700000000, time.UTC), + }, + Strategy: "", + StrategyParams: nil, + Weight: 0, + Hosts: nil, + } + err := dm.SetDispatcherProfile(dsp, false) + if err != nil { + t.Errorf("\nExpected <%+v>, \nReceived <%+v>", nil, err) + } + fltrs := engine.NewFilterS(cfg, connMng, dm) + dss := NewDispatcherService(dm, cfg, fltrs, connMng) + ev := &utils.CGREvent{ + Tenant: "cgrates.org", + ID: "123", + Time: utils.TimePointer(time.Now()), + Event: map[string]interface{}{ + utils.AccountField: "1001", + "Password": "CGRateS.org", + "RunID": utils.MetaDefault, + }, + APIOpts: map[string]interface{}{ + utils.Subsys: utils.MetaAccounts, + }, + } + tnt := ev.Tenant + subsys := utils.IfaceAsString(ev.APIOpts[utils.Subsys]) + _, err = dss.dispatcherProfileForEvent(tnt, ev, subsys) + if err == nil || err != utils.ErrNotFound { + t.Errorf("\nExpected <%+v>, \nReceived <%+v>", utils.ErrNotFound, err) + } +} + +func TestDispatcherServiceDispatcherProfileForEventErrNotFoundFilter(t *testing.T) { + cfg := config.NewDefaultCGRConfig() + cfg.DispatcherSCfg().IndexedSelects = false + rpcCl := map[string]chan rpcclient.ClientConnector{} + connMng := engine.NewConnManager(cfg, rpcCl) + dataDB := engine.NewInternalDB(nil, nil, true) + dm := engine.NewDataManager(dataDB, nil, connMng) + dsp := &engine.DispatcherProfile{ + Tenant: "cgrates.org", + ID: "123", + Subsystems: []string{utils.MetaAccounts}, + FilterIDs: []string{"filter"}, + ActivationInterval: &utils.ActivationInterval{}, + Strategy: "", + StrategyParams: nil, + Weight: 0, + Hosts: nil, + } + err := dm.SetDispatcherProfile(dsp, false) + if err != nil { + t.Errorf("\nExpected <%+v>, \nReceived <%+v>", nil, err) + } + fltrs := engine.NewFilterS(cfg, connMng, dm) + dss := NewDispatcherService(dm, cfg, fltrs, connMng) + ev := &utils.CGREvent{ + Tenant: "cgrates.org", + ID: "123", + Event: map[string]interface{}{ + utils.AccountField: "1001", + "Password": "CGRateS.org", + "RunID": utils.MetaDefault, + }, + APIOpts: map[string]interface{}{ + utils.Subsys: utils.MetaAccounts, + }, + } + tnt := ev.Tenant + subsys := utils.IfaceAsString(ev.APIOpts[utils.Subsys]) + _, err = dss.dispatcherProfileForEvent(tnt, ev, subsys) + if err == nil || err.Error() != "NOT_FOUND:filter" { + t.Errorf("\nExpected <%+v>, \nReceived <%+v>", "NOT_FOUND:filter", err) + } +} + +func TestDispatcherServiceDispatchDspErr(t *testing.T) { + cfg := config.NewDefaultCGRConfig() + cfg.DispatcherSCfg().IndexedSelects = false + rpcCl := map[string]chan rpcclient.ClientConnector{} + connMng := engine.NewConnManager(cfg, rpcCl) + dataDB := engine.NewInternalDB(nil, nil, true) + dm := engine.NewDataManager(dataDB, nil, connMng) + dsp := &engine.DispatcherProfile{ + Tenant: "cgrates.org", + ID: "123", + Subsystems: []string{utils.MetaAccounts}, + FilterIDs: nil, + ActivationInterval: nil, + Strategy: "", + StrategyParams: nil, + Weight: 0, + Hosts: nil, + } + err := dm.SetDispatcherProfile(dsp, false) + if err != nil { + t.Errorf("\nExpected <%+v>, \nReceived <%+v>", nil, err) + } + dss := NewDispatcherService(dm, cfg, nil, connMng) + ev := &utils.CGREvent{ + Tenant: "cgrates.org", + ID: "123", + Time: nil, + Event: map[string]interface{}{ + utils.AccountField: "1001", + "Password": "CGRateS.org", + "RunID": utils.MetaDefault, + }, + APIOpts: map[string]interface{}{ + utils.Subsys: utils.MetaAccounts, + }, + } + subsys := utils.IfaceAsString(ev.APIOpts[utils.Subsys]) + err = dss.Dispatch(ev, subsys, "", "", "") + expected := "DISPATCHER_ERROR:unsupported dispatch strategy: <>" + if err == nil || err.Error() != expected { + t.Errorf("\nExpected <%+v>, \nReceived <%+v>", expected, err) + } +} + +func TestDispatcherServiceDispatchDspErrHostNotFound(t *testing.T) { + cacheInit := engine.Cache + cfg := config.NewDefaultCGRConfig() + cfg.DispatcherSCfg().IndexedSelects = false + rpcCl := map[string]chan rpcclient.ClientConnector{} + connMng := engine.NewConnManager(cfg, rpcCl) + dataDB := engine.NewInternalDB(nil, nil, true) + dm := engine.NewDataManager(dataDB, nil, connMng) + dsp := &engine.DispatcherProfile{ + Tenant: "cgrates.org", + ID: "123", + Subsystems: []string{utils.MetaAccounts}, + FilterIDs: nil, + ActivationInterval: nil, + StrategyParams: make(map[string]interface{}), + Strategy: utils.MetaWeight, + Weight: 0, + Hosts: nil, + } + newCache := engine.NewCacheS(cfg, dm, nil) + value, errDsp := newDispatcher(dm, dsp) + if errDsp != nil { + t.Fatal(errDsp) + } + engine.Cache = newCache + engine.Cache.Set(utils.CacheDispatchers, dsp.TenantID(), value, nil, true, utils.EmptyString) + + err := dm.SetDispatcherProfile(dsp, false) + if err != nil { + t.Errorf("\nExpected <%+v>, \nReceived <%+v>", nil, err) + } + dss := NewDispatcherService(dm, cfg, nil, connMng) + ev := &utils.CGREvent{ + Tenant: "cgrates.org", + ID: "123", + Time: nil, + Event: map[string]interface{}{ + utils.AccountField: "1001", + "Password": "CGRateS.org", + "RunID": utils.MetaDefault, + }, + APIOpts: map[string]interface{}{ + utils.Subsys: utils.MetaAccounts, + }, + } + subsys := utils.IfaceAsString(ev.APIOpts[utils.Subsys]) + err = dss.Dispatch(ev, subsys, "", "", "") + expected := "HOST_NOT_FOUND" + if err == nil || err.Error() != expected { + t.Errorf("\nExpected <%+v>, \nReceived <%+v>", expected, err) + } + engine.Cache = cacheInit +} + +func TestDispatcherServiceDispatcherProfileForEventFoundFilter(t *testing.T) { + cfg := config.NewDefaultCGRConfig() + cfg.DispatcherSCfg().IndexedSelects = false + rpcCl := map[string]chan rpcclient.ClientConnector{} + connMng := engine.NewConnManager(cfg, rpcCl) + dataDB := engine.NewInternalDB(nil, nil, true) + dm := engine.NewDataManager(dataDB, nil, connMng) + dsp := &engine.DispatcherProfile{ + Tenant: "cgrates.org", + ID: "123", + Subsystems: []string{utils.MetaAccounts}, + FilterIDs: []string{"filter"}, + ActivationInterval: &utils.ActivationInterval{}, + Strategy: "", + StrategyParams: nil, + Weight: 0, + Hosts: nil, + } + err := dm.SetDispatcherProfile(dsp, false) + if err != nil { + t.Errorf("\nExpected <%+v>, \nReceived <%+v>", nil, err) + } + fltr := &engine.Filter{ + Tenant: "cgrates.org", + ID: "filter", + Rules: nil, + ActivationInterval: &utils.ActivationInterval{ + ActivationTime: time.Date(1999, 2, 3, 4, 5, 6, 700000000, time.UTC), + ExpiryTime: time.Date(2000, 2, 3, 4, 5, 6, 700000000, time.UTC), + }, + } + err = dm.SetFilter(fltr, false) + if err != nil { + t.Errorf("\nExpected <%+v>, \nReceived <%+v>", nil, err) + } + fltrs := engine.NewFilterS(cfg, connMng, dm) + dss := NewDispatcherService(dm, cfg, fltrs, connMng) + ev := &utils.CGREvent{ + Tenant: "cgrates.org", + ID: "123", + Event: map[string]interface{}{ + utils.AccountField: "1001", + "Password": "CGRateS.org", + "RunID": utils.MetaDefault, + }, + APIOpts: map[string]interface{}{ + utils.Subsys: utils.MetaAccounts, + }, + } + tnt := ev.Tenant + subsys := utils.IfaceAsString(ev.APIOpts[utils.Subsys]) + _, err = dss.dispatcherProfileForEvent(tnt, ev, subsys) + if err == nil || err.Error() != "NOT_FOUND" { + t.Errorf("\nExpected <%+v>, \nReceived <%+v>", "NOT_FOUND:filter", err) + } +} + +func TestDispatcherServiceDispatcherProfileForEventNotNotFound(t *testing.T) { + cfg := config.NewDefaultCGRConfig() + cfg.DispatcherSCfg().IndexedSelects = true + rpcCl := map[string]chan rpcclient.ClientConnector{} + connMng := engine.NewConnManager(cfg, rpcCl) + var cnt int + + dm := engine.NewDataManager(&engine.DataDBMock{ + GetIndexesDrvF: func(idxItmType, tntCtx, idxKey string) (indexes map[string]utils.StringSet, err error) { + if cnt == 0 { + cnt++ + return map[string]utils.StringSet{ + idxKey: utils.StringSet{"cgrates.org:dsp1": {}}, + }, nil + } + return nil, utils.ErrNotImplemented + }, + }, nil, connMng) + fltrs := engine.NewFilterS(cfg, connMng, dm) + dss := NewDispatcherService(dm, cfg, fltrs, connMng) + ev := &utils.CGREvent{ + Tenant: "cgrates.org", + ID: "123", + Event: map[string]interface{}{ + utils.AccountField: "1001", + "Password": "CGRateS.org", + "RunID": utils.MetaDefault, + }, + APIOpts: map[string]interface{}{ + utils.Subsys: utils.MetaAccounts, + }, + } + tnt := ev.Tenant + subsys := utils.IfaceAsString(ev.APIOpts[utils.Subsys]) + _, err := dss.dispatcherProfileForEvent(tnt, ev, subsys) + expected := utils.ErrNotImplemented + if err == nil || err != expected { + t.Errorf("\nExpected <%+v>, \nReceived <%+v>", expected, err) + } +} + +/* +CALL +func TestDispatcherServiceCall2(t *testing.T) { + cfg := config.NewDefaultCGRConfig() + rpcCl := map[string]chan rpcclient.ClientConnector{} + connMng := engine.NewConnManager(cfg, rpcCl) + dm := engine.NewDataManager(nil, nil, nil) + dsp := NewDispatcherService(dm, cfg, nil, connMng) + reply := "reply" + args := &utils.CGREvent{ + Tenant: "cgrates.org", + ID: "123", + Time: nil, + Event: map[string]interface{}{ + utils.AccountField: "1001", + "Password": "CGRateS.org", + "RunID": utils.MetaDefault, + }, + APIOpts: map[string]interface{}{ + utils.Subsys: utils.MetaDispatchers, + }, + } + err := dsp.Call(utils.DispatcherServicePing, args, &reply) + if err != nil { + t.Errorf("\nExpected <%+v>, \nReceived <%+v>", nil, err) + } +} + +func TestDispatcherServiceDispatchDspErrHostNotFound2(t *testing.T) { + cacheInit := engine.Cache + cfg := config.NewDefaultCGRConfig() + cfg.DispatcherSCfg().IndexedSelects = false + rpcCl := map[string]chan rpcclient.ClientConnector{} + connMng := engine.NewConnManager(cfg, rpcCl) + dataDB := engine.NewInternalDB(nil, nil, true) + dm := engine.NewDataManager(dataDB, nil, connMng) + dsp := &engine.DispatcherProfile{ + Tenant: "cgrates.org", + ID: "123", + Subsystems: []string{utils.MetaAccounts}, + FilterIDs: nil, + ActivationInterval: nil, + StrategyParams: make(map[string]interface{}), + Strategy: utils.MetaWeight, + Weight: 0, + Hosts: nil, + } + newCache := engine.NewCacheS(cfg, dm, nil) + value, errDsp := newDispatcher(dm, dsp) + if errDsp != nil { + t.Fatal(errDsp) + } + engine.Cache = newCache + engine.Cache.Set(utils.CacheDispatchers, dsp.TenantID(), value, nil, true, utils.EmptyString) + + err := dm.SetDispatcherProfile(dsp, false) + if err != nil { + t.Errorf("\nExpected <%+v>, \nReceived <%+v>", nil, err) + } + dss := NewDispatcherService(dm, cfg, nil, connMng) + ev := &utils.CGREvent{ + Tenant: "cgrates.org", + ID: "123", + Time: nil, + Event: map[string]interface{}{ + utils.AccountField: "1001", + "Password": "CGRateS.org", + "RunID": utils.MetaDefault, + }, + APIOpts: map[string]interface{}{ + utils.Subsys: utils.MetaAccounts, + }, + } + subsys := utils.IfaceAsString(ev.APIOpts[utils.Subsys]) + err = dss.Dispatch(ev, subsys, "", "", "") + expected := "HOST_NOT_FOUND" + if err == nil || err.Error() != expected { + t.Errorf("\nExpected <%+v>, \nReceived <%+v>", expected, err) + } + engine.Cache = cacheInit +} + +func TestDispatcherServiceDispatcherProfileForEventGetDispatcherError(t *testing.T) { + cfg := config.NewDefaultCGRConfig() + cfg.DispatcherSCfg().IndexedSelects = false + rpcCl := map[string]chan rpcclient.ClientConnector{} + connMng := engine.NewConnManager(cfg, rpcCl) + dm := engine.NewDataManager(&engine.DataDBMock{}, nil, connMng) + dsp := &engine.DispatcherProfile{ + Tenant: "cgrates.org", + ID: "123", + Subsystems: []string{utils.MetaAccounts}, + FilterIDs: []string{"filter"}, + ActivationInterval: &utils.ActivationInterval{}, + Strategy: "", + StrategyParams: nil, + Weight: 0, + Hosts: nil, + } + err := dm.SetDispatcherProfile(dsp, false) + if err != nil { + t.Errorf("\nExpected <%+v>, \nReceived <%+v>", nil, err) + } + fltr := &engine.Filter{ + Tenant: "cgrates.org", + ID: "filter", + Rules: nil, + ActivationInterval: &utils.ActivationInterval{ + ActivationTime: time.Date(1999, 2, 3, 4, 5, 6, 700000000, time.UTC), + ExpiryTime: time.Date(2000, 2, 3, 4, 5, 6, 700000000, time.UTC), + }, + } + err = dm.SetFilter(fltr, false) + if err != nil { + t.Errorf("\nExpected <%+v>, \nReceived <%+v>", nil, err) + } + fltrs := engine.NewFilterS(cfg, connMng, dm) + dss := NewDispatcherService(dm, cfg, fltrs, connMng) + ev := &utils.CGREvent{ + Tenant: "cgrates.org", + ID: "123", + Event: map[string]interface{}{ + utils.AccountField: "1001", + "Password": "CGRateS.org", + "RunID": utils.MetaDefault, + }, + APIOpts: map[string]interface{}{ + utils.Subsys: utils.MetaAccounts, + }, + } + tnt := ev.Tenant + subsys := utils.IfaceAsString(ev.APIOpts[utils.Subsys]) + _, err = dss.dispatcherProfileForEvent(tnt, ev, subsys) + if err == nil || err.Error() != "NOT_FOUND" { + t.Errorf("\nExpected <%+v>, \nReceived <%+v>", "NOT_FOUND:filter", err) + } +} + +*/ diff --git a/engine/datadbmock.go b/engine/datadbmock.go index ef7252e35..f9d1aff85 100644 --- a/engine/datadbmock.go +++ b/engine/datadbmock.go @@ -26,6 +26,7 @@ type DataDBMock struct { GetKeysForPrefixF func(string) ([]string, error) GetChargerProfileDrvF func(string, string) (*ChargerProfile, error) GetFilterDrvF func(string, string) (*Filter, error) + GetIndexesDrvF func(idxItmType, tntCtx, idxKey string) (indexes map[string]utils.StringSet, err error) } //Storage methods @@ -245,6 +246,9 @@ func (dbM *DataDBMock) AddLoadHistory(*utils.LoadInstance, int, string) error { } func (dbM *DataDBMock) GetIndexesDrv(idxItmType, tntCtx, idxKey string) (indexes map[string]utils.StringSet, err error) { + if dbM.GetIndexesDrvF != nil { + return dbM.GetIndexesDrvF(idxItmType, tntCtx, idxKey) + } return nil, utils.ErrNotImplemented } diff --git a/engine/filters.go b/engine/filters.go index 156bfaf4a..c13f40283 100644 --- a/engine/filters.go +++ b/engine/filters.go @@ -44,7 +44,7 @@ type FilterS struct { connMgr *ConnManager } -// Pass will check all filters wihin filterIDs and require them passing for dataProvider +// Pass will check all filters within filterIDs and require them passing for dataProvider // there should be at least one filter passing, ie: if filters are not active event will fail to pass // receives the event as DataProvider so we can accept undecoded data (ie: HttpRequest) func (fS *FilterS) Pass(tenant string, filterIDs []string,