Merge remote-tracking branch 'origin/main' into tyriar/megan

extensions/vscode-api-tests/src/singlefolder-tests/notebook.document.test.ts

@@ -0,0 +1,235 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as assert from 'assert';
+import * as vscode from 'vscode';
+import * as utils from '../utils';
+
+suite('Notebook Document', function () {
+
+	const contentProvider = new class implements vscode.NotebookContentProvider {
+		async openNotebook(uri: vscode.Uri, _openContext: vscode.NotebookDocumentOpenContext): Promise<vscode.NotebookData> {
+			return {
+				cells: [{ cellKind: vscode.NotebookCellKind.Code, source: uri.toString(), language: 'javascript', metadata: {}, outputs: [] }],
+				metadata: {}
+			};
+		}
+		async resolveNotebook(_document: vscode.NotebookDocument, _webview: vscode.NotebookCommunication) {
+			//
+		}
+		async saveNotebook(_document: vscode.NotebookDocument, _cancellation: vscode.CancellationToken) {
+			//
+		}
+		async saveNotebookAs(_targetResource: vscode.Uri, _document: vscode.NotebookDocument, _cancellation: vscode.CancellationToken) {
+			//
+		}
+		async backupNotebook(_document: vscode.NotebookDocument, _context: vscode.NotebookDocumentBackupContext, _cancellation: vscode.CancellationToken) {
+			return { id: '', delete() { } };
+		}
+	};
+
+	const disposables: vscode.Disposable[] = [];
+
+	suiteTeardown(async function () {
+		// utils.assertNoRpc();
+		await utils.revertAllDirty();
+		await utils.closeAllEditors();
+		utils.disposeAll(disposables);
+		disposables.length = 0;
+
+		for (let doc of vscode.notebook.notebookDocuments) {
+			assert.strictEqual(doc.isDirty, false, doc.uri.toString());
+		}
+	});
+
+	suiteSetup(function () {
+		disposables.push(vscode.notebook.registerNotebookContentProvider('notebook.nbdtest', contentProvider));
+	});
+
+	test('cannot register sample provider multiple times', function () {
+		assert.throws(() => {
+			vscode.notebook.registerNotebookContentProvider('notebook.nbdtest', contentProvider);
+		});
+	});
+
+	test('cannot open unknown types', async function () {
+		try {
+			await vscode.notebook.openNotebookDocument(vscode.Uri.parse('some:///thing.notTypeKnown'));
+			assert.ok(false);
+		} catch {
+			assert.ok(true);
+		}
+	});
+
+	test('document basics', async function () {
+		const uri = await utils.createRandomFile(undefined, undefined, '.nbdtest');
+		const notebook = await vscode.notebook.openNotebookDocument(uri);
+
+		assert.strictEqual(notebook.uri.toString(), uri.toString());
+		assert.strictEqual(notebook.isDirty, false);
+		assert.strictEqual(notebook.isUntitled, false);
+		assert.strictEqual(notebook.cells.length, 1);
+
+		assert.strictEqual(notebook.viewType, 'notebook.nbdtest');
+	});
+
+	test('notebook open/close, notebook ready when cell-document open event is fired', async function () {
+		const uri = await utils.createRandomFile(undefined, undefined, '.nbdtest');
+		let didHappen = false;
+		const p = utils.asPromise(vscode.workspace.onDidOpenTextDocument).then(doc => {
+			if (doc.uri.scheme !== 'vscode-notebook-cell') {
+				return;
+			}
+			const notebook = vscode.notebook.notebookDocuments.find(notebook => {
+				const cell = notebook.cells.find(cell => cell.document === doc);
+				return Boolean(cell);
+			});
+			assert.ok(notebook, `notebook for cell ${doc.uri} NOT found`);
+			didHappen = true;
+		});
+
+		await vscode.notebook.openNotebookDocument(uri);
+		await p;
+		assert.strictEqual(didHappen, true);
+	});
+
+	test('notebook open/close, all cell-documents are ready', async function () {
+		const uri = await utils.createRandomFile(undefined, undefined, '.nbdtest');
+
+		const p = utils.asPromise(vscode.notebook.onDidOpenNotebookDocument).then(notebook => {
+			for (let cell of notebook.cells) {
+				const doc = vscode.workspace.textDocuments.find(doc => doc.uri.toString() === cell.uri.toString());
+				assert.ok(doc);
+				assert.strictEqual(doc.notebook === notebook, true);
+				assert.strictEqual(doc === cell.document, true);
+				assert.strictEqual(doc?.languageId, cell.language);
+				assert.strictEqual(doc?.isDirty, false);
+				assert.strictEqual(doc?.isClosed, false);
+			}
+		});
+
+		await vscode.notebook.openNotebookDocument(uri);
+		await p;
+	});
+
+
+	test('workspace edit API (replaceCells)', async function () {
+		const uri = await utils.createRandomFile(undefined, undefined, '.nbdtest');
+
+		const document = await vscode.notebook.openNotebookDocument(uri);
+		assert.strictEqual(document.cells.length, 1);
+
+		// inserting two new cells
+		{
+			const edit = new vscode.WorkspaceEdit();
+			edit.replaceNotebookCells(document.uri, 0, 0, [{
+				cellKind: vscode.NotebookCellKind.Markdown,
+				language: 'markdown',
+				metadata: undefined,
+				outputs: [],
+				source: 'new_markdown'
+			}, {
+				cellKind: vscode.NotebookCellKind.Code,
+				language: 'fooLang',
+				metadata: undefined,
+				outputs: [],
+				source: 'new_code'
+			}]);
+
+			const success = await vscode.workspace.applyEdit(edit);
+			assert.strictEqual(success, true);
+		}
+
+		assert.strictEqual(document.cells.length, 3);
+		assert.strictEqual(document.cells[0].document.getText(), 'new_markdown');
+		assert.strictEqual(document.cells[1].document.getText(), 'new_code');
+
+		// deleting cell 1 and 3
+		{
+			const edit = new vscode.WorkspaceEdit();
+			edit.replaceNotebookCells(document.uri, 0, 1, []);
+			edit.replaceNotebookCells(document.uri, 2, 3, []);
+			const success = await vscode.workspace.applyEdit(edit);
+			assert.strictEqual(success, true);
+		}
+
+		assert.strictEqual(document.cells.length, 1);
+		assert.strictEqual(document.cells[0].document.getText(), 'new_code');
+
+		// replacing all cells
+		{
+			const edit = new vscode.WorkspaceEdit();
+			edit.replaceNotebookCells(document.uri, 0, 1, [{
+				cellKind: vscode.NotebookCellKind.Markdown,
+				language: 'markdown',
+				metadata: undefined,
+				outputs: [],
+				source: 'new2_markdown'
+			}, {
+				cellKind: vscode.NotebookCellKind.Code,
+				language: 'fooLang',
+				metadata: undefined,
+				outputs: [],
+				source: 'new2_code'
+			}]);
+			const success = await vscode.workspace.applyEdit(edit);
+			assert.strictEqual(success, true);
+		}
+		assert.strictEqual(document.cells.length, 2);
+		assert.strictEqual(document.cells[0].document.getText(), 'new2_markdown');
+		assert.strictEqual(document.cells[1].document.getText(), 'new2_code');
+
+		// remove all cells
+		{
+			const edit = new vscode.WorkspaceEdit();
+			edit.replaceNotebookCells(document.uri, 0, document.cells.length, []);
+			const success = await vscode.workspace.applyEdit(edit);
+			assert.strictEqual(success, true);
+		}
+		assert.strictEqual(document.cells.length, 0);
+	});
+
+	test('workspace edit API (replaceCells, event)', async function () {
+		const uri = await utils.createRandomFile(undefined, undefined, '.nbdtest');
+		const document = await vscode.notebook.openNotebookDocument(uri);
+		assert.strictEqual(document.cells.length, 1);
+
+		const edit = new vscode.WorkspaceEdit();
+		edit.replaceNotebookCells(document.uri, 0, 0, [{
+			cellKind: vscode.NotebookCellKind.Markdown,
+			language: 'markdown',
+			metadata: undefined,
+			outputs: [],
+			source: 'new_markdown'
+		}, {
+			cellKind: vscode.NotebookCellKind.Code,
+			language: 'fooLang',
+			metadata: undefined,
+			outputs: [],
+			source: 'new_code'
+		}]);
+
+		const event = utils.asPromise<vscode.NotebookCellsChangeEvent>(vscode.notebook.onDidChangeNotebookCells);
+
+		const success = await vscode.workspace.applyEdit(edit);
+		assert.strictEqual(success, true);
+
+		const data = await event;
+
+		// check document
+		assert.strictEqual(document.cells.length, 3);
+		assert.strictEqual(document.cells[0].document.getText(), 'new_markdown');
+		assert.strictEqual(document.cells[1].document.getText(), 'new_code');
+
+		// check event data
+		assert.strictEqual(data.document === document, true);
+		assert.strictEqual(data.changes.length, 1);
+		assert.strictEqual(data.changes[0].deletedCount, 0);
+		assert.strictEqual(data.changes[0].deletedItems.length, 0);
+		assert.strictEqual(data.changes[0].items.length, 2);
+		assert.strictEqual(data.changes[0].items[0], document.cells[0]);
+		assert.strictEqual(data.changes[0].items[1], document.cells[1]);
+	});
+});

