Continuing tests in services

services/actions_it_test.go

@@ -1,3 +1,5 @@
+// +build integration
+
 /*
 Real-time Online/Offline Charging System (OCS) for Telecom & ISP environments
 Copyright (C) ITsysCOM GmbH
@@ -18,6 +20,7 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>
 package services
 
 import (
+	"fmt"
 	"reflect"
 	"sync"
 	"testing"
@@ -58,6 +61,7 @@ func TestNewActionService(t *testing.T) {
 		srvDep:      srvDep,
 		rldChan:     make(chan struct{}),
 	}
+	fmt.Println(reflect.TypeOf(actS))
 	if !reflect.DeepEqual(utils.ToJSON(actS), utils.ToJSON(expected)) {
 		t.Errorf("\nExpecting <%+v>,\n Received <%+v>", utils.ToJSON(expected), utils.ToJSON(actS))
 	}

services/analyzers_it_test.go

@@ -0,0 +1,90 @@
+// +build integration
+
+/*
+Real-time Online/Offline Charging System (OCS) for Telecom & ISP environments
+Copyright (C) ITsysCOM GmbH
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>
+*/
+package services
+
+import (
+	"reflect"
+	"sync"
+	"testing"
+
+	"github.com/cgrates/cgrates/config"
+	"github.com/cgrates/cgrates/cores"
+	"github.com/cgrates/cgrates/engine"
+	"github.com/cgrates/cgrates/utils"
+	"github.com/cgrates/rpcclient"
+)
+
+func TestNewAnalyzerService(t *testing.T) {
+	cfg := config.NewDefaultCGRConfig()
+	utils.Logger, _ = utils.Newlogger(utils.MetaSysLog, cfg.GeneralCfg().NodeID)
+	utils.Logger.SetLogLevel(7)
+	shdChan := utils.NewSyncedChan()
+	chS := engine.NewCacheS(cfg, nil, nil)
+	filterSChan := make(chan *engine.FilterS, 1)
+	filterSChan <- nil
+	close(chS.GetPrecacheChannel(utils.CacheActionProfiles))
+	close(chS.GetPrecacheChannel(utils.CacheActionProfilesFilterIndexes))
+	server := cores.NewServer(nil)
+	srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)}
+	connChan := make(chan rpcclient.ClientConnector, 1)
+	anz := NewAnalyzerService(cfg, server, filterSChan, shdChan, connChan, srvDep)
+	expected := &AnalyzerService{
+		connChan:    connChan,
+		cfg:         cfg,
+		server:      server,
+		filterSChan: filterSChan,
+		shdChan:     shdChan,
+		srvDep:      srvDep,
+	}
+	if !reflect.DeepEqual(anz, expected) {
+		t.Errorf("\nExpecting <%+v>,\n Received <%+v>", utils.ToJSON(expected), utils.ToJSON(anz))
+	}
+}
+
+func TestAnalyzerSNotRunning(t *testing.T) {
+	cfg := config.NewDefaultCGRConfig()
+	utils.Logger, _ = utils.Newlogger(utils.MetaSysLog, cfg.GeneralCfg().NodeID)
+	utils.Logger.SetLogLevel(7)
+	shdChan := utils.NewSyncedChan()
+	chS := engine.NewCacheS(cfg, nil, nil)
+	filterSChan := make(chan *engine.FilterS, 1)
+	filterSChan <- nil
+	close(chS.GetPrecacheChannel(utils.CacheActionProfiles))
+	close(chS.GetPrecacheChannel(utils.CacheActionProfilesFilterIndexes))
+	server := cores.NewServer(nil)
+	srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)}
+	connChan := make(chan rpcclient.ClientConnector, 1)
+	anz := NewAnalyzerService(cfg, server, filterSChan, shdChan, connChan, srvDep)
+	if anz.IsRunning() {
+		t.Errorf("Expected service to be down")
+	}
+	serviceName := anz.ServiceName()
+	if !reflect.DeepEqual(serviceName, utils.AnalyzerS) {
+		t.Errorf("\nExpecting <ActionS>,\n Received <%+v>", serviceName)
+	}
+	shouldRun := anz.ShouldRun()
+	if !reflect.DeepEqual(shouldRun, false) {
+		t.Errorf("\nExpecting <false>,\n Received <%+v>", shouldRun)
+	}
+	getAnalyzerS := anz.GetAnalyzerS()
+	if !reflect.DeepEqual(anz.anz, getAnalyzerS) {
+		t.Errorf("\nExpecting <%+v>,\n Received <%+v>", utils.ToJSON(anz.anz), utils.ToJSON(getAnalyzerS))
+	}
+}

services/attributes.go

@@ -65,7 +65,7 @@ type AttributeService struct {
 	srvDep   map[string]*sync.WaitGroup
 }
 
