Refactored tests in services

ees/ees.go

@@ -37,7 +37,7 @@ func onCacheEvicted(itmID string, value interface{}) {
 
 // NewEventExporterS instantiates the EventExporterS
 func NewEventExporterS(cfg *config.CGRConfig, filterS *engine.FilterS,
-	connMgr *engine.ConnManager) (eeS *EventExporterS, err error) {
+	connMgr *engine.ConnManager) (eeS *EventExporterS) {
 	eeS = &EventExporterS{
 		cfg:     cfg,
 		filterS: filterS,
@@ -76,10 +76,9 @@ func (eeS *EventExporterS) ListenAndServe(stopChan, cfgRld chan struct{}) {
 }
 
 // Shutdown is called to shutdown the service
-func (eeS *EventExporterS) Shutdown() (err error) {
+func (eeS *EventExporterS) Shutdown() {
 	utils.Logger.Info(fmt.Sprintf("<%s> shutdown <%s>", utils.CoreS, utils.EventExporterS))
 	eeS.setupCache(nil) // cleanup exporters
-	return
 }
 
 // Call implements rpcclient.ClientConnector interface for internal RPC

services/dnsagent_it_test.go

@@ -19,7 +19,22 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>
 */
 package services
 
-/*
+import (
+	"path"
+	"runtime"
+	"sync"
+	"testing"
+	"time"
+
+	"github.com/cgrates/cgrates/agents"
+	"github.com/cgrates/cgrates/config"
+	"github.com/cgrates/cgrates/cores"
+	"github.com/cgrates/cgrates/engine"
+	"github.com/cgrates/cgrates/servmanager"
+	"github.com/cgrates/cgrates/utils"
+	"github.com/cgrates/rpcclient"
+)
+
 func TestDNSAgentReload(t *testing.T) {
 	cfg := config.NewDefaultCGRConfig()
 	cfg.SessionSCfg().Enabled = true
@@ -151,7 +166,8 @@ func TestDNSAgentReload4(t *testing.T) {
 	cfg.SessionSCfg().Enabled = true
 	cfg.DNSAgentCfg().Enabled = true
 	cfg.DNSAgentCfg().ListenNet = "tls"
-
+	cfg.TLSCfg().ServerCerificate = "bad_certificate"
+	cfg.TLSCfg().ServerKey = "bad_key"
 	utils.Logger, _ = utils.Newlogger(utils.MetaSysLog, cfg.GeneralCfg().NodeID)
 	utils.Logger.SetLogLevel(7)
 	filterSChan := make(chan *engine.FilterS, 1)
@@ -164,8 +180,8 @@ func TestDNSAgentReload4(t *testing.T) {
 	dnsSrv := srv.(*DNSAgent)
 	dnsSrv.dns = nil
 	err := dnsSrv.Start()
-	if err == nil || err.Error() != "open : no such file or directory" {
-		t.Fatalf("\nExpected <%+v>, \nReceived <%+v>", "open : no such file or directory", err)
+	if err == nil || err.Error() != "open bad_certificate: no such file or directory" {
+		t.Fatalf("\nExpected <%+v>, \nReceived <%+v>", "open bad_certificate: no such file or directory", err)
 	}
 	dnsSrv.dns = nil
 }
@@ -187,6 +203,7 @@ func TestDNSAgentReload5(t *testing.T) {
 		t.Fatalf("\nExpected <%+v>, \nReceived <%+v>", nil, err)
 	}
 	srv.(*DNSAgent).oldListen = "127.0.0.1:2093"
+	time.Sleep(10 * time.Millisecond)
 	runtime.Gosched()
 	runtime.Gosched()
 	err = srv.Reload()
@@ -195,226 +212,31 @@ func TestDNSAgentReload5(t *testing.T) {
 	}
 }
 
-/*
-func TestDNSAgentReload2(t *testing.T) {
+func TestDNSAgentReload6(t *testing.T) {
 	cfg := config.NewDefaultCGRConfig()
 	cfg.SessionSCfg().Enabled = true
+	cfg.DNSAgentCfg().Enabled = true
+
 	utils.Logger, _ = utils.Newlogger(utils.MetaSysLog, cfg.GeneralCfg().NodeID)
 	utils.Logger.SetLogLevel(7)
 	filterSChan := make(chan *engine.FilterS, 1)
 	filterSChan <- nil
 	shdChan := utils.NewSyncedChan()
-	defer func() {
-		shdChan.CloseOnce()
-		time.Sleep(10 * time.Millisecond)
-	}()
-	shdWg := new(sync.WaitGroup)
-	chS := engine.NewCacheS(cfg, nil, nil)
-
-	cacheSChan := make(chan rpcclient.ClientConnector, 1)
-	cacheSChan <- chS
-
-	server := cores.NewServer(nil)
-	srvMngr := servmanager.NewServiceManager(cfg, shdChan, shdWg)
 	srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)}
-	db := NewDataDBService(cfg, nil, srvDep)
-	anz := NewAnalyzerService(cfg, server, filterSChan, shdChan, make(chan rpcclient.ClientConnector, 1), srvDep)
-	sS := NewSessionService(cfg, db, server, make(chan rpcclient.ClientConnector, 1),
-		shdChan, nil, nil, anz, srvDep)
 	srv := NewDNSAgent(cfg, filterSChan, shdChan, nil, srvDep)
-	engine.NewConnManager(cfg, nil)
-	srvMngr.AddServices(srv, sS,
-		NewLoaderService(cfg, db, filterSChan, server, make(chan rpcclient.ClientConnector, 1), nil, anz, srvDep), db)
-	if err := srvMngr.StartServices(); err != nil {
-		t.Fatal(err)
-	}
-	if srv.IsRunning() {
-		t.Fatalf("Expected service to be down")
-	}
-	var reply string
-	if err := cfg.V1ReloadConfig(&config.ReloadArgs{
-		Path:    path.Join("/usr", "share", "cgrates", "conf", "samples", "dnsagent_mongo"),
-		Section: config.DNSAgentJson,
-	}, &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()
-	if err == nil || err != utils.ErrServiceAlreadyRunning {
-		t.Fatalf("\nExpecting <%+v>,\n Received <%+v>", utils.ErrServiceAlreadyRunning, err)
+	if err != nil {
+		t.Fatalf("\nExpected <%+v>, \nReceived <%+v>", nil, err)
 	}
-
-	castSrv, canCastSrv := srv.(*DNSAgent)
-	if !canCastSrv {
-		t.Fatalf("cannot cast")
-	}
-
-	castSrv.oldListen = "test_string"
+	srv.(*DNSAgent).oldListen = "127.0.0.1:2093"
+	cfg.DNSAgentCfg().ListenNet = "tls"
+	cfg.TLSCfg().ServerCerificate = "bad_certificate"
+	cfg.TLSCfg().ServerKey = "bad_key"
+	time.Sleep(10 * time.Millisecond)
 	runtime.Gosched()
 	runtime.Gosched()
 	err = srv.Reload()
-	if err != nil {
-		t.Fatalf("\nExpecting <nil>,\n Received <%+v>", err)
-	}
-	err = db.Reload()
-	if err != nil {
-		t.Fatalf("\nExpecting <nil>,\n Received <%+v>", err)
-	}
-	runtime.Gosched()
-	runtime.Gosched()
-	err = srv.Reload()
-	if err != nil {
-		t.Fatalf("\nExpecting <nil>,\n Received <%+v>", err)
-	}
-	time.Sleep(10 * time.Millisecond)
-	cfg.DNSAgentCfg().Enabled = false
-	cfg.GetReloadChan(config.DNSAgentJson) <- struct{}{}
-	time.Sleep(10 * time.Millisecond)
-	runtime.Gosched()
-	if srv.IsRunning() {
-		t.Fatalf("Expected service to be down")
+	if err == nil || err.Error() != "open bad_certificate: no such file or directory" {
+		t.Fatalf("\nExpected <%+v>, \nReceived <%+v>", "open bad_certificate: no such file or directory", err)
 	}
 }
-
-func TestDNSAgentReload3(t *testing.T) {
-	cfg := config.NewDefaultCGRConfig()
-	cfg.SessionSCfg().Enabled = true
-
-	cfg.DNSAgentCfg().ListenNet = "testtls"
-	cfg.TLSCfg().ServerCerificate = ""
-	cfg.TLSCfg().ServerKey = ""
-
-	utils.Logger, _ = utils.Newlogger(utils.MetaSysLog, cfg.GeneralCfg().NodeID)
-	utils.Logger.SetLogLevel(7)
-	filterSChan := make(chan *engine.FilterS, 1)
-	filterSChan <- nil
-	shdChan := utils.NewSyncedChan()
-	defer func() {
-		shdChan.CloseOnce()
-		time.Sleep(10 * time.Millisecond)
-	}()
-	shdWg := new(sync.WaitGroup)
-	chS := engine.NewCacheS(cfg, nil, nil)
-
-	cacheSChan := make(chan rpcclient.ClientConnector, 1)
-	cacheSChan <- chS
-
-	server := cores.NewServer(nil)
-	srvMngr := servmanager.NewServiceManager(cfg, shdChan, shdWg)
-	srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)}
-	db := NewDataDBService(cfg, nil, srvDep)
-	anz := NewAnalyzerService(cfg, server, filterSChan, shdChan, make(chan rpcclient.ClientConnector, 1), srvDep)
-	sS := NewSessionService(cfg, db, server, make(chan rpcclient.ClientConnector, 1),
-		shdChan, nil, nil, anz, srvDep)
-	srv := NewDNSAgent(cfg, filterSChan, shdChan, nil, srvDep)
-	engine.NewConnManager(cfg, nil)
-	srvMngr.AddServices(srv, sS,
-		NewLoaderService(cfg, db, filterSChan, server, make(chan rpcclient.ClientConnector, 1), nil, anz, srvDep), db)
-	if err := srvMngr.StartServices(); err != nil {
-		t.Fatal(err)
-	}
-	if srv.IsRunning() {
-		t.Fatalf("Expected service to be down")
-	}
-	var reply string
-	if err := cfg.V1ReloadConfig(&config.ReloadArgs{
-		Path:    path.Join("/usr", "share", "cgrates", "conf", "samples", "dnsagent_mongo"),
-		Section: config.DNSAgentJson,
-	}, &reply); err != nil {
-		t.Fatal(err)
-	} else if reply != utils.OK {
-		t.Fatalf("Expecting OK ,received %s", reply)
-	}
-
-	time.Sleep(10 * time.Millisecond)
-
-	cfg.DNSAgentCfg().Enabled = false
-	cfg.GetReloadChan(config.DNSAgentJson) <- struct{}{}
-	time.Sleep(10 * time.Millisecond)
-	if srv.IsRunning() {
-		t.Fatalf("Expected service to be down")
-	}
-
-}
-
-func TestDNSAgentReload4(t *testing.T) {
-	cfg := config.NewDefaultCGRConfig()
-	cfg.SessionSCfg().Enabled = true
-
-	utils.Logger, _ = utils.Newlogger(utils.MetaSysLog, cfg.GeneralCfg().NodeID)
-	utils.Logger.SetLogLevel(7)
-	filterSChan := make(chan *engine.FilterS, 1)
-	filterSChan <- nil
-	shdChan := utils.NewSyncedChan()
-	defer func() {
-		shdChan.CloseOnce()
-		time.Sleep(10 * time.Millisecond)
-	}()
-	shdWg := new(sync.WaitGroup)
-	chS := engine.NewCacheS(cfg, nil, nil)
-
-	cacheSChan := make(chan rpcclient.ClientConnector, 1)
-	cacheSChan <- chS
-
-	server := cores.NewServer(nil)
-	srvMngr := servmanager.NewServiceManager(cfg, shdChan, shdWg)
-	srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)}
-	db := NewDataDBService(cfg, nil, srvDep)
-	anz := NewAnalyzerService(cfg, server, filterSChan, shdChan, make(chan rpcclient.ClientConnector, 1), srvDep)
-	sS := NewSessionService(cfg, db, server, make(chan rpcclient.ClientConnector, 1),
-		shdChan, nil, nil, anz, srvDep)
-	srv := NewDNSAgent(cfg, filterSChan, shdChan, nil, srvDep)
-	var err error
-
-	srvMngr.AddServices(srv, sS,
-		NewLoaderService(cfg, db, filterSChan, server, make(chan rpcclient.ClientConnector, 1), nil, anz, srvDep), db)
-	if err := srvMngr.StartServices(); err != nil {
-		t.Fatal(err)
-	}
-	if srv.IsRunning() {
-		t.Fatalf("Expected service to be down")
-	}
-	var reply string
-	if err := cfg.V1ReloadConfig(&config.ReloadArgs{
-		Path:    path.Join("/usr", "share", "cgrates", "conf", "samples", "dnsagent_mongo"),
-		Section: config.DNSAgentJson,
-	}, &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 goroutine
-
-	runtime.Gosched()
-	if !srv.IsRunning() {
-		t.Fatalf("Expected service to be running")
-	}
-
-	runtime.Gosched()
-	err = db.Reload()
-	if err != nil {
-		t.Fatalf("\nExpecting <nil>,\n Received <%+v>", err)
-	}
-
-	dnsTest := &agents.DNSAgent{}
-	srv.(*DNSAgent).dns = dnsTest
-
-	time.Sleep(10 * time.Millisecond)
-	cfg.DNSAgentCfg().Enabled = false
-	cfg.GetReloadChan(config.DNSAgentJson) <- struct{}{}
-	time.Sleep(10 * time.Millisecond)
-	runtime.Gosched()
-	runtime.Gosched()
-	if srv.IsRunning() {
-		t.Fatalf("Expected service to be down")
-	}
-
-}
-*/

services/ees.go

@@ -95,9 +95,7 @@ func (es *EventExporterService) Shutdown() (err error) {
 	es.Lock()
 	defer es.Unlock()
 	close(es.stopChan)
-	if err = es.eeS.Shutdown(); err != nil {
-		return
-	}
+	es.eeS.Shutdown()
 	es.eeS = nil
 	<-es.intConnChan
 	return
@@ -117,12 +115,7 @@ func (es *EventExporterService) Start() (err error) {
 	es.Lock()
 	defer es.Unlock()
 
-	es.eeS, err = ees.NewEventExporterS(es.cfg, fltrS, es.connMgr)
-	if err != nil {
-		utils.Logger.Err(fmt.Sprintf("<%s> error: %s!",
-			utils.EventExporterS, err))
-		return
-	}
+	es.eeS = ees.NewEventExporterS(es.cfg, fltrS, es.connMgr)
 	es.stopChan = make(chan struct{})
 	go es.eeS.ListenAndServe(es.stopChan, es.rldChan)
 

services/ees_it_test.go

@@ -114,3 +114,32 @@ func TestEventExporterSReload(t *testing.T) {
 	shdChan.CloseOnce()
 	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()
+
+	utils.Logger, _ = utils.Newlogger(utils.MetaSysLog, cfg.GeneralCfg().NodeID)
+	utils.Logger.SetLogLevel(7)
+	cfg.AttributeSCfg().Enabled = true
+	filterSChan := make(chan *engine.FilterS, 1)
+	filterSChan <- nil
+	shdChan := utils.NewSyncedChan()
+	server := cores.NewServer(nil)
+	srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)}
+	anz := NewAnalyzerService(cfg, server, filterSChan, shdChan, make(chan rpcclient.ClientConnector, 1), srvDep)
+	ees := NewEventExporterService(cfg, filterSChan, engine.NewConnManager(cfg, nil),
+		server, make(chan rpcclient.ClientConnector, 2), anz, srvDep)
+	if ees.IsRunning() {
+		t.Fatalf("Expected service to be down")
+	}
+
+}

services/freeswitchagent.go

@@ -81,12 +81,15 @@ func (fS *FreeswitchAgent) Reload() (err error) {
 		return
 	}
 	fS.fS.Reload()
-	go func(f *agents.FSsessions) {
-		if err := fS.fS.Connect(); err != nil {
-			utils.Logger.Err(fmt.Sprintf("<%s> error: %s!", utils.FreeSWITCHAgent, err))
-			fS.shdChan.CloseOnce() // stop the engine here
-		}
-	}(fS.fS)
+	go fS.reload(fS.fS)
+	return
+}
+
+func (fS *FreeswitchAgent) reload(f *agents.FSsessions) (err error) {
+	if err := fS.fS.Connect(); err != nil {
+		utils.Logger.Err(fmt.Sprintf("<%s> error: %s!", utils.FreeSWITCHAgent, err))
+		fS.shdChan.CloseOnce() // stop the engine here
+	}
 	return
 }
 
@@ -94,9 +97,7 @@ func (fS *FreeswitchAgent) Reload() (err error) {
 func (fS *FreeswitchAgent) Shutdown() (err error) {
 	fS.Lock()
 	defer fS.Unlock()
-	if err = fS.fS.Shutdown(); err != nil {
-		return
-	}
+	err = fS.fS.Shutdown()
 	fS.fS = nil
 	return
 }

services/freeswitchagent_it_test.go

@@ -19,7 +19,21 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>
 */
 package services
 
-/*
+import (
+	"path"
+	"sync"
+	"testing"
+	"time"
+
+	"github.com/cgrates/cgrates/agents"
+	"github.com/cgrates/cgrates/config"
+	"github.com/cgrates/cgrates/cores"
+	"github.com/cgrates/cgrates/engine"
+	"github.com/cgrates/cgrates/servmanager"
+	"github.com/cgrates/cgrates/utils"
+	"github.com/cgrates/rpcclient"
+)
+
 func TestFreeSwitchAgentReload(t *testing.T) {
 	cfg := config.NewDefaultCGRConfig()
 
@@ -68,22 +82,9 @@ func TestFreeSwitchAgentReload(t *testing.T) {
 
 	time.Sleep(10 * time.Millisecond) //need to switch to gorutine
 	// the engine should be stopped as we could not connect to freeswitch
-	agentCfg := &config.FsAgentCfg{
-		Enabled:          true,
-		CreateCdr:        true,
-		SubscribePark:    true,
-		EventSocketConns: []*config.FsConnCfg{},
-	}
-
-	srv.(*FreeswitchAgent).fS = agents.NewFSsessions(agentCfg, "", nil)
-	runtime.Gosched()
-	err := srv.Reload()
-	if err != nil {
-		t.Fatalf("\nExpected <%+v>, \nReceived <%+v>", nil, err)
-	}
-	time.Sleep(10 * time.Millisecond)
 
 }
+
 func TestFreeSwitchAgentReload2(t *testing.T) {
 	cfg := config.NewDefaultCGRConfig()
 
@@ -148,4 +149,111 @@ func TestFreeSwitchAgentReload3(t *testing.T) {
 		t.Fatalf("\nExpected <%+v>, \nReceived <%+v>", nil, err)
 	}
 }
-*/
+
+func TestFreeSwitchAgentReload4(t *testing.T) {
+	cfg := config.NewDefaultCGRConfig()
+	cfg.SessionSCfg().Enabled = true
+	utils.Logger, _ = utils.Newlogger(utils.MetaSysLog, cfg.GeneralCfg().NodeID)
+	utils.Logger.SetLogLevel(7)
+	filterSChan := make(chan *engine.FilterS, 1)
+	filterSChan <- nil
+	shdChan := utils.NewSyncedChan()
+	chS := engine.NewCacheS(cfg, nil, nil)
+	cacheSChan := make(chan rpcclient.ClientConnector, 1)
+	cacheSChan <- chS
+	srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)}
+	srv := NewFreeswitchAgent(cfg, shdChan, 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)
+	err := srv.(*FreeswitchAgent).reload(srv.(*FreeswitchAgent).fS)
+	if err != nil {
+		t.Fatalf("\nExpected <%+v>, \nReceived <%+v>", nil, err)
+	}
+}
+
+func TestFreeSwitchAgentReload5(t *testing.T) {
+	cfg := config.NewDefaultCGRConfig()
+	cfg.SessionSCfg().Enabled = true
+	utils.Logger, _ = utils.Newlogger(utils.MetaSysLog, cfg.GeneralCfg().NodeID)
+	utils.Logger.SetLogLevel(7)
+	filterSChan := make(chan *engine.FilterS, 1)
+	filterSChan <- nil
+	shdChan := utils.NewSyncedChan()
+	chS := engine.NewCacheS(cfg, nil, nil)
+	cacheSChan := make(chan rpcclient.ClientConnector, 1)
+	cacheSChan <- chS
+	srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)}
+	srv := NewFreeswitchAgent(cfg, shdChan, nil, srvDep)
+	if srv.IsRunning() {
+		t.Fatalf("Expected service to be down")
+	}
+
+	srv.(*FreeswitchAgent).fS = nil
+	err := srv.Start()
+	if err != nil {
+		t.Fatalf("\nExpected <%+v>, \nReceived <%+v>", nil, err)
+	}
+}
+
+func TestFreeSwitchAgentReload6(t *testing.T) {
+	cfg := config.NewDefaultCGRConfig()
+	cfg.SessionSCfg().Enabled = true
+	utils.Logger, _ = utils.Newlogger(utils.MetaSysLog, cfg.GeneralCfg().NodeID)
+	utils.Logger.SetLogLevel(7)
+	filterSChan := make(chan *engine.FilterS, 1)
+	filterSChan <- nil
+	shdChan := utils.NewSyncedChan()
+	chS := engine.NewCacheS(cfg, nil, nil)
+	cacheSChan := make(chan rpcclient.ClientConnector, 1)
+	cacheSChan <- chS
+	srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)}
+	srv := NewFreeswitchAgent(cfg, shdChan, 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)
+	err := srv.Reload()
+	if err != nil {
+		t.Fatalf("\nExpected <%+v>, \nReceived <%+v>", nil, err)
+	}
+}

