Merge commit 'be3e8236086165e5e45a5a10783823874b3f3ebd' as 'lib/vscode'

lib/vscode/extensions/vscode-notebook-tests/src/customRenderer.js

@@ -0,0 +1,21 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+const vscode = acquireVsCodeApi();
+
+vscode.postMessage({
+	type: 'custom_renderer_initialize',
+	payload: {
+		firstMessage: true
+	}
+});
+
+const notebook = acquireNotebookRendererApi('notebookCoreTestRenderer');
+
+notebook.onDidCreateOutput(({ element, mimeType }) => {
+	const div = document.createElement('div');
+	div.innerText = `Hello ${mimeType}!`;
+	element.appendChild(div);
+});

lib/vscode/extensions/vscode-notebook-tests/src/index.ts

@@ -0,0 +1,40 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+const path = require('path');
+const testRunner = require('vscode/lib/testrunner');
+
+const options: any = {
+	ui: 'tdd',
+	useColors: (!process.env.BUILD_ARTIFACTSTAGINGDIRECTORY && process.platform !== 'win32'),
+	timeout: 60000
+};
+
+// These integration tests is being run in multiple environments (electron, web, remote)
+// so we need to set the suite name based on the environment as the suite name is used
+// for the test results file name
+let suite = '';
+if (process.env.VSCODE_BROWSER) {
+	suite = `${process.env.VSCODE_BROWSER} Browser Integration Notebook Tests`;
+} else if (process.env.REMOTE_VSCODE) {
+	suite = 'Remote Integration Notebook Tests';
+} else {
+	suite = 'Integration Notebook Tests';
+}
+
+if (process.env.BUILD_ARTIFACTSTAGINGDIRECTORY) {
+	options.reporter = 'mocha-multi-reporters';
+	options.reporterOptions = {
+		reporterEnabled: 'spec, mocha-junit-reporter',
+		mochaJunitReporterReporterOptions: {
+			testsuitesTitle: `${suite} ${process.platform}`,
+			mochaFile: path.join(process.env.BUILD_ARTIFACTSTAGINGDIRECTORY, `test-results/${process.platform}-${process.arch}-${suite.toLowerCase().replace(/[^\w]/g, '-')}-results.xml`)
+		}
+	};
+}
+
+testRunner.configure(options);
+
+export = testRunner;

lib/vscode/extensions/vscode-notebook-tests/src/notebookSmokeTestMain.ts

