Add new unit tests on agents

agents/kamevent_test.go

@@ -653,3 +653,35 @@ func TestKamEventKamReplyString(t *testing.T) {
 		t.Errorf("Event mismatch. Expected: %s, Got: %v", krply.Event, unmarshalledResult["Event"])
 	}
 }
+
+func TestKamEventProcessMessageEmptyReply(t *testing.T) {
+	kev := KamEvent{
+		"KamReplyRoute": "CGR_PROCESS_MESSAGE",
+	}
+	kar := kev.AsKamProcessMessageEmptyReply()
+	if kar.Event != "CGR_PROCESS_MESSAGE" {
+		t.Errorf("expected event name 'CGR_PROCESS_MESSAGE', got %s", kar.Event)
+	}
+
+}
+
+func TestAsKamProcessCDRReply(t *testing.T) {
+	kev := KamEvent{
+		"KamReplyRoute": "CGR_PROCESS_CDR",
+		"KamTRIndex":    "123",
+		"KamTRLabel":    "456",
+	}
+	cgrEvWithArgDisp := &utils.CGREvent{}
+	rply := "reply"
+	var rplyErr error
+	kar, err := kev.AsKamProcessCDRReply(cgrEvWithArgDisp, &rply, rplyErr)
+	if kar.Event != "CGR_PROCESS_CDR" {
+		t.Errorf("expected event name 'CGR_PROCESS_CDR', got %s", kar.Event)
+	}
+	if kar.Error != "" {
+		t.Errorf("unexpected error: %s", kar.Error)
+	}
+	if err != nil {
+		t.Errorf("unexpected error: %v", err)
+	}
+}

agents/libdns_test.go

@@ -242,3 +242,49 @@ func TestLibdnsNewDnsReply(t *testing.T) {
 		}
 	}
 }
+
+func TestLibdnsUpdateDnsRRHeader(t *testing.T) {
+	type testCase struct {
+		name  string
+		v     *dns.RR_Header
+		path  []string
+		value interface{}
+		err   error
+	}
+	testCases := []testCase{
+		{
+			name:  "Update Name",
+			v:     &dns.RR_Header{},
+			path:  []string{utils.DNSName},
+			value: "cgrates.org",
+		},
+		{
+			name:  "Update Rrtype (valid)",
+			v:     &dns.RR_Header{},
+			path:  []string{utils.DNSRrtype},
+			value: 1,
+		},
+		{
+			name:  "Wrong path",
+			v:     &dns.RR_Header{},
+			path:  []string{"invalid"},
+			value: "cgrates.org",
+			err:   utils.ErrWrongPath,
+		},
+		{
+			name:  "Empty path",
+			v:     &dns.RR_Header{},
+			path:  []string{},
+			value: "cgrates.org",
+			err:   utils.ErrWrongPath,
+		},
+	}
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			err := updateDnsRRHeader(tc.v, tc.path, tc.value)
+			if err != tc.err {
+				t.Errorf("Expected error %v, got %v", tc.err, err)
+			}
+		})
+	}
+}

agents/libsip_test.go

@@ -60,3 +60,14 @@ func TestUpdateSIPMsgFromNavMap(t *testing.T) {
 		t.Errorf("Expected: %s , received: %s", expected, m)
 	}
 }
+
+func TestLibsipBareSipErr(t *testing.T) {
+	m := sipingo.Message{
+		"requestHeader": "test-header",
+	}
+	errMsg := "test-header"
+	updatedMsg := bareSipErr(m, errMsg)
+	if updatedMsg["requestHeader"] != errMsg {
+		t.Errorf("expected error message %s, got %s", errMsg, updatedMsg["requestHeader"])
+	}
+}

agents/radagent_test.go

@@ -22,8 +22,10 @@ import (
 	"reflect"
 	"testing"
 
+	"github.com/cgrates/birpc/context"
 	"github.com/cgrates/cgrates/config"
 	"github.com/cgrates/cgrates/sessions"
+	"github.com/cgrates/cgrates/utils"
 	"github.com/cgrates/radigo"
 )
 
