@vscode/test-web 0.0.11 → 0.0.15

package/out/index.js

@@ -18,89 +18,107 @@ const path = require("path");
  * @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
+        folderMountPath: options.folderPath,
+        hideServerLog: true,
+        extensionPaths: options.extensionPaths
     };
     const port = 3000;
-    const server = await 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,
+    const server = await (0, main_1.runServer)(port, config);
+    return new Promise(async (s, e) => {
+        const endpoint = `http://localhost:${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'));
+            }
+        });
     });
-    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 download_1.downloadAndUnzipVSCode(version === 'stable' ? 'stable' : 'insider');
+    return await (0, download_1.downloadAndUnzipVSCode)(version === 'stable' ? 'stable' : 'insider');
 }
 async function open(options) {
-    var _a;
     const config = {
         extensionDevelopmentPath: options.extensionDevelopmentPath,
+        extensionTestsPath: options.extensionTestsPath,
         build: await getBuild(options.version),
         folderUri: options.folderUri,
-        folderMountPath: options.folderPath
+        folderMountPath: options.folderPath,
+        extensionPaths: options.extensionPaths
     };
     const port = 3000;
-    await main_1.runServer(port, config);
+    const server = 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
-    });
+    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;
-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}`);
+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.extensionDevelopmentPath !== 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();
             }
-            s(code === 0);
         });
     });