@@ -0,0 +1,116 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as vscode from 'vscode';
+import * as child_process from 'child_process';
+import * as path from 'path';
+
+function wait(ms: number): Promise<void> {
+	return new Promise(r => setTimeout(r, ms));
+}
+
+export function smokeTestActivate(context: vscode.ExtensionContext): any {
+	context.subscriptions.push(vscode.commands.registerCommand('vscode-notebook-tests.createNewNotebook', async () => {
+		const workspacePath = vscode.workspace.workspaceFolders![0].uri.fsPath;
+		const notebookPath = path.join(workspacePath, 'test.smoke-nb');
+		child_process.execSync('echo \'\' > ' + notebookPath);
+		await wait(500);
+		await vscode.commands.executeCommand('vscode.open', vscode.Uri.file(notebookPath));
+	}));
+
+	context.subscriptions.push(vscode.notebook.registerNotebookContentProvider('notebookSmokeTest', {
+		onDidChangeNotebook: new vscode.EventEmitter<vscode.NotebookDocumentEditEvent>().event,
+		openNotebook: async (_resource: vscode.Uri) => {
+			const dto: vscode.NotebookData = {
+				languages: ['typescript'],
+				metadata: {},
+				cells: [
+					{
+						source: 'code()',
+						language: 'typescript',
+						cellKind: vscode.CellKind.Code,
+						outputs: [],
+						metadata: {
+							custom: { testCellMetadata: 123 }
+						}
+					},
+					{
+						source: 'Markdown Cell',
+						language: 'markdown',
+						cellKind: vscode.CellKind.Markdown,
+						outputs: [],
+						metadata: {
+							custom: { testCellMetadata: 123 }
+						}
+					}
+				]
+			};
+
+			return dto;
+		},
+		resolveNotebook: async (_document: vscode.NotebookDocument) => {
+			return;
+		},
+		saveNotebook: async (_document: vscode.NotebookDocument, _cancellation: vscode.CancellationToken) => {
+			return;
+		},
+		saveNotebookAs: async (_targetResource: vscode.Uri, _document: vscode.NotebookDocument, _cancellation: vscode.CancellationToken) => {
+			return;
+		},
+		backupNotebook: async (_document: vscode.NotebookDocument, _context: vscode.NotebookDocumentBackupContext, _cancellation: vscode.CancellationToken) => {
+			return {
+				id: '1',
+				delete: () => { }
+			};
+		}
+	}));
+
+	const kernel: vscode.NotebookKernel = {
+		label: 'notebookSmokeTest',
+		isPreferred: true,
+		executeAllCells: async (_document: vscode.NotebookDocument) => {
+			for (let i = 0; i < _document.cells.length; i++) {
+				_document.cells[i].outputs = [{
+					outputKind: vscode.CellOutputKind.Rich,
+					data: {
+						'text/html': ['test output']
+					}
+				}];
+			}
+		},
+		cancelAllCellsExecution: async () => { },
+		executeCell: async (_document: vscode.NotebookDocument, _cell: vscode.NotebookCell | undefined) => {
+			if (!_cell) {
+				_cell = _document.cells[0];
+			}
+
+			_cell.outputs = [{
+				outputKind: vscode.CellOutputKind.Rich,
+				data: {
+					'text/html': ['test output']
+				}
+			}];
+			return;
+		},
+		cancelCellExecution: async () => { }
+	};
+
+	context.subscriptions.push(vscode.notebook.registerNotebookKernelProvider({ filenamePattern: '*.smoke-nb' }, {
+		provideKernels: async () => {
+			return [kernel];
+		}
+	}));
+
+	context.subscriptions.push(vscode.commands.registerCommand('vscode-notebook-tests.debugAction', async (cell: vscode.NotebookCell) => {
+		if (cell) {
+			const edit = new vscode.WorkspaceEdit();
+			const fullRange = new vscode.Range(0, 0, cell.document.lineCount - 1, cell.document.lineAt(cell.document.lineCount - 1).range.end.character);
+			edit.replace(cell.document.uri, fullRange, 'test');
+			await vscode.workspace.applyEdit(edit);
+		} else {
+			throw new Error('Cell not set correctly');
+		}
+	}));
+}

lib/vscode/extensions/vscode-notebook-tests/src/notebookTestMain.ts

