Merge branch 'main' into update-readme

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",

icon.png

@@ -2,7 +2,7 @@
   "name": "debugpy",
   "displayName": "Debugpy",
   "description": "Python Debugger extension using `debugpy`.",
-  "version": "0.0.1",
+  "version": "2023.1.0-dev",
   "publisher": "ms-python",
   "license": "MIT",
   "homepage": "https://github.com/Microsoft/vscode-python-debugger",
@@ -13,6 +13,7 @@
   "bugs": {
     "url": "https://github.com/Microsoft/vscode-python-debugger/issues"
   },
+  "icon": "icon.png",
   "keywords": [
     "python",
     "debugger",
@@ -468,6 +469,7 @@
   "dependencies": {
     "@vscode/extension-telemetry": "^0.7.4-preview",
     "fs-extra": "^11.1.0",
+    "iconv-lite": "^0.6.3",
     "inversify": "^6.0.1",
     "jsonc-parser": "^3.2.0",
     "lodash": "^4.17.21",

package-lock.json

@@ -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';

package.json

@@ -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/ciConstants.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/common.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/constants.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;
+    }
+}