services/kamailioagent_it_test.go

@@ -68,7 +68,7 @@ func TestKamailioAgentReload(t *testing.T) {
 	}
 
 	if srv.IsRunning() {
-		t.Errorf("Expected service to be down")
+		t.Fatalf("Expected service to be down")
 	}
 	var reply string
 	if err := cfg.V1ReloadConfig(&config.ReloadArgs{
@@ -77,7 +77,7 @@ func TestKamailioAgentReload(t *testing.T) {
 	}, &reply); err != nil {
 		t.Fatal(err)
 	} else if reply != utils.OK {
-		t.Errorf("Expecting OK ,received %s", reply)
+		t.Fatalf("Expecting OK ,received %s", reply)
 	}
 
 	runtime.Gosched()
@@ -94,7 +94,7 @@ func TestKamailioAgentReload(t *testing.T) {
 
 	err := srv.Reload()
 	if err != nil {
-		t.Errorf("\nExpected <%+v>, \nReceived <%+v>", nil, err)
+		t.Fatalf("\nExpected <%+v>, \nReceived <%+v>", nil, err)
 	}
 	time.Sleep(10 * time.Millisecond) //need to switch to gorutine
 	// the engine should be stoped as we could not connect to kamailio
@@ -102,3 +102,53 @@ func TestKamailioAgentReload(t *testing.T) {
 	shdChan.CloseOnce()
 	time.Sleep(10 * time.Millisecond)
 }
+
+func TestKamailioAgentReload2(t *testing.T) {
+	cfg := config.NewDefaultCGRConfig()
+	cfg.SessionSCfg().Enabled = true
+	cfg.SessionSCfg().ListenBijson = ""
+	utils.Logger, _ = utils.Newlogger(utils.MetaSysLog, cfg.GeneralCfg().NodeID)
+	utils.Logger.SetLogLevel(7)
+	filterSChan := make(chan *engine.FilterS, 1)
+	filterSChan <- nil
+	shdChan := utils.NewSyncedChan()
+	srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)}
+	srv := NewKamailioAgent(cfg, shdChan, 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")
+	}
+	err := srv.Start()
+	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 = ""
+	utils.Logger, _ = utils.Newlogger(utils.MetaSysLog, cfg.GeneralCfg().NodeID)
+	utils.Logger.SetLogLevel(7)
+	filterSChan := make(chan *engine.FilterS, 1)
+	filterSChan <- nil
+	shdChan := utils.NewSyncedChan()
+	srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)}
+	srv := NewKamailioAgent(cfg, shdChan, 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")
+	}
+	err := srv.Start()
+	if err == nil || err.Error() != "service already running" {
+		t.Fatalf("\nExpected <%+v>, \nReceived <%+v>", "service already running", err)
+	}
+}

