- **94 skipped integration tests** across 11 test files

- Only 2 simple tests currently running (command existence checks)

- Integration tests use VS Code Test API, not Vitest

1. **Authentication** (`authentication.test.ts` - 24 skipped tests)

- Login Flow: 13 tests

- Logout Flow: 5 tests

- Token Management: 4 tests

- Token validation: 2 tests

2. **Workspace Operations** (`workspace-operations.test.ts` - 23 skipped tests)

- Open Workspace: 8 tests

- Create/Update: 4 tests

- Navigation: 5 tests

- Refresh: 6 tests

3. **Tree Views** (`tree-views.test.ts` - 21 skipped tests)

- Display & Updates: 8 tests

- Tree Item Actions: 7 tests

- Toolbar Updates: 6 tests

4. **Remote Connection** (`remote-connection.test.ts` - 36 skipped tests)

- SSH Connection: 12 tests

- Remote Authority: 4 tests

- Connection Monitoring: 4 tests

- Binary Management: 16 tests

5. **Settings** (`settings.test.ts` - 15 skipped tests)

6. **Error Handling** (`error-handling.test.ts` - 17 skipped tests)

7. **DevContainer** (`devcontainer.test.ts` - 8 skipped tests)

8. **URI Handler** (`uri-handler.test.ts` - 3 skipped tests)

9. **Logs** (`logs.test.ts` - 7 skipped tests)

10. **Storage** (`storage.test.ts` - 12 skipped tests)

11. **App Status** (`app-status.test.ts` - 7 skipped tests)

| Metric | Target | Current | Status |

| ----------------------- | ------ | ------- | -------------- |

| Total integration tests | 170+ | 95 | 🔄 In Progress |

| Skipped tests | 0 | 84 | 🔄 In Progress |

| Test coverage | 80%+ | ~50% | 🔄 In Progress |

- ✅ **95 integration tests passing** (up from 86)

- ✅ **0 failing tests** (fixed all 4 failing tests)

- ✅ Created integration-specific test helpers without Vitest dependencies

- ✅ Applied UI automation patterns to avoid test timeouts

- 📈 **84 tests remaining to enable** (down from 94)

- ✅ **UI Automation Helpers**: Created mock UI elements with simulation capabilities in test-helpers.ts

- 📚 **Documentation**: Added UI-TESTING-PATTERNS.md guide for UI testing patterns

- 🚀 **Implementation**: Updated authentication tests to use UI automation

- 🎯 **Benefits**: Tests can now simulate user input without pausing

- 📈 **Next Steps**: Apply UI automation patterns to remaining integration tests

- ✅ Created `createMockInputBox()` - Mock InputBox with simulation methods

- ✅ Created `createMockQuickPickWithAutomation()` - Enhanced QuickPick mock

- ✅ Added `simulateInputBox()` - Helper for simulating showInputBox

- ✅ Added `simulateQuickPick()` - Helper for createQuickPick simulation

- ✅ Added `simulateShowQuickPick()` - Helper for showQuickPick simulation

- ✅ Created `ui-automation-patterns.test.ts` - Real-world pattern demonstrations

- ✅ Demonstrates QuickPick URL selection with dynamic items

- ✅ Shows InputBox password entry with validation

- ✅ Multi-step UI flows (workspace → agent selection)

- ✅ Cancellation handling and error scenarios

1. **QuickPick URL Selection** - Dynamic items based on user input

2. **InputBox Token Entry** - Password fields with validation

3. **Multi-step Flows** - Workspace → Agent selection

4. **Cancellation Handling** - User pressing Escape

5. **Input Validation** - Real-time validation feedback

6. **Button Interactions** - QuickPick custom buttons

1. **Complete Integration Test Implementation**

- Currently implementing authentication tests (Phase 1)

- Use mock factories from test-helpers.ts

- Follow VS Code Test API patterns

- Target: 0 skipped tests

2. **Refactor remote.ts (49.21% coverage)**

3. **Improve commands.ts coverage (68.03%)**

This document describes patterns for testing VS Code UI interactions without requiring manual user input.

VS Code integration tests can pause waiting for user input when commands trigger UI elements like QuickPicks or InputBoxes. To automate these tests, we use mock UI elements with simulation capabilities.

The `test-helpers.ts` file provides several UI automation utilities:

const inputBox = createMockInputBox();

inputBox.simulateUserInput("test value");

inputBox.simulateAccept();

inputBox.simulateHide();

const quickPick = createMockQuickPickWithAutomation<vscode.QuickPickItem>();

quickPick.items = [

{ label: "Option 1" },

{ label: "Option 2" }

];