extensions/vscode-api-tests/src/singlefolder-tests/window.test.ts

@@ -150,6 +150,13 @@ suite('vscode API - window', () => {
 	});
 
 	test('active editor not always correct... #49125', async function () {
+
+		if (!window.state.focused) {
+			// no focus!
+			this.skip();
+			return;
+		}
+
 		if (process.env['BUILD_SOURCEVERSION']) {
 			this.skip();
 			return;

extensions/vscode-api-tests/src/utils.ts

@@ -17,7 +17,7 @@ vscode.workspace.registerFileSystemProvider(testFs.scheme, testFs, { isCaseSensi
 export async function createRandomFile(contents = '', dir: vscode.Uri | undefined = undefined, ext = ''): Promise<vscode.Uri> {
 	let fakeFile: vscode.Uri;
 	if (dir) {
-		assert.equal(dir.scheme, testFs.scheme);
+		assert.strictEqual(dir.scheme, testFs.scheme);
 		fakeFile = dir.with({ path: dir.path + '/' + rndName() + ext });
 	} else {
 		fakeFile = vscode.Uri.parse(`${testFs.scheme}:/${rndName() + ext}`);
@@ -48,6 +48,10 @@ export function closeAllEditors(): Thenable<any> {
 	return vscode.commands.executeCommand('workbench.action.closeAllEditors');
 }
 
+export function saveAllEditors(): Thenable<any> {
+	return vscode.commands.executeCommand('workbench.action.files.saveAll');
+}
+
 export async function revertAllDirty(): Promise<void> {
 	return vscode.commands.executeCommand('_workbench.revertAllDirty');
 }
@@ -117,3 +121,19 @@ export function assertNoRpcFromEntry(entry: [obj: any, name: string]) {
 	assert.strictEqual(rpcPaths.length, 0, rpcPaths.join('\n'));
 	assert.strictEqual(proxyPaths.length, 0, proxyPaths.join('\n')); // happens...
 }
+
+export async function asPromise<T>(event: vscode.Event<T>, timeout = 5000): Promise<T> {
+	return new Promise<T>((resolve, reject) => {
+
+		const handle = setTimeout(() => {
+			sub.dispose();
+			reject(new Error('asPromise TIMEOUT reached'));
+		}, timeout);
+
+		const sub = event(e => {
+			clearTimeout(handle);
+			sub.dispose();
+			resolve(e);
+		});
+	});
+}