services/radiusagent_it_test.go

@@ -19,7 +19,22 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>
 */
 package services
 
-/*
+import (
+	"path"
+	"runtime"
+	"sync"
+	"testing"
+	"time"
+
+	"github.com/cgrates/cgrates/agents"
+	"github.com/cgrates/cgrates/config"
+	"github.com/cgrates/cgrates/cores"
+	"github.com/cgrates/cgrates/engine"
+	"github.com/cgrates/cgrates/servmanager"
+	"github.com/cgrates/cgrates/utils"
+	"github.com/cgrates/rpcclient"
+)
+
 func TestRadiusAgentReload(t *testing.T) {
 	cfg := config.NewDefaultCGRConfig()
 
@@ -221,4 +236,3 @@ func TestRadiusAgentReload4(t *testing.T) {
 		t.Fatalf("\nExpected <%+v>, \nReceived <%+v>", "unsupported network: <test>", err)
 	}
 }
-*/

services/sessions.go

@@ -113,16 +113,19 @@ func (smg *SessionService) Start() (err error) {
 			smg.server.BiRPCRegisterName(method, handler)
 		}
 		// run this in it's own goroutine
-		go func() {
-			if err := smg.server.ServeBiRPC(smg.cfg.SessionSCfg().ListenBijson,
-				smg.cfg.SessionSCfg().ListenBigob, smg.sm.OnBiJSONConnect, smg.sm.OnBiJSONDisconnect); err != nil {
-				utils.Logger.Err(fmt.Sprintf("<%s> serve BiRPC error: %s!", utils.SessionS, err))
-				smg.Lock()
-				smg.bircpEnabled = false
-				smg.Unlock()
-				smg.shdChan.CloseOnce()
-			}
-		}()
+		go smg.start()
+	}
+	return
+}
+
+func (smg *SessionService) start() (err error) {
+	if err := smg.server.ServeBiRPC(smg.cfg.SessionSCfg().ListenBijson,
+		smg.cfg.SessionSCfg().ListenBigob, smg.sm.OnBiJSONConnect, smg.sm.OnBiJSONDisconnect); err != nil {
+		utils.Logger.Err(fmt.Sprintf("<%s> serve BiRPC error: %s!", utils.SessionS, err))
+		smg.Lock()
+		smg.bircpEnabled = false
+		smg.Unlock()
+		smg.shdChan.CloseOnce()
 	}
 	return
 }