@@ -95,3 +97,99 @@ func TestNewRadiusDAClientCfgOK(t *testing.T) {
 	}
 
 }
+func TestRadagentV1DisconnectPeer(t *testing.T) {
+	TestAgent := &RadiusAgent{}
+	ctx := context.Background()
+	args := &utils.DPRArgs{}
+	var reply *string
+	err := TestAgent.V1DisconnectPeer(ctx, args, reply)
+	if err != utils.ErrNotImplemented {
+		t.Errorf("Expected error %v, got %v", utils.ErrNotImplemented, err)
+	}
+}
+
+func TestRadagentV1GetActiveSessionIDs(t *testing.T) {
+	TestAgent := &RadiusAgent{}
+	ctx := context.Background()
+	clientId := "test-client-id"
+	var sessionIDs []*sessions.SessionID
+	err := TestAgent.V1GetActiveSessionIDs(ctx, clientId, &sessionIDs)
+	if err != utils.ErrNotImplemented {
+		t.Errorf("Expected error %v, got %v", utils.ErrNotImplemented, err)
+	}
+
+}
+
+func TestRadagentV1WarnDisconnect(t *testing.T) {
+	agent := &RadiusAgent{}
+	err := agent.V1WarnDisconnect(context.Background(), map[string]any{}, nil)
+	if err == nil {
+		t.Errorf("Expected error 'not implemented', got nil")
+	} else if err.Error() != utils.ErrNotImplemented.Error() {
+		t.Errorf("Expected error 'not implemented', got '%v'", err.Error())
+	}
+}
+
+func TestRadagentDaRequestAddress(t *testing.T) {
+	type testCase struct {
+		name         string
+		remoteAddr   string
+		dynAuthAddrs map[string]config.DAClientOpts
+		expectedAddr string
+		expectedHost string
+		expectedErr  error
+	}
+	testCases := []testCase{
+		{
+			name:         "Empty dynAuthAddresses",
+			remoteAddr:   "testhost:1234",
+			dynAuthAddrs: map[string]config.DAClientOpts{},
+			expectedAddr: "",
+			expectedHost: "",
+			expectedErr:  utils.ErrNotFound,
+		},
+		{
+			name:       "Matching remote host",
+			remoteAddr: "matchinghost:5678",
+			dynAuthAddrs: map[string]config.DAClientOpts{
+				"matchinghost": {Host: "targethost", Port: 8080},
+			},
+			expectedAddr: "targethost:8080",
+			expectedHost: "matchinghost",
+			expectedErr:  nil,
+		},
+		{
+			name:       "Non-matching remote host",
+			remoteAddr: "nonmatchinghost:9012",
+			dynAuthAddrs: map[string]config.DAClientOpts{
+				"otherhost": {Host: "yetanotherhost", Port: 3000},
+			},
+			expectedAddr: "",
+			expectedHost: "",
+			expectedErr:  utils.ErrNotFound,
+		},
+		{
+			name:         "Invalid remote address format",
+			remoteAddr:   "invalidformat",
+			dynAuthAddrs: map[string]config.DAClientOpts{},
+			expectedAddr: "",
+			expectedHost: "",
+			expectedErr:  utils.ErrNotFound,
+		},
+	}
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			addr, host, err := daRequestAddress(tc.remoteAddr, tc.dynAuthAddrs)
+
+			if err != tc.expectedErr {
+				t.Errorf("Error does not match: expected %v, got %v", tc.expectedErr, err)
+			}
+			if addr != tc.expectedAddr {
+				t.Errorf("Address does not match: expected %v, got %v", tc.expectedAddr, addr)
+			}
+			if host != tc.expectedHost {
+				t.Errorf("Host does not match: expected %v, got %v", tc.expectedHost, host)
+			}
+		})
+	}
+}