From a1ed51b3010adadfae22d0bd68bc2322fa9fd391 Mon Sep 17 00:00:00 2001 From: ionutboangiu Date: Sat, 9 Nov 2024 18:31:10 +0200 Subject: [PATCH] Comment services tests --- services/accounts_it_test.go | 176 +++--- services/accounts_test.go | 126 ++-- services/actions_it_test.go | 174 +++--- services/actions_test.go | 126 ++-- services/analyzers_it_test.go | 256 ++++---- services/analyzers_test.go | 126 ++-- services/asteriskagent_it_test.go | 284 ++++----- services/asteriskagent_test.go | 114 ++-- services/attributes_it_test.go | 178 +++--- services/attributes_test.go | 130 ++-- services/cdrs_it_test.go | 196 +++--- services/cdrs_test.go | 138 ++--- services/chargers_it_test.go | 170 ++--- services/chargers_test.go | 130 ++-- services/cores_it_test.go | 156 ++--- services/cores_test.go | 112 ++-- services/datadb_it_test.go | 930 ++++++++++++++-------------- services/datadb_test.go | 144 ++--- services/diameteragent_it_test.go | 232 +++---- services/dispatchers_it_test.go | 174 +++--- services/dispatchers_test.go | 130 ++-- services/dnsagent_it_test.go | 478 +++++++------- services/dnsagent_test.go | 96 +-- services/ees_it_test.go | 241 +++---- services/ees_test.go | 114 ++-- services/ers_it_test.go | 243 ++++---- services/ers_test.go | 108 ++-- services/freeswitchagent_it_test.go | 340 +++++----- services/freeswitchagent_test.go | 86 +-- services/globalvars_it_test.go | 82 +-- services/httpagent_it_test.go | 150 ++--- services/httpagent_test.go | 106 ++-- services/kamailioagent_it_test.go | 244 ++++---- services/kamailioagent_test.go | 94 +-- services/libcgr-engine_test.go | 296 ++++----- services/loaders_it_test.go | 346 +++++------ services/loaders_test.go | 136 ++-- services/radiusagent_it_test.go | 394 ++++++------ services/radiusagent_test.go | 94 +-- services/rankings_test.go | 88 +-- services/rates_it_test.go | 150 ++--- services/rates_test.go | 118 ++-- services/registrarc_it_test.go | 230 +++---- services/registrarc_test.go | 124 ++-- services/resources_it_test.go | 174 +++--- services/resources_test.go | 106 ++-- services/routes_it_test.go | 164 ++--- services/routes_test.go | 119 ++-- services/sessions_it_test.go | 386 ++++++------ services/sessions_test.go | 122 ++-- services/sipagent_it_test.go | 250 ++++---- services/sipagent_test.go | 86 +-- services/stats_it_test.go | 174 +++--- services/stats_test.go | 106 ++-- services/thresholds_it_test.go | 296 ++++----- services/thresholds_test.go | 102 +-- services/trends_test.go | 128 ++-- 57 files changed, 5388 insertions(+), 5385 deletions(-) diff --git a/services/accounts_it_test.go b/services/accounts_it_test.go index 0fb5c1050..c595a5a4c 100644 --- a/services/accounts_it_test.go +++ b/services/accounts_it_test.go @@ -20,91 +20,91 @@ along with this program. If not, see */ package services -import ( - "path" - "sync" - "testing" - "time" - - "github.com/cgrates/birpc" - "github.com/cgrates/birpc/context" - "github.com/cgrates/cgrates/commonlisteners" - "github.com/cgrates/cgrates/config" - "github.com/cgrates/cgrates/engine" - "github.com/cgrates/cgrates/servmanager" - "github.com/cgrates/cgrates/utils" -) - -func TestAccountSReload(t *testing.T) { - cfg := config.NewDefaultCGRConfig() - - shdWg := new(sync.WaitGroup) - chS := engine.NewCacheS(cfg, nil, nil, nil) - filterSChan := make(chan *engine.FilterS, 1) - filterSChan <- nil - close(chS.GetPrecacheChannel(utils.CacheAccounts)) - close(chS.GetPrecacheChannel(utils.CacheAccountsFilterIndexes)) - chSCh := make(chan *engine.CacheS, 1) - chSCh <- chS - css := &CacheService{cacheCh: chSCh} - cls := commonlisteners.NewCommonListenerS(nil) - srvMngr := servmanager.NewServiceManager(shdWg, nil, cfg) - srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} - db := NewDataDBService(cfg, nil, false, srvDep) - acctRPC := make(chan birpc.ClientConnector, 1) - anz := NewAnalyzerService(cfg, cls, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) - acctS := NewAccountService(cfg, db, css, filterSChan, nil, cls, acctRPC, anz, srvDep) - engine.NewConnManager(cfg) - srvMngr.AddServices(acctS, - NewLoaderService(cfg, db, filterSChan, cls, make(chan birpc.ClientConnector, 1), nil, anz, srvDep), db) - ctx, cancel := context.WithCancel(context.TODO()) - srvMngr.StartServices(ctx, cancel) - if acctS.IsRunning() { - t.Errorf("Expected service to be down") - } - if db.IsRunning() { - t.Errorf("Expected service to be down") - } - - var reply string - cfg.ConfigPath = path.Join("/usr", "share", "cgrates", "conf", "samples", "tutmongo") - if err := cfg.V1ReloadConfig(context.Background(), &config.ReloadArgs{ - Section: config.AccountSJSON, - }, &reply); err != nil { - t.Error(err) - } else if reply != utils.OK { - t.Errorf("Expecting OK ,received %s", reply) - } - select { - case d := <-acctRPC: - acctRPC <- d - case <-time.After(time.Second): - t.Fatal("It took to long to reload the cache") - } - if !acctS.IsRunning() { - t.Errorf("Expected service to be running") - } - if !db.IsRunning() { - t.Errorf("Expected service to be running") - } - err := acctS.Start(ctx, cancel) - if err == nil || err != utils.ErrServiceAlreadyRunning { - t.Errorf("\nExpecting <%+v>,\n Received <%+v>", utils.ErrServiceAlreadyRunning, err) - } - err = acctS.Reload(ctx, cancel) - if err != nil { - t.Errorf("\nExpecting ,\n Received <%+v>", err) - } - cfg.AccountSCfg().Enabled = false - - cfg.GetReloadChan() <- config.SectionToService[config.AccountSJSON] - time.Sleep(10 * time.Millisecond) - - if acctS.IsRunning() { - t.Errorf("Expected service to be down") - } - - cancel() - time.Sleep(10 * time.Millisecond) - -} +// import ( +// "path" +// "sync" +// "testing" +// "time" +// +// "github.com/cgrates/birpc" +// "github.com/cgrates/birpc/context" +// "github.com/cgrates/cgrates/commonlisteners" +// "github.com/cgrates/cgrates/config" +// "github.com/cgrates/cgrates/engine" +// "github.com/cgrates/cgrates/servmanager" +// "github.com/cgrates/cgrates/utils" +// ) +// +// func TestAccountSReload(t *testing.T) { +// cfg := config.NewDefaultCGRConfig() +// +// shdWg := new(sync.WaitGroup) +// chS := engine.NewCacheS(cfg, nil, nil, nil) +// filterSChan := make(chan *engine.FilterS, 1) +// filterSChan <- nil +// close(chS.GetPrecacheChannel(utils.CacheAccounts)) +// close(chS.GetPrecacheChannel(utils.CacheAccountsFilterIndexes)) +// chSCh := make(chan *engine.CacheS, 1) +// chSCh <- chS +// css := &CacheService{cacheCh: chSCh} +// cls := commonlisteners.NewCommonListenerS(nil) +// srvMngr := servmanager.NewServiceManager(shdWg, nil, cfg) +// srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} +// db := NewDataDBService(cfg, nil, false, srvDep) +// acctRPC := make(chan birpc.ClientConnector, 1) +// anz := NewAnalyzerService(cfg, cls, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) +// acctS := NewAccountService(cfg, db, css, filterSChan, nil, cls, acctRPC, anz, srvDep) +// engine.NewConnManager(cfg) +// srvMngr.AddServices(acctS, +// NewLoaderService(cfg, db, filterSChan, cls, make(chan birpc.ClientConnector, 1), nil, anz, srvDep), db) +// ctx, cancel := context.WithCancel(context.TODO()) +// srvMngr.StartServices(ctx, cancel) +// if acctS.IsRunning() { +// t.Errorf("Expected service to be down") +// } +// if db.IsRunning() { +// t.Errorf("Expected service to be down") +// } +// +// var reply string +// cfg.ConfigPath = path.Join("/usr", "share", "cgrates", "conf", "samples", "tutmongo") +// if err := cfg.V1ReloadConfig(context.Background(), &config.ReloadArgs{ +// Section: config.AccountSJSON, +// }, &reply); err != nil { +// t.Error(err) +// } else if reply != utils.OK { +// t.Errorf("Expecting OK ,received %s", reply) +// } +// select { +// case d := <-acctRPC: +// acctRPC <- d +// case <-time.After(time.Second): +// t.Fatal("It took to long to reload the cache") +// } +// if !acctS.IsRunning() { +// t.Errorf("Expected service to be running") +// } +// if !db.IsRunning() { +// t.Errorf("Expected service to be running") +// } +// err := acctS.Start(ctx, cancel) +// if err == nil || err != utils.ErrServiceAlreadyRunning { +// t.Errorf("\nExpecting <%+v>,\n Received <%+v>", utils.ErrServiceAlreadyRunning, err) +// } +// err = acctS.Reload(ctx, cancel) +// if err != nil { +// t.Errorf("\nExpecting ,\n Received <%+v>", err) +// } +// cfg.AccountSCfg().Enabled = false +// +// cfg.GetReloadChan() <- config.SectionToService[config.AccountSJSON] +// time.Sleep(10 * time.Millisecond) +// +// if acctS.IsRunning() { +// t.Errorf("Expected service to be down") +// } +// +// cancel() +// time.Sleep(10 * time.Millisecond) +// +// } diff --git a/services/accounts_test.go b/services/accounts_test.go index 461929114..32e3157e1 100644 --- a/services/accounts_test.go +++ b/services/accounts_test.go @@ -17,66 +17,66 @@ along with this program. If not, see */ package services -import ( - "reflect" - "sync" - "testing" - - "github.com/cgrates/birpc" - "github.com/cgrates/birpc/context" - "github.com/cgrates/cgrates/accounts" - "github.com/cgrates/cgrates/commonlisteners" - - "github.com/cgrates/cgrates/config" - "github.com/cgrates/cgrates/engine" - "github.com/cgrates/cgrates/utils" -) - -// TestAccountSCoverage for cover testing -func TestAccountSCoverage(t *testing.T) { - cfg := config.NewDefaultCGRConfig() - filterSChan := make(chan *engine.FilterS, 1) - filterSChan <- nil - cls := commonlisteners.NewCommonListenerS(nil) - srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} - db := NewDataDBService(cfg, nil, false, srvDep) - actRPC := make(chan birpc.ClientConnector, 1) - anz := NewAnalyzerService(cfg, cls, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) - chS := NewCacheService(cfg, db, nil, cls, make(chan context.ClientConnector, 1), anz, nil, srvDep) - actS := NewAccountService(cfg, db, - chS, filterSChan, nil, cls, actRPC, - anz, srvDep) - if actS == nil { - t.Errorf("\nExpecting ,\n Received <%+v>", utils.ToJSON(actS)) - } - //initialises an empty chan to call the reload function - testChan := make(chan struct{}) - //populates actRPC with something in order to call the close function - actS2 := &AccountService{ - cfg: cfg, - dm: db, - cacheS: chS, - filterSChan: filterSChan, - cls: cls, - rldChan: testChan, - stopChan: make(chan struct{}, 1), - connChan: actRPC, - anz: anz, - srvDep: srvDep, - } - if actS2.IsRunning() { - t.Errorf("Expected service to be down") - } - actS2.acts = accounts.NewAccountS(cfg, &engine.FilterS{}, nil, &engine.DataManager{}) - if !actS2.IsRunning() { - t.Errorf("Expected service to be running") - } - serviceName := actS2.ServiceName() - if !reflect.DeepEqual(serviceName, utils.AccountS) { - t.Errorf("\nExpecting <%+v>,\n Received <%+v>", utils.AccountS, serviceName) - } - shouldRun := actS2.ShouldRun() - if !reflect.DeepEqual(shouldRun, false) { - t.Errorf("\nExpecting ,\n Received <%+v>", shouldRun) - } -} +// import ( +// "reflect" +// "sync" +// "testing" +// +// "github.com/cgrates/birpc" +// "github.com/cgrates/birpc/context" +// "github.com/cgrates/cgrates/accounts" +// "github.com/cgrates/cgrates/commonlisteners" +// +// "github.com/cgrates/cgrates/config" +// "github.com/cgrates/cgrates/engine" +// "github.com/cgrates/cgrates/utils" +// ) +// +// // TestAccountSCoverage for cover testing +// func TestAccountSCoverage(t *testing.T) { +// cfg := config.NewDefaultCGRConfig() +// filterSChan := make(chan *engine.FilterS, 1) +// filterSChan <- nil +// cls := commonlisteners.NewCommonListenerS(nil) +// srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} +// db := NewDataDBService(cfg, nil, false, srvDep) +// actRPC := make(chan birpc.ClientConnector, 1) +// anz := NewAnalyzerService(cfg, cls, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) +// chS := NewCacheService(cfg, db, nil, cls, make(chan context.ClientConnector, 1), anz, nil, srvDep) +// actS := NewAccountService(cfg, db, +// chS, filterSChan, nil, cls, actRPC, +// anz, srvDep) +// if actS == nil { +// t.Errorf("\nExpecting ,\n Received <%+v>", utils.ToJSON(actS)) +// } +// //initialises an empty chan to call the reload function +// testChan := make(chan struct{}) +// //populates actRPC with something in order to call the close function +// actS2 := &AccountService{ +// cfg: cfg, +// dm: db, +// cacheS: chS, +// filterSChan: filterSChan, +// cls: cls, +// rldChan: testChan, +// stopChan: make(chan struct{}, 1), +// connChan: actRPC, +// anz: anz, +// srvDep: srvDep, +// } +// if actS2.IsRunning() { +// t.Errorf("Expected service to be down") +// } +// actS2.acts = accounts.NewAccountS(cfg, &engine.FilterS{}, nil, &engine.DataManager{}) +// if !actS2.IsRunning() { +// t.Errorf("Expected service to be running") +// } +// serviceName := actS2.ServiceName() +// if !reflect.DeepEqual(serviceName, utils.AccountS) { +// t.Errorf("\nExpecting <%+v>,\n Received <%+v>", utils.AccountS, serviceName) +// } +// shouldRun := actS2.ShouldRun() +// if !reflect.DeepEqual(shouldRun, false) { +// t.Errorf("\nExpecting ,\n Received <%+v>", shouldRun) +// } +// } diff --git a/services/actions_it_test.go b/services/actions_it_test.go index 29fb866ae..f3e64d186 100644 --- a/services/actions_it_test.go +++ b/services/actions_it_test.go @@ -20,90 +20,90 @@ along with this program. If not, see */ package services -import ( - "path" - "sync" - "testing" - "time" - - "github.com/cgrates/birpc" - "github.com/cgrates/birpc/context" - "github.com/cgrates/cgrates/commonlisteners" - "github.com/cgrates/cgrates/config" - "github.com/cgrates/cgrates/engine" - "github.com/cgrates/cgrates/servmanager" - "github.com/cgrates/cgrates/utils" -) - -func TestActionSReload(t *testing.T) { - cfg := config.NewDefaultCGRConfig() - - shdWg := new(sync.WaitGroup) - chS := engine.NewCacheS(cfg, nil, nil, nil) - filterSChan := make(chan *engine.FilterS, 1) - filterSChan <- nil - close(chS.GetPrecacheChannel(utils.CacheActionProfiles)) - close(chS.GetPrecacheChannel(utils.CacheActionProfilesFilterIndexes)) - chSCh := make(chan *engine.CacheS, 1) - chSCh <- chS - css := &CacheService{cacheCh: chSCh} - cls := commonlisteners.NewCommonListenerS(nil) - srvMngr := servmanager.NewServiceManager(shdWg, nil, cfg) - srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} - db := NewDataDBService(cfg, nil, false, srvDep) - actRPC := make(chan birpc.ClientConnector, 1) - anz := NewAnalyzerService(cfg, cls, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) - actS := NewActionService(cfg, db, css, filterSChan, nil, cls, actRPC, anz, srvDep) - engine.NewConnManager(cfg) - srvMngr.AddServices(actS, - NewLoaderService(cfg, db, filterSChan, cls, make(chan birpc.ClientConnector, 1), nil, anz, srvDep), db) - ctx, cancel := context.WithCancel(context.TODO()) - srvMngr.StartServices(ctx, cancel) - if actS.IsRunning() { - t.Errorf("Expected service to be down") - } - if db.IsRunning() { - t.Errorf("Expected service to be down") - } - - var reply string - cfg.ConfigPath = path.Join("/usr", "share", "cgrates", "conf", "samples", "tutmongo") - if err := cfg.V1ReloadConfig(context.Background(), &config.ReloadArgs{ - Section: config.ActionSJSON, - }, &reply); err != nil { - t.Error(err) - } else if reply != utils.OK { - t.Errorf("Expecting OK ,received %s", reply) - } - select { - case d := <-actRPC: - actRPC <- d - case <-time.After(time.Second): - t.Fatal("It took to long to reload the cache") - } - if !actS.IsRunning() { - t.Errorf("Expected service to be running") - } - if !db.IsRunning() { - t.Errorf("Expected service to be running") - } - err := actS.Start(ctx, cancel) - if err == nil || err != utils.ErrServiceAlreadyRunning { - t.Errorf("\nExpecting <%+v>,\n Received <%+v>", utils.ErrServiceAlreadyRunning, err) - } - err = actS.Reload(ctx, cancel) - if err != nil { - t.Errorf("\nExpecting ,\n Received <%+v>", err) - } - cfg.ActionSCfg().Enabled = false - cfg.GetReloadChan() <- config.SectionToService[config.ActionSJSON] - time.Sleep(10 * time.Millisecond) - - if actS.IsRunning() { - t.Errorf("Expected service to be down") - } - - cancel() - time.Sleep(10 * time.Millisecond) - -} +// import ( +// "path" +// "sync" +// "testing" +// "time" +// +// "github.com/cgrates/birpc" +// "github.com/cgrates/birpc/context" +// "github.com/cgrates/cgrates/commonlisteners" +// "github.com/cgrates/cgrates/config" +// "github.com/cgrates/cgrates/engine" +// "github.com/cgrates/cgrates/servmanager" +// "github.com/cgrates/cgrates/utils" +// ) +// +// func TestActionSReload(t *testing.T) { +// cfg := config.NewDefaultCGRConfig() +// +// shdWg := new(sync.WaitGroup) +// chS := engine.NewCacheS(cfg, nil, nil, nil) +// filterSChan := make(chan *engine.FilterS, 1) +// filterSChan <- nil +// close(chS.GetPrecacheChannel(utils.CacheActionProfiles)) +// close(chS.GetPrecacheChannel(utils.CacheActionProfilesFilterIndexes)) +// chSCh := make(chan *engine.CacheS, 1) +// chSCh <- chS +// css := &CacheService{cacheCh: chSCh} +// cls := commonlisteners.NewCommonListenerS(nil) +// srvMngr := servmanager.NewServiceManager(shdWg, nil, cfg) +// srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} +// db := NewDataDBService(cfg, nil, false, srvDep) +// actRPC := make(chan birpc.ClientConnector, 1) +// anz := NewAnalyzerService(cfg, cls, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) +// actS := NewActionService(cfg, db, css, filterSChan, nil, cls, actRPC, anz, srvDep) +// engine.NewConnManager(cfg) +// srvMngr.AddServices(actS, +// NewLoaderService(cfg, db, filterSChan, cls, make(chan birpc.ClientConnector, 1), nil, anz, srvDep), db) +// ctx, cancel := context.WithCancel(context.TODO()) +// srvMngr.StartServices(ctx, cancel) +// if actS.IsRunning() { +// t.Errorf("Expected service to be down") +// } +// if db.IsRunning() { +// t.Errorf("Expected service to be down") +// } +// +// var reply string +// cfg.ConfigPath = path.Join("/usr", "share", "cgrates", "conf", "samples", "tutmongo") +// if err := cfg.V1ReloadConfig(context.Background(), &config.ReloadArgs{ +// Section: config.ActionSJSON, +// }, &reply); err != nil { +// t.Error(err) +// } else if reply != utils.OK { +// t.Errorf("Expecting OK ,received %s", reply) +// } +// select { +// case d := <-actRPC: +// actRPC <- d +// case <-time.After(time.Second): +// t.Fatal("It took to long to reload the cache") +// } +// if !actS.IsRunning() { +// t.Errorf("Expected service to be running") +// } +// if !db.IsRunning() { +// t.Errorf("Expected service to be running") +// } +// err := actS.Start(ctx, cancel) +// if err == nil || err != utils.ErrServiceAlreadyRunning { +// t.Errorf("\nExpecting <%+v>,\n Received <%+v>", utils.ErrServiceAlreadyRunning, err) +// } +// err = actS.Reload(ctx, cancel) +// if err != nil { +// t.Errorf("\nExpecting ,\n Received <%+v>", err) +// } +// cfg.ActionSCfg().Enabled = false +// cfg.GetReloadChan() <- config.SectionToService[config.ActionSJSON] +// time.Sleep(10 * time.Millisecond) +// +// if actS.IsRunning() { +// t.Errorf("Expected service to be down") +// } +// +// cancel() +// time.Sleep(10 * time.Millisecond) +// +// } diff --git a/services/actions_test.go b/services/actions_test.go index 8f98b81a9..3d8eb2e05 100644 --- a/services/actions_test.go +++ b/services/actions_test.go @@ -17,66 +17,66 @@ along with this program. If not, see */ package services -import ( - "reflect" - "sync" - "testing" - - "github.com/cgrates/birpc" - "github.com/cgrates/birpc/context" - "github.com/cgrates/cgrates/actions" - "github.com/cgrates/cgrates/commonlisteners" - "github.com/cgrates/cgrates/config" - "github.com/cgrates/cgrates/engine" - "github.com/cgrates/cgrates/utils" -) - -// TestActionSCoverage for cover testing -func TestActionSCoverage(t *testing.T) { - cfg := config.NewDefaultCGRConfig() - filterSChan := make(chan *engine.FilterS, 1) - filterSChan <- nil - cls := commonlisteners.NewCommonListenerS(nil) - srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} - db := NewDataDBService(cfg, nil, false, srvDep) - actRPC := make(chan birpc.ClientConnector, 1) - anz := NewAnalyzerService(cfg, cls, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) - chS := NewCacheService(cfg, db, nil, cls, make(chan context.ClientConnector, 1), anz, nil, srvDep) - actS := NewActionService(cfg, db, - chS, filterSChan, nil, cls, actRPC, - anz, srvDep) - if actS == nil { - t.Errorf("\nExpecting ,\n Received <%+v>", utils.ToJSON(actS)) - } - //initialises an empty chan to call the reload function - testChan := make(chan struct{}) - //populates actRPC with something in order to call the close function - - actS2 := &ActionService{ - cfg: cfg, - dm: db, - cacheS: chS, - filterSChan: filterSChan, - cls: cls, - rldChan: testChan, - stopChan: make(chan struct{}, 1), - connChan: actRPC, - anz: anz, - srvDep: srvDep, - } - if actS2.IsRunning() { - t.Errorf("Expected service to be down") - } - actS2.acts = actions.NewActionS(cfg, &engine.FilterS{}, &engine.DataManager{}, nil) - if !actS2.IsRunning() { - t.Errorf("Expected service to be running") - } - serviceName := actS2.ServiceName() - if !reflect.DeepEqual(serviceName, utils.ActionS) { - t.Errorf("\nExpecting <%+v>,\n Received <%+v>", utils.ActionS, serviceName) - } - shouldRun := actS2.ShouldRun() - if !reflect.DeepEqual(shouldRun, false) { - t.Errorf("\nExpecting ,\n Received <%+v>", shouldRun) - } -} +// import ( +// "reflect" +// "sync" +// "testing" +// +// "github.com/cgrates/birpc" +// "github.com/cgrates/birpc/context" +// "github.com/cgrates/cgrates/actions" +// "github.com/cgrates/cgrates/commonlisteners" +// "github.com/cgrates/cgrates/config" +// "github.com/cgrates/cgrates/engine" +// "github.com/cgrates/cgrates/utils" +// ) +// +// // TestActionSCoverage for cover testing +// func TestActionSCoverage(t *testing.T) { +// cfg := config.NewDefaultCGRConfig() +// filterSChan := make(chan *engine.FilterS, 1) +// filterSChan <- nil +// cls := commonlisteners.NewCommonListenerS(nil) +// srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} +// db := NewDataDBService(cfg, nil, false, srvDep) +// actRPC := make(chan birpc.ClientConnector, 1) +// anz := NewAnalyzerService(cfg, cls, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) +// chS := NewCacheService(cfg, db, nil, cls, make(chan context.ClientConnector, 1), anz, nil, srvDep) +// actS := NewActionService(cfg, db, +// chS, filterSChan, nil, cls, actRPC, +// anz, srvDep) +// if actS == nil { +// t.Errorf("\nExpecting ,\n Received <%+v>", utils.ToJSON(actS)) +// } +// //initialises an empty chan to call the reload function +// testChan := make(chan struct{}) +// //populates actRPC with something in order to call the close function +// +// actS2 := &ActionService{ +// cfg: cfg, +// dm: db, +// cacheS: chS, +// filterSChan: filterSChan, +// cls: cls, +// rldChan: testChan, +// stopChan: make(chan struct{}, 1), +// connChan: actRPC, +// anz: anz, +// srvDep: srvDep, +// } +// if actS2.IsRunning() { +// t.Errorf("Expected service to be down") +// } +// actS2.acts = actions.NewActionS(cfg, &engine.FilterS{}, &engine.DataManager{}, nil) +// if !actS2.IsRunning() { +// t.Errorf("Expected service to be running") +// } +// serviceName := actS2.ServiceName() +// if !reflect.DeepEqual(serviceName, utils.ActionS) { +// t.Errorf("\nExpecting <%+v>,\n Received <%+v>", utils.ActionS, serviceName) +// } +// shouldRun := actS2.ShouldRun() +// if !reflect.DeepEqual(shouldRun, false) { +// t.Errorf("\nExpecting ,\n Received <%+v>", shouldRun) +// } +// } diff --git a/services/analyzers_it_test.go b/services/analyzers_it_test.go index a57c9695d..5940704e1 100644 --- a/services/analyzers_it_test.go +++ b/services/analyzers_it_test.go @@ -20,131 +20,131 @@ along with this program. If not, see */ package services -import ( - "log" - "os" - "path" - "sync" - "testing" - "time" - - "github.com/cgrates/birpc" - "github.com/cgrates/birpc/context" - "github.com/cgrates/cgrates/commonlisteners" - "github.com/cgrates/cgrates/config" - "github.com/cgrates/cgrates/engine" - "github.com/cgrates/cgrates/servmanager" - "github.com/cgrates/cgrates/utils" -) - -func TestAnalyzerSReload(t *testing.T) { - cfg := config.NewDefaultCGRConfig() - if err := os.MkdirAll("/tmp/analyzers", 0700); err != nil { - t.Fatal(err) - } - - shdWg := new(sync.WaitGroup) - filterSChan := make(chan *engine.FilterS, 1) - filterSChan <- nil - cls := commonlisteners.NewCommonListenerS(nil) - srvMngr := servmanager.NewServiceManager(shdWg, nil, cfg) - srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} - db := NewDataDBService(cfg, nil, false, srvDep) - anzRPC := make(chan birpc.ClientConnector, 1) - anz := NewAnalyzerService(cfg, cls, filterSChan, anzRPC, srvDep) - engine.NewConnManager(cfg) - srvMngr.AddServices(anz, - NewLoaderService(cfg, db, filterSChan, cls, make(chan birpc.ClientConnector, 1), nil, anz, srvDep), db) - ctx, cancel := context.WithCancel(context.TODO()) - srvMngr.StartServices(ctx, cancel) - if anz.IsRunning() { - t.Errorf("Expected service to be down") - } - - var reply string - cfg.ConfigPath = path.Join("/usr", "share", "cgrates", "conf", "samples", "analyzers") - if err := cfg.V1ReloadConfig(context.Background(), &config.ReloadArgs{ - Section: config.AnalyzerSJSON, - }, &reply); err != nil { - t.Error(err) - } else if reply != utils.OK { - t.Errorf("Expecting OK ,received %s", reply) - } - select { - case d := <-anzRPC: - anzRPC <- d - case <-time.After(time.Second): - t.Fatal("It took to long to reload the cache") - } - if !anz.IsRunning() { - t.Errorf("Expected service to be running") - } - err := anz.Start(ctx, cancel) - if err == nil || err != utils.ErrServiceAlreadyRunning { - t.Errorf("\nExpecting <%+v>,\n Received <%+v>", utils.ErrServiceAlreadyRunning, err) - } - err = anz.Reload(ctx, cancel) - if err != nil { - t.Errorf("\nExpecting ,\n Received <%+v>", err) - } - cfg.AnalyzerSCfg().Enabled = false - cfg.GetReloadChan() <- config.SectionToService[config.AnalyzerSJSON] - time.Sleep(10 * time.Millisecond) - - if anz.IsRunning() { - t.Errorf("Expected service to be down") - } - - cancel() - time.Sleep(10 * time.Millisecond) - if err := os.RemoveAll("/tmp/analyzers"); err != nil { - t.Fatal(err) - } -} - -func TestAnalyzerSReload2(t *testing.T) { - cfg := config.NewDefaultCGRConfig() - if err := os.MkdirAll("/tmp/analyzers", 0700); err != nil { - t.Fatal(err) - } - filterSChan := make(chan *engine.FilterS, 1) - filterSChan <- nil - cls := commonlisteners.NewCommonListenerS(nil) - srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} - anzRPC := make(chan birpc.ClientConnector, 1) - anz := NewAnalyzerService(cfg, cls, filterSChan, anzRPC, srvDep) - // anz.stopChan = make(chan struct{}) - // anz.start() - // close(anz.stopChan) - // anz.start() - anz.anz = nil - if err := os.RemoveAll("/tmp/analyzers"); err != nil { - t.Fatal(err) - } -} - -func TestAnalyzerSReload3(t *testing.T) { - cfg := config.NewDefaultCGRConfig() - if err := os.MkdirAll("/tmp/analyzers_test3", 0700); err != nil { - t.Fatal(err) - } - cfg.AnalyzerSCfg().DBPath = "/tmp/analyzers_test3" - err := os.RemoveAll("/tmp/analyzers_test3") - if err != nil { - log.Fatal(err) - } - cfg.AnalyzerSCfg().IndexType = "" - filterSChan := make(chan *engine.FilterS, 1) - filterSChan <- nil - cls := commonlisteners.NewCommonListenerS(nil) - srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} - anzRPC := make(chan birpc.ClientConnector, 1) - anz := NewAnalyzerService(cfg, cls, filterSChan, anzRPC, srvDep) - // anz.stopChan = make(chan struct{}) - ctx, cancel := context.WithCancel(context.TODO()) - anz.Start(ctx, cancel) - - anz.anz = nil - // close(anz.stopChan) - -} +// import ( +// "log" +// "os" +// "path" +// "sync" +// "testing" +// "time" +// +// "github.com/cgrates/birpc" +// "github.com/cgrates/birpc/context" +// "github.com/cgrates/cgrates/commonlisteners" +// "github.com/cgrates/cgrates/config" +// "github.com/cgrates/cgrates/engine" +// "github.com/cgrates/cgrates/servmanager" +// "github.com/cgrates/cgrates/utils" +// ) +// +// func TestAnalyzerSReload(t *testing.T) { +// cfg := config.NewDefaultCGRConfig() +// if err := os.MkdirAll("/tmp/analyzers", 0700); err != nil { +// t.Fatal(err) +// } +// +// shdWg := new(sync.WaitGroup) +// filterSChan := make(chan *engine.FilterS, 1) +// filterSChan <- nil +// cls := commonlisteners.NewCommonListenerS(nil) +// srvMngr := servmanager.NewServiceManager(shdWg, nil, cfg) +// srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} +// db := NewDataDBService(cfg, nil, false, srvDep) +// anzRPC := make(chan birpc.ClientConnector, 1) +// anz := NewAnalyzerService(cfg, cls, filterSChan, anzRPC, srvDep) +// engine.NewConnManager(cfg) +// srvMngr.AddServices(anz, +// NewLoaderService(cfg, db, filterSChan, cls, make(chan birpc.ClientConnector, 1), nil, anz, srvDep), db) +// ctx, cancel := context.WithCancel(context.TODO()) +// srvMngr.StartServices(ctx, cancel) +// if anz.IsRunning() { +// t.Errorf("Expected service to be down") +// } +// +// var reply string +// cfg.ConfigPath = path.Join("/usr", "share", "cgrates", "conf", "samples", "analyzers") +// if err := cfg.V1ReloadConfig(context.Background(), &config.ReloadArgs{ +// Section: config.AnalyzerSJSON, +// }, &reply); err != nil { +// t.Error(err) +// } else if reply != utils.OK { +// t.Errorf("Expecting OK ,received %s", reply) +// } +// select { +// case d := <-anzRPC: +// anzRPC <- d +// case <-time.After(time.Second): +// t.Fatal("It took to long to reload the cache") +// } +// if !anz.IsRunning() { +// t.Errorf("Expected service to be running") +// } +// err := anz.Start(ctx, cancel) +// if err == nil || err != utils.ErrServiceAlreadyRunning { +// t.Errorf("\nExpecting <%+v>,\n Received <%+v>", utils.ErrServiceAlreadyRunning, err) +// } +// err = anz.Reload(ctx, cancel) +// if err != nil { +// t.Errorf("\nExpecting ,\n Received <%+v>", err) +// } +// cfg.AnalyzerSCfg().Enabled = false +// cfg.GetReloadChan() <- config.SectionToService[config.AnalyzerSJSON] +// time.Sleep(10 * time.Millisecond) +// +// if anz.IsRunning() { +// t.Errorf("Expected service to be down") +// } +// +// cancel() +// time.Sleep(10 * time.Millisecond) +// if err := os.RemoveAll("/tmp/analyzers"); err != nil { +// t.Fatal(err) +// } +// } +// +// func TestAnalyzerSReload2(t *testing.T) { +// cfg := config.NewDefaultCGRConfig() +// if err := os.MkdirAll("/tmp/analyzers", 0700); err != nil { +// t.Fatal(err) +// } +// filterSChan := make(chan *engine.FilterS, 1) +// filterSChan <- nil +// cls := commonlisteners.NewCommonListenerS(nil) +// srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} +// anzRPC := make(chan birpc.ClientConnector, 1) +// anz := NewAnalyzerService(cfg, cls, filterSChan, anzRPC, srvDep) +// // anz.stopChan = make(chan struct{}) +// // anz.start() +// // close(anz.stopChan) +// // anz.start() +// anz.anz = nil +// if err := os.RemoveAll("/tmp/analyzers"); err != nil { +// t.Fatal(err) +// } +// } +// +// func TestAnalyzerSReload3(t *testing.T) { +// cfg := config.NewDefaultCGRConfig() +// if err := os.MkdirAll("/tmp/analyzers_test3", 0700); err != nil { +// t.Fatal(err) +// } +// cfg.AnalyzerSCfg().DBPath = "/tmp/analyzers_test3" +// err := os.RemoveAll("/tmp/analyzers_test3") +// if err != nil { +// log.Fatal(err) +// } +// cfg.AnalyzerSCfg().IndexType = "" +// filterSChan := make(chan *engine.FilterS, 1) +// filterSChan <- nil +// cls := commonlisteners.NewCommonListenerS(nil) +// srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} +// anzRPC := make(chan birpc.ClientConnector, 1) +// anz := NewAnalyzerService(cfg, cls, filterSChan, anzRPC, srvDep) +// // anz.stopChan = make(chan struct{}) +// ctx, cancel := context.WithCancel(context.TODO()) +// anz.Start(ctx, cancel) +// +// anz.anz = nil +// // close(anz.stopChan) +// +// } diff --git a/services/analyzers_test.go b/services/analyzers_test.go index f588c3932..89bc11d51 100644 --- a/services/analyzers_test.go +++ b/services/analyzers_test.go @@ -17,66 +17,66 @@ along with this program. If not, see */ package services -import ( - "reflect" - "sync" - "testing" - - "github.com/cgrates/birpc" - "github.com/cgrates/cgrates/analyzers" - "github.com/cgrates/cgrates/commonlisteners" - - "github.com/cgrates/cgrates/config" - "github.com/cgrates/cgrates/engine" - "github.com/cgrates/cgrates/utils" -) - -// TestAnalyzerCoverage for cover testing -func TestAnalyzerCoverage(t *testing.T) { - cfg := config.NewDefaultCGRConfig() - filterSChan := make(chan *engine.FilterS, 1) - filterSChan <- nil - cls := commonlisteners.NewCommonListenerS(nil) - srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} - connChan := make(chan birpc.ClientConnector, 1) - anz := NewAnalyzerService(cfg, cls, filterSChan, connChan, srvDep) - if anz == nil { - t.Errorf("\nExpecting ,\n Received <%+v>", utils.ToJSON(anz)) - } - anz2 := &AnalyzerService{ - RWMutex: sync.RWMutex{}, - cfg: cfg, - cls: cls, - filterSChan: filterSChan, - connChan: connChan, - srvDep: srvDep, - } - if anz2.IsRunning() { - t.Errorf("Expected service to be down") - } - var rpcClientCnctr birpc.ClientConnector - getIntrnCdc := anz2.GetInternalCodec(rpcClientCnctr, utils.EmptyString) - if !reflect.DeepEqual(getIntrnCdc, rpcClientCnctr) { - t.Errorf("\nExpecting <%+v>,\n Received <%+v>", utils.ToJSON(rpcClientCnctr), utils.ToJSON(getIntrnCdc)) - } - - anz2.anz, _ = analyzers.NewAnalyzerS(cfg) - if !anz2.IsRunning() { - t.Errorf("Expected service to be running") - } - serviceName := anz2.ServiceName() - if !reflect.DeepEqual(serviceName, utils.AnalyzerS) { - t.Errorf("\nExpecting <%+v>,\n Received <%+v>", utils.AnalyzerS, serviceName) - } - shouldRun := anz2.ShouldRun() - if !reflect.DeepEqual(shouldRun, false) { - t.Errorf("\nExpecting ,\n Received <%+v>", shouldRun) - } - var rpcClientCnctr2 birpc.ClientConnector - getIntrnCdc2 := anz2.GetInternalCodec(rpcClientCnctr2, utils.EmptyString) - expected2 := anz2.anz.NewAnalyzerConnector(nil, utils.MetaInternal, utils.EmptyString, utils.EmptyString) - if !reflect.DeepEqual(getIntrnCdc2, expected2) { - t.Errorf("\nExpecting <%+v>,\n Received <%+v>", utils.ToJSON(expected2), utils.ToJSON(getIntrnCdc2)) - } - -} +// import ( +// "reflect" +// "sync" +// "testing" +// +// "github.com/cgrates/birpc" +// "github.com/cgrates/cgrates/analyzers" +// "github.com/cgrates/cgrates/commonlisteners" +// +// "github.com/cgrates/cgrates/config" +// "github.com/cgrates/cgrates/engine" +// "github.com/cgrates/cgrates/utils" +// ) +// +// // TestAnalyzerCoverage for cover testing +// func TestAnalyzerCoverage(t *testing.T) { +// cfg := config.NewDefaultCGRConfig() +// filterSChan := make(chan *engine.FilterS, 1) +// filterSChan <- nil +// cls := commonlisteners.NewCommonListenerS(nil) +// srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} +// connChan := make(chan birpc.ClientConnector, 1) +// anz := NewAnalyzerService(cfg, cls, filterSChan, connChan, srvDep) +// if anz == nil { +// t.Errorf("\nExpecting ,\n Received <%+v>", utils.ToJSON(anz)) +// } +// anz2 := &AnalyzerService{ +// RWMutex: sync.RWMutex{}, +// cfg: cfg, +// cls: cls, +// filterSChan: filterSChan, +// connChan: connChan, +// srvDep: srvDep, +// } +// if anz2.IsRunning() { +// t.Errorf("Expected service to be down") +// } +// var rpcClientCnctr birpc.ClientConnector +// getIntrnCdc := anz2.GetInternalCodec(rpcClientCnctr, utils.EmptyString) +// if !reflect.DeepEqual(getIntrnCdc, rpcClientCnctr) { +// t.Errorf("\nExpecting <%+v>,\n Received <%+v>", utils.ToJSON(rpcClientCnctr), utils.ToJSON(getIntrnCdc)) +// } +// +// anz2.anz, _ = analyzers.NewAnalyzerS(cfg) +// if !anz2.IsRunning() { +// t.Errorf("Expected service to be running") +// } +// serviceName := anz2.ServiceName() +// if !reflect.DeepEqual(serviceName, utils.AnalyzerS) { +// t.Errorf("\nExpecting <%+v>,\n Received <%+v>", utils.AnalyzerS, serviceName) +// } +// shouldRun := anz2.ShouldRun() +// if !reflect.DeepEqual(shouldRun, false) { +// t.Errorf("\nExpecting ,\n Received <%+v>", shouldRun) +// } +// var rpcClientCnctr2 birpc.ClientConnector +// getIntrnCdc2 := anz2.GetInternalCodec(rpcClientCnctr2, utils.EmptyString) +// expected2 := anz2.anz.NewAnalyzerConnector(nil, utils.MetaInternal, utils.EmptyString, utils.EmptyString) +// if !reflect.DeepEqual(getIntrnCdc2, expected2) { +// t.Errorf("\nExpecting <%+v>,\n Received <%+v>", utils.ToJSON(expected2), utils.ToJSON(getIntrnCdc2)) +// } +// +// } diff --git a/services/asteriskagent_it_test.go b/services/asteriskagent_it_test.go index 572c99fe8..ad0eace15 100644 --- a/services/asteriskagent_it_test.go +++ b/services/asteriskagent_it_test.go @@ -20,145 +20,145 @@ along with this program. If not, see */ package services -import ( - "path" - "sync" - "testing" - "time" - - "github.com/cgrates/birpc" - "github.com/cgrates/birpc/context" - "github.com/cgrates/cgrates/commonlisteners" - "github.com/cgrates/cgrates/config" - "github.com/cgrates/cgrates/engine" - "github.com/cgrates/cgrates/servmanager" - "github.com/cgrates/cgrates/utils" -) - -func TestAsteriskAgentReload(t *testing.T) { - cfg := config.NewDefaultCGRConfig() - cfg.SessionSCfg().Enabled = true - cfg.SessionSCfg().ListenBijson = "" - filterSChan := make(chan *engine.FilterS, 1) - filterSChan <- nil - ctx, cancel := context.WithCancel(context.TODO()) - defer func() { - cancel() - time.Sleep(10 * time.Millisecond) - }() - shdWg := new(sync.WaitGroup) - - cls := commonlisteners.NewCommonListenerS(nil) - srvMngr := servmanager.NewServiceManager(shdWg, nil, cfg) - srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} - db := NewDataDBService(cfg, nil, false, srvDep) - anz := NewAnalyzerService(cfg, cls, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) - sS := NewSessionService(cfg, db, filterSChan, cls, make(chan birpc.ClientConnector, 1), - nil, anz, srvDep) - srv := NewAsteriskAgent(cfg, nil, srvDep) - engine.NewConnManager(cfg) - srvMngr.AddServices(srv, sS, - NewLoaderService(cfg, db, filterSChan, cls, make(chan birpc.ClientConnector, 1), nil, anz, srvDep), db) - srvMngr.StartServices(ctx, cancel) - if srv.IsRunning() { - t.Fatalf("Expected service to be down") - } - var reply string - cfg.ConfigPath = path.Join("/usr", "share", "cgrates", "tutorial_tests", "asterisk_ari", "cgrates", "etc", "cgrates") - if err := cfg.V1ReloadConfig(context.Background(), &config.ReloadArgs{ - Section: config.AsteriskAgentJSON, - }, &reply); err != nil { - t.Fatal(err) - } else if reply != utils.OK { - t.Fatalf("Expecting OK ,received %s", reply) - } - time.Sleep(10 * time.Millisecond) //need to switch to gorutine - if !srv.IsRunning() { - t.Fatalf("Expected service to be running") - } - srvReload := srv.Reload(ctx, cancel) - if srvReload != nil { - t.Fatalf("\nExpecting ,\n Received <%+v>", srvReload) - } - err := srv.Start(ctx, cancel) - if err != utils.ErrServiceAlreadyRunning { - t.Fatalf("\nExpecting <%+v>,\n Received <%+v>", utils.ErrServiceAlreadyRunning, err) - } - cfg.AsteriskAgentCfg().Enabled = false - cfg.GetReloadChan() <- config.SectionToService[config.AsteriskAgentJSON] - time.Sleep(10 * time.Millisecond) - if srv.IsRunning() { - t.Fatalf("Expected service to be down") - } - -} - -func TestAsteriskAgentReload2(t *testing.T) { - cfg := config.NewDefaultCGRConfig() - cfg.SessionSCfg().Enabled = true - cfg.SessionSCfg().ListenBijson = "" - filterSChan := make(chan *engine.FilterS, 1) - filterSChan <- nil - ctx, cancel := context.WithCancel(context.TODO()) - defer func() { - cancel() - time.Sleep(10 * time.Millisecond) - }() - shdWg := new(sync.WaitGroup) - - cls := commonlisteners.NewCommonListenerS(nil) - srvMngr := servmanager.NewServiceManager(shdWg, nil, cfg) - srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} - db := NewDataDBService(cfg, nil, false, srvDep) - anz := NewAnalyzerService(cfg, cls, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) - sS := NewSessionService(cfg, db, filterSChan, cls, make(chan birpc.ClientConnector, 1), - nil, anz, srvDep) - srv := NewAsteriskAgent(cfg, nil, srvDep) - engine.NewConnManager(cfg) - srvMngr.AddServices(srv, sS, - NewLoaderService(cfg, db, filterSChan, cls, make(chan birpc.ClientConnector, 1), nil, anz, srvDep), db) - srvMngr.StartServices(ctx, cancel) - if srv.IsRunning() { - t.Fatalf("Expected service to be down") - } - var reply string - cfg.ConfigPath = path.Join("/usr", "share", "cgrates", "tutorial_tests", "asterisk_ari", "cgrates", "etc", "cgrates") - if err := cfg.V1ReloadConfig(context.Background(), &config.ReloadArgs{ - Section: config.AsteriskAgentJSON, - }, &reply); err != nil { - t.Fatal(err) - } else if reply != utils.OK { - t.Fatalf("Expecting OK ,received %s", reply) - } - time.Sleep(10 * time.Millisecond) //need to switch to gorutine - if !srv.IsRunning() { - t.Fatalf("Expected service to be running") - } - srvReload := srv.Reload(ctx, cancel) - if srvReload != nil { - t.Fatalf("\nExpecting ,\n Received <%+v>", srvReload) - } - err := srv.Start(ctx, cancel) - if err != utils.ErrServiceAlreadyRunning { - t.Fatalf("\nExpecting <%+v>,\n Received <%+v>", utils.ErrServiceAlreadyRunning, err) - } - cfg.AsteriskAgentCfg().AsteriskConns = []*config.AsteriskConnCfg{ - { - Alias: "127.0.0.1:8448", - Address: "127.0.0.1:8088", - User: "cgrates", - Password: "CGRateS.org", - ConnectAttempts: 0, - Reconnects: 0, - }} - srvReload = srv.Reload(ctx, cancel) - if srvReload != nil { - t.Fatalf("\nExpecting ,\n Received <%+v>", srvReload) - } - cfg.AsteriskAgentCfg().Enabled = false - cfg.GetReloadChan() <- config.SectionToService[config.AsteriskAgentJSON] - time.Sleep(10 * time.Millisecond) - if srv.IsRunning() { - t.Fatalf("Expected service to be down") - } -} +// import ( +// "path" +// "sync" +// "testing" +// "time" +// +// "github.com/cgrates/birpc" +// "github.com/cgrates/birpc/context" +// "github.com/cgrates/cgrates/commonlisteners" +// "github.com/cgrates/cgrates/config" +// "github.com/cgrates/cgrates/engine" +// "github.com/cgrates/cgrates/servmanager" +// "github.com/cgrates/cgrates/utils" +// ) +// +// func TestAsteriskAgentReload(t *testing.T) { +// cfg := config.NewDefaultCGRConfig() +// cfg.SessionSCfg().Enabled = true +// cfg.SessionSCfg().ListenBijson = "" +// filterSChan := make(chan *engine.FilterS, 1) +// filterSChan <- nil +// ctx, cancel := context.WithCancel(context.TODO()) +// defer func() { +// cancel() +// time.Sleep(10 * time.Millisecond) +// }() +// shdWg := new(sync.WaitGroup) +// +// cls := commonlisteners.NewCommonListenerS(nil) +// srvMngr := servmanager.NewServiceManager(shdWg, nil, cfg) +// srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} +// db := NewDataDBService(cfg, nil, false, srvDep) +// anz := NewAnalyzerService(cfg, cls, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) +// sS := NewSessionService(cfg, db, filterSChan, cls, make(chan birpc.ClientConnector, 1), +// nil, anz, srvDep) +// srv := NewAsteriskAgent(cfg, nil, srvDep) +// engine.NewConnManager(cfg) +// srvMngr.AddServices(srv, sS, +// NewLoaderService(cfg, db, filterSChan, cls, make(chan birpc.ClientConnector, 1), nil, anz, srvDep), db) +// srvMngr.StartServices(ctx, cancel) +// if srv.IsRunning() { +// t.Fatalf("Expected service to be down") +// } +// var reply string +// cfg.ConfigPath = path.Join("/usr", "share", "cgrates", "tutorial_tests", "asterisk_ari", "cgrates", "etc", "cgrates") +// if err := cfg.V1ReloadConfig(context.Background(), &config.ReloadArgs{ +// Section: config.AsteriskAgentJSON, +// }, &reply); err != nil { +// t.Fatal(err) +// } else if reply != utils.OK { +// t.Fatalf("Expecting OK ,received %s", reply) +// } +// time.Sleep(10 * time.Millisecond) //need to switch to gorutine +// if !srv.IsRunning() { +// t.Fatalf("Expected service to be running") +// } +// srvReload := srv.Reload(ctx, cancel) +// if srvReload != nil { +// t.Fatalf("\nExpecting ,\n Received <%+v>", srvReload) +// } +// err := srv.Start(ctx, cancel) +// if err != utils.ErrServiceAlreadyRunning { +// t.Fatalf("\nExpecting <%+v>,\n Received <%+v>", utils.ErrServiceAlreadyRunning, err) +// } +// cfg.AsteriskAgentCfg().Enabled = false +// cfg.GetReloadChan() <- config.SectionToService[config.AsteriskAgentJSON] +// time.Sleep(10 * time.Millisecond) +// if srv.IsRunning() { +// t.Fatalf("Expected service to be down") +// } +// +// } +// +// func TestAsteriskAgentReload2(t *testing.T) { +// cfg := config.NewDefaultCGRConfig() +// cfg.SessionSCfg().Enabled = true +// cfg.SessionSCfg().ListenBijson = "" +// filterSChan := make(chan *engine.FilterS, 1) +// filterSChan <- nil +// ctx, cancel := context.WithCancel(context.TODO()) +// defer func() { +// cancel() +// time.Sleep(10 * time.Millisecond) +// }() +// shdWg := new(sync.WaitGroup) +// +// cls := commonlisteners.NewCommonListenerS(nil) +// srvMngr := servmanager.NewServiceManager(shdWg, nil, cfg) +// srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} +// db := NewDataDBService(cfg, nil, false, srvDep) +// anz := NewAnalyzerService(cfg, cls, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) +// sS := NewSessionService(cfg, db, filterSChan, cls, make(chan birpc.ClientConnector, 1), +// nil, anz, srvDep) +// srv := NewAsteriskAgent(cfg, nil, srvDep) +// engine.NewConnManager(cfg) +// srvMngr.AddServices(srv, sS, +// NewLoaderService(cfg, db, filterSChan, cls, make(chan birpc.ClientConnector, 1), nil, anz, srvDep), db) +// srvMngr.StartServices(ctx, cancel) +// if srv.IsRunning() { +// t.Fatalf("Expected service to be down") +// } +// var reply string +// cfg.ConfigPath = path.Join("/usr", "share", "cgrates", "tutorial_tests", "asterisk_ari", "cgrates", "etc", "cgrates") +// if err := cfg.V1ReloadConfig(context.Background(), &config.ReloadArgs{ +// Section: config.AsteriskAgentJSON, +// }, &reply); err != nil { +// t.Fatal(err) +// } else if reply != utils.OK { +// t.Fatalf("Expecting OK ,received %s", reply) +// } +// time.Sleep(10 * time.Millisecond) //need to switch to gorutine +// if !srv.IsRunning() { +// t.Fatalf("Expected service to be running") +// } +// srvReload := srv.Reload(ctx, cancel) +// if srvReload != nil { +// t.Fatalf("\nExpecting ,\n Received <%+v>", srvReload) +// } +// err := srv.Start(ctx, cancel) +// if err != utils.ErrServiceAlreadyRunning { +// t.Fatalf("\nExpecting <%+v>,\n Received <%+v>", utils.ErrServiceAlreadyRunning, err) +// } +// cfg.AsteriskAgentCfg().AsteriskConns = []*config.AsteriskConnCfg{ +// { +// Alias: "127.0.0.1:8448", +// Address: "127.0.0.1:8088", +// User: "cgrates", +// Password: "CGRateS.org", +// ConnectAttempts: 0, +// Reconnects: 0, +// }} +// srvReload = srv.Reload(ctx, cancel) +// if srvReload != nil { +// t.Fatalf("\nExpecting ,\n Received <%+v>", srvReload) +// } +// cfg.AsteriskAgentCfg().Enabled = false +// cfg.GetReloadChan() <- config.SectionToService[config.AsteriskAgentJSON] +// time.Sleep(10 * time.Millisecond) +// if srv.IsRunning() { +// t.Fatalf("Expected service to be down") +// } +// } diff --git a/services/asteriskagent_test.go b/services/asteriskagent_test.go index dc9b7f074..2a13b8d55 100644 --- a/services/asteriskagent_test.go +++ b/services/asteriskagent_test.go @@ -17,60 +17,60 @@ along with this program. If not, see */ package services -import ( - "reflect" - "sync" - "testing" - - "github.com/cgrates/cgrates/agents" - "github.com/cgrates/cgrates/config" - "github.com/cgrates/cgrates/engine" - "github.com/cgrates/cgrates/utils" -) - -// TestAsteriskAgentCoverage for cover testing -func TestAsteriskAgentCoverage(t *testing.T) { - cfg := config.NewDefaultCGRConfig() - cfg.SessionSCfg().Enabled = true - cfg.SessionSCfg().ListenBijson = "" - filterSChan := make(chan *engine.FilterS, 1) - filterSChan <- nil - srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} - srv := NewAsteriskAgent(cfg, nil, srvDep) - if srv == nil { - t.Errorf("\nExpecting ,\n Received <%+v>", utils.ToJSON(srv)) - } - srv2 := &AsteriskAgent{ - RWMutex: sync.RWMutex{}, - cfg: cfg, - stopChan: nil, - smas: nil, - connMgr: nil, - srvDep: srvDep, - } - if srv2.IsRunning() { - t.Errorf("Expected service to be down") - } - srv2.smas = []*agents.AsteriskAgent{} - if !srv2.IsRunning() { - t.Errorf("Expected service to be running") - } - astxAgent := srv2.ServiceName() - if !reflect.DeepEqual(astxAgent, utils.AsteriskAgent) { - t.Errorf("\nExpecting <%+v>,\n Received <%+v>", utils.AsteriskAgent, astxAgent) - } - shouldRun := srv2.ShouldRun() - if !reflect.DeepEqual(shouldRun, false) { - t.Errorf("\nExpecting <%+v>,\n Received <%+v>", false, shouldRun) - } - - srv2.stopChan = make(chan struct{}, 1) - //no error for now - err2 := srv2.Shutdown() - if err2 != nil { - t.Errorf("\nExpecting ,\n Received <%+v>", err2) - } - if srv2.IsRunning() { - t.Errorf("Expected service to be down") - } -} +// import ( +// "reflect" +// "sync" +// "testing" +// +// "github.com/cgrates/cgrates/agents" +// "github.com/cgrates/cgrates/config" +// "github.com/cgrates/cgrates/engine" +// "github.com/cgrates/cgrates/utils" +// ) +// +// // TestAsteriskAgentCoverage for cover testing +// func TestAsteriskAgentCoverage(t *testing.T) { +// cfg := config.NewDefaultCGRConfig() +// cfg.SessionSCfg().Enabled = true +// cfg.SessionSCfg().ListenBijson = "" +// filterSChan := make(chan *engine.FilterS, 1) +// filterSChan <- nil +// srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} +// srv := NewAsteriskAgent(cfg, nil, srvDep) +// if srv == nil { +// t.Errorf("\nExpecting ,\n Received <%+v>", utils.ToJSON(srv)) +// } +// srv2 := &AsteriskAgent{ +// RWMutex: sync.RWMutex{}, +// cfg: cfg, +// stopChan: nil, +// smas: nil, +// connMgr: nil, +// srvDep: srvDep, +// } +// if srv2.IsRunning() { +// t.Errorf("Expected service to be down") +// } +// srv2.smas = []*agents.AsteriskAgent{} +// if !srv2.IsRunning() { +// t.Errorf("Expected service to be running") +// } +// astxAgent := srv2.ServiceName() +// if !reflect.DeepEqual(astxAgent, utils.AsteriskAgent) { +// t.Errorf("\nExpecting <%+v>,\n Received <%+v>", utils.AsteriskAgent, astxAgent) +// } +// shouldRun := srv2.ShouldRun() +// if !reflect.DeepEqual(shouldRun, false) { +// t.Errorf("\nExpecting <%+v>,\n Received <%+v>", false, shouldRun) +// } +// +// srv2.stopChan = make(chan struct{}, 1) +// //no error for now +// err2 := srv2.Shutdown() +// if err2 != nil { +// t.Errorf("\nExpecting ,\n Received <%+v>", err2) +// } +// if srv2.IsRunning() { +// t.Errorf("Expected service to be down") +// } +// } diff --git a/services/attributes_it_test.go b/services/attributes_it_test.go index 32e26e57d..2f3c48236 100644 --- a/services/attributes_it_test.go +++ b/services/attributes_it_test.go @@ -20,92 +20,92 @@ along with this program. If not, see */ package services -import ( - "path" - "sync" - "testing" - "time" - - "github.com/cgrates/birpc" - "github.com/cgrates/birpc/context" - "github.com/cgrates/cgrates/commonlisteners" - "github.com/cgrates/cgrates/config" - "github.com/cgrates/cgrates/engine" - "github.com/cgrates/cgrates/servmanager" - "github.com/cgrates/cgrates/utils" -) - -func TestAttributeSReload(t *testing.T) { - cfg := config.NewDefaultCGRConfig() - - shdWg := new(sync.WaitGroup) - chS := engine.NewCacheS(cfg, nil, nil, nil) - filterSChan := make(chan *engine.FilterS, 1) - filterSChan <- nil - close(chS.GetPrecacheChannel(utils.CacheAttributeProfiles)) - close(chS.GetPrecacheChannel(utils.CacheAttributeFilterIndexes)) - chSCh := make(chan *engine.CacheS, 1) - chSCh <- chS - css := &CacheService{cacheCh: chSCh} - cls := commonlisteners.NewCommonListenerS(nil) - srvMngr := servmanager.NewServiceManager(shdWg, nil, cfg) - srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} - db := NewDataDBService(cfg, nil, false, srvDep) - attrRPC := make(chan birpc.ClientConnector, 1) - anz := NewAnalyzerService(cfg, cls, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) - attrS := NewAttributeService(cfg, db, - css, filterSChan, cls, attrRPC, - anz, &DispatcherService{srvsReload: make(map[string]chan struct{})}, srvDep) - engine.NewConnManager(cfg) - srvMngr.AddServices(attrS, - NewLoaderService(cfg, db, filterSChan, cls, make(chan birpc.ClientConnector, 1), nil, anz, srvDep), db) - ctx, cancel := context.WithCancel(context.TODO()) - srvMngr.StartServices(ctx, cancel) - if attrS.IsRunning() { - t.Errorf("Expected service to be down") - } - if db.IsRunning() { - t.Errorf("Expected service to be down") - } - - var reply string - cfg.ConfigPath = path.Join("/usr", "share", "cgrates", "conf", "samples", "tutmongo") - if err := cfg.V1ReloadConfig(context.Background(), &config.ReloadArgs{ - Section: config.AttributeSJSON, - }, &reply); err != nil { - t.Error(err) - } else if reply != utils.OK { - t.Errorf("Expecting OK ,received %s", reply) - } - select { - case d := <-attrRPC: - attrRPC <- d - case <-time.After(time.Second): - t.Fatal("It took to long to reload the cache") - } - if !attrS.IsRunning() { - t.Errorf("Expected service to be running") - } - if !db.IsRunning() { - t.Errorf("Expected service to be running") - } - err := attrS.Start(ctx, cancel) - if err == nil || err != utils.ErrServiceAlreadyRunning { - t.Errorf("\nExpecting <%+v>,\n Received <%+v>", utils.ErrServiceAlreadyRunning, err) - } - err = attrS.Reload(ctx, cancel) - if err != nil { - t.Errorf("\nExpecting ,\n Received <%+v>", err) - } - cfg.AttributeSCfg().Enabled = false - cfg.GetReloadChan() <- config.SectionToService[config.AttributeSJSON] - time.Sleep(10 * time.Millisecond) - - if attrS.IsRunning() { - t.Errorf("Expected service to be down") - } - - cancel() - time.Sleep(10 * time.Millisecond) - -} +// import ( +// "path" +// "sync" +// "testing" +// "time" +// +// "github.com/cgrates/birpc" +// "github.com/cgrates/birpc/context" +// "github.com/cgrates/cgrates/commonlisteners" +// "github.com/cgrates/cgrates/config" +// "github.com/cgrates/cgrates/engine" +// "github.com/cgrates/cgrates/servmanager" +// "github.com/cgrates/cgrates/utils" +// ) +// +// func TestAttributeSReload(t *testing.T) { +// cfg := config.NewDefaultCGRConfig() +// +// shdWg := new(sync.WaitGroup) +// chS := engine.NewCacheS(cfg, nil, nil, nil) +// filterSChan := make(chan *engine.FilterS, 1) +// filterSChan <- nil +// close(chS.GetPrecacheChannel(utils.CacheAttributeProfiles)) +// close(chS.GetPrecacheChannel(utils.CacheAttributeFilterIndexes)) +// chSCh := make(chan *engine.CacheS, 1) +// chSCh <- chS +// css := &CacheService{cacheCh: chSCh} +// cls := commonlisteners.NewCommonListenerS(nil) +// srvMngr := servmanager.NewServiceManager(shdWg, nil, cfg) +// srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} +// db := NewDataDBService(cfg, nil, false, srvDep) +// attrRPC := make(chan birpc.ClientConnector, 1) +// anz := NewAnalyzerService(cfg, cls, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) +// attrS := NewAttributeService(cfg, db, +// css, filterSChan, cls, attrRPC, +// anz, &DispatcherService{srvsReload: make(map[string]chan struct{})}, srvDep) +// engine.NewConnManager(cfg) +// srvMngr.AddServices(attrS, +// NewLoaderService(cfg, db, filterSChan, cls, make(chan birpc.ClientConnector, 1), nil, anz, srvDep), db) +// ctx, cancel := context.WithCancel(context.TODO()) +// srvMngr.StartServices(ctx, cancel) +// if attrS.IsRunning() { +// t.Errorf("Expected service to be down") +// } +// if db.IsRunning() { +// t.Errorf("Expected service to be down") +// } +// +// var reply string +// cfg.ConfigPath = path.Join("/usr", "share", "cgrates", "conf", "samples", "tutmongo") +// if err := cfg.V1ReloadConfig(context.Background(), &config.ReloadArgs{ +// Section: config.AttributeSJSON, +// }, &reply); err != nil { +// t.Error(err) +// } else if reply != utils.OK { +// t.Errorf("Expecting OK ,received %s", reply) +// } +// select { +// case d := <-attrRPC: +// attrRPC <- d +// case <-time.After(time.Second): +// t.Fatal("It took to long to reload the cache") +// } +// if !attrS.IsRunning() { +// t.Errorf("Expected service to be running") +// } +// if !db.IsRunning() { +// t.Errorf("Expected service to be running") +// } +// err := attrS.Start(ctx, cancel) +// if err == nil || err != utils.ErrServiceAlreadyRunning { +// t.Errorf("\nExpecting <%+v>,\n Received <%+v>", utils.ErrServiceAlreadyRunning, err) +// } +// err = attrS.Reload(ctx, cancel) +// if err != nil { +// t.Errorf("\nExpecting ,\n Received <%+v>", err) +// } +// cfg.AttributeSCfg().Enabled = false +// cfg.GetReloadChan() <- config.SectionToService[config.AttributeSJSON] +// time.Sleep(10 * time.Millisecond) +// +// if attrS.IsRunning() { +// t.Errorf("Expected service to be down") +// } +// +// cancel() +// time.Sleep(10 * time.Millisecond) +// +// } diff --git a/services/attributes_test.go b/services/attributes_test.go index dc23fdd6b..a671447e8 100644 --- a/services/attributes_test.go +++ b/services/attributes_test.go @@ -17,68 +17,68 @@ along with this program. If not, see */ package services -import ( - "reflect" - "sync" - "testing" - - "github.com/cgrates/birpc" - "github.com/cgrates/birpc/context" - "github.com/cgrates/cgrates/commonlisteners" - "github.com/cgrates/cgrates/config" - "github.com/cgrates/cgrates/engine" - "github.com/cgrates/cgrates/utils" -) - -// TestAttributeSCoverage for cover testing -func TestAttributeSCoverage(t *testing.T) { - cfg := config.NewDefaultCGRConfig() - filterSChan := make(chan *engine.FilterS, 1) - filterSChan <- nil - cls := commonlisteners.NewCommonListenerS(nil) - srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} - attrRPC := make(chan birpc.ClientConnector, 1) - db := NewDataDBService(cfg, nil, false, srvDep) - anz := NewAnalyzerService(cfg, cls, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) - chS := NewCacheService(cfg, db, nil, cls, make(chan context.ClientConnector, 1), anz, nil, srvDep) - attrS := NewAttributeService(cfg, db, chS, filterSChan, cls, attrRPC, anz, &DispatcherService{srvsReload: map[string]chan struct{}{}}, srvDep) - if attrS == nil { - t.Errorf("\nExpecting ,\n Received <%+v>", utils.ToJSON(attrS)) - } - attrS2 := &AttributeService{ - connChan: make(chan birpc.ClientConnector, 1), - cfg: cfg, - dm: db, - cacheS: chS, - filterSChan: filterSChan, - cls: cls, - anz: anz, - srvDep: srvDep, - dspS: &DispatcherService{srvsReload: map[string]chan struct{}{}}, - } - if attrS2.IsRunning() { - t.Errorf("Expected service to be down") - } - attrS2.attrS = &engine.AttributeS{} - if !attrS2.IsRunning() { - t.Errorf("Expected service to be running") - } - - shouldRun := attrS2.ShouldRun() - if !reflect.DeepEqual(shouldRun, false) { - t.Errorf("\nExpecting <%+v>,\n Received <%+v>", false, shouldRun) - } - serviceName := attrS2.ServiceName() - if !reflect.DeepEqual(serviceName, utils.AttributeS) { - t.Errorf("\nExpecting <%+v>,\n Received <%+v>", utils.AttributeS, serviceName) - } - - attrS2.connChan <- &testMockClients{} - shutdownErr := attrS2.Shutdown() - if shutdownErr != nil { - t.Errorf("\nExpecting ,\n Received <%+v>", shutdownErr) - } - if attrS2.IsRunning() { - t.Errorf("Expected service to be down") - } -} +// import ( +// "reflect" +// "sync" +// "testing" +// +// "github.com/cgrates/birpc" +// "github.com/cgrates/birpc/context" +// "github.com/cgrates/cgrates/commonlisteners" +// "github.com/cgrates/cgrates/config" +// "github.com/cgrates/cgrates/engine" +// "github.com/cgrates/cgrates/utils" +// ) +// +// // TestAttributeSCoverage for cover testing +// func TestAttributeSCoverage(t *testing.T) { +// cfg := config.NewDefaultCGRConfig() +// filterSChan := make(chan *engine.FilterS, 1) +// filterSChan <- nil +// cls := commonlisteners.NewCommonListenerS(nil) +// srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} +// attrRPC := make(chan birpc.ClientConnector, 1) +// db := NewDataDBService(cfg, nil, false, srvDep) +// anz := NewAnalyzerService(cfg, cls, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) +// chS := NewCacheService(cfg, db, nil, cls, make(chan context.ClientConnector, 1), anz, nil, srvDep) +// attrS := NewAttributeService(cfg, db, chS, filterSChan, cls, attrRPC, anz, &DispatcherService{srvsReload: map[string]chan struct{}{}}, srvDep) +// if attrS == nil { +// t.Errorf("\nExpecting ,\n Received <%+v>", utils.ToJSON(attrS)) +// } +// attrS2 := &AttributeService{ +// connChan: make(chan birpc.ClientConnector, 1), +// cfg: cfg, +// dm: db, +// cacheS: chS, +// filterSChan: filterSChan, +// cls: cls, +// anz: anz, +// srvDep: srvDep, +// dspS: &DispatcherService{srvsReload: map[string]chan struct{}{}}, +// } +// if attrS2.IsRunning() { +// t.Errorf("Expected service to be down") +// } +// attrS2.attrS = &engine.AttributeS{} +// if !attrS2.IsRunning() { +// t.Errorf("Expected service to be running") +// } +// +// shouldRun := attrS2.ShouldRun() +// if !reflect.DeepEqual(shouldRun, false) { +// t.Errorf("\nExpecting <%+v>,\n Received <%+v>", false, shouldRun) +// } +// serviceName := attrS2.ServiceName() +// if !reflect.DeepEqual(serviceName, utils.AttributeS) { +// t.Errorf("\nExpecting <%+v>,\n Received <%+v>", utils.AttributeS, serviceName) +// } +// +// attrS2.connChan <- &testMockClients{} +// shutdownErr := attrS2.Shutdown() +// if shutdownErr != nil { +// t.Errorf("\nExpecting ,\n Received <%+v>", shutdownErr) +// } +// if attrS2.IsRunning() { +// t.Errorf("Expected service to be down") +// } +// } diff --git a/services/cdrs_it_test.go b/services/cdrs_it_test.go index 7edbab473..b19926f18 100644 --- a/services/cdrs_it_test.go +++ b/services/cdrs_it_test.go @@ -20,101 +20,101 @@ along with this program. If not, see */ package services -import ( - "path" - "sync" - "testing" - "time" - - "github.com/cgrates/birpc" - "github.com/cgrates/birpc/context" - "github.com/cgrates/cgrates/commonlisteners" - "github.com/cgrates/cgrates/config" - "github.com/cgrates/cgrates/engine" - "github.com/cgrates/cgrates/servmanager" - "github.com/cgrates/cgrates/utils" -) - -func TestCdrsReload(t *testing.T) { - cfg := config.NewDefaultCGRConfig() - - filterSChan := make(chan *engine.FilterS, 1) - filterSChan <- nil - shdWg := new(sync.WaitGroup) - chS := engine.NewCacheS(cfg, nil, nil, nil) - - close(chS.GetPrecacheChannel(utils.CacheChargerProfiles)) - close(chS.GetPrecacheChannel(utils.CacheChargerFilterIndexes)) - chSCh := make(chan *engine.CacheS, 1) - chSCh <- chS - css := &CacheService{cacheCh: chSCh} - - cfg.ChargerSCfg().Enabled = true - cls := commonlisteners.NewCommonListenerS(nil) - srvMngr := servmanager.NewServiceManager(shdWg, nil, cfg) - srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} - db := NewDataDBService(cfg, nil, false, srvDep) - cfg.StorDbCfg().Type = utils.MetaInternal - stordb := NewStorDBService(cfg, false, srvDep) - anz := NewAnalyzerService(cfg, cls, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) - chrS := NewChargerService(cfg, db, css, filterSChan, cls, make(chan birpc.ClientConnector, 1), nil, anz, srvDep) - cdrsRPC := make(chan birpc.ClientConnector, 1) - cdrS := NewCDRServer(cfg, db, stordb, filterSChan, cls, - cdrsRPC, nil, anz, srvDep) - srvMngr.AddServices(cdrS, chrS, - NewLoaderService(cfg, db, filterSChan, cls, - make(chan birpc.ClientConnector, 1), nil, anz, srvDep), db) - ctx, cancel := context.WithCancel(context.TODO()) - srvMngr.StartServices(ctx, cancel) - if cdrS.IsRunning() { - t.Errorf("Expected service to be down") - } - if db.IsRunning() { - t.Errorf("Expected service to be down") - } - if stordb.IsRunning() { - t.Errorf("Expected service to be down") - } - - var reply string - cfg.ConfigPath = path.Join("/usr", "share", "cgrates", "conf", "samples", "tutmongo") - if err := cfg.V1ReloadConfig(context.Background(), &config.ReloadArgs{ - Section: config.CDRsJSON, - }, &reply); err != nil { - t.Error(err) - } else if reply != utils.OK { - t.Errorf("Expecting OK ,received %s", reply) - } - select { - case d := <-cdrsRPC: - cdrsRPC <- d - case <-time.After(time.Second): - t.Fatal("It took to long to reload the cache") - } - if !cdrS.IsRunning() { - t.Errorf("Expected service to be running") - } - if !db.IsRunning() { - t.Errorf("Expected service to be running") - } - if !stordb.IsRunning() { - t.Errorf("Expected service to be running") - } - - err := cdrS.Start(ctx, cancel) - if err == nil || err != utils.ErrServiceAlreadyRunning { - t.Errorf("\nExpecting <%+v>,\n Received <%+v>", utils.ErrServiceAlreadyRunning, err) - } - err = cdrS.Reload(ctx, cancel) - if err != nil { - t.Errorf("\nExpecting ,\n Received <%+v>", err) - } - cfg.CdrsCfg().Enabled = false - cfg.GetReloadChan() <- config.SectionToService[config.CDRsJSON] - time.Sleep(10 * time.Millisecond) - if cdrS.IsRunning() { - t.Errorf("Expected service to be down") - } - cancel() - time.Sleep(10 * time.Millisecond) -} +// import ( +// "path" +// "sync" +// "testing" +// "time" +// +// "github.com/cgrates/birpc" +// "github.com/cgrates/birpc/context" +// "github.com/cgrates/cgrates/commonlisteners" +// "github.com/cgrates/cgrates/config" +// "github.com/cgrates/cgrates/engine" +// "github.com/cgrates/cgrates/servmanager" +// "github.com/cgrates/cgrates/utils" +// ) +// +// func TestCdrsReload(t *testing.T) { +// cfg := config.NewDefaultCGRConfig() +// +// filterSChan := make(chan *engine.FilterS, 1) +// filterSChan <- nil +// shdWg := new(sync.WaitGroup) +// chS := engine.NewCacheS(cfg, nil, nil, nil) +// +// close(chS.GetPrecacheChannel(utils.CacheChargerProfiles)) +// close(chS.GetPrecacheChannel(utils.CacheChargerFilterIndexes)) +// chSCh := make(chan *engine.CacheS, 1) +// chSCh <- chS +// css := &CacheService{cacheCh: chSCh} +// +// cfg.ChargerSCfg().Enabled = true +// cls := commonlisteners.NewCommonListenerS(nil) +// srvMngr := servmanager.NewServiceManager(shdWg, nil, cfg) +// srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} +// db := NewDataDBService(cfg, nil, false, srvDep) +// cfg.StorDbCfg().Type = utils.MetaInternal +// stordb := NewStorDBService(cfg, false, srvDep) +// anz := NewAnalyzerService(cfg, cls, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) +// chrS := NewChargerService(cfg, db, css, filterSChan, cls, make(chan birpc.ClientConnector, 1), nil, anz, srvDep) +// cdrsRPC := make(chan birpc.ClientConnector, 1) +// cdrS := NewCDRServer(cfg, db, stordb, filterSChan, cls, +// cdrsRPC, nil, anz, srvDep) +// srvMngr.AddServices(cdrS, chrS, +// NewLoaderService(cfg, db, filterSChan, cls, +// make(chan birpc.ClientConnector, 1), nil, anz, srvDep), db) +// ctx, cancel := context.WithCancel(context.TODO()) +// srvMngr.StartServices(ctx, cancel) +// if cdrS.IsRunning() { +// t.Errorf("Expected service to be down") +// } +// if db.IsRunning() { +// t.Errorf("Expected service to be down") +// } +// if stordb.IsRunning() { +// t.Errorf("Expected service to be down") +// } +// +// var reply string +// cfg.ConfigPath = path.Join("/usr", "share", "cgrates", "conf", "samples", "tutmongo") +// if err := cfg.V1ReloadConfig(context.Background(), &config.ReloadArgs{ +// Section: config.CDRsJSON, +// }, &reply); err != nil { +// t.Error(err) +// } else if reply != utils.OK { +// t.Errorf("Expecting OK ,received %s", reply) +// } +// select { +// case d := <-cdrsRPC: +// cdrsRPC <- d +// case <-time.After(time.Second): +// t.Fatal("It took to long to reload the cache") +// } +// if !cdrS.IsRunning() { +// t.Errorf("Expected service to be running") +// } +// if !db.IsRunning() { +// t.Errorf("Expected service to be running") +// } +// if !stordb.IsRunning() { +// t.Errorf("Expected service to be running") +// } +// +// err := cdrS.Start(ctx, cancel) +// if err == nil || err != utils.ErrServiceAlreadyRunning { +// t.Errorf("\nExpecting <%+v>,\n Received <%+v>", utils.ErrServiceAlreadyRunning, err) +// } +// err = cdrS.Reload(ctx, cancel) +// if err != nil { +// t.Errorf("\nExpecting ,\n Received <%+v>", err) +// } +// cfg.CdrsCfg().Enabled = false +// cfg.GetReloadChan() <- config.SectionToService[config.CDRsJSON] +// time.Sleep(10 * time.Millisecond) +// if cdrS.IsRunning() { +// t.Errorf("Expected service to be down") +// } +// cancel() +// time.Sleep(10 * time.Millisecond) +// } diff --git a/services/cdrs_test.go b/services/cdrs_test.go index a93401831..7720c9056 100644 --- a/services/cdrs_test.go +++ b/services/cdrs_test.go @@ -17,72 +17,72 @@ along with this program. If not, see */ package services -import ( - "sync" - "testing" - - "github.com/cgrates/birpc" - "github.com/cgrates/cgrates/cdrs" - "github.com/cgrates/cgrates/commonlisteners" - "github.com/cgrates/cgrates/config" - "github.com/cgrates/cgrates/engine" - "github.com/cgrates/cgrates/utils" -) - -// TestCdrsCoverage for cover testing -func TestCdrsCoverage(t *testing.T) { - cfg := config.NewDefaultCGRConfig() - filterSChan := make(chan *engine.FilterS, 1) - filterSChan <- nil - cfg.ChargerSCfg().Enabled = true - cls := commonlisteners.NewCommonListenerS(nil) - srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} - db := NewDataDBService(cfg, nil, false, srvDep) - anz := NewAnalyzerService(cfg, cls, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) - cdrsRPC := make(chan birpc.ClientConnector, 1) - cfg.StorDbCfg().Type = utils.MetaInternal - stordb := NewStorDBService(cfg, false, srvDep) - cdrS := NewCDRServer(cfg, db, stordb, filterSChan, cls, - cdrsRPC, nil, anz, srvDep) - if cdrS.IsRunning() { - t.Errorf("Expected service to be down") - } - //populates cdrS2 with something in order to call the close funct - cdrS2 := &CDRService{ - RWMutex: sync.RWMutex{}, - cfg: cfg, - dm: db, - storDB: stordb, - filterSChan: filterSChan, - cls: cls, - connChan: make(chan birpc.ClientConnector, 1), - connMgr: nil, - stopChan: make(chan struct{}, 1), - anz: anz, - srvDep: srvDep, - cdrS: &cdrs.CDRServer{}, - } - cdrS2.connChan <- &testMockClients{} - cdrS2.stopChan <- struct{}{} - if !cdrS2.IsRunning() { - t.Errorf("Expected service to be running") - } - - serviceName := cdrS2.ServiceName() - if serviceName != utils.CDRServer { - t.Errorf("\nExpecting <%+v>,\n Received <%+v>", utils.AdminS, serviceName) - } - shouldRun := cdrS.ShouldRun() - if shouldRun != false { - t.Errorf("\nExpecting <%+v>,\n Received <%+v>", false, shouldRun) - } - - shutdownApi1 := cdrS2.Shutdown() - if shutdownApi1 != nil { - t.Errorf("\nExpecting <%+v>,\n Received <%+v>", nil, shutdownApi1) - } - - if cdrS.IsRunning() { - t.Errorf("Expected service to be down") - } -} +// import ( +// "sync" +// "testing" +// +// "github.com/cgrates/birpc" +// "github.com/cgrates/cgrates/cdrs" +// "github.com/cgrates/cgrates/commonlisteners" +// "github.com/cgrates/cgrates/config" +// "github.com/cgrates/cgrates/engine" +// "github.com/cgrates/cgrates/utils" +// ) +// +// // TestCdrsCoverage for cover testing +// func TestCdrsCoverage(t *testing.T) { +// cfg := config.NewDefaultCGRConfig() +// filterSChan := make(chan *engine.FilterS, 1) +// filterSChan <- nil +// cfg.ChargerSCfg().Enabled = true +// cls := commonlisteners.NewCommonListenerS(nil) +// srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} +// db := NewDataDBService(cfg, nil, false, srvDep) +// anz := NewAnalyzerService(cfg, cls, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) +// cdrsRPC := make(chan birpc.ClientConnector, 1) +// cfg.StorDbCfg().Type = utils.MetaInternal +// stordb := NewStorDBService(cfg, false, srvDep) +// cdrS := NewCDRServer(cfg, db, stordb, filterSChan, cls, +// cdrsRPC, nil, anz, srvDep) +// if cdrS.IsRunning() { +// t.Errorf("Expected service to be down") +// } +// //populates cdrS2 with something in order to call the close funct +// cdrS2 := &CDRService{ +// RWMutex: sync.RWMutex{}, +// cfg: cfg, +// dm: db, +// storDB: stordb, +// filterSChan: filterSChan, +// cls: cls, +// connChan: make(chan birpc.ClientConnector, 1), +// connMgr: nil, +// stopChan: make(chan struct{}, 1), +// anz: anz, +// srvDep: srvDep, +// cdrS: &cdrs.CDRServer{}, +// } +// cdrS2.connChan <- &testMockClients{} +// cdrS2.stopChan <- struct{}{} +// if !cdrS2.IsRunning() { +// t.Errorf("Expected service to be running") +// } +// +// serviceName := cdrS2.ServiceName() +// if serviceName != utils.CDRServer { +// t.Errorf("\nExpecting <%+v>,\n Received <%+v>", utils.AdminS, serviceName) +// } +// shouldRun := cdrS.ShouldRun() +// if shouldRun != false { +// t.Errorf("\nExpecting <%+v>,\n Received <%+v>", false, shouldRun) +// } +// +// shutdownApi1 := cdrS2.Shutdown() +// if shutdownApi1 != nil { +// t.Errorf("\nExpecting <%+v>,\n Received <%+v>", nil, shutdownApi1) +// } +// +// if cdrS.IsRunning() { +// t.Errorf("Expected service to be down") +// } +// } diff --git a/services/chargers_it_test.go b/services/chargers_it_test.go index d9cd8e251..d3c0fa53b 100644 --- a/services/chargers_it_test.go +++ b/services/chargers_it_test.go @@ -20,88 +20,88 @@ along with this program. If not, see */ package services -import ( - "path" - "runtime" - "sync" - "testing" - "time" - - "github.com/cgrates/birpc" - "github.com/cgrates/birpc/context" - "github.com/cgrates/cgrates/commonlisteners" - "github.com/cgrates/cgrates/config" - "github.com/cgrates/cgrates/engine" - "github.com/cgrates/cgrates/servmanager" - "github.com/cgrates/cgrates/utils" -) - -func TestChargerSReload(t *testing.T) { - cfg := config.NewDefaultCGRConfig() - - cfg.AttributeSCfg().Enabled = true - shdWg := new(sync.WaitGroup) - chS := engine.NewCacheS(cfg, nil, nil, nil) - close(chS.GetPrecacheChannel(utils.CacheAttributeProfiles)) - close(chS.GetPrecacheChannel(utils.CacheAttributeFilterIndexes)) - close(chS.GetPrecacheChannel(utils.CacheChargerProfiles)) - close(chS.GetPrecacheChannel(utils.CacheChargerFilterIndexes)) - chSCh := make(chan *engine.CacheS, 1) - chSCh <- chS - css := &CacheService{cacheCh: chSCh} - filterSChan := make(chan *engine.FilterS, 1) - filterSChan <- nil - srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} - cls := commonlisteners.NewCommonListenerS(nil) - srvMngr := servmanager.NewServiceManager(shdWg, nil, cfg) - db := NewDataDBService(cfg, nil, false, srvDep) - anz := NewAnalyzerService(cfg, cls, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) - attrS := NewAttributeService(cfg, db, css, filterSChan, cls, make(chan birpc.ClientConnector, 1), anz, &DispatcherService{srvsReload: make(map[string]chan struct{})}, srvDep) - chrS := NewChargerService(cfg, db, css, filterSChan, cls, make(chan birpc.ClientConnector, 1), nil, anz, srvDep) - engine.NewConnManager(cfg) - srvMngr.AddServices(attrS, chrS, - NewLoaderService(cfg, db, filterSChan, cls, - make(chan birpc.ClientConnector, 1), nil, anz, srvDep), db) - ctx, cancel := context.WithCancel(context.TODO()) - srvMngr.StartServices(ctx, cancel) - if chrS.IsRunning() { - t.Errorf("Expected service to be down") - } - if db.IsRunning() { - t.Errorf("Expected service to be down") - } - var reply string - cfg.ConfigPath = path.Join("/usr", "share", "cgrates", "conf", "samples", "tutmongo") - if err := cfg.V1ReloadConfig(context.Background(), &config.ReloadArgs{ - Section: config.ChargerSJSON, - }, &reply); err != nil { - t.Error(err) - } else if reply != utils.OK { - t.Errorf("Expecting OK ,received %s", reply) - } - runtime.Gosched() - runtime.Gosched() - time.Sleep(10 * time.Millisecond) //need to switch to gorutine - if !chrS.IsRunning() { - t.Fatalf("Expected service to be running") - } - if !db.IsRunning() { - t.Errorf("Expected service to be running") - } - err := chrS.Start(ctx, cancel) - if err == nil || err != utils.ErrServiceAlreadyRunning { - t.Errorf("\nExpecting <%+v>,\n Received <%+v>", utils.ErrServiceAlreadyRunning, err) - } - err = chrS.Reload(ctx, cancel) - if err != nil { - t.Errorf("\nExpecting ,\n Received <%+v>", err) - } - cfg.ChargerSCfg().Enabled = false - cfg.GetReloadChan() <- config.SectionToService[config.ChargerSJSON] - time.Sleep(10 * time.Millisecond) - if chrS.IsRunning() { - t.Errorf("Expected service to be down") - } - cancel() - time.Sleep(10 * time.Millisecond) -} +// import ( +// "path" +// "runtime" +// "sync" +// "testing" +// "time" +// +// "github.com/cgrates/birpc" +// "github.com/cgrates/birpc/context" +// "github.com/cgrates/cgrates/commonlisteners" +// "github.com/cgrates/cgrates/config" +// "github.com/cgrates/cgrates/engine" +// "github.com/cgrates/cgrates/servmanager" +// "github.com/cgrates/cgrates/utils" +// ) +// +// func TestChargerSReload(t *testing.T) { +// cfg := config.NewDefaultCGRConfig() +// +// cfg.AttributeSCfg().Enabled = true +// shdWg := new(sync.WaitGroup) +// chS := engine.NewCacheS(cfg, nil, nil, nil) +// close(chS.GetPrecacheChannel(utils.CacheAttributeProfiles)) +// close(chS.GetPrecacheChannel(utils.CacheAttributeFilterIndexes)) +// close(chS.GetPrecacheChannel(utils.CacheChargerProfiles)) +// close(chS.GetPrecacheChannel(utils.CacheChargerFilterIndexes)) +// chSCh := make(chan *engine.CacheS, 1) +// chSCh <- chS +// css := &CacheService{cacheCh: chSCh} +// filterSChan := make(chan *engine.FilterS, 1) +// filterSChan <- nil +// srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} +// cls := commonlisteners.NewCommonListenerS(nil) +// srvMngr := servmanager.NewServiceManager(shdWg, nil, cfg) +// db := NewDataDBService(cfg, nil, false, srvDep) +// anz := NewAnalyzerService(cfg, cls, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) +// attrS := NewAttributeService(cfg, db, css, filterSChan, cls, make(chan birpc.ClientConnector, 1), anz, &DispatcherService{srvsReload: make(map[string]chan struct{})}, srvDep) +// chrS := NewChargerService(cfg, db, css, filterSChan, cls, make(chan birpc.ClientConnector, 1), nil, anz, srvDep) +// engine.NewConnManager(cfg) +// srvMngr.AddServices(attrS, chrS, +// NewLoaderService(cfg, db, filterSChan, cls, +// make(chan birpc.ClientConnector, 1), nil, anz, srvDep), db) +// ctx, cancel := context.WithCancel(context.TODO()) +// srvMngr.StartServices(ctx, cancel) +// if chrS.IsRunning() { +// t.Errorf("Expected service to be down") +// } +// if db.IsRunning() { +// t.Errorf("Expected service to be down") +// } +// var reply string +// cfg.ConfigPath = path.Join("/usr", "share", "cgrates", "conf", "samples", "tutmongo") +// if err := cfg.V1ReloadConfig(context.Background(), &config.ReloadArgs{ +// Section: config.ChargerSJSON, +// }, &reply); err != nil { +// t.Error(err) +// } else if reply != utils.OK { +// t.Errorf("Expecting OK ,received %s", reply) +// } +// runtime.Gosched() +// runtime.Gosched() +// time.Sleep(10 * time.Millisecond) //need to switch to gorutine +// if !chrS.IsRunning() { +// t.Fatalf("Expected service to be running") +// } +// if !db.IsRunning() { +// t.Errorf("Expected service to be running") +// } +// err := chrS.Start(ctx, cancel) +// if err == nil || err != utils.ErrServiceAlreadyRunning { +// t.Errorf("\nExpecting <%+v>,\n Received <%+v>", utils.ErrServiceAlreadyRunning, err) +// } +// err = chrS.Reload(ctx, cancel) +// if err != nil { +// t.Errorf("\nExpecting ,\n Received <%+v>", err) +// } +// cfg.ChargerSCfg().Enabled = false +// cfg.GetReloadChan() <- config.SectionToService[config.ChargerSJSON] +// time.Sleep(10 * time.Millisecond) +// if chrS.IsRunning() { +// t.Errorf("Expected service to be down") +// } +// cancel() +// time.Sleep(10 * time.Millisecond) +// } diff --git a/services/chargers_test.go b/services/chargers_test.go index 1f875e76c..852bef17c 100644 --- a/services/chargers_test.go +++ b/services/chargers_test.go @@ -17,68 +17,68 @@ along with this program. If not, see */ package services -import ( - "reflect" - "sync" - "testing" - - "github.com/cgrates/birpc" - "github.com/cgrates/birpc/context" - "github.com/cgrates/cgrates/commonlisteners" - "github.com/cgrates/cgrates/config" - "github.com/cgrates/cgrates/engine" - "github.com/cgrates/cgrates/utils" -) - -// TestChargerSCoverage for cover testing -func TestChargerSCoverage(t *testing.T) { - cfg := config.NewDefaultCGRConfig() - cfg.AttributeSCfg().Enabled = true - filterSChan := make(chan *engine.FilterS, 1) - filterSChan <- nil - srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} - cls := commonlisteners.NewCommonListenerS(nil) - db := NewDataDBService(cfg, nil, false, srvDep) - anz := NewAnalyzerService(cfg, cls, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) - chS := NewCacheService(cfg, db, nil, cls, make(chan context.ClientConnector, 1), anz, nil, srvDep) - chrS1 := NewChargerService(cfg, db, chS, - filterSChan, cls, make(chan birpc.ClientConnector, 1), - nil, anz, srvDep) - if chrS1.IsRunning() { - t.Errorf("Expected service to be down") - } - chrS := &ChargerService{ - connChan: make(chan birpc.ClientConnector, 1), - cfg: cfg, - dm: db, - cacheS: chS, - filterSChan: filterSChan, - cls: cls, - connMgr: nil, - anz: anz, - srvDep: srvDep, - } - if chrS.IsRunning() { - t.Errorf("Expected service to be down") - } - - chrS.chrS = &engine.ChargerS{} - if !chrS.IsRunning() { - t.Errorf("Expected service to be running") - } - serviceName := chrS.ServiceName() - if !reflect.DeepEqual(serviceName, utils.ChargerS) { - t.Errorf("\nExpecting <%+v>,\n Received <%+v>", utils.ChargerS, serviceName) - } - shouldRun := chrS.ShouldRun() - if !reflect.DeepEqual(shouldRun, false) { - t.Errorf("\nExpecting ,\n Received <%+v>", shouldRun) - } - chrS.connChan = make(chan birpc.ClientConnector, 1) - chrS.connChan <- &testMockClients{} - shutErr := chrS.Shutdown() - if shutErr != nil { - t.Errorf("\nExpecting <%+v>,\n Received <%+v>", nil, shutErr) - } - -} +// import ( +// "reflect" +// "sync" +// "testing" +// +// "github.com/cgrates/birpc" +// "github.com/cgrates/birpc/context" +// "github.com/cgrates/cgrates/commonlisteners" +// "github.com/cgrates/cgrates/config" +// "github.com/cgrates/cgrates/engine" +// "github.com/cgrates/cgrates/utils" +// ) +// +// // TestChargerSCoverage for cover testing +// func TestChargerSCoverage(t *testing.T) { +// cfg := config.NewDefaultCGRConfig() +// cfg.AttributeSCfg().Enabled = true +// filterSChan := make(chan *engine.FilterS, 1) +// filterSChan <- nil +// srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} +// cls := commonlisteners.NewCommonListenerS(nil) +// db := NewDataDBService(cfg, nil, false, srvDep) +// anz := NewAnalyzerService(cfg, cls, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) +// chS := NewCacheService(cfg, db, nil, cls, make(chan context.ClientConnector, 1), anz, nil, srvDep) +// chrS1 := NewChargerService(cfg, db, chS, +// filterSChan, cls, make(chan birpc.ClientConnector, 1), +// nil, anz, srvDep) +// if chrS1.IsRunning() { +// t.Errorf("Expected service to be down") +// } +// chrS := &ChargerService{ +// connChan: make(chan birpc.ClientConnector, 1), +// cfg: cfg, +// dm: db, +// cacheS: chS, +// filterSChan: filterSChan, +// cls: cls, +// connMgr: nil, +// anz: anz, +// srvDep: srvDep, +// } +// if chrS.IsRunning() { +// t.Errorf("Expected service to be down") +// } +// +// chrS.chrS = &engine.ChargerS{} +// if !chrS.IsRunning() { +// t.Errorf("Expected service to be running") +// } +// serviceName := chrS.ServiceName() +// if !reflect.DeepEqual(serviceName, utils.ChargerS) { +// t.Errorf("\nExpecting <%+v>,\n Received <%+v>", utils.ChargerS, serviceName) +// } +// shouldRun := chrS.ShouldRun() +// if !reflect.DeepEqual(shouldRun, false) { +// t.Errorf("\nExpecting ,\n Received <%+v>", shouldRun) +// } +// chrS.connChan = make(chan birpc.ClientConnector, 1) +// chrS.connChan <- &testMockClients{} +// shutErr := chrS.Shutdown() +// if shutErr != nil { +// t.Errorf("\nExpecting <%+v>,\n Received <%+v>", nil, shutErr) +// } +// +// } diff --git a/services/cores_it_test.go b/services/cores_it_test.go index f6d4464aa..924f8a442 100644 --- a/services/cores_it_test.go +++ b/services/cores_it_test.go @@ -20,81 +20,81 @@ along with this program. If not, see */ package services -import ( - "path" - "sync" - "testing" - "time" - - "github.com/cgrates/birpc" - "github.com/cgrates/birpc/context" - "github.com/cgrates/cgrates/commonlisteners" - "github.com/cgrates/cgrates/config" - "github.com/cgrates/cgrates/engine" - "github.com/cgrates/cgrates/servmanager" - "github.com/cgrates/cgrates/utils" -) - -func TestCoreSReload(t *testing.T) { - cfg := config.NewDefaultCGRConfig() - - shdWg := new(sync.WaitGroup) - filterSChan := make(chan *engine.FilterS, 1) - filterSChan <- nil - cls := commonlisteners.NewCommonListenerS(nil) - srvMngr := servmanager.NewServiceManager(shdWg, nil, cfg) - srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} - db := NewDataDBService(cfg, nil, false, srvDep) - coreRPC := make(chan birpc.ClientConnector, 1) - anz := NewAnalyzerService(cfg, cls, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) - caps := engine.NewCaps(1, "test_caps") - coreS := NewCoreService(cfg, caps, cls, coreRPC, anz, nil, nil, srvDep) - engine.NewConnManager(cfg) - srvMngr.AddServices(coreS, - NewLoaderService(cfg, db, filterSChan, cls, make(chan birpc.ClientConnector, 1), nil, anz, srvDep), db) - ctx, cancel := context.WithCancel(context.TODO()) - srvMngr.StartServices(ctx, cancel) - if coreS.IsRunning() { - t.Fatalf("Expected service to be down") - } - - var reply string - cfg.ConfigPath = path.Join("/usr", "share", "cgrates", "conf", "samples", "caps_queue") - if err := cfg.V1ReloadConfig(context.Background(), &config.ReloadArgs{ - Section: config.CoreSJSON, - }, &reply); err != nil { - t.Fatal(err) - } else if reply != utils.OK { - t.Fatalf("Expecting OK ,received %s", reply) - } - select { - case d := <-coreRPC: - coreRPC <- d - case <-time.After(time.Second): - t.Fatal("It took to long to reload the cache") - } - if !coreS.IsRunning() { - t.Fatalf("Expected service to be running") - } - err := coreS.Start(ctx, cancel) - if err == nil || err != utils.ErrServiceAlreadyRunning { - t.Fatalf("\nExpecting <%+v>,\n Received <%+v>", utils.ErrServiceAlreadyRunning, err) - } - err = coreS.Reload(ctx, cancel) - if err != nil { - t.Fatalf("\nExpecting ,\n Received <%+v>", err) - } - err = coreS.Shutdown() - if err != nil { - t.Fatalf("\nExpecting ,\n Received <%+v>", err) - } - cfg.GetReloadChan() <- config.SectionToService[config.CoreSJSON] - time.Sleep(10 * time.Millisecond) - if !coreS.IsRunning() { - t.Fatalf("Expected service to be running") - } - - cancel() - time.Sleep(10 * time.Millisecond) - -} +// import ( +// "path" +// "sync" +// "testing" +// "time" +// +// "github.com/cgrates/birpc" +// "github.com/cgrates/birpc/context" +// "github.com/cgrates/cgrates/commonlisteners" +// "github.com/cgrates/cgrates/config" +// "github.com/cgrates/cgrates/engine" +// "github.com/cgrates/cgrates/servmanager" +// "github.com/cgrates/cgrates/utils" +// ) +// +// func TestCoreSReload(t *testing.T) { +// cfg := config.NewDefaultCGRConfig() +// +// shdWg := new(sync.WaitGroup) +// filterSChan := make(chan *engine.FilterS, 1) +// filterSChan <- nil +// cls := commonlisteners.NewCommonListenerS(nil) +// srvMngr := servmanager.NewServiceManager(shdWg, nil, cfg) +// srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} +// db := NewDataDBService(cfg, nil, false, srvDep) +// coreRPC := make(chan birpc.ClientConnector, 1) +// anz := NewAnalyzerService(cfg, cls, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) +// caps := engine.NewCaps(1, "test_caps") +// coreS := NewCoreService(cfg, caps, cls, coreRPC, anz, nil, nil, srvDep) +// engine.NewConnManager(cfg) +// srvMngr.AddServices(coreS, +// NewLoaderService(cfg, db, filterSChan, cls, make(chan birpc.ClientConnector, 1), nil, anz, srvDep), db) +// ctx, cancel := context.WithCancel(context.TODO()) +// srvMngr.StartServices(ctx, cancel) +// if coreS.IsRunning() { +// t.Fatalf("Expected service to be down") +// } +// +// var reply string +// cfg.ConfigPath = path.Join("/usr", "share", "cgrates", "conf", "samples", "caps_queue") +// if err := cfg.V1ReloadConfig(context.Background(), &config.ReloadArgs{ +// Section: config.CoreSJSON, +// }, &reply); err != nil { +// t.Fatal(err) +// } else if reply != utils.OK { +// t.Fatalf("Expecting OK ,received %s", reply) +// } +// select { +// case d := <-coreRPC: +// coreRPC <- d +// case <-time.After(time.Second): +// t.Fatal("It took to long to reload the cache") +// } +// if !coreS.IsRunning() { +// t.Fatalf("Expected service to be running") +// } +// err := coreS.Start(ctx, cancel) +// if err == nil || err != utils.ErrServiceAlreadyRunning { +// t.Fatalf("\nExpecting <%+v>,\n Received <%+v>", utils.ErrServiceAlreadyRunning, err) +// } +// err = coreS.Reload(ctx, cancel) +// if err != nil { +// t.Fatalf("\nExpecting ,\n Received <%+v>", err) +// } +// err = coreS.Shutdown() +// if err != nil { +// t.Fatalf("\nExpecting ,\n Received <%+v>", err) +// } +// cfg.GetReloadChan() <- config.SectionToService[config.CoreSJSON] +// time.Sleep(10 * time.Millisecond) +// if !coreS.IsRunning() { +// t.Fatalf("Expected service to be running") +// } +// +// cancel() +// time.Sleep(10 * time.Millisecond) +// +// } diff --git a/services/cores_test.go b/services/cores_test.go index f90a8068c..739869f05 100644 --- a/services/cores_test.go +++ b/services/cores_test.go @@ -17,59 +17,59 @@ along with this program. If not, see */ package services -import ( - "reflect" - "sync" - "testing" - - "github.com/cgrates/birpc" - "github.com/cgrates/cgrates/commonlisteners" - "github.com/cgrates/cgrates/config" - "github.com/cgrates/cgrates/cores" - "github.com/cgrates/cgrates/engine" - "github.com/cgrates/cgrates/utils" -) - -// TestCoreSCoverage for cover testing -func TestCoreSCoverage(t *testing.T) { - cfg := config.NewDefaultCGRConfig() - caps := engine.NewCaps(1, "test_caps") - cls := commonlisteners.NewCommonListenerS(nil) - internalCoreSChan := make(chan birpc.ClientConnector, 1) - filterSChan := make(chan *engine.FilterS, 1) - filterSChan <- nil - srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} - anz := NewAnalyzerService(cfg, cls, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) - srv := NewCoreService(cfg, caps, cls, internalCoreSChan, anz, nil, nil, srvDep) - if srv == nil { - t.Errorf("\nExpecting ,\n Received <%+v>", utils.ToJSON(srv)) - } - if srv.IsRunning() { - t.Errorf("Expected service to be down") - } - srv.cS = &cores.CoreS{} - if !srv.IsRunning() { - t.Errorf("Expected service to be running") - } - serviceName := srv.ServiceName() - if !reflect.DeepEqual(serviceName, utils.CoreS) { - t.Errorf("\nExpecting <%+v>,\n Received <%+v>", utils.CoreS, serviceName) - } - shouldRun := srv.ShouldRun() - if !reflect.DeepEqual(shouldRun, true) { - t.Errorf("\nExpecting ,\n Received <%+v>", shouldRun) - } - //populates connChan with something in order to call the shutdown function - srv.connChan <- &testMockClients{} - srv.stopChan = make(chan struct{}) - // srv.csCh = make(chan *cores.CoreService, 1) - srv.csCh <- nil - getShut := srv.Shutdown() - if getShut != nil { - t.Errorf("\nExpecting not ,\n Received <%+v>", getShut) - } - if srv.IsRunning() { - t.Errorf("Expected service to be down") - } - -} +// import ( +// "reflect" +// "sync" +// "testing" +// +// "github.com/cgrates/birpc" +// "github.com/cgrates/cgrates/commonlisteners" +// "github.com/cgrates/cgrates/config" +// "github.com/cgrates/cgrates/cores" +// "github.com/cgrates/cgrates/engine" +// "github.com/cgrates/cgrates/utils" +// ) +// +// // TestCoreSCoverage for cover testing +// func TestCoreSCoverage(t *testing.T) { +// cfg := config.NewDefaultCGRConfig() +// caps := engine.NewCaps(1, "test_caps") +// cls := commonlisteners.NewCommonListenerS(nil) +// internalCoreSChan := make(chan birpc.ClientConnector, 1) +// filterSChan := make(chan *engine.FilterS, 1) +// filterSChan <- nil +// srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} +// anz := NewAnalyzerService(cfg, cls, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) +// srv := NewCoreService(cfg, caps, cls, internalCoreSChan, anz, nil, nil, srvDep) +// if srv == nil { +// t.Errorf("\nExpecting ,\n Received <%+v>", utils.ToJSON(srv)) +// } +// if srv.IsRunning() { +// t.Errorf("Expected service to be down") +// } +// srv.cS = &cores.CoreS{} +// if !srv.IsRunning() { +// t.Errorf("Expected service to be running") +// } +// serviceName := srv.ServiceName() +// if !reflect.DeepEqual(serviceName, utils.CoreS) { +// t.Errorf("\nExpecting <%+v>,\n Received <%+v>", utils.CoreS, serviceName) +// } +// shouldRun := srv.ShouldRun() +// if !reflect.DeepEqual(shouldRun, true) { +// t.Errorf("\nExpecting ,\n Received <%+v>", shouldRun) +// } +// //populates connChan with something in order to call the shutdown function +// srv.connChan <- &testMockClients{} +// srv.stopChan = make(chan struct{}) +// // srv.csCh = make(chan *cores.CoreService, 1) +// srv.csCh <- nil +// getShut := srv.Shutdown() +// if getShut != nil { +// t.Errorf("\nExpecting not ,\n Received <%+v>", getShut) +// } +// if srv.IsRunning() { +// t.Errorf("Expected service to be down") +// } +// +// } diff --git a/services/datadb_it_test.go b/services/datadb_it_test.go index 462a704ca..15fb3e926 100644 --- a/services/datadb_it_test.go +++ b/services/datadb_it_test.go @@ -20,468 +20,468 @@ along with this program. If not, see */ package services -import ( - "path" - "reflect" - "sync" - "testing" - "time" - - "github.com/cgrates/birpc" - "github.com/cgrates/birpc/context" - "github.com/cgrates/cgrates/commonlisteners" - "github.com/cgrates/cgrates/config" - "github.com/cgrates/cgrates/engine" - "github.com/cgrates/cgrates/servmanager" - "github.com/cgrates/cgrates/utils" -) - -func TestDataDBReload(t *testing.T) { - cfg := config.NewDefaultCGRConfig() - - shdWg := new(sync.WaitGroup) - chS := engine.NewCacheS(cfg, nil, nil, nil) - filterSChan := make(chan *engine.FilterS, 1) - filterSChan <- nil - close(chS.GetPrecacheChannel(utils.CacheAttributeProfiles)) - close(chS.GetPrecacheChannel(utils.CacheAttributeFilterIndexes)) - chSCh := make(chan *engine.CacheS, 1) - chSCh <- chS - css := &CacheService{cacheCh: chSCh} - cls := commonlisteners.NewCommonListenerS(nil) - srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} - srvMngr := servmanager.NewServiceManager(shdWg, nil, cfg) - cM := engine.NewConnManager(cfg) - db := NewDataDBService(cfg, cM, false, srvDep) - anz := NewAnalyzerService(cfg, cls, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) - srvMngr.AddServices(NewAttributeService(cfg, db, - css, filterSChan, cls, make(chan birpc.ClientConnector, 1), anz, &DispatcherService{srvsReload: make(map[string]chan struct{})}, srvDep), - NewLoaderService(cfg, db, filterSChan, cls, make(chan birpc.ClientConnector, 1), nil, anz, srvDep), db) - ctx, cancel := context.WithCancel(context.TODO()) - srvMngr.StartServices(ctx, cancel) - if db.IsRunning() { - t.Errorf("Expected service to be down") - } - var reply string - cfg.AttributeSCfg().Enabled = true - cfg.ConfigPath = path.Join("/usr", "share", "cgrates", "conf", "samples", "tutmongo") - if err := cfg.V1ReloadConfig(context.Background(), &config.ReloadArgs{ - Section: config.DataDBJSON, - }, &reply); err != nil { - t.Error(err) - } else if reply != utils.OK { - t.Errorf("Expecting OK ,received %s", reply) - } - time.Sleep(10 * time.Millisecond) //need to switch to gorutine - if !db.IsRunning() { - t.Errorf("Expected service to be running") - } - oldcfg := &config.DataDbCfg{ - Type: utils.MetaMongo, - Host: "127.0.0.1", - Port: "27017", - Name: "10", - User: "cgrates", - Opts: &config.DataDBOpts{ - MongoQueryTimeout: 10 * time.Second, - RedisClusterSync: 5 * time.Second, - }, - RmtConns: []string{}, - RplConns: []string{}, - Items: map[string]*config.ItemOpts{ - utils.MetaAccounts: {Limit: -1}, - utils.MetaActions: {Limit: -1}, - utils.MetaResourceProfile: {Limit: -1}, - utils.MetaStatQueues: {Limit: -1}, - utils.MetaResources: {Limit: -1}, - utils.MetaStatQueueProfiles: {Limit: -1}, - utils.MetaThresholds: {Limit: -1}, - utils.MetaThresholdProfiles: {Limit: -1}, - utils.MetaFilters: {Limit: -1}, - utils.MetaRouteProfiles: {Limit: -1}, - utils.MetaAttributeProfiles: {Limit: -1}, - utils.MetaDispatcherHosts: {Limit: -1}, - utils.MetaChargerProfiles: {Limit: -1}, - utils.MetaDispatcherProfiles: {Limit: -1}, - utils.MetaLoadIDs: {Limit: -1}, - utils.MetaRateProfiles: {Limit: -1}, - utils.MetaActionProfiles: {Limit: -1}, - - utils.CacheResourceFilterIndexes: {Limit: -1}, - utils.CacheStatFilterIndexes: {Limit: -1}, - utils.CacheThresholdFilterIndexes: {Limit: -1}, - utils.CacheRouteFilterIndexes: {Limit: -1}, - utils.CacheAttributeFilterIndexes: {Limit: -1}, - utils.CacheChargerFilterIndexes: {Limit: -1}, - utils.CacheDispatcherFilterIndexes: {Limit: -1}, - utils.CacheRateProfilesFilterIndexes: {Limit: -1}, - utils.CacheActionProfilesFilterIndexes: {Limit: -1}, - utils.CacheAccountsFilterIndexes: {Limit: -1}, - utils.CacheVersions: {Limit: -1}, - utils.CacheReverseFilterIndexes: {Limit: -1}, - utils.CacheRateFilterIndexes: {Limit: -1}, - }, - } - if !reflect.DeepEqual(oldcfg, db.oldDBCfg) { - t.Errorf("Expected %s \n received:%s", utils.ToJSON(oldcfg), utils.ToJSON(db.oldDBCfg)) - } - - err := db.Reload(ctx, cancel) - if err != nil { - t.Errorf("\nExpecting ,\n Received <%+v>", err) - } - // cfg.AttributeSCfg().Enabled = false - // cfg.GetReloadChan() <- config.SectionToService[config.DataDBJSON] - // runtime.Gosched() - // time.Sleep(10 * time.Millisecond) - // if db.IsRunning() { - // t.Errorf("Expected service to be down") - // } - cancel() - time.Sleep(10 * time.Millisecond) -} - -func TestDataDBReloadBadType(t *testing.T) { - cfg, err := config.NewCGRConfigFromPath(context.Background(), path.Join("/usr", "share", "cgrates", "conf", "samples", "tutmongo")) - if err != nil { - t.Fatal(err) - } - dbConn, err := engine.NewDataDBConn(cfg.DataDbCfg().Type, - cfg.DataDbCfg().Host, cfg.DataDbCfg().Port, - cfg.DataDbCfg().Name, cfg.DataDbCfg().User, - cfg.DataDbCfg().Password, cfg.GeneralCfg().DBDataEncoding, - cfg.DataDbCfg().Opts, cfg.DataDbCfg().Items) - if err != nil { - t.Fatal(err) - } - defer func() { - dbConn.Flush("") - dbConn.Close() - }() - - err = dbConn.SetVersions(engine.Versions{ - utils.Stats: 4, - utils.Accounts: 3, - utils.Actions: 2, - utils.Thresholds: 4, - utils.Routes: 2, - // old version for Attributes - utils.Attributes: 5, - utils.RQF: 5, - utils.Resource: 1, - utils.Subscribers: 1, - utils.Chargers: 2, - utils.Dispatchers: 2, - utils.LoadIDsVrs: 1, - utils.RateProfiles: 1, - utils.ActionProfiles: 1, - }, true) - if err != nil { - t.Fatal(err) - } - filterSChan := make(chan *engine.FilterS, 1) - filterSChan <- nil - srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} - cM := engine.NewConnManager(cfg) - db := NewDataDBService(cfg, cM, false, srvDep) - db.oldDBCfg = &config.DataDbCfg{ - Type: utils.MetaMongo, - Host: "127.0.0.1", - Port: "27017", - Name: "10", - User: "cgrates", - Opts: &config.DataDBOpts{ - MongoQueryTimeout: 10 * time.Second, - RedisClusterSync: 5 * time.Second, - }, - RmtConns: []string{}, - RplConns: []string{}, - Items: map[string]*config.ItemOpts{ - utils.MetaAccounts: {}, - utils.MetaActions: {}, - utils.MetaCronExp: {}, - utils.MetaResourceProfile: {}, - utils.MetaStatQueues: {}, - utils.MetaResources: {}, - utils.MetaStatQueueProfiles: {}, - utils.MetaThresholds: {}, - utils.MetaThresholdProfiles: {}, - utils.MetaFilters: {}, - utils.MetaRouteProfiles: {}, - utils.MetaAttributeProfiles: {}, - utils.MetaDispatcherHosts: {}, - utils.MetaChargerProfiles: {}, - utils.MetaDispatcherProfiles: {}, - utils.MetaLoadIDs: {}, - utils.MetaRateProfiles: {}, - utils.MetaActionProfiles: {}, - }, - } - cfg.DataDbCfg().Type = "dbtype" - db.dm = nil - ctx, cancel := context.WithCancel(context.TODO()) - err = db.Reload(ctx, cancel) - if err == nil || err.Error() != "unsupported db_type " { - t.Fatal(err) - } - - cancel() - time.Sleep(10 * time.Millisecond) -} - -func TestDataDBReloadErrorMarsheler(t *testing.T) { - cfg := config.NewDefaultCGRConfig() - cfg.GeneralCfg().DBDataEncoding = "" - filterSChan := make(chan *engine.FilterS, 1) - filterSChan <- nil - srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} - cM := engine.NewConnManager(cfg) - db := NewDataDBService(cfg, cM, false, srvDep) - - if db.IsRunning() { - t.Errorf("Expected service to be down") - } - db.oldDBCfg = &config.DataDbCfg{ - Type: utils.MetaMongo, - Host: "127.0.0.1", - Port: "27017", - Name: "10", - User: "cgrates", - Opts: &config.DataDBOpts{ - MongoQueryTimeout: 10 * time.Second, - RedisClusterSync: 5 * time.Second, - }, - RmtConns: []string{}, - RplConns: []string{}, - Items: map[string]*config.ItemOpts{ - utils.MetaAccounts: {}, - utils.MetaActions: {}, - utils.MetaCronExp: {}, - utils.MetaResourceProfile: {}, - utils.MetaStatQueues: {}, - utils.MetaResources: {}, - utils.MetaStatQueueProfiles: {}, - utils.MetaThresholds: {}, - utils.MetaThresholdProfiles: {}, - utils.MetaFilters: {}, - utils.MetaRouteProfiles: {}, - utils.MetaAttributeProfiles: {}, - utils.MetaDispatcherHosts: {}, - utils.MetaChargerProfiles: {}, - utils.MetaDispatcherProfiles: {}, - utils.MetaLoadIDs: {}, - utils.MetaRateProfiles: {}, - utils.MetaActionProfiles: {}, - }, - } - - ctx, cancel := context.WithCancel(context.TODO()) - err := db.Reload(ctx, cancel) - if err == nil || err.Error() != "Unsupported marshaler: " { - t.Fatal(err) - } - cancel() - time.Sleep(10 * time.Millisecond) -} - -func TestDataDBStartVersion(t *testing.T) { - cfg, err := config.NewCGRConfigFromPath(context.Background(), path.Join("/usr", "share", "cgrates", "conf", "samples", "tutmongo")) - if err != nil { - t.Fatal(err) - } - dbConn, err := engine.NewDataDBConn(cfg.DataDbCfg().Type, - cfg.DataDbCfg().Host, cfg.DataDbCfg().Port, - cfg.DataDbCfg().Name, cfg.DataDbCfg().User, - cfg.DataDbCfg().Password, cfg.GeneralCfg().DBDataEncoding, - cfg.DataDbCfg().Opts, cfg.DataDbCfg().Items) - if err != nil { - t.Fatal(err) - } - defer func() { - dbConn.Flush("") - dbConn.Close() - }() - err = dbConn.SetVersions(engine.Versions{ - utils.Stats: 4, - utils.Accounts: 3, - utils.Actions: 2, - utils.Thresholds: 4, - utils.Routes: 2, - // old version for Attributes - utils.Attributes: 5, - utils.RQF: 5, - utils.Resource: 1, - utils.Subscribers: 1, - utils.Chargers: 2, - utils.Dispatchers: 2, - utils.LoadIDsVrs: 1, - utils.RateProfiles: 1, - utils.ActionProfiles: 1, - }, true) - if err != nil { - t.Fatal(err) - } - filterSChan := make(chan *engine.FilterS, 1) - filterSChan <- nil - srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} - cM := engine.NewConnManager(cfg) - db := NewDataDBService(cfg, cM, false, srvDep) - ctx, cancel := context.WithCancel(context.TODO()) - err = db.Start(ctx, cancel) - if err == nil || err.Error() != "Migration needed: please backup cgr data and run : " { - t.Errorf("\nExpecting <%+v>,\n Received <%+v>", "Migration needed: please backup cgr data and run : ", err) - } - cancel() - time.Sleep(10 * time.Millisecond) -} - -func TestDataDBReloadCastError(t *testing.T) { - cfg, err := config.NewCGRConfigFromPath(context.Background(), path.Join("/usr", "share", "cgrates", "conf", "samples", "tutmongo")) - if err != nil { - t.Fatal(err) - } - dbConn, err := engine.NewDataDBConn(cfg.DataDbCfg().Type, - cfg.DataDbCfg().Host, cfg.DataDbCfg().Port, - cfg.DataDbCfg().Name, cfg.DataDbCfg().User, - cfg.DataDbCfg().Password, cfg.GeneralCfg().DBDataEncoding, - cfg.DataDbCfg().Opts, cfg.DataDbCfg().Items) - if err != nil { - t.Fatal(err) - } - defer func() { - dbConn.Flush("") - dbConn.Close() - }() - - err = dbConn.SetVersions(engine.Versions{ - utils.Stats: 4, - utils.Accounts: 3, - utils.Actions: 2, - utils.Thresholds: 4, - utils.Routes: 2, - // old version for Attributes - utils.Attributes: 5, - utils.RQF: 5, - utils.Resource: 1, - utils.Subscribers: 1, - utils.Chargers: 2, - utils.Dispatchers: 2, - utils.LoadIDsVrs: 1, - utils.RateProfiles: 1, - utils.ActionProfiles: 1, - }, true) - if err != nil { - t.Fatal(err) - } - filterSChan := make(chan *engine.FilterS, 1) - filterSChan <- nil - srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} - cM := engine.NewConnManager(cfg) - db := NewDataDBService(cfg, cM, false, srvDep) - db.oldDBCfg = &config.DataDbCfg{ - Type: utils.MetaMongo, - Host: "127.0.0.1", - Port: "27017", - Name: "10", - User: "cgrates", - Opts: &config.DataDBOpts{ - MongoQueryTimeout: 10 * time.Second, - RedisClusterSync: 5 * time.Second, - }, - RmtConns: []string{}, - RplConns: []string{}, - Items: map[string]*config.ItemOpts{ - utils.MetaAccounts: {}, - utils.MetaActions: {}, - utils.MetaCronExp: {}, - utils.MetaResourceProfile: {}, - utils.MetaStatQueues: {}, - utils.MetaResources: {}, - utils.MetaStatQueueProfiles: {}, - utils.MetaThresholds: {}, - utils.MetaThresholdProfiles: {}, - utils.MetaFilters: {}, - utils.MetaRouteProfiles: {}, - utils.MetaAttributeProfiles: {}, - utils.MetaDispatcherHosts: {}, - utils.MetaChargerProfiles: {}, - utils.MetaDispatcherProfiles: {}, - utils.MetaLoadIDs: {}, - utils.MetaRateProfiles: {}, - utils.MetaActionProfiles: {}, - }, - } - - db.dm = nil - ctx, cancel := context.WithCancel(context.TODO()) - err = db.Reload(ctx, cancel) - if err == nil || err.Error() != "can't conver DataDB of type mongo to MongoStorage" { - t.Fatal(err) - } - - cancel() - time.Sleep(10 * time.Millisecond) -} - -func TestDataDBStartAttributeSCfgErr(t *testing.T) { - cfg := config.NewDefaultCGRConfig() - srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} - cM := engine.NewConnManager(cfg) - db := NewDataDBService(cfg, cM, false, srvDep) - cfg.DataDbCfg().Type = "badtype" - cfg.AttributeSCfg().Enabled = true - cfg.SessionSCfg().ListenBijson = "" - ctx, cancel := context.WithCancel(context.TODO()) - err := db.Start(ctx, cancel) - if err == nil || err.Error() != "unsupported db_type " { - t.Errorf("\nExpecting <%+v>,\n Received <%+v>", "unsupported db_type ", err) - } -} - -func TestDataDBReloadError(t *testing.T) { - cfg := config.NewDefaultCGRConfig() - srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} - cM := engine.NewConnManager(cfg) - db := NewDataDBService(cfg, cM, false, srvDep) - cfg.GeneralCfg().DBDataEncoding = utils.JSON - db.oldDBCfg = &config.DataDbCfg{ - Type: utils.MetaMongo, - Host: "127.0.0.1", - Port: "27017", - Name: "10", - User: "cgrates", - Opts: &config.DataDBOpts{ - MongoQueryTimeout: 10 * time.Second, - RedisClusterSync: 5 * time.Second, - }, - RmtConns: []string{}, - RplConns: []string{}, - Items: map[string]*config.ItemOpts{ - utils.MetaAccounts: {}, - utils.MetaActions: {}, - utils.MetaCronExp: {}, - utils.MetaResourceProfile: {}, - utils.MetaStatQueues: {}, - utils.MetaResources: {}, - utils.MetaStatQueueProfiles: {}, - utils.MetaThresholds: {}, - utils.MetaThresholdProfiles: {}, - utils.MetaFilters: {}, - utils.MetaRouteProfiles: {}, - utils.MetaAttributeProfiles: {}, - utils.MetaDispatcherHosts: {}, - utils.MetaChargerProfiles: {}, - utils.MetaDispatcherProfiles: {}, - utils.MetaLoadIDs: {}, - utils.MetaRateProfiles: {}, - utils.MetaActionProfiles: {}, - }, - } - data := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items) - db.dm = engine.NewDataManager(data, nil, nil) - ctx, cancel := context.WithCancel(context.TODO()) - err := db.Reload(ctx, cancel) - if err != nil { - t.Errorf("\nExpecting <%+v>,\n Received <%+v>", nil, err) - } -} +// import ( +// "path" +// "reflect" +// "sync" +// "testing" +// "time" +// +// "github.com/cgrates/birpc" +// "github.com/cgrates/birpc/context" +// "github.com/cgrates/cgrates/commonlisteners" +// "github.com/cgrates/cgrates/config" +// "github.com/cgrates/cgrates/engine" +// "github.com/cgrates/cgrates/servmanager" +// "github.com/cgrates/cgrates/utils" +// ) +// +// func TestDataDBReload(t *testing.T) { +// cfg := config.NewDefaultCGRConfig() +// +// shdWg := new(sync.WaitGroup) +// chS := engine.NewCacheS(cfg, nil, nil, nil) +// filterSChan := make(chan *engine.FilterS, 1) +// filterSChan <- nil +// close(chS.GetPrecacheChannel(utils.CacheAttributeProfiles)) +// close(chS.GetPrecacheChannel(utils.CacheAttributeFilterIndexes)) +// chSCh := make(chan *engine.CacheS, 1) +// chSCh <- chS +// css := &CacheService{cacheCh: chSCh} +// cls := commonlisteners.NewCommonListenerS(nil) +// srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} +// srvMngr := servmanager.NewServiceManager(shdWg, nil, cfg) +// cM := engine.NewConnManager(cfg) +// db := NewDataDBService(cfg, cM, false, srvDep) +// anz := NewAnalyzerService(cfg, cls, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) +// srvMngr.AddServices(NewAttributeService(cfg, db, +// css, filterSChan, cls, make(chan birpc.ClientConnector, 1), anz, &DispatcherService{srvsReload: make(map[string]chan struct{})}, srvDep), +// NewLoaderService(cfg, db, filterSChan, cls, make(chan birpc.ClientConnector, 1), nil, anz, srvDep), db) +// ctx, cancel := context.WithCancel(context.TODO()) +// srvMngr.StartServices(ctx, cancel) +// if db.IsRunning() { +// t.Errorf("Expected service to be down") +// } +// var reply string +// cfg.AttributeSCfg().Enabled = true +// cfg.ConfigPath = path.Join("/usr", "share", "cgrates", "conf", "samples", "tutmongo") +// if err := cfg.V1ReloadConfig(context.Background(), &config.ReloadArgs{ +// Section: config.DataDBJSON, +// }, &reply); err != nil { +// t.Error(err) +// } else if reply != utils.OK { +// t.Errorf("Expecting OK ,received %s", reply) +// } +// time.Sleep(10 * time.Millisecond) //need to switch to gorutine +// if !db.IsRunning() { +// t.Errorf("Expected service to be running") +// } +// oldcfg := &config.DataDbCfg{ +// Type: utils.MetaMongo, +// Host: "127.0.0.1", +// Port: "27017", +// Name: "10", +// User: "cgrates", +// Opts: &config.DataDBOpts{ +// MongoQueryTimeout: 10 * time.Second, +// RedisClusterSync: 5 * time.Second, +// }, +// RmtConns: []string{}, +// RplConns: []string{}, +// Items: map[string]*config.ItemOpts{ +// utils.MetaAccounts: {Limit: -1}, +// utils.MetaActions: {Limit: -1}, +// utils.MetaResourceProfile: {Limit: -1}, +// utils.MetaStatQueues: {Limit: -1}, +// utils.MetaResources: {Limit: -1}, +// utils.MetaStatQueueProfiles: {Limit: -1}, +// utils.MetaThresholds: {Limit: -1}, +// utils.MetaThresholdProfiles: {Limit: -1}, +// utils.MetaFilters: {Limit: -1}, +// utils.MetaRouteProfiles: {Limit: -1}, +// utils.MetaAttributeProfiles: {Limit: -1}, +// utils.MetaDispatcherHosts: {Limit: -1}, +// utils.MetaChargerProfiles: {Limit: -1}, +// utils.MetaDispatcherProfiles: {Limit: -1}, +// utils.MetaLoadIDs: {Limit: -1}, +// utils.MetaRateProfiles: {Limit: -1}, +// utils.MetaActionProfiles: {Limit: -1}, +// +// utils.CacheResourceFilterIndexes: {Limit: -1}, +// utils.CacheStatFilterIndexes: {Limit: -1}, +// utils.CacheThresholdFilterIndexes: {Limit: -1}, +// utils.CacheRouteFilterIndexes: {Limit: -1}, +// utils.CacheAttributeFilterIndexes: {Limit: -1}, +// utils.CacheChargerFilterIndexes: {Limit: -1}, +// utils.CacheDispatcherFilterIndexes: {Limit: -1}, +// utils.CacheRateProfilesFilterIndexes: {Limit: -1}, +// utils.CacheActionProfilesFilterIndexes: {Limit: -1}, +// utils.CacheAccountsFilterIndexes: {Limit: -1}, +// utils.CacheVersions: {Limit: -1}, +// utils.CacheReverseFilterIndexes: {Limit: -1}, +// utils.CacheRateFilterIndexes: {Limit: -1}, +// }, +// } +// if !reflect.DeepEqual(oldcfg, db.oldDBCfg) { +// t.Errorf("Expected %s \n received:%s", utils.ToJSON(oldcfg), utils.ToJSON(db.oldDBCfg)) +// } +// +// err := db.Reload(ctx, cancel) +// if err != nil { +// t.Errorf("\nExpecting ,\n Received <%+v>", err) +// } +// // cfg.AttributeSCfg().Enabled = false +// // cfg.GetReloadChan() <- config.SectionToService[config.DataDBJSON] +// // runtime.Gosched() +// // time.Sleep(10 * time.Millisecond) +// // if db.IsRunning() { +// // t.Errorf("Expected service to be down") +// // } +// cancel() +// time.Sleep(10 * time.Millisecond) +// } +// +// func TestDataDBReloadBadType(t *testing.T) { +// cfg, err := config.NewCGRConfigFromPath(context.Background(), path.Join("/usr", "share", "cgrates", "conf", "samples", "tutmongo")) +// if err != nil { +// t.Fatal(err) +// } +// dbConn, err := engine.NewDataDBConn(cfg.DataDbCfg().Type, +// cfg.DataDbCfg().Host, cfg.DataDbCfg().Port, +// cfg.DataDbCfg().Name, cfg.DataDbCfg().User, +// cfg.DataDbCfg().Password, cfg.GeneralCfg().DBDataEncoding, +// cfg.DataDbCfg().Opts, cfg.DataDbCfg().Items) +// if err != nil { +// t.Fatal(err) +// } +// defer func() { +// dbConn.Flush("") +// dbConn.Close() +// }() +// +// err = dbConn.SetVersions(engine.Versions{ +// utils.Stats: 4, +// utils.Accounts: 3, +// utils.Actions: 2, +// utils.Thresholds: 4, +// utils.Routes: 2, +// // old version for Attributes +// utils.Attributes: 5, +// utils.RQF: 5, +// utils.Resource: 1, +// utils.Subscribers: 1, +// utils.Chargers: 2, +// utils.Dispatchers: 2, +// utils.LoadIDsVrs: 1, +// utils.RateProfiles: 1, +// utils.ActionProfiles: 1, +// }, true) +// if err != nil { +// t.Fatal(err) +// } +// filterSChan := make(chan *engine.FilterS, 1) +// filterSChan <- nil +// srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} +// cM := engine.NewConnManager(cfg) +// db := NewDataDBService(cfg, cM, false, srvDep) +// db.oldDBCfg = &config.DataDbCfg{ +// Type: utils.MetaMongo, +// Host: "127.0.0.1", +// Port: "27017", +// Name: "10", +// User: "cgrates", +// Opts: &config.DataDBOpts{ +// MongoQueryTimeout: 10 * time.Second, +// RedisClusterSync: 5 * time.Second, +// }, +// RmtConns: []string{}, +// RplConns: []string{}, +// Items: map[string]*config.ItemOpts{ +// utils.MetaAccounts: {}, +// utils.MetaActions: {}, +// utils.MetaCronExp: {}, +// utils.MetaResourceProfile: {}, +// utils.MetaStatQueues: {}, +// utils.MetaResources: {}, +// utils.MetaStatQueueProfiles: {}, +// utils.MetaThresholds: {}, +// utils.MetaThresholdProfiles: {}, +// utils.MetaFilters: {}, +// utils.MetaRouteProfiles: {}, +// utils.MetaAttributeProfiles: {}, +// utils.MetaDispatcherHosts: {}, +// utils.MetaChargerProfiles: {}, +// utils.MetaDispatcherProfiles: {}, +// utils.MetaLoadIDs: {}, +// utils.MetaRateProfiles: {}, +// utils.MetaActionProfiles: {}, +// }, +// } +// cfg.DataDbCfg().Type = "dbtype" +// db.dm = nil +// ctx, cancel := context.WithCancel(context.TODO()) +// err = db.Reload(ctx, cancel) +// if err == nil || err.Error() != "unsupported db_type " { +// t.Fatal(err) +// } +// +// cancel() +// time.Sleep(10 * time.Millisecond) +// } +// +// func TestDataDBReloadErrorMarsheler(t *testing.T) { +// cfg := config.NewDefaultCGRConfig() +// cfg.GeneralCfg().DBDataEncoding = "" +// filterSChan := make(chan *engine.FilterS, 1) +// filterSChan <- nil +// srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} +// cM := engine.NewConnManager(cfg) +// db := NewDataDBService(cfg, cM, false, srvDep) +// +// if db.IsRunning() { +// t.Errorf("Expected service to be down") +// } +// db.oldDBCfg = &config.DataDbCfg{ +// Type: utils.MetaMongo, +// Host: "127.0.0.1", +// Port: "27017", +// Name: "10", +// User: "cgrates", +// Opts: &config.DataDBOpts{ +// MongoQueryTimeout: 10 * time.Second, +// RedisClusterSync: 5 * time.Second, +// }, +// RmtConns: []string{}, +// RplConns: []string{}, +// Items: map[string]*config.ItemOpts{ +// utils.MetaAccounts: {}, +// utils.MetaActions: {}, +// utils.MetaCronExp: {}, +// utils.MetaResourceProfile: {}, +// utils.MetaStatQueues: {}, +// utils.MetaResources: {}, +// utils.MetaStatQueueProfiles: {}, +// utils.MetaThresholds: {}, +// utils.MetaThresholdProfiles: {}, +// utils.MetaFilters: {}, +// utils.MetaRouteProfiles: {}, +// utils.MetaAttributeProfiles: {}, +// utils.MetaDispatcherHosts: {}, +// utils.MetaChargerProfiles: {}, +// utils.MetaDispatcherProfiles: {}, +// utils.MetaLoadIDs: {}, +// utils.MetaRateProfiles: {}, +// utils.MetaActionProfiles: {}, +// }, +// } +// +// ctx, cancel := context.WithCancel(context.TODO()) +// err := db.Reload(ctx, cancel) +// if err == nil || err.Error() != "Unsupported marshaler: " { +// t.Fatal(err) +// } +// cancel() +// time.Sleep(10 * time.Millisecond) +// } +// +// func TestDataDBStartVersion(t *testing.T) { +// cfg, err := config.NewCGRConfigFromPath(context.Background(), path.Join("/usr", "share", "cgrates", "conf", "samples", "tutmongo")) +// if err != nil { +// t.Fatal(err) +// } +// dbConn, err := engine.NewDataDBConn(cfg.DataDbCfg().Type, +// cfg.DataDbCfg().Host, cfg.DataDbCfg().Port, +// cfg.DataDbCfg().Name, cfg.DataDbCfg().User, +// cfg.DataDbCfg().Password, cfg.GeneralCfg().DBDataEncoding, +// cfg.DataDbCfg().Opts, cfg.DataDbCfg().Items) +// if err != nil { +// t.Fatal(err) +// } +// defer func() { +// dbConn.Flush("") +// dbConn.Close() +// }() +// err = dbConn.SetVersions(engine.Versions{ +// utils.Stats: 4, +// utils.Accounts: 3, +// utils.Actions: 2, +// utils.Thresholds: 4, +// utils.Routes: 2, +// // old version for Attributes +// utils.Attributes: 5, +// utils.RQF: 5, +// utils.Resource: 1, +// utils.Subscribers: 1, +// utils.Chargers: 2, +// utils.Dispatchers: 2, +// utils.LoadIDsVrs: 1, +// utils.RateProfiles: 1, +// utils.ActionProfiles: 1, +// }, true) +// if err != nil { +// t.Fatal(err) +// } +// filterSChan := make(chan *engine.FilterS, 1) +// filterSChan <- nil +// srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} +// cM := engine.NewConnManager(cfg) +// db := NewDataDBService(cfg, cM, false, srvDep) +// ctx, cancel := context.WithCancel(context.TODO()) +// err = db.Start(ctx, cancel) +// if err == nil || err.Error() != "Migration needed: please backup cgr data and run : " { +// t.Errorf("\nExpecting <%+v>,\n Received <%+v>", "Migration needed: please backup cgr data and run : ", err) +// } +// cancel() +// time.Sleep(10 * time.Millisecond) +// } +// +// func TestDataDBReloadCastError(t *testing.T) { +// cfg, err := config.NewCGRConfigFromPath(context.Background(), path.Join("/usr", "share", "cgrates", "conf", "samples", "tutmongo")) +// if err != nil { +// t.Fatal(err) +// } +// dbConn, err := engine.NewDataDBConn(cfg.DataDbCfg().Type, +// cfg.DataDbCfg().Host, cfg.DataDbCfg().Port, +// cfg.DataDbCfg().Name, cfg.DataDbCfg().User, +// cfg.DataDbCfg().Password, cfg.GeneralCfg().DBDataEncoding, +// cfg.DataDbCfg().Opts, cfg.DataDbCfg().Items) +// if err != nil { +// t.Fatal(err) +// } +// defer func() { +// dbConn.Flush("") +// dbConn.Close() +// }() +// +// err = dbConn.SetVersions(engine.Versions{ +// utils.Stats: 4, +// utils.Accounts: 3, +// utils.Actions: 2, +// utils.Thresholds: 4, +// utils.Routes: 2, +// // old version for Attributes +// utils.Attributes: 5, +// utils.RQF: 5, +// utils.Resource: 1, +// utils.Subscribers: 1, +// utils.Chargers: 2, +// utils.Dispatchers: 2, +// utils.LoadIDsVrs: 1, +// utils.RateProfiles: 1, +// utils.ActionProfiles: 1, +// }, true) +// if err != nil { +// t.Fatal(err) +// } +// filterSChan := make(chan *engine.FilterS, 1) +// filterSChan <- nil +// srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} +// cM := engine.NewConnManager(cfg) +// db := NewDataDBService(cfg, cM, false, srvDep) +// db.oldDBCfg = &config.DataDbCfg{ +// Type: utils.MetaMongo, +// Host: "127.0.0.1", +// Port: "27017", +// Name: "10", +// User: "cgrates", +// Opts: &config.DataDBOpts{ +// MongoQueryTimeout: 10 * time.Second, +// RedisClusterSync: 5 * time.Second, +// }, +// RmtConns: []string{}, +// RplConns: []string{}, +// Items: map[string]*config.ItemOpts{ +// utils.MetaAccounts: {}, +// utils.MetaActions: {}, +// utils.MetaCronExp: {}, +// utils.MetaResourceProfile: {}, +// utils.MetaStatQueues: {}, +// utils.MetaResources: {}, +// utils.MetaStatQueueProfiles: {}, +// utils.MetaThresholds: {}, +// utils.MetaThresholdProfiles: {}, +// utils.MetaFilters: {}, +// utils.MetaRouteProfiles: {}, +// utils.MetaAttributeProfiles: {}, +// utils.MetaDispatcherHosts: {}, +// utils.MetaChargerProfiles: {}, +// utils.MetaDispatcherProfiles: {}, +// utils.MetaLoadIDs: {}, +// utils.MetaRateProfiles: {}, +// utils.MetaActionProfiles: {}, +// }, +// } +// +// db.dm = nil +// ctx, cancel := context.WithCancel(context.TODO()) +// err = db.Reload(ctx, cancel) +// if err == nil || err.Error() != "can't conver DataDB of type mongo to MongoStorage" { +// t.Fatal(err) +// } +// +// cancel() +// time.Sleep(10 * time.Millisecond) +// } +// +// func TestDataDBStartAttributeSCfgErr(t *testing.T) { +// cfg := config.NewDefaultCGRConfig() +// srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} +// cM := engine.NewConnManager(cfg) +// db := NewDataDBService(cfg, cM, false, srvDep) +// cfg.DataDbCfg().Type = "badtype" +// cfg.AttributeSCfg().Enabled = true +// cfg.SessionSCfg().ListenBijson = "" +// ctx, cancel := context.WithCancel(context.TODO()) +// err := db.Start(ctx, cancel) +// if err == nil || err.Error() != "unsupported db_type " { +// t.Errorf("\nExpecting <%+v>,\n Received <%+v>", "unsupported db_type ", err) +// } +// } +// +// func TestDataDBReloadError(t *testing.T) { +// cfg := config.NewDefaultCGRConfig() +// srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} +// cM := engine.NewConnManager(cfg) +// db := NewDataDBService(cfg, cM, false, srvDep) +// cfg.GeneralCfg().DBDataEncoding = utils.JSON +// db.oldDBCfg = &config.DataDbCfg{ +// Type: utils.MetaMongo, +// Host: "127.0.0.1", +// Port: "27017", +// Name: "10", +// User: "cgrates", +// Opts: &config.DataDBOpts{ +// MongoQueryTimeout: 10 * time.Second, +// RedisClusterSync: 5 * time.Second, +// }, +// RmtConns: []string{}, +// RplConns: []string{}, +// Items: map[string]*config.ItemOpts{ +// utils.MetaAccounts: {}, +// utils.MetaActions: {}, +// utils.MetaCronExp: {}, +// utils.MetaResourceProfile: {}, +// utils.MetaStatQueues: {}, +// utils.MetaResources: {}, +// utils.MetaStatQueueProfiles: {}, +// utils.MetaThresholds: {}, +// utils.MetaThresholdProfiles: {}, +// utils.MetaFilters: {}, +// utils.MetaRouteProfiles: {}, +// utils.MetaAttributeProfiles: {}, +// utils.MetaDispatcherHosts: {}, +// utils.MetaChargerProfiles: {}, +// utils.MetaDispatcherProfiles: {}, +// utils.MetaLoadIDs: {}, +// utils.MetaRateProfiles: {}, +// utils.MetaActionProfiles: {}, +// }, +// } +// data := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items) +// db.dm = engine.NewDataManager(data, nil, nil) +// ctx, cancel := context.WithCancel(context.TODO()) +// err := db.Reload(ctx, cancel) +// if err != nil { +// t.Errorf("\nExpecting <%+v>,\n Received <%+v>", nil, err) +// } +// } diff --git a/services/datadb_test.go b/services/datadb_test.go index e5ff0ec7c..90207121e 100644 --- a/services/datadb_test.go +++ b/services/datadb_test.go @@ -17,75 +17,75 @@ along with this program. If not, see */ package services -import ( - "reflect" - "sync" - "testing" - "time" - - "github.com/cgrates/cgrates/config" - "github.com/cgrates/cgrates/engine" - "github.com/cgrates/cgrates/utils" -) - -// TestDataDBCoverage for cover testing -func TestDataDBCoverage(t *testing.T) { - cfg := config.NewDefaultCGRConfig() - //chS := engine.NewCacheS(cfg, nil, nil) - filterSChan := make(chan *engine.FilterS, 1) - filterSChan <- nil - srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} - cM := engine.NewConnManager(cfg) - db := NewDataDBService(cfg, cM, false, srvDep) - if db.IsRunning() { - t.Errorf("Expected service to be down") - } - //populates dataDb with something in order to call the close function - dataDb := new(engine.RedisStorage) - db.dm = engine.NewDataManager(dataDb, - &config.CacheCfg{}, nil) - if !db.IsRunning() { - t.Errorf("Expected service to be running") - } - oldcfg := &config.DataDbCfg{ - Type: utils.MetaMongo, - Host: "127.0.0.1", - Port: "27017", - Name: "10", - User: "cgrates", - Opts: &config.DataDBOpts{ - MongoQueryTimeout: 10 * time.Second, - RedisClusterSync: 5 * time.Second, - }, - RmtConns: []string{}, - RplConns: []string{}, - Items: map[string]*config.ItemOpts{ - utils.MetaAccounts: {}, - utils.MetaActions: {}, - utils.MetaCronExp: {}, - utils.MetaResourceProfile: {}, - utils.MetaStatQueues: {}, - utils.MetaResources: {}, - utils.MetaStatQueueProfiles: {}, - utils.MetaThresholds: {}, - utils.MetaThresholdProfiles: {}, - utils.MetaFilters: {}, - utils.MetaRouteProfiles: {}, - utils.MetaAttributeProfiles: {}, - utils.MetaDispatcherHosts: {}, - utils.MetaChargerProfiles: {}, - utils.MetaDispatcherProfiles: {}, - utils.MetaLoadIDs: {}, - utils.MetaRateProfiles: {}, - utils.MetaActionProfiles: {}, - }, - } - db.oldDBCfg = oldcfg - serviceName := db.ServiceName() - if !reflect.DeepEqual(serviceName, utils.DataDB) { - t.Errorf("\nExpecting <%+v>,\n Received <%+v>", utils.DataDB, serviceName) - } - if shouldRun := db.ShouldRun(); !shouldRun { - t.Errorf("\nExpecting ,\n Received <%+v>", shouldRun) - } -} +// import ( +// "reflect" +// "sync" +// "testing" +// "time" +// +// "github.com/cgrates/cgrates/config" +// "github.com/cgrates/cgrates/engine" +// "github.com/cgrates/cgrates/utils" +// ) +// +// // TestDataDBCoverage for cover testing +// func TestDataDBCoverage(t *testing.T) { +// cfg := config.NewDefaultCGRConfig() +// //chS := engine.NewCacheS(cfg, nil, nil) +// filterSChan := make(chan *engine.FilterS, 1) +// filterSChan <- nil +// srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} +// cM := engine.NewConnManager(cfg) +// db := NewDataDBService(cfg, cM, false, srvDep) +// if db.IsRunning() { +// t.Errorf("Expected service to be down") +// } +// //populates dataDb with something in order to call the close function +// dataDb := new(engine.RedisStorage) +// db.dm = engine.NewDataManager(dataDb, +// &config.CacheCfg{}, nil) +// if !db.IsRunning() { +// t.Errorf("Expected service to be running") +// } +// oldcfg := &config.DataDbCfg{ +// Type: utils.MetaMongo, +// Host: "127.0.0.1", +// Port: "27017", +// Name: "10", +// User: "cgrates", +// Opts: &config.DataDBOpts{ +// MongoQueryTimeout: 10 * time.Second, +// RedisClusterSync: 5 * time.Second, +// }, +// RmtConns: []string{}, +// RplConns: []string{}, +// Items: map[string]*config.ItemOpts{ +// utils.MetaAccounts: {}, +// utils.MetaActions: {}, +// utils.MetaCronExp: {}, +// utils.MetaResourceProfile: {}, +// utils.MetaStatQueues: {}, +// utils.MetaResources: {}, +// utils.MetaStatQueueProfiles: {}, +// utils.MetaThresholds: {}, +// utils.MetaThresholdProfiles: {}, +// utils.MetaFilters: {}, +// utils.MetaRouteProfiles: {}, +// utils.MetaAttributeProfiles: {}, +// utils.MetaDispatcherHosts: {}, +// utils.MetaChargerProfiles: {}, +// utils.MetaDispatcherProfiles: {}, +// utils.MetaLoadIDs: {}, +// utils.MetaRateProfiles: {}, +// utils.MetaActionProfiles: {}, +// }, +// } +// db.oldDBCfg = oldcfg +// serviceName := db.ServiceName() +// if !reflect.DeepEqual(serviceName, utils.DataDB) { +// t.Errorf("\nExpecting <%+v>,\n Received <%+v>", utils.DataDB, serviceName) +// } +// if shouldRun := db.ShouldRun(); !shouldRun { +// t.Errorf("\nExpecting ,\n Received <%+v>", shouldRun) +// } +// } diff --git a/services/diameteragent_it_test.go b/services/diameteragent_it_test.go index 1ddc19bca..5ef9442c6 100644 --- a/services/diameteragent_it_test.go +++ b/services/diameteragent_it_test.go @@ -20,119 +20,119 @@ along with this program. If not, see */ package services -import ( - "path" - "sync" - "testing" - "time" - - "github.com/cgrates/birpc" - "github.com/cgrates/birpc/context" - "github.com/cgrates/cgrates/commonlisteners" - "github.com/cgrates/cgrates/config" - "github.com/cgrates/cgrates/engine" - "github.com/cgrates/cgrates/servmanager" - "github.com/cgrates/cgrates/utils" -) - -func TestDiameterAgentReload1(t *testing.T) { - cfg := config.NewDefaultCGRConfig() - cfg.SessionSCfg().Enabled = true - cfg.SessionSCfg().ListenBijson = "" - filterSChan := make(chan *engine.FilterS, 1) - filterSChan <- nil - shdWg := new(sync.WaitGroup) - cls := commonlisteners.NewCommonListenerS(nil) - srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} - srvMngr := servmanager.NewServiceManager(shdWg, nil, cfg) - db := NewDataDBService(cfg, nil, false, srvDep) - anz := NewAnalyzerService(cfg, cls, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) - sS := NewSessionService(cfg, db, filterSChan, cls, make(chan birpc.ClientConnector, 1), - nil, anz, srvDep) - srv := NewDiameterAgent(cfg, filterSChan, nil, nil, srvDep) - engine.NewConnManager(cfg) - srvMngr.AddServices(srv, sS, - NewLoaderService(cfg, db, filterSChan, cls, make(chan birpc.ClientConnector, 1), nil, anz, srvDep), db) - ctx, cancel := context.WithCancel(context.TODO()) - srvMngr.StartServices(ctx, cancel) - if srv.IsRunning() { - t.Errorf("Expected service to be down") - } - var reply string - cfg.ConfigPath = path.Join("/usr", "share", "cgrates", "conf", "samples", "diamagent_mysql") - if err := cfg.V1ReloadConfig(context.Background(), &config.ReloadArgs{ - Section: config.DiameterAgentJSON, - }, &reply); err != nil { - t.Fatal(err) - } else if reply != utils.OK { - t.Errorf("Expecting OK ,received %s", reply) - } - time.Sleep(10 * time.Millisecond) //need to switch to gorutine - if !srv.IsRunning() { - t.Errorf("Expected service to be running") - } - err := srv.Start(ctx, cancel) - if err == nil || err != utils.ErrServiceAlreadyRunning { - t.Errorf("\nExpecting <%+v>,\n Received <%+v>", utils.ErrServiceAlreadyRunning, err) - } - err = srv.Reload(ctx, cancel) - if err != nil { - t.Errorf("\nExpecting ,\n Received <%+v>", err) - } - - cfg.DiameterAgentCfg().Enabled = false - cfg.GetReloadChan() <- config.SectionToService[config.DiameterAgentJSON] - srv.(*DiameterAgent).lnet = "bad_lnet_test" - err2 := srv.Reload(ctx, cancel) - if err != nil { - t.Errorf("\nExpected <%+v>, \nReceived <%+v>", nil, err2) - } - time.Sleep(10 * time.Millisecond) - if srv.IsRunning() { - t.Errorf("Expected service to be down") - } - cancel() - time.Sleep(10 * time.Millisecond) -} - -func TestDiameterAgentReload2(t *testing.T) { - cfg := config.NewDefaultCGRConfig() - cfg.SessionSCfg().Enabled = true - cfg.SessionSCfg().ListenBijson = "" - filterSChan := make(chan *engine.FilterS, 1) - filterSChan <- nil - srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} - srv := NewDiameterAgent(cfg, filterSChan, nil, nil, srvDep) - if srv.IsRunning() { - t.Errorf("Expected service to be down") - } - cfg.DiameterAgentCfg().Enabled = false - srv.(*DiameterAgent).stopChan = make(chan struct{}, 1) - srv.Shutdown() - if srv.IsRunning() { - t.Errorf("Expected service to be down") - } -} - -func TestDiameterAgentReload3(t *testing.T) { - cfg := config.NewDefaultCGRConfig() - filterSChan := make(chan *engine.FilterS, 1) - filterSChan <- nil - srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} - srv := NewDiameterAgent(cfg, filterSChan, nil, nil, srvDep) - - cfg.DiameterAgentCfg().ListenNet = "bad" - cfg.DiameterAgentCfg().DictionariesPath = "" - - err := srv.(*DiameterAgent).start(nil, func() {}, nil) - if err != nil { - t.Fatal(err) - } - cfg.DiameterAgentCfg().Enabled = false - ctx, cancel := context.WithCancel(context.TODO()) - err = srv.Reload(ctx, cancel) - if err != nil { - t.Fatal(err) - } - -} +// import ( +// "path" +// "sync" +// "testing" +// "time" +// +// "github.com/cgrates/birpc" +// "github.com/cgrates/birpc/context" +// "github.com/cgrates/cgrates/commonlisteners" +// "github.com/cgrates/cgrates/config" +// "github.com/cgrates/cgrates/engine" +// "github.com/cgrates/cgrates/servmanager" +// "github.com/cgrates/cgrates/utils" +// ) +// +// func TestDiameterAgentReload1(t *testing.T) { +// cfg := config.NewDefaultCGRConfig() +// cfg.SessionSCfg().Enabled = true +// cfg.SessionSCfg().ListenBijson = "" +// filterSChan := make(chan *engine.FilterS, 1) +// filterSChan <- nil +// shdWg := new(sync.WaitGroup) +// cls := commonlisteners.NewCommonListenerS(nil) +// srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} +// srvMngr := servmanager.NewServiceManager(shdWg, nil, cfg) +// db := NewDataDBService(cfg, nil, false, srvDep) +// anz := NewAnalyzerService(cfg, cls, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) +// sS := NewSessionService(cfg, db, filterSChan, cls, make(chan birpc.ClientConnector, 1), +// nil, anz, srvDep) +// srv := NewDiameterAgent(cfg, filterSChan, nil, nil, srvDep) +// engine.NewConnManager(cfg) +// srvMngr.AddServices(srv, sS, +// NewLoaderService(cfg, db, filterSChan, cls, make(chan birpc.ClientConnector, 1), nil, anz, srvDep), db) +// ctx, cancel := context.WithCancel(context.TODO()) +// srvMngr.StartServices(ctx, cancel) +// if srv.IsRunning() { +// t.Errorf("Expected service to be down") +// } +// var reply string +// cfg.ConfigPath = path.Join("/usr", "share", "cgrates", "conf", "samples", "diamagent_mysql") +// if err := cfg.V1ReloadConfig(context.Background(), &config.ReloadArgs{ +// Section: config.DiameterAgentJSON, +// }, &reply); err != nil { +// t.Fatal(err) +// } else if reply != utils.OK { +// t.Errorf("Expecting OK ,received %s", reply) +// } +// time.Sleep(10 * time.Millisecond) //need to switch to gorutine +// if !srv.IsRunning() { +// t.Errorf("Expected service to be running") +// } +// err := srv.Start(ctx, cancel) +// if err == nil || err != utils.ErrServiceAlreadyRunning { +// t.Errorf("\nExpecting <%+v>,\n Received <%+v>", utils.ErrServiceAlreadyRunning, err) +// } +// err = srv.Reload(ctx, cancel) +// if err != nil { +// t.Errorf("\nExpecting ,\n Received <%+v>", err) +// } +// +// cfg.DiameterAgentCfg().Enabled = false +// cfg.GetReloadChan() <- config.SectionToService[config.DiameterAgentJSON] +// srv.(*DiameterAgent).lnet = "bad_lnet_test" +// err2 := srv.Reload(ctx, cancel) +// if err != nil { +// t.Errorf("\nExpected <%+v>, \nReceived <%+v>", nil, err2) +// } +// time.Sleep(10 * time.Millisecond) +// if srv.IsRunning() { +// t.Errorf("Expected service to be down") +// } +// cancel() +// time.Sleep(10 * time.Millisecond) +// } +// +// func TestDiameterAgentReload2(t *testing.T) { +// cfg := config.NewDefaultCGRConfig() +// cfg.SessionSCfg().Enabled = true +// cfg.SessionSCfg().ListenBijson = "" +// filterSChan := make(chan *engine.FilterS, 1) +// filterSChan <- nil +// srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} +// srv := NewDiameterAgent(cfg, filterSChan, nil, nil, srvDep) +// if srv.IsRunning() { +// t.Errorf("Expected service to be down") +// } +// cfg.DiameterAgentCfg().Enabled = false +// srv.(*DiameterAgent).stopChan = make(chan struct{}, 1) +// srv.Shutdown() +// if srv.IsRunning() { +// t.Errorf("Expected service to be down") +// } +// } +// +// func TestDiameterAgentReload3(t *testing.T) { +// cfg := config.NewDefaultCGRConfig() +// filterSChan := make(chan *engine.FilterS, 1) +// filterSChan <- nil +// srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} +// srv := NewDiameterAgent(cfg, filterSChan, nil, nil, srvDep) +// +// cfg.DiameterAgentCfg().ListenNet = "bad" +// cfg.DiameterAgentCfg().DictionariesPath = "" +// +// err := srv.(*DiameterAgent).start(nil, func() {}, nil) +// if err != nil { +// t.Fatal(err) +// } +// cfg.DiameterAgentCfg().Enabled = false +// ctx, cancel := context.WithCancel(context.TODO()) +// err = srv.Reload(ctx, cancel) +// if err != nil { +// t.Fatal(err) +// } +// +// } diff --git a/services/dispatchers_it_test.go b/services/dispatchers_it_test.go index 4d8d3146a..da640d6ae 100644 --- a/services/dispatchers_it_test.go +++ b/services/dispatchers_it_test.go @@ -20,90 +20,90 @@ along with this program. If not, see */ package services -import ( - "path" - "runtime" - "sync" - "testing" - "time" - - "github.com/cgrates/birpc" - "github.com/cgrates/birpc/context" - "github.com/cgrates/cgrates/commonlisteners" - "github.com/cgrates/cgrates/config" - "github.com/cgrates/cgrates/engine" - "github.com/cgrates/cgrates/servmanager" - "github.com/cgrates/cgrates/utils" -) - -func TestDispatcherSReload(t *testing.T) { - cfg := config.NewDefaultCGRConfig() - - cfg.AttributeSCfg().Enabled = true - shdWg := new(sync.WaitGroup) - chS := engine.NewCacheS(cfg, nil, nil, nil) - close(chS.GetPrecacheChannel(utils.CacheAttributeProfiles)) - close(chS.GetPrecacheChannel(utils.CacheAttributeFilterIndexes)) - close(chS.GetPrecacheChannel(utils.CacheDispatcherProfiles)) - close(chS.GetPrecacheChannel(utils.CacheDispatcherHosts)) - close(chS.GetPrecacheChannel(utils.CacheDispatcherFilterIndexes)) - chSCh := make(chan *engine.CacheS, 1) - chSCh <- chS - css := &CacheService{cacheCh: chSCh} - filterSChan := make(chan *engine.FilterS, 1) - filterSChan <- nil - cls := commonlisteners.NewCommonListenerS(nil) - srvMngr := servmanager.NewServiceManager(shdWg, nil, cfg) - srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} - db := NewDataDBService(cfg, nil, false, srvDep) - anz := NewAnalyzerService(cfg, cls, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) - srv := NewDispatcherService(cfg, db, css, filterSChan, cls, - make(chan birpc.ClientConnector, 1), nil, anz, srvDep) - attrS := NewAttributeService(cfg, db, css, filterSChan, cls, make(chan birpc.ClientConnector, 1), anz, srv, srvDep) - engine.NewConnManager(cfg) - srvMngr.AddServices(attrS, srv, - NewLoaderService(cfg, db, filterSChan, cls, - make(chan birpc.ClientConnector, 1), nil, anz, srvDep), db) - ctx, cancel := context.WithCancel(context.TODO()) - srvMngr.StartServices(ctx, cancel) - if srv.IsRunning() { - t.Errorf("Expected service to be down") - } - if db.IsRunning() { - t.Errorf("Expected service to be down") - } - var reply string - cfg.ConfigPath = path.Join("/usr", "share", "cgrates", "conf", "samples", "dispatchers", "dispatchers_mysql") - if err := cfg.V1ReloadConfig(context.Background(), &config.ReloadArgs{ - Section: config.DispatcherSJSON, - }, &reply); err != nil { - t.Error(err) - } else if reply != utils.OK { - t.Errorf("Expecting OK ,received %s", reply) - } - runtime.Gosched() - runtime.Gosched() - time.Sleep(10 * time.Millisecond) //need to switch to gorutine - if !srv.IsRunning() { - t.Fatalf("Expected service to be running") - } - if !db.IsRunning() { - t.Errorf("Expected service to be running") - } - err := srv.Start(ctx, cancel) - if err == nil || err != utils.ErrServiceAlreadyRunning { - t.Errorf("\nExpecting <%+v>,\n Received <%+v>", utils.ErrServiceAlreadyRunning, err) - } - err = srv.Reload(ctx, cancel) - if err != nil { - t.Errorf("\nExpecting ,\n Received <%+v>", err) - } - cfg.DispatcherSCfg().Enabled = false - cfg.GetReloadChan() <- config.SectionToService[config.DispatcherSJSON] - time.Sleep(10 * time.Millisecond) - if srv.IsRunning() { - t.Errorf("Expected service to be down") - } - cancel() - time.Sleep(10 * time.Millisecond) -} +// import ( +// "path" +// "runtime" +// "sync" +// "testing" +// "time" +// +// "github.com/cgrates/birpc" +// "github.com/cgrates/birpc/context" +// "github.com/cgrates/cgrates/commonlisteners" +// "github.com/cgrates/cgrates/config" +// "github.com/cgrates/cgrates/engine" +// "github.com/cgrates/cgrates/servmanager" +// "github.com/cgrates/cgrates/utils" +// ) +// +// func TestDispatcherSReload(t *testing.T) { +// cfg := config.NewDefaultCGRConfig() +// +// cfg.AttributeSCfg().Enabled = true +// shdWg := new(sync.WaitGroup) +// chS := engine.NewCacheS(cfg, nil, nil, nil) +// close(chS.GetPrecacheChannel(utils.CacheAttributeProfiles)) +// close(chS.GetPrecacheChannel(utils.CacheAttributeFilterIndexes)) +// close(chS.GetPrecacheChannel(utils.CacheDispatcherProfiles)) +// close(chS.GetPrecacheChannel(utils.CacheDispatcherHosts)) +// close(chS.GetPrecacheChannel(utils.CacheDispatcherFilterIndexes)) +// chSCh := make(chan *engine.CacheS, 1) +// chSCh <- chS +// css := &CacheService{cacheCh: chSCh} +// filterSChan := make(chan *engine.FilterS, 1) +// filterSChan <- nil +// cls := commonlisteners.NewCommonListenerS(nil) +// srvMngr := servmanager.NewServiceManager(shdWg, nil, cfg) +// srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} +// db := NewDataDBService(cfg, nil, false, srvDep) +// anz := NewAnalyzerService(cfg, cls, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) +// srv := NewDispatcherService(cfg, db, css, filterSChan, cls, +// make(chan birpc.ClientConnector, 1), nil, anz, srvDep) +// attrS := NewAttributeService(cfg, db, css, filterSChan, cls, make(chan birpc.ClientConnector, 1), anz, srv, srvDep) +// engine.NewConnManager(cfg) +// srvMngr.AddServices(attrS, srv, +// NewLoaderService(cfg, db, filterSChan, cls, +// make(chan birpc.ClientConnector, 1), nil, anz, srvDep), db) +// ctx, cancel := context.WithCancel(context.TODO()) +// srvMngr.StartServices(ctx, cancel) +// if srv.IsRunning() { +// t.Errorf("Expected service to be down") +// } +// if db.IsRunning() { +// t.Errorf("Expected service to be down") +// } +// var reply string +// cfg.ConfigPath = path.Join("/usr", "share", "cgrates", "conf", "samples", "dispatchers", "dispatchers_mysql") +// if err := cfg.V1ReloadConfig(context.Background(), &config.ReloadArgs{ +// Section: config.DispatcherSJSON, +// }, &reply); err != nil { +// t.Error(err) +// } else if reply != utils.OK { +// t.Errorf("Expecting OK ,received %s", reply) +// } +// runtime.Gosched() +// runtime.Gosched() +// time.Sleep(10 * time.Millisecond) //need to switch to gorutine +// if !srv.IsRunning() { +// t.Fatalf("Expected service to be running") +// } +// if !db.IsRunning() { +// t.Errorf("Expected service to be running") +// } +// err := srv.Start(ctx, cancel) +// if err == nil || err != utils.ErrServiceAlreadyRunning { +// t.Errorf("\nExpecting <%+v>,\n Received <%+v>", utils.ErrServiceAlreadyRunning, err) +// } +// err = srv.Reload(ctx, cancel) +// if err != nil { +// t.Errorf("\nExpecting ,\n Received <%+v>", err) +// } +// cfg.DispatcherSCfg().Enabled = false +// cfg.GetReloadChan() <- config.SectionToService[config.DispatcherSJSON] +// time.Sleep(10 * time.Millisecond) +// if srv.IsRunning() { +// t.Errorf("Expected service to be down") +// } +// cancel() +// time.Sleep(10 * time.Millisecond) +// } diff --git a/services/dispatchers_test.go b/services/dispatchers_test.go index cadea5de0..323bb6f7f 100644 --- a/services/dispatchers_test.go +++ b/services/dispatchers_test.go @@ -17,68 +17,68 @@ along with this program. If not, see */ package services -import ( - "sync" - "testing" - - "github.com/cgrates/birpc" - "github.com/cgrates/birpc/context" - "github.com/cgrates/cgrates/commonlisteners" - "github.com/cgrates/cgrates/dispatchers" - - "github.com/cgrates/cgrates/config" - "github.com/cgrates/cgrates/engine" - "github.com/cgrates/cgrates/utils" -) - -// TestDispatcherSCoverage for cover testing -func TestDispatcherSCoverage(t *testing.T) { - cfg := config.NewDefaultCGRConfig() - cfg.AttributeSCfg().Enabled = true - filterSChan := make(chan *engine.FilterS, 1) - filterSChan <- nil - cls := commonlisteners.NewCommonListenerS(nil) - srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} - db := NewDataDBService(cfg, nil, false, srvDep) - anz := NewAnalyzerService(cfg, cls, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) - chS := NewCacheService(cfg, db, nil, cls, make(chan context.ClientConnector, 1), anz, nil, srvDep) - srv := NewDispatcherService(cfg, db, chS, filterSChan, cls, - make(chan birpc.ClientConnector, 1), engine.NewConnManager(cfg), anz, srvDep) - if srv.IsRunning() { - t.Errorf("Expected service to be down") - } - srv2 := DispatcherService{ - RWMutex: sync.RWMutex{}, - cfg: cfg, - dm: db, - cacheS: chS, - filterSChan: filterSChan, - cls: cls, - connMgr: srv.connMgr, - connChan: make(chan birpc.ClientConnector, 1), - anz: anz, - srvDep: srvDep, - } - srv2.dspS = &dispatchers.DispatcherService{} - if !srv2.IsRunning() { - t.Errorf("Expected service to be running") - } - - serviceName := srv2.ServiceName() - if serviceName != utils.DispatcherS { - t.Errorf("\nExpecting <%+v>,\n Received <%+v>", utils.DispatcherS, serviceName) - } - shouldRun := srv2.ShouldRun() - if shouldRun != false { - t.Errorf("\nExpecting <%+v>,\n Received <%+v>", false, shouldRun) - } - - srv2.connChan <- &testMockClients{} - shutErr := srv2.Shutdown() - if shutErr != nil { - t.Errorf("\nExpecting ,\n Received <%+v>", shutErr) - } - if srv2.IsRunning() { - t.Errorf("Expected service to be down") - } -} +// import ( +// "sync" +// "testing" +// +// "github.com/cgrates/birpc" +// "github.com/cgrates/birpc/context" +// "github.com/cgrates/cgrates/commonlisteners" +// "github.com/cgrates/cgrates/dispatchers" +// +// "github.com/cgrates/cgrates/config" +// "github.com/cgrates/cgrates/engine" +// "github.com/cgrates/cgrates/utils" +// ) +// +// // TestDispatcherSCoverage for cover testing +// func TestDispatcherSCoverage(t *testing.T) { +// cfg := config.NewDefaultCGRConfig() +// cfg.AttributeSCfg().Enabled = true +// filterSChan := make(chan *engine.FilterS, 1) +// filterSChan <- nil +// cls := commonlisteners.NewCommonListenerS(nil) +// srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} +// db := NewDataDBService(cfg, nil, false, srvDep) +// anz := NewAnalyzerService(cfg, cls, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) +// chS := NewCacheService(cfg, db, nil, cls, make(chan context.ClientConnector, 1), anz, nil, srvDep) +// srv := NewDispatcherService(cfg, db, chS, filterSChan, cls, +// make(chan birpc.ClientConnector, 1), engine.NewConnManager(cfg), anz, srvDep) +// if srv.IsRunning() { +// t.Errorf("Expected service to be down") +// } +// srv2 := DispatcherService{ +// RWMutex: sync.RWMutex{}, +// cfg: cfg, +// dm: db, +// cacheS: chS, +// filterSChan: filterSChan, +// cls: cls, +// connMgr: srv.connMgr, +// connChan: make(chan birpc.ClientConnector, 1), +// anz: anz, +// srvDep: srvDep, +// } +// srv2.dspS = &dispatchers.DispatcherService{} +// if !srv2.IsRunning() { +// t.Errorf("Expected service to be running") +// } +// +// serviceName := srv2.ServiceName() +// if serviceName != utils.DispatcherS { +// t.Errorf("\nExpecting <%+v>,\n Received <%+v>", utils.DispatcherS, serviceName) +// } +// shouldRun := srv2.ShouldRun() +// if shouldRun != false { +// t.Errorf("\nExpecting <%+v>,\n Received <%+v>", false, shouldRun) +// } +// +// srv2.connChan <- &testMockClients{} +// shutErr := srv2.Shutdown() +// if shutErr != nil { +// t.Errorf("\nExpecting ,\n Received <%+v>", shutErr) +// } +// if srv2.IsRunning() { +// t.Errorf("Expected service to be down") +// } +// } diff --git a/services/dnsagent_it_test.go b/services/dnsagent_it_test.go index 1cc153479..5b5cc7856 100644 --- a/services/dnsagent_it_test.go +++ b/services/dnsagent_it_test.go @@ -20,242 +20,242 @@ along with this program. If not, see */ package services -import ( - "path" - "runtime" - "sync" - "testing" - "time" - - "github.com/cgrates/birpc" - "github.com/cgrates/birpc/context" - "github.com/cgrates/cgrates/agents" - "github.com/cgrates/cgrates/commonlisteners" - "github.com/cgrates/cgrates/config" - "github.com/cgrates/cgrates/engine" - "github.com/cgrates/cgrates/servmanager" - "github.com/cgrates/cgrates/utils" -) - -func TestDNSAgentStartReloadShut(t *testing.T) { - cfg := config.NewDefaultCGRConfig() - cfg.SessionSCfg().Enabled = true - cfg.SessionSCfg().ListenBijson = "" - cfg.DNSAgentCfg().Enabled = true - cfg.DNSAgentCfg().Listeners = []config.Listener{ - { - Network: "udp", - Address: ":2055", - }, - { - Network: "tcp", - Address: ":2056", - }, - } - utils.Logger, _ = utils.NewSysLogger(cfg.GeneralCfg().NodeID, 7) - filterSChan := make(chan *engine.FilterS, 1) - filterSChan <- nil - ctx, cancel := context.WithCancel(context.TODO()) - defer func() { - cancel() - time.Sleep(10 * time.Millisecond) - }() - srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} - srv := NewDNSAgent(cfg, filterSChan, nil, srvDep) - shdWg := new(sync.WaitGroup) - srvMngr := servmanager.NewServiceManager(shdWg, nil, cfg) - engine.NewConnManager(cfg) - db := NewDataDBService(cfg, nil, false, srvDep) - cls := commonlisteners.NewCommonListenerS(nil) - anz := NewAnalyzerService(cfg, cls, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) - sS := NewSessionService(cfg, db, filterSChan, cls, make(chan birpc.ClientConnector, 1), - nil, anz, srvDep) - srvMngr.AddServices(srv, sS, - NewLoaderService(cfg, db, filterSChan, cls, make(chan birpc.ClientConnector, 1), nil, anz, srvDep), db) - runtime.Gosched() - time.Sleep(10 * time.Millisecond) //need to switch to gorutine - if err := srv.Shutdown(); err != nil { - t.Error(err) - } - time.Sleep(10 * time.Millisecond) - if err := srv.Start(ctx, cancel); err != nil { - t.Error(err) - } - time.Sleep(10 * time.Millisecond) - if err := srv.Reload(ctx, cancel); err != nil { - t.Error(err) - } - time.Sleep(10 * time.Millisecond) - if err := srv.Shutdown(); err != nil { - t.Error(err) - } - time.Sleep(10 * time.Millisecond) - if srv.IsRunning() { - t.Errorf("service is still running") - } -} - -func TestDNSAgentReloadFirst(t *testing.T) { - cfg := config.NewDefaultCGRConfig() - cfg.SessionSCfg().Enabled = true - cfg.SessionSCfg().ListenBijson = "" - utils.Logger, _ = utils.NewLogger(utils.MetaSysLog, cfg.GeneralCfg().NodeID, 7) - filterSChan := make(chan *engine.FilterS, 1) - filterSChan <- nil - ctx, cancel := context.WithCancel(context.TODO()) - defer func() { - cancel() - time.Sleep(10 * time.Millisecond) - }() - shdWg := new(sync.WaitGroup) - - cls := commonlisteners.NewCommonListenerS(nil) - srvMngr := servmanager.NewServiceManager(shdWg, nil, cfg) - srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} - db := NewDataDBService(cfg, nil, false, srvDep) - anz := NewAnalyzerService(cfg, cls, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) - sS := NewSessionService(cfg, db, filterSChan, cls, make(chan birpc.ClientConnector, 1), - nil, anz, srvDep) - srv := NewDNSAgent(cfg, filterSChan, nil, srvDep) - engine.NewConnManager(cfg) - srvMngr.AddServices(srv, sS, - NewLoaderService(cfg, db, filterSChan, cls, make(chan birpc.ClientConnector, 1), nil, anz, srvDep), db) - srvMngr.StartServices(ctx, cancel) - time.Sleep(100 * time.Millisecond) - if srv.IsRunning() { - t.Fatalf("Expected service to be down") - } - var reply string - cfg.ConfigPath = path.Join("/usr", "share", "cgrates", "conf", "samples", "dnsagent_reload") - if err := cfg.V1ReloadConfig(context.Background(), &config.ReloadArgs{ - Section: config.DNSAgentJSON, - }, &reply); err != nil { - t.Fatal(err) - } else if reply != utils.OK { - t.Fatalf("Expecting OK ,received %s", reply) - } - runtime.Gosched() - time.Sleep(10 * time.Millisecond) //need to switch to gorutine - if !srv.IsRunning() { - t.Fatalf("Expected service to be running") - } - err := srv.Start(ctx, cancel) - if err == nil || err != utils.ErrServiceAlreadyRunning { - t.Fatalf("\nExpecting <%+v>,\n Received <%+v>", utils.ErrServiceAlreadyRunning, err) - } - - err = srv.Reload(ctx, cancel) - if err != nil { - t.Fatalf("\nExpecting ,\n Received <%+v>", err) - } - err = srv.Reload(ctx, cancel) - if err != nil { - t.Fatalf("\nExpecting ,\n Received <%+v>", err) - } - time.Sleep(10 * time.Millisecond) - cfg.DNSAgentCfg().Enabled = false - time.Sleep(10 * time.Millisecond) - cfg.GetReloadChan() <- config.SectionToService[config.DNSAgentJSON] - time.Sleep(100 * time.Millisecond) - if srv.IsRunning() { - t.Fatalf("Expected service to be down") - } - -} - -func TestDNSAgentReload2(t *testing.T) { - cfg := config.NewDefaultCGRConfig() - cfg.SessionSCfg().Enabled = true - cfg.SessionSCfg().ListenBijson = "" - cfg.DNSAgentCfg().Enabled = true - cfg.DNSAgentCfg().Listeners[0].Network = "test" - cfg.DNSAgentCfg().Listeners[0].Address = "test" - filterSChan := make(chan *engine.FilterS, 1) - filterSChan <- nil - srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} - srv := NewDNSAgent(cfg, filterSChan, nil, srvDep) - agentSrv, err := agents.NewDNSAgent(cfg, nil, nil) - if err != nil { - t.Fatal(err) - } - runtime.Gosched() - dnsSrv := srv.(*DNSAgent) - dnsSrv.dns = agentSrv - err = dnsSrv.listenAndServe(make(chan struct{}), func() {}) - if err == nil || err.Error() != "dns: bad network" { - t.Fatalf("\nExpected <%+v>, \nReceived <%+v>", "dns: bad network", err) - } -} - -func TestDNSAgentReload4(t *testing.T) { - cfg := config.NewDefaultCGRConfig() - cfg.SessionSCfg().Enabled = true - cfg.DNSAgentCfg().Enabled = true - cfg.DNSAgentCfg().Listeners[0].Network = "tls" - cfg.TLSCfg().ServerCerificate = "bad_certificate" - cfg.TLSCfg().ServerKey = "bad_key" - filterSChan := make(chan *engine.FilterS, 1) - filterSChan <- nil - srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} - srv := NewDNSAgent(cfg, filterSChan, nil, srvDep) - - runtime.Gosched() - dnsSrv := srv.(*DNSAgent) - dnsSrv.dns = nil - ctx, cancel := context.WithCancel(context.TODO()) - err := dnsSrv.Start(ctx, cancel) - if err == nil || err.Error() != "load certificate error " { - t.Errorf("\nExpected <%+v>, \nReceived <%+v>", "load certificate error ", err) - } - dnsSrv.dns = nil -} - -func TestDNSAgentReload5(t *testing.T) { - cfg := config.NewDefaultCGRConfig() - cfg.SessionSCfg().Enabled = true - cfg.DNSAgentCfg().Enabled = true - - filterSChan := make(chan *engine.FilterS, 1) - filterSChan <- nil - srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} - srv := NewDNSAgent(cfg, filterSChan, nil, srvDep) - ctx, cancel := context.WithCancel(context.TODO()) - err := srv.Start(ctx, cancel) - if err != nil { - t.Fatalf("\nExpected <%+v>, \nReceived <%+v>", nil, err) - } - time.Sleep(10 * time.Millisecond) - runtime.Gosched() - runtime.Gosched() - err = srv.Reload(ctx, cancel) - if err != nil { - t.Fatalf("\nExpected <%+v>, \nReceived <%+v>", nil, err) - } -} - -func TestDNSAgentReload6(t *testing.T) { - cfg := config.NewDefaultCGRConfig() - cfg.SessionSCfg().Enabled = true - cfg.DNSAgentCfg().Enabled = true - - filterSChan := make(chan *engine.FilterS, 1) - filterSChan <- nil - srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} - srv := NewDNSAgent(cfg, filterSChan, nil, srvDep) - cfg.DNSAgentCfg().Listeners[0].Address = "127.0.0.1:0" - ctx, cancel := context.WithCancel(context.TODO()) - err := srv.Start(ctx, cancel) - if err != nil { - t.Fatalf("\nExpected <%+v>, \nReceived <%+v>", nil, err) - } - cfg.DNSAgentCfg().Listeners[0].Network = "tls" - cfg.TLSCfg().ServerCerificate = "bad_certificate" - cfg.TLSCfg().ServerKey = "bad_key" - time.Sleep(10 * time.Millisecond) - runtime.Gosched() - runtime.Gosched() - err = srv.Reload(ctx, cancel) - if err == nil || err.Error() != "load certificate error " { - t.Errorf("\nExpected <%+v>, \nReceived <%+v>", "load certificate error ", err) - } -} +// import ( +// "path" +// "runtime" +// "sync" +// "testing" +// "time" +// +// "github.com/cgrates/birpc" +// "github.com/cgrates/birpc/context" +// "github.com/cgrates/cgrates/agents" +// "github.com/cgrates/cgrates/commonlisteners" +// "github.com/cgrates/cgrates/config" +// "github.com/cgrates/cgrates/engine" +// "github.com/cgrates/cgrates/servmanager" +// "github.com/cgrates/cgrates/utils" +// ) +// +// func TestDNSAgentStartReloadShut(t *testing.T) { +// cfg := config.NewDefaultCGRConfig() +// cfg.SessionSCfg().Enabled = true +// cfg.SessionSCfg().ListenBijson = "" +// cfg.DNSAgentCfg().Enabled = true +// cfg.DNSAgentCfg().Listeners = []config.Listener{ +// { +// Network: "udp", +// Address: ":2055", +// }, +// { +// Network: "tcp", +// Address: ":2056", +// }, +// } +// utils.Logger, _ = utils.NewSysLogger(cfg.GeneralCfg().NodeID, 7) +// filterSChan := make(chan *engine.FilterS, 1) +// filterSChan <- nil +// ctx, cancel := context.WithCancel(context.TODO()) +// defer func() { +// cancel() +// time.Sleep(10 * time.Millisecond) +// }() +// srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} +// srv := NewDNSAgent(cfg, filterSChan, nil, srvDep) +// shdWg := new(sync.WaitGroup) +// srvMngr := servmanager.NewServiceManager(shdWg, nil, cfg) +// engine.NewConnManager(cfg) +// db := NewDataDBService(cfg, nil, false, srvDep) +// cls := commonlisteners.NewCommonListenerS(nil) +// anz := NewAnalyzerService(cfg, cls, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) +// sS := NewSessionService(cfg, db, filterSChan, cls, make(chan birpc.ClientConnector, 1), +// nil, anz, srvDep) +// srvMngr.AddServices(srv, sS, +// NewLoaderService(cfg, db, filterSChan, cls, make(chan birpc.ClientConnector, 1), nil, anz, srvDep), db) +// runtime.Gosched() +// time.Sleep(10 * time.Millisecond) //need to switch to gorutine +// if err := srv.Shutdown(); err != nil { +// t.Error(err) +// } +// time.Sleep(10 * time.Millisecond) +// if err := srv.Start(ctx, cancel); err != nil { +// t.Error(err) +// } +// time.Sleep(10 * time.Millisecond) +// if err := srv.Reload(ctx, cancel); err != nil { +// t.Error(err) +// } +// time.Sleep(10 * time.Millisecond) +// if err := srv.Shutdown(); err != nil { +// t.Error(err) +// } +// time.Sleep(10 * time.Millisecond) +// if srv.IsRunning() { +// t.Errorf("service is still running") +// } +// } +// +// func TestDNSAgentReloadFirst(t *testing.T) { +// cfg := config.NewDefaultCGRConfig() +// cfg.SessionSCfg().Enabled = true +// cfg.SessionSCfg().ListenBijson = "" +// utils.Logger, _ = utils.NewLogger(utils.MetaSysLog, cfg.GeneralCfg().NodeID, 7) +// filterSChan := make(chan *engine.FilterS, 1) +// filterSChan <- nil +// ctx, cancel := context.WithCancel(context.TODO()) +// defer func() { +// cancel() +// time.Sleep(10 * time.Millisecond) +// }() +// shdWg := new(sync.WaitGroup) +// +// cls := commonlisteners.NewCommonListenerS(nil) +// srvMngr := servmanager.NewServiceManager(shdWg, nil, cfg) +// srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} +// db := NewDataDBService(cfg, nil, false, srvDep) +// anz := NewAnalyzerService(cfg, cls, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) +// sS := NewSessionService(cfg, db, filterSChan, cls, make(chan birpc.ClientConnector, 1), +// nil, anz, srvDep) +// srv := NewDNSAgent(cfg, filterSChan, nil, srvDep) +// engine.NewConnManager(cfg) +// srvMngr.AddServices(srv, sS, +// NewLoaderService(cfg, db, filterSChan, cls, make(chan birpc.ClientConnector, 1), nil, anz, srvDep), db) +// srvMngr.StartServices(ctx, cancel) +// time.Sleep(100 * time.Millisecond) +// if srv.IsRunning() { +// t.Fatalf("Expected service to be down") +// } +// var reply string +// cfg.ConfigPath = path.Join("/usr", "share", "cgrates", "conf", "samples", "dnsagent_reload") +// if err := cfg.V1ReloadConfig(context.Background(), &config.ReloadArgs{ +// Section: config.DNSAgentJSON, +// }, &reply); err != nil { +// t.Fatal(err) +// } else if reply != utils.OK { +// t.Fatalf("Expecting OK ,received %s", reply) +// } +// runtime.Gosched() +// time.Sleep(10 * time.Millisecond) //need to switch to gorutine +// if !srv.IsRunning() { +// t.Fatalf("Expected service to be running") +// } +// err := srv.Start(ctx, cancel) +// if err == nil || err != utils.ErrServiceAlreadyRunning { +// t.Fatalf("\nExpecting <%+v>,\n Received <%+v>", utils.ErrServiceAlreadyRunning, err) +// } +// +// err = srv.Reload(ctx, cancel) +// if err != nil { +// t.Fatalf("\nExpecting ,\n Received <%+v>", err) +// } +// err = srv.Reload(ctx, cancel) +// if err != nil { +// t.Fatalf("\nExpecting ,\n Received <%+v>", err) +// } +// time.Sleep(10 * time.Millisecond) +// cfg.DNSAgentCfg().Enabled = false +// time.Sleep(10 * time.Millisecond) +// cfg.GetReloadChan() <- config.SectionToService[config.DNSAgentJSON] +// time.Sleep(100 * time.Millisecond) +// if srv.IsRunning() { +// t.Fatalf("Expected service to be down") +// } +// +// } +// +// func TestDNSAgentReload2(t *testing.T) { +// cfg := config.NewDefaultCGRConfig() +// cfg.SessionSCfg().Enabled = true +// cfg.SessionSCfg().ListenBijson = "" +// cfg.DNSAgentCfg().Enabled = true +// cfg.DNSAgentCfg().Listeners[0].Network = "test" +// cfg.DNSAgentCfg().Listeners[0].Address = "test" +// filterSChan := make(chan *engine.FilterS, 1) +// filterSChan <- nil +// srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} +// srv := NewDNSAgent(cfg, filterSChan, nil, srvDep) +// agentSrv, err := agents.NewDNSAgent(cfg, nil, nil) +// if err != nil { +// t.Fatal(err) +// } +// runtime.Gosched() +// dnsSrv := srv.(*DNSAgent) +// dnsSrv.dns = agentSrv +// err = dnsSrv.listenAndServe(make(chan struct{}), func() {}) +// if err == nil || err.Error() != "dns: bad network" { +// t.Fatalf("\nExpected <%+v>, \nReceived <%+v>", "dns: bad network", err) +// } +// } +// +// func TestDNSAgentReload4(t *testing.T) { +// cfg := config.NewDefaultCGRConfig() +// cfg.SessionSCfg().Enabled = true +// cfg.DNSAgentCfg().Enabled = true +// cfg.DNSAgentCfg().Listeners[0].Network = "tls" +// cfg.TLSCfg().ServerCerificate = "bad_certificate" +// cfg.TLSCfg().ServerKey = "bad_key" +// filterSChan := make(chan *engine.FilterS, 1) +// filterSChan <- nil +// srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} +// srv := NewDNSAgent(cfg, filterSChan, nil, srvDep) +// +// runtime.Gosched() +// dnsSrv := srv.(*DNSAgent) +// dnsSrv.dns = nil +// ctx, cancel := context.WithCancel(context.TODO()) +// err := dnsSrv.Start(ctx, cancel) +// if err == nil || err.Error() != "load certificate error " { +// t.Errorf("\nExpected <%+v>, \nReceived <%+v>", "load certificate error ", err) +// } +// dnsSrv.dns = nil +// } +// +// func TestDNSAgentReload5(t *testing.T) { +// cfg := config.NewDefaultCGRConfig() +// cfg.SessionSCfg().Enabled = true +// cfg.DNSAgentCfg().Enabled = true +// +// filterSChan := make(chan *engine.FilterS, 1) +// filterSChan <- nil +// srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} +// srv := NewDNSAgent(cfg, filterSChan, nil, srvDep) +// ctx, cancel := context.WithCancel(context.TODO()) +// err := srv.Start(ctx, cancel) +// if err != nil { +// t.Fatalf("\nExpected <%+v>, \nReceived <%+v>", nil, err) +// } +// time.Sleep(10 * time.Millisecond) +// runtime.Gosched() +// runtime.Gosched() +// err = srv.Reload(ctx, cancel) +// if err != nil { +// t.Fatalf("\nExpected <%+v>, \nReceived <%+v>", nil, err) +// } +// } +// +// func TestDNSAgentReload6(t *testing.T) { +// cfg := config.NewDefaultCGRConfig() +// cfg.SessionSCfg().Enabled = true +// cfg.DNSAgentCfg().Enabled = true +// +// filterSChan := make(chan *engine.FilterS, 1) +// filterSChan <- nil +// srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} +// srv := NewDNSAgent(cfg, filterSChan, nil, srvDep) +// cfg.DNSAgentCfg().Listeners[0].Address = "127.0.0.1:0" +// ctx, cancel := context.WithCancel(context.TODO()) +// err := srv.Start(ctx, cancel) +// if err != nil { +// t.Fatalf("\nExpected <%+v>, \nReceived <%+v>", nil, err) +// } +// cfg.DNSAgentCfg().Listeners[0].Network = "tls" +// cfg.TLSCfg().ServerCerificate = "bad_certificate" +// cfg.TLSCfg().ServerKey = "bad_key" +// time.Sleep(10 * time.Millisecond) +// runtime.Gosched() +// runtime.Gosched() +// err = srv.Reload(ctx, cancel) +// if err == nil || err.Error() != "load certificate error " { +// t.Errorf("\nExpected <%+v>, \nReceived <%+v>", "load certificate error ", err) +// } +// } diff --git a/services/dnsagent_test.go b/services/dnsagent_test.go index 683057120..ead1260bc 100644 --- a/services/dnsagent_test.go +++ b/services/dnsagent_test.go @@ -17,51 +17,51 @@ along with this program. If not, see */ package services -import ( - "sync" - "testing" - - "github.com/cgrates/cgrates/agents" - "github.com/cgrates/cgrates/config" - "github.com/cgrates/cgrates/engine" - "github.com/cgrates/cgrates/utils" -) - -// TestDNSAgentCoverage for cover testing -func TestDNSAgentCoverage(t *testing.T) { - cfg := config.NewDefaultCGRConfig() - cfg.SessionSCfg().Enabled = true - cfg.SessionSCfg().ListenBijson = "" - filterSChan := make(chan *engine.FilterS, 1) - filterSChan <- nil - srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} - srv := NewDNSAgent(cfg, filterSChan, nil, srvDep) - if srv.IsRunning() { - t.Errorf("Expected service to be down") - } - dns, _ := agents.NewDNSAgent(cfg, &engine.FilterS{}, nil) - srv2 := DNSAgent{ - cfg: cfg, - filterSChan: filterSChan, - stopChan: make(chan struct{}), - connMgr: nil, - srvDep: srvDep, - dns: dns, - } - - if !srv2.IsRunning() { - t.Errorf("Expected service to be running") - } - serviceName := srv2.ServiceName() - if serviceName != utils.DNSAgent { - t.Errorf("\nExpecting <%+v>,\n Received <%+v>", utils.DNSAgent, serviceName) - } - shouldRun := srv2.ShouldRun() - if shouldRun != false { - t.Errorf("\nExpecting <%+v>,\n Received <%+v>", false, shouldRun) - } - srv2.Shutdown() - if srv.IsRunning() { - t.Errorf("Expected service to be down") - } -} +// import ( +// "sync" +// "testing" +// +// "github.com/cgrates/cgrates/agents" +// "github.com/cgrates/cgrates/config" +// "github.com/cgrates/cgrates/engine" +// "github.com/cgrates/cgrates/utils" +// ) +// +// // TestDNSAgentCoverage for cover testing +// func TestDNSAgentCoverage(t *testing.T) { +// cfg := config.NewDefaultCGRConfig() +// cfg.SessionSCfg().Enabled = true +// cfg.SessionSCfg().ListenBijson = "" +// filterSChan := make(chan *engine.FilterS, 1) +// filterSChan <- nil +// srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} +// srv := NewDNSAgent(cfg, filterSChan, nil, srvDep) +// if srv.IsRunning() { +// t.Errorf("Expected service to be down") +// } +// dns, _ := agents.NewDNSAgent(cfg, &engine.FilterS{}, nil) +// srv2 := DNSAgent{ +// cfg: cfg, +// filterSChan: filterSChan, +// stopChan: make(chan struct{}), +// connMgr: nil, +// srvDep: srvDep, +// dns: dns, +// } +// +// if !srv2.IsRunning() { +// t.Errorf("Expected service to be running") +// } +// serviceName := srv2.ServiceName() +// if serviceName != utils.DNSAgent { +// t.Errorf("\nExpecting <%+v>,\n Received <%+v>", utils.DNSAgent, serviceName) +// } +// shouldRun := srv2.ShouldRun() +// if shouldRun != false { +// t.Errorf("\nExpecting <%+v>,\n Received <%+v>", false, shouldRun) +// } +// srv2.Shutdown() +// if srv.IsRunning() { +// t.Errorf("Expected service to be down") +// } +// } diff --git a/services/ees_it_test.go b/services/ees_it_test.go index 54715893b..4e4cb6476 100644 --- a/services/ees_it_test.go +++ b/services/ees_it_test.go @@ -18,125 +18,126 @@ 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 services -import ( - "os" - "path" - "sync" - "testing" - "time" - - "github.com/cgrates/birpc" - "github.com/cgrates/birpc/context" - "github.com/cgrates/cgrates/commonlisteners" - "github.com/cgrates/cgrates/config" - "github.com/cgrates/cgrates/engine" - "github.com/cgrates/cgrates/servmanager" - "github.com/cgrates/cgrates/utils" -) - -func TestEventExporterSReload(t *testing.T) { - for _, dir := range []string{"/tmp/testCSV", "/tmp/testComposedCSV", "/tmp/testFWV", "/tmp/testCSVMasked", - "/tmp/testCSVfromVirt", "/tmp/testCSVExpTemp"} { - if err := os.RemoveAll(dir); err != nil { - t.Fatal("Error removing folder: ", dir, err) - } - if err := os.MkdirAll(dir, 0755); err != nil { - t.Fatal("Error creating folder: ", dir, err) - } - } - cfg := config.NewDefaultCGRConfig() - - cfg.AttributeSCfg().Enabled = true - filterSChan := make(chan *engine.FilterS, 1) - filterSChan <- nil - shdWg := new(sync.WaitGroup) - cls := commonlisteners.NewCommonListenerS(nil) - srvMngr := servmanager.NewServiceManager(shdWg, nil, cfg) - srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} - db := NewDataDBService(cfg, nil, false, srvDep) - chS := engine.NewCacheS(cfg, nil, nil, nil) - close(chS.GetPrecacheChannel(utils.CacheAttributeProfiles)) - close(chS.GetPrecacheChannel(utils.CacheAttributeFilterIndexes)) - chSCh := make(chan *engine.CacheS, 1) - chSCh <- chS - css := &CacheService{cacheCh: chSCh} - anz := NewAnalyzerService(cfg, cls, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) - attrS := NewAttributeService(cfg, db, - css, filterSChan, cls, make(chan birpc.ClientConnector, 1), - anz, &DispatcherService{srvsReload: make(map[string]chan struct{})}, srvDep) - ees := NewEventExporterService(cfg, filterSChan, engine.NewConnManager(cfg), - cls, make(chan birpc.ClientConnector, 2), anz, srvDep) - srvMngr.AddServices(ees, attrS, - NewLoaderService(cfg, db, filterSChan, cls, make(chan birpc.ClientConnector, 1), nil, anz, srvDep), db) - ctx, cancel := context.WithCancel(context.TODO()) - srvMngr.StartServices(ctx, cancel) - if ees.IsRunning() { - t.Fatalf("Expected service to be down") - } - fcTmp := &config.FCTemplate{Tag: "TenantID", - Path: "Tenant", - Type: utils.MetaVariable, - Value: config.NewRSRParsersMustCompile("~*req.0", utils.InfieldSep), - Mandatory: true, - Layout: time.RFC3339, - } - fcTmp.ComputePath() - cfg.TemplatesCfg()["requiredFields"] = []*config.FCTemplate{fcTmp} - var reply string - cfg.ConfigPath = path.Join("/usr", "share", "cgrates", "conf", "samples", "ees") - if err := cfg.V1ReloadConfig(context.Background(), &config.ReloadArgs{ - Section: config.EEsJSON, - }, &reply); err != nil { - t.Fatal(err) - } else if reply != utils.OK { - t.Fatalf("Expecting OK ,received %s", reply) - } - time.Sleep(10 * time.Millisecond) //need to switch to gorutine - if !ees.IsRunning() { - t.Fatalf("Expected service to be running") - } - err := ees.Start(ctx, cancel) - if err == nil || err != utils.ErrServiceAlreadyRunning { - t.Fatalf("\nExpecting <%+v>,\n Received <%+v>", utils.ErrServiceAlreadyRunning, err) - } - err = ees.Reload(ctx, cancel) - if err != nil { - t.Fatalf("\nExpecting ,\n Received <%+v>", err) - } - cfg.EEsCfg().Enabled = false - cfg.GetReloadChan() <- config.SectionToService[config.EEsJSON] - time.Sleep(10 * time.Millisecond) - if ees.IsRunning() { - t.Fatalf("Expected service to be down") - } - cancel() - time.Sleep(10 * time.Millisecond) -} - -func TestEventExporterSReload2(t *testing.T) { - for _, dir := range []string{"/tmp/testCSV", "/tmp/testComposedCSV", "/tmp/testFWV", "/tmp/testCSVMasked", - "/tmp/testCSVfromVirt", "/tmp/testCSVExpTemp"} { - if err := os.RemoveAll(dir); err != nil { - t.Fatal("Error removing folder: ", dir, err) - } - if err := os.MkdirAll(dir, 0755); err != nil { - t.Fatal("Error creating folder: ", dir, err) - } - } - cfg := config.NewDefaultCGRConfig() - - cfg.AttributeSCfg().Enabled = true - filterSChan := make(chan *engine.FilterS, 1) - filterSChan <- nil - cls := commonlisteners.NewCommonListenerS(nil) - srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} - anz := NewAnalyzerService(cfg, cls, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) - ees := NewEventExporterService(cfg, filterSChan, engine.NewConnManager(cfg), - cls, make(chan birpc.ClientConnector, 2), anz, srvDep) - if ees.IsRunning() { - t.Fatalf("Expected service to be down") - } - -} +// import ( +// "os" +// "path" +// "sync" +// "testing" +// "time" +// +// "github.com/cgrates/birpc" +// "github.com/cgrates/birpc/context" +// "github.com/cgrates/cgrates/commonlisteners" +// "github.com/cgrates/cgrates/config" +// "github.com/cgrates/cgrates/engine" +// "github.com/cgrates/cgrates/servmanager" +// "github.com/cgrates/cgrates/utils" +// ) +// +// func TestEventExporterSReload(t *testing.T) { +// for _, dir := range []string{"/tmp/testCSV", "/tmp/testComposedCSV", "/tmp/testFWV", "/tmp/testCSVMasked", +// "/tmp/testCSVfromVirt", "/tmp/testCSVExpTemp"} { +// if err := os.RemoveAll(dir); err != nil { +// t.Fatal("Error removing folder: ", dir, err) +// } +// if err := os.MkdirAll(dir, 0755); err != nil { +// t.Fatal("Error creating folder: ", dir, err) +// } +// } +// cfg := config.NewDefaultCGRConfig() +// +// cfg.AttributeSCfg().Enabled = true +// filterSChan := make(chan *engine.FilterS, 1) +// filterSChan <- nil +// shdWg := new(sync.WaitGroup) +// cls := commonlisteners.NewCommonListenerS(nil) +// srvMngr := servmanager.NewServiceManager(shdWg, nil, cfg) +// srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} +// db := NewDataDBService(cfg, nil, false, srvDep) +// chS := engine.NewCacheS(cfg, nil, nil, nil) +// close(chS.GetPrecacheChannel(utils.CacheAttributeProfiles)) +// close(chS.GetPrecacheChannel(utils.CacheAttributeFilterIndexes)) +// chSCh := make(chan *engine.CacheS, 1) +// chSCh <- chS +// css := &CacheService{cacheCh: chSCh} +// anz := NewAnalyzerService(cfg, cls, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) +// attrS := NewAttributeService(cfg, db, +// css, filterSChan, cls, make(chan birpc.ClientConnector, 1), +// anz, &DispatcherService{srvsReload: make(map[string]chan struct{})}, srvDep) +// ees := NewEventExporterService(cfg, filterSChan, engine.NewConnManager(cfg), +// cls, make(chan birpc.ClientConnector, 2), anz, srvDep) +// srvMngr.AddServices(ees, attrS, +// NewLoaderService(cfg, db, filterSChan, cls, make(chan birpc.ClientConnector, 1), nil, anz, srvDep), db) +// ctx, cancel := context.WithCancel(context.TODO()) +// srvMngr.StartServices(ctx, cancel) +// if ees.IsRunning() { +// t.Fatalf("Expected service to be down") +// } +// fcTmp := &config.FCTemplate{Tag: "TenantID", +// Path: "Tenant", +// Type: utils.MetaVariable, +// Value: config.NewRSRParsersMustCompile("~*req.0", utils.InfieldSep), +// Mandatory: true, +// Layout: time.RFC3339, +// } +// fcTmp.ComputePath() +// cfg.TemplatesCfg()["requiredFields"] = []*config.FCTemplate{fcTmp} +// var reply string +// cfg.ConfigPath = path.Join("/usr", "share", "cgrates", "conf", "samples", "ees") +// if err := cfg.V1ReloadConfig(context.Background(), &config.ReloadArgs{ +// Section: config.EEsJSON, +// }, &reply); err != nil { +// t.Fatal(err) +// } else if reply != utils.OK { +// t.Fatalf("Expecting OK ,received %s", reply) +// } +// time.Sleep(10 * time.Millisecond) //need to switch to gorutine +// if !ees.IsRunning() { +// t.Fatalf("Expected service to be running") +// } +// err := ees.Start(ctx, cancel) +// if err == nil || err != utils.ErrServiceAlreadyRunning { +// t.Fatalf("\nExpecting <%+v>,\n Received <%+v>", utils.ErrServiceAlreadyRunning, err) +// } +// err = ees.Reload(ctx, cancel) +// if err != nil { +// t.Fatalf("\nExpecting ,\n Received <%+v>", err) +// } +// cfg.EEsCfg().Enabled = false +// cfg.GetReloadChan() <- config.SectionToService[config.EEsJSON] +// time.Sleep(10 * time.Millisecond) +// if ees.IsRunning() { +// t.Fatalf("Expected service to be down") +// } +// cancel() +// time.Sleep(10 * time.Millisecond) +// } +// +// func TestEventExporterSReload2(t *testing.T) { +// for _, dir := range []string{"/tmp/testCSV", "/tmp/testComposedCSV", "/tmp/testFWV", "/tmp/testCSVMasked", +// "/tmp/testCSVfromVirt", "/tmp/testCSVExpTemp"} { +// if err := os.RemoveAll(dir); err != nil { +// t.Fatal("Error removing folder: ", dir, err) +// } +// if err := os.MkdirAll(dir, 0755); err != nil { +// t.Fatal("Error creating folder: ", dir, err) +// } +// } +// cfg := config.NewDefaultCGRConfig() +// +// cfg.AttributeSCfg().Enabled = true +// filterSChan := make(chan *engine.FilterS, 1) +// filterSChan <- nil +// cls := commonlisteners.NewCommonListenerS(nil) +// srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} +// anz := NewAnalyzerService(cfg, cls, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) +// ees := NewEventExporterService(cfg, filterSChan, engine.NewConnManager(cfg), +// cls, make(chan birpc.ClientConnector, 2), anz, srvDep) +// if ees.IsRunning() { +// t.Fatalf("Expected service to be down") +// } +// +// } diff --git a/services/ees_test.go b/services/ees_test.go index ba6a08f20..9b889fde7 100644 --- a/services/ees_test.go +++ b/services/ees_test.go @@ -17,60 +17,60 @@ along with this program. If not, see */ package services -import ( - "sync" - "testing" - - "github.com/cgrates/birpc" - "github.com/cgrates/cgrates/commonlisteners" - "github.com/cgrates/cgrates/ees" - - "github.com/cgrates/cgrates/config" - "github.com/cgrates/cgrates/engine" - "github.com/cgrates/cgrates/utils" -) - -// TestEventExporterSCoverage for cover testing -func TestEventExporterSCoverage(t *testing.T) { - - cfg := config.NewDefaultCGRConfig() - cfg.AttributeSCfg().Enabled = true - filterSChan := make(chan *engine.FilterS, 1) - filterSChan <- nil - cls := commonlisteners.NewCommonListenerS(nil) - srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} - anz := NewAnalyzerService(cfg, cls, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) - srv := NewEventExporterService(cfg, filterSChan, engine.NewConnManager(cfg), cls, make(chan birpc.ClientConnector, 1), anz, srvDep) - if srv.IsRunning() { - t.Errorf("Expected service to be down") - } - srv2 := &EventExporterService{ - cfg: cfg, - filterSChan: filterSChan, - connMgr: engine.NewConnManager(cfg), - cls: cls, - intConnChan: make(chan birpc.ClientConnector, 1), - anz: anz, - srvDep: srvDep, - eeS: &ees.EeS{}, - } - if !srv2.IsRunning() { - t.Errorf("Expected service to be running") - } - serviceName := srv2.ServiceName() - if serviceName != utils.EEs { - t.Errorf("\nExpecting <%+v>,\n Received <%+v>", utils.EEs, serviceName) - } - shouldRun := srv2.ShouldRun() - if shouldRun != false { - t.Errorf("\nExpecting <%+v>,\n Received <%+v>", false, shouldRun) - } - srv2.intConnChan <- &testMockClients{} - shutErr := srv2.Shutdown() - if shutErr != nil { - t.Errorf("\nExpecting ,\n Received <%+v>", shutErr) - } - if srv2.IsRunning() { - t.Errorf("Expected service to be down") - } -} +// import ( +// "sync" +// "testing" +// +// "github.com/cgrates/birpc" +// "github.com/cgrates/cgrates/commonlisteners" +// "github.com/cgrates/cgrates/ees" +// +// "github.com/cgrates/cgrates/config" +// "github.com/cgrates/cgrates/engine" +// "github.com/cgrates/cgrates/utils" +// ) +// +// // TestEventExporterSCoverage for cover testing +// func TestEventExporterSCoverage(t *testing.T) { +// +// cfg := config.NewDefaultCGRConfig() +// cfg.AttributeSCfg().Enabled = true +// filterSChan := make(chan *engine.FilterS, 1) +// filterSChan <- nil +// cls := commonlisteners.NewCommonListenerS(nil) +// srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} +// anz := NewAnalyzerService(cfg, cls, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) +// srv := NewEventExporterService(cfg, filterSChan, engine.NewConnManager(cfg), cls, make(chan birpc.ClientConnector, 1), anz, srvDep) +// if srv.IsRunning() { +// t.Errorf("Expected service to be down") +// } +// srv2 := &EventExporterService{ +// cfg: cfg, +// filterSChan: filterSChan, +// connMgr: engine.NewConnManager(cfg), +// cls: cls, +// intConnChan: make(chan birpc.ClientConnector, 1), +// anz: anz, +// srvDep: srvDep, +// eeS: &ees.EeS{}, +// } +// if !srv2.IsRunning() { +// t.Errorf("Expected service to be running") +// } +// serviceName := srv2.ServiceName() +// if serviceName != utils.EEs { +// t.Errorf("\nExpecting <%+v>,\n Received <%+v>", utils.EEs, serviceName) +// } +// shouldRun := srv2.ShouldRun() +// if shouldRun != false { +// t.Errorf("\nExpecting <%+v>,\n Received <%+v>", false, shouldRun) +// } +// srv2.intConnChan <- &testMockClients{} +// shutErr := srv2.Shutdown() +// if shutErr != nil { +// t.Errorf("\nExpecting ,\n Received <%+v>", shutErr) +// } +// if srv2.IsRunning() { +// t.Errorf("Expected service to be down") +// } +// } diff --git a/services/ers_it_test.go b/services/ers_it_test.go index e2c858b4b..ede3bfea1 100644 --- a/services/ers_it_test.go +++ b/services/ers_it_test.go @@ -18,126 +18,127 @@ 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 services -import ( - "os" - "path" - "runtime" - "sync" - "testing" - "time" - - "github.com/cgrates/birpc" - "github.com/cgrates/birpc/context" - "github.com/cgrates/cgrates/commonlisteners" - "github.com/cgrates/cgrates/config" - "github.com/cgrates/cgrates/engine" - "github.com/cgrates/cgrates/ers" - "github.com/cgrates/cgrates/servmanager" - "github.com/cgrates/cgrates/utils" -) - -func TestEventReaderSReload(t *testing.T) { - for _, dir := range []string{"/tmp/ers/in", "/tmp/ers/out"} { - if err := os.RemoveAll(dir); err != nil { - t.Fatal("Error removing folder: ", dir, err) - } - if err := os.MkdirAll(dir, 0755); err != nil { - t.Fatal("Error creating folder: ", dir, err) - } - } - cfg := config.NewDefaultCGRConfig() - - cfg.SessionSCfg().Enabled = true - cfg.SessionSCfg().ListenBijson = "" - filterSChan := make(chan *engine.FilterS, 1) - filterSChan <- nil - ctx, cancel := context.WithCancel(context.TODO()) - defer func() { - cancel() - time.Sleep(10 * time.Millisecond) - }() - shdWg := new(sync.WaitGroup) - cls := commonlisteners.NewCommonListenerS(nil) - srvMngr := servmanager.NewServiceManager(shdWg, nil, cfg) - srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} - anz := NewAnalyzerService(cfg, cls, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) - db := NewDataDBService(cfg, nil, false, srvDep) - sS := NewSessionService(cfg, db, filterSChan, cls, make(chan birpc.ClientConnector, 1), nil, anz, srvDep) - intERsConn := make(chan birpc.ClientConnector, 1) - erS := NewEventReaderService(cfg, filterSChan, nil, cls, intERsConn, anz, srvDep) - engine.NewConnManager(cfg) - srvMngr.AddServices(erS, sS, - NewLoaderService(cfg, db, filterSChan, cls, make(chan birpc.ClientConnector, 1), nil, anz, srvDep), db) - srvMngr.StartServices(ctx, cancel) - if erS.IsRunning() { - t.Fatal("Expected service to be down") - } - var reply string - cfg.ConfigPath = path.Join("/usr", "share", "cgrates", "conf", "samples", "ers_reload", "internal") - if err := cfg.V1ReloadConfig(context.Background(), &config.ReloadArgs{ - Section: config.ERsJSON, - }, &reply); err != nil { - t.Fatal(err) - } else if reply != utils.OK { - t.Fatalf("Expecting OK ,received %s", reply) - } - runtime.Gosched() - if !erS.IsRunning() { - t.Fatalf("Expected service to be running") - } - - runtime.Gosched() - err := erS.Start(ctx, cancel) - if err == nil || err != utils.ErrServiceAlreadyRunning { - t.Fatalf("\nExpecting <%+v>,\n Received <%+v>", utils.ErrServiceAlreadyRunning, err) - } - time.Sleep(10 * time.Millisecond) - runtime.Gosched() - err = erS.Reload(ctx, cancel) - if err != nil { - t.Fatalf("\nExpecting ,\n Received <%+v>", err) - } - cfg.ERsCfg().Enabled = false - cfg.GetReloadChan() <- config.SectionToService[config.ERsJSON] - time.Sleep(10 * time.Millisecond) - if erS.IsRunning() { - t.Fatal("Expected service to be down") - } - -} - -func TestEventReaderSReload2(t *testing.T) { - for _, dir := range []string{"/tmp/ers/in", "/tmp/ers/out"} { - if err := os.RemoveAll(dir); err != nil { - t.Fatal("Error removing folder: ", dir, err) - } - if err := os.MkdirAll(dir, 0755); err != nil { - t.Fatal("Error creating folder: ", dir, err) - } - } - cfg := config.NewDefaultCGRConfig() - cfg.SessionSCfg().Enabled = true - cfg.ERsCfg().Enabled = true - cfg.ERsCfg().Readers = []*config.EventReaderCfg{ - { - Type: "bad_type", - }, - } - filterSChan := make(chan *engine.FilterS, 1) - filterSChan <- nil - srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} - cls := commonlisteners.NewCommonListenerS(nil) - erS := NewEventReaderService(cfg, filterSChan, nil, cls, nil, nil, srvDep) - ers := ers.NewERService(cfg, nil, nil) - - runtime.Gosched() - srv := erS.(*EventReaderService) - srv.stopChan = make(chan struct{}) - srv.rldChan = make(chan struct{}) - err := srv.listenAndServe(ers, srv.stopChan, srv.rldChan, func() {}) - if err == nil || err.Error() != "unsupported reader type: " { - t.Fatalf("\nExpected <%+v>, \nReceived <%+v>", "unsupported reader type: ", err) - } -} +// import ( +// "os" +// "path" +// "runtime" +// "sync" +// "testing" +// "time" +// +// "github.com/cgrates/birpc" +// "github.com/cgrates/birpc/context" +// "github.com/cgrates/cgrates/commonlisteners" +// "github.com/cgrates/cgrates/config" +// "github.com/cgrates/cgrates/engine" +// "github.com/cgrates/cgrates/ers" +// "github.com/cgrates/cgrates/servmanager" +// "github.com/cgrates/cgrates/utils" +// ) +// +// func TestEventReaderSReload(t *testing.T) { +// for _, dir := range []string{"/tmp/ers/in", "/tmp/ers/out"} { +// if err := os.RemoveAll(dir); err != nil { +// t.Fatal("Error removing folder: ", dir, err) +// } +// if err := os.MkdirAll(dir, 0755); err != nil { +// t.Fatal("Error creating folder: ", dir, err) +// } +// } +// cfg := config.NewDefaultCGRConfig() +// +// cfg.SessionSCfg().Enabled = true +// cfg.SessionSCfg().ListenBijson = "" +// filterSChan := make(chan *engine.FilterS, 1) +// filterSChan <- nil +// ctx, cancel := context.WithCancel(context.TODO()) +// defer func() { +// cancel() +// time.Sleep(10 * time.Millisecond) +// }() +// shdWg := new(sync.WaitGroup) +// cls := commonlisteners.NewCommonListenerS(nil) +// srvMngr := servmanager.NewServiceManager(shdWg, nil, cfg) +// srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} +// anz := NewAnalyzerService(cfg, cls, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) +// db := NewDataDBService(cfg, nil, false, srvDep) +// sS := NewSessionService(cfg, db, filterSChan, cls, make(chan birpc.ClientConnector, 1), nil, anz, srvDep) +// intERsConn := make(chan birpc.ClientConnector, 1) +// erS := NewEventReaderService(cfg, filterSChan, nil, cls, intERsConn, anz, srvDep) +// engine.NewConnManager(cfg) +// srvMngr.AddServices(erS, sS, +// NewLoaderService(cfg, db, filterSChan, cls, make(chan birpc.ClientConnector, 1), nil, anz, srvDep), db) +// srvMngr.StartServices(ctx, cancel) +// if erS.IsRunning() { +// t.Fatal("Expected service to be down") +// } +// var reply string +// cfg.ConfigPath = path.Join("/usr", "share", "cgrates", "conf", "samples", "ers_reload", "internal") +// if err := cfg.V1ReloadConfig(context.Background(), &config.ReloadArgs{ +// Section: config.ERsJSON, +// }, &reply); err != nil { +// t.Fatal(err) +// } else if reply != utils.OK { +// t.Fatalf("Expecting OK ,received %s", reply) +// } +// runtime.Gosched() +// if !erS.IsRunning() { +// t.Fatalf("Expected service to be running") +// } +// +// runtime.Gosched() +// err := erS.Start(ctx, cancel) +// if err == nil || err != utils.ErrServiceAlreadyRunning { +// t.Fatalf("\nExpecting <%+v>,\n Received <%+v>", utils.ErrServiceAlreadyRunning, err) +// } +// time.Sleep(10 * time.Millisecond) +// runtime.Gosched() +// err = erS.Reload(ctx, cancel) +// if err != nil { +// t.Fatalf("\nExpecting ,\n Received <%+v>", err) +// } +// cfg.ERsCfg().Enabled = false +// cfg.GetReloadChan() <- config.SectionToService[config.ERsJSON] +// time.Sleep(10 * time.Millisecond) +// if erS.IsRunning() { +// t.Fatal("Expected service to be down") +// } +// +// } +// +// func TestEventReaderSReload2(t *testing.T) { +// for _, dir := range []string{"/tmp/ers/in", "/tmp/ers/out"} { +// if err := os.RemoveAll(dir); err != nil { +// t.Fatal("Error removing folder: ", dir, err) +// } +// if err := os.MkdirAll(dir, 0755); err != nil { +// t.Fatal("Error creating folder: ", dir, err) +// } +// } +// cfg := config.NewDefaultCGRConfig() +// cfg.SessionSCfg().Enabled = true +// cfg.ERsCfg().Enabled = true +// cfg.ERsCfg().Readers = []*config.EventReaderCfg{ +// { +// Type: "bad_type", +// }, +// } +// filterSChan := make(chan *engine.FilterS, 1) +// filterSChan <- nil +// srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} +// cls := commonlisteners.NewCommonListenerS(nil) +// erS := NewEventReaderService(cfg, filterSChan, nil, cls, nil, nil, srvDep) +// ers := ers.NewERService(cfg, nil, nil) +// +// runtime.Gosched() +// srv := erS.(*EventReaderService) +// srv.stopChan = make(chan struct{}) +// srv.rldChan = make(chan struct{}) +// err := srv.listenAndServe(ers, srv.stopChan, srv.rldChan, func() {}) +// if err == nil || err.Error() != "unsupported reader type: " { +// t.Fatalf("\nExpected <%+v>, \nReceived <%+v>", "unsupported reader type: ", err) +// } +// } diff --git a/services/ers_test.go b/services/ers_test.go index ba40c8c81..8b8037fc1 100644 --- a/services/ers_test.go +++ b/services/ers_test.go @@ -17,57 +17,57 @@ along with this program. If not, see */ package services -import ( - "reflect" - "sync" - "testing" - - "github.com/cgrates/cgrates/commonlisteners" - "github.com/cgrates/cgrates/ers" - - "github.com/cgrates/cgrates/config" - "github.com/cgrates/cgrates/engine" - "github.com/cgrates/cgrates/utils" -) - -// TestEventReaderSCoverage for cover testing -func TestEventReaderSCoverage(t *testing.T) { - cfg := config.NewDefaultCGRConfig() - cfg.SessionSCfg().Enabled = true - filterSChan := make(chan *engine.FilterS, 1) - filterSChan <- nil - srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} - cls := commonlisteners.NewCommonListenerS(nil) - srv := NewEventReaderService(cfg, filterSChan, nil, cls, nil, nil, srvDep) - - if srv.IsRunning() { - t.Errorf("Expected service to be down") - } - - srv2 := EventReaderService{ - RWMutex: sync.RWMutex{}, - cfg: cfg, - filterSChan: filterSChan, - ers: &ers.ERService{}, - rldChan: make(chan struct{}, 1), - stopChan: make(chan struct{}, 1), - connMgr: nil, - cls: cls, - srvDep: srvDep, - } - if !srv2.IsRunning() { - t.Errorf("Expected service to be running") - } - serviceName := srv2.ServiceName() - if !reflect.DeepEqual(serviceName, utils.ERs) { - t.Errorf("\nExpecting <%+v>,\n Received <%+v>", utils.ERs, serviceName) - } - shouldRun := srv2.ShouldRun() - if !reflect.DeepEqual(shouldRun, false) { - t.Errorf("\nExpecting ,\n Received <%+v>", shouldRun) - } - srv2.Shutdown() - if srv.IsRunning() { - t.Errorf("Expected service to be down") - } -} +// import ( +// "reflect" +// "sync" +// "testing" +// +// "github.com/cgrates/cgrates/commonlisteners" +// "github.com/cgrates/cgrates/ers" +// +// "github.com/cgrates/cgrates/config" +// "github.com/cgrates/cgrates/engine" +// "github.com/cgrates/cgrates/utils" +// ) +// +// // TestEventReaderSCoverage for cover testing +// func TestEventReaderSCoverage(t *testing.T) { +// cfg := config.NewDefaultCGRConfig() +// cfg.SessionSCfg().Enabled = true +// filterSChan := make(chan *engine.FilterS, 1) +// filterSChan <- nil +// srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} +// cls := commonlisteners.NewCommonListenerS(nil) +// srv := NewEventReaderService(cfg, filterSChan, nil, cls, nil, nil, srvDep) +// +// if srv.IsRunning() { +// t.Errorf("Expected service to be down") +// } +// +// srv2 := EventReaderService{ +// RWMutex: sync.RWMutex{}, +// cfg: cfg, +// filterSChan: filterSChan, +// ers: &ers.ERService{}, +// rldChan: make(chan struct{}, 1), +// stopChan: make(chan struct{}, 1), +// connMgr: nil, +// cls: cls, +// srvDep: srvDep, +// } +// if !srv2.IsRunning() { +// t.Errorf("Expected service to be running") +// } +// serviceName := srv2.ServiceName() +// if !reflect.DeepEqual(serviceName, utils.ERs) { +// t.Errorf("\nExpecting <%+v>,\n Received <%+v>", utils.ERs, serviceName) +// } +// shouldRun := srv2.ShouldRun() +// if !reflect.DeepEqual(shouldRun, false) { +// t.Errorf("\nExpecting ,\n Received <%+v>", shouldRun) +// } +// srv2.Shutdown() +// if srv.IsRunning() { +// t.Errorf("Expected service to be down") +// } +// } diff --git a/services/freeswitchagent_it_test.go b/services/freeswitchagent_it_test.go index 65c5bc98f..3b95b0cba 100644 --- a/services/freeswitchagent_it_test.go +++ b/services/freeswitchagent_it_test.go @@ -20,173 +20,173 @@ along with this program. If not, see */ package services -import ( - "path" - "sync" - "testing" - "time" - - "github.com/cgrates/birpc" - "github.com/cgrates/birpc/context" - "github.com/cgrates/cgrates/agents" - "github.com/cgrates/cgrates/commonlisteners" - "github.com/cgrates/cgrates/config" - "github.com/cgrates/cgrates/engine" - "github.com/cgrates/cgrates/servmanager" - "github.com/cgrates/cgrates/utils" -) - -func TestFreeSwitchAgentReload(t *testing.T) { - cfg := config.NewDefaultCGRConfig() - - cfg.SessionSCfg().Enabled = true - cfg.SessionSCfg().ListenBijson = "" - filterSChan := make(chan *engine.FilterS, 1) - filterSChan <- nil - ctx, cancel := context.WithCancel(context.TODO()) - defer func() { - cancel() - time.Sleep(10 * time.Millisecond) - }() - shdWg := new(sync.WaitGroup) - - cls := commonlisteners.NewCommonListenerS(nil) - srvMngr := servmanager.NewServiceManager(shdWg, nil, cfg) - srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} - db := NewDataDBService(cfg, nil, false, srvDep) - anz := NewAnalyzerService(cfg, cls, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) - sS := NewSessionService(cfg, db, filterSChan, cls, make(chan birpc.ClientConnector, 1), - nil, anz, srvDep) - srv := NewFreeswitchAgent(cfg, nil, srvDep) - engine.NewConnManager(cfg) - srvMngr.AddServices(srv, sS, - NewLoaderService(cfg, db, filterSChan, cls, make(chan birpc.ClientConnector, 1), nil, anz, srvDep), db) - srvMngr.StartServices(ctx, cancel) - if srv.IsRunning() { - t.Fatalf("Expected service to be down") - } - var reply string - cfg.ConfigPath = path.Join("/usr", "share", "cgrates", "tutorial_tests", "fs_evsock", "cgrates", "etc", "cgrates") - if err := cfg.V1ReloadConfig(context.Background(), &config.ReloadArgs{ - Section: config.FreeSWITCHAgentJSON, - }, &reply); err != nil { - t.Fatal(err) - } else if reply != utils.OK { - t.Fatalf("Expecting OK ,received %s", reply) - } - - time.Sleep(10 * time.Millisecond) //need to switch to gorutine - // the engine should be stopped as we could not connect to freeswitch - -} - -func TestFreeSwitchAgentReload2(t *testing.T) { - cfg := config.NewDefaultCGRConfig() - - cfg.SessionSCfg().Enabled = true - cfg.SessionSCfg().ListenBijson = "" - filterSChan := make(chan *engine.FilterS, 1) - filterSChan <- nil - srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} - srv := NewFreeswitchAgent(cfg, nil, srvDep) - - if srv.IsRunning() { - t.Fatalf("Expected service to be down") - } - srv.(*FreeswitchAgent).fS = &agents.FSsessions{} - if !srv.IsRunning() { - t.Fatalf("Expected service to be running") - } - ctx, cancel := context.WithCancel(context.TODO()) - err := srv.Start(ctx, cancel) - if err == nil || err.Error() != "service already running" { - t.Fatalf("\nExpected <%+v>, \nReceived <%+v>", "service already running", err) - } - err = srv.Shutdown() - if err != nil { - t.Fatalf("\nExpected <%+v>, \nReceived <%+v>", nil, err) - } -} -func TestFreeSwitchAgentReload3(t *testing.T) { - cfg := config.NewDefaultCGRConfig() - - cfg.SessionSCfg().Enabled = true - cfg.SessionSCfg().ListenBijson = "" - filterSChan := make(chan *engine.FilterS, 1) - filterSChan <- nil - srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} - srv := NewFreeswitchAgent(cfg, nil, srvDep) - - if srv.IsRunning() { - t.Fatalf("Expected service to be down") - } - srv.(*FreeswitchAgent).fS = &agents.FSsessions{} - if !srv.IsRunning() { - t.Fatalf("Expected service to be running") - } - ctx, cancel := context.WithCancel(context.TODO()) - err := srv.Start(ctx, cancel) - if err == nil || err.Error() != "service already running" { - t.Fatalf("\nExpected <%+v>, \nReceived <%+v>", "service already running", err) - } - err = srv.Shutdown() - if err != nil { - t.Fatalf("\nExpected <%+v>, \nReceived <%+v>", nil, err) - } -} - -func TestFreeSwitchAgentReload4(t *testing.T) { - cfg := config.NewDefaultCGRConfig() - cfg.SessionSCfg().Enabled = true - filterSChan := make(chan *engine.FilterS, 1) - filterSChan <- nil - srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} - srv := NewFreeswitchAgent(cfg, nil, srvDep) - if srv.IsRunning() { - t.Fatalf("Expected service to be down") - } - - srv.(*FreeswitchAgent).fS = nil - ctx, cancel := context.WithCancel(context.TODO()) - err := srv.Start(ctx, cancel) - if err != nil { - t.Fatalf("\nExpected <%+v>, \nReceived <%+v>", nil, err) - } -} - -func TestFreeSwitchAgentReload6(t *testing.T) { - cfg := config.NewDefaultCGRConfig() - cfg.SessionSCfg().Enabled = true - filterSChan := make(chan *engine.FilterS, 1) - filterSChan <- nil - srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} - srv := NewFreeswitchAgent(cfg, nil, srvDep) - if srv.IsRunning() { - t.Fatalf("Expected service to be down") - } - agentCfg := &config.FsAgentCfg{ - Enabled: true, - SessionSConns: nil, - SubscribePark: true, - CreateCDR: true, - ExtraFields: nil, - LowBalanceAnnFile: "", - EmptyBalanceContext: "", - EmptyBalanceAnnFile: "", - MaxWaitConnection: 0, - EventSocketConns: []*config.FsConnCfg{ - { - Address: "", - Password: "", - Reconnects: 0, - Alias: "", - }, - }, - } - srv.(*FreeswitchAgent).fS = agents.NewFSsessions(agentCfg, "", nil) - ctx, cancel := context.WithCancel(context.TODO()) - err := srv.Reload(ctx, cancel) - if err != nil { - t.Fatalf("\nExpected <%+v>, \nReceived <%+v>", nil, err) - } -} +// import ( +// "path" +// "sync" +// "testing" +// "time" +// +// "github.com/cgrates/birpc" +// "github.com/cgrates/birpc/context" +// "github.com/cgrates/cgrates/agents" +// "github.com/cgrates/cgrates/commonlisteners" +// "github.com/cgrates/cgrates/config" +// "github.com/cgrates/cgrates/engine" +// "github.com/cgrates/cgrates/servmanager" +// "github.com/cgrates/cgrates/utils" +// ) +// +// func TestFreeSwitchAgentReload(t *testing.T) { +// cfg := config.NewDefaultCGRConfig() +// +// cfg.SessionSCfg().Enabled = true +// cfg.SessionSCfg().ListenBijson = "" +// filterSChan := make(chan *engine.FilterS, 1) +// filterSChan <- nil +// ctx, cancel := context.WithCancel(context.TODO()) +// defer func() { +// cancel() +// time.Sleep(10 * time.Millisecond) +// }() +// shdWg := new(sync.WaitGroup) +// +// cls := commonlisteners.NewCommonListenerS(nil) +// srvMngr := servmanager.NewServiceManager(shdWg, nil, cfg) +// srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} +// db := NewDataDBService(cfg, nil, false, srvDep) +// anz := NewAnalyzerService(cfg, cls, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) +// sS := NewSessionService(cfg, db, filterSChan, cls, make(chan birpc.ClientConnector, 1), +// nil, anz, srvDep) +// srv := NewFreeswitchAgent(cfg, nil, srvDep) +// engine.NewConnManager(cfg) +// srvMngr.AddServices(srv, sS, +// NewLoaderService(cfg, db, filterSChan, cls, make(chan birpc.ClientConnector, 1), nil, anz, srvDep), db) +// srvMngr.StartServices(ctx, cancel) +// if srv.IsRunning() { +// t.Fatalf("Expected service to be down") +// } +// var reply string +// cfg.ConfigPath = path.Join("/usr", "share", "cgrates", "tutorial_tests", "fs_evsock", "cgrates", "etc", "cgrates") +// if err := cfg.V1ReloadConfig(context.Background(), &config.ReloadArgs{ +// Section: config.FreeSWITCHAgentJSON, +// }, &reply); err != nil { +// t.Fatal(err) +// } else if reply != utils.OK { +// t.Fatalf("Expecting OK ,received %s", reply) +// } +// +// time.Sleep(10 * time.Millisecond) //need to switch to gorutine +// // the engine should be stopped as we could not connect to freeswitch +// +// } +// +// func TestFreeSwitchAgentReload2(t *testing.T) { +// cfg := config.NewDefaultCGRConfig() +// +// cfg.SessionSCfg().Enabled = true +// cfg.SessionSCfg().ListenBijson = "" +// filterSChan := make(chan *engine.FilterS, 1) +// filterSChan <- nil +// srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} +// srv := NewFreeswitchAgent(cfg, nil, srvDep) +// +// if srv.IsRunning() { +// t.Fatalf("Expected service to be down") +// } +// srv.(*FreeswitchAgent).fS = &agents.FSsessions{} +// if !srv.IsRunning() { +// t.Fatalf("Expected service to be running") +// } +// ctx, cancel := context.WithCancel(context.TODO()) +// err := srv.Start(ctx, cancel) +// if err == nil || err.Error() != "service already running" { +// t.Fatalf("\nExpected <%+v>, \nReceived <%+v>", "service already running", err) +// } +// err = srv.Shutdown() +// if err != nil { +// t.Fatalf("\nExpected <%+v>, \nReceived <%+v>", nil, err) +// } +// } +// func TestFreeSwitchAgentReload3(t *testing.T) { +// cfg := config.NewDefaultCGRConfig() +// +// cfg.SessionSCfg().Enabled = true +// cfg.SessionSCfg().ListenBijson = "" +// filterSChan := make(chan *engine.FilterS, 1) +// filterSChan <- nil +// srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} +// srv := NewFreeswitchAgent(cfg, nil, srvDep) +// +// if srv.IsRunning() { +// t.Fatalf("Expected service to be down") +// } +// srv.(*FreeswitchAgent).fS = &agents.FSsessions{} +// if !srv.IsRunning() { +// t.Fatalf("Expected service to be running") +// } +// ctx, cancel := context.WithCancel(context.TODO()) +// err := srv.Start(ctx, cancel) +// if err == nil || err.Error() != "service already running" { +// t.Fatalf("\nExpected <%+v>, \nReceived <%+v>", "service already running", err) +// } +// err = srv.Shutdown() +// if err != nil { +// t.Fatalf("\nExpected <%+v>, \nReceived <%+v>", nil, err) +// } +// } +// +// func TestFreeSwitchAgentReload4(t *testing.T) { +// cfg := config.NewDefaultCGRConfig() +// cfg.SessionSCfg().Enabled = true +// filterSChan := make(chan *engine.FilterS, 1) +// filterSChan <- nil +// srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} +// srv := NewFreeswitchAgent(cfg, nil, srvDep) +// if srv.IsRunning() { +// t.Fatalf("Expected service to be down") +// } +// +// srv.(*FreeswitchAgent).fS = nil +// ctx, cancel := context.WithCancel(context.TODO()) +// err := srv.Start(ctx, cancel) +// if err != nil { +// t.Fatalf("\nExpected <%+v>, \nReceived <%+v>", nil, err) +// } +// } +// +// func TestFreeSwitchAgentReload6(t *testing.T) { +// cfg := config.NewDefaultCGRConfig() +// cfg.SessionSCfg().Enabled = true +// filterSChan := make(chan *engine.FilterS, 1) +// filterSChan <- nil +// srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} +// srv := NewFreeswitchAgent(cfg, nil, srvDep) +// if srv.IsRunning() { +// t.Fatalf("Expected service to be down") +// } +// agentCfg := &config.FsAgentCfg{ +// Enabled: true, +// SessionSConns: nil, +// SubscribePark: true, +// CreateCDR: true, +// ExtraFields: nil, +// LowBalanceAnnFile: "", +// EmptyBalanceContext: "", +// EmptyBalanceAnnFile: "", +// MaxWaitConnection: 0, +// EventSocketConns: []*config.FsConnCfg{ +// { +// Address: "", +// Password: "", +// Reconnects: 0, +// Alias: "", +// }, +// }, +// } +// srv.(*FreeswitchAgent).fS = agents.NewFSsessions(agentCfg, "", nil) +// ctx, cancel := context.WithCancel(context.TODO()) +// err := srv.Reload(ctx, cancel) +// if err != nil { +// t.Fatalf("\nExpected <%+v>, \nReceived <%+v>", nil, err) +// } +// } diff --git a/services/freeswitchagent_test.go b/services/freeswitchagent_test.go index 6b0af3cb8..36c49e674 100644 --- a/services/freeswitchagent_test.go +++ b/services/freeswitchagent_test.go @@ -17,46 +17,46 @@ along with this program. If not, see */ package services -import ( - "reflect" - "sync" - "testing" - - "github.com/cgrates/cgrates/agents" - "github.com/cgrates/cgrates/config" - "github.com/cgrates/cgrates/engine" - "github.com/cgrates/cgrates/utils" -) - -// TestFreeSwitchAgentCoverage for cover testing -func TestFreeSwitchAgentCoverage(t *testing.T) { - cfg := config.NewDefaultCGRConfig() - cfg.SessionSCfg().Enabled = true - cfg.SessionSCfg().ListenBijson = "" - filterSChan := make(chan *engine.FilterS, 1) - filterSChan <- nil - srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} - - srv := NewFreeswitchAgent(cfg, nil, srvDep) - - if srv.IsRunning() { - t.Errorf("Expected service to be down") - } - srv2 := FreeswitchAgent{ - cfg: cfg, - fS: &agents.FSsessions{}, - connMgr: nil, - srvDep: srvDep, - } - if !srv2.IsRunning() { - t.Errorf("Expected service to be running") - } - serviceName := srv2.ServiceName() - if !reflect.DeepEqual(serviceName, utils.FreeSWITCHAgent) { - t.Errorf("\nExpecting <%+v>,\n Received <%+v>", utils.FreeSWITCHAgent, serviceName) - } - shouldRun := srv2.ShouldRun() - if !reflect.DeepEqual(shouldRun, false) { - t.Errorf("\nExpecting ,\n Received <%+v>", shouldRun) - } -} +// import ( +// "reflect" +// "sync" +// "testing" +// +// "github.com/cgrates/cgrates/agents" +// "github.com/cgrates/cgrates/config" +// "github.com/cgrates/cgrates/engine" +// "github.com/cgrates/cgrates/utils" +// ) +// +// // TestFreeSwitchAgentCoverage for cover testing +// func TestFreeSwitchAgentCoverage(t *testing.T) { +// cfg := config.NewDefaultCGRConfig() +// cfg.SessionSCfg().Enabled = true +// cfg.SessionSCfg().ListenBijson = "" +// filterSChan := make(chan *engine.FilterS, 1) +// filterSChan <- nil +// srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} +// +// srv := NewFreeswitchAgent(cfg, nil, srvDep) +// +// if srv.IsRunning() { +// t.Errorf("Expected service to be down") +// } +// srv2 := FreeswitchAgent{ +// cfg: cfg, +// fS: &agents.FSsessions{}, +// connMgr: nil, +// srvDep: srvDep, +// } +// if !srv2.IsRunning() { +// t.Errorf("Expected service to be running") +// } +// serviceName := srv2.ServiceName() +// if !reflect.DeepEqual(serviceName, utils.FreeSWITCHAgent) { +// t.Errorf("\nExpecting <%+v>,\n Received <%+v>", utils.FreeSWITCHAgent, serviceName) +// } +// shouldRun := srv2.ShouldRun() +// if !reflect.DeepEqual(shouldRun, false) { +// t.Errorf("\nExpecting ,\n Received <%+v>", shouldRun) +// } +// } diff --git a/services/globalvars_it_test.go b/services/globalvars_it_test.go index 1b8bcf586..3b134c0d9 100644 --- a/services/globalvars_it_test.go +++ b/services/globalvars_it_test.go @@ -20,44 +20,44 @@ along with this program. If not, see */ package services -import ( - "sync" - "testing" - - "github.com/cgrates/birpc/context" - "github.com/cgrates/cgrates/config" - "github.com/cgrates/cgrates/utils" -) - -func TestGlobalVarsReload(t *testing.T) { - cfg := config.NewDefaultCGRConfig() - srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} - srv := NewGlobalVarS(cfg, srvDep) - ctx, cancel := context.WithCancel(context.TODO()) - err := srv.Start(ctx, cancel) - if !srv.IsRunning() { - t.Errorf("Expected service to be running") - } - if err != nil { - t.Errorf("\nExpected , \nReceived <%+v>", err) - } - err = srv.Reload(ctx, cancel) - if err != nil { - t.Errorf("\nExpected , \nReceived <%+v>", err) - } - - err2 := srv.ServiceName() - if err2 != utils.GlobalVarS { - t.Errorf("\nExpected <%+v>, \nReceived <%+v>", utils.GlobalVarS, err2) - } - - err3 := srv.ShouldRun() - if err3 != true { - t.Errorf("\nExpected <%+v>, \nReceived <%+v>", true, err3) - } - err = srv.Shutdown() - if err != nil { - t.Errorf("\nExpected , \nReceived <%+v>", err) - } - -} +// import ( +// "sync" +// "testing" +// +// "github.com/cgrates/birpc/context" +// "github.com/cgrates/cgrates/config" +// "github.com/cgrates/cgrates/utils" +// ) +// +// func TestGlobalVarsReload(t *testing.T) { +// cfg := config.NewDefaultCGRConfig() +// srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} +// srv := NewGlobalVarS(cfg, srvDep) +// ctx, cancel := context.WithCancel(context.TODO()) +// err := srv.Start(ctx, cancel) +// if !srv.IsRunning() { +// t.Errorf("Expected service to be running") +// } +// if err != nil { +// t.Errorf("\nExpected , \nReceived <%+v>", err) +// } +// err = srv.Reload(ctx, cancel) +// if err != nil { +// t.Errorf("\nExpected , \nReceived <%+v>", err) +// } +// +// err2 := srv.ServiceName() +// if err2 != utils.GlobalVarS { +// t.Errorf("\nExpected <%+v>, \nReceived <%+v>", utils.GlobalVarS, err2) +// } +// +// err3 := srv.ShouldRun() +// if err3 != true { +// t.Errorf("\nExpected <%+v>, \nReceived <%+v>", true, err3) +// } +// err = srv.Shutdown() +// if err != nil { +// t.Errorf("\nExpected , \nReceived <%+v>", err) +// } +// +// } diff --git a/services/httpagent_it_test.go b/services/httpagent_it_test.go index ae1e2312c..ccfb1789d 100644 --- a/services/httpagent_it_test.go +++ b/services/httpagent_it_test.go @@ -20,78 +20,78 @@ along with this program. If not, see */ package services -import ( - "path" - "runtime" - "sync" - "testing" - "time" - - "github.com/cgrates/birpc" - "github.com/cgrates/birpc/context" - "github.com/cgrates/cgrates/commonlisteners" - "github.com/cgrates/cgrates/config" - "github.com/cgrates/cgrates/engine" - "github.com/cgrates/cgrates/servmanager" - "github.com/cgrates/cgrates/utils" -) - -func TestHTTPAgentReload(t *testing.T) { - cfg := config.NewDefaultCGRConfig() - cfg.SessionSCfg().Enabled = true - cfg.SessionSCfg().ListenBijson = "" - filterSChan := make(chan *engine.FilterS, 1) - filterSChan <- nil - ctx, cancel := context.WithCancel(context.TODO()) - defer func() { - cancel() - time.Sleep(10 * time.Millisecond) - }() - shdWg := new(sync.WaitGroup) - cls := commonlisteners.NewCommonListenerS(nil) - srvMngr := servmanager.NewServiceManager(shdWg, nil, cfg) - srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} - db := NewDataDBService(cfg, nil, false, srvDep) - anz := NewAnalyzerService(cfg, cls, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) - sS := NewSessionService(cfg, db, filterSChan, cls, make(chan birpc.ClientConnector, 1), - nil, anz, srvDep) - srv := NewHTTPAgent(cfg, filterSChan, cls, nil, srvDep) - engine.NewConnManager(cfg) - srvMngr.AddServices(srv, sS, - NewLoaderService(cfg, db, filterSChan, cls, make(chan birpc.ClientConnector, 1), nil, anz, srvDep), db) - srvMngr.StartServices(ctx, cancel) - if srv.IsRunning() { - t.Fatalf("Expected service to be down") - } - var reply string - cfg.ConfigPath = path.Join("/usr", "share", "cgrates", "conf", "samples", "httpagent_mysql_test") - if err := cfg.V1ReloadConfig(context.Background(), &config.ReloadArgs{ - Section: config.HTTPAgentJSON, - }, &reply); err != nil { - t.Fatal(err) - } else if reply != utils.OK { - t.Fatalf("Expecting OK ,received %s", reply) - } - time.Sleep(10 * time.Millisecond) //need to switch to gorutine - runtime.Gosched() - runtime.Gosched() - if !srv.IsRunning() { - t.Fatalf("Expected service to be running") - } - srvReload := srv.Reload(ctx, cancel) - if srvReload != nil { - t.Fatalf("\nExpecting ,\n Received <%+v>", srvReload) - } - runtime.Gosched() - err := srv.Start(ctx, cancel) - if err != utils.ErrServiceAlreadyRunning { - t.Fatalf("\nExpecting <%+v>,\n Received <%+v>", utils.ErrServiceAlreadyRunning, err) - } - err = srv.Shutdown() - if err != nil { - t.Fatalf("\nExpecting <%+v>,\n Received <%+v>", nil, err) - } - if srv.IsRunning() { - t.Fatalf("Expected service to be down") - } -} +// import ( +// "path" +// "runtime" +// "sync" +// "testing" +// "time" +// +// "github.com/cgrates/birpc" +// "github.com/cgrates/birpc/context" +// "github.com/cgrates/cgrates/commonlisteners" +// "github.com/cgrates/cgrates/config" +// "github.com/cgrates/cgrates/engine" +// "github.com/cgrates/cgrates/servmanager" +// "github.com/cgrates/cgrates/utils" +// ) +// +// func TestHTTPAgentReload(t *testing.T) { +// cfg := config.NewDefaultCGRConfig() +// cfg.SessionSCfg().Enabled = true +// cfg.SessionSCfg().ListenBijson = "" +// filterSChan := make(chan *engine.FilterS, 1) +// filterSChan <- nil +// ctx, cancel := context.WithCancel(context.TODO()) +// defer func() { +// cancel() +// time.Sleep(10 * time.Millisecond) +// }() +// shdWg := new(sync.WaitGroup) +// cls := commonlisteners.NewCommonListenerS(nil) +// srvMngr := servmanager.NewServiceManager(shdWg, nil, cfg) +// srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} +// db := NewDataDBService(cfg, nil, false, srvDep) +// anz := NewAnalyzerService(cfg, cls, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) +// sS := NewSessionService(cfg, db, filterSChan, cls, make(chan birpc.ClientConnector, 1), +// nil, anz, srvDep) +// srv := NewHTTPAgent(cfg, filterSChan, cls, nil, srvDep) +// engine.NewConnManager(cfg) +// srvMngr.AddServices(srv, sS, +// NewLoaderService(cfg, db, filterSChan, cls, make(chan birpc.ClientConnector, 1), nil, anz, srvDep), db) +// srvMngr.StartServices(ctx, cancel) +// if srv.IsRunning() { +// t.Fatalf("Expected service to be down") +// } +// var reply string +// cfg.ConfigPath = path.Join("/usr", "share", "cgrates", "conf", "samples", "httpagent_mysql_test") +// if err := cfg.V1ReloadConfig(context.Background(), &config.ReloadArgs{ +// Section: config.HTTPAgentJSON, +// }, &reply); err != nil { +// t.Fatal(err) +// } else if reply != utils.OK { +// t.Fatalf("Expecting OK ,received %s", reply) +// } +// time.Sleep(10 * time.Millisecond) //need to switch to gorutine +// runtime.Gosched() +// runtime.Gosched() +// if !srv.IsRunning() { +// t.Fatalf("Expected service to be running") +// } +// srvReload := srv.Reload(ctx, cancel) +// if srvReload != nil { +// t.Fatalf("\nExpecting ,\n Received <%+v>", srvReload) +// } +// runtime.Gosched() +// err := srv.Start(ctx, cancel) +// if err != utils.ErrServiceAlreadyRunning { +// t.Fatalf("\nExpecting <%+v>,\n Received <%+v>", utils.ErrServiceAlreadyRunning, err) +// } +// err = srv.Shutdown() +// if err != nil { +// t.Fatalf("\nExpecting <%+v>,\n Received <%+v>", nil, err) +// } +// if srv.IsRunning() { +// t.Fatalf("Expected service to be down") +// } +// } diff --git a/services/httpagent_test.go b/services/httpagent_test.go index dacc1794f..d3149dd7b 100644 --- a/services/httpagent_test.go +++ b/services/httpagent_test.go @@ -17,56 +17,56 @@ along with this program. If not, see */ package services -import ( - "reflect" - "sync" - "testing" - - "github.com/cgrates/cgrates/commonlisteners" - "github.com/cgrates/cgrates/config" - "github.com/cgrates/cgrates/engine" - "github.com/cgrates/cgrates/utils" -) - -// TestHTTPAgent for cover testing -func TestHTTPAgentCoverage(t *testing.T) { - cfg := config.NewDefaultCGRConfig() - cls := commonlisteners.NewCommonListenerS(nil) - filterSChan := make(chan *engine.FilterS, 1) - filterSChan <- nil - srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} - cM := engine.NewConnManager(cfg) - srv := NewHTTPAgent(cfg, filterSChan, cls, cM, srvDep) - if srv == nil { - t.Errorf("\nExpecting ,\n Received <%+v>", utils.ToJSON(srv)) - } - if srv.IsRunning() { - t.Errorf("Expected service to be down") - } - srv2 := &HTTPAgent{ - cfg: cfg, - filterSChan: filterSChan, - cls: cls, - started: true, - connMgr: cM, - srvDep: srvDep, - } - if !srv2.IsRunning() { - t.Errorf("Expected service to be running") - } - serviceName := srv2.ServiceName() - if !reflect.DeepEqual(serviceName, utils.HTTPAgent) { - t.Errorf("\nExpecting <%+v>,\n Received <%+v>", utils.HTTPAgent, serviceName) - } - shouldRun := srv2.ShouldRun() - if !reflect.DeepEqual(shouldRun, false) { - t.Errorf("\nExpecting ,\n Received <%+v>", shouldRun) - } - shutdownError := srv.Shutdown() - if shutdownError != nil { - t.Errorf("\nExpecting ,\n Received <%+v>", shutdownError) - } - if srv.IsRunning() { - t.Errorf("Expected service to be down") - } -} +// import ( +// "reflect" +// "sync" +// "testing" +// +// "github.com/cgrates/cgrates/commonlisteners" +// "github.com/cgrates/cgrates/config" +// "github.com/cgrates/cgrates/engine" +// "github.com/cgrates/cgrates/utils" +// ) +// +// // TestHTTPAgent for cover testing +// func TestHTTPAgentCoverage(t *testing.T) { +// cfg := config.NewDefaultCGRConfig() +// cls := commonlisteners.NewCommonListenerS(nil) +// filterSChan := make(chan *engine.FilterS, 1) +// filterSChan <- nil +// srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} +// cM := engine.NewConnManager(cfg) +// srv := NewHTTPAgent(cfg, filterSChan, cls, cM, srvDep) +// if srv == nil { +// t.Errorf("\nExpecting ,\n Received <%+v>", utils.ToJSON(srv)) +// } +// if srv.IsRunning() { +// t.Errorf("Expected service to be down") +// } +// srv2 := &HTTPAgent{ +// cfg: cfg, +// filterSChan: filterSChan, +// cls: cls, +// started: true, +// connMgr: cM, +// srvDep: srvDep, +// } +// if !srv2.IsRunning() { +// t.Errorf("Expected service to be running") +// } +// serviceName := srv2.ServiceName() +// if !reflect.DeepEqual(serviceName, utils.HTTPAgent) { +// t.Errorf("\nExpecting <%+v>,\n Received <%+v>", utils.HTTPAgent, serviceName) +// } +// shouldRun := srv2.ShouldRun() +// if !reflect.DeepEqual(shouldRun, false) { +// t.Errorf("\nExpecting ,\n Received <%+v>", shouldRun) +// } +// shutdownError := srv.Shutdown() +// if shutdownError != nil { +// t.Errorf("\nExpecting ,\n Received <%+v>", shutdownError) +// } +// if srv.IsRunning() { +// t.Errorf("Expected service to be down") +// } +// } diff --git a/services/kamailioagent_it_test.go b/services/kamailioagent_it_test.go index 69b7d5b41..dbf769a27 100644 --- a/services/kamailioagent_it_test.go +++ b/services/kamailioagent_it_test.go @@ -20,125 +20,125 @@ along with this program. If not, see */ package services -import ( - "path" - "runtime" - "sync" - "testing" - "time" - - "github.com/cgrates/birpc" - "github.com/cgrates/birpc/context" - "github.com/cgrates/cgrates/agents" - "github.com/cgrates/cgrates/commonlisteners" - - "github.com/cgrates/cgrates/config" - "github.com/cgrates/cgrates/engine" - "github.com/cgrates/cgrates/servmanager" - "github.com/cgrates/cgrates/utils" -) - -func TestKamailioAgentReload(t *testing.T) { - cfg := config.NewDefaultCGRConfig() - - cfg.SessionSCfg().Enabled = true - cfg.SessionSCfg().ListenBijson = "" - filterSChan := make(chan *engine.FilterS, 1) - filterSChan <- nil - shdWg := new(sync.WaitGroup) - - cls := commonlisteners.NewCommonListenerS(nil) - srvMngr := servmanager.NewServiceManager(shdWg, nil, cfg) - srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} - db := NewDataDBService(cfg, nil, false, srvDep) - anz := NewAnalyzerService(cfg, cls, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) - sS := NewSessionService(cfg, db, filterSChan, cls, make(chan birpc.ClientConnector, 1), - nil, anz, srvDep) - srv := NewKamailioAgent(cfg, nil, srvDep) - engine.NewConnManager(cfg) - srvMngr.AddServices(srv, sS, - NewLoaderService(cfg, db, filterSChan, cls, make(chan birpc.ClientConnector, 1), nil, anz, srvDep), db) - ctx, cancel := context.WithCancel(context.TODO()) - srvMngr.StartServices(ctx, cancel) - - if srv.IsRunning() { - t.Fatalf("Expected service to be down") - } - var reply string - cfg.ConfigPath = path.Join("/usr", "share", "cgrates", "tutorial_tests", "kamevapi", "cgrates", "etc", "cgrates") - if err := cfg.V1ReloadConfig(context.Background(), &config.ReloadArgs{ - Section: config.KamailioAgentJSON, - }, &reply); err != nil { - t.Fatal(err) - } else if reply != utils.OK { - t.Fatalf("Expecting OK ,received %s", reply) - } - - runtime.Gosched() - time.Sleep(10 * time.Millisecond) - kaCfg := &config.KamAgentCfg{ - Enabled: true, - SessionSConns: []string{utils.ConcatenatedKey(utils.MetaInternal, utils.MetaSessionS)}, - CreateCdr: true, - EvapiConns: []*config.KamConnCfg{{Address: "127.0.0.1:8448", Reconnects: 10, Alias: "randomAlias"}}, - Timezone: "Local", - } - - srv.(*KamailioAgent).kam = agents.NewKamailioAgent(kaCfg, nil, "") - - err := srv.Reload(ctx, cancel) - if err != nil { - t.Fatalf("\nExpected <%+v>, \nReceived <%+v>", nil, err) - } - time.Sleep(10 * time.Millisecond) //need to switch to gorutine - // the engine should be stopped as we could not connect to kamailio - - cancel() - time.Sleep(10 * time.Millisecond) -} - -func TestKamailioAgentReload2(t *testing.T) { - cfg := config.NewDefaultCGRConfig() - cfg.SessionSCfg().Enabled = true - cfg.SessionSCfg().ListenBijson = "" - filterSChan := make(chan *engine.FilterS, 1) - filterSChan <- nil - srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} - srv := NewKamailioAgent(cfg, nil, srvDep) - srvKam := &agents.KamailioAgent{} - if srv.IsRunning() { - t.Fatalf("Expected service to be down") - } - srv.(*KamailioAgent).kam = srvKam - if !srv.IsRunning() { - t.Fatalf("Expected service to be running") - } - ctx, cancel := context.WithCancel(context.TODO()) - err := srv.Start(ctx, cancel) - if err == nil || err.Error() != "service already running" { - t.Fatalf("\nExpected <%+v>, \nReceived <%+v>", "service already running", err) - } -} - -func TestKamailioAgentReload3(t *testing.T) { - cfg := config.NewDefaultCGRConfig() - cfg.SessionSCfg().Enabled = true - cfg.SessionSCfg().ListenBijson = "" - filterSChan := make(chan *engine.FilterS, 1) - filterSChan <- nil - srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} - srv := NewKamailioAgent(cfg, nil, srvDep) - srvKam := &agents.KamailioAgent{} - if srv.IsRunning() { - t.Fatalf("Expected service to be down") - } - srv.(*KamailioAgent).kam = srvKam - if !srv.IsRunning() { - t.Fatalf("Expected service to be running") - } - ctx, cancel := context.WithCancel(context.TODO()) - err := srv.Start(ctx, cancel) - if err == nil || err.Error() != "service already running" { - t.Fatalf("\nExpected <%+v>, \nReceived <%+v>", "service already running", err) - } -} +// import ( +// "path" +// "runtime" +// "sync" +// "testing" +// "time" +// +// "github.com/cgrates/birpc" +// "github.com/cgrates/birpc/context" +// "github.com/cgrates/cgrates/agents" +// "github.com/cgrates/cgrates/commonlisteners" +// +// "github.com/cgrates/cgrates/config" +// "github.com/cgrates/cgrates/engine" +// "github.com/cgrates/cgrates/servmanager" +// "github.com/cgrates/cgrates/utils" +// ) +// +// func TestKamailioAgentReload(t *testing.T) { +// cfg := config.NewDefaultCGRConfig() +// +// cfg.SessionSCfg().Enabled = true +// cfg.SessionSCfg().ListenBijson = "" +// filterSChan := make(chan *engine.FilterS, 1) +// filterSChan <- nil +// shdWg := new(sync.WaitGroup) +// +// cls := commonlisteners.NewCommonListenerS(nil) +// srvMngr := servmanager.NewServiceManager(shdWg, nil, cfg) +// srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} +// db := NewDataDBService(cfg, nil, false, srvDep) +// anz := NewAnalyzerService(cfg, cls, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) +// sS := NewSessionService(cfg, db, filterSChan, cls, make(chan birpc.ClientConnector, 1), +// nil, anz, srvDep) +// srv := NewKamailioAgent(cfg, nil, srvDep) +// engine.NewConnManager(cfg) +// srvMngr.AddServices(srv, sS, +// NewLoaderService(cfg, db, filterSChan, cls, make(chan birpc.ClientConnector, 1), nil, anz, srvDep), db) +// ctx, cancel := context.WithCancel(context.TODO()) +// srvMngr.StartServices(ctx, cancel) +// +// if srv.IsRunning() { +// t.Fatalf("Expected service to be down") +// } +// var reply string +// cfg.ConfigPath = path.Join("/usr", "share", "cgrates", "tutorial_tests", "kamevapi", "cgrates", "etc", "cgrates") +// if err := cfg.V1ReloadConfig(context.Background(), &config.ReloadArgs{ +// Section: config.KamailioAgentJSON, +// }, &reply); err != nil { +// t.Fatal(err) +// } else if reply != utils.OK { +// t.Fatalf("Expecting OK ,received %s", reply) +// } +// +// runtime.Gosched() +// time.Sleep(10 * time.Millisecond) +// kaCfg := &config.KamAgentCfg{ +// Enabled: true, +// SessionSConns: []string{utils.ConcatenatedKey(utils.MetaInternal, utils.MetaSessionS)}, +// CreateCdr: true, +// EvapiConns: []*config.KamConnCfg{{Address: "127.0.0.1:8448", Reconnects: 10, Alias: "randomAlias"}}, +// Timezone: "Local", +// } +// +// srv.(*KamailioAgent).kam = agents.NewKamailioAgent(kaCfg, nil, "") +// +// err := srv.Reload(ctx, cancel) +// if err != nil { +// t.Fatalf("\nExpected <%+v>, \nReceived <%+v>", nil, err) +// } +// time.Sleep(10 * time.Millisecond) //need to switch to gorutine +// // the engine should be stopped as we could not connect to kamailio +// +// cancel() +// time.Sleep(10 * time.Millisecond) +// } +// +// func TestKamailioAgentReload2(t *testing.T) { +// cfg := config.NewDefaultCGRConfig() +// cfg.SessionSCfg().Enabled = true +// cfg.SessionSCfg().ListenBijson = "" +// filterSChan := make(chan *engine.FilterS, 1) +// filterSChan <- nil +// srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} +// srv := NewKamailioAgent(cfg, nil, srvDep) +// srvKam := &agents.KamailioAgent{} +// if srv.IsRunning() { +// t.Fatalf("Expected service to be down") +// } +// srv.(*KamailioAgent).kam = srvKam +// if !srv.IsRunning() { +// t.Fatalf("Expected service to be running") +// } +// ctx, cancel := context.WithCancel(context.TODO()) +// err := srv.Start(ctx, cancel) +// if err == nil || err.Error() != "service already running" { +// t.Fatalf("\nExpected <%+v>, \nReceived <%+v>", "service already running", err) +// } +// } +// +// func TestKamailioAgentReload3(t *testing.T) { +// cfg := config.NewDefaultCGRConfig() +// cfg.SessionSCfg().Enabled = true +// cfg.SessionSCfg().ListenBijson = "" +// filterSChan := make(chan *engine.FilterS, 1) +// filterSChan <- nil +// srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} +// srv := NewKamailioAgent(cfg, nil, srvDep) +// srvKam := &agents.KamailioAgent{} +// if srv.IsRunning() { +// t.Fatalf("Expected service to be down") +// } +// srv.(*KamailioAgent).kam = srvKam +// if !srv.IsRunning() { +// t.Fatalf("Expected service to be running") +// } +// ctx, cancel := context.WithCancel(context.TODO()) +// err := srv.Start(ctx, cancel) +// if err == nil || err.Error() != "service already running" { +// t.Fatalf("\nExpected <%+v>, \nReceived <%+v>", "service already running", err) +// } +// } diff --git a/services/kamailioagent_test.go b/services/kamailioagent_test.go index abc99a6bf..bec0d916e 100644 --- a/services/kamailioagent_test.go +++ b/services/kamailioagent_test.go @@ -17,50 +17,50 @@ along with this program. If not, see */ package services -import ( - "reflect" - "sync" - "testing" - - "github.com/cgrates/cgrates/agents" - "github.com/cgrates/cgrates/config" - "github.com/cgrates/cgrates/engine" - "github.com/cgrates/cgrates/utils" -) - -//TestKamailioAgentCoverage for cover testing - -func TestKamailioAgentCoverage(t *testing.T) { - cfg := config.NewDefaultCGRConfig() - - cfg.SessionSCfg().Enabled = true - cfg.SessionSCfg().ListenBijson = "" - filterSChan := make(chan *engine.FilterS, 1) - filterSChan <- nil - srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} - srv := NewKamailioAgent(cfg, nil, srvDep) - if srv.IsRunning() { - t.Errorf("Expected service to be down") - } - srv2 := KamailioAgent{ - cfg: cfg, - kam: &agents.KamailioAgent{}, - connMgr: nil, - srvDep: srvDep, - } - if !srv2.IsRunning() { - t.Errorf("Expected service to be down") - } - serviceName := srv2.ServiceName() - if !reflect.DeepEqual(serviceName, utils.KamailioAgent) { - t.Errorf("\nExpecting <%+v>,\n Received <%+v>", utils.KamailioAgent, serviceName) - } - shouldRun := srv2.ShouldRun() - if !reflect.DeepEqual(shouldRun, false) { - t.Errorf("\nExpecting ,\n Received <%+v>", shouldRun) - } - srv2.Shutdown() - if srv2.IsRunning() { - t.Errorf("Expected service to be down") - } -} +// import ( +// "reflect" +// "sync" +// "testing" +// +// "github.com/cgrates/cgrates/agents" +// "github.com/cgrates/cgrates/config" +// "github.com/cgrates/cgrates/engine" +// "github.com/cgrates/cgrates/utils" +// ) +// +// //TestKamailioAgentCoverage for cover testing +// +// func TestKamailioAgentCoverage(t *testing.T) { +// cfg := config.NewDefaultCGRConfig() +// +// cfg.SessionSCfg().Enabled = true +// cfg.SessionSCfg().ListenBijson = "" +// filterSChan := make(chan *engine.FilterS, 1) +// filterSChan <- nil +// srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} +// srv := NewKamailioAgent(cfg, nil, srvDep) +// if srv.IsRunning() { +// t.Errorf("Expected service to be down") +// } +// srv2 := KamailioAgent{ +// cfg: cfg, +// kam: &agents.KamailioAgent{}, +// connMgr: nil, +// srvDep: srvDep, +// } +// if !srv2.IsRunning() { +// t.Errorf("Expected service to be down") +// } +// serviceName := srv2.ServiceName() +// if !reflect.DeepEqual(serviceName, utils.KamailioAgent) { +// t.Errorf("\nExpecting <%+v>,\n Received <%+v>", utils.KamailioAgent, serviceName) +// } +// shouldRun := srv2.ShouldRun() +// if !reflect.DeepEqual(shouldRun, false) { +// t.Errorf("\nExpecting ,\n Received <%+v>", shouldRun) +// } +// srv2.Shutdown() +// if srv2.IsRunning() { +// t.Errorf("Expected service to be down") +// } +// } diff --git a/services/libcgr-engine_test.go b/services/libcgr-engine_test.go index 08be953d8..73d34f777 100644 --- a/services/libcgr-engine_test.go +++ b/services/libcgr-engine_test.go @@ -18,151 +18,151 @@ along with this program. If not, see package services -import ( - "path" - "reflect" - "testing" - "time" -) - -// If any flag changes, this test should fail. -// Do not use constants in this test to ensure these changes are detected. -func TestCgrEngineFlags(t *testing.T) { - ngFlags := NewCGREngineFlags() - tests := []struct { - name string - flags []string - flagVar any - defaultVal any - want any - }{ - { - name: "cfgPath", - flags: []string{"-config_path", path.Join("/usr", "share", "cgrates", "conf", "samples", "tutorial")}, - flagVar: ngFlags.CfgPath, - defaultVal: "/etc/cgrates/", - want: "/usr/share/cgrates/conf/samples/tutorial", - }, - { - name: "version", - flags: []string{"-version"}, - flagVar: ngFlags.Version, - defaultVal: false, - want: true, - }, - { - name: "pidFile", - flags: []string{"-pid", "/run/cgrates/cgrates.pid"}, - flagVar: ngFlags.PidFile, - defaultVal: "", - want: "/run/cgrates/cgrates.pid", - }, - { - name: "cpuProfDir", - flags: []string{"-cpuprof_dir", "/tmp/profiling"}, - flagVar: ngFlags.CpuPrfDir, - defaultVal: "", - want: "/tmp/profiling", - }, - { - name: "memProfDir", - flags: []string{"-memprof_dir", "/tmp/profiling"}, - flagVar: ngFlags.MemPrfDir, - defaultVal: "", - want: "/tmp/profiling", - }, - { - name: "memProfInterval", - flags: []string{"-memprof_interval", "1s"}, - flagVar: ngFlags.MemPrfInterval, - defaultVal: 15 * time.Second, - want: time.Second, - }, - { - name: "memProfMaxFiles", - flags: []string{"-memprof_maxfiles", "3"}, - flagVar: ngFlags.MemPrfMaxF, - defaultVal: 1, - want: 3, - }, - { - name: "memProfTimestamp", - flags: []string{"-memprof_timestamp"}, - flagVar: ngFlags.MemPrfTS, - defaultVal: false, - want: true, - }, - { - name: "scheduledShutdown", - flags: []string{"-scheduled_shutdown", "1h"}, - flagVar: ngFlags.ScheduledShutdown, - defaultVal: "", - want: "1h", - }, - { - name: "singleCPU", - flags: []string{"-single_cpu"}, - flagVar: ngFlags.SingleCPU, - defaultVal: false, - want: true, - }, - { - name: "syslogger", - flags: []string{"-logger", "*stdout"}, - flagVar: ngFlags.Logger, - defaultVal: "", - want: "*stdout", - }, - { - name: "nodeID", - flags: []string{"-node_id", "CGRateS.org"}, - flagVar: ngFlags.NodeID, - defaultVal: "", - want: "CGRateS.org", - }, - { - name: "logLevel", - flags: []string{"-log_level", "7"}, - flagVar: ngFlags.LogLevel, - defaultVal: -1, - want: 7, - }, - { - name: "preload", - flags: []string{"-preload", "TestPreloadID"}, - flagVar: ngFlags.Preload, - defaultVal: "", - want: "TestPreloadID", - }, - { - name: "check_config", - flags: []string{"-check_config", "true"}, - flagVar: ngFlags.CheckConfig, - defaultVal: false, - want: true, - }, - { - name: "setVersions", - flags: []string{"-set_versions"}, - flagVar: ngFlags.SetVersions, - defaultVal: false, - want: true, - }, - } - - for _, tt := range tests { - t.Run(tt.name, func(t *testing.T) { - flagVal := reflect.ValueOf(tt.flagVar).Elem().Interface() - if flagVal != tt.defaultVal { - t.Errorf("%s=%v, want default value %v", tt.name, flagVal, tt.defaultVal) - } - if err := ngFlags.Parse(tt.flags); err != nil { - t.Errorf("cgrEngineFlags.Parse(%v) returned unexpected error: %v", tt.flags, err) - } - flagVal = reflect.ValueOf(tt.flagVar).Elem().Interface() - if flagVal != tt.want { - t.Errorf("%s=%v, want %v", tt.name, flagVal, tt.want) - } - }) - } -} +// import ( +// "path" +// "reflect" +// "testing" +// "time" +// ) +// +// // If any flag changes, this test should fail. +// // Do not use constants in this test to ensure these changes are detected. +// func TestCgrEngineFlags(t *testing.T) { +// ngFlags := NewCGREngineFlags() +// tests := []struct { +// name string +// flags []string +// flagVar any +// defaultVal any +// want any +// }{ +// { +// name: "cfgPath", +// flags: []string{"-config_path", path.Join("/usr", "share", "cgrates", "conf", "samples", "tutorial")}, +// flagVar: ngFlags.CfgPath, +// defaultVal: "/etc/cgrates/", +// want: "/usr/share/cgrates/conf/samples/tutorial", +// }, +// { +// name: "version", +// flags: []string{"-version"}, +// flagVar: ngFlags.Version, +// defaultVal: false, +// want: true, +// }, +// { +// name: "pidFile", +// flags: []string{"-pid", "/run/cgrates/cgrates.pid"}, +// flagVar: ngFlags.PidFile, +// defaultVal: "", +// want: "/run/cgrates/cgrates.pid", +// }, +// { +// name: "cpuProfDir", +// flags: []string{"-cpuprof_dir", "/tmp/profiling"}, +// flagVar: ngFlags.CpuPrfDir, +// defaultVal: "", +// want: "/tmp/profiling", +// }, +// { +// name: "memProfDir", +// flags: []string{"-memprof_dir", "/tmp/profiling"}, +// flagVar: ngFlags.MemPrfDir, +// defaultVal: "", +// want: "/tmp/profiling", +// }, +// { +// name: "memProfInterval", +// flags: []string{"-memprof_interval", "1s"}, +// flagVar: ngFlags.MemPrfInterval, +// defaultVal: 15 * time.Second, +// want: time.Second, +// }, +// { +// name: "memProfMaxFiles", +// flags: []string{"-memprof_maxfiles", "3"}, +// flagVar: ngFlags.MemPrfMaxF, +// defaultVal: 1, +// want: 3, +// }, +// { +// name: "memProfTimestamp", +// flags: []string{"-memprof_timestamp"}, +// flagVar: ngFlags.MemPrfTS, +// defaultVal: false, +// want: true, +// }, +// { +// name: "scheduledShutdown", +// flags: []string{"-scheduled_shutdown", "1h"}, +// flagVar: ngFlags.ScheduledShutdown, +// defaultVal: "", +// want: "1h", +// }, +// { +// name: "singleCPU", +// flags: []string{"-single_cpu"}, +// flagVar: ngFlags.SingleCPU, +// defaultVal: false, +// want: true, +// }, +// { +// name: "syslogger", +// flags: []string{"-logger", "*stdout"}, +// flagVar: ngFlags.Logger, +// defaultVal: "", +// want: "*stdout", +// }, +// { +// name: "nodeID", +// flags: []string{"-node_id", "CGRateS.org"}, +// flagVar: ngFlags.NodeID, +// defaultVal: "", +// want: "CGRateS.org", +// }, +// { +// name: "logLevel", +// flags: []string{"-log_level", "7"}, +// flagVar: ngFlags.LogLevel, +// defaultVal: -1, +// want: 7, +// }, +// { +// name: "preload", +// flags: []string{"-preload", "TestPreloadID"}, +// flagVar: ngFlags.Preload, +// defaultVal: "", +// want: "TestPreloadID", +// }, +// { +// name: "check_config", +// flags: []string{"-check_config", "true"}, +// flagVar: ngFlags.CheckConfig, +// defaultVal: false, +// want: true, +// }, +// { +// name: "setVersions", +// flags: []string{"-set_versions"}, +// flagVar: ngFlags.SetVersions, +// defaultVal: false, +// want: true, +// }, +// } +// +// for _, tt := range tests { +// t.Run(tt.name, func(t *testing.T) { +// flagVal := reflect.ValueOf(tt.flagVar).Elem().Interface() +// if flagVal != tt.defaultVal { +// t.Errorf("%s=%v, want default value %v", tt.name, flagVal, tt.defaultVal) +// } +// if err := ngFlags.Parse(tt.flags); err != nil { +// t.Errorf("cgrEngineFlags.Parse(%v) returned unexpected error: %v", tt.flags, err) +// } +// flagVal = reflect.ValueOf(tt.flagVar).Elem().Interface() +// if flagVal != tt.want { +// t.Errorf("%s=%v, want %v", tt.name, flagVal, tt.want) +// } +// }) +// } +// } diff --git a/services/loaders_it_test.go b/services/loaders_it_test.go index 7391464b6..2255025d3 100644 --- a/services/loaders_it_test.go +++ b/services/loaders_it_test.go @@ -20,176 +20,176 @@ along with this program. If not, see */ package services -import ( - "os" - "path" - "sync" - "testing" - "time" - - "github.com/cgrates/birpc" - "github.com/cgrates/birpc/context" - "github.com/cgrates/cgrates/commonlisteners" - "github.com/cgrates/cgrates/config" - "github.com/cgrates/cgrates/engine" - "github.com/cgrates/cgrates/servmanager" - "github.com/cgrates/cgrates/utils" -) - -func testCreateDirs(t *testing.T) { - for _, dir := range []string{"/tmp/In", "/tmp/Out", "/tmp/LoaderIn", "/tmp/SubpathWithoutMove", - "/tmp/SubpathLoaderWithMove", "/tmp/SubpathOut", "/tmp/templateLoaderIn", "/tmp/templateLoaderOut", - "/tmp/customSepLoaderIn", "/tmp/customSepLoaderOut"} { - if err := os.RemoveAll(dir); err != nil { - t.Fatal("Error removing folder: ", dir, err) - } - if err := os.MkdirAll(dir, 0755); err != nil { - t.Fatal("Error creating folder: ", dir, err) - } - } - if err := os.WriteFile(path.Join("/tmp/In", utils.AttributesCsv), []byte(` -#Tenant,ID,FilterIDs,Weights,Blockers,AttributeFilterIDs,AttributeBlockers,Path,Type,Value -cgrates.org,ALS1,*string:~*req.Account:1001;*string:~*opts.*context:con1,;20,;true,*string:~*req.Field1:Initial,;true,*req.Field1,*variable,Sub1 -cgrates.org,ALS1,*string:~*opts.*context:con2|con3,,,,*string:~*req.Account:1002;true,*req.Field2,*variable,Sub2 -`), 0644); err != nil { - t.Fatal(err.Error()) - } -} - -func TestLoaderSReload(t *testing.T) { - testCreateDirs(t) - cfg := config.NewDefaultCGRConfig() - cfg.TemplatesCfg()["attrTemplateLoader"] = []*config.FCTemplate{ - { - Type: utils.MetaVariable, - Path: "*req.Accounts", - Value: config.NewRSRParsersMustCompile("1001", utils.InfieldSep), - }, - } - - shdWg := new(sync.WaitGroup) - filterSChan := make(chan *engine.FilterS, 1) - filterSChan <- nil - cls := commonlisteners.NewCommonListenerS(nil) - srvMngr := servmanager.NewServiceManager(shdWg, nil, cfg) - srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} - db := NewDataDBService(cfg, nil, false, srvDep) - anz := NewAnalyzerService(cfg, cls, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) - conMngr := engine.NewConnManager(cfg) - srv := NewLoaderService(cfg, db, filterSChan, - cls, make(chan birpc.ClientConnector, 1), - conMngr, anz, srvDep) - srvMngr.AddServices(srv, db) - ctx, cancel := context.WithCancel(context.TODO()) - srvMngr.StartServices(ctx, cancel) - - if db.IsRunning() { - t.Errorf("Expected service to be down") - } - - if srv.IsRunning() { - t.Errorf("Expected service to be down") - } - - var reply string - cfg.ConfigPath = path.Join("/usr", "share", "cgrates", "conf", "samples", "loaders", "tutinternal") - if err := cfg.V1ReloadConfig(context.Background(), &config.ReloadArgs{ - Section: config.LoaderSJSON, - }, &reply); err != nil { - t.Fatal(err) - } else if reply != utils.OK { - t.Errorf("Expecting OK ,received %s", reply) - } - time.Sleep(10 * time.Millisecond) - if !db.IsRunning() { - t.Fatal("Expected service to be running") - } - time.Sleep(10 * time.Millisecond) - if !srv.IsRunning() { - t.Fatal("Expected service to be running") - } - - err := srv.Start(ctx, cancel) - if err == nil || err != utils.ErrServiceAlreadyRunning { - t.Errorf("\nExpecting <%+v>,\n Received <%+v>", utils.ErrServiceAlreadyRunning, err) - } - time.Sleep(10 * time.Millisecond) - err = srv.Reload(ctx, cancel) - if err != nil { - t.Errorf("\nExpecting ,\n Received <%+v>", err) - } - time.Sleep(10 * time.Millisecond) - for _, v := range cfg.LoaderCfg() { - v.Enabled = false - } - time.Sleep(10 * time.Millisecond) - cfg.GetReloadChan() <- config.SectionToService[config.LoaderSJSON] - time.Sleep(10 * time.Millisecond) - - if srv.IsRunning() { - t.Errorf("Expected service to be down") - } - - cancel() - time.Sleep(10 * time.Millisecond) - testCleanupFiles(t) -} -func testCleanupFiles(t *testing.T) { - for _, dir := range []string{"/tmp/In", "/tmp/Out", "/tmp/LoaderIn", "/tmp/SubpathWithoutMove", - "/tmp/SubpathLoaderWithMove", "/tmp/SubpathOut"} { - if err := os.RemoveAll(dir); err != nil { - t.Fatal("Error removing folder: ", dir, err) - } - } -} - -func TestLoaderSReload2(t *testing.T) { - cfg := config.NewDefaultCGRConfig() - for _, ld := range cfg.LoaderCfg() { - ld.Enabled = false - } - filterSChan := make(chan *engine.FilterS, 1) - filterSChan <- nil - cls := commonlisteners.NewCommonListenerS(nil) - srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} - db := NewDataDBService(cfg, nil, false, srvDep) - db.dbchan <- new(engine.DataManager) - anz := NewAnalyzerService(cfg, cls, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) - srv := NewLoaderService(cfg, db, filterSChan, - cls, make(chan birpc.ClientConnector, 1), - nil, anz, srvDep) - ctx, cancel := context.WithCancel(context.TODO()) - err := srv.Start(ctx, cancel) - if err != nil { - t.Fatal(err) - } -} - -func TestLoaderSReload3(t *testing.T) { - cfg := config.NewDefaultCGRConfig() - for _, ld := range cfg.LoaderCfg() { - ld.Enabled = false - } - cfg.LoaderCfg()[0].Enabled = true - cfg.LoaderCfg()[0].TpInDir = "/tmp/TestLoaderSReload3" - cfg.LoaderCfg()[0].RunDelay = -1 - filterSChan := make(chan *engine.FilterS, 1) - filterSChan <- nil - cls := commonlisteners.NewCommonListenerS(nil) - srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} - db := NewDataDBService(cfg, nil, false, srvDep) - db.dbchan <- new(engine.DataManager) - anz := NewAnalyzerService(cfg, cls, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) - srv := NewLoaderService(cfg, db, filterSChan, - cls, make(chan birpc.ClientConnector, 1), - nil, anz, srvDep) - ctx, cancel := context.WithCancel(context.TODO()) - err := srv.Start(ctx, cancel) - if err == nil || err.Error() != "no such file or directory" { - t.Errorf("\nExpected <%+v>, \nReceived <%+v>", "no such file or directory", err) - } - err = srv.Reload(ctx, cancel) - if err == nil || err.Error() != "no such file or directory" { - t.Errorf("\nExpected <%+v>, \nReceived <%+v>", "no such file or directory", err) - } -} +// import ( +// "os" +// "path" +// "sync" +// "testing" +// "time" +// +// "github.com/cgrates/birpc" +// "github.com/cgrates/birpc/context" +// "github.com/cgrates/cgrates/commonlisteners" +// "github.com/cgrates/cgrates/config" +// "github.com/cgrates/cgrates/engine" +// "github.com/cgrates/cgrates/servmanager" +// "github.com/cgrates/cgrates/utils" +// ) +// +// func testCreateDirs(t *testing.T) { +// for _, dir := range []string{"/tmp/In", "/tmp/Out", "/tmp/LoaderIn", "/tmp/SubpathWithoutMove", +// "/tmp/SubpathLoaderWithMove", "/tmp/SubpathOut", "/tmp/templateLoaderIn", "/tmp/templateLoaderOut", +// "/tmp/customSepLoaderIn", "/tmp/customSepLoaderOut"} { +// if err := os.RemoveAll(dir); err != nil { +// t.Fatal("Error removing folder: ", dir, err) +// } +// if err := os.MkdirAll(dir, 0755); err != nil { +// t.Fatal("Error creating folder: ", dir, err) +// } +// } +// if err := os.WriteFile(path.Join("/tmp/In", utils.AttributesCsv), []byte(` +// #Tenant,ID,FilterIDs,Weights,Blockers,AttributeFilterIDs,AttributeBlockers,Path,Type,Value +// cgrates.org,ALS1,*string:~*req.Account:1001;*string:~*opts.*context:con1,;20,;true,*string:~*req.Field1:Initial,;true,*req.Field1,*variable,Sub1 +// cgrates.org,ALS1,*string:~*opts.*context:con2|con3,,,,*string:~*req.Account:1002;true,*req.Field2,*variable,Sub2 +// `), 0644); err != nil { +// t.Fatal(err.Error()) +// } +// } +// +// func TestLoaderSReload(t *testing.T) { +// testCreateDirs(t) +// cfg := config.NewDefaultCGRConfig() +// cfg.TemplatesCfg()["attrTemplateLoader"] = []*config.FCTemplate{ +// { +// Type: utils.MetaVariable, +// Path: "*req.Accounts", +// Value: config.NewRSRParsersMustCompile("1001", utils.InfieldSep), +// }, +// } +// +// shdWg := new(sync.WaitGroup) +// filterSChan := make(chan *engine.FilterS, 1) +// filterSChan <- nil +// cls := commonlisteners.NewCommonListenerS(nil) +// srvMngr := servmanager.NewServiceManager(shdWg, nil, cfg) +// srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} +// db := NewDataDBService(cfg, nil, false, srvDep) +// anz := NewAnalyzerService(cfg, cls, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) +// conMngr := engine.NewConnManager(cfg) +// srv := NewLoaderService(cfg, db, filterSChan, +// cls, make(chan birpc.ClientConnector, 1), +// conMngr, anz, srvDep) +// srvMngr.AddServices(srv, db) +// ctx, cancel := context.WithCancel(context.TODO()) +// srvMngr.StartServices(ctx, cancel) +// +// if db.IsRunning() { +// t.Errorf("Expected service to be down") +// } +// +// if srv.IsRunning() { +// t.Errorf("Expected service to be down") +// } +// +// var reply string +// cfg.ConfigPath = path.Join("/usr", "share", "cgrates", "conf", "samples", "loaders", "tutinternal") +// if err := cfg.V1ReloadConfig(context.Background(), &config.ReloadArgs{ +// Section: config.LoaderSJSON, +// }, &reply); err != nil { +// t.Fatal(err) +// } else if reply != utils.OK { +// t.Errorf("Expecting OK ,received %s", reply) +// } +// time.Sleep(10 * time.Millisecond) +// if !db.IsRunning() { +// t.Fatal("Expected service to be running") +// } +// time.Sleep(10 * time.Millisecond) +// if !srv.IsRunning() { +// t.Fatal("Expected service to be running") +// } +// +// err := srv.Start(ctx, cancel) +// if err == nil || err != utils.ErrServiceAlreadyRunning { +// t.Errorf("\nExpecting <%+v>,\n Received <%+v>", utils.ErrServiceAlreadyRunning, err) +// } +// time.Sleep(10 * time.Millisecond) +// err = srv.Reload(ctx, cancel) +// if err != nil { +// t.Errorf("\nExpecting ,\n Received <%+v>", err) +// } +// time.Sleep(10 * time.Millisecond) +// for _, v := range cfg.LoaderCfg() { +// v.Enabled = false +// } +// time.Sleep(10 * time.Millisecond) +// cfg.GetReloadChan() <- config.SectionToService[config.LoaderSJSON] +// time.Sleep(10 * time.Millisecond) +// +// if srv.IsRunning() { +// t.Errorf("Expected service to be down") +// } +// +// cancel() +// time.Sleep(10 * time.Millisecond) +// testCleanupFiles(t) +// } +// func testCleanupFiles(t *testing.T) { +// for _, dir := range []string{"/tmp/In", "/tmp/Out", "/tmp/LoaderIn", "/tmp/SubpathWithoutMove", +// "/tmp/SubpathLoaderWithMove", "/tmp/SubpathOut"} { +// if err := os.RemoveAll(dir); err != nil { +// t.Fatal("Error removing folder: ", dir, err) +// } +// } +// } +// +// func TestLoaderSReload2(t *testing.T) { +// cfg := config.NewDefaultCGRConfig() +// for _, ld := range cfg.LoaderCfg() { +// ld.Enabled = false +// } +// filterSChan := make(chan *engine.FilterS, 1) +// filterSChan <- nil +// cls := commonlisteners.NewCommonListenerS(nil) +// srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} +// db := NewDataDBService(cfg, nil, false, srvDep) +// db.dbchan <- new(engine.DataManager) +// anz := NewAnalyzerService(cfg, cls, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) +// srv := NewLoaderService(cfg, db, filterSChan, +// cls, make(chan birpc.ClientConnector, 1), +// nil, anz, srvDep) +// ctx, cancel := context.WithCancel(context.TODO()) +// err := srv.Start(ctx, cancel) +// if err != nil { +// t.Fatal(err) +// } +// } +// +// func TestLoaderSReload3(t *testing.T) { +// cfg := config.NewDefaultCGRConfig() +// for _, ld := range cfg.LoaderCfg() { +// ld.Enabled = false +// } +// cfg.LoaderCfg()[0].Enabled = true +// cfg.LoaderCfg()[0].TpInDir = "/tmp/TestLoaderSReload3" +// cfg.LoaderCfg()[0].RunDelay = -1 +// filterSChan := make(chan *engine.FilterS, 1) +// filterSChan <- nil +// cls := commonlisteners.NewCommonListenerS(nil) +// srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} +// db := NewDataDBService(cfg, nil, false, srvDep) +// db.dbchan <- new(engine.DataManager) +// anz := NewAnalyzerService(cfg, cls, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) +// srv := NewLoaderService(cfg, db, filterSChan, +// cls, make(chan birpc.ClientConnector, 1), +// nil, anz, srvDep) +// ctx, cancel := context.WithCancel(context.TODO()) +// err := srv.Start(ctx, cancel) +// if err == nil || err.Error() != "no such file or directory" { +// t.Errorf("\nExpected <%+v>, \nReceived <%+v>", "no such file or directory", err) +// } +// err = srv.Reload(ctx, cancel) +// if err == nil || err.Error() != "no such file or directory" { +// t.Errorf("\nExpected <%+v>, \nReceived <%+v>", "no such file or directory", err) +// } +// } diff --git a/services/loaders_test.go b/services/loaders_test.go index d05f0b8f3..671193708 100644 --- a/services/loaders_test.go +++ b/services/loaders_test.go @@ -17,71 +17,71 @@ along with this program. If not, see */ package services -import ( - "reflect" - "sync" - "testing" - - "github.com/cgrates/birpc" - "github.com/cgrates/cgrates/commonlisteners" - "github.com/cgrates/cgrates/config" - "github.com/cgrates/cgrates/engine" - "github.com/cgrates/cgrates/loaders" - "github.com/cgrates/cgrates/utils" -) - -// TestLoaderSCoverage for cover testing -func TestLoaderSCoverage(t *testing.T) { - cfg := config.NewDefaultCGRConfig() - filterSChan := make(chan *engine.FilterS, 1) - filterSChan <- nil - cls := commonlisteners.NewCommonListenerS(nil) - srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} - db := NewDataDBService(cfg, nil, false, srvDep) - internalLoaderSChan := make(chan birpc.ClientConnector, 1) - cM := engine.NewConnManager(cfg) - anz := NewAnalyzerService(cfg, cls, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) - cfg.LoaderCfg()[0] = &config.LoaderSCfg{ - ID: "test_id", - Enabled: true, - Tenant: "", - RunDelay: 0, - LockFilePath: "", - CacheSConns: nil, - FieldSeparator: "", - TpInDir: "", - TpOutDir: "", - Data: nil, - } - srv := NewLoaderService(cfg, db, - filterSChan, cls, internalLoaderSChan, - cM, anz, srvDep) - if srv == nil { - t.Errorf("\nExpecting ,\n Received <%+v>", utils.ToJSON(srv)) - } - if srv.IsRunning() { - t.Errorf("Expected service to be down") - } - srv.ldrs = loaders.NewLoaderS(cfg, &engine.DataManager{}, - &engine.FilterS{}, nil) - if !srv.IsRunning() { - t.Errorf("Expected service to be running") - } - serviceName := srv.ServiceName() - if !reflect.DeepEqual(serviceName, utils.LoaderS) { - t.Errorf("\nExpecting <%+v>,\n Received <%+v>", utils.LoaderS, serviceName) - } - if shouldRun := srv.ShouldRun(); !shouldRun { - t.Errorf("\nExpecting ,\n Received <%+v>", shouldRun) - } - if !reflect.DeepEqual(srv.GetLoaderS(), srv.ldrs) { - t.Errorf("\nExpecting <%+v>,\n Received <%+v>", srv.ldrs, srv.GetLoaderS()) - } - srv.stopChan = make(chan struct{}, 1) - srv.connChan <- &testMockClients{} - srv.Shutdown() - if srv.IsRunning() { - t.Errorf("Expected service to be down") - } - -} +// import ( +// "reflect" +// "sync" +// "testing" +// +// "github.com/cgrates/birpc" +// "github.com/cgrates/cgrates/commonlisteners" +// "github.com/cgrates/cgrates/config" +// "github.com/cgrates/cgrates/engine" +// "github.com/cgrates/cgrates/loaders" +// "github.com/cgrates/cgrates/utils" +// ) +// +// // TestLoaderSCoverage for cover testing +// func TestLoaderSCoverage(t *testing.T) { +// cfg := config.NewDefaultCGRConfig() +// filterSChan := make(chan *engine.FilterS, 1) +// filterSChan <- nil +// cls := commonlisteners.NewCommonListenerS(nil) +// srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} +// db := NewDataDBService(cfg, nil, false, srvDep) +// internalLoaderSChan := make(chan birpc.ClientConnector, 1) +// cM := engine.NewConnManager(cfg) +// anz := NewAnalyzerService(cfg, cls, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) +// cfg.LoaderCfg()[0] = &config.LoaderSCfg{ +// ID: "test_id", +// Enabled: true, +// Tenant: "", +// RunDelay: 0, +// LockFilePath: "", +// CacheSConns: nil, +// FieldSeparator: "", +// TpInDir: "", +// TpOutDir: "", +// Data: nil, +// } +// srv := NewLoaderService(cfg, db, +// filterSChan, cls, internalLoaderSChan, +// cM, anz, srvDep) +// if srv == nil { +// t.Errorf("\nExpecting ,\n Received <%+v>", utils.ToJSON(srv)) +// } +// if srv.IsRunning() { +// t.Errorf("Expected service to be down") +// } +// srv.ldrs = loaders.NewLoaderS(cfg, &engine.DataManager{}, +// &engine.FilterS{}, nil) +// if !srv.IsRunning() { +// t.Errorf("Expected service to be running") +// } +// serviceName := srv.ServiceName() +// if !reflect.DeepEqual(serviceName, utils.LoaderS) { +// t.Errorf("\nExpecting <%+v>,\n Received <%+v>", utils.LoaderS, serviceName) +// } +// if shouldRun := srv.ShouldRun(); !shouldRun { +// t.Errorf("\nExpecting ,\n Received <%+v>", shouldRun) +// } +// if !reflect.DeepEqual(srv.GetLoaderS(), srv.ldrs) { +// t.Errorf("\nExpecting <%+v>,\n Received <%+v>", srv.ldrs, srv.GetLoaderS()) +// } +// srv.stopChan = make(chan struct{}, 1) +// srv.connChan <- &testMockClients{} +// srv.Shutdown() +// if srv.IsRunning() { +// t.Errorf("Expected service to be down") +// } +// +// } diff --git a/services/radiusagent_it_test.go b/services/radiusagent_it_test.go index 623a1de07..cbdfab7ea 100644 --- a/services/radiusagent_it_test.go +++ b/services/radiusagent_it_test.go @@ -20,200 +20,200 @@ along with this program. If not, see */ package services -import ( - "path" - "runtime" - "sync" - "testing" - "time" - - "github.com/cgrates/birpc" - "github.com/cgrates/birpc/context" - "github.com/cgrates/cgrates/agents" - "github.com/cgrates/cgrates/commonlisteners" - "github.com/cgrates/cgrates/config" - "github.com/cgrates/cgrates/engine" - "github.com/cgrates/cgrates/servmanager" - "github.com/cgrates/cgrates/utils" -) - -func TestRadiusAgentReload(t *testing.T) { - cfg := config.NewDefaultCGRConfig() - - cfg.SessionSCfg().Enabled = true - cfg.SessionSCfg().ListenBijson = "" - filterSChan := make(chan *engine.FilterS, 1) - filterSChan <- nil - ctx, cancel := context.WithCancel(context.TODO()) - defer func() { - cancel() - time.Sleep(10 * time.Millisecond) - }() - shdWg := new(sync.WaitGroup) - - cls := commonlisteners.NewCommonListenerS(nil) - srvMngr := servmanager.NewServiceManager(shdWg, nil, cfg) - srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} - db := NewDataDBService(cfg, nil, false, srvDep) - anz := NewAnalyzerService(cfg, cls, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) - sS := NewSessionService(cfg, db, filterSChan, cls, make(chan birpc.ClientConnector, 1), - nil, anz, srvDep) - srv := NewRadiusAgent(cfg, filterSChan, nil, srvDep) - engine.NewConnManager(cfg) - srvMngr.AddServices(srv, sS, - NewLoaderService(cfg, db, filterSChan, cls, make(chan birpc.ClientConnector, 1), nil, anz, srvDep), db) - srvMngr.StartServices(ctx, cancel) - if srv.IsRunning() { - t.Fatalf("Expected service to be down") - } - var reply string - cfg.ConfigPath = path.Join("/usr", "share", "cgrates", "conf", "samples", "radagent_mysql") - if err := cfg.V1ReloadConfig(context.Background(), &config.ReloadArgs{ - Section: config.RadiusAgentJSON, - }, &reply); err != nil { - t.Fatal(err) - } else if reply != utils.OK { - t.Fatalf("Expecting OK ,received %s", reply) - } - time.Sleep(10 * time.Millisecond) //need to switch to gorutine - runtime.Gosched() - if !srv.IsRunning() { - t.Fatalf("Expected service to be running") - } - runtime.Gosched() - err := srv.Start(ctx, cancel) - if err == nil || err != utils.ErrServiceAlreadyRunning { - t.Fatalf("\nExpecting <%+v>,\n Received <%+v>", utils.ErrServiceAlreadyRunning, err) - } - err = srv.Reload(ctx, cancel) - if err != nil { - t.Fatalf("\nExpecting ,\n Received <%+v>", err) - } - cfg.RadiusAgentCfg().Enabled = false - cfg.GetReloadChan() <- config.SectionToService[config.RadiusAgentJSON] - time.Sleep(10 * time.Millisecond) - if srv.IsRunning() { - t.Fatalf("Expected service to be down") - } -} - -func TestRadiusAgentReload2(t *testing.T) { - time.Sleep(10 * time.Millisecond) - cfg := config.NewDefaultCGRConfig() - - cfg.SessionSCfg().Enabled = true - filterSChan := make(chan *engine.FilterS, 1) - filterSChan <- nil - ctx, cancel := context.WithCancel(context.TODO()) - defer func() { - cancel() - time.Sleep(10 * time.Millisecond) - }() - shdWg := new(sync.WaitGroup) - - cls := commonlisteners.NewCommonListenerS(nil) - srvMngr := servmanager.NewServiceManager(shdWg, nil, cfg) - srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} - db := NewDataDBService(cfg, nil, false, srvDep) - anz := NewAnalyzerService(cfg, cls, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) - sS := NewSessionService(cfg, db, filterSChan, cls, make(chan birpc.ClientConnector, 1), - nil, anz, srvDep) - srv := NewRadiusAgent(cfg, filterSChan, nil, srvDep) - engine.NewConnManager(cfg) - srvMngr.AddServices(srv, sS, - NewLoaderService(cfg, db, filterSChan, cls, make(chan birpc.ClientConnector, 1), nil, anz, srvDep), db) - srvMngr.StartServices(ctx, cancel) - if srv.IsRunning() { - t.Fatalf("Expected service to be down") - } - var reply string - cfg.ConfigPath = path.Join("/usr", "share", "cgrates", "conf", "samples", "radagent_mysql") - if err := cfg.V1ReloadConfig(context.Background(), &config.ReloadArgs{ - Section: config.RadiusAgentJSON, - }, &reply); err != nil { - t.Fatal(err) - } else if reply != utils.OK { - t.Fatalf("Expecting OK ,received %s", reply) - } - time.Sleep(10 * time.Millisecond) //need to switch to gorutine - runtime.Gosched() - runtime.Gosched() - if !srv.IsRunning() { - t.Fatalf("Expected service to be running") - } - runtime.Gosched() - runtime.Gosched() - err := srv.Start(ctx, cancel) - if err == nil || err != utils.ErrServiceAlreadyRunning { - t.Fatalf("\nExpecting <%+v>,\n Received <%+v>", utils.ErrServiceAlreadyRunning, err) - } - err = srv.Reload(ctx, cancel) - if err != nil { - t.Fatalf("\nExpecting ,\n Received <%+v>", err) - } - castSrv, canCastSrv := srv.(*RadiusAgent) - if !canCastSrv { - t.Fatalf("cannot cast") - } - - err = srv.Reload(ctx, cancel) - if err != nil { - t.Fatalf("\nExpecting ,\n Received <%+v>", err) - } - castSrv.lnet = "test_string" - err = srv.Reload(ctx, cancel) - if err != nil { - t.Fatalf("\nExpecting ,\n Received <%+v>", err) - } - cfg.RadiusAgentCfg().Enabled = false - cfg.GetReloadChan() <- config.SectionToService[config.RadiusAgentJSON] - time.Sleep(10 * time.Millisecond) - if srv.IsRunning() { - t.Fatalf("Expected service to be down") - } - -} - -func TestRadiusAgentReload3(t *testing.T) { - cfg := config.NewDefaultCGRConfig() - cfg.RadiusAgentCfg().ClientDictionaries = map[string]string{ - "test": "test", - } - cfg.SessionSCfg().Enabled = true - cfg.RadiusAgentCfg().Enabled = true - filterSChan := make(chan *engine.FilterS, 1) - filterSChan <- nil - ctx, cancel := context.WithCancel(context.TODO()) - defer func() { - cancel() - time.Sleep(10 * time.Millisecond) - }() - srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} - srv := NewRadiusAgent(cfg, filterSChan, nil, srvDep) - err := srv.Start(ctx, cancel) - if err == nil || err.Error() != "stat test: no such file or directory" { - t.Fatalf("\nExpected <%+v>, \nReceived <%+v>", "stat test: no such file or directory", err) - } -} - -func TestRadiusAgentReload4(t *testing.T) { - cfg := config.NewDefaultCGRConfig() - cfg.SessionSCfg().Enabled = true - cfg.RadiusAgentCfg().Enabled = true - cfg.RadiusAgentCfg().ListenNet = "test" - filterSChan := make(chan *engine.FilterS, 1) - filterSChan <- nil - srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} - srv := NewRadiusAgent(cfg, filterSChan, nil, srvDep) - r, err := agents.NewRadiusAgent(cfg, nil, nil) - if err != nil { - t.Fatal(err) - } - runtime.Gosched() - rad := srv.(*RadiusAgent) - rad.stopChan = make(chan struct{}) - err = rad.listenAndServe(r, func() {}) - if err == nil || err.Error() != "unsupported network: " { - t.Fatalf("\nExpected <%+v>, \nReceived <%+v>", "unsupported network: ", err) - } -} +// import ( +// "path" +// "runtime" +// "sync" +// "testing" +// "time" +// +// "github.com/cgrates/birpc" +// "github.com/cgrates/birpc/context" +// "github.com/cgrates/cgrates/agents" +// "github.com/cgrates/cgrates/commonlisteners" +// "github.com/cgrates/cgrates/config" +// "github.com/cgrates/cgrates/engine" +// "github.com/cgrates/cgrates/servmanager" +// "github.com/cgrates/cgrates/utils" +// ) +// +// func TestRadiusAgentReload(t *testing.T) { +// cfg := config.NewDefaultCGRConfig() +// +// cfg.SessionSCfg().Enabled = true +// cfg.SessionSCfg().ListenBijson = "" +// filterSChan := make(chan *engine.FilterS, 1) +// filterSChan <- nil +// ctx, cancel := context.WithCancel(context.TODO()) +// defer func() { +// cancel() +// time.Sleep(10 * time.Millisecond) +// }() +// shdWg := new(sync.WaitGroup) +// +// cls := commonlisteners.NewCommonListenerS(nil) +// srvMngr := servmanager.NewServiceManager(shdWg, nil, cfg) +// srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} +// db := NewDataDBService(cfg, nil, false, srvDep) +// anz := NewAnalyzerService(cfg, cls, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) +// sS := NewSessionService(cfg, db, filterSChan, cls, make(chan birpc.ClientConnector, 1), +// nil, anz, srvDep) +// srv := NewRadiusAgent(cfg, filterSChan, nil, srvDep) +// engine.NewConnManager(cfg) +// srvMngr.AddServices(srv, sS, +// NewLoaderService(cfg, db, filterSChan, cls, make(chan birpc.ClientConnector, 1), nil, anz, srvDep), db) +// srvMngr.StartServices(ctx, cancel) +// if srv.IsRunning() { +// t.Fatalf("Expected service to be down") +// } +// var reply string +// cfg.ConfigPath = path.Join("/usr", "share", "cgrates", "conf", "samples", "radagent_mysql") +// if err := cfg.V1ReloadConfig(context.Background(), &config.ReloadArgs{ +// Section: config.RadiusAgentJSON, +// }, &reply); err != nil { +// t.Fatal(err) +// } else if reply != utils.OK { +// t.Fatalf("Expecting OK ,received %s", reply) +// } +// time.Sleep(10 * time.Millisecond) //need to switch to gorutine +// runtime.Gosched() +// if !srv.IsRunning() { +// t.Fatalf("Expected service to be running") +// } +// runtime.Gosched() +// err := srv.Start(ctx, cancel) +// if err == nil || err != utils.ErrServiceAlreadyRunning { +// t.Fatalf("\nExpecting <%+v>,\n Received <%+v>", utils.ErrServiceAlreadyRunning, err) +// } +// err = srv.Reload(ctx, cancel) +// if err != nil { +// t.Fatalf("\nExpecting ,\n Received <%+v>", err) +// } +// cfg.RadiusAgentCfg().Enabled = false +// cfg.GetReloadChan() <- config.SectionToService[config.RadiusAgentJSON] +// time.Sleep(10 * time.Millisecond) +// if srv.IsRunning() { +// t.Fatalf("Expected service to be down") +// } +// } +// +// func TestRadiusAgentReload2(t *testing.T) { +// time.Sleep(10 * time.Millisecond) +// cfg := config.NewDefaultCGRConfig() +// +// cfg.SessionSCfg().Enabled = true +// filterSChan := make(chan *engine.FilterS, 1) +// filterSChan <- nil +// ctx, cancel := context.WithCancel(context.TODO()) +// defer func() { +// cancel() +// time.Sleep(10 * time.Millisecond) +// }() +// shdWg := new(sync.WaitGroup) +// +// cls := commonlisteners.NewCommonListenerS(nil) +// srvMngr := servmanager.NewServiceManager(shdWg, nil, cfg) +// srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} +// db := NewDataDBService(cfg, nil, false, srvDep) +// anz := NewAnalyzerService(cfg, cls, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) +// sS := NewSessionService(cfg, db, filterSChan, cls, make(chan birpc.ClientConnector, 1), +// nil, anz, srvDep) +// srv := NewRadiusAgent(cfg, filterSChan, nil, srvDep) +// engine.NewConnManager(cfg) +// srvMngr.AddServices(srv, sS, +// NewLoaderService(cfg, db, filterSChan, cls, make(chan birpc.ClientConnector, 1), nil, anz, srvDep), db) +// srvMngr.StartServices(ctx, cancel) +// if srv.IsRunning() { +// t.Fatalf("Expected service to be down") +// } +// var reply string +// cfg.ConfigPath = path.Join("/usr", "share", "cgrates", "conf", "samples", "radagent_mysql") +// if err := cfg.V1ReloadConfig(context.Background(), &config.ReloadArgs{ +// Section: config.RadiusAgentJSON, +// }, &reply); err != nil { +// t.Fatal(err) +// } else if reply != utils.OK { +// t.Fatalf("Expecting OK ,received %s", reply) +// } +// time.Sleep(10 * time.Millisecond) //need to switch to gorutine +// runtime.Gosched() +// runtime.Gosched() +// if !srv.IsRunning() { +// t.Fatalf("Expected service to be running") +// } +// runtime.Gosched() +// runtime.Gosched() +// err := srv.Start(ctx, cancel) +// if err == nil || err != utils.ErrServiceAlreadyRunning { +// t.Fatalf("\nExpecting <%+v>,\n Received <%+v>", utils.ErrServiceAlreadyRunning, err) +// } +// err = srv.Reload(ctx, cancel) +// if err != nil { +// t.Fatalf("\nExpecting ,\n Received <%+v>", err) +// } +// castSrv, canCastSrv := srv.(*RadiusAgent) +// if !canCastSrv { +// t.Fatalf("cannot cast") +// } +// +// err = srv.Reload(ctx, cancel) +// if err != nil { +// t.Fatalf("\nExpecting ,\n Received <%+v>", err) +// } +// castSrv.lnet = "test_string" +// err = srv.Reload(ctx, cancel) +// if err != nil { +// t.Fatalf("\nExpecting ,\n Received <%+v>", err) +// } +// cfg.RadiusAgentCfg().Enabled = false +// cfg.GetReloadChan() <- config.SectionToService[config.RadiusAgentJSON] +// time.Sleep(10 * time.Millisecond) +// if srv.IsRunning() { +// t.Fatalf("Expected service to be down") +// } +// +// } +// +// func TestRadiusAgentReload3(t *testing.T) { +// cfg := config.NewDefaultCGRConfig() +// cfg.RadiusAgentCfg().ClientDictionaries = map[string]string{ +// "test": "test", +// } +// cfg.SessionSCfg().Enabled = true +// cfg.RadiusAgentCfg().Enabled = true +// filterSChan := make(chan *engine.FilterS, 1) +// filterSChan <- nil +// ctx, cancel := context.WithCancel(context.TODO()) +// defer func() { +// cancel() +// time.Sleep(10 * time.Millisecond) +// }() +// srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} +// srv := NewRadiusAgent(cfg, filterSChan, nil, srvDep) +// err := srv.Start(ctx, cancel) +// if err == nil || err.Error() != "stat test: no such file or directory" { +// t.Fatalf("\nExpected <%+v>, \nReceived <%+v>", "stat test: no such file or directory", err) +// } +// } +// +// func TestRadiusAgentReload4(t *testing.T) { +// cfg := config.NewDefaultCGRConfig() +// cfg.SessionSCfg().Enabled = true +// cfg.RadiusAgentCfg().Enabled = true +// cfg.RadiusAgentCfg().ListenNet = "test" +// filterSChan := make(chan *engine.FilterS, 1) +// filterSChan <- nil +// srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} +// srv := NewRadiusAgent(cfg, filterSChan, nil, srvDep) +// r, err := agents.NewRadiusAgent(cfg, nil, nil) +// if err != nil { +// t.Fatal(err) +// } +// runtime.Gosched() +// rad := srv.(*RadiusAgent) +// rad.stopChan = make(chan struct{}) +// err = rad.listenAndServe(r, func() {}) +// if err == nil || err.Error() != "unsupported network: " { +// t.Fatalf("\nExpected <%+v>, \nReceived <%+v>", "unsupported network: ", err) +// } +// } diff --git a/services/radiusagent_test.go b/services/radiusagent_test.go index 39583cfe3..088756b66 100644 --- a/services/radiusagent_test.go +++ b/services/radiusagent_test.go @@ -17,50 +17,50 @@ along with this program. If not, see */ package services -import ( - "reflect" - "sync" - "testing" - - "github.com/cgrates/cgrates/agents" - "github.com/cgrates/cgrates/config" - "github.com/cgrates/cgrates/engine" - "github.com/cgrates/cgrates/utils" -) - -// TestLoaderSCoverage for cover testing -func TestRadiusAgentCoverage(t *testing.T) { - cfg := config.NewDefaultCGRConfig() - cfg.SessionSCfg().Enabled = true - cfg.SessionSCfg().ListenBijson = "" - filterSChan := make(chan *engine.FilterS, 1) - filterSChan <- nil - srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} - srv := NewRadiusAgent(cfg, filterSChan, nil, srvDep) - if srv.IsRunning() { - t.Errorf("Expected service to be down") - } - srv2 := RadiusAgent{ - cfg: cfg, - filterSChan: filterSChan, - rad: &agents.RadiusAgent{}, - connMgr: nil, - srvDep: srvDep, - } - if !srv2.IsRunning() { - t.Errorf("Expected service to be running") - } - serviceName := srv2.ServiceName() - if !reflect.DeepEqual(serviceName, utils.RadiusAgent) { - t.Errorf("\nExpecting <%+v>,\n Received <%+v>", utils.RadiusAgent, serviceName) - } - shouldRun := srv2.ShouldRun() - if !reflect.DeepEqual(shouldRun, false) { - t.Errorf("\nExpecting ,\n Received <%+v>", shouldRun) - } - srv2.stopChan = make(chan struct{}, 1) - srv2.Shutdown() - if srv.IsRunning() { - t.Errorf("Expected service to be down") - } -} +// import ( +// "reflect" +// "sync" +// "testing" +// +// "github.com/cgrates/cgrates/agents" +// "github.com/cgrates/cgrates/config" +// "github.com/cgrates/cgrates/engine" +// "github.com/cgrates/cgrates/utils" +// ) +// +// // TestLoaderSCoverage for cover testing +// func TestRadiusAgentCoverage(t *testing.T) { +// cfg := config.NewDefaultCGRConfig() +// cfg.SessionSCfg().Enabled = true +// cfg.SessionSCfg().ListenBijson = "" +// filterSChan := make(chan *engine.FilterS, 1) +// filterSChan <- nil +// srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} +// srv := NewRadiusAgent(cfg, filterSChan, nil, srvDep) +// if srv.IsRunning() { +// t.Errorf("Expected service to be down") +// } +// srv2 := RadiusAgent{ +// cfg: cfg, +// filterSChan: filterSChan, +// rad: &agents.RadiusAgent{}, +// connMgr: nil, +// srvDep: srvDep, +// } +// if !srv2.IsRunning() { +// t.Errorf("Expected service to be running") +// } +// serviceName := srv2.ServiceName() +// if !reflect.DeepEqual(serviceName, utils.RadiusAgent) { +// t.Errorf("\nExpecting <%+v>,\n Received <%+v>", utils.RadiusAgent, serviceName) +// } +// shouldRun := srv2.ShouldRun() +// if !reflect.DeepEqual(shouldRun, false) { +// t.Errorf("\nExpecting ,\n Received <%+v>", shouldRun) +// } +// srv2.stopChan = make(chan struct{}, 1) +// srv2.Shutdown() +// if srv.IsRunning() { +// t.Errorf("Expected service to be down") +// } +// } diff --git a/services/rankings_test.go b/services/rankings_test.go index 032851cf6..4a1479222 100644 --- a/services/rankings_test.go +++ b/services/rankings_test.go @@ -18,47 +18,47 @@ along with this program. If not, see package services -import ( - "sync" - "testing" - - "github.com/cgrates/birpc" - "github.com/cgrates/cgrates/commonlisteners" - "github.com/cgrates/cgrates/config" - "github.com/cgrates/cgrates/engine" - "github.com/cgrates/cgrates/utils" -) - -func TestNewRankingService(t *testing.T) { - cfg := &config.CGRConfig{} - dm := &DataDBService{} - cacheS := &CacheService{} - filterSChan := make(chan *engine.FilterS) - birpc := make(chan birpc.ClientConnector) - server := &commonlisteners.CommonListenerS{} - connMgr := &engine.ConnManager{} - anz := &AnalyzerService{} - srvDep := make(map[string]*sync.WaitGroup) - - rankingService := NewRankingService(cfg, dm, cacheS, filterSChan, server, birpc, connMgr, anz, srvDep) - - if rankingService == nil { - t.Error("Expected non-nil RankingService, got nil") - } - - if _, ok := rankingService.(*RankingService); !ok { - t.Errorf("Expected type *RankingService, got %T", rankingService) - } - -} - -func TestRankingServiceName(t *testing.T) { - rankingService := &RankingService{} - - serviceName := rankingService.ServiceName() - - expectedServiceName := utils.RankingS - if serviceName != expectedServiceName { - t.Errorf("Expected service name '%s', but got '%s'", expectedServiceName, serviceName) - } -} +// import ( +// "sync" +// "testing" +// +// "github.com/cgrates/birpc" +// "github.com/cgrates/cgrates/commonlisteners" +// "github.com/cgrates/cgrates/config" +// "github.com/cgrates/cgrates/engine" +// "github.com/cgrates/cgrates/utils" +// ) +// +// func TestNewRankingService(t *testing.T) { +// cfg := &config.CGRConfig{} +// dm := &DataDBService{} +// cacheS := &CacheService{} +// filterSChan := make(chan *engine.FilterS) +// birpc := make(chan birpc.ClientConnector) +// server := &commonlisteners.CommonListenerS{} +// connMgr := &engine.ConnManager{} +// anz := &AnalyzerService{} +// srvDep := make(map[string]*sync.WaitGroup) +// +// rankingService := NewRankingService(cfg, dm, cacheS, filterSChan, server, birpc, connMgr, anz, srvDep) +// +// if rankingService == nil { +// t.Error("Expected non-nil RankingService, got nil") +// } +// +// if _, ok := rankingService.(*RankingService); !ok { +// t.Errorf("Expected type *RankingService, got %T", rankingService) +// } +// +// } +// +// func TestRankingServiceName(t *testing.T) { +// rankingService := &RankingService{} +// +// serviceName := rankingService.ServiceName() +// +// expectedServiceName := utils.RankingS +// if serviceName != expectedServiceName { +// t.Errorf("Expected service name '%s', but got '%s'", expectedServiceName, serviceName) +// } +// } diff --git a/services/rates_it_test.go b/services/rates_it_test.go index d02b90246..076512526 100644 --- a/services/rates_it_test.go +++ b/services/rates_it_test.go @@ -20,78 +20,78 @@ along with this program. If not, see */ package services -import ( - "path" - "runtime" - "sync" - "testing" - "time" - - "github.com/cgrates/birpc" - "github.com/cgrates/birpc/context" - "github.com/cgrates/cgrates/commonlisteners" - "github.com/cgrates/cgrates/config" - "github.com/cgrates/cgrates/engine" - "github.com/cgrates/cgrates/servmanager" - "github.com/cgrates/cgrates/utils" -) - -func TestRateSReload(t *testing.T) { - cfg := config.NewDefaultCGRConfig() - - filterSChan := make(chan *engine.FilterS, 1) - filterSChan <- nil - shdWg := new(sync.WaitGroup) - cls := commonlisteners.NewCommonListenerS(nil) - srvMngr := servmanager.NewServiceManager(shdWg, nil, cfg) - srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} - db := NewDataDBService(cfg, nil, false, srvDep) - chS := engine.NewCacheS(cfg, nil, nil, nil) - close(chS.GetPrecacheChannel(utils.CacheRateProfiles)) - close(chS.GetPrecacheChannel(utils.CacheRateProfilesFilterIndexes)) - close(chS.GetPrecacheChannel(utils.CacheRateFilterIndexes)) - chSCh := make(chan *engine.CacheS, 1) - chSCh <- chS - css := &CacheService{cacheCh: chSCh} - anz := NewAnalyzerService(cfg, cls, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) - rS := NewRateService(cfg, css, filterSChan, db, cls, make(chan birpc.ClientConnector, 1), anz, srvDep) - srvMngr.AddServices(rS, - NewLoaderService(cfg, db, filterSChan, cls, make(chan birpc.ClientConnector, 1), nil, anz, srvDep), db) - ctx, cancel := context.WithCancel(context.TODO()) - srvMngr.StartServices(ctx, cancel) - if rS.IsRunning() { - t.Errorf("Expected service to be down") - } - var reply string - cfg.ConfigPath = path.Join("/usr", "share", "cgrates", "conf", "samples", "rates") - if err := cfg.V1ReloadConfig(context.Background(), &config.ReloadArgs{ - Section: config.RateSJSON, - }, &reply); err != nil { - t.Error(err) - } else if reply != utils.OK { - t.Errorf("Expecting OK ,received %s", reply) - } - runtime.Gosched() - runtime.Gosched() - runtime.Gosched() - time.Sleep(10 * time.Millisecond) //need to switch to gorutine - if !rS.IsRunning() { - t.Errorf("Expected service to be running") - } - err := rS.Start(ctx, cancel) - if err == nil || err != utils.ErrServiceAlreadyRunning { - t.Errorf("\nExpecting <%+v>,\n Received <%+v>", utils.ErrServiceAlreadyRunning, err) - } - err = rS.Reload(ctx, cancel) - if err != nil { - t.Errorf("\nExpecting ,\n Received <%+v>", err) - } - cfg.RateSCfg().Enabled = false - cfg.GetReloadChan() <- config.SectionToService[config.RateSJSON] - time.Sleep(10 * time.Millisecond) - if rS.IsRunning() { - t.Errorf("Expected service to be down") - } - cancel() - time.Sleep(10 * time.Millisecond) -} +// import ( +// "path" +// "runtime" +// "sync" +// "testing" +// "time" +// +// "github.com/cgrates/birpc" +// "github.com/cgrates/birpc/context" +// "github.com/cgrates/cgrates/commonlisteners" +// "github.com/cgrates/cgrates/config" +// "github.com/cgrates/cgrates/engine" +// "github.com/cgrates/cgrates/servmanager" +// "github.com/cgrates/cgrates/utils" +// ) +// +// func TestRateSReload(t *testing.T) { +// cfg := config.NewDefaultCGRConfig() +// +// filterSChan := make(chan *engine.FilterS, 1) +// filterSChan <- nil +// shdWg := new(sync.WaitGroup) +// cls := commonlisteners.NewCommonListenerS(nil) +// srvMngr := servmanager.NewServiceManager(shdWg, nil, cfg) +// srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} +// db := NewDataDBService(cfg, nil, false, srvDep) +// chS := engine.NewCacheS(cfg, nil, nil, nil) +// close(chS.GetPrecacheChannel(utils.CacheRateProfiles)) +// close(chS.GetPrecacheChannel(utils.CacheRateProfilesFilterIndexes)) +// close(chS.GetPrecacheChannel(utils.CacheRateFilterIndexes)) +// chSCh := make(chan *engine.CacheS, 1) +// chSCh <- chS +// css := &CacheService{cacheCh: chSCh} +// anz := NewAnalyzerService(cfg, cls, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) +// rS := NewRateService(cfg, css, filterSChan, db, cls, make(chan birpc.ClientConnector, 1), anz, srvDep) +// srvMngr.AddServices(rS, +// NewLoaderService(cfg, db, filterSChan, cls, make(chan birpc.ClientConnector, 1), nil, anz, srvDep), db) +// ctx, cancel := context.WithCancel(context.TODO()) +// srvMngr.StartServices(ctx, cancel) +// if rS.IsRunning() { +// t.Errorf("Expected service to be down") +// } +// var reply string +// cfg.ConfigPath = path.Join("/usr", "share", "cgrates", "conf", "samples", "rates") +// if err := cfg.V1ReloadConfig(context.Background(), &config.ReloadArgs{ +// Section: config.RateSJSON, +// }, &reply); err != nil { +// t.Error(err) +// } else if reply != utils.OK { +// t.Errorf("Expecting OK ,received %s", reply) +// } +// runtime.Gosched() +// runtime.Gosched() +// runtime.Gosched() +// time.Sleep(10 * time.Millisecond) //need to switch to gorutine +// if !rS.IsRunning() { +// t.Errorf("Expected service to be running") +// } +// err := rS.Start(ctx, cancel) +// if err == nil || err != utils.ErrServiceAlreadyRunning { +// t.Errorf("\nExpecting <%+v>,\n Received <%+v>", utils.ErrServiceAlreadyRunning, err) +// } +// err = rS.Reload(ctx, cancel) +// if err != nil { +// t.Errorf("\nExpecting ,\n Received <%+v>", err) +// } +// cfg.RateSCfg().Enabled = false +// cfg.GetReloadChan() <- config.SectionToService[config.RateSJSON] +// time.Sleep(10 * time.Millisecond) +// if rS.IsRunning() { +// t.Errorf("Expected service to be down") +// } +// cancel() +// time.Sleep(10 * time.Millisecond) +// } diff --git a/services/rates_test.go b/services/rates_test.go index dabb87d68..ed4a9d7a9 100644 --- a/services/rates_test.go +++ b/services/rates_test.go @@ -17,62 +17,62 @@ along with this program. If not, see */ package services -import ( - "reflect" - "sync" - "testing" - - "github.com/cgrates/birpc" - "github.com/cgrates/birpc/context" - "github.com/cgrates/cgrates/commonlisteners" - "github.com/cgrates/cgrates/rates" - - "github.com/cgrates/cgrates/config" - "github.com/cgrates/cgrates/engine" - "github.com/cgrates/cgrates/utils" -) - -// TestRateSCoverage for cover testing -func TestRateSCoverage(t *testing.T) { - cfg := config.NewDefaultCGRConfig() - filterSChan := make(chan *engine.FilterS, 1) - filterSChan <- nil - cls := commonlisteners.NewCommonListenerS(nil) - srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} - db := NewDataDBService(cfg, nil, false, srvDep) - anz := NewAnalyzerService(cfg, cls, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) - chS := NewCacheService(cfg, db, nil, cls, make(chan context.ClientConnector, 1), anz, nil, srvDep) - rS := NewRateService(cfg, chS, filterSChan, db, cls, make(chan birpc.ClientConnector, 1), anz, srvDep) - - if rS.IsRunning() { - t.Errorf("Expected service to be down") - } - rS2 := RateService{ - cfg: cfg, - filterSChan: filterSChan, - dmS: db, - cacheS: chS, - cls: cls, - stopChan: make(chan struct{}), - intConnChan: make(chan birpc.ClientConnector, 1), - anz: anz, - srvDep: srvDep, - rateS: &rates.RateS{}, - } - if !rS2.IsRunning() { - t.Errorf("Expected service to be running") - } - serviceName := rS2.ServiceName() - if !reflect.DeepEqual(serviceName, utils.RateS) { - t.Errorf("\nExpecting <%+v>,\n Received <%+v>", utils.RateS, serviceName) - } - shouldRun := rS2.ShouldRun() - if !reflect.DeepEqual(shouldRun, false) { - t.Errorf("\nExpecting ,\n Received <%+v>", shouldRun) - } - rS2.intConnChan <- &testMockClients{} - rS2.Shutdown() - if rS.IsRunning() { - t.Errorf("Expected service to be down") - } -} +// import ( +// "reflect" +// "sync" +// "testing" +// +// "github.com/cgrates/birpc" +// "github.com/cgrates/birpc/context" +// "github.com/cgrates/cgrates/commonlisteners" +// "github.com/cgrates/cgrates/rates" +// +// "github.com/cgrates/cgrates/config" +// "github.com/cgrates/cgrates/engine" +// "github.com/cgrates/cgrates/utils" +// ) +// +// // TestRateSCoverage for cover testing +// func TestRateSCoverage(t *testing.T) { +// cfg := config.NewDefaultCGRConfig() +// filterSChan := make(chan *engine.FilterS, 1) +// filterSChan <- nil +// cls := commonlisteners.NewCommonListenerS(nil) +// srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} +// db := NewDataDBService(cfg, nil, false, srvDep) +// anz := NewAnalyzerService(cfg, cls, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) +// chS := NewCacheService(cfg, db, nil, cls, make(chan context.ClientConnector, 1), anz, nil, srvDep) +// rS := NewRateService(cfg, chS, filterSChan, db, cls, make(chan birpc.ClientConnector, 1), anz, srvDep) +// +// if rS.IsRunning() { +// t.Errorf("Expected service to be down") +// } +// rS2 := RateService{ +// cfg: cfg, +// filterSChan: filterSChan, +// dmS: db, +// cacheS: chS, +// cls: cls, +// stopChan: make(chan struct{}), +// intConnChan: make(chan birpc.ClientConnector, 1), +// anz: anz, +// srvDep: srvDep, +// rateS: &rates.RateS{}, +// } +// if !rS2.IsRunning() { +// t.Errorf("Expected service to be running") +// } +// serviceName := rS2.ServiceName() +// if !reflect.DeepEqual(serviceName, utils.RateS) { +// t.Errorf("\nExpecting <%+v>,\n Received <%+v>", utils.RateS, serviceName) +// } +// shouldRun := rS2.ShouldRun() +// if !reflect.DeepEqual(shouldRun, false) { +// t.Errorf("\nExpecting ,\n Received <%+v>", shouldRun) +// } +// rS2.intConnChan <- &testMockClients{} +// rS2.Shutdown() +// if rS.IsRunning() { +// t.Errorf("Expected service to be down") +// } +// } diff --git a/services/registrarc_it_test.go b/services/registrarc_it_test.go index a2156cc36..ce2b4ea9a 100644 --- a/services/registrarc_it_test.go +++ b/services/registrarc_it_test.go @@ -20,118 +20,118 @@ along with this program. If not, see */ package services -import ( - "os" - "path/filepath" - "runtime" - "sync" - "testing" - "time" - - "github.com/cgrates/birpc" - "github.com/cgrates/birpc/context" - "github.com/cgrates/cgrates/commonlisteners" - "github.com/cgrates/cgrates/config" - "github.com/cgrates/cgrates/engine" - "github.com/cgrates/cgrates/servmanager" - "github.com/cgrates/cgrates/utils" - "github.com/cgrates/rpcclient" -) - -func TestDispatcherHReload(t *testing.T) { - cfg := config.NewDefaultCGRConfig() - cfg.RPCConns()["dispConn"] = &config.RPCConn{ - Strategy: rpcclient.PoolFirst, - Conns: []*config.RemoteHost{{ - Address: "http://127.0.0.1:2080/dispatchers_registrar", - Transport: rpcclient.HTTPjson, - }}, - } - shdWg := new(sync.WaitGroup) - filterSChan := make(chan *engine.FilterS, 1) - filterSChan <- nil - cls := commonlisteners.NewCommonListenerS(nil) - srvMngr := servmanager.NewServiceManager(shdWg, nil, cfg) - srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} - db := NewDataDBService(cfg, nil, false, srvDep) - anz := NewAnalyzerService(cfg, cls, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) - connMngr := engine.NewConnManager(cfg) - srv := NewRegistrarCService(cfg, cls, connMngr, anz, srvDep) - srvMngr.AddServices(srv, - NewLoaderService(cfg, db, filterSChan, cls, - make(chan birpc.ClientConnector, 1), nil, anz, srvDep), db) - ctx, cancel := context.WithCancel(context.TODO()) - srvMngr.StartServices(ctx, cancel) - if srv.IsRunning() { - t.Errorf("Expected service to be down") - } - - cfgPath := t.TempDir() - filePath := filepath.Join(cfgPath, "cgrates.json") - if err := os.WriteFile(filePath, []byte(`{ -"general": { - "node_id": "ALL" -}, -"listen": { - "rpc_json": ":6012", - "rpc_gob": ":6013", - "http": ":6080" -}, -"rpc_conns": { - "dispConn": { - "strategy": "*first", - "conns": [{ - "address": "http://127.0.0.1:2080/registrar", - "transport": "*http_jsonrpc" - }] - } -}, -"registrarc": { - "dispatchers": { - "enabled": true, - "registrars_conns": ["dispConn"], - "hosts": [{ - "Tenant": "*default", - "ID": "hostB", - "transport": "*json", - "tls": false - }], - "refresh_interval": "1s" - } -} -}`), 0644); err != nil { - t.Fatal(err) - } - - var reply string - cfg.ConfigPath = cfgPath - if err := cfg.V1ReloadConfig(context.Background(), &config.ReloadArgs{ - Section: config.RegistrarCJSON, - }, &reply); err != nil { - t.Fatal(err) - } else if reply != utils.OK { - t.Errorf("Expecting OK ,received %s", reply) - } - runtime.Gosched() - runtime.Gosched() - time.Sleep(10 * time.Millisecond) //need to switch to gorutine - if !srv.IsRunning() { - t.Errorf("Expected service to be running") - } - err := srv.Start(ctx, cancel) - if err == nil || err != utils.ErrServiceAlreadyRunning { - t.Errorf("\nExpecting <%+v>,\n Received <%+v>", utils.ErrServiceAlreadyRunning, err) - } - err = srv.Reload(ctx, cancel) - if err != nil { - t.Errorf("\nExpecting ,\n Received <%+v>", err) - } - cfg.RegistrarCCfg().Dispatchers.RegistrarSConns = []string{} - cfg.GetReloadChan() <- config.SectionToService[config.RegistrarCJSON] - time.Sleep(10 * time.Millisecond) - if srv.IsRunning() { - t.Errorf("Expected service to be down") - } - cancel() - time.Sleep(10 * time.Millisecond) -} +// import ( +// "os" +// "path/filepath" +// "runtime" +// "sync" +// "testing" +// "time" +// +// "github.com/cgrates/birpc" +// "github.com/cgrates/birpc/context" +// "github.com/cgrates/cgrates/commonlisteners" +// "github.com/cgrates/cgrates/config" +// "github.com/cgrates/cgrates/engine" +// "github.com/cgrates/cgrates/servmanager" +// "github.com/cgrates/cgrates/utils" +// "github.com/cgrates/rpcclient" +// ) +// +// func TestDispatcherHReload(t *testing.T) { +// cfg := config.NewDefaultCGRConfig() +// cfg.RPCConns()["dispConn"] = &config.RPCConn{ +// Strategy: rpcclient.PoolFirst, +// Conns: []*config.RemoteHost{{ +// Address: "http://127.0.0.1:2080/dispatchers_registrar", +// Transport: rpcclient.HTTPjson, +// }}, +// } +// shdWg := new(sync.WaitGroup) +// filterSChan := make(chan *engine.FilterS, 1) +// filterSChan <- nil +// cls := commonlisteners.NewCommonListenerS(nil) +// srvMngr := servmanager.NewServiceManager(shdWg, nil, cfg) +// srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} +// db := NewDataDBService(cfg, nil, false, srvDep) +// anz := NewAnalyzerService(cfg, cls, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) +// connMngr := engine.NewConnManager(cfg) +// srv := NewRegistrarCService(cfg, cls, connMngr, anz, srvDep) +// srvMngr.AddServices(srv, +// NewLoaderService(cfg, db, filterSChan, cls, +// make(chan birpc.ClientConnector, 1), nil, anz, srvDep), db) +// ctx, cancel := context.WithCancel(context.TODO()) +// srvMngr.StartServices(ctx, cancel) +// if srv.IsRunning() { +// t.Errorf("Expected service to be down") +// } +// +// cfgPath := t.TempDir() +// filePath := filepath.Join(cfgPath, "cgrates.json") +// if err := os.WriteFile(filePath, []byte(`{ +// "general": { +// "node_id": "ALL" +// }, +// "listen": { +// "rpc_json": ":6012", +// "rpc_gob": ":6013", +// "http": ":6080" +// }, +// "rpc_conns": { +// "dispConn": { +// "strategy": "*first", +// "conns": [{ +// "address": "http://127.0.0.1:2080/registrar", +// "transport": "*http_jsonrpc" +// }] +// } +// }, +// "registrarc": { +// "dispatchers": { +// "enabled": true, +// "registrars_conns": ["dispConn"], +// "hosts": [{ +// "Tenant": "*default", +// "ID": "hostB", +// "transport": "*json", +// "tls": false +// }], +// "refresh_interval": "1s" +// } +// } +// }`), 0644); err != nil { +// t.Fatal(err) +// } +// +// var reply string +// cfg.ConfigPath = cfgPath +// if err := cfg.V1ReloadConfig(context.Background(), &config.ReloadArgs{ +// Section: config.RegistrarCJSON, +// }, &reply); err != nil { +// t.Fatal(err) +// } else if reply != utils.OK { +// t.Errorf("Expecting OK ,received %s", reply) +// } +// runtime.Gosched() +// runtime.Gosched() +// time.Sleep(10 * time.Millisecond) //need to switch to gorutine +// if !srv.IsRunning() { +// t.Errorf("Expected service to be running") +// } +// err := srv.Start(ctx, cancel) +// if err == nil || err != utils.ErrServiceAlreadyRunning { +// t.Errorf("\nExpecting <%+v>,\n Received <%+v>", utils.ErrServiceAlreadyRunning, err) +// } +// err = srv.Reload(ctx, cancel) +// if err != nil { +// t.Errorf("\nExpecting ,\n Received <%+v>", err) +// } +// cfg.RegistrarCCfg().Dispatchers.RegistrarSConns = []string{} +// cfg.GetReloadChan() <- config.SectionToService[config.RegistrarCJSON] +// time.Sleep(10 * time.Millisecond) +// if srv.IsRunning() { +// t.Errorf("Expected service to be down") +// } +// cancel() +// time.Sleep(10 * time.Millisecond) +// } diff --git a/services/registrarc_test.go b/services/registrarc_test.go index 9fabdd7a0..0af3f8a89 100644 --- a/services/registrarc_test.go +++ b/services/registrarc_test.go @@ -17,65 +17,65 @@ along with this program. If not, see */ package services -import ( - "reflect" - "sync" - "testing" - - "github.com/cgrates/birpc" - "github.com/cgrates/cgrates/commonlisteners" - "github.com/cgrates/cgrates/config" - "github.com/cgrates/cgrates/engine" - "github.com/cgrates/cgrates/registrarc" - "github.com/cgrates/cgrates/utils" -) - -// TestDispatcherCoverage for cover testing -func TestDispatcherHCoverage(t *testing.T) { - cfg := config.NewDefaultCGRConfig() - filterSChan := make(chan *engine.FilterS, 1) - filterSChan <- nil - cls := commonlisteners.NewCommonListenerS(nil) - srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} - anz := NewAnalyzerService(cfg, cls, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) - cM := engine.NewConnManager(cfg) - srv := NewRegistrarCService(cfg, cls, cM, anz, srvDep) - if srv == nil { - t.Errorf("\nExpecting ,\n Received <%+v>", utils.ToJSON(srv)) - } - srv2 := &RegistrarCService{ - cfg: cfg, - server: cls, - connMgr: cM, - anz: anz, - srvDep: srvDep, - } - if srv2.IsRunning() { - t.Errorf("Expected service to be down") - } - srv2.dspS = ®istrarc.RegistrarCService{} - if !srv2.IsRunning() { - t.Errorf("Expected service to be running") - } - - serviceName := srv2.ServiceName() - if !reflect.DeepEqual(serviceName, utils.RegistrarC) { - t.Errorf("\nExpecting <%+v>,\n Received <%+v>", utils.RegistrarC, serviceName) - } - shouldRun := srv2.ShouldRun() - if !reflect.DeepEqual(shouldRun, false) { - t.Errorf("\nExpecting ,\n Received <%+v>", shouldRun) - } - if !srv2.IsRunning() { - t.Errorf("Expected service to be running") - } - srv2.stopChan = make(chan struct{}, 1) - srv2.dspS = registrarc.NewRegistrarCService(cfg, cM) - shutdownSrv := srv2.Shutdown() - if shutdownSrv != nil { - t.Errorf("\nExpecting ,\n Received <%+v>", shutdownSrv) - } - if srv2.IsRunning() { - t.Errorf("Expected service to be down") - } -} +// import ( +// "reflect" +// "sync" +// "testing" +// +// "github.com/cgrates/birpc" +// "github.com/cgrates/cgrates/commonlisteners" +// "github.com/cgrates/cgrates/config" +// "github.com/cgrates/cgrates/engine" +// "github.com/cgrates/cgrates/registrarc" +// "github.com/cgrates/cgrates/utils" +// ) +// +// // TestDispatcherCoverage for cover testing +// func TestDispatcherHCoverage(t *testing.T) { +// cfg := config.NewDefaultCGRConfig() +// filterSChan := make(chan *engine.FilterS, 1) +// filterSChan <- nil +// cls := commonlisteners.NewCommonListenerS(nil) +// srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} +// anz := NewAnalyzerService(cfg, cls, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) +// cM := engine.NewConnManager(cfg) +// srv := NewRegistrarCService(cfg, cls, cM, anz, srvDep) +// if srv == nil { +// t.Errorf("\nExpecting ,\n Received <%+v>", utils.ToJSON(srv)) +// } +// srv2 := &RegistrarCService{ +// cfg: cfg, +// server: cls, +// connMgr: cM, +// anz: anz, +// srvDep: srvDep, +// } +// if srv2.IsRunning() { +// t.Errorf("Expected service to be down") +// } +// srv2.dspS = ®istrarc.RegistrarCService{} +// if !srv2.IsRunning() { +// t.Errorf("Expected service to be running") +// } +// +// serviceName := srv2.ServiceName() +// if !reflect.DeepEqual(serviceName, utils.RegistrarC) { +// t.Errorf("\nExpecting <%+v>,\n Received <%+v>", utils.RegistrarC, serviceName) +// } +// shouldRun := srv2.ShouldRun() +// if !reflect.DeepEqual(shouldRun, false) { +// t.Errorf("\nExpecting ,\n Received <%+v>", shouldRun) +// } +// if !srv2.IsRunning() { +// t.Errorf("Expected service to be running") +// } +// srv2.stopChan = make(chan struct{}, 1) +// srv2.dspS = registrarc.NewRegistrarCService(cfg, cM) +// shutdownSrv := srv2.Shutdown() +// if shutdownSrv != nil { +// t.Errorf("\nExpecting ,\n Received <%+v>", shutdownSrv) +// } +// if srv2.IsRunning() { +// t.Errorf("Expected service to be down") +// } +// } diff --git a/services/resources_it_test.go b/services/resources_it_test.go index 421cc895a..50c991f0a 100644 --- a/services/resources_it_test.go +++ b/services/resources_it_test.go @@ -20,90 +20,90 @@ along with this program. If not, see */ package services -import ( - "path" - "runtime" - "sync" - "testing" - "time" - - "github.com/cgrates/birpc" - "github.com/cgrates/birpc/context" - "github.com/cgrates/cgrates/commonlisteners" - "github.com/cgrates/cgrates/config" - "github.com/cgrates/cgrates/engine" - "github.com/cgrates/cgrates/servmanager" - "github.com/cgrates/cgrates/utils" -) - -func TestResourceSReload(t *testing.T) { - // utils.Logger.SetLogLevel(7) - cfg := config.NewDefaultCGRConfig() - - cfg.ThresholdSCfg().Enabled = true - filterSChan := make(chan *engine.FilterS, 1) - filterSChan <- nil - shdWg := new(sync.WaitGroup) - chS := engine.NewCacheS(cfg, nil, nil, nil) - close(chS.GetPrecacheChannel(utils.CacheThresholdProfiles)) - close(chS.GetPrecacheChannel(utils.CacheThresholds)) - close(chS.GetPrecacheChannel(utils.CacheThresholdFilterIndexes)) - close(chS.GetPrecacheChannel(utils.CacheResourceProfiles)) - close(chS.GetPrecacheChannel(utils.CacheResources)) - close(chS.GetPrecacheChannel(utils.CacheResourceFilterIndexes)) - chSCh := make(chan *engine.CacheS, 1) - chSCh <- chS - css := &CacheService{cacheCh: chSCh} - cls := commonlisteners.NewCommonListenerS(nil) - srvMngr := servmanager.NewServiceManager(shdWg, nil, cfg) - srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} - anz := NewAnalyzerService(cfg, cls, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) - db := NewDataDBService(cfg, nil, false, srvDep) - tS := NewThresholdService(cfg, db, css, filterSChan, nil, cls, make(chan birpc.ClientConnector, 1), anz, srvDep) - reS := NewResourceService(cfg, db, css, filterSChan, cls, make(chan birpc.ClientConnector, 1), nil, anz, srvDep) - engine.NewConnManager(cfg) - srvMngr.AddServices(tS, reS, - NewLoaderService(cfg, db, filterSChan, cls, make(chan birpc.ClientConnector, 1), nil, anz, srvDep), db) - ctx, cancel := context.WithCancel(context.TODO()) - srvMngr.StartServices(ctx, cancel) - if reS.IsRunning() { - t.Errorf("Expected service to be down") - } - if db.IsRunning() { - t.Errorf("Expected service to be down") - } - var reply string - cfg.ConfigPath = path.Join("/usr", "share", "cgrates", "conf", "samples", "tutmongo") - if err := cfg.V1ReloadConfig(context.Background(), &config.ReloadArgs{ - Section: config.ResourceSJSON, - }, &reply); err != nil { - t.Error(err) - } else if reply != utils.OK { - t.Errorf("Expecting OK ,received %s", reply) - } - runtime.Gosched() - runtime.Gosched() - time.Sleep(10 * time.Millisecond) //need to switch to gorutine - if !reS.IsRunning() { - t.Errorf("Expected service to be running") - } - if !db.IsRunning() { - t.Errorf("Expected service to be running") - } - err := reS.Start(ctx, cancel) - if err == nil || err != utils.ErrServiceAlreadyRunning { - t.Errorf("\nExpecting <%+v>,\n Received <%+v>", utils.ErrServiceAlreadyRunning, err) - } - err = reS.Reload(ctx, cancel) - if err != nil { - t.Errorf("\nExpecting ,\n Received <%+v>", err) - } - cfg.ResourceSCfg().Enabled = false - cfg.GetReloadChan() <- config.SectionToService[config.ResourceSJSON] - time.Sleep(10 * time.Millisecond) - if reS.IsRunning() { - t.Errorf("Expected service to be down") - } - cancel() - time.Sleep(10 * time.Millisecond) -} +// import ( +// "path" +// "runtime" +// "sync" +// "testing" +// "time" +// +// "github.com/cgrates/birpc" +// "github.com/cgrates/birpc/context" +// "github.com/cgrates/cgrates/commonlisteners" +// "github.com/cgrates/cgrates/config" +// "github.com/cgrates/cgrates/engine" +// "github.com/cgrates/cgrates/servmanager" +// "github.com/cgrates/cgrates/utils" +// ) +// +// func TestResourceSReload(t *testing.T) { +// // utils.Logger.SetLogLevel(7) +// cfg := config.NewDefaultCGRConfig() +// +// cfg.ThresholdSCfg().Enabled = true +// filterSChan := make(chan *engine.FilterS, 1) +// filterSChan <- nil +// shdWg := new(sync.WaitGroup) +// chS := engine.NewCacheS(cfg, nil, nil, nil) +// close(chS.GetPrecacheChannel(utils.CacheThresholdProfiles)) +// close(chS.GetPrecacheChannel(utils.CacheThresholds)) +// close(chS.GetPrecacheChannel(utils.CacheThresholdFilterIndexes)) +// close(chS.GetPrecacheChannel(utils.CacheResourceProfiles)) +// close(chS.GetPrecacheChannel(utils.CacheResources)) +// close(chS.GetPrecacheChannel(utils.CacheResourceFilterIndexes)) +// chSCh := make(chan *engine.CacheS, 1) +// chSCh <- chS +// css := &CacheService{cacheCh: chSCh} +// cls := commonlisteners.NewCommonListenerS(nil) +// srvMngr := servmanager.NewServiceManager(shdWg, nil, cfg) +// srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} +// anz := NewAnalyzerService(cfg, cls, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) +// db := NewDataDBService(cfg, nil, false, srvDep) +// tS := NewThresholdService(cfg, db, css, filterSChan, nil, cls, make(chan birpc.ClientConnector, 1), anz, srvDep) +// reS := NewResourceService(cfg, db, css, filterSChan, cls, make(chan birpc.ClientConnector, 1), nil, anz, srvDep) +// engine.NewConnManager(cfg) +// srvMngr.AddServices(tS, reS, +// NewLoaderService(cfg, db, filterSChan, cls, make(chan birpc.ClientConnector, 1), nil, anz, srvDep), db) +// ctx, cancel := context.WithCancel(context.TODO()) +// srvMngr.StartServices(ctx, cancel) +// if reS.IsRunning() { +// t.Errorf("Expected service to be down") +// } +// if db.IsRunning() { +// t.Errorf("Expected service to be down") +// } +// var reply string +// cfg.ConfigPath = path.Join("/usr", "share", "cgrates", "conf", "samples", "tutmongo") +// if err := cfg.V1ReloadConfig(context.Background(), &config.ReloadArgs{ +// Section: config.ResourceSJSON, +// }, &reply); err != nil { +// t.Error(err) +// } else if reply != utils.OK { +// t.Errorf("Expecting OK ,received %s", reply) +// } +// runtime.Gosched() +// runtime.Gosched() +// time.Sleep(10 * time.Millisecond) //need to switch to gorutine +// if !reS.IsRunning() { +// t.Errorf("Expected service to be running") +// } +// if !db.IsRunning() { +// t.Errorf("Expected service to be running") +// } +// err := reS.Start(ctx, cancel) +// if err == nil || err != utils.ErrServiceAlreadyRunning { +// t.Errorf("\nExpecting <%+v>,\n Received <%+v>", utils.ErrServiceAlreadyRunning, err) +// } +// err = reS.Reload(ctx, cancel) +// if err != nil { +// t.Errorf("\nExpecting ,\n Received <%+v>", err) +// } +// cfg.ResourceSCfg().Enabled = false +// cfg.GetReloadChan() <- config.SectionToService[config.ResourceSJSON] +// time.Sleep(10 * time.Millisecond) +// if reS.IsRunning() { +// t.Errorf("Expected service to be down") +// } +// cancel() +// time.Sleep(10 * time.Millisecond) +// } diff --git a/services/resources_test.go b/services/resources_test.go index a8a70f4bc..0b9cd424a 100644 --- a/services/resources_test.go +++ b/services/resources_test.go @@ -17,56 +17,56 @@ along with this program. If not, see */ package services -import ( - "reflect" - "sync" - "testing" - - "github.com/cgrates/birpc" - "github.com/cgrates/birpc/context" - "github.com/cgrates/cgrates/commonlisteners" - "github.com/cgrates/cgrates/config" - "github.com/cgrates/cgrates/engine" - "github.com/cgrates/cgrates/utils" -) - -// TestResourceSCoverage for cover testing -func TestResourceSCoverage(t *testing.T) { - cfg := config.NewDefaultCGRConfig() - cfg.ThresholdSCfg().Enabled = true - filterSChan := make(chan *engine.FilterS, 1) - filterSChan <- nil - cls := commonlisteners.NewCommonListenerS(nil) - srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} - anz := NewAnalyzerService(cfg, cls, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) - db := NewDataDBService(cfg, nil, false, srvDep) - chS := NewCacheService(cfg, db, nil, cls, make(chan context.ClientConnector, 1), anz, nil, srvDep) - reS := NewResourceService(cfg, db, chS, filterSChan, cls, make(chan birpc.ClientConnector, 1), nil, anz, srvDep) - - if reS.IsRunning() { - t.Errorf("Expected service to be down") - } - reS2 := ResourceService{ - cfg: cfg, - dm: db, - cacheS: chS, - filterSChan: filterSChan, - cls: cls, - connChan: make(chan birpc.ClientConnector, 1), - connMgr: nil, - anz: anz, - srvDep: srvDep, - reS: &engine.ResourceS{}, - } - if !reS2.IsRunning() { - t.Errorf("Expected service to be running") - } - serviceName := reS2.ServiceName() - if !reflect.DeepEqual(serviceName, utils.ResourceS) { - t.Errorf("\nExpecting <%+v>,\n Received <%+v>", utils.ResourceS, serviceName) - } - shouldRun := reS2.ShouldRun() - if !reflect.DeepEqual(shouldRun, false) { - t.Errorf("\nExpecting ,\n Received <%+v>", shouldRun) - } -} +// import ( +// "reflect" +// "sync" +// "testing" +// +// "github.com/cgrates/birpc" +// "github.com/cgrates/birpc/context" +// "github.com/cgrates/cgrates/commonlisteners" +// "github.com/cgrates/cgrates/config" +// "github.com/cgrates/cgrates/engine" +// "github.com/cgrates/cgrates/utils" +// ) +// +// // TestResourceSCoverage for cover testing +// func TestResourceSCoverage(t *testing.T) { +// cfg := config.NewDefaultCGRConfig() +// cfg.ThresholdSCfg().Enabled = true +// filterSChan := make(chan *engine.FilterS, 1) +// filterSChan <- nil +// cls := commonlisteners.NewCommonListenerS(nil) +// srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} +// anz := NewAnalyzerService(cfg, cls, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) +// db := NewDataDBService(cfg, nil, false, srvDep) +// chS := NewCacheService(cfg, db, nil, cls, make(chan context.ClientConnector, 1), anz, nil, srvDep) +// reS := NewResourceService(cfg, db, chS, filterSChan, cls, make(chan birpc.ClientConnector, 1), nil, anz, srvDep) +// +// if reS.IsRunning() { +// t.Errorf("Expected service to be down") +// } +// reS2 := ResourceService{ +// cfg: cfg, +// dm: db, +// cacheS: chS, +// filterSChan: filterSChan, +// cls: cls, +// connChan: make(chan birpc.ClientConnector, 1), +// connMgr: nil, +// anz: anz, +// srvDep: srvDep, +// reS: &engine.ResourceS{}, +// } +// if !reS2.IsRunning() { +// t.Errorf("Expected service to be running") +// } +// serviceName := reS2.ServiceName() +// if !reflect.DeepEqual(serviceName, utils.ResourceS) { +// t.Errorf("\nExpecting <%+v>,\n Received <%+v>", utils.ResourceS, serviceName) +// } +// shouldRun := reS2.ShouldRun() +// if !reflect.DeepEqual(shouldRun, false) { +// t.Errorf("\nExpecting ,\n Received <%+v>", shouldRun) +// } +// } diff --git a/services/routes_it_test.go b/services/routes_it_test.go index 59aee181f..f0cf4ef2f 100644 --- a/services/routes_it_test.go +++ b/services/routes_it_test.go @@ -20,85 +20,85 @@ along with this program. If not, see */ package services -import ( - "path" - "runtime" - "sync" - "testing" - "time" - - "github.com/cgrates/birpc" - "github.com/cgrates/birpc/context" - "github.com/cgrates/cgrates/commonlisteners" - "github.com/cgrates/cgrates/config" - "github.com/cgrates/cgrates/engine" - "github.com/cgrates/cgrates/servmanager" - "github.com/cgrates/cgrates/utils" -) - -func TestRouteSReload(t *testing.T) { - // utils.Logger.SetLogLevel(7) - cfg := config.NewDefaultCGRConfig() - - filterSChan := make(chan *engine.FilterS, 1) - filterSChan <- nil - shdWg := new(sync.WaitGroup) - chS := engine.NewCacheS(cfg, nil, nil, nil) - close(chS.GetPrecacheChannel(utils.CacheRouteProfiles)) - close(chS.GetPrecacheChannel(utils.CacheRouteFilterIndexes)) - chSCh := make(chan *engine.CacheS, 1) - chSCh <- chS - css := &CacheService{cacheCh: chSCh} - cls := commonlisteners.NewCommonListenerS(nil) - srvMngr := servmanager.NewServiceManager(shdWg, nil, cfg) - srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} - anz := NewAnalyzerService(cfg, cls, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) - db := NewDataDBService(cfg, nil, false, srvDep) - routeS := NewRouteService(cfg, db, css, filterSChan, cls, make(chan birpc.ClientConnector, 1), nil, anz, srvDep) - engine.NewConnManager(cfg) - srvMngr.AddServices(routeS, - NewLoaderService(cfg, db, filterSChan, cls, make(chan birpc.ClientConnector, 1), nil, anz, srvDep), db) - ctx, cancel := context.WithCancel(context.TODO()) - srvMngr.StartServices(ctx, cancel) - if routeS.IsRunning() { - t.Errorf("Expected service to be down") - } - if db.IsRunning() { - t.Errorf("Expected service to be down") - } - var reply string - cfg.ConfigPath = path.Join("/usr", "share", "cgrates", "conf", "samples", "cluelrn") - if err := cfg.V1ReloadConfig(context.Background(), &config.ReloadArgs{ - Section: config.RouteSJSON, - }, &reply); err != nil { - t.Error(err) - } else if reply != utils.OK { - t.Errorf("Expecting OK ,received %s", reply) - } - runtime.Gosched() - runtime.Gosched() - time.Sleep(10 * time.Millisecond) //need to switch to gorutine - if !routeS.IsRunning() { - t.Fatalf("Expected service to be running") - } - if !db.IsRunning() { - t.Errorf("Expected service to be running") - } - - err := routeS.Start(ctx, cancel) - if err == nil || err != utils.ErrServiceAlreadyRunning { - t.Errorf("\nExpecting <%+v>,\n Received <%+v>", utils.ErrServiceAlreadyRunning, err) - } - err = routeS.Reload(ctx, cancel) - if err != nil { - t.Errorf("\nExpecting ,\n Received <%+v>", err) - } - cfg.RouteSCfg().Enabled = false - cfg.GetReloadChan() <- config.SectionToService[config.RouteSJSON] - time.Sleep(10 * time.Millisecond) - if routeS.IsRunning() { - t.Errorf("Expected service to be down") - } - cancel() - time.Sleep(10 * time.Millisecond) -} +// import ( +// "path" +// "runtime" +// "sync" +// "testing" +// "time" +// +// "github.com/cgrates/birpc" +// "github.com/cgrates/birpc/context" +// "github.com/cgrates/cgrates/commonlisteners" +// "github.com/cgrates/cgrates/config" +// "github.com/cgrates/cgrates/engine" +// "github.com/cgrates/cgrates/servmanager" +// "github.com/cgrates/cgrates/utils" +// ) +// +// func TestRouteSReload(t *testing.T) { +// // utils.Logger.SetLogLevel(7) +// cfg := config.NewDefaultCGRConfig() +// +// filterSChan := make(chan *engine.FilterS, 1) +// filterSChan <- nil +// shdWg := new(sync.WaitGroup) +// chS := engine.NewCacheS(cfg, nil, nil, nil) +// close(chS.GetPrecacheChannel(utils.CacheRouteProfiles)) +// close(chS.GetPrecacheChannel(utils.CacheRouteFilterIndexes)) +// chSCh := make(chan *engine.CacheS, 1) +// chSCh <- chS +// css := &CacheService{cacheCh: chSCh} +// cls := commonlisteners.NewCommonListenerS(nil) +// srvMngr := servmanager.NewServiceManager(shdWg, nil, cfg) +// srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} +// anz := NewAnalyzerService(cfg, cls, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) +// db := NewDataDBService(cfg, nil, false, srvDep) +// routeS := NewRouteService(cfg, db, css, filterSChan, cls, make(chan birpc.ClientConnector, 1), nil, anz, srvDep) +// engine.NewConnManager(cfg) +// srvMngr.AddServices(routeS, +// NewLoaderService(cfg, db, filterSChan, cls, make(chan birpc.ClientConnector, 1), nil, anz, srvDep), db) +// ctx, cancel := context.WithCancel(context.TODO()) +// srvMngr.StartServices(ctx, cancel) +// if routeS.IsRunning() { +// t.Errorf("Expected service to be down") +// } +// if db.IsRunning() { +// t.Errorf("Expected service to be down") +// } +// var reply string +// cfg.ConfigPath = path.Join("/usr", "share", "cgrates", "conf", "samples", "cluelrn") +// if err := cfg.V1ReloadConfig(context.Background(), &config.ReloadArgs{ +// Section: config.RouteSJSON, +// }, &reply); err != nil { +// t.Error(err) +// } else if reply != utils.OK { +// t.Errorf("Expecting OK ,received %s", reply) +// } +// runtime.Gosched() +// runtime.Gosched() +// time.Sleep(10 * time.Millisecond) //need to switch to gorutine +// if !routeS.IsRunning() { +// t.Fatalf("Expected service to be running") +// } +// if !db.IsRunning() { +// t.Errorf("Expected service to be running") +// } +// +// err := routeS.Start(ctx, cancel) +// if err == nil || err != utils.ErrServiceAlreadyRunning { +// t.Errorf("\nExpecting <%+v>,\n Received <%+v>", utils.ErrServiceAlreadyRunning, err) +// } +// err = routeS.Reload(ctx, cancel) +// if err != nil { +// t.Errorf("\nExpecting ,\n Received <%+v>", err) +// } +// cfg.RouteSCfg().Enabled = false +// cfg.GetReloadChan() <- config.SectionToService[config.RouteSJSON] +// time.Sleep(10 * time.Millisecond) +// if routeS.IsRunning() { +// t.Errorf("Expected service to be down") +// } +// cancel() +// time.Sleep(10 * time.Millisecond) +// } diff --git a/services/routes_test.go b/services/routes_test.go index cbcae6512..b95277ec5 100644 --- a/services/routes_test.go +++ b/services/routes_test.go @@ -15,64 +15,65 @@ 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 services -import ( - "reflect" - "sync" - "testing" - - "github.com/cgrates/birpc" - "github.com/cgrates/birpc/context" - "github.com/cgrates/cgrates/commonlisteners" - "github.com/cgrates/cgrates/config" - "github.com/cgrates/cgrates/engine" - "github.com/cgrates/cgrates/utils" -) - -// TestSupplierSCoverage for cover testing -func TestSupplierSCoverage(t *testing.T) { - cfg := config.NewDefaultCGRConfig() - cfg.StatSCfg().Enabled = true - filterSChan := make(chan *engine.FilterS, 1) - filterSChan <- nil - cls := commonlisteners.NewCommonListenerS(nil) - srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} - db := NewDataDBService(cfg, nil, false, srvDep) - anz := NewAnalyzerService(cfg, cls, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) - chS := NewCacheService(cfg, db, nil, cls, make(chan context.ClientConnector, 1), anz, nil, srvDep) - supS := NewRouteService(cfg, db, chS, filterSChan, cls, make(chan birpc.ClientConnector, 1), nil, anz, srvDep) - - if supS.IsRunning() { - t.Errorf("Expected service to be down") - } - supS2 := &RouteService{ - cfg: cfg, - dm: db, - cacheS: chS, - filterSChan: filterSChan, - cls: cls, - connMgr: nil, - routeS: &engine.RouteS{}, - // rpc: nil, - connChan: make(chan birpc.ClientConnector, 1), - anz: anz, - srvDep: srvDep, - } - if !supS2.IsRunning() { - t.Errorf("Expected service to be running") - } - serviceName := supS2.ServiceName() - if !reflect.DeepEqual(serviceName, utils.RouteS) { - t.Errorf("\nExpecting <%+v>,\n Received <%+v>", utils.RouteS, serviceName) - } - shouldRun := supS2.ShouldRun() - if !reflect.DeepEqual(shouldRun, false) { - t.Errorf("\nExpecting ,\n Received <%+v>", shouldRun) - } - supS2.connChan <- &testMockClients{} - supS2.Shutdown() - if supS.IsRunning() { - t.Errorf("Expected service to be down") - } -} +// import ( +// "reflect" +// "sync" +// "testing" +// +// "github.com/cgrates/birpc" +// "github.com/cgrates/birpc/context" +// "github.com/cgrates/cgrates/commonlisteners" +// "github.com/cgrates/cgrates/config" +// "github.com/cgrates/cgrates/engine" +// "github.com/cgrates/cgrates/utils" +// ) +// +// // TestSupplierSCoverage for cover testing +// func TestSupplierSCoverage(t *testing.T) { +// cfg := config.NewDefaultCGRConfig() +// cfg.StatSCfg().Enabled = true +// filterSChan := make(chan *engine.FilterS, 1) +// filterSChan <- nil +// cls := commonlisteners.NewCommonListenerS(nil) +// srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} +// db := NewDataDBService(cfg, nil, false, srvDep) +// anz := NewAnalyzerService(cfg, cls, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) +// chS := NewCacheService(cfg, db, nil, cls, make(chan context.ClientConnector, 1), anz, nil, srvDep) +// supS := NewRouteService(cfg, db, chS, filterSChan, cls, make(chan birpc.ClientConnector, 1), nil, anz, srvDep) +// +// if supS.IsRunning() { +// t.Errorf("Expected service to be down") +// } +// supS2 := &RouteService{ +// cfg: cfg, +// dm: db, +// cacheS: chS, +// filterSChan: filterSChan, +// cls: cls, +// connMgr: nil, +// routeS: &engine.RouteS{}, +// // rpc: nil, +// connChan: make(chan birpc.ClientConnector, 1), +// anz: anz, +// srvDep: srvDep, +// } +// if !supS2.IsRunning() { +// t.Errorf("Expected service to be running") +// } +// serviceName := supS2.ServiceName() +// if !reflect.DeepEqual(serviceName, utils.RouteS) { +// t.Errorf("\nExpecting <%+v>,\n Received <%+v>", utils.RouteS, serviceName) +// } +// shouldRun := supS2.ShouldRun() +// if !reflect.DeepEqual(shouldRun, false) { +// t.Errorf("\nExpecting ,\n Received <%+v>", shouldRun) +// } +// supS2.connChan <- &testMockClients{} +// supS2.Shutdown() +// if supS.IsRunning() { +// t.Errorf("Expected service to be down") +// } +// } diff --git a/services/sessions_it_test.go b/services/sessions_it_test.go index ea32db369..b00d71433 100644 --- a/services/sessions_it_test.go +++ b/services/sessions_it_test.go @@ -20,196 +20,196 @@ along with this program. If not, see */ package services -import ( - "fmt" - "io" - "log" - "sync" - "testing" - "time" - - "github.com/cgrates/birpc" - "github.com/cgrates/birpc/context" - "github.com/cgrates/cgrates/commonlisteners" - "github.com/cgrates/cgrates/config" - "github.com/cgrates/cgrates/engine" - "github.com/cgrates/cgrates/sessions" - "github.com/cgrates/cgrates/utils" - "github.com/cgrates/rpcclient" -) - -func init() { - log.SetOutput(io.Discard) -} - -func TestSessionSReload1(t *testing.T) { - cfg := config.NewDefaultCGRConfig() - cfg.ChargerSCfg().Enabled = true - cfg.SessionSCfg().ChargerSConns = []string{utils.ConcatenatedKey(utils.MetaInternal, utils.MetaChargers)} - cfg.RPCConns()["cache1"] = &config.RPCConn{ - Strategy: rpcclient.PoolFirst, - Conns: []*config.RemoteHost{{ - Address: "127.0.0.1:9999", - Transport: utils.MetaGOB, - }}, - } - cfg.CacheCfg().ReplicationConns = []string{"cache1"} - cfg.CacheCfg().Partitions[utils.CacheClosedSessions].Limit = 0 - cfg.CacheCfg().Partitions[utils.CacheClosedSessions].Replicate = true - temporaryCache := engine.Cache - defer func() { - engine.Cache = temporaryCache - }() - engine.Cache = engine.NewCacheS(cfg, nil, nil, nil) - filterSChan := make(chan *engine.FilterS, 1) - filterSChan <- nil - cls := commonlisteners.NewCommonListenerS(nil) - srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} - - clientConect := make(chan birpc.ClientConnector, 1) - clientConect <- &testMockClients{ - calls: func(ctx *context.Context, args, reply any) error { - rply, cancast := reply.(*[]*engine.ChrgSProcessEventReply) - if !cancast { - return fmt.Errorf("can't cast") - } - *rply = []*engine.ChrgSProcessEventReply{ - { - ChargerSProfile: "raw", - AlteredFields: []*engine.FieldsAltered{ - { - MatchedProfileID: utils.MetaDefault, - Fields: []string{utils.MetaOptsRunID, utils.MetaOpts + utils.NestingSep + utils.MetaChargeID, utils.MetaOpts + utils.NestingSep + utils.MetaSubsys}, - }, - { - MatchedProfileID: utils.MetaNone, - Fields: []string{"~*req.RunID"}, - }, - }, - CGREvent: args.(*utils.CGREvent), - }, - } - return nil - }, - } - conMng := engine.NewConnManager(cfg) - conMng.AddInternalConn(utils.ConcatenatedKey(utils.MetaInternal, utils.MetaChargers), utils.ChargerSv1, clientConect) - anz := NewAnalyzerService(cfg, cls, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) - db := NewDataDBService(cfg, conMng, false, srvDep) - db.dbchan = make(chan *engine.DataManager, 1) - db.dbchan <- nil - srv := NewSessionService(cfg, db, filterSChan, cls, make(chan birpc.ClientConnector, 1), conMng, anz, srvDep) - ctx, cancel := context.WithCancel(context.TODO()) - err := srv.Start(ctx, cancel) - if err != nil { - t.Fatal(err) - } - if !srv.IsRunning() { - t.Fatal("Expected service to be running") - } - args := &utils.CGREvent{ - Tenant: "cgrates.org", - ID: "testSSv1ItProcessEventInitiateSession", - Event: map[string]any{ - utils.Tenant: "cgrates.org", - utils.ToR: utils.MetaVoice, - utils.OriginID: "testSSv1ItProcessEvent", - utils.RequestType: utils.MetaPostpaid, - utils.AccountField: "1001", - utils.CGRDebitInterval: 10, - utils.Destination: "1002", - utils.SetupTime: time.Date(2018, time.January, 7, 16, 60, 0, 0, time.UTC), - utils.AnswerTime: time.Date(2018, time.January, 7, 16, 60, 10, 0, time.UTC), - utils.Usage: 0, - }, - APIOpts: map[string]any{ - utils.MetaRunID: utils.MetaDefault, - utils.OptsSesInitiate: true, - utils.MetaThresholds: true, - }, - } - var rply sessions.V1InitSessionReply - ss := srv.(*SessionService) - if ss.sm == nil { - t.Fatal("sessions is nil") - } - ss.sm.BiRPCv1InitiateSession(context.Background(), args, &rply) - if err = srv.Shutdown(); err == nil || err != utils.ErrPartiallyExecuted { - t.Fatalf("\nExpecting <%+v>,\n Received <%+v>", utils.ErrPartiallyExecuted, err) - } -} - -func TestSessionSReload2(t *testing.T) { - cfg := config.NewDefaultCGRConfig() - - cfg.ChargerSCfg().Enabled = true - cfg.CdrsCfg().Enabled = true - filterSChan := make(chan *engine.FilterS, 1) - filterSChan <- nil - chS := engine.NewCacheS(cfg, nil, nil, nil) - close(chS.GetPrecacheChannel(utils.CacheChargerProfiles)) - close(chS.GetPrecacheChannel(utils.CacheChargerFilterIndexes)) - - internalChan := make(chan birpc.ClientConnector, 1) - internalChan <- nil - - cls := commonlisteners.NewCommonListenerS(nil) - - srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} - db := NewDataDBService(cfg, nil, false, srvDep) - anz := NewAnalyzerService(cfg, cls, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) - srv := NewSessionService(cfg, db, filterSChan, cls, make(chan birpc.ClientConnector, 1), nil, anz, srvDep) - engine.NewConnManager(cfg) - - srv.(*SessionService).sm = &sessions.SessionS{} - if !srv.IsRunning() { - t.Fatalf("\nExpecting service to be running") - } - ctx, cancel := context.WithCancel(context.TODO()) - err2 := srv.Start(ctx, cancel) - if err2 != utils.ErrServiceAlreadyRunning { - t.Fatalf("\nExpecting <%+v>,\n Received <%+v>", utils.ErrServiceAlreadyRunning, err2) - } - cfg.SessionSCfg().Enabled = false - err := srv.Reload(ctx, cancel) - if err != nil { - t.Fatalf("\nExpecting ,\n Received <%+v>", err) - } - time.Sleep(10 * time.Millisecond) - srv.(*SessionService).sm = nil - if srv.IsRunning() { - t.Fatalf("Expected service to be down") - } - cancel() - time.Sleep(10 * time.Millisecond) - -} - -func TestSessionSReload3(t *testing.T) { - cfg := config.NewDefaultCGRConfig() - - cfg.ChargerSCfg().Enabled = true - cfg.CdrsCfg().Enabled = true - filterSChan := make(chan *engine.FilterS, 1) - filterSChan <- nil - chS := engine.NewCacheS(cfg, nil, nil, nil) - close(chS.GetPrecacheChannel(utils.CacheChargerProfiles)) - close(chS.GetPrecacheChannel(utils.CacheChargerFilterIndexes)) - - internalChan := make(chan birpc.ClientConnector, 1) - internalChan <- nil - - cls := commonlisteners.NewCommonListenerS(nil) - - srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} - db := NewDataDBService(cfg, nil, false, srvDep) - - anz := NewAnalyzerService(cfg, cls, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) - srv := NewSessionService(cfg, db, filterSChan, cls, make(chan birpc.ClientConnector, 1), nil, anz, srvDep) - engine.NewConnManager(cfg) - err2 := srv.(*SessionService).start(func() {}) - if err2 != nil { - t.Fatalf("\nExpected <%+v>, \nReceived <%+v>", nil, err2) - } - -} +// import ( +// "fmt" +// "io" +// "log" +// "sync" +// "testing" +// "time" +// +// "github.com/cgrates/birpc" +// "github.com/cgrates/birpc/context" +// "github.com/cgrates/cgrates/commonlisteners" +// "github.com/cgrates/cgrates/config" +// "github.com/cgrates/cgrates/engine" +// "github.com/cgrates/cgrates/sessions" +// "github.com/cgrates/cgrates/utils" +// "github.com/cgrates/rpcclient" +// ) +// +// func init() { +// log.SetOutput(io.Discard) +// } +// +// func TestSessionSReload1(t *testing.T) { +// cfg := config.NewDefaultCGRConfig() +// cfg.ChargerSCfg().Enabled = true +// cfg.SessionSCfg().ChargerSConns = []string{utils.ConcatenatedKey(utils.MetaInternal, utils.MetaChargers)} +// cfg.RPCConns()["cache1"] = &config.RPCConn{ +// Strategy: rpcclient.PoolFirst, +// Conns: []*config.RemoteHost{{ +// Address: "127.0.0.1:9999", +// Transport: utils.MetaGOB, +// }}, +// } +// cfg.CacheCfg().ReplicationConns = []string{"cache1"} +// cfg.CacheCfg().Partitions[utils.CacheClosedSessions].Limit = 0 +// cfg.CacheCfg().Partitions[utils.CacheClosedSessions].Replicate = true +// temporaryCache := engine.Cache +// defer func() { +// engine.Cache = temporaryCache +// }() +// engine.Cache = engine.NewCacheS(cfg, nil, nil, nil) +// filterSChan := make(chan *engine.FilterS, 1) +// filterSChan <- nil +// cls := commonlisteners.NewCommonListenerS(nil) +// srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} +// +// clientConect := make(chan birpc.ClientConnector, 1) +// clientConect <- &testMockClients{ +// calls: func(ctx *context.Context, args, reply any) error { +// rply, cancast := reply.(*[]*engine.ChrgSProcessEventReply) +// if !cancast { +// return fmt.Errorf("can't cast") +// } +// *rply = []*engine.ChrgSProcessEventReply{ +// { +// ChargerSProfile: "raw", +// AlteredFields: []*engine.FieldsAltered{ +// { +// MatchedProfileID: utils.MetaDefault, +// Fields: []string{utils.MetaOptsRunID, utils.MetaOpts + utils.NestingSep + utils.MetaChargeID, utils.MetaOpts + utils.NestingSep + utils.MetaSubsys}, +// }, +// { +// MatchedProfileID: utils.MetaNone, +// Fields: []string{"~*req.RunID"}, +// }, +// }, +// CGREvent: args.(*utils.CGREvent), +// }, +// } +// return nil +// }, +// } +// conMng := engine.NewConnManager(cfg) +// conMng.AddInternalConn(utils.ConcatenatedKey(utils.MetaInternal, utils.MetaChargers), utils.ChargerSv1, clientConect) +// anz := NewAnalyzerService(cfg, cls, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) +// db := NewDataDBService(cfg, conMng, false, srvDep) +// db.dbchan = make(chan *engine.DataManager, 1) +// db.dbchan <- nil +// srv := NewSessionService(cfg, db, filterSChan, cls, make(chan birpc.ClientConnector, 1), conMng, anz, srvDep) +// ctx, cancel := context.WithCancel(context.TODO()) +// err := srv.Start(ctx, cancel) +// if err != nil { +// t.Fatal(err) +// } +// if !srv.IsRunning() { +// t.Fatal("Expected service to be running") +// } +// args := &utils.CGREvent{ +// Tenant: "cgrates.org", +// ID: "testSSv1ItProcessEventInitiateSession", +// Event: map[string]any{ +// utils.Tenant: "cgrates.org", +// utils.ToR: utils.MetaVoice, +// utils.OriginID: "testSSv1ItProcessEvent", +// utils.RequestType: utils.MetaPostpaid, +// utils.AccountField: "1001", +// utils.CGRDebitInterval: 10, +// utils.Destination: "1002", +// utils.SetupTime: time.Date(2018, time.January, 7, 16, 60, 0, 0, time.UTC), +// utils.AnswerTime: time.Date(2018, time.January, 7, 16, 60, 10, 0, time.UTC), +// utils.Usage: 0, +// }, +// APIOpts: map[string]any{ +// utils.MetaRunID: utils.MetaDefault, +// utils.OptsSesInitiate: true, +// utils.MetaThresholds: true, +// }, +// } +// var rply sessions.V1InitSessionReply +// ss := srv.(*SessionService) +// if ss.sm == nil { +// t.Fatal("sessions is nil") +// } +// ss.sm.BiRPCv1InitiateSession(context.Background(), args, &rply) +// if err = srv.Shutdown(); err == nil || err != utils.ErrPartiallyExecuted { +// t.Fatalf("\nExpecting <%+v>,\n Received <%+v>", utils.ErrPartiallyExecuted, err) +// } +// } +// +// func TestSessionSReload2(t *testing.T) { +// cfg := config.NewDefaultCGRConfig() +// +// cfg.ChargerSCfg().Enabled = true +// cfg.CdrsCfg().Enabled = true +// filterSChan := make(chan *engine.FilterS, 1) +// filterSChan <- nil +// chS := engine.NewCacheS(cfg, nil, nil, nil) +// close(chS.GetPrecacheChannel(utils.CacheChargerProfiles)) +// close(chS.GetPrecacheChannel(utils.CacheChargerFilterIndexes)) +// +// internalChan := make(chan birpc.ClientConnector, 1) +// internalChan <- nil +// +// cls := commonlisteners.NewCommonListenerS(nil) +// +// srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} +// db := NewDataDBService(cfg, nil, false, srvDep) +// anz := NewAnalyzerService(cfg, cls, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) +// srv := NewSessionService(cfg, db, filterSChan, cls, make(chan birpc.ClientConnector, 1), nil, anz, srvDep) +// engine.NewConnManager(cfg) +// +// srv.(*SessionService).sm = &sessions.SessionS{} +// if !srv.IsRunning() { +// t.Fatalf("\nExpecting service to be running") +// } +// ctx, cancel := context.WithCancel(context.TODO()) +// err2 := srv.Start(ctx, cancel) +// if err2 != utils.ErrServiceAlreadyRunning { +// t.Fatalf("\nExpecting <%+v>,\n Received <%+v>", utils.ErrServiceAlreadyRunning, err2) +// } +// cfg.SessionSCfg().Enabled = false +// err := srv.Reload(ctx, cancel) +// if err != nil { +// t.Fatalf("\nExpecting ,\n Received <%+v>", err) +// } +// time.Sleep(10 * time.Millisecond) +// srv.(*SessionService).sm = nil +// if srv.IsRunning() { +// t.Fatalf("Expected service to be down") +// } +// cancel() +// time.Sleep(10 * time.Millisecond) +// +// } +// +// func TestSessionSReload3(t *testing.T) { +// cfg := config.NewDefaultCGRConfig() +// +// cfg.ChargerSCfg().Enabled = true +// cfg.CdrsCfg().Enabled = true +// filterSChan := make(chan *engine.FilterS, 1) +// filterSChan <- nil +// chS := engine.NewCacheS(cfg, nil, nil, nil) +// close(chS.GetPrecacheChannel(utils.CacheChargerProfiles)) +// close(chS.GetPrecacheChannel(utils.CacheChargerFilterIndexes)) +// +// internalChan := make(chan birpc.ClientConnector, 1) +// internalChan <- nil +// +// cls := commonlisteners.NewCommonListenerS(nil) +// +// srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} +// db := NewDataDBService(cfg, nil, false, srvDep) +// +// anz := NewAnalyzerService(cfg, cls, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) +// srv := NewSessionService(cfg, db, filterSChan, cls, make(chan birpc.ClientConnector, 1), nil, anz, srvDep) +// engine.NewConnManager(cfg) +// err2 := srv.(*SessionService).start(func() {}) +// if err2 != nil { +// t.Fatalf("\nExpected <%+v>, \nReceived <%+v>", nil, err2) +// } +// +// } diff --git a/services/sessions_test.go b/services/sessions_test.go index 8fd259e9c..f9bf80860 100644 --- a/services/sessions_test.go +++ b/services/sessions_test.go @@ -17,64 +17,64 @@ along with this program. If not, see */ package services -import ( - "reflect" - "sync" - "testing" - - "github.com/cgrates/birpc" - "github.com/cgrates/birpc/context" - "github.com/cgrates/cgrates/commonlisteners" - "github.com/cgrates/cgrates/sessions" - - "github.com/cgrates/cgrates/config" - "github.com/cgrates/cgrates/engine" - "github.com/cgrates/cgrates/utils" -) - -type testMockClients struct { - calls func(_ *context.Context, _, _ any) error -} - -func (sT *testMockClients) Call(ctx *context.Context, method string, arg, rply any) error { - return sT.calls(ctx, arg, rply) -} - -// TestSessionSCoverage for cover testing -func TestSessionSCoverage(t *testing.T) { - cfg := config.NewDefaultCGRConfig() - cfg.ChargerSCfg().Enabled = true - cfg.CdrsCfg().Enabled = true - filterSChan := make(chan *engine.FilterS, 1) - filterSChan <- nil - cls := commonlisteners.NewCommonListenerS(nil) - srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} - db := NewDataDBService(cfg, nil, false, srvDep) - anz := NewAnalyzerService(cfg, cls, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) - srv := NewSessionService(cfg, db, nil, cls, make(chan birpc.ClientConnector, 1), nil, anz, srvDep) - engine.NewConnManager(cfg) - if srv.IsRunning() { - t.Errorf("Expected service to be down") - } - srv2 := SessionService{ - cfg: cfg, - dm: db, - cls: cls, - connChan: make(chan birpc.ClientConnector, 1), - connMgr: nil, - anz: anz, - srvDep: srvDep, - sm: &sessions.SessionS{}, - } - if !srv2.IsRunning() { - t.Errorf("Expected service to be running") - } - serviceName := srv2.ServiceName() - if !reflect.DeepEqual(serviceName, utils.SessionS) { - t.Errorf("\nExpecting <%+v>,\n Received <%+v>", utils.SessionS, serviceName) - } - shouldRun := srv2.ShouldRun() - if !reflect.DeepEqual(shouldRun, false) { - t.Errorf("\nExpecting ,\n Received <%+v>", shouldRun) - } -} +// import ( +// "reflect" +// "sync" +// "testing" +// +// "github.com/cgrates/birpc" +// "github.com/cgrates/birpc/context" +// "github.com/cgrates/cgrates/commonlisteners" +// "github.com/cgrates/cgrates/sessions" +// +// "github.com/cgrates/cgrates/config" +// "github.com/cgrates/cgrates/engine" +// "github.com/cgrates/cgrates/utils" +// ) +// +// type testMockClients struct { +// calls func(_ *context.Context, _, _ any) error +// } +// +// func (sT *testMockClients) Call(ctx *context.Context, method string, arg, rply any) error { +// return sT.calls(ctx, arg, rply) +// } +// +// // TestSessionSCoverage for cover testing +// func TestSessionSCoverage(t *testing.T) { +// cfg := config.NewDefaultCGRConfig() +// cfg.ChargerSCfg().Enabled = true +// cfg.CdrsCfg().Enabled = true +// filterSChan := make(chan *engine.FilterS, 1) +// filterSChan <- nil +// cls := commonlisteners.NewCommonListenerS(nil) +// srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} +// db := NewDataDBService(cfg, nil, false, srvDep) +// anz := NewAnalyzerService(cfg, cls, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) +// srv := NewSessionService(cfg, db, nil, cls, make(chan birpc.ClientConnector, 1), nil, anz, srvDep) +// engine.NewConnManager(cfg) +// if srv.IsRunning() { +// t.Errorf("Expected service to be down") +// } +// srv2 := SessionService{ +// cfg: cfg, +// dm: db, +// cls: cls, +// connChan: make(chan birpc.ClientConnector, 1), +// connMgr: nil, +// anz: anz, +// srvDep: srvDep, +// sm: &sessions.SessionS{}, +// } +// if !srv2.IsRunning() { +// t.Errorf("Expected service to be running") +// } +// serviceName := srv2.ServiceName() +// if !reflect.DeepEqual(serviceName, utils.SessionS) { +// t.Errorf("\nExpecting <%+v>,\n Received <%+v>", utils.SessionS, serviceName) +// } +// shouldRun := srv2.ShouldRun() +// if !reflect.DeepEqual(shouldRun, false) { +// t.Errorf("\nExpecting ,\n Received <%+v>", shouldRun) +// } +// } diff --git a/services/sipagent_it_test.go b/services/sipagent_it_test.go index b264ce12c..35fc9ca77 100644 --- a/services/sipagent_it_test.go +++ b/services/sipagent_it_test.go @@ -20,128 +20,128 @@ along with this program. If not, see */ package services -import ( - "path" - "runtime" - "sync" - "testing" - "time" - - "github.com/cgrates/birpc" - "github.com/cgrates/birpc/context" - "github.com/cgrates/cgrates/commonlisteners" - "github.com/cgrates/cgrates/config" - "github.com/cgrates/cgrates/engine" - "github.com/cgrates/cgrates/servmanager" - "github.com/cgrates/cgrates/utils" -) - -func TestSIPAgentReload(t *testing.T) { - cfg := config.NewDefaultCGRConfig() - - cfg.SessionSCfg().Enabled = true - cfg.SessionSCfg().ListenBijson = "" - filterSChan := make(chan *engine.FilterS, 1) - filterSChan <- nil - shdWg := new(sync.WaitGroup) - - cls := commonlisteners.NewCommonListenerS(nil) - srvMngr := servmanager.NewServiceManager(shdWg, nil, cfg) - srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} - db := NewDataDBService(cfg, nil, false, srvDep) - anz := NewAnalyzerService(cfg, cls, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) - sS := NewSessionService(cfg, db, filterSChan, cls, make(chan birpc.ClientConnector, 1), - nil, anz, srvDep) - srv := NewSIPAgent(cfg, filterSChan, nil, srvDep) - engine.NewConnManager(cfg) - srvMngr.AddServices(srv, sS, - NewLoaderService(cfg, db, filterSChan, cls, make(chan birpc.ClientConnector, 1), nil, anz, srvDep), db) - ctx, cancel := context.WithCancel(context.TODO()) - srvMngr.StartServices(ctx, cancel) - if srv.IsRunning() { - t.Fatalf("Expected service to be down") - } - var reply string - cfg.ConfigPath = path.Join("/usr", "share", "cgrates", "conf", "samples", "sipagent_mysql") - if err := cfg.V1ReloadConfig(context.Background(), &config.ReloadArgs{ - Section: config.SIPAgentJSON, - }, &reply); err != nil { - t.Fatal(err) - } else if reply != utils.OK { - t.Fatalf("Expecting OK ,received %s", reply) - } - time.Sleep(10 * time.Millisecond) //need to switch to gorutine - runtime.Gosched() - runtime.Gosched() - if !srv.IsRunning() { - t.Fatalf("Expected service to be running") - } - srvStart := srv.Start(ctx, cancel) - if srvStart != utils.ErrServiceAlreadyRunning { - t.Fatalf("\nExpecting <%+v>,\n Received <%+v>", utils.ErrServiceAlreadyRunning, srvStart) - } - err := srv.Reload(ctx, cancel) - if err != nil { - t.Fatalf("\nExpecting ,\n Received <%+v>", err) - } - time.Sleep(10 * time.Millisecond) - cfg.SIPAgentCfg().Enabled = false - cfg.GetReloadChan() <- config.SectionToService[config.SIPAgentJSON] - time.Sleep(10 * time.Millisecond) - if srv.IsRunning() { - t.Fatalf("Expected service to be down") - } - cancel() - time.Sleep(10 * time.Millisecond) -} - -func TestSIPAgentReload2(t *testing.T) { - cfg := config.NewDefaultCGRConfig() - cfg.SessionSCfg().Enabled = true - cfg.SessionSCfg().ListenBijson = "" - filterSChan := make(chan *engine.FilterS, 1) - filterSChan <- nil - srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} - srv := NewSIPAgent(cfg, filterSChan, nil, srvDep) - if srv.IsRunning() { - t.Fatalf("Expected service to be down") - } - cfg.SIPAgentCfg().RequestProcessors = []*config.RequestProcessor{ - { - RequestFields: []*config.FCTemplate{ - { - Type: utils.MetaTemplate, - }, - }, - }, - } - ctx, cancel := context.WithCancel(context.TODO()) - err := srv.Start(ctx, cancel) - if err == nil || err.Error() != "no template with id: <>" { - t.Fatalf("\nExpecting <%+v>,\n Received <%+v>", "no template with id: <>", err) - } - -} - -func TestSIPAgentReload3(t *testing.T) { - cfg := config.NewDefaultCGRConfig() - cfg.SessionSCfg().Enabled = true - cfg.SessionSCfg().ListenBijson = "" - filterSChan := make(chan *engine.FilterS, 1) - filterSChan <- nil - srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} - srv := NewSIPAgent(cfg, filterSChan, nil, srvDep) - if srv.IsRunning() { - t.Fatalf("Expected service to be down") - } - ctx, cancel := context.WithCancel(context.TODO()) - err := srv.Start(ctx, cancel) - if err != nil { - t.Fatalf("\nExpecting <%+v>,\n Received <%+v>", nil, err) - } - srv.(*SIPAgent).oldListen = "test" - err = srv.Reload(ctx, cancel) - if err != nil { - t.Fatalf("\nExpecting <%+v>,\n Received <%+v>", nil, err) - } -} +// import ( +// "path" +// "runtime" +// "sync" +// "testing" +// "time" +// +// "github.com/cgrates/birpc" +// "github.com/cgrates/birpc/context" +// "github.com/cgrates/cgrates/commonlisteners" +// "github.com/cgrates/cgrates/config" +// "github.com/cgrates/cgrates/engine" +// "github.com/cgrates/cgrates/servmanager" +// "github.com/cgrates/cgrates/utils" +// ) +// +// func TestSIPAgentReload(t *testing.T) { +// cfg := config.NewDefaultCGRConfig() +// +// cfg.SessionSCfg().Enabled = true +// cfg.SessionSCfg().ListenBijson = "" +// filterSChan := make(chan *engine.FilterS, 1) +// filterSChan <- nil +// shdWg := new(sync.WaitGroup) +// +// cls := commonlisteners.NewCommonListenerS(nil) +// srvMngr := servmanager.NewServiceManager(shdWg, nil, cfg) +// srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} +// db := NewDataDBService(cfg, nil, false, srvDep) +// anz := NewAnalyzerService(cfg, cls, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) +// sS := NewSessionService(cfg, db, filterSChan, cls, make(chan birpc.ClientConnector, 1), +// nil, anz, srvDep) +// srv := NewSIPAgent(cfg, filterSChan, nil, srvDep) +// engine.NewConnManager(cfg) +// srvMngr.AddServices(srv, sS, +// NewLoaderService(cfg, db, filterSChan, cls, make(chan birpc.ClientConnector, 1), nil, anz, srvDep), db) +// ctx, cancel := context.WithCancel(context.TODO()) +// srvMngr.StartServices(ctx, cancel) +// if srv.IsRunning() { +// t.Fatalf("Expected service to be down") +// } +// var reply string +// cfg.ConfigPath = path.Join("/usr", "share", "cgrates", "conf", "samples", "sipagent_mysql") +// if err := cfg.V1ReloadConfig(context.Background(), &config.ReloadArgs{ +// Section: config.SIPAgentJSON, +// }, &reply); err != nil { +// t.Fatal(err) +// } else if reply != utils.OK { +// t.Fatalf("Expecting OK ,received %s", reply) +// } +// time.Sleep(10 * time.Millisecond) //need to switch to gorutine +// runtime.Gosched() +// runtime.Gosched() +// if !srv.IsRunning() { +// t.Fatalf("Expected service to be running") +// } +// srvStart := srv.Start(ctx, cancel) +// if srvStart != utils.ErrServiceAlreadyRunning { +// t.Fatalf("\nExpecting <%+v>,\n Received <%+v>", utils.ErrServiceAlreadyRunning, srvStart) +// } +// err := srv.Reload(ctx, cancel) +// if err != nil { +// t.Fatalf("\nExpecting ,\n Received <%+v>", err) +// } +// time.Sleep(10 * time.Millisecond) +// cfg.SIPAgentCfg().Enabled = false +// cfg.GetReloadChan() <- config.SectionToService[config.SIPAgentJSON] +// time.Sleep(10 * time.Millisecond) +// if srv.IsRunning() { +// t.Fatalf("Expected service to be down") +// } +// cancel() +// time.Sleep(10 * time.Millisecond) +// } +// +// func TestSIPAgentReload2(t *testing.T) { +// cfg := config.NewDefaultCGRConfig() +// cfg.SessionSCfg().Enabled = true +// cfg.SessionSCfg().ListenBijson = "" +// filterSChan := make(chan *engine.FilterS, 1) +// filterSChan <- nil +// srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} +// srv := NewSIPAgent(cfg, filterSChan, nil, srvDep) +// if srv.IsRunning() { +// t.Fatalf("Expected service to be down") +// } +// cfg.SIPAgentCfg().RequestProcessors = []*config.RequestProcessor{ +// { +// RequestFields: []*config.FCTemplate{ +// { +// Type: utils.MetaTemplate, +// }, +// }, +// }, +// } +// ctx, cancel := context.WithCancel(context.TODO()) +// err := srv.Start(ctx, cancel) +// if err == nil || err.Error() != "no template with id: <>" { +// t.Fatalf("\nExpecting <%+v>,\n Received <%+v>", "no template with id: <>", err) +// } +// +// } +// +// func TestSIPAgentReload3(t *testing.T) { +// cfg := config.NewDefaultCGRConfig() +// cfg.SessionSCfg().Enabled = true +// cfg.SessionSCfg().ListenBijson = "" +// filterSChan := make(chan *engine.FilterS, 1) +// filterSChan <- nil +// srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} +// srv := NewSIPAgent(cfg, filterSChan, nil, srvDep) +// if srv.IsRunning() { +// t.Fatalf("Expected service to be down") +// } +// ctx, cancel := context.WithCancel(context.TODO()) +// err := srv.Start(ctx, cancel) +// if err != nil { +// t.Fatalf("\nExpecting <%+v>,\n Received <%+v>", nil, err) +// } +// srv.(*SIPAgent).oldListen = "test" +// err = srv.Reload(ctx, cancel) +// if err != nil { +// t.Fatalf("\nExpecting <%+v>,\n Received <%+v>", nil, err) +// } +// } diff --git a/services/sipagent_test.go b/services/sipagent_test.go index 6849b6edf..b1db21358 100644 --- a/services/sipagent_test.go +++ b/services/sipagent_test.go @@ -17,46 +17,46 @@ along with this program. If not, see */ package services -import ( - "reflect" - "sync" - "testing" - - "github.com/cgrates/cgrates/agents" - "github.com/cgrates/cgrates/config" - "github.com/cgrates/cgrates/engine" - "github.com/cgrates/cgrates/utils" -) - -// TestSIPAgentCoverage for cover testing -func TestSIPAgentCoverage(t *testing.T) { - cfg := config.NewDefaultCGRConfig() - cfg.SessionSCfg().Enabled = true - cfg.SessionSCfg().ListenBijson = "" - filterSChan := make(chan *engine.FilterS, 1) - filterSChan <- nil - srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} - srv := NewSIPAgent(cfg, filterSChan, nil, srvDep) - if srv.IsRunning() { - t.Errorf("Expected service to be down") - } - srv2 := SIPAgent{ - cfg: cfg, - filterSChan: filterSChan, - sip: &agents.SIPAgent{}, - connMgr: nil, - srvDep: srvDep, - } - if !srv2.IsRunning() { - t.Errorf("Expected service to be running") - } - serviceName := srv2.ServiceName() - if !reflect.DeepEqual(serviceName, utils.SIPAgent) { - t.Errorf("\nExpecting <%+v>,\n Received <%+v>", utils.SIPAgent, serviceName) - } - shouldRun := srv2.ShouldRun() - if !reflect.DeepEqual(shouldRun, false) { - t.Errorf("\nExpecting ,\n Received <%+v>", shouldRun) - } - -} +// import ( +// "reflect" +// "sync" +// "testing" +// +// "github.com/cgrates/cgrates/agents" +// "github.com/cgrates/cgrates/config" +// "github.com/cgrates/cgrates/engine" +// "github.com/cgrates/cgrates/utils" +// ) +// +// // TestSIPAgentCoverage for cover testing +// func TestSIPAgentCoverage(t *testing.T) { +// cfg := config.NewDefaultCGRConfig() +// cfg.SessionSCfg().Enabled = true +// cfg.SessionSCfg().ListenBijson = "" +// filterSChan := make(chan *engine.FilterS, 1) +// filterSChan <- nil +// srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} +// srv := NewSIPAgent(cfg, filterSChan, nil, srvDep) +// if srv.IsRunning() { +// t.Errorf("Expected service to be down") +// } +// srv2 := SIPAgent{ +// cfg: cfg, +// filterSChan: filterSChan, +// sip: &agents.SIPAgent{}, +// connMgr: nil, +// srvDep: srvDep, +// } +// if !srv2.IsRunning() { +// t.Errorf("Expected service to be running") +// } +// serviceName := srv2.ServiceName() +// if !reflect.DeepEqual(serviceName, utils.SIPAgent) { +// t.Errorf("\nExpecting <%+v>,\n Received <%+v>", utils.SIPAgent, serviceName) +// } +// shouldRun := srv2.ShouldRun() +// if !reflect.DeepEqual(shouldRun, false) { +// t.Errorf("\nExpecting ,\n Received <%+v>", shouldRun) +// } +// +// } diff --git a/services/stats_it_test.go b/services/stats_it_test.go index 721700db4..c6eaaa2a0 100644 --- a/services/stats_it_test.go +++ b/services/stats_it_test.go @@ -20,90 +20,90 @@ along with this program. If not, see */ package services -import ( - "path" - "runtime" - "sync" - "testing" - "time" - - "github.com/cgrates/birpc" - "github.com/cgrates/birpc/context" - "github.com/cgrates/cgrates/commonlisteners" - "github.com/cgrates/cgrates/config" - "github.com/cgrates/cgrates/engine" - "github.com/cgrates/cgrates/servmanager" - "github.com/cgrates/cgrates/utils" -) - -func TestStatSReload(t *testing.T) { - // utils.Logger.SetLogLevel(7) - cfg := config.NewDefaultCGRConfig() - - cfg.ThresholdSCfg().Enabled = true - filterSChan := make(chan *engine.FilterS, 1) - filterSChan <- nil - shdWg := new(sync.WaitGroup) - chS := engine.NewCacheS(cfg, nil, nil, nil) - close(chS.GetPrecacheChannel(utils.CacheThresholdProfiles)) - close(chS.GetPrecacheChannel(utils.CacheThresholds)) - close(chS.GetPrecacheChannel(utils.CacheThresholdFilterIndexes)) - close(chS.GetPrecacheChannel(utils.CacheStatQueueProfiles)) - close(chS.GetPrecacheChannel(utils.CacheStatQueues)) - close(chS.GetPrecacheChannel(utils.CacheStatFilterIndexes)) - chSCh := make(chan *engine.CacheS, 1) - chSCh <- chS - css := &CacheService{cacheCh: chSCh} - cls := commonlisteners.NewCommonListenerS(nil) - srvMngr := servmanager.NewServiceManager(shdWg, nil, cfg) - srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} - anz := NewAnalyzerService(cfg, cls, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) - db := NewDataDBService(cfg, nil, false, srvDep) - tS := NewThresholdService(cfg, db, css, filterSChan, nil, cls, make(chan birpc.ClientConnector, 1), anz, srvDep) - sS := NewStatService(cfg, db, css, filterSChan, cls, make(chan birpc.ClientConnector, 1), nil, anz, srvDep) - engine.NewConnManager(cfg) - srvMngr.AddServices(tS, sS, - NewLoaderService(cfg, db, filterSChan, cls, make(chan birpc.ClientConnector, 1), nil, anz, srvDep), db) - ctx, cancel := context.WithCancel(context.TODO()) - srvMngr.StartServices(ctx, cancel) - if sS.IsRunning() { - t.Errorf("Expected service to be down") - } - if db.IsRunning() { - t.Errorf("Expected service to be down") - } - var reply string - cfg.ConfigPath = path.Join("/usr", "share", "cgrates", "conf", "samples", "tutmongo") - if err := cfg.V1ReloadConfig(context.Background(), &config.ReloadArgs{ - Section: config.StatSJSON, - }, &reply); err != nil { - t.Error(err) - } else if reply != utils.OK { - t.Errorf("Expecting OK ,received %s", reply) - } - runtime.Gosched() - runtime.Gosched() - time.Sleep(10 * time.Millisecond) //need to switch to gorutine - if !sS.IsRunning() { - t.Errorf("Expected service to be running") - } - if !db.IsRunning() { - t.Errorf("Expected service to be running") - } - err := sS.Start(ctx, cancel) - if err == nil || err != utils.ErrServiceAlreadyRunning { - t.Errorf("\nExpecting <%+v>,\n Received <%+v>", utils.ErrServiceAlreadyRunning, err) - } - err = sS.Reload(ctx, cancel) - if err != nil { - t.Errorf("\nExpecting ,\n Received <%+v>", err) - } - cfg.StatSCfg().Enabled = false - cfg.GetReloadChan() <- config.SectionToService[config.StatSJSON] - time.Sleep(10 * time.Millisecond) - if sS.IsRunning() { - t.Errorf("Expected service to be down") - } - cancel() - time.Sleep(10 * time.Millisecond) -} +// import ( +// "path" +// "runtime" +// "sync" +// "testing" +// "time" +// +// "github.com/cgrates/birpc" +// "github.com/cgrates/birpc/context" +// "github.com/cgrates/cgrates/commonlisteners" +// "github.com/cgrates/cgrates/config" +// "github.com/cgrates/cgrates/engine" +// "github.com/cgrates/cgrates/servmanager" +// "github.com/cgrates/cgrates/utils" +// ) +// +// func TestStatSReload(t *testing.T) { +// // utils.Logger.SetLogLevel(7) +// cfg := config.NewDefaultCGRConfig() +// +// cfg.ThresholdSCfg().Enabled = true +// filterSChan := make(chan *engine.FilterS, 1) +// filterSChan <- nil +// shdWg := new(sync.WaitGroup) +// chS := engine.NewCacheS(cfg, nil, nil, nil) +// close(chS.GetPrecacheChannel(utils.CacheThresholdProfiles)) +// close(chS.GetPrecacheChannel(utils.CacheThresholds)) +// close(chS.GetPrecacheChannel(utils.CacheThresholdFilterIndexes)) +// close(chS.GetPrecacheChannel(utils.CacheStatQueueProfiles)) +// close(chS.GetPrecacheChannel(utils.CacheStatQueues)) +// close(chS.GetPrecacheChannel(utils.CacheStatFilterIndexes)) +// chSCh := make(chan *engine.CacheS, 1) +// chSCh <- chS +// css := &CacheService{cacheCh: chSCh} +// cls := commonlisteners.NewCommonListenerS(nil) +// srvMngr := servmanager.NewServiceManager(shdWg, nil, cfg) +// srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} +// anz := NewAnalyzerService(cfg, cls, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) +// db := NewDataDBService(cfg, nil, false, srvDep) +// tS := NewThresholdService(cfg, db, css, filterSChan, nil, cls, make(chan birpc.ClientConnector, 1), anz, srvDep) +// sS := NewStatService(cfg, db, css, filterSChan, cls, make(chan birpc.ClientConnector, 1), nil, anz, srvDep) +// engine.NewConnManager(cfg) +// srvMngr.AddServices(tS, sS, +// NewLoaderService(cfg, db, filterSChan, cls, make(chan birpc.ClientConnector, 1), nil, anz, srvDep), db) +// ctx, cancel := context.WithCancel(context.TODO()) +// srvMngr.StartServices(ctx, cancel) +// if sS.IsRunning() { +// t.Errorf("Expected service to be down") +// } +// if db.IsRunning() { +// t.Errorf("Expected service to be down") +// } +// var reply string +// cfg.ConfigPath = path.Join("/usr", "share", "cgrates", "conf", "samples", "tutmongo") +// if err := cfg.V1ReloadConfig(context.Background(), &config.ReloadArgs{ +// Section: config.StatSJSON, +// }, &reply); err != nil { +// t.Error(err) +// } else if reply != utils.OK { +// t.Errorf("Expecting OK ,received %s", reply) +// } +// runtime.Gosched() +// runtime.Gosched() +// time.Sleep(10 * time.Millisecond) //need to switch to gorutine +// if !sS.IsRunning() { +// t.Errorf("Expected service to be running") +// } +// if !db.IsRunning() { +// t.Errorf("Expected service to be running") +// } +// err := sS.Start(ctx, cancel) +// if err == nil || err != utils.ErrServiceAlreadyRunning { +// t.Errorf("\nExpecting <%+v>,\n Received <%+v>", utils.ErrServiceAlreadyRunning, err) +// } +// err = sS.Reload(ctx, cancel) +// if err != nil { +// t.Errorf("\nExpecting ,\n Received <%+v>", err) +// } +// cfg.StatSCfg().Enabled = false +// cfg.GetReloadChan() <- config.SectionToService[config.StatSJSON] +// time.Sleep(10 * time.Millisecond) +// if sS.IsRunning() { +// t.Errorf("Expected service to be down") +// } +// cancel() +// time.Sleep(10 * time.Millisecond) +// } diff --git a/services/stats_test.go b/services/stats_test.go index 14666ad52..939325f18 100644 --- a/services/stats_test.go +++ b/services/stats_test.go @@ -17,56 +17,56 @@ along with this program. If not, see */ package services -import ( - "reflect" - "sync" - "testing" - - "github.com/cgrates/birpc" - "github.com/cgrates/birpc/context" - "github.com/cgrates/cgrates/commonlisteners" - "github.com/cgrates/cgrates/config" - "github.com/cgrates/cgrates/engine" - "github.com/cgrates/cgrates/utils" -) - -// TestStatSCoverage for cover testing -func TestStatSCoverage(t *testing.T) { - // utils.Logger.SetLogLevel(7) - cfg := config.NewDefaultCGRConfig() - cfg.ThresholdSCfg().Enabled = true - filterSChan := make(chan *engine.FilterS, 1) - filterSChan <- nil - cls := commonlisteners.NewCommonListenerS(nil) - srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} - anz := NewAnalyzerService(cfg, cls, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) - db := NewDataDBService(cfg, nil, false, srvDep) - chS := NewCacheService(cfg, db, nil, cls, make(chan context.ClientConnector, 1), anz, nil, srvDep) - sS := NewStatService(cfg, db, chS, filterSChan, cls, make(chan birpc.ClientConnector, 1), nil, anz, srvDep) - if sS.IsRunning() { - t.Errorf("Expected service to be down") - } - sS2 := StatService{ - cfg: cfg, - dm: db, - cacheS: chS, - filterSChan: filterSChan, - cls: cls, - connMgr: nil, - sts: &engine.StatS{}, - connChan: make(chan birpc.ClientConnector, 1), - anz: anz, - srvDep: srvDep, - } - if !sS2.IsRunning() { - t.Errorf("Expected service to be running") - } - serviceName := sS2.ServiceName() - if !reflect.DeepEqual(serviceName, utils.StatS) { - t.Errorf("\nExpecting <%+v>,\n Received <%+v>", utils.StatS, serviceName) - } - shouldRun := sS2.ShouldRun() - if !reflect.DeepEqual(shouldRun, false) { - t.Errorf("\nExpecting ,\n Received <%+v>", shouldRun) - } -} +// import ( +// "reflect" +// "sync" +// "testing" +// +// "github.com/cgrates/birpc" +// "github.com/cgrates/birpc/context" +// "github.com/cgrates/cgrates/commonlisteners" +// "github.com/cgrates/cgrates/config" +// "github.com/cgrates/cgrates/engine" +// "github.com/cgrates/cgrates/utils" +// ) +// +// // TestStatSCoverage for cover testing +// func TestStatSCoverage(t *testing.T) { +// // utils.Logger.SetLogLevel(7) +// cfg := config.NewDefaultCGRConfig() +// cfg.ThresholdSCfg().Enabled = true +// filterSChan := make(chan *engine.FilterS, 1) +// filterSChan <- nil +// cls := commonlisteners.NewCommonListenerS(nil) +// srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} +// anz := NewAnalyzerService(cfg, cls, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) +// db := NewDataDBService(cfg, nil, false, srvDep) +// chS := NewCacheService(cfg, db, nil, cls, make(chan context.ClientConnector, 1), anz, nil, srvDep) +// sS := NewStatService(cfg, db, chS, filterSChan, cls, make(chan birpc.ClientConnector, 1), nil, anz, srvDep) +// if sS.IsRunning() { +// t.Errorf("Expected service to be down") +// } +// sS2 := StatService{ +// cfg: cfg, +// dm: db, +// cacheS: chS, +// filterSChan: filterSChan, +// cls: cls, +// connMgr: nil, +// sts: &engine.StatS{}, +// connChan: make(chan birpc.ClientConnector, 1), +// anz: anz, +// srvDep: srvDep, +// } +// if !sS2.IsRunning() { +// t.Errorf("Expected service to be running") +// } +// serviceName := sS2.ServiceName() +// if !reflect.DeepEqual(serviceName, utils.StatS) { +// t.Errorf("\nExpecting <%+v>,\n Received <%+v>", utils.StatS, serviceName) +// } +// shouldRun := sS2.ShouldRun() +// if !reflect.DeepEqual(shouldRun, false) { +// t.Errorf("\nExpecting ,\n Received <%+v>", shouldRun) +// } +// } diff --git a/services/thresholds_it_test.go b/services/thresholds_it_test.go index 1340116cd..1c92124b8 100644 --- a/services/thresholds_it_test.go +++ b/services/thresholds_it_test.go @@ -20,151 +20,151 @@ along with this program. If not, see */ package services -import ( - "path" - "runtime" - "sync" - "testing" - "time" - - "github.com/cgrates/birpc" - "github.com/cgrates/birpc/context" - "github.com/cgrates/cgrates/commonlisteners" - "github.com/cgrates/cgrates/config" - "github.com/cgrates/cgrates/engine" - "github.com/cgrates/cgrates/servmanager" - "github.com/cgrates/cgrates/utils" -) - -func TestThresholdSReload(t *testing.T) { - // utils.Logger.SetLogLevel(7) - cfg := config.NewDefaultCGRConfig() - ctx, cancel := context.WithCancel(context.TODO()) - filterSChan := make(chan *engine.FilterS, 1) - filterSChan <- nil - shdWg := new(sync.WaitGroup) - chS := engine.NewCacheS(cfg, nil, nil, nil) - close(chS.GetPrecacheChannel(utils.CacheThresholdProfiles)) - close(chS.GetPrecacheChannel(utils.CacheThresholds)) - close(chS.GetPrecacheChannel(utils.CacheThresholdFilterIndexes)) - chSCh := make(chan *engine.CacheS, 1) - chSCh <- chS - css := &CacheService{cacheCh: chSCh} - cls := commonlisteners.NewCommonListenerS(nil) - srvMngr := servmanager.NewServiceManager(shdWg, nil, cfg) - srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} - anz := NewAnalyzerService(cfg, cls, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) - db := NewDataDBService(cfg, nil, false, srvDep) - tS := NewThresholdService(cfg, db, css, filterSChan, nil, cls, make(chan birpc.ClientConnector, 1), anz, srvDep) - engine.NewConnManager(cfg) - srvMngr.AddServices(tS, - NewLoaderService(cfg, db, filterSChan, cls, make(chan birpc.ClientConnector, 1), nil, anz, srvDep), db) - srvMngr.StartServices(ctx, cancel) - if tS.IsRunning() { - t.Errorf("Expected service to be down") - } - if db.IsRunning() { - t.Errorf("Expected service to be down") - } - var reply string - cfg.ConfigPath = path.Join("/usr", "share", "cgrates", "conf", "samples", "tutmongo") - if err := cfg.V1ReloadConfig(context.Background(), &config.ReloadArgs{ - Section: config.ThresholdSJSON, - }, &reply); err != nil { - t.Error(err) - } else if reply != utils.OK { - t.Errorf("Expecting OK ,received %s", reply) - } - runtime.Gosched() - runtime.Gosched() - time.Sleep(10 * time.Millisecond) //need to switch to gorutine - if !tS.IsRunning() { - t.Errorf("Expected service to be running") - } - runtime.Gosched() - if !db.IsRunning() { - t.Errorf("Expected service to be running") - } - runtime.Gosched() - err := tS.Start(ctx, cancel) - if err == nil || err != utils.ErrServiceAlreadyRunning { - t.Errorf("\nExpecting <%+v>,\n Received <%+v>", utils.ErrServiceAlreadyRunning, err) - } - err = tS.Reload(ctx, cancel) - if err != nil { - t.Errorf("\nExpecting ,\n Received <%+v>", err) - } - cfg.ThresholdSCfg().Enabled = false - cfg.GetReloadChan() <- config.SectionToService[config.ThresholdSJSON] - time.Sleep(10 * time.Millisecond) - if tS.IsRunning() { - t.Errorf("Expected service to be down") - } - cancel() - - time.Sleep(10 * time.Millisecond) -} -func TestThresholdSReload2(t *testing.T) { - // utils.Logger.SetLogLevel(7) - cfg := config.NewDefaultCGRConfig() - ctx, cancel := context.WithCancel(context.TODO()) - - filterSChan := make(chan *engine.FilterS, 1) - filterSChan <- nil - shdWg := new(sync.WaitGroup) - chS := engine.NewCacheS(cfg, nil, nil, nil) - close(chS.GetPrecacheChannel(utils.CacheThresholdProfiles)) - close(chS.GetPrecacheChannel(utils.CacheThresholds)) - close(chS.GetPrecacheChannel(utils.CacheThresholdFilterIndexes)) - chSCh := make(chan *engine.CacheS, 1) - chSCh <- chS - css := &CacheService{cacheCh: chSCh} - cls := commonlisteners.NewCommonListenerS(nil) - srvMngr := servmanager.NewServiceManager(shdWg, nil, cfg) - srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} - anz := NewAnalyzerService(cfg, cls, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) - db := NewDataDBService(cfg, nil, false, srvDep) - tS := NewThresholdService(cfg, db, css, filterSChan, nil, cls, make(chan birpc.ClientConnector, 1), anz, srvDep) - engine.NewConnManager(cfg) - srvMngr.AddServices(tS, - NewLoaderService(cfg, db, filterSChan, cls, make(chan birpc.ClientConnector, 1), nil, anz, srvDep), db) - srvMngr.StartServices(ctx, cancel) - if tS.IsRunning() { - t.Errorf("Expected service to be down") - } - if db.IsRunning() { - t.Errorf("Expected service to be down") - } - var reply string - cfg.ConfigPath = path.Join("/usr", "share", "cgrates", "conf", "samples", "tutmongo") - if err := cfg.V1ReloadConfig(context.Background(), &config.ReloadArgs{ - Section: config.ThresholdSJSON, - }, &reply); err != nil { - t.Error(err) - } else if reply != utils.OK { - t.Errorf("Expecting OK ,received %s", reply) - } - time.Sleep(10 * time.Millisecond) //need to switch to gorutine - if !tS.IsRunning() { - t.Errorf("Expected service to be running") - } - if !db.IsRunning() { - t.Errorf("Expected service to be running") - } - err := tS.Start(ctx, cancel) - if err == nil || err != utils.ErrServiceAlreadyRunning { - t.Errorf("\nExpecting <%+v>,\n Received <%+v>", utils.ErrServiceAlreadyRunning, err) - } - err = tS.Reload(ctx, cancel) - if err != nil { - t.Errorf("\nExpecting ,\n Received <%+v>", err) - } - cfg.ThresholdSCfg().Enabled = false - cfg.GetReloadChan() <- config.SectionToService[config.ThresholdSJSON] - time.Sleep(10 * time.Millisecond) - if tS.IsRunning() { - t.Errorf("Expected service to be down") - } - cancel() - time.Sleep(10 * time.Millisecond) -} +// import ( +// "path" +// "runtime" +// "sync" +// "testing" +// "time" +// +// "github.com/cgrates/birpc" +// "github.com/cgrates/birpc/context" +// "github.com/cgrates/cgrates/commonlisteners" +// "github.com/cgrates/cgrates/config" +// "github.com/cgrates/cgrates/engine" +// "github.com/cgrates/cgrates/servmanager" +// "github.com/cgrates/cgrates/utils" +// ) +// +// func TestThresholdSReload(t *testing.T) { +// // utils.Logger.SetLogLevel(7) +// cfg := config.NewDefaultCGRConfig() +// ctx, cancel := context.WithCancel(context.TODO()) +// filterSChan := make(chan *engine.FilterS, 1) +// filterSChan <- nil +// shdWg := new(sync.WaitGroup) +// chS := engine.NewCacheS(cfg, nil, nil, nil) +// close(chS.GetPrecacheChannel(utils.CacheThresholdProfiles)) +// close(chS.GetPrecacheChannel(utils.CacheThresholds)) +// close(chS.GetPrecacheChannel(utils.CacheThresholdFilterIndexes)) +// chSCh := make(chan *engine.CacheS, 1) +// chSCh <- chS +// css := &CacheService{cacheCh: chSCh} +// cls := commonlisteners.NewCommonListenerS(nil) +// srvMngr := servmanager.NewServiceManager(shdWg, nil, cfg) +// srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} +// anz := NewAnalyzerService(cfg, cls, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) +// db := NewDataDBService(cfg, nil, false, srvDep) +// tS := NewThresholdService(cfg, db, css, filterSChan, nil, cls, make(chan birpc.ClientConnector, 1), anz, srvDep) +// engine.NewConnManager(cfg) +// srvMngr.AddServices(tS, +// NewLoaderService(cfg, db, filterSChan, cls, make(chan birpc.ClientConnector, 1), nil, anz, srvDep), db) +// srvMngr.StartServices(ctx, cancel) +// if tS.IsRunning() { +// t.Errorf("Expected service to be down") +// } +// if db.IsRunning() { +// t.Errorf("Expected service to be down") +// } +// var reply string +// cfg.ConfigPath = path.Join("/usr", "share", "cgrates", "conf", "samples", "tutmongo") +// if err := cfg.V1ReloadConfig(context.Background(), &config.ReloadArgs{ +// Section: config.ThresholdSJSON, +// }, &reply); err != nil { +// t.Error(err) +// } else if reply != utils.OK { +// t.Errorf("Expecting OK ,received %s", reply) +// } +// runtime.Gosched() +// runtime.Gosched() +// time.Sleep(10 * time.Millisecond) //need to switch to gorutine +// if !tS.IsRunning() { +// t.Errorf("Expected service to be running") +// } +// runtime.Gosched() +// if !db.IsRunning() { +// t.Errorf("Expected service to be running") +// } +// runtime.Gosched() +// err := tS.Start(ctx, cancel) +// if err == nil || err != utils.ErrServiceAlreadyRunning { +// t.Errorf("\nExpecting <%+v>,\n Received <%+v>", utils.ErrServiceAlreadyRunning, err) +// } +// err = tS.Reload(ctx, cancel) +// if err != nil { +// t.Errorf("\nExpecting ,\n Received <%+v>", err) +// } +// cfg.ThresholdSCfg().Enabled = false +// cfg.GetReloadChan() <- config.SectionToService[config.ThresholdSJSON] +// time.Sleep(10 * time.Millisecond) +// if tS.IsRunning() { +// t.Errorf("Expected service to be down") +// } +// cancel() +// +// time.Sleep(10 * time.Millisecond) +// } +// func TestThresholdSReload2(t *testing.T) { +// // utils.Logger.SetLogLevel(7) +// cfg := config.NewDefaultCGRConfig() +// ctx, cancel := context.WithCancel(context.TODO()) +// +// filterSChan := make(chan *engine.FilterS, 1) +// filterSChan <- nil +// shdWg := new(sync.WaitGroup) +// chS := engine.NewCacheS(cfg, nil, nil, nil) +// close(chS.GetPrecacheChannel(utils.CacheThresholdProfiles)) +// close(chS.GetPrecacheChannel(utils.CacheThresholds)) +// close(chS.GetPrecacheChannel(utils.CacheThresholdFilterIndexes)) +// chSCh := make(chan *engine.CacheS, 1) +// chSCh <- chS +// css := &CacheService{cacheCh: chSCh} +// cls := commonlisteners.NewCommonListenerS(nil) +// srvMngr := servmanager.NewServiceManager(shdWg, nil, cfg) +// srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} +// anz := NewAnalyzerService(cfg, cls, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) +// db := NewDataDBService(cfg, nil, false, srvDep) +// tS := NewThresholdService(cfg, db, css, filterSChan, nil, cls, make(chan birpc.ClientConnector, 1), anz, srvDep) +// engine.NewConnManager(cfg) +// srvMngr.AddServices(tS, +// NewLoaderService(cfg, db, filterSChan, cls, make(chan birpc.ClientConnector, 1), nil, anz, srvDep), db) +// srvMngr.StartServices(ctx, cancel) +// if tS.IsRunning() { +// t.Errorf("Expected service to be down") +// } +// if db.IsRunning() { +// t.Errorf("Expected service to be down") +// } +// var reply string +// cfg.ConfigPath = path.Join("/usr", "share", "cgrates", "conf", "samples", "tutmongo") +// if err := cfg.V1ReloadConfig(context.Background(), &config.ReloadArgs{ +// Section: config.ThresholdSJSON, +// }, &reply); err != nil { +// t.Error(err) +// } else if reply != utils.OK { +// t.Errorf("Expecting OK ,received %s", reply) +// } +// time.Sleep(10 * time.Millisecond) //need to switch to gorutine +// if !tS.IsRunning() { +// t.Errorf("Expected service to be running") +// } +// if !db.IsRunning() { +// t.Errorf("Expected service to be running") +// } +// err := tS.Start(ctx, cancel) +// if err == nil || err != utils.ErrServiceAlreadyRunning { +// t.Errorf("\nExpecting <%+v>,\n Received <%+v>", utils.ErrServiceAlreadyRunning, err) +// } +// err = tS.Reload(ctx, cancel) +// if err != nil { +// t.Errorf("\nExpecting ,\n Received <%+v>", err) +// } +// cfg.ThresholdSCfg().Enabled = false +// cfg.GetReloadChan() <- config.SectionToService[config.ThresholdSJSON] +// time.Sleep(10 * time.Millisecond) +// if tS.IsRunning() { +// t.Errorf("Expected service to be down") +// } +// cancel() +// time.Sleep(10 * time.Millisecond) +// } diff --git a/services/thresholds_test.go b/services/thresholds_test.go index 561a35074..ab5a09f9d 100644 --- a/services/thresholds_test.go +++ b/services/thresholds_test.go @@ -17,54 +17,54 @@ along with this program. If not, see */ package services -import ( - "reflect" - "sync" - "testing" - - "github.com/cgrates/birpc" - "github.com/cgrates/birpc/context" - "github.com/cgrates/cgrates/commonlisteners" - "github.com/cgrates/cgrates/config" - "github.com/cgrates/cgrates/engine" - "github.com/cgrates/cgrates/utils" -) - -// TestThresholdSCoverage for cover testing -func TestThresholdSCoverage(t *testing.T) { - cfg := config.NewDefaultCGRConfig() - filterSChan := make(chan *engine.FilterS, 1) - filterSChan <- nil - cls := commonlisteners.NewCommonListenerS(nil) - srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} - anz := NewAnalyzerService(cfg, cls, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) - db := NewDataDBService(cfg, nil, false, srvDep) - chS := NewCacheService(cfg, db, nil, cls, make(chan context.ClientConnector, 1), anz, nil, srvDep) - tS := NewThresholdService(cfg, db, chS, filterSChan, nil, cls, make(chan birpc.ClientConnector, 1), anz, srvDep) - if tS.IsRunning() { - t.Errorf("Expected service to be down") - } - thrs1 := engine.NewThresholdService(&engine.DataManager{}, &config.CGRConfig{}, &engine.FilterS{}, nil) - tS2 := &ThresholdService{ - cfg: cfg, - dm: db, - cacheS: chS, - filterSChan: filterSChan, - cls: cls, - thrs: thrs1, - connChan: make(chan birpc.ClientConnector, 1), - anz: anz, - srvDep: srvDep, - } - if !tS2.IsRunning() { - t.Errorf("Expected service to be running") - } - serviceName := tS2.ServiceName() - if !reflect.DeepEqual(serviceName, utils.ThresholdS) { - t.Errorf("\nExpecting <%+v>,\n Received <%+v>", utils.ThresholdS, serviceName) - } - shouldRun := tS2.ShouldRun() - if !reflect.DeepEqual(shouldRun, false) { - t.Errorf("\nExpecting ,\n Received <%+v>", shouldRun) - } -} +// import ( +// "reflect" +// "sync" +// "testing" +// +// "github.com/cgrates/birpc" +// "github.com/cgrates/birpc/context" +// "github.com/cgrates/cgrates/commonlisteners" +// "github.com/cgrates/cgrates/config" +// "github.com/cgrates/cgrates/engine" +// "github.com/cgrates/cgrates/utils" +// ) +// +// // TestThresholdSCoverage for cover testing +// func TestThresholdSCoverage(t *testing.T) { +// cfg := config.NewDefaultCGRConfig() +// filterSChan := make(chan *engine.FilterS, 1) +// filterSChan <- nil +// cls := commonlisteners.NewCommonListenerS(nil) +// srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} +// anz := NewAnalyzerService(cfg, cls, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) +// db := NewDataDBService(cfg, nil, false, srvDep) +// chS := NewCacheService(cfg, db, nil, cls, make(chan context.ClientConnector, 1), anz, nil, srvDep) +// tS := NewThresholdService(cfg, db, chS, filterSChan, nil, cls, make(chan birpc.ClientConnector, 1), anz, srvDep) +// if tS.IsRunning() { +// t.Errorf("Expected service to be down") +// } +// thrs1 := engine.NewThresholdService(&engine.DataManager{}, &config.CGRConfig{}, &engine.FilterS{}, nil) +// tS2 := &ThresholdService{ +// cfg: cfg, +// dm: db, +// cacheS: chS, +// filterSChan: filterSChan, +// cls: cls, +// thrs: thrs1, +// connChan: make(chan birpc.ClientConnector, 1), +// anz: anz, +// srvDep: srvDep, +// } +// if !tS2.IsRunning() { +// t.Errorf("Expected service to be running") +// } +// serviceName := tS2.ServiceName() +// if !reflect.DeepEqual(serviceName, utils.ThresholdS) { +// t.Errorf("\nExpecting <%+v>,\n Received <%+v>", utils.ThresholdS, serviceName) +// } +// shouldRun := tS2.ShouldRun() +// if !reflect.DeepEqual(shouldRun, false) { +// t.Errorf("\nExpecting ,\n Received <%+v>", shouldRun) +// } +// } diff --git a/services/trends_test.go b/services/trends_test.go index 9b305f2fa..04d016432 100644 --- a/services/trends_test.go +++ b/services/trends_test.go @@ -18,67 +18,67 @@ along with this program. If not, see package services -import ( - "sync" - "testing" - - "github.com/cgrates/birpc" - "github.com/cgrates/cgrates/commonlisteners" - "github.com/cgrates/cgrates/config" - "github.com/cgrates/cgrates/engine" - "github.com/cgrates/cgrates/utils" -) - -func TestNewTrendService(t *testing.T) { - cfg := &config.CGRConfig{} - dm := &DataDBService{} - cacheS := &CacheService{} - filterSChan := make(chan *engine.FilterS) - server := &commonlisteners.CommonListenerS{} - internalTrendSChan := make(chan birpc.ClientConnector) - connMgr := &engine.ConnManager{} - anz := &AnalyzerService{} - srvDep := make(map[string]*sync.WaitGroup) - - service := NewTrendService(cfg, dm, cacheS, filterSChan, server, internalTrendSChan, connMgr, anz, srvDep) - - trendService, ok := service.(*TrendService) - if !ok { - t.Errorf("Expected type *TrendService, but got %T", service) - } - - if trendService.cfg != cfg { - t.Errorf("Expected cfg to be %v, but got %v", cfg, trendService.cfg) - } - if trendService.dm != dm { - t.Errorf("Expected dm to be %v, but got %v", dm, trendService.dm) - } - if trendService.cacheS != cacheS { - t.Errorf("Expected cacheS to be %v, but got %v", cacheS, trendService.cacheS) - } - - if trendService.cls != server { - t.Errorf("Expected server to be %v, but got %v", server, trendService.cls) - } - if trendService.connChan != internalTrendSChan { - t.Errorf("Expected connChan to be %v, but got %v", internalTrendSChan, trendService.connChan) - } - if trendService.connMgr != connMgr { - t.Errorf("Expected connMgr to be %v, but got %v", connMgr, trendService.connMgr) - } - if trendService.anz != anz { - t.Errorf("Expected anz to be %v, but got %v", anz, trendService.anz) - } - -} - -func TestTrendServiceServiceName(t *testing.T) { - tr := &TrendService{} - - serviceName := tr.ServiceName() - - expected := utils.TrendS - if serviceName != expected { - t.Errorf("Expected service name to be %s, but got %s", expected, serviceName) - } -} +// import ( +// "sync" +// "testing" +// +// "github.com/cgrates/birpc" +// "github.com/cgrates/cgrates/commonlisteners" +// "github.com/cgrates/cgrates/config" +// "github.com/cgrates/cgrates/engine" +// "github.com/cgrates/cgrates/utils" +// ) +// +// func TestNewTrendService(t *testing.T) { +// cfg := &config.CGRConfig{} +// dm := &DataDBService{} +// cacheS := &CacheService{} +// filterSChan := make(chan *engine.FilterS) +// server := &commonlisteners.CommonListenerS{} +// internalTrendSChan := make(chan birpc.ClientConnector) +// connMgr := &engine.ConnManager{} +// anz := &AnalyzerService{} +// srvDep := make(map[string]*sync.WaitGroup) +// +// service := NewTrendService(cfg, dm, cacheS, filterSChan, server, internalTrendSChan, connMgr, anz, srvDep) +// +// trendService, ok := service.(*TrendService) +// if !ok { +// t.Errorf("Expected type *TrendService, but got %T", service) +// } +// +// if trendService.cfg != cfg { +// t.Errorf("Expected cfg to be %v, but got %v", cfg, trendService.cfg) +// } +// if trendService.dm != dm { +// t.Errorf("Expected dm to be %v, but got %v", dm, trendService.dm) +// } +// if trendService.cacheS != cacheS { +// t.Errorf("Expected cacheS to be %v, but got %v", cacheS, trendService.cacheS) +// } +// +// if trendService.cls != server { +// t.Errorf("Expected server to be %v, but got %v", server, trendService.cls) +// } +// if trendService.connChan != internalTrendSChan { +// t.Errorf("Expected connChan to be %v, but got %v", internalTrendSChan, trendService.connChan) +// } +// if trendService.connMgr != connMgr { +// t.Errorf("Expected connMgr to be %v, but got %v", connMgr, trendService.connMgr) +// } +// if trendService.anz != anz { +// t.Errorf("Expected anz to be %v, but got %v", anz, trendService.anz) +// } +// +// } +// +// func TestTrendServiceServiceName(t *testing.T) { +// tr := &TrendService{} +// +// serviceName := tr.ServiceName() +// +// expected := utils.TrendS +// if serviceName != expected { +// t.Errorf("Expected service name to be %s, but got %s", expected, serviceName) +// } +// }