chore: add unit tests for agent proxy status handling and validation

Author: actions-user

backend/internal/api/handlers/orthrus_handler_test.go

@@ -713,3 +713,112 @@ func TestOrthrusHandler_GetProxyStatus_Connected(t *testing.T) {
 	assert.Equal(t, "0.0.0.0:2375", resp["bind_address"])
 	assert.Equal(t, "tcp://charon:2375", resp["connection_string"])
 }
+
+// TestOrthrusHandler_SetProxyResolver_TypedNilClearsResolver verifies that
+// passing a typed nil pointer (non-nil interface wrapping nil pointer) causes
+// SetProxyResolver to clear the stored resolver via the reflect.IsNil branch.
+func TestOrthrusHandler_SetProxyResolver_TypedNilClearsResolver(t *testing.T) {
+	h, _ := newOrthrusTestSetup(t)
+
+	// Wire a valid resolver first.
+	h.SetProxyResolver(&mockProxyResolver{ok: true})
+
+	// Pass a typed nil *mockProxyResolver — the interface value is non-nil but
+	// rv.IsNil() returns true, exercising the h.proxyResolver = nil / return path.
+	var nilResolver *mockProxyResolver
+	h.SetProxyResolver(nilResolver)
+
+	// Confirm the resolver was cleared: provision an agent and verify
+	// GetProxyStatus returns agent_online=false (no resolver active).
+	wProv := httptest.NewRecorder()
+	cProv, _ := gin.CreateTestContext(wProv)
+	cProv.Request = httptest.NewRequest(http.MethodPost, "/management/orthrus/agents",
+		bytes.NewBufferString(`{"name":"typed-nil-agent"}`))
+	cProv.Request.Header.Set("Content-Type", "application/json")
+	h.Provision(cProv)
+	require.Equal(t, http.StatusCreated, wProv.Code)
+	var provisioned map[string]any
+	require.NoError(t, json.Unmarshal(wProv.Body.Bytes(), &provisioned))
+	agentUUID := provisioned["agent"].(map[string]any)["uuid"].(string)
+
+	w := httptest.NewRecorder()
+	c, _ := gin.CreateTestContext(w)
+	c.Request = httptest.NewRequest(http.MethodGet, "/management/orthrus/agents/"+agentUUID+"/proxy-status", http.NoBody)
+	c.Params = gin.Params{{Key: "uuid", Value: agentUUID}}
+	h.GetProxyStatus(c)
+
+	assert.Equal(t, http.StatusOK, w.Code)
+	var resp map[string]any
+	require.NoError(t, json.Unmarshal(w.Body.Bytes(), &resp))
+	assert.Equal(t, false, resp["agent_online"])
+}
+
+// TestOrthrusHandler_Patch_MalformedJSON verifies that sending a body that
+// cannot be parsed as JSON triggers the ShouldBindJSON error path → 400.
+func TestOrthrusHandler_Patch_MalformedJSON(t *testing.T) {
+	h, _ := newOrthrusTestSetup(t)
+
+	w := httptest.NewRecorder()
+	c, _ := gin.CreateTestContext(w)
+	c.Request = httptest.NewRequest(http.MethodPatch, "/management/orthrus/agents/any-uuid",
+		bytes.NewBufferString(`{not valid json`))
+	c.Request.Header.Set("Content-Type", "application/json")
+	c.Params = gin.Params{{Key: "uuid", Value: "any-uuid"}}
+
+	h.Patch(c)
+
+	assert.Equal(t, http.StatusBadRequest, w.Code)
+}
+
+// TestOrthrusHandler_GetProxyStatus_AgentNotFound verifies that requesting
+// proxy status for a non-existent agent UUID returns 404.
+func TestOrthrusHandler_GetProxyStatus_AgentNotFound(t *testing.T) {
+	h, _ := newOrthrusTestSetup(t)
+
+	w := httptest.NewRecorder()
+	c, _ := gin.CreateTestContext(w)
+	c.Request = httptest.NewRequest(http.MethodGet, "/management/orthrus/agents/does-not-exist/proxy-status", http.NoBody)
+	c.Params = gin.Params{{Key: "uuid", Value: "does-not-exist"}}
+
+	h.GetProxyStatus(c)
+
+	assert.Equal(t, http.StatusNotFound, w.Code)
+}
+
+// TestOrthrusHandler_GetProxyStatus_Connected_WithError verifies that when the
+// resolver returns a status with a non-empty Error field, the error is included
+// in the response — covering the if status.Error != "" branch.
+func TestOrthrusHandler_GetProxyStatus_Connected_WithError(t *testing.T) {
+	h, _ := newOrthrusTestSetup(t)
+
+	wProv := httptest.NewRecorder()
+	cProv, _ := gin.CreateTestContext(wProv)
+	cProv.Request = httptest.NewRequest(http.MethodPost, "/management/orthrus/agents",
+		bytes.NewBufferString(`{"name":"error-agent"}`))
+	cProv.Request.Header.Set("Content-Type", "application/json")
+	h.Provision(cProv)
+	require.Equal(t, http.StatusCreated, wProv.Code)
+	var provisioned map[string]any
+	require.NoError(t, json.Unmarshal(wProv.Body.Bytes(), &provisioned))
+	agentUUID := provisioned["agent"].(map[string]any)["uuid"].(string)
+
+	errStatus := orthrus.ExternalProxyStatus{
+		ConfiguredPort: 2375,
+		Active:         false,
+		Error:          "bind failed: address already in use",
+	}
+	h.SetProxyResolver(&mockProxyResolver{status: errStatus, ok: true})
+
+	w := httptest.NewRecorder()
+	c, _ := gin.CreateTestContext(w)
+	c.Request = httptest.NewRequest(http.MethodGet, "/management/orthrus/agents/"+agentUUID+"/proxy-status", http.NoBody)
+	c.Params = gin.Params{{Key: "uuid", Value: agentUUID}}
+	h.GetProxyStatus(c)
+
+	assert.Equal(t, http.StatusOK, w.Code)
+	var resp map[string]any
+	require.NoError(t, json.Unmarshal(w.Body.Bytes(), &resp))
+	assert.Equal(t, true, resp["agent_online"])
+	assert.Equal(t, false, resp["active"])
+	assert.Equal(t, "bind failed: address already in use", resp["error"])
+}