+    const page = (_b = context.pages()[0]) !== null && _b !== void 0 ? _b : await context.newPage();
+    if (options.waitForDebugger) {
+        await page.waitForFunction(() => '__jsDebugIsReady' in globalThis);
+    }
+    await page.setViewportSize({ width, height });
+    await page.goto(endpoint);
+    return context;
 }
 function validateStringOrUndefined(options, name) {
     const value = options[name];
@@ -125,7 +143,7 @@ function validateBooleanOrUndefined(options, name) {
     process.exit(-1);
 }
 function valdiateBrowserType(browserType) {
-    if (browserType === 'undefined') {
+    if (browserType === undefined) {
         return 'chromium';
     }
     if ((typeof browserType === 'string') && ['chromium', 'firefox', 'webkit'].includes(browserType)) {
@@ -135,16 +153,56 @@ function valdiateBrowserType(browserType) {
     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 download_1.fileExists(loc)) {
+        if (!await (0, download_1.fileExists)(loc)) {
             console.log(`'${loc}' must be an existing file.`);
             process.exit(-1);
         }
     }
     else {
-        if (!await download_1.directoryExists(loc)) {
+        if (!await (0, download_1.directoryExists)(loc)) {
             console.log(`'${loc}' must be an existing folder.`);
             process.exit(-1);
         }
@@ -170,24 +228,49 @@ function validatePortNumber(port) {
 }
 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`);
+    console.log(`  --browserType 'chromium' | 'firefox' | 'webkit': The browser to launch. [Optional, default '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(`  --version 'insiders' | 'stable' | 'sources' [Optional, default 'insiders']`);
+    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(`  --hideServerLog: Whether to hide the server log. 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(`  folderPath. A local folder to open VS Code on. The folder content will be available as a virtual file system. [Optional]`);
 }
 async function cliMain() {
-    const options = { string: ['extensionDevelopmentPath', 'extensionTestsPath', 'browserType', 'version', 'waitForDebugger', 'folder-uri', 'mount'], boolean: ['open-devtools', 'headless'] };
+    // 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', 'version', 'waitForDebugger', 'folder-uri', 'permission', 'extensionPath'],
+        boolean: ['open-devtools', 'headless', 'hideServerLog', 'help'],
+        unknown: arg => {
+            if (arg.startsWith('-')) {
+                console.log(`Unknown argument ${arg}`);
+                showHelp();
+                return false;
+            }
+            return true;
+        }
+    };
     const args = minimist(process.argv.slice(2), options);
+    if (args.help) {
+        showHelp();
+        process.exit();
+    }
     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 extensionPaths = await valdiateExtensionPaths(args.extensionPath);
+    const version = validateVersion(args.version);
     const devTools = validateBooleanOrUndefined(args, 'open-devtools');
-    const port = validatePortNumber(args.waitForDebugger);
+    const headless = validateBooleanOrUndefined(args, 'headless');
+    const permissions = valdiatePermissions(args.permission);
+    const hideServerLog = validateBooleanOrUndefined(args, 'hideServerLog');
+    const waitForDebugger = validatePortNumber(args.waitForDebugger);
     let folderUri = validateStringOrUndefined(args, 'folder-uri');
     let folderPath;
     const inputs = args._;
@@ -197,8 +280,8 @@ async function cliMain() {
             folderPath = input;
             if (folderUri) {
                 console.log(`Local folder provided as input, ignoring 'folder-uri'`);
+                folderUri = undefined;
             }
-            folderUri = `vscode-test-web://mount/`;
         }
     }
     if (extensionTestsPath) {
@@ -208,10 +291,13 @@ async function cliMain() {
             browserType,
             version,
             devTools,
-            waitForDebugger: port,
+            waitForDebugger,
             folderUri,
             folderPath,
-            headless
+            headless,
+            hideServerLog,
+            permissions,
+            extensionPaths
         });
     }
     else {
@@ -220,10 +306,13 @@ async function cliMain() {
             browserType,
             version,
             devTools,
-            waitForDebugger: port,
+            waitForDebugger,
             folderUri,
             folderPath,
-            headless
+            headless,
+            hideServerLog,
+            permissions,
+            extensionPaths
         });
     }
 }

package/out/server/app.js

@@ -13,17 +13,15 @@ const path = require("path");
 const mounts_1 = require("./mounts");
 async function createApp(config) {
     const app = new Koa();
-    app.use(morgan('dev'));
+    if (!config.hideServerLog) {
+        app.use(morgan('dev'));
+    }
     // this is here such that the iframe worker can fetch the extension files
     app.use((ctx, next) => {
         ctx.set('Access-Control-Allow-Origin', '*');
         return next();
     });
     app.use(kmount('/static', kstatic(path.join(__dirname, '../static'))));
-    if (config.extensionPath) {
-        console.log('Serving extensions from ' + config.extensionPath);
-        app.use(kmount('/static/extensions', kstatic(config.extensionPath, { hidden: true })));
-    }
     if (config.extensionDevelopmentPath) {
         console.log('Serving dev extensions from ' + config.extensionDevelopmentPath);
         app.use(kmount('/static/devextensions', kstatic(config.extensionDevelopmentPath, { hidden: true })));
@@ -31,8 +29,14 @@ async function createApp(config) {
     if (config.build.type === 'static') {
         app.use(kmount('/static/build', kstatic(config.build.location, { hidden: true })));
     }
-    mounts_1.configureMounts(config, app);
-    app.use(workbench_1.default(config));
+    (0, mounts_1.configureMounts)(config, app);
+    if (config.extensionPaths) {
+        config.extensionPaths.forEach((extensionPath, index) => {
+            console.log('Serving additional built-in extensions from ' + extensionPath);
+            app.use(kmount(`/static/extensions/${index}`, kstatic(extensionPath, { hidden: true })));
+        });
+    }
+    app.use((0, workbench_1.default)(config));
     return app;
 }
 exports.default = createApp;

package/out/server/download.js

@@ -29,7 +29,7 @@ async function download(downloadUrl, destination, message) {
             const total = Number(res.headers['content-length']);
             let received = 0;
             let timeout;
-            const outStream = fs_1.createWriteStream(destination);
+            const outStream = (0, fs_1.createWriteStream)(destination);
             outStream.on('close', () => resolve(destination));
             outStream.on('error', reject);
             res.on('data', chunk => {
@@ -54,7 +54,7 @@ async function download(downloadUrl, destination, message) {
 }
 async function unzip(source, destination, message) {
     process.stdout.write(message);
-    if (!fs_1.existsSync(destination)) {
+    if (!(0, fs_1.existsSync)(destination)) {
         await fs_1.promises.mkdir(destination, { recursive: true });
     }
     await decompress(source, destination, {
@@ -69,10 +69,10 @@ async function downloadAndUnzipVSCode(quality) {
     const info = await getLatestVersion(quality);
     const folderName = `vscode-web-${quality}-${info.version}`;
     const downloadedPath = path.resolve(vscodeTestDir, folderName);
-    if (fs_1.existsSync(downloadedPath) && fs_1.existsSync(path.join(downloadedPath, 'version'))) {
-        return { type: 'static', location: downloadedPath };
+    if ((0, fs_1.existsSync)(downloadedPath) && (0, fs_1.existsSync)(path.join(downloadedPath, 'version'))) {
+        return { type: 'static', location: downloadedPath, quality, version: info.version };
     }
-    if (fs_1.existsSync(vscodeTestDir)) {
+    if ((0, fs_1.existsSync)(vscodeTestDir)) {
         await fs_1.promises.rmdir(vscodeTestDir, { recursive: true, maxRetries: 5 });
     }
     await fs_1.promises.mkdir(vscodeTestDir, { recursive: true });
@@ -95,7 +95,7 @@ async function downloadAndUnzipVSCode(quality) {
             // ignore
         }
     }
-    return { type: 'static', location: downloadedPath };
+    return { type: 'static', location: downloadedPath, quality, version: info.version };
 }
 exports.downloadAndUnzipVSCode = downloadAndUnzipVSCode;
 async function fetch(api) {

package/out/server/main.js

@@ -7,7 +7,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.runServer = void 0;
 const app_1 = require("./app");
 async function runServer(port, config) {
-    const app = await app_1.default(config);
+    const app = await (0, app_1.default)(config);
     const server = app.listen(port);
     console.log(`Listening on http://localhost:${port}`);
     return server;

package/out/server/mounts.js

@@ -4,14 +4,15 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.configureMounts = exports.fsProviderExtensionPrefix = void 0;
+exports.configureMounts = exports.fsProviderFolderUri = exports.fsProviderExtensionPrefix = void 0;
 const kstatic = require("koa-static");
 const kmount = require("koa-mount");
 const Router = require("@koa/router");
 const fs_1 = require("fs");
 const path = require("path");
 const mountPrefix = '/static/mount';
-exports.fsProviderExtensionPrefix = '/static/fsproviderextension';
+exports.fsProviderExtensionPrefix = '/static/extensions/fs';
+exports.fsProviderFolderUri = 'vscode-test-web://mount/';
 function configureMounts(config, app) {
     const folderMountPath = config.folderMountPath;
     if (folderMountPath) {

package/out/server/workbench.js

@@ -44,7 +44,7 @@ class Workbench {
                 + `<script src="${this.baseUrl}/out/vs/code/browser/workbench/workbench.js"></script>`;
     }
     async renderCallback() {
-        return await download_1.fetch(`${this.baseUrl}/out/vs/code/browser/workbench/callback.html`);
+        return await (0, download_1.fetch)(`${this.baseUrl}/out/vs/code/browser/workbench/callback.html`);
     }
 }
 function valueOrFirst(value) {
@@ -52,16 +52,18 @@ function valueOrFirst(value) {
 }
 async function getWorkbenchOptions(ctx, config) {
     const options = {};
-    if (config.extensionPath) {
-        options.additionalBuiltinExtensions = await extensions_1.scanForExtensions(config.extensionPath, {
-            scheme: ctx.protocol,
-            authority: ctx.host,
-            path: '/static/extensions',
-        });
+    if (config.extensionPaths) {
+        await Promise.all(config.extensionPaths.map(async (extensionPath, index) => {
+            options.additionalBuiltinExtensions = await (0, extensions_1.scanForExtensions)(extensionPath, {
+                scheme: ctx.protocol,
+                authority: ctx.host,
+                path: `/static/extensions/${index}`,
+            });
+        }));
     }
     if (config.extensionDevelopmentPath) {
         const developmentOptions = options.developmentOptions = {};
-        developmentOptions.extensions = await extensions_1.scanForExtensions(config.extensionDevelopmentPath, { scheme: ctx.protocol, authority: ctx.host, path: '/static/devextensions' });
+        developmentOptions.extensions = await (0, extensions_1.scanForExtensions)(config.extensionDevelopmentPath, { scheme: ctx.protocol, authority: ctx.host, path: '/static/devextensions' });
         if (config.extensionTestsPath) {
             let relativePath = path.relative(config.extensionDevelopmentPath, config.extensionTestsPath);
             if (process.platform === 'win32') {
@@ -74,14 +76,15 @@ async function getWorkbenchOptions(ctx, config) {
             };
         }
     }
-    if (config.folderUri) {
-        options.folderUri = vscode_uri_1.URI.parse(config.folderUri);
-    }
     if (config.folderMountPath) {
         if (!options.additionalBuiltinExtensions) {
             options.additionalBuiltinExtensions = [];
         }
         options.additionalBuiltinExtensions.push({ scheme: ctx.protocol, authority: ctx.host, path: mounts_1.fsProviderExtensionPrefix });
+        options.folderUri = vscode_uri_1.URI.parse(mounts_1.fsProviderFolderUri);
+    }
+    else if (config.folderUri) {
+        options.folderUri = vscode_uri_1.URI.parse(config.folderUri);
     }
     return options;
 }
@@ -90,7 +93,7 @@ function default_1(config) {
     router.use(async (ctx, next) => {
         if (ctx.query['dev'] || config.build.type === 'sources') {
             try {
-                const builtInExtensions = await download_1.fetchJSON('http://localhost:8080/builtin');
+                const builtInExtensions = await (0, download_1.fetchJSON)('http://localhost:8080/builtin');
                 ctx.state.workbench = new Workbench('http://localhost:8080/static', true, builtInExtensions);
             }
             catch (err) {

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@vscode/test-web",
-  "version": "0.0.11",
+  "version": "0.0.15",
   "scripts": {
-    "init": "yarn --cwd=fs-provider && yarn --cwd=sample",
+    "install-extensions": "yarn --cwd=fs-provider && yarn --cwd=sample",
     "compile": "tsc -p ./ && yarn compile-fs-provider",
     "watch": "tsc -w -p ./",
     "prepublishOnly": "yarn compile",
@@ -22,13 +22,13 @@
     "node": ">=8.9.3"
   },
   "dependencies": {
-    "@koa/router": "^10.0.0",
+    "@koa/router": "^10.1.1",
     "koa": "^2.13.1",
     "koa-morgan": "^1.0.1",
     "koa-mount": "^4.0.0",
     "koa-static": "^5.0.0",
     "minimist": "^1.2.5",
-    "playwright": "^1.12.2",
+    "playwright": "1.14.1",
     "vscode-uri": "^3.0.2",
     "http-proxy-agent": "^4.0.1",
     "https-proxy-agent": "^5.0.0",
@@ -36,19 +36,19 @@
     "decompress-targz": "^4.1.1"
   },
   "devDependencies": {
-    "@types/koa": "^2.13.1",
-    "@types/koa-morgan": "^1.0.4",
-    "@types/koa-mount": "^4.0.0",
-    "@types/koa-static": "^4.0.1",
-    "@types/koa__router": "^8.0.4",
-    "@types/minimist": "^1.2.1",
+    "@types/koa": "^2.13.4",
+    "@types/koa-morgan": "^1.0.5",
+    "@types/koa-mount": "^4.0.1",
+    "@types/koa-static": "^4.0.2",
+    "@types/koa__router": "^8.0.8",
+    "@types/minimist": "^1.2.2",
     "@types/node": "^12.19.9",
-    "@typescript-eslint/eslint-plugin": "^4.13.0",
-    "@typescript-eslint/parser": "^4.13.0",
-    "@types/decompress": "^4.2.3",
-    "eslint": "^7.17.0",
-    "eslint-plugin-header": "^3.1.0",
-    "typescript": "^4.1.3"
+    "@typescript-eslint/eslint-plugin": "^4.31.1",
+    "@typescript-eslint/parser": "^4.31.1",
+    "@types/decompress": "^4.2.4",
+    "eslint": "^7.32.0",
+    "eslint-plugin-header": "^3.1.1",
+    "typescript": "^4.4.3"
   },
   "license": "MIT",
   "author": "Visual Studio Code Team",