@vscode/test-web 0.0.13 → 0.0.17

package/out/index.js

@@ -1,233 +1,365 @@
-#!/usr/bin/env node
-"use strict";
-/* eslint-disable header/header */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.open = exports.runTests = void 0;
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-const main_1 = require("./server/main");
-const download_1 = require("./server/download");
-const playwright = require("playwright");
-const minimist = require("minimist");
-const path = require("path");
-/**
- * Runs the tests in a browser.
- *
- * @param options The options defining browser type, extension and test location.
- */
-async function runTests(options) {
-    var _a;
-    const config = {
-        extensionDevelopmentPath: options.extensionDevelopmentPath,
-        extensionTestsPath: options.extensionTestsPath,
-        build: await getBuild(options.version),
-        folderUri: options.folderUri,
-        folderMountPath: options.folderPath
-    };
-    const port = 3000;
-    const server = await (0, main_1.runServer)(port, config);
-    const endpoint = `http://localhost:${port}`;
-    const result = await openInBrowser({
-        browserType: options.browserType,
-        endpoint,
-        headless: (_a = options.headless) !== null && _a !== void 0 ? _a : true,
-        devTools: options.devTools,
-        waitForDebugger: options.waitForDebugger,
-    });
-    server.close();
-    if (result) {
-        return;
-    }
-    throw new Error('Test failed');
-}
-exports.runTests = runTests;
-async function getBuild(version) {
-    if (version === 'sources') {
-        return { type: 'sources' };
-    }
-    return await (0, download_1.downloadAndUnzipVSCode)(version === 'stable' ? 'stable' : 'insider');
-}
-async function open(options) {
-    var _a;
-    const config = {
-        extensionDevelopmentPath: options.extensionDevelopmentPath,
-        build: await getBuild(options.version),
-        folderUri: options.folderUri,
-        folderMountPath: options.folderPath
-    };
-    const port = 3000;
-    await (0, main_1.runServer)(port, config);
-    const endpoint = `http://localhost:${port}`;
-    await openInBrowser({
-        browserType: options.browserType,
-        endpoint,
-        headless: (_a = options.headless) !== null && _a !== void 0 ? _a : false,
-        devTools: options.devTools,
-        waitForDebugger: options.waitForDebugger
-    });
-}
-exports.open = open;
-const width = 1200;
-const height = 800;
-function openInBrowser(options) {
-    return new Promise(async (s) => {
-        var _a;
-        const args = [];
-        if (process.platform === 'linux' && options.browserType === 'chromium') {
-            args.push('--no-sandbox');
-        }
-        if (options.waitForDebugger) {
-            args.push(`--remote-debugging-port=${options.waitForDebugger}`);
-        }
-        const browser = await playwright[options.browserType].launch({ headless: options.headless, args, devtools: options.devTools });
-        const context = await browser.newContext();
-        const page = (_a = context.pages()[0]) !== null && _a !== void 0 ? _a : await context.newPage();
-        if (options.waitForDebugger) {
-            await page.waitForFunction(() => '__jsDebugIsReady' in globalThis);
-        }
-        await page.setViewportSize({ width, height });
-        await page.goto(options.endpoint);
-        await page.exposeFunction('codeAutomationLog', (type, args) => {
-            console[type](...args);
-        });
-        await page.exposeFunction('codeAutomationExit', async (code) => {
-            try {
-                await browser.close();
-            }
-            catch (error) {
-                console.error(`Error when closing browser: ${error}`);
-            }
-            s(code === 0);
-        });
-    });
-}
-function validateStringOrUndefined(options, name) {
-    const value = options[name];
-    if (value === undefined || (typeof value === 'string')) {
-        return value;
-    }
-    console.log(`'${name}' needs to be a string value.`);
-    showHelp();
-    process.exit(-1);
-}
-async function validatePathOrUndefined(options, name, isFile) {
-    const loc = validateStringOrUndefined(options, name);
-    return loc && validatePath(loc, isFile);
-}
-function validateBooleanOrUndefined(options, name) {
-    const value = options[name];
-    if (value === undefined || (typeof value === 'boolean')) {
-        return value;
-    }
-    console.log(`'${name}' needs to be a boolean value.`);
-    showHelp();
-    process.exit(-1);
-}
-function valdiateBrowserType(browserType) {
-    if (browserType === 'undefined') {
-        return 'chromium';
-    }
-    if ((typeof browserType === 'string') && ['chromium', 'firefox', 'webkit'].includes(browserType)) {
-        return browserType;
-    }
-    console.log(`Invalid browser type.`);
-    showHelp();
-    process.exit(-1);
-}
-async function validatePath(loc, isFile) {
-    loc = path.resolve(loc);
-    if (isFile) {
-        if (!await (0, download_1.fileExists)(loc)) {
-            console.log(`'${loc}' must be an existing file.`);
-            process.exit(-1);
-        }
-    }
-    else {
-        if (!await (0, download_1.directoryExists)(loc)) {
-            console.log(`'${loc}' must be an existing folder.`);
-            process.exit(-1);
-        }
-    }
-    return loc;
-}
-function validateVersion(version) {
-    if (version === undefined || ((typeof version === 'string') && ['insiders', 'stable', 'sources'].includes(version))) {
-        return version;
-    }
-    console.log(`Invalid version.`);
-    showHelp();
-    process.exit(-1);
-}
-function validatePortNumber(port) {
-    if (typeof port === 'string') {
-        const number = Number.parseInt(port);
-        if (!Number.isNaN(number) && number >= 0) {
-            return number;
-        }
-    }
-    return undefined;
-}
-function showHelp() {
-    console.log('Usage:');
-    console.log(`  --browserType 'chromium' | 'firefox' | 'webkit': The browser to launch`);
-    console.log(`  --extensionDevelopmentPath path. [Optional]: A path pointing to a extension to include.`);
-    console.log(`  --extensionTestsPath path.  [Optional]: A path to a test module to run`);
-    console.log(`  --version. 'insiders' (Default) | 'stable' | 'sources' [Optional]`);
-    console.log(`  --open-devtools. Opens the dev tools  [Optional]`);
-    console.log(`  --headless. Whether to show the browser. Defaults to true when an extensionTestsPath is provided, otherwise false. [Optional]`);
-    console.log(`  folderPath. A local folder to open VS Code on. The folder content will be available as a virtual file system`);
-}
-async function cliMain() {
-    const options = { string: ['extensionDevelopmentPath', 'extensionTestsPath', 'browserType', 'version', 'waitForDebugger', 'folder-uri', 'mount'], boolean: ['open-devtools', 'headless'] };
-    const args = minimist(process.argv.slice(2), options);
-    const browserType = valdiateBrowserType(args.browserType);
-    const version = validateVersion(args.version);
-    const extensionTestsPath = await validatePathOrUndefined(args, 'extensionTestsPath', true);
-    const extensionDevelopmentPath = await validatePathOrUndefined(args, 'extensionDevelopmentPath');
-    const headless = validateBooleanOrUndefined(args, 'headless');
-    const devTools = validateBooleanOrUndefined(args, 'open-devtools');
-    const port = validatePortNumber(args.waitForDebugger);
-    let folderUri = validateStringOrUndefined(args, 'folder-uri');
-    let folderPath;
-    const inputs = args._;
-    if (inputs.length) {
-        const input = await validatePath(inputs[0]);
-        if (input) {
-            folderPath = input;
-            if (folderUri) {
-                console.log(`Local folder provided as input, ignoring 'folder-uri'`);
-                folderUri = undefined;
-            }
-        }
-    }
-    if (extensionTestsPath) {
-        runTests({
-            extensionTestsPath,
-            extensionDevelopmentPath,
-            browserType,
-            version,
-            devTools,
-            waitForDebugger: port,
-            folderUri,
-            folderPath,
-            headless
-        });
-    }
-    else {
-        open({
-            extensionDevelopmentPath,
-            browserType,
-            version,
-            devTools,
-            waitForDebugger: port,
-            folderUri,
-            folderPath,
-            headless
-        });
-    }
-}
-if (require.main === module) {
-    cliMain();
-}
+#!/usr/bin/env node
+"use strict";
+/* eslint-disable header/header */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.open = exports.runTests = void 0;
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+const main_1 = require("./server/main");
+const download_1 = require("./server/download");
+const playwright = require("playwright");
+const minimist = require("minimist");
+const path = require("path");
+/**
+ * Runs the tests in a browser.
+ *
+ * @param options The options defining browser type, extension and test location.
+ */
+async function runTests(options) {
+    var _a, _b, _c;
+    const config = {
+        extensionDevelopmentPath: options.extensionDevelopmentPath,
+        extensionTestsPath: options.extensionTestsPath,
+        build: await getBuild(options),
+        folderUri: options.folderUri,
+        folderMountPath: options.folderPath,
+        hideServerLog: (_a = options.hideServerLog) !== null && _a !== void 0 ? _a : true,
+        extensionPaths: options.extensionPaths
+    };
+    const host = (_b = options.host) !== null && _b !== void 0 ? _b : 'localhost';
+    const port = (_c = options.port) !== null && _c !== void 0 ? _c : 3000;
+    const server = await (0, main_1.runServer)(host, port, config);
+    return new Promise(async (s, e) => {
+        const endpoint = `http://${host}:${port}`;
+        const context = await openBrowser(endpoint, options);
+        context.once('close', () => server.close());
+        await context.exposeFunction('codeAutomationLog', (type, args) => {
+            console[type](...args);
+        });
+        await context.exposeFunction('codeAutomationExit', async (code) => {
+            var _a;
+            try {
+                await ((_a = context.browser()) === null || _a === void 0 ? void 0 : _a.close());
+            }
+            catch (error) {
+                console.error(`Error when closing browser: ${error}`);
+            }
+            server.close();
+            if (code === 0) {
+                s();
+            }
+            else {
+                e(new Error('Test failed'));
+            }
+        });
+    });
+}
+exports.runTests = runTests;
+async function getBuild(options) {
+    if (options.vsCodeDevPath) {
+        return {
+            type: 'sources',
+            location: options.vsCodeDevPath
+        };
+    }
+    const quality = options.quality || options.version;
+    return await (0, download_1.downloadAndUnzipVSCode)(quality === 'stable' ? 'stable' : 'insider');
+}
+async function open(options) {
+    var _a, _b, _c;
+    const config = {
+        extensionDevelopmentPath: options.extensionDevelopmentPath,
+        extensionTestsPath: options.extensionTestsPath,
+        build: await getBuild(options),
+        folderUri: options.folderUri,
+        folderMountPath: options.folderPath,
+        hideServerLog: (_a = options.hideServerLog) !== null && _a !== void 0 ? _a : true,
+        extensionPaths: options.extensionPaths
+    };
+    const host = (_b = options.host) !== null && _b !== void 0 ? _b : 'localhost';
+    const port = (_c = options.port) !== null && _c !== void 0 ? _c : 3000;
+    const server = await (0, main_1.runServer)(host, port, config);
+    const endpoint = `http://${host}:${port}`;
+    const context = await openBrowser(endpoint, options);
+    context.once('close', () => server.close());
+    return {
+        dispose: () => {
+            var _a;
+            server.close();
+            (_a = context.browser()) === null || _a === void 0 ? void 0 : _a.close();
+        }
+    };
+}
+exports.open = open;
+const width = 1200;
+const height = 800;
+async function openBrowser(endpoint, options) {
+    var _a, _b;
+    const args = [];
+    if (process.platform === 'linux' && options.browserType === 'chromium') {
+        args.push('--no-sandbox');
+    }
+    if (options.waitForDebugger) {
+        args.push(`--remote-debugging-port=${options.waitForDebugger}`);
+    }
+    const headless = (_a = options.headless) !== null && _a !== void 0 ? _a : options.extensionTestsPath !== undefined;
+    const browser = await playwright[options.browserType].launch({ headless, args, devtools: options.devTools });
+    const context = await browser.newContext();
+    if (options.permissions) {
+        context.grantPermissions(options.permissions);
+    }
+    // forcefully close browser if last page is closed. workaround for https://github.com/microsoft/playwright/issues/2946
+    let openPages = 0;
+    context.on('page', page => {
+        openPages++;
+        page.once('close', () => {
+            openPages--;
+            if (openPages === 0) {
+                browser.close();
+            }
+        });
+    });
+    const page = (_b = context.pages()[0]) !== null && _b !== void 0 ? _b : await context.newPage();
+    if (options.waitForDebugger) {
+        await page.waitForFunction(() => '__jsDebugIsReady' in globalThis);
+    }
+    if (options.verbose) {
+        page.on('console', (message) => {
+            console.log(message.text());
+        });
+    }
+    await page.setViewportSize({ width, height });
+    await page.goto(endpoint);
+    return context;
+}
+function validateStringOrUndefined(options, name) {
+    const value = options[name];
+    if (value === undefined || (typeof value === 'string')) {
+        return value;
+    }
+    console.log(`'${name}' needs to be a string value.`);
+    showHelp();
+    process.exit(-1);
+}
+async function validatePathOrUndefined(options, name, isFile) {
+    const loc = validateStringOrUndefined(options, name);
+    return loc && validatePath(loc, isFile);
+}
+function validateBooleanOrUndefined(options, name) {
+    const value = options[name];
+    if (value === undefined || (typeof value === 'boolean')) {
+        return value;
+    }
+    console.log(`'${name}' needs to be a boolean value.`);
+    showHelp();
+    process.exit(-1);
+}
+function valdiateBrowserType(browserType) {
+    if (browserType === undefined) {
+        return 'chromium';
+    }
+    if ((typeof browserType === 'string') && ['chromium', 'firefox', 'webkit'].includes(browserType)) {
+        return browserType;
+    }
+    console.log(`Invalid browser type.`);
+    showHelp();
+    process.exit(-1);
+}
+function valdiatePermissions(permissions) {
+    if (permissions === undefined) {
+        return undefined;
+    }
+    function isValidPermission(p) {
+        return typeof p === 'string';
+    }
+    if (isValidPermission(permissions)) {
+        return [permissions];
+    }
+    if (Array.isArray(permissions) && permissions.every(isValidPermission)) {
+        return permissions;
+    }
+    console.log(`Invalid permission`);
+    showHelp();
+    process.exit(-1);
+}
+async function valdiateExtensionPaths(extensionPaths) {
+    if (extensionPaths === undefined) {
+        return undefined;
+    }
+    if (!Array.isArray(extensionPaths)) {
+        extensionPaths = [extensionPaths];
+    }
+    if (Array.isArray(extensionPaths)) {
+        const res = [];
+        for (const extensionPath of extensionPaths) {
+            if (typeof extensionPath === 'string') {
+                res.push(await validatePath(extensionPath));
+            }
+            else {
+                break;
+            }
+        }
+        return res;
+    }
+    console.log(`Invalid extensionPath`);
+    showHelp();
+    process.exit(-1);
+}
+async function validatePath(loc, isFile) {
+    loc = path.resolve(loc);
+    if (isFile) {
+        if (!await (0, download_1.fileExists)(loc)) {
+            console.log(`'${loc}' must be an existing file.`);
+            process.exit(-1);
+        }
+    }
+    else {
+        if (!await (0, download_1.directoryExists)(loc)) {
+            console.log(`'${loc}' must be an existing folder.`);
+            process.exit(-1);
+        }
+    }
+    return loc;
+}
+function validateQuality(quality, version, vsCodeDevPath) {
+    if (version) {
+        console.log(`--version has been replaced by --quality`);
+        quality = quality || version;
+    }
+    if (vsCodeDevPath && quality) {
+        console.log(`Sources folder is provided as input, quality is ignored.`);
+        return undefined;
+    }
+    if (quality === undefined || ((typeof quality === 'string') && ['insiders', 'stable'].includes(quality))) {
+        return quality;
+    }
+    if (version === 'sources') {
+        console.log(`Instead of version=sources use 'sourcesPath' with the location of the VS Code repository.`);
+    }
+    else {
+        console.log(`Invalid quality.`);
+    }
+    showHelp();
+    process.exit(-1);
+}
+function validatePortNumber(port) {
+    if (typeof port === 'string') {
+        const number = Number.parseInt(port);
+        if (!Number.isNaN(number) && number >= 0) {
+            return number;
+        }
+    }
+    return undefined;
+}
+function showHelp() {
+    console.log('Usage:');
+    console.log(`  --browserType 'chromium' | 'firefox' | 'webkit': The browser to launch. [Optional, defaults to 'chromium']`);
+    console.log(`  --extensionDevelopmentPath path: A path pointing to an extension under development to include. [Optional]`);
+    console.log(`  --extensionTestsPath path: A path to a test module to run. [Optional]`);
+    console.log(`  --quality 'insiders' | 'stable' [Optional, default 'insiders', ignored when running from sources]`);
+    console.log(`  --sourcesPath path: If provided, running from VS Code sources at the given location [Optional]`);
+    console.log(`  --open-devtools: If set, opens the dev tools  [Optional]`);
+    console.log(`  --headless: Whether to hide the browser. Defaults to true when an extensionTestsPath is provided, otherwise false. [Optional]`);
+    console.log(`  --permission: Permission granted in the opened browser: e.g. 'clipboard-read', 'clipboard-write':  [Optional, Multiple]`);
+    console.log(`  --folder-uri: workspace to open VS Code on. Ignored when folderPath is provided [Optional]`);
+    console.log(`  --extensionPath: A path pointing to a folder containing additional extensions to include [Optional, Multiple]`);
+    console.log(`  --host: The host name the server is opened on  [Optional, defaults to localhost]`);
+    console.log(`  --port: The port the server is opened on  [Optional, defaults to 3000]`);
+    console.log(`  --open-devtools: If set, opens the dev tools  [Optional]`);
+    console.log(`  --verbose: If set, prints out more information when running the server  [Optional]`);
+    console.log(`  --hideServerLog: Whether to hide the server log. Defaults to true when an extensionTestsPath is provided, otherwise false. [Optional]`);
+    console.log(`  folderPath. A local folder to open VS Code on. The folder content will be available as a virtual file system. [Optional]`);
+}
+async function cliMain() {
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    const manifest = require('../package.json');
+    console.log(`${manifest.name}: ${manifest.version}`);
+    const options = {
+        string: ['extensionDevelopmentPath', 'extensionTestsPath', 'browserType', 'quality', 'version', 'waitForDebugger', 'folder-uri', 'permission', 'extensionPath', 'sourcesPath', 'host', 'port'],
+        boolean: ['open-devtools', 'headless', 'hideServerLog', 'help', 'verbose'],
+        unknown: arg => {
+            if (arg.startsWith('-')) {
+                console.log(`Unknown argument ${arg}`);
+                showHelp();
+                process.exit();
+            }
+            return true;
+        }
+    };
+    const args = minimist(process.argv.slice(2), options);
+    if (args.help) {
+        showHelp();
+        process.exit();
+    }
+    const browserType = valdiateBrowserType(args.browserType);
+    const extensionTestsPath = await validatePathOrUndefined(args, 'extensionTestsPath', true);
+    const extensionDevelopmentPath = await validatePathOrUndefined(args, 'extensionDevelopmentPath');
+    const extensionPaths = await valdiateExtensionPaths(args.extensionPath);
+    const vsCodeDevPath = await validatePathOrUndefined(args, 'sourcesPath');
+    const quality = validateQuality(args.quality, args.version, vsCodeDevPath);
+    const devTools = validateBooleanOrUndefined(args, 'open-devtools');
+    const headless = validateBooleanOrUndefined(args, 'headless');
+    const permissions = valdiatePermissions(args.permission);
+    const hideServerLog = validateBooleanOrUndefined(args, 'hideServerLog');
+    const verbose = validateBooleanOrUndefined(args, 'verbose');
+    const port = validatePortNumber(args.port);
+    const host = validateStringOrUndefined(args, 'host');
+    const waitForDebugger = validatePortNumber(args.waitForDebugger);
+    let folderUri = validateStringOrUndefined(args, 'folder-uri');
+    let folderPath;
+    const inputs = args._;
+    if (inputs.length) {
+        const input = await validatePath(inputs[0]);
+        if (input) {
+            folderPath = input;
+            if (folderUri) {
+                console.log(`Local folder provided as input, ignoring 'folder-uri'`);
+                folderUri = undefined;
+            }
+        }
+    }
+    if (extensionTestsPath) {
+        runTests({
+            extensionTestsPath,
+            extensionDevelopmentPath,
+            browserType,
+            quality,
+            devTools,
+            waitForDebugger,
+            folderUri,
+            folderPath,
+            headless,
+            hideServerLog,
+            permissions,
+            extensionPaths,
+            vsCodeDevPath,
+            verbose,
+            host,
+            port
+        });
+    }
+    else {
+        open({
+            extensionDevelopmentPath,
+            browserType,
+            quality,
+            devTools,
+            waitForDebugger,
+            folderUri,
+            folderPath,
+            headless,
+            hideServerLog,
+            permissions,
+            extensionPaths,
+            vsCodeDevPath,
+            verbose,
+            host,
+            port
+        });
+    }
+}
+if (require.main === module) {
+    cliMain();
+}