add support for testEnvFile

package.json

@@ -489,6 +489,11 @@
           "default": {},
           "description": "Environment variables that will passed to the process that runs the Go tests"
         },
+        "go.testEnvFile": {
+          "type": "string",
+          "default": null,
+          "description": "Absolute path to a file containing environment variables definitions"
+        },
         "go.testFlags": {
           "type": [
             "array",

src/debugAdapter/goDebug.ts

@@ -11,7 +11,7 @@ import { readFileSync, existsSync, lstatSync } from 'fs';
 import { basename, dirname, extname } from 'path';
 import { spawn, ChildProcess, execSync, spawnSync } from 'child_process';
 import { Client, RPCConnection } from 'json-rpc2';
-import { getBinPathWithPreferredGopath, resolvePath, stripBOM, getGoRuntimePath } from '../goPath';
+import { parseEnvFile, getBinPathWithPreferredGopath, resolvePath, stripBOM, getGoRuntimePath } from '../goPath';
 import * as logger from 'vscode-debug-logger';
 import * as FS from 'fs';
 
@@ -207,24 +207,12 @@ class Delve {
 				return reject('The program attribute must point to valid directory, .go file or executable.');
 			}
 
-			// read env from disk and merge into envVars
+			// read env from disk and merge into env variables
 			let fileEnv = {};
-			if (launchArgs.envFile) {
-				try {
-					const buffer = stripBOM(FS.readFileSync(launchArgs.envFile, 'utf8'));
-					buffer.split('\n').forEach( line => {
-						const r = line.match(/^\s*([\w\.\-]+)\s*=\s*(.*)?\s*$/);
-						if (r !== null) {
-							let value = r[2] || '';
-							if (value.length > 0 && value.charAt(0) === '"' && value.charAt(value.length - 1) === '"') {
-								value = value.replace(/\\n/gm, '\n');
-							}
-							fileEnv[r[1]] = value.replace(/(^['"]|['"]$)/g, '');
-						}
-					});
-				} catch (e) {
-					return reject('Cannot load environment variables from file');
-				}
+			try {
+				fileEnv = parseEnvFile(launchArgs.envFile);
+			} catch (e) {
+				return reject(e);
 			}
 
 			let env = Object.assign({}, process.env, fileEnv, launchArgs.env);

src/goPath.ts

@@ -125,4 +125,28 @@ export function stripBOM(s: string): string {
 		s = s.substr(1);
 	}
 	return s;
+}
+
+export function parseEnvFile(path: string): { [key: string]: string } {
+	const env = { };
+	if (!path) {
+		return env;
+	}
+
+	try {
+		const buffer = stripBOM(fs.readFileSync(path, 'utf8'));
+		buffer.split('\n').forEach( line => {
+			const r = line.match(/^\s*([\w\.\-]+)\s*=\s*(.*)?\s*$/);
+			if (r !== null) {
+				let value = r[2] || '';
+				if (value.length > 0 && value.charAt(0) === '"' && value.charAt(value.length - 1) === '"') {
+					value = value.replace(/\\n/gm, '\n');
+				}
+				env[r[1]] = value.replace(/(^['"]|['"]$)/g, '');
+			}
+		});
+		return env;
+	} catch (e) {
+		throw(`Cannot load environment variables from file ${path}`);
+	}
 }

src/goRunTestCodelens.ts

@@ -9,29 +9,28 @@ import vscode = require('vscode');
 import path = require('path');
 import { CodeLensProvider, TextDocument, CancellationToken, CodeLens, Command } from 'vscode';
 import { getTestFunctions } from './goTest';
+import { getTestEnvVars } from './util';
 import { GoDocumentSymbolProvider } from './goOutline';
 
 export class GoRunTestCodeLensProvider implements CodeLensProvider {
 	private readonly debugConfig: any = {
 				'name': 'Launch',
 				'type': 'go',
 				'request': 'launch',
-				'mode': 'test',
-				'env': {
-					'GOPATH': process.env['GOPATH']
-				}
+				'mode': 'test'
 			};
 
 	public provideCodeLenses(document: TextDocument, token: CancellationToken): CodeLens[] | Thenable<CodeLens[]> {
-		let codeLensConfig = vscode.workspace.getConfiguration('go').get('enableCodeLens');
+		let config = vscode.workspace.getConfiguration('go');
+		let codeLensConfig = config.get('enableCodeLens');
 		let codelensEnabled = codeLensConfig ? codeLensConfig['runtest'] : false;
 		if (!codelensEnabled || !document.fileName.endsWith('_test.go')) {
 			return;
 		}
 
 		return Promise.all([
 			this.getCodeLensForPackage(document),
-			this.getCodeLensForFunctions(document)
+			this.getCodeLensForFunctions(config, document)
 		]).then(res => {
 			return res[0].concat(res[1]);
 		});
@@ -58,7 +57,7 @@ export class GoRunTestCodeLensProvider implements CodeLensProvider {
 				});
 	}
 
-	private getCodeLensForFunctions(document: TextDocument): Thenable<CodeLens[]> {
+	private getCodeLensForFunctions(vsConfig: vscode.WorkspaceConfiguration, document: TextDocument): Thenable<CodeLens[]> {
 		return getTestFunctions(document).then(testFunctions => {
 			let codelens = [];
 
@@ -69,8 +68,12 @@ export class GoRunTestCodeLensProvider implements CodeLensProvider {
 					arguments: [ { functionName: func.name} ]
 				};
 
-				let config = Object.assign({}, this.debugConfig, { args: ['-test.run', func.name], program: path.dirname(document.fileName) });
-				Object.assign(config.env, vscode.workspace.getConfiguration('go').get('testEnvVars'));
+				const args = ['-test.run', func.name];
+				const program = path.dirname(document.fileName);
+				const env = vsConfig['testEnvVars'] || {};
+				const envFile = vsConfig['testEnvFile'];
+
+				let config = Object.assign({}, this.debugConfig, { args, program, env, envFile });
 				let debugTestCmd: Command = {
 					title: 'debug test',
 					command: 'vscode.startDebug',

src/goTest.ts

@@ -12,7 +12,7 @@ import util = require('util');
 import os = require('os');
 import { getGoRuntimePath } from './goPath';
 import { GoDocumentSymbolProvider } from './goOutline';
-import { getToolsEnvVars } from './util';
+import { getTestEnvVars } from './util';
 
 let outputChannel = vscode.window.createOutputChannel('Go Tests');
 
@@ -204,7 +204,7 @@ export function goTest(testconfig: TestConfig): Thenable<boolean> {
 
 		let buildTags: string = testconfig.goConfig['buildTags'];
 		let args = ['test', ...testconfig.flags, '-timeout', testconfig.goConfig['testTimeout'], '-tags', buildTags];
-		let testEnvVars = Object.assign({}, getToolsEnvVars(), testconfig.goConfig['testEnvVars']);
+		let testEnvVars = getTestEnvVars();
 		let goRuntimePath = getGoRuntimePath();
 
 		if (!goRuntimePath) {

src/util.ts

@@ -5,9 +5,10 @@
 
 import vscode = require('vscode');
 import path = require('path');
-import { getGoRuntimePath, getBinPathWithPreferredGopath, resolvePath } from './goPath';
+import { parseEnvFile, getGoRuntimePath, getBinPathWithPreferredGopath, resolvePath, stripBOM } from './goPath';
 import cp = require('child_process');
 import TelemetryReporter from 'vscode-extension-telemetry';
+import fs = require('fs');
 
 const extensionId: string = 'lukehoban.Go';
 const extensionVersion: string = vscode.extensions.getExtension(extensionId).packageJSON.version;
@@ -298,6 +299,21 @@ export function getToolsEnvVars(): any {
 	return Object.assign({}, process.env, toolsEnvVars);
 }
 
+export function getTestEnvVars(): any {
+	const config = vscode.workspace.getConfiguration('go');
+	const toolsEnv = getToolsEnvVars();
+	const testEnv = config['testEnvVars'] || {};
+
+	let fileEnv = {};
+	let testEnvFile = config['testEnvFile'];
+	if (testEnvFile) {
+		testEnvFile = testEnvFile.replace(/\${workspaceRoot}/g, vscode.workspace.rootPath);
+		fileEnv = parseEnvFile(testEnvFile);
+	}
+
+	return Object.assign({}, toolsEnv, fileEnv, testEnv);
+}
+
 export function getExtensionCommands(): any[] {
 	let pkgJSON = vscode.extensions.getExtension(extensionId).packageJSON;
 	if (!pkgJSON.contributes || !pkgJSON.contributes.commands) {