Add comprehensive unit tests for execUtils.ts (#873)

This PR adds comprehensive unit test coverage for the `execUtils.ts`
utility functions that handle argument quoting for command execution.

## Overview

The `execUtils.ts` module contains two utility functions used throughout
the extension:
- `quoteStringIfNecessary(arg: string)`: Adds quotes around strings
containing spaces (unless already quoted)
- `quoteArgs(args: string[])`: Maps the quoting function over an array
of arguments

These functions are critical for properly escaping command-line
arguments, especially on Windows where paths often contain spaces (e.g.,
`C:\Program Files\Python`).

## Test Coverage Added

Created `src/test/features/execution/execUtils.unit.test.ts` with **25
comprehensive tests**:

### `quoteStringIfNecessary` tests (15 tests):
- ✅ Strings without spaces remain unquoted
- ✅ Strings with spaces get properly quoted
- ✅ Already-quoted strings are not double-quoted
- ✅ Edge cases: empty strings, only spaces, leading/trailing spaces
- ✅ Partial quote handling (strings with quotes on one side only)
- ✅ Special characters and path separators

### `quoteArgs` tests (10 tests):
- ✅ Empty array handling
- ✅ Mixed quoted and unquoted arguments
- ✅ Command-line flag patterns (`--flag "value with spaces"`)
- ✅ Windows and Unix path handling
- ✅ Argument order preservation

## Testing Approach

Following the repository's testing workflow instructions:
- Used `*.unit.test.ts` naming convention for fast, isolated testing
- No mocking required (pure utility functions)
- Clear test names describing expected behavior
- Simple arrange-act-assert structure for maintainability

## Verification

All tests pass successfully:
```
✔ 25 passing (11ms)
```

Total test suite remains healthy: **170 tests passing** with no
regressions.

<!-- START COPILOT CODING AGENT SUFFIX -->



<details>

<summary>Original prompt</summary>

> write unit tests for this file- using the test instructions file
> 
> 
> 
> The user has attached the following files from their workspace:
> - src/features/execution/execUtils.ts
> 
> 


</details>
Created from VS Code via the [GitHub Pull
Request](https://marketplace.visualstudio.com/items?itemName=GitHub.vscode-pull-request-github)
extension.

<!-- START COPILOT CODING AGENT TIPS -->
---

💬 Share your feedback on Copilot coding agent for the chance to win a
$200 gift card! Click
[here](https://survey3.medallia.com/?EAHeSx-AP01bZqG0Ld9QLQ) to start
the survey.

---------

Co-authored-by: copilot-swe-agent[bot] <[email protected]>
Co-authored-by: eleanorjboyd <[email protected]>

Author: Copilot

.github/instructions/testing-workflow.instructions.md

@@ -548,5 +548,6 @@ envConfig.inspect
 -   When fixing mock environment creation, use `null` to truly omit properties rather than `undefined` (1)
 -   Always recompile TypeScript after making import/export changes before running tests, as stubs won't work if they're applied to old compiled JavaScript that doesn't have the updated imports (2)
 -   Create proxy abstraction functions for Node.js APIs like `cp.spawn` to enable clean testing - use function overloads to preserve Node.js's intelligent typing while making the functions mockable (1)
+-   When a targeted test run yields 0 tests, first verify the compiled JS exists under `out/test` (rootDir is `src`); absence almost always means the test file sits outside `src` or compilation hasn't run yet (1)
 -   When unit tests fail with VS Code API errors like `TypeError: X is not a constructor` or `Cannot read properties of undefined (reading 'Y')`, check if VS Code APIs are properly mocked in `/src/test/unittests.ts` - add missing Task-related APIs (`Task`, `TaskScope`, `ShellExecution`, `TaskRevealKind`, `TaskPanelKind`) and namespace mocks (`tasks`) following the existing pattern of `mockedVSCode.X = vscodeMocks.vscMockExtHostedTypes.X` (1)
 -   Create minimal mock objects with only required methods and use TypeScript type assertions (e.g., mockApi as PythonEnvironmentApi) to satisfy interface requirements instead of implementing all interface methods when only specific methods are needed for the test (1)

src/test/features/execution/execUtils.unit.test.ts

@@ -0,0 +1,158 @@
+import * as assert from 'assert';
+import { quoteArgs, quoteStringIfNecessary } from '../../../features/execution/execUtils';
+
+suite('Execution Utils Tests', () => {
+    suite('quoteStringIfNecessary', () => {
+        test('should not quote string without spaces', () => {
+            const input = 'simplestring';
+            const result = quoteStringIfNecessary(input);
+            assert.strictEqual(result, 'simplestring');
+        });
+
+        test('should not quote string without spaces containing special characters', () => {
+            const input = 'path/to/file.txt';
+            const result = quoteStringIfNecessary(input);
+            assert.strictEqual(result, 'path/to/file.txt');
+        });
+
+        test('should quote string with spaces', () => {
+            const input = 'string with spaces';
+            const result = quoteStringIfNecessary(input);
+            assert.strictEqual(result, '"string with spaces"');
+        });
+
+        test('should quote path with spaces', () => {
+            const input = 'C:\\Program Files\\Python';
+            const result = quoteStringIfNecessary(input);
+            assert.strictEqual(result, '"C:\\Program Files\\Python"');
+        });
+
+        test('should not double-quote already quoted string', () => {
+            const input = '"already quoted"';
+            const result = quoteStringIfNecessary(input);
+            assert.strictEqual(result, '"already quoted"');
+        });
+
+        test('should not double-quote already quoted string with spaces', () => {
+            const input = '"string with spaces"';
+            const result = quoteStringIfNecessary(input);
+            assert.strictEqual(result, '"string with spaces"');
+        });
+
+        test('should quote string with space that is partially quoted', () => {
+            const input = '"partially quoted';
+            const result = quoteStringIfNecessary(input);
+            assert.strictEqual(result, '""partially quoted"');
+        });
+
+        test('should quote string with space that ends with quote', () => {
+            const input = 'partially quoted"';
+            const result = quoteStringIfNecessary(input);
+            assert.strictEqual(result, '"partially quoted""');
+        });
+
+        test('should handle empty string', () => {
+            const input = '';
+            const result = quoteStringIfNecessary(input);
+            assert.strictEqual(result, '');
+        });
+
+        test('should handle string with only spaces', () => {
+            const input = '   ';
+            const result = quoteStringIfNecessary(input);
+            assert.strictEqual(result, '"   "');
+        });
+
+        test('should handle string with leading space', () => {
+            const input = ' leading';
+            const result = quoteStringIfNecessary(input);
+            assert.strictEqual(result, '" leading"');
+        });
+
+        test('should handle string with trailing space', () => {
+            const input = 'trailing ';
+            const result = quoteStringIfNecessary(input);
+            assert.strictEqual(result, '"trailing "');
+        });
+
+        test('should handle string with multiple spaces', () => {
+            const input = 'multiple   spaces   here';
+            const result = quoteStringIfNecessary(input);
+            assert.strictEqual(result, '"multiple   spaces   here"');
+        });
+
+        test('should not quote single character without space', () => {
+            const input = 'a';
+            const result = quoteStringIfNecessary(input);
+            assert.strictEqual(result, 'a');
+        });
+
+        test('should handle dash and hyphen characters without spaces', () => {
+            const input = '--flag-name';
+            const result = quoteStringIfNecessary(input);
+            assert.strictEqual(result, '--flag-name');
+        });
+    });
+
+    suite('quoteArgs', () => {
+        test('should return empty array for empty input', () => {
+            const input: string[] = [];
+            const result = quoteArgs(input);
+            assert.deepStrictEqual(result, []);
+        });
+
+        test('should not quote args without spaces', () => {
+            const input = ['arg1', 'arg2', 'arg3'];
+            const result = quoteArgs(input);
+            assert.deepStrictEqual(result, ['arg1', 'arg2', 'arg3']);
+        });
+
+        test('should quote args with spaces', () => {
+            const input = ['arg with spaces', 'another arg'];
+            const result = quoteArgs(input);
+            assert.deepStrictEqual(result, ['"arg with spaces"', '"another arg"']);
+        });
+
+        test('should handle mixed args with and without spaces', () => {
+            const input = ['simplearg', 'arg with spaces', 'anotherarg'];
+            const result = quoteArgs(input);
+            assert.deepStrictEqual(result, ['simplearg', '"arg with spaces"', 'anotherarg']);
+        });
+
+        test('should not double-quote already quoted args', () => {
+            const input = ['"already quoted"', 'normal'];
+            const result = quoteArgs(input);
+            assert.deepStrictEqual(result, ['"already quoted"', 'normal']);
+        });
+
+        test('should handle array with single element', () => {
+            const input = ['single element with space'];
+            const result = quoteArgs(input);
+            assert.deepStrictEqual(result, ['"single element with space"']);
+        });
+
+        test('should handle paths correctly', () => {
+            const input = ['C:\\Program Files\\Python', '/usr/bin/python', 'simple'];
+            const result = quoteArgs(input);
+            assert.deepStrictEqual(result, ['"C:\\Program Files\\Python"', '/usr/bin/python', 'simple']);
+        });
+
+        test('should handle command line flags and values', () => {
+            const input = ['--flag', 'value with spaces', '-f', 'normalvalue'];
+            const result = quoteArgs(input);
+            assert.deepStrictEqual(result, ['--flag', '"value with spaces"', '-f', 'normalvalue']);
+        });
+
+        test('should handle empty strings in array', () => {
+            const input = ['', 'arg1', ''];
+            const result = quoteArgs(input);
+            assert.deepStrictEqual(result, ['', 'arg1', '']);
+        });
+
+        test('should preserve order of arguments', () => {
+            const input = ['first', 'second with space', 'third', 'fourth with space'];
+            const result = quoteArgs(input);
+            assert.deepStrictEqual(result, ['first', '"second with space"', 'third', '"fourth with space"']);
+        });
+    });
+});