feat(vscode): Container support for extension dependencies (#8833)

* Added toggle for dev container creation in the create workspace webview and removed dead code

* Added unit tests to cover the workspace/project creation and to test the new devcontainer experience

* Adding Workspace Creation Integration Tests

* Added the enableDevContainer command and additional integration tests to test adding a project to a devcontainer workspace and to verify the structure of the workspace

* Corrected test

* Block onboarding from executing when devcontainer project is recognized. Added additional tests to verify this behavior

* Update to public image

* Reverting unnecessary modifications from merge

* Remove unneeded files

* fixed failing tests

* Correct mocks

* test-setup updates

* Added additional unit tests

* Adding additional unit tests

* Added unit tests for messages

* exclude intl messages from code coverage

* Exclude from coverage

Author: lambrianmsft

.github/workflows/pr-coverage.yml

@@ -133,6 +133,8 @@ jobs:
             **/providers/**
             # VS Code webview communication (uses acquireVsCodeApi runtime global, cannot be unit tested)
             **/webviewCommunication.tsx
+            # VS Code React intl files (localization catalog, not unit-test target)
+            apps/vs-code-react/src/intl/**
 
       - name: Check coverage on changed files
         id: coverage-check

apps/vs-code-designer/TESTING.md

@@ -0,0 +1,96 @@
+# Testing Guide for VS Code Designer Extension
+
+## Running Tests
+
+### VS Code Testing Tab (Recommended)
+Use the VS Code Testing tab in the sidebar for an interactive testing experience with debugging support.
+
+### Command Line
+
+#### Run All Tests
+```bash
+cd apps/vs-code-designer
+pnpm vitest run
+```
+
+#### Run Specific Test File
+```bash
+cd apps/vs-code-designer
+pnpm vitest run <test-file-name>
+```
+
+Examples:
+```bash
+pnpm vitest run binaries.test.ts
+pnpm vitest run enableDevContainerIntegration.test.ts
+```
+
+#### Run Tests in Watch Mode
+```bash
+cd apps/vs-code-designer
+pnpm vitest
+```
+
+#### Run Tests with Coverage
+```bash
+cd apps/vs-code-designer
+pnpm vitest run --coverage
+```
+
+## Test Types
+
+### Unit Tests
+- Location: `src/**/__test__/*.test.ts`
+- Framework: Vitest
+- Run with: `pnpm vitest run`
+
+### Integration Tests
+- Location: `src/**/__test__/*Integration.test.ts`
+- Framework: Vitest with real file system operations
+- These tests may take longer due to actual file I/O
+
+### E2E Tests (Extension UI)
+- Location: `out/test/**/*.js`
+- Framework: VS Code Extension Test Runner
+- Run with: `pnpm run vscode:designer:e2e:ui` (UI mode)
+- Run with: `pnpm run vscode:designer:e2e:headless` (Headless mode)
+
+## Common Test Commands
+
+| Command | Description |
+|---------|-------------|
+| `pnpm vitest run` | Run all unit tests once |
+| `pnpm vitest` | Run tests in watch mode |
+| `pnpm vitest run --ui` | Run tests with Vitest UI |
+| `pnpm vitest run <file>` | Run specific test file |
+| `pnpm run test:extension-unit` | Run unit tests with retries |
+
+## Test Configuration
+
+- **Vitest Config**: `vitest.workspace.ts` (workspace root)
+- **Test Timeout**: Default 5000ms (can be overridden per test)
+- **Coverage**: Enabled by default with Istanbul
+
+## Tips
+
+1. **Long-running tests**: Some integration tests may need extended timeouts. Add `{ timeout: 30000 }` to slow tests.
+   
+2. **Debugging tests**: Use VS Code's Testing tab and click the debug icon next to any test.
+
+3. **Mocking**: Tests use Vitest's `vi.mock()` for mocking modules. See existing tests for patterns.
+
+4. **File system tests**: Tests that interact with the file system use `fs-extra` and create temp directories that are cleaned up in `afterEach`.
+
+## Troubleshooting
+
+### Tests timing out
+- Increase timeout for specific test: `it('test name', { timeout: 30000 }, async () => { ... })`
+- Check for missing `await` keywords in async operations
+
+### Module not found errors
+- Ensure all mocked modules are declared with `vi.mock('module-path')` at the top level
+- Check import paths are correct
+
+### Mock issues
+- Use `vi.mocked()` to properly type mocked functions
+- Import actual implementations with `vi.importActual()` when needed

apps/vs-code-designer/src/__test__/devContainerIntegration.test.ts

@@ -0,0 +1,265 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import type { IActionContext } from '@microsoft/vscode-azext-utils';
+
+// Use factory mocks to prevent transitive module loading issues (e.g., AzureWizardPromptStep).
+// devContainerUtils and settings are leaf dependencies called by the real useBinariesDependencies/binariesExist.
+vi.mock('../app/utils/devContainerUtils', () => ({
+  isDevContainerWorkspace: vi.fn(),
+}));
+vi.mock('../app/utils/vsCodeConfig/settings', () => ({
+  getGlobalSetting: vi.fn(),
+  getWorkspaceSetting: vi.fn(),
+  updateGlobalSetting: vi.fn(),
+}));
+
+// Fully mock binaries (synchronous factory, no importActual) to avoid module resolution deadlock.
+// Tests that need the REAL useBinariesDependencies/binariesExist use vi.importActual at test level.
+vi.mock('../app/utils/binaries', () => ({
+  useBinariesDependencies: vi.fn(),
+  binariesExist: vi.fn(),
+  installBinaries: vi.fn(),
+  downloadAndExtractDependency: vi.fn(),
+  getLatestFunctionCoreToolsVersion: vi.fn(),
+  getLatestDotNetVersion: vi.fn(),
+  getLatestNodeJsVersion: vi.fn(),
+  getNodeJsBinariesReleaseUrl: vi.fn(),
+  getFunctionCoreToolsBinariesReleaseUrl: vi.fn(),
+  getDotNetBinariesReleaseUrl: vi.fn(),
+  getCpuArchitecture: vi.fn(),
+  getDependencyTimeout: vi.fn(),
+}));
+
+// Mock transitive dependencies of binaries.ts to prevent real module loading
+// when vi.importActual('../app/utils/binaries') is used at test level.
+vi.mock('../app/utils/codeless/startDesignTimeApi', () => ({
+  promptStartDesignTimeOption: vi.fn(),
+  startAllDesignTimeApis: vi.fn(),
+  stopAllDesignTimeApis: vi.fn(),
+}));
+vi.mock('../app/utils/funcCoreTools/cpUtils', () => ({
+  executeCommand: vi.fn(),
+}));
+vi.mock('../app/utils/funcCoreTools/funcVersion', () => ({
+  setFunctionsCommand: vi.fn(),
+  getFunctionsCommand: vi.fn(),
+}));
+vi.mock('../app/commands/nodeJs/validateNodeJsInstalled', () => ({
+  isNodeJsInstalled: vi.fn(),
+}));
+vi.mock('../app/utils/nodeJs/nodeJsVersion', () => ({
+  getNpmCommand: vi.fn(),
+}));
+// Fully mock onboarding to break circular dep (onboarding ↔ binaries).
+vi.mock('../onboarding', () => ({
+  onboardBinaries: vi.fn(),
+  startOnboarding: vi.fn(),
+}));
+vi.mock('../app/utils/vsCodeConfig/tasks', () => ({
+  validateTasksJson: vi.fn(),
+}));
+vi.mock('../app/commands/binaries/validateAndInstallBinaries', () => ({
+  validateAndInstallBinaries: vi.fn(),
+}));
+vi.mock('../app/utils/telemetry', () => ({
+  runWithDurationTelemetry: vi.fn(async (_ctx: any, _cmd: any, callback: () => Promise<void>) => await callback()),
+}));
+vi.mock('@microsoft/vscode-azext-utils', () => ({
+  callWithTelemetryAndErrorHandling: vi.fn(async (_cmd: string, callback: (ctx: IActionContext) => Promise<void>) => {
+    return await callback({
+      telemetry: { properties: {}, measurements: {} },
+      errorHandling: {},
+      ui: {},
+      valuesToMask: [],
+    } as any);
+  }),
+}));
+
+/**
+ * Re-implements the core startOnboarding flow inline to test devContainer detection
+ * without hitting the circular dependency between onboarding.ts ↔ binaries.ts.
+ * This mirrors the real logic in onboarding.ts: check isDevContainerWorkspace,
+ * skip if true, otherwise call installBinaries + promptStartDesignTimeOption.
+ */
+async function startOnboardingForTest(activateContext: IActionContext) {
+  const { isDevContainerWorkspace } = await import('../app/utils/devContainerUtils');
+  const { installBinaries } = await import('../app/utils/binaries');
+  const { promptStartDesignTimeOption } = await import('../app/utils/codeless/startDesignTimeApi');
+
+  const isDevContainer = await isDevContainerWorkspace();
+  if (isDevContainer) {
+    activateContext.telemetry.properties.skippedOnboarding = 'true';
+    activateContext.telemetry.properties.skippedReason = 'devContainer';
+    return;
+  }
+
+  const binariesInstallStartTime = Date.now();
+  await installBinaries(activateContext as any);
+  activateContext.telemetry.measurements.binariesInstallDuration = Date.now() - binariesInstallStartTime;
+
+  await promptStartDesignTimeOption(activateContext);
+}
+
+describe('devContainer Integration Tests', () => {
+  let mockContext: IActionContext;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockContext = {
+      telemetry: {
+        properties: {},
+        measurements: {},
+      },
+      errorHandling: {},
+      ui: {},
+      valuesToMask: [],
+    } as any;
+  });
+
+  describe('Complete onboarding flow - devContainer', () => {
+    it('should skip entire onboarding flow in devContainer workspace', async () => {
+      const { isDevContainerWorkspace } = await import('../app/utils/devContainerUtils');
+      const { installBinaries } = await import('../app/utils/binaries');
+      const { promptStartDesignTimeOption } = await import('../app/utils/codeless/startDesignTimeApi');
+
+      vi.mocked(isDevContainerWorkspace).mockResolvedValue(true);
+
+      await startOnboardingForTest(mockContext);
+
+      expect(mockContext.telemetry.properties.skippedOnboarding).toBe('true');
+      expect(mockContext.telemetry.properties.skippedReason).toBe('devContainer');
+      expect(installBinaries).not.toHaveBeenCalled();
+      expect(promptStartDesignTimeOption).not.toHaveBeenCalled();
+    });
+
+    it('should complete onboarding flow in non-devContainer workspace', async () => {
+      const { isDevContainerWorkspace } = await import('../app/utils/devContainerUtils');
+      const { installBinaries } = await import('../app/utils/binaries');
+      const { promptStartDesignTimeOption } = await import('../app/utils/codeless/startDesignTimeApi');
+
+      vi.mocked(isDevContainerWorkspace).mockResolvedValue(false);
+      vi.mocked(installBinaries).mockResolvedValue(undefined);
+      vi.mocked(promptStartDesignTimeOption).mockResolvedValue(undefined);
+
+      await startOnboardingForTest(mockContext);
+
+      expect(mockContext.telemetry.properties.skippedOnboarding).toBeUndefined();
+      expect(installBinaries).toHaveBeenCalled();
+      expect(promptStartDesignTimeOption).toHaveBeenCalled();
+      expect(mockContext.telemetry.measurements.binariesInstallDuration).toBeDefined();
+    });
+  });
+
+  describe('useBinariesDependencies - devContainer override', () => {
+    it('should return false in devContainer regardless of global setting', async () => {
+      // Use importActual to run the REAL useBinariesDependencies logic.
+      // Its dependencies (isDevContainerWorkspace, getGlobalSetting) are still mocked.
+      const { useBinariesDependencies: realUseBinariesDependencies } =
+        await vi.importActual<typeof import('../app/utils/binaries')>('../app/utils/binaries');
+      const { isDevContainerWorkspace } = await import('../app/utils/devContainerUtils');
+      const settingsModule = await import('../app/utils/vsCodeConfig/settings');
+
+      vi.mocked(isDevContainerWorkspace).mockResolvedValue(true);
+      vi.mocked(settingsModule.getGlobalSetting).mockReturnValue(true);
+
+      const result = await realUseBinariesDependencies();
+
+      expect(result).toBe(false);
+    });
+
+    it('should respect global setting in non-devContainer workspace', async () => {
+      const { useBinariesDependencies: realUseBinariesDependencies } =
+        await vi.importActual<typeof import('../app/utils/binaries')>('../app/utils/binaries');
+      const { isDevContainerWorkspace } = await import('../app/utils/devContainerUtils');
+      const settingsModule = await import('../app/utils/vsCodeConfig/settings');
+
+      vi.mocked(isDevContainerWorkspace).mockResolvedValue(false);
+      vi.mocked(settingsModule.getGlobalSetting).mockReturnValue(true);
+
+      const result = await realUseBinariesDependencies();
+
+      expect(result).toBe(true);
+    });
+  });
+
+  describe('binariesExist - devContainer early exit', () => {
+    it('should return false immediately in devContainer without checking filesystem', async () => {
+      const { binariesExist: realBinariesExist } = await vi.importActual<typeof import('../app/utils/binaries')>('../app/utils/binaries');
+      const { isDevContainerWorkspace } = await import('../app/utils/devContainerUtils');
+      const fs = await import('fs');
+
+      vi.mocked(isDevContainerWorkspace).mockResolvedValue(true);
+      vi.mocked(fs.existsSync).mockReturnValue(true);
+
+      const result = await realBinariesExist('dotnet');
+
+      expect(result).toBe(false);
+      expect(fs.existsSync).not.toHaveBeenCalled();
+    });
+
+    it('should check filesystem in non-devContainer workspace', async () => {
+      const { binariesExist: realBinariesExist } = await vi.importActual<typeof import('../app/utils/binaries')>('../app/utils/binaries');
+      const { isDevContainerWorkspace } = await import('../app/utils/devContainerUtils');
+      const fs = await import('fs');
+      const settingsModule = await import('../app/utils/vsCodeConfig/settings');
+
+      vi.mocked(isDevContainerWorkspace).mockResolvedValue(false);
+      vi.mocked(settingsModule.getGlobalSetting).mockReturnValue('test/path');
+      vi.mocked(fs.existsSync).mockReturnValue(true);
+
+      const result = await realBinariesExist('dotnet');
+
+      expect(result).toBe(true);
+      expect(fs.existsSync).toHaveBeenCalled();
+    });
+  });
+
+  describe('Telemetry tracking across devContainer detection', () => {
+    it('should track skipped onboarding in telemetry for devContainer', async () => {
+      const { isDevContainerWorkspace } = await import('../app/utils/devContainerUtils');
+
+      vi.mocked(isDevContainerWorkspace).mockResolvedValue(true);
+
+      await startOnboardingForTest(mockContext);
+
+      expect(mockContext.telemetry.properties.skippedOnboarding).toBe('true');
+      expect(mockContext.telemetry.properties.skippedReason).toBe('devContainer');
+    });
+
+    it('should track binaries install duration for non-devContainer', async () => {
+      const { isDevContainerWorkspace } = await import('../app/utils/devContainerUtils');
+      const { installBinaries } = await import('../app/utils/binaries');
+
+      vi.mocked(isDevContainerWorkspace).mockResolvedValue(false);
+      vi.mocked(installBinaries).mockResolvedValue(undefined);
+
+      await startOnboardingForTest(mockContext);
+
+      expect(mockContext.telemetry.measurements.binariesInstallDuration).toBeDefined();
+      expect(typeof mockContext.telemetry.measurements.binariesInstallDuration).toBe('number');
+      expect(mockContext.telemetry.measurements.binariesInstallDuration).toBeGreaterThanOrEqual(0);
+    });
+
+    it('should not track binaries install duration for devContainer', async () => {
+      const { isDevContainerWorkspace } = await import('../app/utils/devContainerUtils');
+
+      vi.mocked(isDevContainerWorkspace).mockResolvedValue(true);
+
+      await startOnboardingForTest(mockContext);
+
+      expect(mockContext.telemetry.measurements.binariesInstallDuration).toBeUndefined();
+    });
+  });
+
+  describe('Error handling in devContainer detection', () => {
+    it('should gracefully handle errors in devContainer detection', async () => {
+      const { useBinariesDependencies: realUseBinariesDependencies } =
+        await vi.importActual<typeof import('../app/utils/binaries')>('../app/utils/binaries');
+      const { isDevContainerWorkspace } = await import('../app/utils/devContainerUtils');
+
+      vi.mocked(isDevContainerWorkspace).mockRejectedValue(new Error('File system error'));
+
+      // Should reject when the underlying detection fails
+      await expect(realUseBinariesDependencies()).rejects.toThrow();
+    });
+  });
+});