services/sessions_it_test.go

@@ -133,7 +133,7 @@ func TestSessionSReload1(t *testing.T) {
 	srv.(*SessionService).sm.BiRPCv1InitiateSession(nil, args, rply)
 	err = srv.Shutdown()
 	if err == nil || err != utils.ErrPartiallyExecuted {
-		t.Errorf("\nExpecting <%+v>,\n Received <%+v>", utils.ErrPartiallyExecuted, err)
+		t.Fatalf("\nExpecting <%+v>,\n Received <%+v>", utils.ErrPartiallyExecuted, err)
 	}
 }
 
@@ -178,23 +178,73 @@ func TestSessionSReload2(t *testing.T) {
 
 	srv.(*SessionService).sm = &sessions.SessionS{}
 	if !srv.IsRunning() {
-		t.Errorf("\nExpecting service to be running")
+		t.Fatalf("\nExpecting service to be running")
 	}
 	err2 := srv.Start()
 	if err2 != utils.ErrServiceAlreadyRunning {
-		t.Errorf("\nExpecting <%+v>,\n Received <%+v>", utils.ErrServiceAlreadyRunning, err2)
+		t.Fatalf("\nExpecting <%+v>,\n Received <%+v>", utils.ErrServiceAlreadyRunning, err2)
 	}
 	cfg.SessionSCfg().Enabled = false
 	err := srv.Reload()
 	if err != nil {
-		t.Errorf("\nExpecting <nil>,\n Received <%+v>", err)
+		t.Fatalf("\nExpecting <nil>,\n Received <%+v>", err)
 	}
 	time.Sleep(10 * time.Millisecond)
 	srv.(*SessionService).sm = nil
 	if srv.IsRunning() {
-		t.Errorf("Expected service to be down")
+		t.Fatalf("Expected service to be down")
 	}
 	shdChan.CloseOnce()
 	time.Sleep(10 * time.Millisecond)
 
 }