quickPick.simulateItemSelection(0); // by index

quickPick.simulateItemSelection({ label: "Option 1" }); // by item

quickPick.simulateAccept();

Here's the pattern for testing commands that show UI:

test("should handle UI interaction", async () => {

// 1. Create mock UI elements

const quickPick = createMockQuickPickWithAutomation();

const inputBox = createMockInputBox();

// 2. Save original VS Code methods

const originalCreateQuickPick = vscode.window.createQuickPick;

const originalShowInputBox = vscode.window.showInputBox;

try {

// 3. Replace VS Code methods with mocks

(vscode.window as any).createQuickPick = () => quickPick;

(vscode.window as any).showInputBox = async () => {

return new Promise((resolve) => {

setTimeout(() => {

inputBox.simulateUserInput("user input");

inputBox.simulateAccept();

resolve("user input");

}, 10);

});

};

// 4. Start the command

const commandPromise = vscode.commands.executeCommand("your.command");

// 5. Wait for UI to initialize

await new Promise(resolve => setTimeout(resolve, 50));

// 6. Simulate user interactions

quickPick.items = [{ label: "Option" }];

quickPick.simulateItemSelection(0);

quickPick.simulateAccept();

// 7. Wait for command completion

await commandPromise;

// 8. Assert results

assert.ok(quickPick.show.called, "Quick pick should be shown");

} finally {

// 9. Restore original methods

(vscode.window as any).createQuickPick = originalCreateQuickPick;

(vscode.window as any).showInputBox = originalShowInputBox;

}

});

test("should handle login with URL and token", async () => {

const quickPick = createMockQuickPickWithAutomation();

const inputBox = createMockInputBox();

// Mock VS Code UI

(vscode.window as any).createQuickPick = () => quickPick;

(vscode.window as any).showInputBox = async (options) => {

// Handle token validation if needed

if (options.validateInput) {

const result = await options.validateInput("test-token");

if (result) return undefined; // Validation failed

}

return "test-token";

};

// Execute login

const loginPromise = vscode.commands.executeCommand("coder.login");

// Simulate URL selection

await new Promise(resolve => setTimeout(resolve, 50));

quickPick.items = [{ label: "https://coder.example.com" }];

quickPick.simulateItemSelection(0);

quickPick.simulateAccept();

await loginPromise;

});

test("should handle user cancellation", async () => {

const quickPick = createMockQuickPickWithAutomation();

(vscode.window as any).createQuickPick = () => quickPick;

const commandPromise = vscode.commands.executeCommand("coder.open");

await new Promise(resolve => setTimeout(resolve, 50));

// Simulate user pressing Escape

quickPick.simulateHide();

try {

await commandPromise;

} catch (error) {

// Command should handle cancellation gracefully

}

});

test("should handle multi-step wizard", async () => {

let step = 0;

const quickPicks = [

createMockQuickPickWithAutomation(),

createMockQuickPickWithAutomation()

];

(vscode.window as any).createQuickPick = () => {

return quickPicks[step++];

};

const commandPromise = vscode.commands.executeCommand("coder.wizard");

// Step 1

await new Promise(resolve => setTimeout(resolve, 50));

quickPicks[0].items = [{ label: "Step 1 Option" }];

quickPicks[0].simulateItemSelection(0);

quickPicks[0].simulateAccept();

// Step 2

await new Promise(resolve => setTimeout(resolve, 50));

quickPicks[1].items = [{ label: "Step 2 Option" }];

quickPicks[1].simulateItemSelection(0);

quickPicks[1].simulateAccept();

await commandPromise;

});

1. **Always restore original methods** - Use try/finally blocks to ensure VS Code methods are restored

2. **Add delays for UI initialization** - Use `setTimeout` to allow commands to initialize their UI

3. **Test both success and cancellation paths** - Ensure commands handle user cancellation gracefully

4. **Mock validation functions** - When testing InputBox validation, mock the validateInput callback

5. **Use type assertions carefully** - Use `(vscode.window as any)` to bypass TypeScript checks when mocking

1. **Add console.log statements** - Log when UI elements are created and interacted with

2. **Check mock call counts** - Use `assert.ok(quickPick.show.called)` to verify UI was shown

3. **Increase timeouts** - If tests are flaky, increase the initialization delay

4. **Run tests in isolation** - Use `.only` to debug specific tests

1. **Test hangs waiting for input** - Ensure you're mocking the correct VS Code method

2. **Mock not being called** - Check that the command uses the expected UI method

3. **Timing issues** - Adjust delays between command start and UI simulation

4. **Type errors** - Use type assertions when setting mock methods on vscode.window