Refactor (for clarity) the venv creation testing helper.

Author: ericsnowcurrently

src/test/interpreters/locators/workspaceVirtualEnvService.test.ts

@@ -7,6 +7,7 @@
 import { expect } from 'chai';
 import { exec } from 'child_process';
 import * as path from 'path';
+import { promisify } from 'util';
 import { Uri } from 'vscode';
 import '../../../client/common/extensions';
 import { createDeferredFromPromise, Deferred } from '../../../client/common/utils/async';
@@ -24,16 +25,66 @@ import { IS_MULTI_ROOT_TEST } from '../../constants';
 import { sleep } from '../../core';
 import { initialize, multirootPath } from '../../initialize';
 
+const execAsync = promisify(exec);
+async function run(argv: string[], cwd: string) {
+    const cmdline = argv.join(' ');
+    const { stderr } = await execAsync(cmdline, {
+        cwd: cwd
+    });
+    if (stderr && stderr.length > 0) {
+        throw Error(stderr);
+    }
+}
+
+class Venvs {
+    constructor(
+        private readonly cwd: string,
+        private readonly prefix = '.venv-'
+    ) { }
+
+    public async create(name: string): Promise<string> {
+        const venvRoot = this.resolve(name);
+        const argv = [
+            PYTHON_PATH.fileToCommandArgument(),
+            '-m', 'venv',
+            venvRoot
+        ];
+        try {
+            await run(argv, this.cwd);
+        } catch (err) {
+            throw new Error(`Failed to create Env ${path.basename(venvRoot)}, ${PYTHON_PATH}, Error: ${err}`);
+        }
+        return venvRoot;
+    }
+
+    public async cleanUp() {
+        const globPattern = path.join(this.cwd, `${this.prefix}*`);
+        await deleteFiles(globPattern);
+    }
+
+    private getID(name: string): string {
+        // Ensure env is random to avoid conflicts in tests (currupting test data).
+        const now = new Date().getTime().toString();
+        return `${this.prefix}${name}${now}`;
+    }
+
+    private resolve(name: string): string {
+        const id = this.getID(name);
+        return path.join(this.cwd, id);
+    }
+}
+
 const timeoutMs = IS_CI_SERVER ? 60_000 : 15_000;
 suite('Interpreters - Workspace VirtualEnv Service', function() {
     this.timeout(timeoutMs);
     this.retries(0);
 
-    let locator: IInterpreterLocatorService;
     const workspaceUri = IS_MULTI_ROOT_TEST ? Uri.file(path.join(multirootPath, 'workspace3')) : rootWorkspaceUri!;
     const workspace4 = Uri.file(path.join(multirootPath, 'workspace4'));
-    const venvPrefix = '.venv';
+    const venvs = new Venvs(workspaceUri.fsPath);
+
     let serviceContainer: IServiceContainer;
+    let locator: IInterpreterLocatorService;
 
     async function manuallyTriggerFSWatcher(deferred: Deferred<void>) {
         // Monitoring files on virtualized environments can be finicky...
@@ -51,7 +102,8 @@ suite('Interpreters - Workspace VirtualEnv Service', function() {
             await sleep(1000);
         }
     }
-    async function waitForInterpreterToBeDetected(envNameToLookFor: string) {
+    async function waitForInterpreterToBeDetected(venvRoot: string) {
+        const envNameToLookFor = path.basename(venvRoot);
         const predicate = async () => {
             const items = await locator.getInterpreters(workspaceUri);
             return items.some(item => item.envName === envNameToLookFor);
@@ -66,24 +118,7 @@ suite('Interpreters - Workspace VirtualEnv Service', function() {
         await deferred.promise;
     }
     async function createVirtualEnvironment(envSuffix: string) {
-        // Ensure env is random to avoid conflicts in tests (currupting test data).
-        const envName = `${venvPrefix}${envSuffix}${new Date().getTime().toString()}`;
-        return new Promise<string>((resolve, reject) => {
-            exec(
-                `${PYTHON_PATH.fileToCommandArgument()} -m venv ${envName}`,
-                { cwd: workspaceUri.fsPath },
-                (ex, _, stderr) => {
-                    if (ex) {
-                        return reject(ex);
-                    }
-                    if (stderr && stderr.length > 0) {
-                        reject(new Error(`Failed to create Env ${envName}, ${PYTHON_PATH}, Error: ${stderr}`));
-                    } else {
-                        resolve(envName);
-                    }
-                }
-            );
-        });
+        return venvs.create(envSuffix);
     }
 
     suiteSetup(async function() {
@@ -99,12 +134,12 @@ suite('Interpreters - Workspace VirtualEnv Service', function() {
         );
         // This test is required, we need to wait for interpreter listing completes,
         // before proceeding with other tests.
-        await deleteFiles(path.join(workspaceUri.fsPath, `${venvPrefix}*`));
+        await venvs.cleanUp();
         await locator.getInterpreters(workspaceUri);
     });
 
-    suiteTeardown(async () => deleteFiles(path.join(workspaceUri.fsPath, `${venvPrefix}*`)));
-    teardown(async () => deleteFiles(path.join(workspaceUri.fsPath, `${venvPrefix}*`)));
+    suiteTeardown(async () => venvs.cleanUp());
+    teardown(async () => venvs.cleanUp());
 
     test('Detect Virtual Environment', async () => {
         const envName = await createVirtualEnvironment('one');
@@ -132,7 +167,10 @@ suite('Interpreters - Workspace VirtualEnv Service', function() {
             createVirtualEnvironment('first3'),
             createVirtualEnvironment('second3')
         ]);
-        await Promise.all([waitForInterpreterToBeDetected(env1), waitForInterpreterToBeDetected(env2)]);
+        await Promise.all([
+            waitForInterpreterToBeDetected(env1),
+            waitForInterpreterToBeDetected(env2)
+        ]);
 
         // Workspace4 should still not have any interpreters.
         items4 = await locator.getInterpreters(workspace4);