+
+func TestSessionSReload3(t *testing.T) {
+	cfg := config.NewDefaultCGRConfig()
+
+	cfg.ChargerSCfg().Enabled = true
+	cfg.RalsCfg().Enabled = true
+	cfg.CdrsCfg().Enabled = true
+	utils.Logger, _ = utils.Newlogger(utils.MetaSysLog, cfg.GeneralCfg().NodeID)
+	utils.Logger.SetLogLevel(7)
+	filterSChan := make(chan *engine.FilterS, 1)
+	filterSChan <- nil
+	shdChan := utils.NewSyncedChan()
+	chS := engine.NewCacheS(cfg, nil, nil)
+	close(chS.GetPrecacheChannel(utils.CacheChargerProfiles))
+	close(chS.GetPrecacheChannel(utils.CacheChargerFilterIndexes))
+	close(chS.GetPrecacheChannel(utils.CacheDestinations))
+	close(chS.GetPrecacheChannel(utils.CacheReverseDestinations))
+	close(chS.GetPrecacheChannel(utils.CacheRatingPlans))
+	close(chS.GetPrecacheChannel(utils.CacheRatingProfiles))
+	close(chS.GetPrecacheChannel(utils.CacheActions))
+	close(chS.GetPrecacheChannel(utils.CacheActionPlans))
+	close(chS.GetPrecacheChannel(utils.CacheAccountActionPlans))
+	close(chS.GetPrecacheChannel(utils.CacheActionTriggers))
+	close(chS.GetPrecacheChannel(utils.CacheSharedGroups))
+	close(chS.GetPrecacheChannel(utils.CacheTimings))
+
+	internalChan := make(chan rpcclient.ClientConnector, 1)
+	internalChan <- nil
+	cacheSChan := make(chan rpcclient.ClientConnector, 1)
+	cacheSChan <- chS
+
+	server := cores.NewServer(nil)
+
+	srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)}
+	db := NewDataDBService(cfg, nil, srvDep)
+	cfg.StorDbCfg().Type = utils.INTERNAL
+	anz := NewAnalyzerService(cfg, server, filterSChan, shdChan, make(chan rpcclient.ClientConnector, 1), srvDep)
+	srv := NewSessionService(cfg, db, server, make(chan rpcclient.ClientConnector, 1), shdChan, nil, nil, anz, srvDep)
+	engine.NewConnManager(cfg, nil)
+
+	srv.(*SessionService).sm = &sessions.SessionS{}
+	if !srv.IsRunning() {
+		t.Fatalf("\nExpecting service to be running")
+	}
+	err2 := srv.(*SessionService).start()
+	if err2 != nil {
+		t.Fatalf("\nExpected <%+v>, \nReceived <%+v>", nil, err2)
+	}
+
+}

