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)
+// }
+// }