Implement multiple test environment files support

Co-authored-by: jfoshee <[email protected]>

Author: Copilot

extension/package.json

@@ -1438,7 +1438,17 @@
         "go.testEnvFile": {
           "type": "string",
           "default": null,
-          "description": "Absolute path to a file containing environment variables definitions. File contents should be of the form key=value.",
+          "description": "Absolute path to a file containing environment variables definitions. File contents should be of the form key=value. (Deprecated: Use go.testEnvFiles instead)",
+          "scope": "resource",
+          "deprecationMessage": "Use go.testEnvFiles instead"
+        },
+        "go.testEnvFiles": {
+          "type": "array",
+          "items": {
+            "type": "string"
+          },
+          "default": [],
+          "description": "Array of absolute paths to files containing environment variables definitions. File contents should be of the form key=value.",
           "scope": "resource"
         },
         "go.testFlags": {

extension/src/testUtils.ts

@@ -19,7 +19,7 @@ import { getCurrentPackage } from './goModules';
 import { GoDocumentSymbolProvider } from './goDocumentSymbols';
 import { getNonVendorPackages } from './goPackages';
 import { getBinPath, getCurrentGoPath, getTempFilePath, LineBuffer, resolvePath } from './util';
-import { parseEnvFile } from './utils/envUtils';
+import { parseEnvFile, parseEnvFiles } from './utils/envUtils';
 import {
 	getEnvPath,
 	expandFilePathInOutput,
@@ -111,12 +111,28 @@ export function getTestEnvVars(config: vscode.WorkspaceConfiguration): any {
 	const envVars = toolExecutionEnvironment();
 	const testEnvConfig = config['testEnvVars'] || {};
 
-	let fileEnv: { [key: string]: any } = {};
-	let testEnvFile = config['testEnvFile'];
+	// Collect environment files from both settings
+	const envFiles: string[] = [];
+
+	// Add files from the new testEnvFiles setting (array)
+	const testEnvFiles = config['testEnvFiles'] || [];
+	if (Array.isArray(testEnvFiles)) {
+		envFiles.push(...testEnvFiles);
+	}
+
+	// Add the deprecated testEnvFile setting (single file) for backward compatibility
+	const testEnvFile = config['testEnvFile'];
 	if (testEnvFile) {
-		testEnvFile = resolvePath(testEnvFile);
+		envFiles.push(testEnvFile);
+	}
+
+	// Parse all environment files
+	let fileEnv: { [key: string]: any } = {};
+	if (envFiles.length > 0) {
 		try {
-			fileEnv = parseEnvFile(testEnvFile, envVars);
+			// Resolve paths for all files
+			const resolvedFiles = envFiles.map((file) => resolvePath(file));
+			fileEnv = parseEnvFiles(resolvedFiles, envVars);
 		} catch (e) {
 			console.log(e);
 		}

extension/test/unit/testEnvFiles.test.ts

@@ -0,0 +1,83 @@
+/*---------------------------------------------------------
+ * Copyright (C) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License. See LICENSE in the project root for license information.
+ *--------------------------------------------------------*/
+
+import * as assert from 'assert';
+import * as path from 'path';
+import * as fs from 'fs';
+import * as os from 'os';
+import { parseEnvFiles } from '../../src/utils/envUtils';
+
+suite('parseEnvFiles Tests', () => {
+	let tmpDir: string;
+
+	setup(() => {
+		tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'go-test-env-'));
+	});
+
+	teardown(() => {
+		if (tmpDir && fs.existsSync(tmpDir)) {
+			// Use rmdir for compatibility with older Node.js versions
+			const rimraf = (dir: string) => {
+				if (fs.existsSync(dir)) {
+					fs.readdirSync(dir).forEach((file) => {
+						const curPath = path.join(dir, file);
+						if (fs.lstatSync(curPath).isDirectory()) {
+							rimraf(curPath);
+						} else {
+							fs.unlinkSync(curPath);
+						}
+					});
+					fs.rmdirSync(dir);
+				}
+			};
+			rimraf(tmpDir);
+		}
+	});
+
+	test('should handle empty array', () => {
+		const result = parseEnvFiles([]);
+		assert.deepStrictEqual(result, {});
+	});
+
+	test('should handle undefined input', () => {
+		const result = parseEnvFiles(undefined);
+		assert.deepStrictEqual(result, {});
+	});
+
+	test('should handle single string input', () => {
+		const envFile = path.join(tmpDir, 'single.env');
+		fs.writeFileSync(envFile, 'SINGLE_VAR=single_value');
+
+		const result = parseEnvFiles(envFile);
+		assert.strictEqual(result.SINGLE_VAR, 'single_value');
+	});
+
+	test('should handle array of files', () => {
+		const envFile1 = path.join(tmpDir, 'first.env');
+		const envFile2 = path.join(tmpDir, 'second.env');
+
+		fs.writeFileSync(envFile1, 'VAR1=value1\nSHARED=from_first');
+		fs.writeFileSync(envFile2, 'VAR2=value2\nSHARED=from_second');
+
+		const result = parseEnvFiles([envFile1, envFile2]);
+
+		assert.strictEqual(result.VAR1, 'value1');
+		assert.strictEqual(result.VAR2, 'value2');
+		// Later files should override earlier ones
+		assert.strictEqual(result.SHARED, 'from_second');
+	});
+
+	test('should handle mixed valid and invalid files', () => {
+		const validFile = path.join(tmpDir, 'valid.env');
+		const invalidFile = path.join(tmpDir, 'nonexistent.env');
+
+		fs.writeFileSync(validFile, 'VALID_VAR=valid_value');
+
+		// This should throw when trying to parse invalid file
+		assert.throws(() => {
+			parseEnvFiles([validFile, invalidFile]);
+		});
+	});
+});