@@ -0,0 +1,126 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as vscode from 'vscode';
+import { smokeTestActivate } from './notebookSmokeTestMain';
+
+export function activate(context: vscode.ExtensionContext): any {
+	smokeTestActivate(context);
+
+	const _onDidChangeNotebook = new vscode.EventEmitter<vscode.NotebookDocumentEditEvent | vscode.NotebookDocumentContentChangeEvent>();
+	context.subscriptions.push(_onDidChangeNotebook);
+	context.subscriptions.push(vscode.notebook.registerNotebookContentProvider('notebookCoreTest', {
+		onDidChangeNotebook: _onDidChangeNotebook.event,
+		openNotebook: async (_resource: vscode.Uri) => {
+			if (/.*empty\-.*\.vsctestnb$/.test(_resource.path)) {
+				return {
+					languages: ['typescript'],
+					metadata: {},
+					cells: []
+				};
+			}
+
+			const dto: vscode.NotebookData = {
+				languages: ['typescript'],
+				metadata: {
+					custom: { testMetadata: false }
+				},
+				cells: [
+					{
+						source: 'test',
+						language: 'typescript',
+						cellKind: vscode.CellKind.Code,
+						outputs: [],
+						metadata: {
+							custom: { testCellMetadata: 123 }
+						}
+					}
+				]
+			};
+
+			return dto;
+		},
+		resolveNotebook: async (_document: vscode.NotebookDocument) => {
+			return;
+		},
+		saveNotebook: async (_document: vscode.NotebookDocument, _cancellation: vscode.CancellationToken) => {
+			return;
+		},
+		saveNotebookAs: async (_targetResource: vscode.Uri, _document: vscode.NotebookDocument, _cancellation: vscode.CancellationToken) => {
+			return;
+		},
+		backupNotebook: async (_document: vscode.NotebookDocument, _context: vscode.NotebookDocumentBackupContext, _cancellation: vscode.CancellationToken) => {
+			return {
+				id: '1',
+				delete: () => { }
+			};
+		}
+	}));
+
+	const kernel: vscode.NotebookKernel = {
+		label: 'Notebook Test Kernel',
+		isPreferred: true,
+		executeAllCells: async (_document: vscode.NotebookDocument) => {
+			const cell = _document.cells[0];
+
+			cell.outputs = [{
+				outputKind: vscode.CellOutputKind.Rich,
+				data: {
+					'text/plain': ['my output']
+				}
+			}];
+			return;
+		},
+		cancelAllCellsExecution: async (_document: vscode.NotebookDocument) => { },
+		executeCell: async (document: vscode.NotebookDocument, cell: vscode.NotebookCell | undefined) => {
+			if (!cell) {
+				cell = document.cells[0];
+			}
+
+			if (document.uri.path.endsWith('customRenderer.vsctestnb')) {
+				cell.outputs = [{
+					outputKind: vscode.CellOutputKind.Rich,
+					data: {
+						'text/custom': 'test'
+					}
+				}];
+
+				return;
+			}
+
+			const previousOutputs = cell.outputs;
+			const newOutputs: vscode.CellOutput[] = [{
+				outputKind: vscode.CellOutputKind.Rich,
+				data: {
+					'text/plain': ['my output']
+				}
+			}];
+
+			cell.outputs = newOutputs;
+
+			_onDidChangeNotebook.fire({
+				document: document,
+				undo: () => {
+					if (cell) {
+						cell.outputs = previousOutputs;
+					}
+				},
+				redo: () => {
+					if (cell) {
+						cell.outputs = newOutputs;
+					}
+				}
+			});
+			return;
+		},
+		cancelCellExecution: async (_document: vscode.NotebookDocument, _cell: vscode.NotebookCell) => { }
+	};
+
+	context.subscriptions.push(vscode.notebook.registerNotebookKernelProvider({ filenamePattern: '*.vsctestnb' }, {
+		provideKernels: async () => {
+			return [kernel];
+		}
+	}));
+}

lib/vscode/extensions/vscode-notebook-tests/src/typings/ref.d.ts

@@ -0,0 +1,9 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+/// <reference path="../../../../src/vs/vscode.d.ts" />
+/// <reference path="../../../../src/vs/vscode.proposed.d.ts" />
+/// <reference types='@types/node'/>
+

lib/vscode/extensions/vscode-notebook-tests/src/utils.ts

