Merge from vscode 79a1f5a5ca0c6c53db617aa1fa5a2396d2caebe2

test/automation/src/code.ts

@@ -148,11 +148,7 @@ export async function spawn(options: SpawnOptions): Promise<Code> {
 
 		if (codePath) {
 			// running against a build: copy the test resolver extension
-			const testResolverExtPath = path.join(options.extensionsPath, 'vscode-test-resolver');
-			if (!fs.existsSync(testResolverExtPath)) {
-				const orig = path.join(repoPath, 'extensions', 'vscode-test-resolver');
-				await new Promise((c, e) => ncp(orig, testResolverExtPath, err => err ? e(err) : c()));
-			}
+			copyExtension(options, 'vscode-test-resolver');
 		}
 		args.push('--enable-proposed-api=vscode.vscode-test-resolver');
 		const remoteDataDir = `${options.userDataDir}-server`;
@@ -160,6 +156,9 @@ export async function spawn(options: SpawnOptions): Promise<Code> {
 		env['TESTRESOLVER_DATA_FOLDER'] = remoteDataDir;
 	}
 
+	copyExtension(options, 'vscode-notebook-tests');
+	args.push('--enable-proposed-api=vscode.vscode-notebook-tests');
+
 	if (!codePath) {
 		args.unshift(repoPath);
 	}
@@ -185,6 +184,14 @@ export async function spawn(options: SpawnOptions): Promise<Code> {
 	return connect(connectDriver, child, outPath, handle, options.logger);
 }
 
+async function copyExtension(options: SpawnOptions, extId: string): Promise<void> {
+	const testResolverExtPath = path.join(options.extensionsPath, extId);
+	if (!fs.existsSync(testResolverExtPath)) {
+		const orig = path.join(repoPath, 'extensions', extId);
+		await new Promise((c, e) => ncp(orig, testResolverExtPath, err => err ? e(err) : c()));
+	}
+}
+
 async function poll<T>(
 	fn: () => Thenable<T>,
 	acceptFn: (result: T) => boolean,

test/automation/src/notebook.ts

@@ -0,0 +1,92 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { Code } from './code';
+import { QuickAccess } from './quickaccess';
+
+const activeRowSelector = `.notebook-editor .monaco-list-row.focused`;
+
+export class Notebook {
+
+	constructor(
+		private readonly quickAccess: QuickAccess,
+		private readonly code: Code) {
+	}
+
+	async openNotebook() {
+		await this.quickAccess.runCommand('vscode-notebook-tests.createNewNotebook');
+		await this.code.waitForElement(activeRowSelector);
+		await this.focusFirstCell();
+		await this.waitForActiveCellEditorContents('code()');
+	}
+
+	async focusNextCell() {
+		await this.code.dispatchKeybinding('down');
+	}
+
+	async focusFirstCell() {
+		await this.quickAccess.runCommand('notebook.focusTop');
+	}
+
+	async editCell() {
+		await this.code.dispatchKeybinding('enter');
+	}
+
+	async stopEditingCell() {
+		await this.code.dispatchKeybinding('esc');
+	}
+
+	async waitForTypeInEditor(text: string): Promise<any> {
+		const editor = `${activeRowSelector} .monaco-editor`;
+
+		await this.code.waitForElement(editor);
+
+		const textarea = `${editor} textarea`;
+		await this.code.waitForActiveElement(textarea);
+
+		await this.code.waitForTypeInEditor(textarea, text);
+
+		await this._waitForActiveCellEditorContents(c => c.indexOf(text) > -1);
+	}
+
+	async waitForActiveCellEditorContents(contents: string): Promise<any> {
+		return this._waitForActiveCellEditorContents(str => str === contents);
+	}
+
+	private async _waitForActiveCellEditorContents(accept: (contents: string) => boolean): Promise<any> {
+		const selector = `${activeRowSelector} .monaco-editor .view-lines`;
+		return this.code.waitForTextContent(selector, undefined, c => accept(c.replace(/\u00a0/g, ' ')));
+	}
+
+	async waitForMarkdownContents(markdownSelector: string, text: string): Promise<void> {
+		const selector = `${activeRowSelector} .markdown ${markdownSelector}`;
+		await this.code.waitForTextContent(selector, text);
+	}
+
+	async insertNotebookCell(kind: 'markdown' | 'code'): Promise<void> {
+		if (kind === 'markdown') {
+			await this.quickAccess.runCommand('notebook.cell.insertMarkdownCellBelow');
+		} else {
+			await this.quickAccess.runCommand('notebook.cell.insertCodeCellBelow');
+		}
+	}
+
+	async deleteActiveCell(): Promise<void> {
+		await this.quickAccess.runCommand('notebook.cell.delete');
+	}
+
+	async focusInCellOutput(): Promise<void> {
+		await this.quickAccess.runCommand('notebook.cell.focusInOutput');
+		await this.code.waitForActiveElement('webview, .webview');
+	}
+
+	async focusOutCellOutput(): Promise<void> {
+		await this.quickAccess.runCommand('notebook.cell.focusOutOutput');
+	}
+
+	async executeActiveCell(): Promise<void> {
+		await this.quickAccess.runCommand('notebook.cell.execute');
+	}
+}

test/automation/src/playwrightDriver.ts

@@ -25,7 +25,8 @@ const vscodeToPlaywrightKey: { [key: string]: string } = {
 	up: 'ArrowUp',
 	down: 'ArrowDown',
 	left: 'ArrowLeft',
-	home: 'Home'
+	home: 'Home',
+	esc: 'Escape'
 };
 
 function buildDriver(browser: playwright.Browser, page: playwright.Page): IDriver {
@@ -86,8 +87,6 @@ function timeout(ms: number): Promise<void> {
 	return new Promise<void>(r => setTimeout(r, ms));
 }
 
-// function runInDriver(call: string, args: (string | boolean)[]): Promise<any> {}
-
 let server: ChildProcess | undefined;
 let endpoint: string | undefined;
 let workspacePath: string | undefined;
@@ -105,8 +104,10 @@ export async function launch(userDataDir: string, _workspacePath: string, extens
 	let serverLocation: string | undefined;
 	if (codeServerPath) {
 		serverLocation = join(codeServerPath, `server.${process.platform === 'win32' ? 'cmd' : 'sh'}`);
+		console.log(`Starting built server from '${serverLocation}'`);
 	} else {
 		serverLocation = join(__dirname, '..', '..', '..', `resources/server/web.${process.platform === 'win32' ? 'bat' : 'sh'}`);
+		console.log(`Starting server out of sources from '${serverLocation}'`);
 	}
 	server = spawn(
 		serverLocation,

test/automation/src/workbench.ts

@@ -19,6 +19,7 @@ import { KeybindingsEditor } from './keybindings';
 import { Editors } from './editors';
 import { Code } from './code';
 import { Terminal } from './terminal';
+import { Notebook } from './notebook';
 
 // {{SQL CARBON EDIT}}
 import { ConnectionDialog } from './sql/connectionDialog';
@@ -48,6 +49,7 @@ export class Workbench {
 	readonly settingsEditor: SettingsEditor;
 	readonly keybindingsEditor: KeybindingsEditor;
 	readonly terminal: Terminal;
+	readonly notebook: Notebook;
 
 	// {{SQL CARBON EDIT}}
 	readonly connectionDialog: ConnectionDialog;
@@ -78,5 +80,6 @@ export class Workbench {
 		this.queryEditors = new QueryEditors(code);
 		this.queryEditor = new QueryEditor(code);
 		// {{END}}
+		this.notebook = new Notebook(this.quickaccess, code);
 	}
 }

test/integration/browser/src/index.ts

@@ -95,10 +95,13 @@ async function launchServer(): Promise<{ endpoint: url.UrlWithStringQuery, serve
 	let serverLocation: string;
 	if (process.env.VSCODE_REMOTE_SERVER_PATH) {
 		serverLocation = path.join(process.env.VSCODE_REMOTE_SERVER_PATH, `server.${process.platform === 'win32' ? 'cmd' : 'sh'}`);
+
+		console.log(`Starting built server from '${serverLocation}'`);
 	} else {
 		serverLocation = path.join(__dirname, '..', '..', '..', '..', `resources/server/web.${process.platform === 'win32' ? 'bat' : 'sh'}`);
-
 		process.env.VSCODE_DEV = '1';
+
+		console.log(`Starting server out of sources from '${serverLocation}'`);
 	}
 
 	let serverProcess = cp.spawn(

test/smoke/src/areas/notebook/notebook.test.ts

@@ -0,0 +1,66 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as cp from 'child_process';
+import { Application } from '../../../../automation';
+
+// function wait(ms: number): Promise<void> {
+// 	return new Promise(r => setTimeout(r, ms));
+// }
+
+
+export function setup() {
+	describe('Notebooks', () => {
+		after(async function () {
+			const app = this.app as Application;
+			cp.execSync('git checkout . --quiet', { cwd: app.workspacePathOrFolder });
+			cp.execSync('git reset --hard origin/master --quiet', { cwd: app.workspacePathOrFolder });
+		});
+
+		afterEach(async function () {
+			const app = this.app as Application;
+			await app.workbench.quickaccess.runCommand('workbench.action.files.save');
+			await app.workbench.quickaccess.runCommand('workbench.action.closeActiveEditor');
+		});
+
+		it('inserts/edits code cell', async function () {
+			const app = this.app as Application;
+			await app.workbench.notebook.openNotebook();
+			await app.workbench.notebook.focusNextCell();
+			await app.workbench.notebook.insertNotebookCell('code');
+			await app.workbench.notebook.waitForTypeInEditor('// some code');
+			await app.workbench.notebook.stopEditingCell();
+		});
+
+		it('inserts/edits markdown cell', async function () {
+			const app = this.app as Application;
+			await app.workbench.notebook.openNotebook();
+			await app.workbench.notebook.focusNextCell();
+			await app.workbench.notebook.insertNotebookCell('markdown');
+			await app.workbench.notebook.waitForTypeInEditor('## hello2! ');
+			await app.workbench.notebook.stopEditingCell();
+			await app.workbench.notebook.waitForMarkdownContents('h2', 'hello2!');
+		});
+
+		it('moves focus as it inserts/deletes a cell', async function () {
+			const app = this.app as Application;
+			await app.workbench.notebook.openNotebook();
+			await app.workbench.notebook.insertNotebookCell('code');
+			await app.workbench.notebook.waitForActiveCellEditorContents(' ');
+			await app.workbench.notebook.stopEditingCell();
+			await app.workbench.notebook.deleteActiveCell();
+			await app.workbench.notebook.waitForMarkdownContents('p', 'Markdown Cell');
+		});
+
+		it('moves focus in and out of output', async function () {
+			const app = this.app as Application;
+			await app.workbench.notebook.openNotebook();
+			await app.workbench.notebook.executeActiveCell();
+			await app.workbench.notebook.focusInCellOutput();
+			await app.workbench.notebook.focusOutCellOutput();
+			await app.workbench.notebook.waitForActiveCellEditorContents('code()');
+		});
+	});
+}

test/smoke/src/main.ts

@@ -26,6 +26,7 @@ import { main as sqlMain, setup as sqlSetup } from './sql/main'; //{{SQL CARBON
 import { setup as setupDataLossTests } from './areas/workbench/data-loss.test';
 import { setup as setupDataPreferencesTests } from './areas/preferences/preferences.test';
 import { setup as setupDataSearchTests } from './areas/search/search.test';
+import { setup as setupDataNotebookTests } from './areas/notebook/notebook.test';
 import { setup as setupDataLanguagesTests } from './areas/languages/languages.test';
 import { setup as setupDataEditorTests } from './areas/editor/editor.test';
 import { setup as setupDataStatusbarTests } from './areas/statusbar/statusbar.test';
@@ -155,6 +156,8 @@ if (!opts.web) {
 	} else {
 		quality = Quality.Stable;
 	}
+
+	console.log(`Running desktop smoke tests against ${electronPath}`);
 }
 
 //
@@ -163,14 +166,20 @@ if (!opts.web) {
 else {
 	const testCodeServerPath = opts.build || process.env.VSCODE_REMOTE_SERVER_PATH;
 
-	if (typeof testCodeServerPath === 'string' && !fs.existsSync(testCodeServerPath)) {
-		fail(`Can't find Code server at ${testCodeServerPath}.`);
+	if (typeof testCodeServerPath === 'string') {
+		if (!fs.existsSync(testCodeServerPath)) {
+			fail(`Can't find Code server at ${testCodeServerPath}.`);
+		} else {
+			console.log(`Running web smoke tests against ${testCodeServerPath}`);
+		}
 	}
 
 	if (!testCodeServerPath) {
 		process.env.VSCODE_REPOSITORY = repoPath;
 		process.env.VSCODE_DEV = '1';
 		process.env.VSCODE_CLI = '1';
+
+		console.log(`Running web smoke out of sources`);
 	}
 
 	if (process.env.VSCODE_DEV === '1') {
@@ -310,6 +319,7 @@ describe(`VSCode Smoke Tests (${opts.web ? 'Web' : 'Electron'})`, () => {
 		/*if (!opts.web) { setupDataLossTests(); }
 		if (!opts.web) { setupDataPreferencesTests(); }
 		setupDataSearchTests();
+		if (!opts.web) { setupDataNotebookTests(); }
 		setupDataLanguagesTests();
 		setupDataEditorTests();
 		setupDataStatusbarTests(!!opts.web);

test/unit/browser/index.js

@@ -72,7 +72,7 @@ function ensureIsArray(a) {
 
 const testModules = (async function () {
 
-	const excludeGlob = '**/{node,electron-browser,electron-main}/**/*.test.js';
+	const excludeGlob = '**/{node,electron-sandbox,electron-browser,electron-main}/**/*.test.js';
 	let isDefaultModules = true;
 	let promise;
 

test/unit/electron/index.js

@@ -124,7 +124,9 @@ app.on('ready', () => {
 			backgroundThrottling: false,
 			nodeIntegration: true,
 			webSecurity: false,
-			webviewTag: true
+			webviewTag: true,
+			preload: path.join(__dirname, '..', '..', '..', 'src', 'vs', 'base', 'parts', 'sandbox', 'electron-browser', 'preload.js'), // ensure similar environment as VSCode as tests may depend on this
+			enableWebSQL: false
 		}
 	});