Merge pull request #5 from microsoft/Add-unit-tests

Add unit tests

Author: paulacamargo25

.vscode/tasks.json

@@ -6,7 +6,7 @@
 		{
 			"type": "npm",
 			"script": "watch",
-			"problemMatcher": "$ts-webpack-watch",
+            "problemMatcher": "$tsc-watch",
 			"isBackground": true,
 			"presentation": {
 				"reveal": "never",

src/test/ciConstants.ts

@@ -0,0 +1,22 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+'use strict';
+
+//
+// Constants that pertain to CI processes/tests only. No dependencies on vscode!
+//
+export const PYTHON_VIRTUAL_ENVS_LOCATION = process.env.PYTHON_VIRTUAL_ENVS_LOCATION;
+export const IS_APPVEYOR = process.env.APPVEYOR === 'true';
+export const IS_TRAVIS = process.env.TRAVIS === 'true';
+export const IS_VSTS = process.env.TF_BUILD !== undefined;
+export const IS_GITHUB_ACTIONS = process.env.GITHUB_ACTIONS === 'true';
+export const IS_CI_SERVER = IS_TRAVIS || IS_APPVEYOR || IS_VSTS || IS_GITHUB_ACTIONS;
+
+// Control JUnit-style output logging for reporting purposes.
+let reportJunit: boolean = false;
+if (IS_CI_SERVER && process.env.MOCHA_REPORTER_JUNIT !== undefined) {
+    reportJunit = process.env.MOCHA_REPORTER_JUNIT.toLowerCase() === 'true';
+}
+export const MOCHA_REPORTER_JUNIT: boolean = reportJunit;
+export const IS_CI_SERVER_TEST_DEBUGGER = process.env.IS_CI_SERVER_TEST_DEBUGGER === '1';

src/test/common.ts

@@ -0,0 +1,96 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+'use strict';
+
+// IMPORTANT: Do not import anything from the 'client' folder in this file as that folder is not available during smoke tests.
+
+import * as fs from 'fs-extra';
+import { ConfigurationTarget, TextDocument, Uri } from 'vscode';
+import { IS_MULTI_ROOT_TEST } from './constants';
+import { IExtensionApi } from '../extension/apiTypes';
+import { assert } from 'chai';
+
+export const PYTHON_PATH = getPythonPath();
+
+export async function clearPythonPathInWorkspaceFolder(resource: string | Uri) {
+    const vscode = require('vscode') as typeof import('vscode');
+    return retryAsync(setPythonPathInWorkspace)(resource, vscode.ConfigurationTarget.WorkspaceFolder);
+}
+
+export async function setPythonPathInWorkspaceRoot(pythonPath: string) {
+    const vscode = require('vscode') as typeof import('vscode');
+    return retryAsync(setPythonPathInWorkspace)(undefined, vscode.ConfigurationTarget.Workspace, pythonPath);
+}
+
+export const resetGlobalPythonPathSetting = async () => retryAsync(restoreGlobalPythonPathSetting)();
+
+export async function openFile(file: string): Promise<TextDocument> {
+    const vscode = require('vscode') as typeof import('vscode');
+    const textDocument = await vscode.workspace.openTextDocument(file);
+    await vscode.window.showTextDocument(textDocument);
+    assert(vscode.window.activeTextEditor, 'No active editor');
+    return textDocument;
+}
+
+export function retryAsync(this: any, wrapped: Function, retryCount: number = 2) {
+    return async (...args: any[]) => {
+        return new Promise((resolve, reject) => {
+            const reasons: any[] = [];
+
+            const makeCall = () => {
+                wrapped.call(this as Function, ...args).then(resolve, (reason: any) => {
+                    reasons.push(reason);
+                    if (reasons.length >= retryCount) {
+                        reject(reasons);
+                    } else {
+                        // If failed once, lets wait for some time before trying again.
+                        setTimeout(makeCall, 500);
+                    }
+                });
+            };
+
+            makeCall();
+        });
+    };
+}
+
+async function setPythonPathInWorkspace(
+    resource: string | Uri | undefined,
+    config: ConfigurationTarget,
+    pythonPath?: string,
+) {
+    const vscode = require('vscode') as typeof import('vscode');
+    if (config === vscode.ConfigurationTarget.WorkspaceFolder && !IS_MULTI_ROOT_TEST) {
+        return;
+    }
+    const resourceUri = typeof resource === 'string' ? vscode.Uri.file(resource) : resource;
+    const settings = vscode.workspace.getConfiguration('python', resourceUri || null);
+    const value = settings.inspect<string>('defaultInterpreterPath');
+    const prop: 'workspaceFolderValue' | 'workspaceValue' =
+        config === vscode.ConfigurationTarget.Workspace ? 'workspaceValue' : 'workspaceFolderValue';
+    if (value && value[prop] !== pythonPath) {
+        await settings.update('defaultInterpreterPath', pythonPath, config);
+        // await disposePythonSettings();
+    }
+}
+async function restoreGlobalPythonPathSetting(): Promise<void> {
+    const vscode = require('vscode') as typeof import('vscode');
+    const pythonConfig = vscode.workspace.getConfiguration('python', null as any as Uri);
+    await Promise.all([
+        pythonConfig.update('defaultInterpreterPath', undefined, true),
+        pythonConfig.update('defaultInterpreterPath', undefined, true),
+    ]);
+    // await disposePythonSettings();
+}
+
+function getPythonPath(): string {
+    if (process.env.CI_PYTHON_PATH && fs.existsSync(process.env.CI_PYTHON_PATH)) {
+        return process.env.CI_PYTHON_PATH;
+    }
+
+    // TODO: Change this to python3.
+    // See https://github.com/microsoft/vscode-python/issues/10910.
+    return 'python';
+}
+
+export interface IExtensionTestApi extends IExtensionApi {}

src/test/constants.ts

@@ -0,0 +1,41 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+import * as path from 'path';
+import { IS_CI_SERVER, IS_CI_SERVER_TEST_DEBUGGER } from './ciConstants';
+
+// Activating extension for Multiroot and Debugger CI tests for Windows takes just over 2 minutes sometimes, so 3 minutes seems like a safe margin
+export const MAX_EXTENSION_ACTIVATION_TIME = 180_000;
+export const TEST_TIMEOUT = 60_000;
+export const TEST_RETRYCOUNT = 3;
+export const IS_SMOKE_TEST = process.env.VSC_PYTHON_SMOKE_TEST === '1';
+export const IS_PERF_TEST = process.env.VSC_PYTHON_PERF_TEST === '1';
+export const IS_MULTI_ROOT_TEST = isMultitrootTest();
+
+// If running on CI server, then run debugger tests ONLY if the corresponding flag is enabled.
+export const TEST_DEBUGGER = IS_CI_SERVER ? IS_CI_SERVER_TEST_DEBUGGER : true;
+
+function isMultitrootTest() {
+    // No need to run smoke nor perf tests in a multi-root environment.
+    if (IS_SMOKE_TEST || IS_PERF_TEST) {
+        return false;
+    }
+    try {
+        const vscode = require('vscode');
+        const workspace = vscode.workspace;
+        return Array.isArray(workspace.workspaceFolders) && workspace.workspaceFolders.length > 1;
+    } catch {
+        // being accessed, when VS Code hasn't been launched.
+        return false;
+    }
+}
+
+export const EXTENSION_ROOT_DIR_FOR_TESTS = path.join(__dirname, '..', '..');
+export const PVSC_EXTENSION_ID_FOR_TESTS = 'ms-python.python';
+
+export const SMOKE_TEST_EXTENSIONS_DIR = path.join(
+    EXTENSION_ROOT_DIR_FOR_TESTS,
+    'tmp',
+    'ext',
+    'smokeTestExtensionsFolder',
+);

src/test/core.ts

@@ -0,0 +1,14 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+'use strict';
+
+// File without any dependencies on VS Code.
+
+export async function sleep(milliseconds: number) {
+    return new Promise<void>((resolve) => setTimeout(resolve, milliseconds));
+}
+
+export function noop() {}
+
+export const isWindows = /^win/.test(process.platform);

src/test/fixtures.ts

@@ -0,0 +1,87 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+import * as fs from 'fs-extra';
+import { PYTHON_PATH } from './common';
+import { sleep } from './core';
+import { Proc, spawn } from './proc';
+
+export type CleanupFunc = (() => void) | (() => Promise<void>);
+
+export class CleanupFixture {
+    private cleanups: CleanupFunc[];
+    constructor() {
+        this.cleanups = [];
+    }
+
+    public addCleanup(cleanup: CleanupFunc) {
+        this.cleanups.push(cleanup);
+    }
+    public addFSCleanup(filename: string) {
+        this.addCleanup(async () => {
+            try {
+                await fs.unlink(filename);
+            } catch {
+                // The file is already gone.
+            }
+        });
+    }
+
+    public async cleanUp() {
+        const cleanups = this.cleanups;
+        this.cleanups = [];
+
+        return Promise.all(
+            cleanups.map(async (cleanup, i) => {
+                try {
+                    const res = cleanup();
+                    if (res) {
+                        await res;
+                    }
+                } catch (err) {
+                    console.error(`cleanup ${i + 1} failed: ${err}`);
+
+                    console.error('moving on...');
+                }
+            }),
+        );
+    }
+}
+
+export class PythonFixture extends CleanupFixture {
+    public readonly python: string;
+    constructor(
+        // If not provided, we will use the global default.
+        python?: string,
+    ) {
+        super();
+        if (python) {
+            this.python = python;
+        } else {
+            this.python = PYTHON_PATH;
+        }
+    }
+
+    public runScript(filename: string, ...args: string[]): Proc {
+        return this.spawn(filename, ...args);
+    }
+
+    public runModule(name: string, ...args: string[]): Proc {
+        return this.spawn('-m', name, ...args);
+    }
+
+    private spawn(...args: string[]) {
+        const proc = spawn(this.python, ...args);
+        this.addCleanup(async () => {
+            if (!proc.exited) {
+                await sleep(1000); // Wait a sec before the hammer falls.
+                try {
+                    proc.raw.kill();
+                } catch {
+                    // It already finished.
+                }
+            }
+        });
+        return proc;
+    }
+}

src/test/initialize.ts

@@ -0,0 +1,107 @@
+import * as path from 'path';
+import * as vscode from 'vscode';
+import { IExtensionApi } from '../extension/apiTypes';
+import {
+    clearPythonPathInWorkspaceFolder,
+    IExtensionTestApi,
+    PYTHON_PATH,
+    resetGlobalPythonPathSetting,
+    setPythonPathInWorkspaceRoot,
+} from './common';
+import { PVSC_EXTENSION_ID_FOR_TESTS } from './constants';
+import { sleep } from './core';
+
+export * from './constants';
+export * from './ciConstants';
+
+const dummyPythonFile = path.join(__dirname, '..', '..', 'src', 'test', 'pythonFiles', 'dummy.py');
+export const multirootPath = path.join(__dirname, '..', '..', 'src', 'testMultiRootWkspc');
+const workspace3Uri = vscode.Uri.file(path.join(multirootPath, 'workspace3'));
+
+//First thing to be executed.
+process.env.VSC_PYTHON_CI_TEST = '1';
+
+// Ability to use custom python environments for testing
+export async function initializePython() {
+    await resetGlobalPythonPathSetting();
+    await clearPythonPathInWorkspaceFolder(dummyPythonFile);
+    await clearPythonPathInWorkspaceFolder(workspace3Uri);
+    await setPythonPathInWorkspaceRoot(PYTHON_PATH);
+}
+
+export async function initialize(): Promise<IExtensionTestApi> {
+    await initializePython();
+    const api = await activateExtension();
+    // if (!IS_SMOKE_TEST) {
+    //     // When running smoke tests, we won't have access to these.
+    //     const configSettings = await import('../client/common/configSettings');
+    //     // Dispose any cached python settings (used only in test env).
+    //     configSettings.PythonSettings.dispose();
+    // }
+
+    return api as any as IExtensionTestApi;
+}
+export async function activateExtension() {
+    const extension = vscode.extensions.getExtension<IExtensionApi>(PVSC_EXTENSION_ID_FOR_TESTS)!;
+    const api = await extension.activate();
+    return api;
+}
+
+export async function initializeTest(): Promise<any> {
+    await initializePython();
+    await closeActiveWindows();
+    // if (!IS_SMOKE_TEST) {
+    //     // When running smoke tests, we won't have access to these.
+    //     const configSettings = await import('../client/common/configSettings');
+    //     // Dispose any cached python settings (used only in test env).
+    //     configSettings.PythonSettings.dispose();
+    // }
+}
+export async function closeActiveWindows(): Promise<void> {
+    await closeActiveNotebooks();
+    await closeWindowsInteral();
+}
+export async function closeActiveNotebooks(): Promise<void> {
+    if (!vscode.env.appName.toLowerCase().includes('insiders') || !isANotebookOpen()) {
+        return;
+    }
+    // We could have untitled notebooks, close them by reverting changes.
+
+    while ((vscode as any).window.activeNotebookEditor || vscode.window.activeTextEditor) {
+        await vscode.commands.executeCommand('workbench.action.revertAndCloseActiveEditor');
+    }
+    // Work around VS Code issues (sometimes notebooks do not get closed).
+    // Hence keep trying.
+    for (let counter = 0; counter <= 5 && isANotebookOpen(); counter += 1) {
+        await sleep(counter * 100);
+        await closeWindowsInteral();
+    }
+}
+
+async function closeWindowsInteral() {
+    return new Promise<void>((resolve, reject) => {
+        // Attempt to fix #1301.
+        // Lets not waste too much time.
+        const timer = setTimeout(() => {
+            reject(new Error("Command 'workbench.action.closeAllEditors' timed out"));
+        }, 15000);
+        vscode.commands.executeCommand('workbench.action.closeAllEditors').then(
+            () => {
+                clearTimeout(timer);
+                resolve();
+            },
+            (ex) => {
+                clearTimeout(timer);
+                reject(ex);
+            },
+        );
+    });
+}
+
+function isANotebookOpen() {
+    if (!vscode.window.activeTextEditor?.document) {
+        return false;
+    }
+
+    return !!(vscode.window.activeTextEditor.document as any).notebook;
+}