@@ -0,0 +1,261 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+
+import * as path from 'path';
+import * as vscode from 'vscode';
+
+class File implements vscode.FileStat {
+
+	type: vscode.FileType;
+	ctime: number;
+	mtime: number;
+	size: number;
+
+	name: string;
+	data?: Uint8Array;
+
+	constructor(name: string) {
+		this.type = vscode.FileType.File;
+		this.ctime = Date.now();
+		this.mtime = Date.now();
+		this.size = 0;
+		this.name = name;
+	}
+}
+
+class Directory implements vscode.FileStat {
+
+	type: vscode.FileType;
+	ctime: number;
+	mtime: number;
+	size: number;
+
+	name: string;
+	entries: Map<string, File | Directory>;
+
+	constructor(name: string) {
+		this.type = vscode.FileType.Directory;
+		this.ctime = Date.now();
+		this.mtime = Date.now();
+		this.size = 0;
+		this.name = name;
+		this.entries = new Map();
+	}
+}
+
+export type Entry = File | Directory;
+
+export class TestFS implements vscode.FileSystemProvider {
+
+	constructor(
+		readonly scheme: string,
+		readonly isCaseSensitive: boolean
+	) { }
+
+	readonly root = new Directory('');
+
+	// --- manage file metadata
+
+	stat(uri: vscode.Uri): vscode.FileStat {
+		return this._lookup(uri, false);
+	}
+
+	readDirectory(uri: vscode.Uri): [string, vscode.FileType][] {
+		const entry = this._lookupAsDirectory(uri, false);
+		const result: [string, vscode.FileType][] = [];
+		for (const [name, child] of entry.entries) {
+			result.push([name, child.type]);
+		}
+		return result;
+	}
+
+	// --- manage file contents
+
+	readFile(uri: vscode.Uri): Uint8Array {
+		const data = this._lookupAsFile(uri, false).data;
+		if (data) {
+			return data;
+		}
+		throw vscode.FileSystemError.FileNotFound();
+	}
+
+	writeFile(uri: vscode.Uri, content: Uint8Array, options: { create: boolean, overwrite: boolean }): void {
+		const basename = path.posix.basename(uri.path);
+		const parent = this._lookupParentDirectory(uri);
+		let entry = parent.entries.get(basename);
+		if (entry instanceof Directory) {
+			throw vscode.FileSystemError.FileIsADirectory(uri);
+		}
+		if (!entry && !options.create) {
+			throw vscode.FileSystemError.FileNotFound(uri);
+		}
+		if (entry && options.create && !options.overwrite) {
+			throw vscode.FileSystemError.FileExists(uri);
+		}
+		if (!entry) {
+			entry = new File(basename);
+			parent.entries.set(basename, entry);
+			this._fireSoon({ type: vscode.FileChangeType.Created, uri });
+		}
+		entry.mtime = Date.now();
+		entry.size = content.byteLength;
+		entry.data = content;
+
+		this._fireSoon({ type: vscode.FileChangeType.Changed, uri });
+	}
+
+	// --- manage files/folders
+
+	rename(oldUri: vscode.Uri, newUri: vscode.Uri, options: { overwrite: boolean }): void {
+
+		if (!options.overwrite && this._lookup(newUri, true)) {
+			throw vscode.FileSystemError.FileExists(newUri);
+		}
+
+		const entry = this._lookup(oldUri, false);
+		const oldParent = this._lookupParentDirectory(oldUri);
+
+		const newParent = this._lookupParentDirectory(newUri);
+		const newName = path.posix.basename(newUri.path);
+
+		oldParent.entries.delete(entry.name);
+		entry.name = newName;
+		newParent.entries.set(newName, entry);
+
+		this._fireSoon(
+			{ type: vscode.FileChangeType.Deleted, uri: oldUri },
+			{ type: vscode.FileChangeType.Created, uri: newUri }
+		);
+	}
+
+	delete(uri: vscode.Uri): void {
+		const dirname = uri.with({ path: path.posix.dirname(uri.path) });
+		const basename = path.posix.basename(uri.path);
+		const parent = this._lookupAsDirectory(dirname, false);
+		if (!parent.entries.has(basename)) {
+			throw vscode.FileSystemError.FileNotFound(uri);
+		}
+		parent.entries.delete(basename);
+		parent.mtime = Date.now();
+		parent.size -= 1;
+		this._fireSoon({ type: vscode.FileChangeType.Changed, uri: dirname }, { uri, type: vscode.FileChangeType.Deleted });
+	}
+
+	createDirectory(uri: vscode.Uri): void {
+		const basename = path.posix.basename(uri.path);
+		const dirname = uri.with({ path: path.posix.dirname(uri.path) });
+		const parent = this._lookupAsDirectory(dirname, false);
+
+		const entry = new Directory(basename);
+		parent.entries.set(entry.name, entry);
+		parent.mtime = Date.now();
+		parent.size += 1;
+		this._fireSoon({ type: vscode.FileChangeType.Changed, uri: dirname }, { type: vscode.FileChangeType.Created, uri });
+	}
+
+	// --- lookup
+
+	private _lookup(uri: vscode.Uri, silent: false): Entry;
+	private _lookup(uri: vscode.Uri, silent: boolean): Entry | undefined;
+	private _lookup(uri: vscode.Uri, silent: boolean): Entry | undefined {
+		const parts = uri.path.split('/');
+		let entry: Entry = this.root;
+		for (const part of parts) {
+			const partLow = part.toLowerCase();
+			if (!part) {
+				continue;
+			}
+			let child: Entry | undefined;
+			if (entry instanceof Directory) {
+				if (this.isCaseSensitive) {
+					child = entry.entries.get(part);
+				} else {
+					for (const [key, value] of entry.entries) {
+						if (key.toLowerCase() === partLow) {
+							child = value;
+							break;
+						}
+					}
+				}
+			}
+			if (!child) {
+				if (!silent) {
+					throw vscode.FileSystemError.FileNotFound(uri);
+				} else {
+					return undefined;
+				}
+			}
+			entry = child;
+		}
+		return entry;
+	}
+
+	private _lookupAsDirectory(uri: vscode.Uri, silent: boolean): Directory {
+		const entry = this._lookup(uri, silent);
+		if (entry instanceof Directory) {
+			return entry;
+		}
+		throw vscode.FileSystemError.FileNotADirectory(uri);
+	}
+
+	private _lookupAsFile(uri: vscode.Uri, silent: boolean): File {
+		const entry = this._lookup(uri, silent);
+		if (entry instanceof File) {
+			return entry;
+		}
+		throw vscode.FileSystemError.FileIsADirectory(uri);
+	}
+
+	private _lookupParentDirectory(uri: vscode.Uri): Directory {
+		const dirname = uri.with({ path: path.posix.dirname(uri.path) });
+		return this._lookupAsDirectory(dirname, false);
+	}
+
+	// --- manage file events
+
+	private _emitter = new vscode.EventEmitter<vscode.FileChangeEvent[]>();
+	private _bufferedEvents: vscode.FileChangeEvent[] = [];
+	private _fireSoonHandle?: NodeJS.Timer;
+
+	readonly onDidChangeFile: vscode.Event<vscode.FileChangeEvent[]> = this._emitter.event;
+
+	watch(_resource: vscode.Uri): vscode.Disposable {
+		// ignore, fires for all changes...
+		return new vscode.Disposable(() => { });
+	}
+
+	private _fireSoon(...events: vscode.FileChangeEvent[]): void {
+		this._bufferedEvents.push(...events);
+
+		if (this._fireSoonHandle) {
+			clearTimeout(this._fireSoonHandle);
+		}
+
+		this._fireSoonHandle = setTimeout(() => {
+			this._emitter.fire(this._bufferedEvents);
+			this._bufferedEvents.length = 0;
+		}, 5);
+	}
+}
+
+export function rndName() {
+	return Math.random().toString(36).replace(/[^a-z]+/g, '').substr(0, 10);
+}
+
+export const testFs = new TestFS('fake-fs', true);
+vscode.workspace.registerFileSystemProvider(testFs.scheme, testFs, { isCaseSensitive: testFs.isCaseSensitive });
+
+export async function createRandomFile(contents = '', dir: vscode.Uri | undefined = undefined, prefix = '', ext = ''): Promise<vscode.Uri> {
+	let fakeFile: vscode.Uri;
+	if (dir) {
+		fakeFile = dir.with({ path: dir.path + '/' + rndName() + ext });
+	} else {
+		fakeFile = vscode.Uri.parse(`${testFs.scheme}:/${prefix}-${rndName() + ext}`);
+	}
+
+	await testFs.writeFile(fakeFile, Buffer.from(contents), { create: true, overwrite: true });
+	return fakeFile;
+}