services/sipagent_it_test.go

@@ -88,7 +88,7 @@ func TestSIPAgentReload(t *testing.T) {
 	}
 	err := srv.Reload()
 	if err != nil {
-		t.Fatalf("\nExpecting <err>,\n Received <%+v>", err)
+		t.Fatalf("\nExpecting <nil>,\n Received <%+v>", err)
 	}
 	time.Sleep(10 * time.Millisecond)
 	cfg.SIPAgentCfg().Enabled = false
@@ -101,16 +101,63 @@ func TestSIPAgentReload(t *testing.T) {
 	time.Sleep(10 * time.Millisecond)
 }
 
-/*
-WILLFIX
-	castSrv, canCastSrv := srv.(*SIPAgent)
-	if !canCastSrv {
-		t.Fatalf("cannot cast")
+func TestSIPAgentReload2(t *testing.T) {
+	cfg := config.NewDefaultCGRConfig()
+	cfg.SessionSCfg().Enabled = true
+	cfg.SessionSCfg().ListenBijson = ""
+	utils.Logger, _ = utils.Newlogger(utils.MetaSysLog, cfg.GeneralCfg().NodeID)
+	utils.Logger.SetLogLevel(7)
+	filterSChan := make(chan *engine.FilterS, 1)
+	filterSChan <- nil
+	shdChan := utils.NewSyncedChan()
+	chS := engine.NewCacheS(cfg, nil, nil)
+	cacheSChan := make(chan rpcclient.ClientConnector, 1)
+	cacheSChan <- chS
+	srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)}
+	srv := NewSIPAgent(cfg, filterSChan, shdChan, nil, srvDep)
+	if srv.IsRunning() {
+		t.Fatalf("Expected service to be down")
 	}
-	castSrv.sip = srvSIP
-	castSrv.oldListen = "test_string"
+	cfg.SIPAgentCfg().RequestProcessors = []*config.RequestProcessor{
+		{
+			RequestFields: []*config.FCTemplate{
+				{
+					Type: utils.MetaTemplate,
+				},
+			},
+		},
+	}
+	err := srv.Start()
+	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 = ""
+	utils.Logger, _ = utils.Newlogger(utils.MetaSysLog, cfg.GeneralCfg().NodeID)
+	utils.Logger.SetLogLevel(7)
+	filterSChan := make(chan *engine.FilterS, 1)
+	filterSChan <- nil
+	shdChan := utils.NewSyncedChan()
+	chS := engine.NewCacheS(cfg, nil, nil)
+	cacheSChan := make(chan rpcclient.ClientConnector, 1)
+	cacheSChan <- chS
+	srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)}
+	srv := NewSIPAgent(cfg, filterSChan, shdChan, nil, srvDep)
+	if srv.IsRunning() {
+		t.Fatalf("Expected service to be down")
+	}
+	err := srv.Start()
+	if err != nil {
+		t.Fatalf("\nExpecting <%+v>,\n Received <%+v>", nil, err)
+	}
+	srv.(*SIPAgent).oldListen = "test"
 	err = srv.Reload()
 	if err != nil {
-		t.Fatalf("\nExpecting <nil>,\n Received <%+v>", err)
+		t.Fatalf("\nExpecting <%+v>,\n Received <%+v>", nil, err)
 	}
-*/
+}