-// Start should handle the sercive start
+// Start should handle the service start
 func (attrS *AttributeService) Start() (err error) {
 	if attrS.IsRunning() {
 		return utils.ErrServiceAlreadyRunning

services/attributes_it_test.go

@@ -90,12 +90,23 @@ func TestAttributeSReload(t *testing.T) {
 	if !db.IsRunning() {
 		t.Errorf("Expected service to be running")
 	}
+	err := attrS.Start()
+	if err == nil || err != utils.ErrServiceAlreadyRunning {
+		t.Errorf("\nExpecting <%+v>,\n Received <%+v>", utils.ErrServiceAlreadyRunning, err)
+	}
+	err = attrS.Reload()
+	if err != nil {
+		t.Errorf("\nExpecting <nil>,\n Received <%+v>", err)
+	}
 	cfg.AttributeSCfg().Enabled = false
 	cfg.GetReloadChan(config.ATTRIBUTE_JSN) <- struct{}{}
 	time.Sleep(10 * time.Millisecond)
+
 	if attrS.IsRunning() {
 		t.Errorf("Expected service to be down")
 	}
+
 	shdChan.CloseOnce()
 	time.Sleep(10 * time.Millisecond)
+
 }

services/schedulers_it_test.go

@@ -21,6 +21,7 @@ package services
 
 import (
 	"path"
+	"reflect"
 	"sync"
 	"testing"
 	"time"
@@ -78,6 +79,18 @@ func TestSchedulerSReload(t *testing.T) {
 	if !db.IsRunning() {
 		t.Errorf("Expected service to be running")
 	}
+	err := schS.Start()
+	if err == nil || err != utils.ErrServiceAlreadyRunning {
+		t.Errorf("\nExpecting <%+v>,\n Received <%+v>", utils.ErrServiceAlreadyRunning, err)
+	}
+	err = schS.Reload()
+	if err != nil {
+		t.Errorf("\nExpecting <nil>,\n Received <%+v>", err)
+	}
+	getScheduler := schS.GetScheduler()
+	if !reflect.DeepEqual(schS.schS, getScheduler) {
+		t.Errorf("\nExpecting <%+v>,\n Received <%+v>", utils.ToJSON(schS.schS), utils.ToJSON(getScheduler))
+	}
 	cfg.SchedulerCfg().Enabled = false
 	cfg.GetReloadChan(config.SCHEDULER_JSN) <- struct{}{}
 	time.Sleep(10 * time.Millisecond)

services/sessions_it_test.go

@@ -113,6 +113,14 @@ func TestSessionSReload(t *testing.T) {
 	if !db.IsRunning() {
 		t.Errorf("Expected service to be running")
 	}
+	err := srv.Start()
+	if err == nil || err != utils.ErrServiceAlreadyRunning {
+		t.Errorf("\nExpecting <%+v>,\n Received <%+v>", utils.ErrServiceAlreadyRunning, err)
+	}
+	err = srv.Reload()
+	if err != nil {
+		t.Errorf("\nExpecting <nil>,\n Received <%+v>", err)
+	}
 	cfg.SessionSCfg().Enabled = false
 	cfg.GetReloadChan(config.SessionSJson) <- struct{}{}
 	time.Sleep(10 * time.Millisecond)

services/sipagent_it_test.go

@@ -78,6 +78,10 @@ func TestSIPAgentReload(t *testing.T) {
 	if !srv.IsRunning() {
 		t.Errorf("Expected service to be running")
 	}
+	err := srv.Reload()
+	if err != nil {
+		t.Errorf("\nExpecting <err>,\n Received <%+v>", err)
+	}
 	cfg.SIPAgentCfg().Enabled = false
 	cfg.GetReloadChan(config.SIPAgentJson) <- struct{}{}
 	time.Sleep(10 * time.Millisecond)

services/stats_it_test.go

@@ -87,6 +87,14 @@ func TestStatSReload(t *testing.T) {
 	if !db.IsRunning() {
 		t.Errorf("Expected service to be running")
 	}
+	err := sS.Start()
+	if err == nil || err != utils.ErrServiceAlreadyRunning {
+		t.Errorf("\nExpecting <%+v>,\n Received <%+v>", utils.ErrServiceAlreadyRunning, err)
+	}
+	err = sS.Reload()
+	if err != nil {
+		t.Errorf("\nExpecting <nil>,\n Received <%+v>", err)
+	}
 	cfg.StatSCfg().Enabled = false
 	cfg.GetReloadChan(config.STATS_JSON) <- struct{}{}
 	time.Sleep(10 * time.Millisecond)

services/thresholds_it_test.go

@@ -81,6 +81,14 @@ func TestThresholdSReload(t *testing.T) {
 	if !db.IsRunning() {
 		t.Errorf("Expected service to be running")
 	}
+	err := tS.Start()
+	if err == nil || err != utils.ErrServiceAlreadyRunning {
+		t.Errorf("\nExpecting <%+v>,\n Received <%+v>", utils.ErrServiceAlreadyRunning, err)
+	}
+	err = tS.Reload()
+	if err != nil {
+		t.Errorf("\nExpecting <nil>,\n Received <%+v>", err)
+	}
 	cfg.ThresholdSCfg().Enabled = false
 	cfg.GetReloadChan(config.THRESHOLDS_JSON) <- struct{}{}
 	time.Sleep(10 * time.Millisecond)