test: add unit tests for unassigned target assignment and gateway removal

- getUnassignedTargets: returns targets, empty when no config, empty when field missing
- createGatewayFromWizard: moves selected targets to new gateway, removes from unassigned
- removeGateway: preserves targets as unassigned on removal, no-op for empty gateways
- previewRemoveGateway: shows 'will become unassigned' warning

Author: aidandaly24

src/cli/operations/mcp/__tests__/create-mcp.test.ts

@@ -131,3 +131,78 @@ describe('createExternalGatewayTarget', () => {
     expect(target.outboundAuth).toEqual({ type: 'API_KEY', credentialName: 'my-cred' });
   });
 });
+
+import { createGatewayFromWizard, getUnassignedTargets } from '../create-mcp.js';
+import type { AddGatewayConfig } from '../../../tui/screens/mcp/types.js';
+
+describe('getUnassignedTargets', () => {
+  afterEach(() => vi.clearAllMocks());
+
+  it('returns unassigned targets from mcp spec', async () => {
+    mockConfigExists.mockReturnValue(true);
+    mockReadMcpSpec.mockResolvedValue({
+      agentCoreGateways: [],
+      unassignedTargets: [{ name: 't1' }, { name: 't2' }],
+    });
+
+    const result = await getUnassignedTargets();
+    expect(result).toHaveLength(2);
+    expect(result[0]!.name).toBe('t1');
+  });
+
+  it('returns empty array when no mcp config exists', async () => {
+    mockConfigExists.mockReturnValue(false);
+    expect(await getUnassignedTargets()).toEqual([]);
+  });
+
+  it('returns empty array when unassignedTargets field is missing', async () => {
+    mockConfigExists.mockReturnValue(true);
+    mockReadMcpSpec.mockResolvedValue({ agentCoreGateways: [] });
+    expect(await getUnassignedTargets()).toEqual([]);
+  });
+});
+
+describe('createGatewayFromWizard with selectedTargets', () => {
+  afterEach(() => vi.clearAllMocks());
+
+  function makeGatewayConfig(overrides: Partial<AddGatewayConfig> = {}): AddGatewayConfig {
+    return {
+      name: 'new-gateway',
+      authorizerType: 'AWS_IAM',
+      ...overrides,
+    } as AddGatewayConfig;
+  }
+
+  it('moves selected targets to new gateway and removes from unassigned', async () => {
+    mockConfigExists.mockReturnValue(true);
+    mockReadMcpSpec.mockResolvedValue({
+      agentCoreGateways: [],
+      unassignedTargets: [
+        { name: 'target-a', targetType: 'mcpServer' },
+        { name: 'target-b', targetType: 'mcpServer' },
+        { name: 'target-c', targetType: 'mcpServer' },
+      ],
+    });
+
+    await createGatewayFromWizard(makeGatewayConfig({ selectedTargets: ['target-a', 'target-c'] }));
+
+    const written = mockWriteMcpSpec.mock.calls[0]![0];
+    const gateway = written.agentCoreGateways.find((g: { name: string }) => g.name === 'new-gateway');
+    expect(gateway.targets).toHaveLength(2);
+    expect(gateway.targets[0]!.name).toBe('target-a');
+    expect(gateway.targets[1]!.name).toBe('target-c');
+    expect(written.unassignedTargets).toHaveLength(1);
+    expect(written.unassignedTargets[0]!.name).toBe('target-b');
+  });
+
+  it('creates gateway with empty targets when no selectedTargets', async () => {
+    mockConfigExists.mockReturnValue(true);
+    mockReadMcpSpec.mockResolvedValue({ agentCoreGateways: [] });
+
+    await createGatewayFromWizard(makeGatewayConfig());
+
+    const written = mockWriteMcpSpec.mock.calls[0]![0];
+    const gateway = written.agentCoreGateways.find((g: { name: string }) => g.name === 'new-gateway');
+    expect(gateway.targets).toHaveLength(0);
+  });
+});

src/cli/operations/remove/__tests__/remove-gateway.test.ts

@@ -0,0 +1,68 @@
+import { previewRemoveGateway, removeGateway } from '../remove-gateway.js';
+import { afterEach, describe, expect, it, vi } from 'vitest';
+
+const { mockReadMcpSpec, mockWriteMcpSpec, mockConfigExists } = vi.hoisted(() => ({
+  mockReadMcpSpec: vi.fn(),
+  mockWriteMcpSpec: vi.fn(),
+  mockConfigExists: vi.fn(),
+}));
+
+vi.mock('../../../../lib/index.js', () => ({
+  ConfigIO: class {
+    configExists = mockConfigExists;
+    readMcpSpec = mockReadMcpSpec;
+    writeMcpSpec = mockWriteMcpSpec;
+  },
+}));
+
+describe('removeGateway', () => {
+  afterEach(() => vi.clearAllMocks());
+
+  it('moves gateway targets to unassignedTargets on removal, preserving existing', async () => {
+    mockReadMcpSpec.mockResolvedValue({
+      agentCoreGateways: [
+        { name: 'gw-to-remove', targets: [{ name: 'target-1' }, { name: 'target-2' }] },
+        { name: 'other-gw', targets: [] },
+      ],
+      unassignedTargets: [{ name: 'already-unassigned' }],
+    });
+
+    const result = await removeGateway('gw-to-remove');
+
+    expect(result.ok).toBe(true);
+    const written = mockWriteMcpSpec.mock.calls[0]![0];
+    expect(written.agentCoreGateways).toHaveLength(1);
+    expect(written.agentCoreGateways[0]!.name).toBe('other-gw');
+    expect(written.unassignedTargets).toHaveLength(3);
+    expect(written.unassignedTargets[0]!.name).toBe('already-unassigned');
+    expect(written.unassignedTargets[1]!.name).toBe('target-1');
+    expect(written.unassignedTargets[2]!.name).toBe('target-2');
+  });
+
+  it('does not modify unassignedTargets when gateway has no targets', async () => {
+    mockReadMcpSpec.mockResolvedValue({
+      agentCoreGateways: [{ name: 'empty-gw', targets: [] }],
+    });
+
+    const result = await removeGateway('empty-gw');
+
+    expect(result.ok).toBe(true);
+    const written = mockWriteMcpSpec.mock.calls[0]![0];
+    expect(written.agentCoreGateways).toHaveLength(0);
+    expect(written.unassignedTargets).toBeUndefined();
+  });
+});
+
+describe('previewRemoveGateway', () => {
+  afterEach(() => vi.clearAllMocks());
+
+  it('shows "will become unassigned" warning when gateway has targets', async () => {
+    mockReadMcpSpec.mockResolvedValue({
+      agentCoreGateways: [{ name: 'my-gw', targets: [{ name: 't1' }, { name: 't2' }] }],
+    });
+
+    const preview = await previewRemoveGateway('my-gw');
+
+    expect(preview.summary.some(s => s.includes('2 target(s) will become unassigned'))).toBe(true);
+  });
+});