frontend/src/api/__tests__/orthrus.test.ts

@@ -10,6 +10,7 @@ import {
   getInstallSnippets,
   patchAgent,
   renameAgent,
+  getAgentProxyStatus,
 } from '../orthrus'
 
 vi.mock('../client', () => ({
@@ -175,4 +176,30 @@ describe('orthrus API', () => {
       await expect(getInstallSnippets('agent-uuid')).rejects.toThrow('snippets failed')
     })
   })
+
+  describe('getAgentProxyStatus', () => {
+    it('calls the proxy-status endpoint and returns data', async () => {
+      const status = {
+        agent_uuid: 'agent-uuid',
+        agent_online: true,
+        configured_port: 2375,
+        active: true,
+        active_port: 2375,
+        bind_address: '0.0.0.0:2375',
+        connection_string: 'tcp://charon:2375',
+        error: '',
+      }
+      vi.mocked(client.get).mockResolvedValue({ data: status })
+
+      const result = await getAgentProxyStatus('agent-uuid')
+
+      expect(client.get).toHaveBeenCalledWith('/orthrus/agents/agent-uuid/proxy-status')
+      expect(result).toEqual(status)
+    })
+
+    it('propagates errors', async () => {
+      vi.mocked(client.get).mockRejectedValue(new Error('proxy status failed'))
+      await expect(getAgentProxyStatus('agent-uuid')).rejects.toThrow('proxy status failed')
+    })
+  })
 })

frontend/src/components/hecate/__tests__/AgentExternalProxyDialog.test.tsx

