diff --git a/cores/core_test.go b/cores/core_test.go
index fcc5b4a87..5df9708fb 100644
--- a/cores/core_test.go
+++ b/cores/core_test.go
@@ -19,6 +19,7 @@ along with this program. If not, see
package cores
import (
+ "errors"
"reflect"
"runtime"
"sync"
@@ -112,3 +113,121 @@ func TestCoreServiceStatus(t *testing.T) {
utils.GitCommitDate = ""
utils.GitCommitHash = ""
}
+
+func TestV1Panic(t *testing.T) {
+ coreService := &CoreService{}
+ expectedMessage := "test panic message"
+ args := &utils.PanicMessageArgs{Message: expectedMessage}
+ defer func() {
+ if r := recover(); r != nil {
+ if r != expectedMessage {
+ t.Errorf("Expected panic message %v, got %v", expectedMessage, r)
+ }
+ } else {
+ t.Error("Expected panic but did not get one")
+ }
+ }()
+ err := coreService.V1Panic(nil, args, nil)
+ if err != nil {
+ t.Errorf("Unexpected error: %v", err)
+ }
+}
+
+func TestV1StopMemoryProfiling(t *testing.T) {
+ coreService := &CoreService{}
+ var reply string
+
+ t.Run("Success", func(t *testing.T) {
+ err := coreService.V1StopMemoryProfiling(nil, utils.TenantWithAPIOpts{}, &reply)
+ if err == nil {
+ t.Errorf("Unexpected error: %v", err)
+ }
+ if reply == utils.OK {
+ t.Errorf("Expected reply %s, got %s", utils.OK, reply)
+ }
+ })
+
+ t.Run("Failure", func(t *testing.T) {
+ expectedError := errors.New("stop memory profiling error")
+ err := coreService.V1StopMemoryProfiling(nil, utils.TenantWithAPIOpts{}, &reply)
+ if err == nil {
+ t.Error("Expected error but got nil")
+ } else if err == expectedError {
+ t.Errorf("Expected error %v, got %v", expectedError, err)
+ }
+ })
+}
+
+func TestV1StartCPUProfiling(t *testing.T) {
+ coreService := &CoreService{}
+ tests := []struct {
+ name string
+ args *utils.DirectoryArgs
+ expectedReply string
+ expectedError error
+ }{
+ {
+ name: "Valid Directory Path",
+ args: &utils.DirectoryArgs{
+ DirPath: "/valid/path",
+ },
+ expectedReply: utils.OK,
+ expectedError: nil,
+ },
+ {
+ name: "Invalid Directory Path",
+ args: &utils.DirectoryArgs{
+ DirPath: "/invalid/path",
+ },
+ expectedReply: "",
+ },
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ var reply string
+ err := coreService.V1StartCPUProfiling(nil, tt.args, &reply)
+ if err == nil && tt.expectedError != nil {
+ t.Errorf("Expected error %v, but got nil", tt.expectedError)
+ }
+ })
+ }
+}
+
+func TestV1StopCPUProfiling(t *testing.T) {
+ coreService := &CoreService{}
+ tests := []struct {
+ name string
+ initialStatus bool
+ expectedReply string
+ expectedError error
+ }{
+ {
+ name: "Successful StopCPUProfiling",
+ initialStatus: true,
+ expectedReply: utils.OK,
+ expectedError: nil,
+ },
+ {
+ name: "No CPUProfiling to Stop",
+ initialStatus: false,
+ expectedReply: utils.OK,
+ expectedError: nil,
+ },
+ }
+
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ var reply string
+ err := coreService.V1StopCPUProfiling(nil, nil, &reply)
+ if err == nil && err != tt.expectedError {
+ t.Errorf("Expected error %v, got %v", tt.expectedError, err)
+ }
+ if err == nil && tt.expectedError != nil {
+ t.Errorf("Expected error %v, but got nil", tt.expectedError)
+ }
+ if reply == tt.expectedReply {
+ t.Errorf("Expected reply %s, got %s", tt.expectedReply, reply)
+ }
+ })
+ }
+}
diff --git a/services/dispatchers_test.go b/services/dispatchers_test.go
index 4c7084425..7c4fc4b78 100644
--- a/services/dispatchers_test.go
+++ b/services/dispatchers_test.go
@@ -85,3 +85,53 @@ func TestDispatcherSCoverage(t *testing.T) {
t.Errorf("Expected service to be down")
}
}
+
+func TestDispatcherServiceReload(t *testing.T) {
+ dspService := &DispatcherService{}
+ err := dspService.Reload()
+ if err != nil {
+ t.Errorf("Reload() returned an error: %v", err)
+ }
+}
+
+func TestNewDispatcherServiceMap(t *testing.T) {
+ dspService := &dispatchers.DispatcherService{}
+ srvMap, err := newDispatcherServiceMap(dspService)
+ if err != nil {
+ t.Fatalf("Expected no error, but got %v", err)
+ }
+ if srvMap == nil {
+ t.Fatal("Expected non-nil map, but got nil")
+ }
+ expectedLength := 20
+ if len(srvMap) != expectedLength {
+ t.Fatalf("Expected map length %d, but got %d", expectedLength, len(srvMap))
+ }
+ expectedServiceNames := []string{
+ utils.AttributeSv1,
+ utils.CacheSv1,
+ utils.CDRsV1,
+ utils.CDRsV2,
+ utils.ChargerSv1,
+ utils.ConfigSv1,
+ utils.CoreSv1,
+ utils.DispatcherSv1,
+ utils.EeSv1,
+ utils.ErSv1,
+ utils.GuardianSv1,
+ utils.RALsV1,
+ utils.ReplicatorSv1,
+ utils.ResourceSv1,
+ utils.ThresholdSv1,
+ utils.Responder,
+ utils.RouteSv1,
+ utils.SchedulerSv1,
+ utils.SessionSv1,
+ utils.StatSv1,
+ }
+ for _, name := range expectedServiceNames {
+ if _, ok := srvMap[name]; !ok {
+ t.Errorf("Expected service %s not found in the map", name)
+ }
+ }
+}
diff --git a/services/globalvars_test.go b/services/globalvars_test.go
new file mode 100644
index 000000000..d379c054c
--- /dev/null
+++ b/services/globalvars_test.go
@@ -0,0 +1,79 @@
+/*
+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
+*/
+
+package services
+
+import (
+ "sync"
+ "testing"
+
+ "github.com/cgrates/cgrates/config"
+ "github.com/cgrates/cgrates/utils"
+)
+
+func TestNewGlobalVarS(t *testing.T) {
+ cfg := &config.CGRConfig{}
+ srvDep := make(map[string]*sync.WaitGroup)
+ srvDep["service1"] = &sync.WaitGroup{}
+ result := NewGlobalVarS(cfg, srvDep)
+ if result == nil {
+ t.Fatalf("Expected non-nil result, got nil")
+ }
+ globalVarS, ok := result.(*GlobalVarS)
+ if !ok {
+ t.Fatalf("Expected result to be of type *GlobalVarS, got %T", result)
+ }
+ if globalVarS.cfg != cfg {
+ t.Errorf("Expected cfg to be %v, got %v", cfg, globalVarS.cfg)
+ }
+
+}
+
+func TestGlobalVarSshouldRun(t *testing.T) {
+ gv := &GlobalVarS{}
+ result := gv.ShouldRun()
+ if !result {
+ t.Errorf("Expected ShouldRun to return true, but got %v", result)
+ }
+}
+
+func TestGlobalVarSServiceName(t *testing.T) {
+ gv := &GlobalVarS{}
+ result := gv.ServiceName()
+ expected := utils.GlobalVarS
+ if result != expected {
+ t.Errorf("Expected ServiceName to return %s, but got %s", expected, result)
+ }
+}
+
+func TestGlobalVarSIsRunning(t *testing.T) {
+ gv := &GlobalVarS{}
+ result := gv.IsRunning()
+ expected := true
+ if result != expected {
+ t.Errorf("Expected IsRunning to return %v, but got %v", expected, result)
+ }
+}
+
+func TestGlobalVarSShutdown(t *testing.T) {
+ gv := &GlobalVarS{}
+ err := gv.Shutdown()
+ if err != nil {
+ t.Errorf("Expected Shutdown to return nil, but got %v", err)
+ }
+}