@@ -0,0 +1,241 @@
+import { render, screen, fireEvent, waitFor, act } from '@testing-library/react';
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+import { type OrthrusAgent } from '../../../api/orthrus';
+import { AgentExternalProxyDialog } from '../AgentExternalProxyDialog';
+
+const mockPatch = vi.fn();
+const mockRefetchStatus = vi.fn();
+let mockProxyStatus: Record<string, unknown> | undefined = undefined;
+
+vi.mock('../../../hooks/useOrthrus', () => ({
+  usePatchAgent: () => ({ mutate: mockPatch, isPending: false }),
+  useAgentProxyStatus: () => ({
+    data: mockProxyStatus,
+    refetch: mockRefetchStatus,
+  }),
+}));
+
+vi.mock('react-i18next', () => ({
+  useTranslation: () => ({
+    t: (key: string, opts?: Record<string, string>) =>
+      opts?.name ? `${key}:${opts.name}` : key,
+  }),
+}));
+
+const baseAgent: OrthrusAgent = {
+  uuid: 'agent-1',
+  name: 'Test Agent',
+  status: 'online',
+  capabilities: '["proxy"]',
+  hecate_tunnel_uuid: undefined,
+  resolved_address: undefined,
+  device_id: undefined,
+  created_at: '2025-01-01T00:00:00Z',
+  updated_at: '2025-01-01T00:00:00Z',
+  external_proxy_port: 2375,
+};
+
+const renderDialog = (agent: OrthrusAgent = baseAgent, open = true, onClose = vi.fn()) =>
+  render(<AgentExternalProxyDialog agent={agent} open={open} onClose={onClose} />);
+
+beforeEach(() => {
+  mockPatch.mockReset();
+  mockRefetchStatus.mockReset();
+  mockProxyStatus = undefined;
+});
+
+describe('AgentExternalProxyDialog', () => {
+  describe('port validation', () => {
+    it('shows no error for port 0', () => {
+      renderDialog({ ...baseAgent, external_proxy_port: 0 });
+      expect(screen.queryByRole('alert')).not.toBeInTheDocument();
+    });
+
+    it('shows no error for a valid port in 1024–65535', () => {
+      renderDialog({ ...baseAgent, external_proxy_port: 2375 });
+      expect(screen.queryByRole('alert')).not.toBeInTheDocument();
+    });
+
+    it('shows an error when port is changed to a privileged value (1–1023)', () => {
+      renderDialog({ ...baseAgent, external_proxy_port: 0 });
+      const input = screen.getByRole('spinbutton');
+      fireEvent.change(input, { target: { value: '80' } });
+      expect(screen.getByRole('alert')).toBeInTheDocument();
+    });
+
+    it('shows an error when port exceeds 65535', () => {
+      renderDialog({ ...baseAgent, external_proxy_port: 0 });
+      const input = screen.getByRole('spinbutton');
+      fireEvent.change(input, { target: { value: '99999' } });
+      expect(screen.getByRole('alert')).toBeInTheDocument();
+    });
+
+    it('clears error when port is changed to 0', () => {
+      renderDialog({ ...baseAgent, external_proxy_port: 0 });
+      const input = screen.getByRole('spinbutton');
+      fireEvent.change(input, { target: { value: '80' } });
+      expect(screen.getByRole('alert')).toBeInTheDocument();
+      fireEvent.change(input, { target: { value: '0' } });
+      expect(screen.queryByRole('alert')).not.toBeInTheDocument();
+    });
+  });
+
+  describe('handleSave', () => {
+    it('calls patch with the current port when valid', () => {
+      renderDialog();
+      fireEvent.click(screen.getByText('common.save'));
+      expect(mockPatch).toHaveBeenCalledWith(
+        { uuid: 'agent-1', req: { external_proxy_port: 2375 } },
+        expect.any(Object),
+      );
+    });
+
+    it('does not call patch when port is invalid', () => {
+      renderDialog({ ...baseAgent, external_proxy_port: 0 });
+      const input = screen.getByRole('spinbutton');
+      fireEvent.change(input, { target: { value: '80' } });
+      fireEvent.click(screen.getByText('common.save'));
+      expect(mockPatch).not.toHaveBeenCalled();
+      expect(screen.getByRole('alert')).toBeInTheDocument();
+    });
+
+    it('calls refetchStatus and onClose on successful save', async () => {
+      const onClose = vi.fn();
+      mockPatch.mockImplementation((_args: unknown, { onSuccess }: { onSuccess: () => void }) => {
+        onSuccess();
+      });
+      renderDialog(baseAgent, true, onClose);
+      fireEvent.click(screen.getByText('common.save'));
+      expect(mockRefetchStatus).toHaveBeenCalled();
+      expect(onClose).toHaveBeenCalled();
+    });
+  });
+
+  describe('offline agent', () => {
+    it('shows offline status when agent is not online', () => {
+      renderDialog({ ...baseAgent, status: 'offline' });
+      const statusNodes = screen.getAllByText('hecate.externalProxy.agentOffline');
+      expect(statusNodes.length).toBeGreaterThan(0);
+    });
+  });
+
+  describe('live proxy status', () => {
+    it('shows error state when proxyStatus.error is set', () => {
+      mockProxyStatus = {
+        agent_uuid: 'agent-1',
+        agent_online: true,
+        configured_port: 2375,
+        active: false,
+        active_port: 0,
+        bind_address: '',
+        connection_string: '',
+        error: 'bind failed: address already in use',
+      };
+      renderDialog();
+      expect(screen.getByRole('alert')).toBeInTheDocument();
+      expect(screen.getByText('bind failed: address already in use')).toBeInTheDocument();
+    });
+
+    it('shows offline message when proxyStatus.agent_online is false', () => {
+      mockProxyStatus = {
+        agent_uuid: 'agent-1',
+        agent_online: false,
+        configured_port: 2375,
+        active: false,
+        active_port: 0,
+        bind_address: '',
+        connection_string: '',
+        error: '',
+      };
+      renderDialog();
+      const offlineMessages = screen.getAllByText('hecate.externalProxy.agentOffline');
+      expect(offlineMessages.length).toBeGreaterThan(0);
+    });
+
+    it('shows active status with connection string when proxy is active', () => {
+      mockProxyStatus = {
+        agent_uuid: 'agent-1',
+        agent_online: true,
+        configured_port: 2375,
+        active: true,
+        active_port: 2375,
+        bind_address: '0.0.0.0:2375',
+        connection_string: 'tcp://charon:2375',
+        error: '',
+      };
+      renderDialog();
+      expect(screen.getByText('hecate.externalProxy.statusActive')).toBeInTheDocument();
+      expect(screen.getByText('tcp://charon:2375')).toBeInTheDocument();
+    });
+
+    it('shows inactive status when proxy is not active', () => {
+      mockProxyStatus = {
+        agent_uuid: 'agent-1',
+        agent_online: true,
+        configured_port: 2375,
+        active: false,
+        active_port: 0,
+        bind_address: '',
+        connection_string: '',
+        error: '',
+      };
+      renderDialog();
+      expect(screen.getByText('hecate.externalProxy.statusInactive')).toBeInTheDocument();
+    });
+
+    it('shows reconnect notice when configured port differs from active port', () => {
+      mockProxyStatus = {
+        agent_uuid: 'agent-1',
+        agent_online: true,
+        configured_port: 2375,
+        active: true,
+        active_port: 9999,
+        bind_address: '0.0.0.0:9999',
+        connection_string: 'tcp://charon:9999',
+        error: '',
+      };
+      renderDialog({ ...baseAgent, external_proxy_port: 2375 });
+      expect(screen.getByText('hecate.externalProxy.reconnectNotice')).toBeInTheDocument();
+    });
+  });
+
+  describe('handleCopy', () => {
+    it('copies connection string to clipboard and shows copied state', async () => {
+      const writeText = vi.fn().mockResolvedValue(undefined);
+      Object.assign(navigator, { clipboard: { writeText } });
+
+      mockProxyStatus = {
+        agent_uuid: 'agent-1',
+        agent_online: true,
+        configured_port: 2375,
+        active: true,
+        active_port: 2375,
+        bind_address: '0.0.0.0:2375',
+        connection_string: 'tcp://charon:2375',
+        error: '',
+      };
+      renderDialog();
+
+      const copyButton = screen.getByRole('button', {
+        name: 'hecate.externalProxy.copyConnectionString',
+      });
+      await act(async () => {
+        fireEvent.click(copyButton);
+      });
+
+      await waitFor(() =>
+        expect(writeText).toHaveBeenCalledWith('tcp://charon:2375'),
+      );
+    });
+  });
+
+  describe('cancel button', () => {
+    it('calls onClose when cancel is clicked', () => {
+      const onClose = vi.fn();
+      renderDialog(baseAgent, true, onClose);
+      fireEvent.click(screen.getByText('common.cancel'));
+      expect(onClose).toHaveBeenCalled();
+    });
+  });
+});