Merge pull request #116685 from microsoft/job/nbtests

Move notebook tests

extensions/vscode-api-tests/package.json

@@ -116,6 +116,27 @@
           }
         ]
       }
+    ],
+    "notebookProvider": [
+      {
+        "viewType": "notebookCoreTest",
+        "displayName": "Notebook Core Test",
+        "selector": [
+          {
+            "filenamePattern": "*.vsctestnb",
+            "excludeFileNamePattern": ""
+          }
+        ]
+      },
+      {
+        "viewType": "notebook.nbdtest",
+        "displayName": "notebook.nbdtest",
+        "selector": [
+          {
+            "filenamePattern": "**/*.nbdtest"
+          }
+        ]
+      }
     ]
   },
   "scripts": {

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

@@ -0,0 +1,234 @@
+/*---------------------------------------------------------------------------------------------
+ *  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 () {
+		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/notebook.test.ts

@@ -6,52 +6,13 @@
 import 'mocha';
 import * as assert from 'assert';
 import * as vscode from 'vscode';
-import { createRandomFile } from './utils';
-
-export function timeoutAsync(n: number): Promise<void> {
-	return new Promise(resolve => {
-		setTimeout(() => {
-			resolve();
-		}, n);
-	});
-}
-
-export function once<T>(event: vscode.Event<T>): vscode.Event<T> {
-	return (listener: any, thisArgs = null, disposables?: any) => {
-		// we need this, in case the event fires during the listener call
-		let didFire = false;
-		let result: vscode.Disposable;
-		result = event(e => {
-			if (didFire) {
-				return;
-			} else if (result) {
-				result.dispose();
-			} else {
-				didFire = true;
-			}
-
-			return listener.call(thisArgs, e);
-		}, null, disposables);
-
-		if (didFire) {
-			result.dispose();
-		}
-
-		return result;
-	};
-}
-
-async function getEventOncePromise<T>(event: vscode.Event<T>): Promise<T> {
-	return new Promise<T>((resolve, _reject) => {
-		once(event)((result: T) => resolve(result));
-	});
-}
+import { createRandomFile, asPromise, disposeAll, closeAllEditors, revertAllDirty } from '../utils';
 
 // Since `workbench.action.splitEditor` command does await properly
 // Notebook editor/document events are not guaranteed to be sent to the ext host when promise resolves
 // The workaround here is waiting for the first visible notebook editor change event.
 async function splitEditor() {
-	const once = getEventOncePromise(vscode.window.onDidChangeVisibleNotebookEditors);
+	const once = asPromise(vscode.window.onDidChangeVisibleNotebookEditors);
 	await vscode.commands.executeCommand('workbench.action.splitEditor');
 	await once;
 }
@@ -100,7 +61,7 @@ async function updateNotebookMetadata(uri: vscode.Uri, newMetadata: vscode.Noteb
 }
 
 async function withEvent<T>(event: vscode.Event<T>, callback: (e: Promise<T>) => Promise<void>) {
-	const e = getEventOncePromise<T>(event);
+	const e = asPromise<T>(event);
 	await callback(e);
 }
 
@@ -112,7 +73,146 @@ function assertInitalState() {
 	// assert.strictEqual(vscode.notebook.visibleNotebookEditors.length, 0);
 }
 
-suite('Notebook API tests', () => {
+suite('Notebook API tests', function () {
+
+	const disposables: vscode.Disposable[] = [];
+
+	suiteTeardown(async function () {
+		await revertAllDirty();
+		await closeAllEditors();
+
+		disposeAll(disposables);
+		disposables.length = 0;
+	});
+
+	suiteSetup(function () {
+		disposables.push(vscode.notebook.registerNotebookContentProvider('notebookCoreTest', {
+			openNotebook: async (_resource: vscode.Uri): Promise<vscode.NotebookData> => {
+				if (/.*empty\-.*\.vsctestnb$/.test(_resource.path)) {
+					return {
+						metadata: {},
+						cells: []
+					};
+				}
+
+				const dto: vscode.NotebookData = {
+					metadata: {
+						custom: { testMetadata: false }
+					},
+					cells: [
+						{
+							source: 'test',
+							language: 'typescript',
+							cellKind: vscode.NotebookCellKind.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 = {
+			id: 'mainKernel',
+			label: 'Notebook Test Kernel',
+			isPreferred: true,
+			supportedLanguages: ['typescript'],
+			executeAllCells: async (_document: vscode.NotebookDocument) => {
+				const edit = new vscode.WorkspaceEdit();
+
+				edit.replaceNotebookCellOutput(_document.uri, 0, [new vscode.NotebookCellOutput([
+					new vscode.NotebookCellOutputItem('text/plain', ['my output'], undefined)
+				])]);
+				return vscode.workspace.applyEdit(edit);
+			},
+			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')) {
+					const edit = new vscode.WorkspaceEdit();
+					edit.replaceNotebookCellOutput(document.uri, cell.index, [new vscode.NotebookCellOutput([
+						new vscode.NotebookCellOutputItem('text/custom', ['test'], undefined)
+					])]);
+
+					return vscode.workspace.applyEdit(edit);
+				}
+
+				const edit = new vscode.WorkspaceEdit();
+				// const previousOutputs = cell.outputs;
+				edit.replaceNotebookCellOutput(document.uri, cell.index, [new vscode.NotebookCellOutput([
+					new vscode.NotebookCellOutputItem('text/plain', ['my output'], undefined)
+				])]);
+
+				return vscode.workspace.applyEdit(edit);
+			},
+			cancelCellExecution: async (_document: vscode.NotebookDocument, _cell: vscode.NotebookCell) => { }
+		};
+
+		const kernel2: vscode.NotebookKernel = {
+			id: 'secondaryKernel',
+			label: 'Notebook Secondary Test Kernel',
+			isPreferred: false,
+			supportedLanguages: ['typescript'],
+			executeAllCells: async (_document: vscode.NotebookDocument) => {
+				const edit = new vscode.WorkspaceEdit();
+				edit.replaceNotebookCellOutput(_document.uri, 0, [new vscode.NotebookCellOutput([
+					new vscode.NotebookCellOutputItem('text/plain', ['my second output'], undefined)
+				])]);
+
+				return vscode.workspace.applyEdit(edit);
+			},
+			cancelAllCellsExecution: async (_document: vscode.NotebookDocument) => { },
+			executeCell: async (document: vscode.NotebookDocument, cell: vscode.NotebookCell | undefined) => {
+				if (!cell) {
+					cell = document.cells[0];
+				}
+
+				const edit = new vscode.WorkspaceEdit();
+
+				if (document.uri.path.endsWith('customRenderer.vsctestnb')) {
+					edit.replaceNotebookCellOutput(document.uri, cell.index, [new vscode.NotebookCellOutput([
+						new vscode.NotebookCellOutputItem('text/custom', ['test 2'], undefined)
+					])]);
+				} else {
+					edit.replaceNotebookCellOutput(document.uri, cell.index, [new vscode.NotebookCellOutput([
+						new vscode.NotebookCellOutputItem('text/plain', ['my second output'], undefined)
+					])]);
+				}
+
+				return vscode.workspace.applyEdit(edit);
+			},
+			cancelCellExecution: async (_document: vscode.NotebookDocument, _cell: vscode.NotebookCell) => { }
+		};
+
+		disposables.push(vscode.notebook.registerNotebookKernelProvider({ filenamePattern: '*.vsctestnb' }, {
+			provideKernels: async () => {
+				return [kernel, kernel2];
+			}
+		}));
+	});
+
 	// test.only('crash', async function () {
 	// 	for (let i = 0; i < 200; i++) {
 	// 		let resource = vscode.Uri.file(join(vscode.workspace.rootPath || '', './first.vsctestnb'));
@@ -141,60 +241,20 @@ suite('Notebook API tests', () => {
 	test('document open/close event', async function () {
 		assertInitalState();
 
-		const resource = await createRandomFile('', undefined, 'first', '.vsctestnb');
-		const firstDocumentOpen = getEventOncePromise(vscode.notebook.onDidOpenNotebookDocument);
+		const resource = await createRandomFile('', undefined, '.vsctestnb');
+		const firstDocumentOpen = asPromise(vscode.notebook.onDidOpenNotebookDocument);
 		await vscode.commands.executeCommand('vscode.openWith', resource, 'notebookCoreTest');
 		await firstDocumentOpen;
 
-		const firstDocumentClose = getEventOncePromise(vscode.notebook.onDidCloseNotebookDocument);
+		const firstDocumentClose = asPromise(vscode.notebook.onDidCloseNotebookDocument);
 		await vscode.commands.executeCommand('workbench.action.closeAllEditors');
 		await firstDocumentClose;
 	});
 
-	test('notebook open/close, all cell-documents are ready', async function () {
-		const resource = await createRandomFile('', undefined, 'first', '.vsctestnb');
-
-		const p = getEventOncePromise(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 === cell.document, true);
-				assert.strictEqual(doc?.languageId, cell.language);
-				assert.strictEqual(doc?.isDirty, false);
-				assert.strictEqual(doc?.isClosed, false);
-			}
-		});
-
-		await vscode.commands.executeCommand('vscode.openWith', resource, 'notebookCoreTest');
-		await p;
-		await vscode.commands.executeCommand('workbench.action.closeAllEditors');
-	});
-
-	test('notebook open/close, notebook ready when cell-document open event is fired', async function () {
-		const resource = await createRandomFile('', undefined, 'first', '.vsctestnb');
-		let didHappen = false;
-		const p = getEventOncePromise(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.commands.executeCommand('vscode.openWith', resource, 'notebookCoreTest');
-		await p;
-		assert.strictEqual(didHappen, true);
-		await vscode.commands.executeCommand('workbench.action.closeAllEditors');
-	});
-
 	test('shared document in notebook editors', async function () {
 		assertInitalState();
 
-		const resource = await createRandomFile('', undefined, 'first', '.vsctestnb');
+		const resource = await createRandomFile('', undefined, '.vsctestnb');
 		let counter = 0;
 		const disposables: vscode.Disposable[] = [];
 		disposables.push(vscode.notebook.onDidOpenNotebookDocument(() => {
@@ -217,12 +277,12 @@ suite('Notebook API tests', () => {
 	test('editor open/close event', async function () {
 		assertInitalState();
 
-		const resource = await createRandomFile('', undefined, 'first', '.vsctestnb');
-		const firstEditorOpen = getEventOncePromise(vscode.window.onDidChangeVisibleNotebookEditors);
+		const resource = await createRandomFile('', undefined, '.vsctestnb');
+		const firstEditorOpen = asPromise(vscode.window.onDidChangeVisibleNotebookEditors);
 		await vscode.commands.executeCommand('vscode.openWith', resource, 'notebookCoreTest');
 		await firstEditorOpen;
 
-		const firstEditorClose = getEventOncePromise(vscode.window.onDidChangeVisibleNotebookEditors);
+		const firstEditorClose = asPromise(vscode.window.onDidChangeVisibleNotebookEditors);
 		await vscode.commands.executeCommand('workbench.action.closeAllEditors');
 		await firstEditorClose;
 	});
@@ -230,7 +290,7 @@ suite('Notebook API tests', () => {
 	test('editor open/close event 2', async function () {
 		assertInitalState();
 
-		const resource = await createRandomFile('', undefined, 'first', '.vsctestnb');
+		const resource = await createRandomFile('', undefined, '.vsctestnb');
 		let count = 0;
 		const disposables: vscode.Disposable[] = [];
 		disposables.push(vscode.window.onDidChangeVisibleNotebookEditors(() => {
@@ -250,10 +310,10 @@ suite('Notebook API tests', () => {
 	test('editor editing event 2', async function () {
 		assertInitalState();
 
-		const resource = await createRandomFile('', undefined, 'first', '.vsctestnb');
+		const resource = await createRandomFile('', undefined, '.vsctestnb');
 		await vscode.commands.executeCommand('vscode.openWith', resource, 'notebookCoreTest');
 
-		const cellsChangeEvent = getEventOncePromise<vscode.NotebookCellsChangeEvent>(vscode.notebook.onDidChangeNotebookCells);
+		const cellsChangeEvent = asPromise<vscode.NotebookCellsChangeEvent>(vscode.notebook.onDidChangeNotebookCells);
 		await vscode.commands.executeCommand('notebook.cell.insertCodeCellBelow');
 		const cellChangeEventRet = await cellsChangeEvent;
 		assert.strictEqual(cellChangeEventRet.document, vscode.window.activeNotebookEditor?.document);
@@ -269,7 +329,7 @@ suite('Notebook API tests', () => {
 
 		const secondCell = vscode.window.activeNotebookEditor!.document.cells[1];
 
-		const moveCellEvent = getEventOncePromise<vscode.NotebookCellsChangeEvent>(vscode.notebook.onDidChangeNotebookCells);
+		const moveCellEvent = asPromise<vscode.NotebookCellsChangeEvent>(vscode.notebook.onDidChangeNotebookCells);
 		await vscode.commands.executeCommand('notebook.cell.moveUp');
 		const moveCellEventRet = await moveCellEvent;
 		assert.deepStrictEqual(moveCellEventRet, {
@@ -290,7 +350,7 @@ suite('Notebook API tests', () => {
 			]
 		});
 
-		const cellOutputChange = getEventOncePromise<vscode.NotebookCellOutputsChangeEvent>(vscode.notebook.onDidChangeCellOutputs);
+		const cellOutputChange = asPromise<vscode.NotebookCellOutputsChangeEvent>(vscode.notebook.onDidChangeCellOutputs);
 		await vscode.commands.executeCommand('notebook.cell.execute');
 		const cellOutputsAddedRet = await cellOutputChange;
 		assert.deepStrictEqual(cellOutputsAddedRet, {
@@ -299,7 +359,7 @@ suite('Notebook API tests', () => {
 		});
 		assert.strictEqual(cellOutputsAddedRet.cells[0].outputs.length, 1);
 
-		const cellOutputClear = getEventOncePromise<vscode.NotebookCellOutputsChangeEvent>(vscode.notebook.onDidChangeCellOutputs);
+		const cellOutputClear = asPromise<vscode.NotebookCellOutputsChangeEvent>(vscode.notebook.onDidChangeCellOutputs);
 		await vscode.commands.executeCommand('notebook.cell.clearOutputs');
 		const cellOutputsCleardRet = await cellOutputClear;
 		assert.deepStrictEqual(cellOutputsCleardRet, {
@@ -323,7 +383,7 @@ suite('Notebook API tests', () => {
 
 	test('editor move cell event', async function () {
 		assertInitalState();
-		const resource = await createRandomFile('', undefined, 'first', '.vsctestnb');
+		const resource = await createRandomFile('', undefined, '.vsctestnb');
 		await vscode.commands.executeCommand('vscode.openWith', resource, 'notebookCoreTest');
 		await vscode.commands.executeCommand('notebook.cell.insertCodeCellBelow');
 		await vscode.commands.executeCommand('notebook.cell.insertCodeCellAbove');
@@ -331,7 +391,7 @@ suite('Notebook API tests', () => {
 
 		const activeCell = vscode.window.activeNotebookEditor!.selection;
 		assert.strictEqual(vscode.window.activeNotebookEditor!.document.cells.indexOf(activeCell!), 0);
-		const moveChange = getEventOncePromise(vscode.notebook.onDidChangeNotebookCells);
+		const moveChange = asPromise(vscode.notebook.onDidChangeNotebookCells);
 		await vscode.commands.executeCommand('notebook.cell.moveDown');
 		const ret = await moveChange;
 		assert.deepStrictEqual(ret, {
@@ -365,7 +425,7 @@ suite('Notebook API tests', () => {
 
 	test('notebook editor active/visible', async function () {
 		assertInitalState();
-		const resource = await createRandomFile('', undefined, 'first', '.vsctestnb');
+		const resource = await createRandomFile('', undefined, '.vsctestnb');
 		await vscode.commands.executeCommand('vscode.openWith', resource, 'notebookCoreTest');
 		const firstEditor = vscode.window.activeNotebookEditor;
 		assert.strictEqual(firstEditor && vscode.window.visibleNotebookEditors.indexOf(firstEditor) >= 0, true);
@@ -377,7 +437,7 @@ suite('Notebook API tests', () => {
 		assert.strictEqual(firstEditor && vscode.window.visibleNotebookEditors.indexOf(firstEditor) >= 0, true);
 		assert.strictEqual(vscode.window.visibleNotebookEditors.length, 2);
 
-		const untitledEditorChange = getEventOncePromise(vscode.window.onDidChangeActiveNotebookEditor);
+		const untitledEditorChange = asPromise(vscode.window.onDidChangeActiveNotebookEditor);
 		await vscode.commands.executeCommand('workbench.action.files.newUntitledFile');
 		await untitledEditorChange;
 		assert.strictEqual(firstEditor && vscode.window.visibleNotebookEditors.indexOf(firstEditor) >= 0, true);
@@ -386,7 +446,7 @@ suite('Notebook API tests', () => {
 		assert.notStrictEqual(secondEditor, vscode.window.activeNotebookEditor);
 		assert.strictEqual(vscode.window.visibleNotebookEditors.length, 1);
 
-		const activeEditorClose = getEventOncePromise(vscode.window.onDidChangeActiveNotebookEditor);
+		const activeEditorClose = asPromise(vscode.window.onDidChangeActiveNotebookEditor);
 		await vscode.commands.executeCommand('workbench.action.closeActiveEditor');
 		await activeEditorClose;
 		assert.strictEqual(secondEditor, vscode.window.activeNotebookEditor);
@@ -399,12 +459,12 @@ suite('Notebook API tests', () => {
 
 	test('notebook active editor change', async function () {
 		assertInitalState();
-		const resource = await createRandomFile('', undefined, 'first', '.vsctestnb');
-		const firstEditorOpen = getEventOncePromise(vscode.window.onDidChangeActiveNotebookEditor);
+		const resource = await createRandomFile('', undefined, '.vsctestnb');
+		const firstEditorOpen = asPromise(vscode.window.onDidChangeActiveNotebookEditor);
 		await vscode.commands.executeCommand('vscode.openWith', resource, 'notebookCoreTest');
 		await firstEditorOpen;
 
-		const firstEditorDeactivate = getEventOncePromise(vscode.window.onDidChangeActiveNotebookEditor);
+		const firstEditorDeactivate = asPromise(vscode.window.onDidChangeActiveNotebookEditor);
 		await vscode.commands.executeCommand('workbench.action.splitEditor');
 		await firstEditorDeactivate;
 
@@ -413,10 +473,10 @@ suite('Notebook API tests', () => {
 
 	test('edit API (replaceCells)', async function () {
 		assertInitalState();
-		const resource = await createRandomFile('', undefined, 'first', '.vsctestnb');
+		const resource = await createRandomFile('', undefined, '.vsctestnb');
 		await vscode.commands.executeCommand('vscode.openWith', resource, 'notebookCoreTest');
 
-		const cellsChangeEvent = getEventOncePromise<vscode.NotebookCellsChangeEvent>(vscode.notebook.onDidChangeNotebookCells);
+		const cellsChangeEvent = asPromise<vscode.NotebookCellsChangeEvent>(vscode.notebook.onDidChangeNotebookCells);
 		await vscode.window.activeNotebookEditor!.edit(editBuilder => {
 			editBuilder.replaceCells(1, 0, [{ cellKind: vscode.NotebookCellKind.Code, language: 'javascript', source: 'test 2', outputs: [], metadata: undefined }]);
 		});
@@ -434,7 +494,7 @@ suite('Notebook API tests', () => {
 
 	test('edit API (replaceOutput, USE NotebookCellOutput-type)', async function () {
 		assertInitalState();
-		const resource = await createRandomFile('', undefined, 'first', '.vsctestnb');
+		const resource = await createRandomFile('', undefined, '.vsctestnb');
 		await vscode.commands.executeCommand('vscode.openWith', resource, 'notebookCoreTest');
 
 		await vscode.window.activeNotebookEditor!.edit(editBuilder => {
@@ -463,7 +523,7 @@ suite('Notebook API tests', () => {
 
 	test('edit API (replaceOutput)', async function () {
 		assertInitalState();
-		const resource = await createRandomFile('', undefined, 'first', '.vsctestnb');
+		const resource = await createRandomFile('', undefined, '.vsctestnb');
 		await vscode.commands.executeCommand('vscode.openWith', resource, 'notebookCoreTest');
 
 		await vscode.window.activeNotebookEditor!.edit(editBuilder => {
@@ -485,10 +545,10 @@ suite('Notebook API tests', () => {
 
 	test('edit API (replaceOutput, event)', async function () {
 		assertInitalState();
-		const resource = await createRandomFile('', undefined, 'first', '.vsctestnb');
+		const resource = await createRandomFile('', undefined, '.vsctestnb');
 		await vscode.commands.executeCommand('vscode.openWith', resource, 'notebookCoreTest');
 
-		const outputChangeEvent = getEventOncePromise<vscode.NotebookCellOutputsChangeEvent>(vscode.notebook.onDidChangeCellOutputs);
+		const outputChangeEvent = asPromise<vscode.NotebookCellOutputsChangeEvent>(vscode.notebook.onDidChangeCellOutputs);
 		await vscode.window.activeNotebookEditor!.edit(editBuilder => {
 			editBuilder.replaceCellOutput(0, [new vscode.NotebookCellOutput([
 				new vscode.NotebookCellOutputItem('foo', 'bar')
@@ -511,7 +571,7 @@ suite('Notebook API tests', () => {
 	test('edit API (replaceMetadata)', async function () {
 
 		assertInitalState();
-		const resource = await createRandomFile('', undefined, 'first', '.vsctestnb');
+		const resource = await createRandomFile('', undefined, '.vsctestnb');
 		await vscode.commands.executeCommand('vscode.openWith', resource, 'notebookCoreTest');
 
 		await vscode.window.activeNotebookEditor!.edit(editBuilder => {
@@ -530,10 +590,10 @@ suite('Notebook API tests', () => {
 	test('edit API (replaceMetadata, event)', async function () {
 
 		assertInitalState();
-		const resource = await createRandomFile('', undefined, 'first', '.vsctestnb');
+		const resource = await createRandomFile('', undefined, '.vsctestnb');
 		await vscode.commands.executeCommand('vscode.openWith', resource, 'notebookCoreTest');
 
-		const event = getEventOncePromise<vscode.NotebookCellMetadataChangeEvent>(vscode.notebook.onDidChangeCellMetadata);
+		const event = asPromise<vscode.NotebookCellMetadataChangeEvent>(vscode.notebook.onDidChangeCellMetadata);
 
 		await vscode.window.activeNotebookEditor!.edit(editBuilder => {
 			editBuilder.replaceCellMetadata(0, { inputCollapsed: true, executionOrder: 17 });
@@ -548,141 +608,13 @@ suite('Notebook API tests', () => {
 		await saveFileAndCloseAll(resource);
 	});
 
-	test('workspace edit API (replaceCells)', async function () {
-
-		assertInitalState();
-		const resource = await createRandomFile('', undefined, 'first', '.vsctestnb');
-		await vscode.commands.executeCommand('vscode.openWith', resource, 'notebookCoreTest');
-
-		const { document } = vscode.window.activeNotebookEditor!;
-		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);
-
-		await saveFileAndCloseAll(resource);
-	});
-
-	test('workspace edit API (replaceCells, event)', async function () {
-
-		assertInitalState();
-		const resource = await createRandomFile('', undefined, 'first', '.vsctestnb');
-		await vscode.commands.executeCommand('vscode.openWith', resource, 'notebookCoreTest');
-
-		const { document } = vscode.window.activeNotebookEditor!;
-		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 = getEventOncePromise<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]);
-		await saveFileAndCloseAll(resource);
-	});
-
 	test('edit API batch edits', async function () {
 		assertInitalState();
-		const resource = await createRandomFile('', undefined, 'first', '.vsctestnb');
+		const resource = await createRandomFile('', undefined, '.vsctestnb');
 		await vscode.commands.executeCommand('vscode.openWith', resource, 'notebookCoreTest');
 
-		const cellsChangeEvent = getEventOncePromise<vscode.NotebookCellsChangeEvent>(vscode.notebook.onDidChangeNotebookCells);
-		const cellMetadataChangeEvent = getEventOncePromise<vscode.NotebookCellMetadataChangeEvent>(vscode.notebook.onDidChangeCellMetadata);
+		const cellsChangeEvent = asPromise<vscode.NotebookCellsChangeEvent>(vscode.notebook.onDidChangeNotebookCells);
+		const cellMetadataChangeEvent = asPromise<vscode.NotebookCellMetadataChangeEvent>(vscode.notebook.onDidChangeCellMetadata);
 		const version = vscode.window.activeNotebookEditor!.document.version;
 		await vscode.window.activeNotebookEditor!.edit(editBuilder => {
 			editBuilder.replaceCells(1, 0, [{ cellKind: vscode.NotebookCellKind.Code, language: 'javascript', source: 'test 2', outputs: [], metadata: undefined }]);
@@ -697,11 +629,11 @@ suite('Notebook API tests', () => {
 
 	test('edit API batch edits undo/redo', async function () {
 		assertInitalState();
-		const resource = await createRandomFile('', undefined, 'first', '.vsctestnb');
+		const resource = await createRandomFile('', undefined, '.vsctestnb');
 		await vscode.commands.executeCommand('vscode.openWith', resource, 'notebookCoreTest');
 
-		const cellsChangeEvent = getEventOncePromise<vscode.NotebookCellsChangeEvent>(vscode.notebook.onDidChangeNotebookCells);
-		const cellMetadataChangeEvent = getEventOncePromise<vscode.NotebookCellMetadataChangeEvent>(vscode.notebook.onDidChangeCellMetadata);
+		const cellsChangeEvent = asPromise<vscode.NotebookCellsChangeEvent>(vscode.notebook.onDidChangeNotebookCells);
+		const cellMetadataChangeEvent = asPromise<vscode.NotebookCellMetadataChangeEvent>(vscode.notebook.onDidChangeCellMetadata);
 		const version = vscode.window.activeNotebookEditor!.document.version;
 		await vscode.window.activeNotebookEditor!.edit(editBuilder => {
 			editBuilder.replaceCells(1, 0, [{ cellKind: vscode.NotebookCellKind.Code, language: 'javascript', source: 'test 2', outputs: [], metadata: undefined }]);
@@ -724,7 +656,7 @@ suite('Notebook API tests', () => {
 
 	test('initialzation should not emit cell change events.', async function () {
 		assertInitalState();
-		const resource = await createRandomFile('', undefined, 'first', '.vsctestnb');
+		const resource = await createRandomFile('', undefined, '.vsctestnb');
 
 		let count = 0;
 		const disposables: vscode.Disposable[] = [];
@@ -739,12 +671,13 @@ suite('Notebook API tests', () => {
 
 		await saveFileAndCloseAll(resource);
 	});
-});
+	// });
+
+	// suite('notebook workflow', () => {
 
-suite('notebook workflow', () => {
 	test('notebook open', async function () {
 		assertInitalState();
-		const resource = await createRandomFile('', undefined, 'first', '.vsctestnb');
+		const resource = await createRandomFile('', undefined, '.vsctestnb');
 		await vscode.commands.executeCommand('vscode.openWith', resource, 'notebookCoreTest');
 		assert.strictEqual(vscode.window.activeNotebookEditor !== undefined, true, 'notebook first');
 		assert.strictEqual(vscode.window.activeNotebookEditor!.selection?.document.getText(), 'test');
@@ -766,7 +699,7 @@ suite('notebook workflow', () => {
 
 	test('notebook cell actions', async function () {
 		assertInitalState();
-		const resource = await createRandomFile('', undefined, 'first', '.vsctestnb');
+		const resource = await createRandomFile('', undefined, '.vsctestnb');
 		await vscode.commands.executeCommand('vscode.openWith', resource, 'notebookCoreTest');
 		assert.strictEqual(vscode.window.activeNotebookEditor !== undefined, true, 'notebook first');
 		assert.strictEqual(vscode.window.activeNotebookEditor!.selection?.document.getText(), 'test');
@@ -840,7 +773,7 @@ suite('notebook workflow', () => {
 
 	test('notebook join cells', async function () {
 		assertInitalState();
-		const resource = await createRandomFile('', undefined, 'first', '.vsctestnb');
+		const resource = await createRandomFile('', undefined, '.vsctestnb');
 		await vscode.commands.executeCommand('vscode.openWith', resource, 'notebookCoreTest');
 		assert.strictEqual(vscode.window.activeNotebookEditor !== undefined, true, 'notebook first');
 		assert.strictEqual(vscode.window.activeNotebookEditor!.selection?.document.getText(), 'test');
@@ -852,7 +785,7 @@ suite('notebook workflow', () => {
 		edit.insert(vscode.window.activeNotebookEditor!.selection!.uri, new vscode.Position(0, 0), 'var abc = 0;');
 		await vscode.workspace.applyEdit(edit);
 
-		const cellsChangeEvent = getEventOncePromise<vscode.NotebookCellsChangeEvent>(vscode.notebook.onDidChangeNotebookCells);
+		const cellsChangeEvent = asPromise<vscode.NotebookCellsChangeEvent>(vscode.notebook.onDidChangeNotebookCells);
 		await vscode.commands.executeCommand('notebook.cell.joinAbove');
 		await cellsChangeEvent;
 
@@ -864,7 +797,7 @@ suite('notebook workflow', () => {
 
 	test('move cells will not recreate cells in ExtHost', async function () {
 		assertInitalState();
-		const resource = await createRandomFile('', undefined, 'first', '.vsctestnb');
+		const resource = await createRandomFile('', undefined, '.vsctestnb');
 		await vscode.commands.executeCommand('vscode.openWith', resource, 'notebookCoreTest');
 		await vscode.commands.executeCommand('notebook.cell.insertCodeCellBelow');
 		await vscode.commands.executeCommand('notebook.cell.insertCodeCellAbove');
@@ -884,7 +817,7 @@ suite('notebook workflow', () => {
 	});
 
 	// test.only('document metadata is respected', async function () {
-	// 	const resource = await createRandomFile('', undefined, 'first', '.vsctestnb');
+	// 	const resource = await createRandomFile('', undefined, '.vsctestnb');
 	// 	await vscode.commands.executeCommand('vscode.openWith', resource, 'notebookCoreTest');
 
 	// 	assert.strictEqual(vscode.window.activeNotebookEditor !== undefined, true, 'notebook first');
@@ -909,7 +842,7 @@ suite('notebook workflow', () => {
 
 	test('cell runnable metadata is respected', async () => {
 		assertInitalState();
-		const resource = await createRandomFile('', undefined, 'first', '.vsctestnb');
+		const resource = await createRandomFile('', undefined, '.vsctestnb');
 		await vscode.commands.executeCommand('vscode.openWith', resource, 'notebookCoreTest');
 		assert.strictEqual(vscode.window.activeNotebookEditor !== undefined, true, 'notebook first');
 		const editor = vscode.window.activeNotebookEditor!;
@@ -918,14 +851,14 @@ suite('notebook workflow', () => {
 		const cell = editor.document.cells[0];
 		assert.strictEqual(cell.outputs.length, 0);
 
-		let metadataChangeEvent = getEventOncePromise<vscode.NotebookCellMetadataChangeEvent>(vscode.notebook.onDidChangeCellMetadata);
+		let metadataChangeEvent = asPromise<vscode.NotebookCellMetadataChangeEvent>(vscode.notebook.onDidChangeCellMetadata);
 		await updateCellMetadata(resource, cell, { ...cell.metadata, runnable: false });
 		await metadataChangeEvent;
 
 		await vscode.commands.executeCommand('notebook.cell.execute');
 		assert.strictEqual(cell.outputs.length, 0, 'should not execute'); // not runnable, didn't work
 
-		metadataChangeEvent = getEventOncePromise<vscode.NotebookCellMetadataChangeEvent>(vscode.notebook.onDidChangeCellMetadata);
+		metadataChangeEvent = asPromise<vscode.NotebookCellMetadataChangeEvent>(vscode.notebook.onDidChangeCellMetadata);
 		await updateCellMetadata(resource, cell, { ...cell.metadata, runnable: true });
 		await metadataChangeEvent;
 
@@ -938,7 +871,7 @@ suite('notebook workflow', () => {
 
 	test('document runnable metadata is respected', async () => {
 		assertInitalState();
-		const resource = await createRandomFile('', undefined, 'first', '.vsctestnb');
+		const resource = await createRandomFile('', undefined, '.vsctestnb');
 		await vscode.commands.executeCommand('vscode.openWith', resource, 'notebookCoreTest');
 		assert.strictEqual(vscode.window.activeNotebookEditor !== undefined, true, 'notebook first');
 		const editor = vscode.window.activeNotebookEditor!;
@@ -973,7 +906,7 @@ suite('notebook workflow', () => {
 	// TODO@rebornix this is wrong, `await vscode.commands.executeCommand('notebook.execute');` doesn't wait until the workspace edit is applied
 	test.skip('cell execute command takes arguments', async () => {
 		assertInitalState();
-		const resource = await createRandomFile('', undefined, 'first', '.vsctestnb');
+		const resource = await createRandomFile('', undefined, '.vsctestnb');
 		await vscode.commands.executeCommand('vscode.openWith', resource, 'notebookCoreTest');
 		assert.strictEqual(vscode.window.activeNotebookEditor !== undefined, true, 'notebook first');
 		const editor = vscode.window.activeNotebookEditor!;
@@ -988,7 +921,7 @@ suite('notebook workflow', () => {
 
 	test('cell execute command takes arguments 2', async () => {
 		assertInitalState();
-		const resource = await createRandomFile('', undefined, 'first', '.vsctestnb');
+		const resource = await createRandomFile('', undefined, '.vsctestnb');
 		await vscode.commands.executeCommand('vscode.openWith', resource, 'notebookCoreTest');
 		assert.strictEqual(vscode.window.activeNotebookEditor !== undefined, true, 'notebook first');
 		const editor = vscode.window.activeNotebookEditor!;
@@ -1011,7 +944,7 @@ suite('notebook workflow', () => {
 			assert.strictEqual(cell.outputs.length, 0, 'should clear');
 		});
 
-		const secondResource = await createRandomFile('', undefined, 'second', '.vsctestnb');
+		const secondResource = await createRandomFile('', undefined, '.vsctestnb');
 		await vscode.commands.executeCommand('vscode.openWith', secondResource, 'notebookCoreTest');
 
 		await withEvent<vscode.NotebookCellOutputsChangeEvent>(vscode.notebook.onDidChangeCellOutputs, async (event) => {
@@ -1029,13 +962,13 @@ suite('notebook workflow', () => {
 
 	test('document execute command takes arguments', async () => {
 		assertInitalState();
-		const resource = await createRandomFile('', undefined, 'first', '.vsctestnb');
+		const resource = await createRandomFile('', undefined, '.vsctestnb');
 		await vscode.commands.executeCommand('vscode.openWith', resource, 'notebookCoreTest');
 		assert.strictEqual(vscode.window.activeNotebookEditor !== undefined, true, 'notebook first');
 		const editor = vscode.window.activeNotebookEditor!;
 		const cell = editor.document.cells[0];
 
-		const metadataChangeEvent = getEventOncePromise<vscode.NotebookDocumentMetadataChangeEvent>(vscode.notebook.onDidChangeNotebookDocumentMetadata);
+		const metadataChangeEvent = asPromise<vscode.NotebookDocumentMetadataChangeEvent>(vscode.notebook.onDidChangeNotebookDocumentMetadata);
 		updateNotebookMetadata(editor.document.uri, { ...editor.document.metadata, runnable: true });
 		await metadataChangeEvent;
 		assert.strictEqual(editor.document.metadata.runnable, true);
@@ -1046,12 +979,12 @@ suite('notebook workflow', () => {
 			assert.strictEqual(cell.outputs.length, 1, 'should execute'); // runnable, it worked
 		});
 
-		const clearChangeEvent = getEventOncePromise<vscode.NotebookCellOutputsChangeEvent>(vscode.notebook.onDidChangeCellOutputs);
+		const clearChangeEvent = asPromise<vscode.NotebookCellOutputsChangeEvent>(vscode.notebook.onDidChangeCellOutputs);
 		await vscode.commands.executeCommand('notebook.cell.clearOutputs');
 		await clearChangeEvent;
 		assert.strictEqual(cell.outputs.length, 0, 'should clear');
 
-		const secondResource = await createRandomFile('', undefined, 'second', '.vsctestnb');
+		const secondResource = await createRandomFile('', undefined, '.vsctestnb');
 		await vscode.commands.executeCommand('vscode.openWith', secondResource, 'notebookCoreTest');
 
 		await withEvent<vscode.NotebookCellOutputsChangeEvent>(vscode.notebook.onDidChangeCellOutputs, async (event) => {
@@ -1069,13 +1002,13 @@ suite('notebook workflow', () => {
 
 	test('cell execute and select kernel', async () => {
 		assertInitalState();
-		const resource = await createRandomFile('', undefined, 'first', '.vsctestnb');
+		const resource = await createRandomFile('', undefined, '.vsctestnb');
 		await vscode.commands.executeCommand('vscode.openWith', resource, 'notebookCoreTest');
 		assert.strictEqual(vscode.window.activeNotebookEditor !== undefined, true, 'notebook first');
 		const editor = vscode.window.activeNotebookEditor!;
 		const cell = editor.document.cells[0];
 
-		const metadataChangeEvent = getEventOncePromise<vscode.NotebookDocumentMetadataChangeEvent>(vscode.notebook.onDidChangeNotebookDocumentMetadata);
+		const metadataChangeEvent = asPromise<vscode.NotebookDocumentMetadataChangeEvent>(vscode.notebook.onDidChangeNotebookDocumentMetadata);
 		updateNotebookMetadata(editor.document.uri, { ...editor.document.metadata, runnable: true });
 		await metadataChangeEvent;
 
@@ -1087,7 +1020,7 @@ suite('notebook workflow', () => {
 			'my output'
 		]);
 
-		await vscode.commands.executeCommand('notebook.selectKernel', { extension: 'vscode.vscode-notebook-tests', id: 'secondaryKernel' });
+		await vscode.commands.executeCommand('notebook.selectKernel', { extension: 'vscode.vscode-api-tests', id: 'secondaryKernel' });
 		await vscode.commands.executeCommand('notebook.cell.execute');
 		assert.strictEqual(cell.outputs.length, 1, 'should execute'); // runnable, it worked
 		assert.strictEqual(cell.outputs[0].outputs.length, 1);
@@ -1099,12 +1032,12 @@ suite('notebook workflow', () => {
 		await vscode.commands.executeCommand('workbench.action.files.save');
 		await vscode.commands.executeCommand('workbench.action.closeActiveEditor');
 	});
-});
+	// });
 
-suite('notebook dirty state', () => {
+	// suite('notebook dirty state', () => {
 	test('notebook open', async function () {
 		assertInitalState();
-		const resource = await createRandomFile('', undefined, 'first', '.vsctestnb');
+		const resource = await createRandomFile('', undefined, '.vsctestnb');
 		await vscode.commands.executeCommand('vscode.openWith', resource, 'notebookCoreTest');
 		assert.strictEqual(vscode.window.activeNotebookEditor !== undefined, true, 'notebook first');
 		assert.strictEqual(vscode.window.activeNotebookEditor!.selection?.document.getText(), 'test');
@@ -1133,12 +1066,12 @@ suite('notebook dirty state', () => {
 
 		await saveFileAndCloseAll(resource);
 	});
-});
+	// });
 
-suite('notebook undo redo', () => {
+	// suite('notebook undo redo', () => {
 	test('notebook open', async function () {
 		assertInitalState();
-		const resource = await createRandomFile('', undefined, 'first', '.vsctestnb');
+		const resource = await createRandomFile('', undefined, '.vsctestnb');
 		await vscode.commands.executeCommand('vscode.openWith', resource, 'notebookCoreTest');
 		assert.strictEqual(vscode.window.activeNotebookEditor !== undefined, true, 'notebook first');
 		assert.strictEqual(vscode.window.activeNotebookEditor!.selection?.document.getText(), 'test');
@@ -1181,7 +1114,7 @@ suite('notebook undo redo', () => {
 
 	// test.skip('execute and then undo redo', async function () {
 	// 	assertInitalState();
-	// 	const resource = await createRandomFile('', undefined, 'first', '.vsctestnb');
+	// 	const resource = await createRandomFile('', undefined, '.vsctestnb');
 	// 	await vscode.commands.executeCommand('vscode.openWith', resource, 'notebookCoreTest');
 
 	// 	const cellsChangeEvent = getEventOncePromise<vscode.NotebookCellsChangeEvent>(vscode.notebook.onDidChangeNotebookCells);
@@ -1242,11 +1175,11 @@ suite('notebook undo redo', () => {
 	// 	await saveFileAndCloseAll(resource);
 	// });
 
-});
+	// });
 
-suite('notebook working copy', () => {
+	// suite('notebook working copy', () => {
 	// test('notebook revert on close', async function () {
-	// 	const resource = await createRandomFile('', undefined, 'first', '.vsctestnb');
+	// 	const resource = await createRandomFile('', undefined, '.vsctestnb');
 	// 	await vscode.commands.executeCommand('vscode.openWith', resource, 'notebookCoreTest');
 	// 	await vscode.commands.executeCommand('notebook.cell.insertCodeCellBelow');
 	// 	assert.strictEqual(vscode.window.activeNotebookEditor!.selection?.document.getText(), '');
@@ -1267,7 +1200,7 @@ suite('notebook working copy', () => {
 	// });
 
 	// test('notebook revert', async function () {
-	// 	const resource = await createRandomFile('', undefined, 'first', '.vsctestnb');
+	// 	const resource = await createRandomFile('', undefined, '.vsctestnb');
 	// 	await vscode.commands.executeCommand('vscode.openWith', resource, 'notebookCoreTest');
 	// 	await vscode.commands.executeCommand('notebook.cell.insertCodeCellBelow');
 	// 	assert.strictEqual(vscode.window.activeNotebookEditor!.selection?.document.getText(), '');
@@ -1288,7 +1221,7 @@ suite('notebook working copy', () => {
 
 	test('multiple tabs: dirty + clean', async function () {
 		assertInitalState();
-		const resource = await createRandomFile('', undefined, 'first', '.vsctestnb');
+		const resource = await createRandomFile('', undefined, '.vsctestnb');
 		await vscode.commands.executeCommand('vscode.openWith', resource, 'notebookCoreTest');
 		await vscode.commands.executeCommand('notebook.cell.insertCodeCellBelow');
 		assert.strictEqual(vscode.window.activeNotebookEditor!.selection?.document.getText(), '');
@@ -1298,7 +1231,7 @@ suite('notebook working copy', () => {
 		edit.insert(vscode.window.activeNotebookEditor!.selection!.uri, new vscode.Position(0, 0), 'var abc = 0;');
 		await vscode.workspace.applyEdit(edit);
 
-		const secondResource = await createRandomFile('', undefined, 'second', '.vsctestnb');
+		const secondResource = await createRandomFile('', undefined, '.vsctestnb');
 		await vscode.commands.executeCommand('vscode.openWith', secondResource, 'notebookCoreTest');
 		await vscode.commands.executeCommand('workbench.action.closeActiveEditor');
 
@@ -1314,7 +1247,7 @@ suite('notebook working copy', () => {
 
 	test('multiple tabs: two dirty tabs and switching', async function () {
 		assertInitalState();
-		const resource = await createRandomFile('', undefined, 'first', '.vsctestnb');
+		const resource = await createRandomFile('', undefined, '.vsctestnb');
 		await vscode.commands.executeCommand('vscode.openWith', resource, 'notebookCoreTest');
 		await vscode.commands.executeCommand('notebook.cell.insertCodeCellBelow');
 		assert.strictEqual(vscode.window.activeNotebookEditor!.selection?.document.getText(), '');
@@ -1324,7 +1257,7 @@ suite('notebook working copy', () => {
 		edit.insert(vscode.window.activeNotebookEditor!.selection!.uri, new vscode.Position(0, 0), 'var abc = 0;');
 		await vscode.workspace.applyEdit(edit);
 
-		const secondResource = await createRandomFile('', undefined, 'second', '.vsctestnb');
+		const secondResource = await createRandomFile('', undefined, '.vsctestnb');
 		await vscode.commands.executeCommand('vscode.openWith', secondResource, 'notebookCoreTest');
 		await vscode.commands.executeCommand('notebook.cell.insertCodeCellBelow');
 		assert.strictEqual(vscode.window.activeNotebookEditor!.selection?.document.getText(), '');
@@ -1353,7 +1286,7 @@ suite('notebook working copy', () => {
 	test('multiple tabs: different editors with same document', async function () {
 		assertInitalState();
 
-		const resource = await createRandomFile('', undefined, 'first', '.vsctestnb');
+		const resource = await createRandomFile('', undefined, '.vsctestnb');
 		await vscode.commands.executeCommand('vscode.openWith', resource, 'notebookCoreTest');
 		const firstNotebookEditor = vscode.window.activeNotebookEditor;
 		assert.strictEqual(firstNotebookEditor !== undefined, true, 'notebook first');
@@ -1375,12 +1308,12 @@ suite('notebook working copy', () => {
 		// await vscode.commands.executeCommand('workbench.action.files.saveAll');
 		// await vscode.commands.executeCommand('workbench.action.closeAllEditors');
 	});
-});
+	// });
 
-suite('metadata', () => {
+	// suite('metadata', () => {
 	test('custom metadata should be supported', async function () {
 		assertInitalState();
-		const resource = await createRandomFile('', undefined, 'first', '.vsctestnb');
+		const resource = await createRandomFile('', undefined, '.vsctestnb');
 		await vscode.commands.executeCommand('vscode.openWith', resource, 'notebookCoreTest');
 		assert.strictEqual(vscode.window.activeNotebookEditor !== undefined, true, 'notebook first');
 		assert.strictEqual(vscode.window.activeNotebookEditor!.document.metadata.custom!['testMetadata'] as boolean, false);
@@ -1394,7 +1327,7 @@ suite('metadata', () => {
 	// TODO@rebornix skip as it crashes the process all the time
 	test.skip('custom metadata should be supported 2', async function () {
 		assertInitalState();
-		const resource = await createRandomFile('', undefined, 'first', '.vsctestnb');
+		const resource = await createRandomFile('', undefined, '.vsctestnb');
 		await vscode.commands.executeCommand('vscode.openWith', resource, 'notebookCoreTest');
 		assert.strictEqual(vscode.window.activeNotebookEditor !== undefined, true, 'notebook first');
 		assert.strictEqual(vscode.window.activeNotebookEditor!.document.metadata.custom!['testMetadata'] as boolean, false);
@@ -1409,9 +1342,9 @@ suite('metadata', () => {
 
 		await saveFileAndCloseAll(resource);
 	});
-});
+	// });
 
-suite('regression', () => {
+	// suite('regression', () => {
 	// test('microsoft/vscode-github-issue-notebooks#26. Insert template cell in the new empty document', async function () {
 	// 	assertInitalState();
 	// 	await vscode.commands.executeCommand('workbench.action.files.newUntitledFile', { "viewType": "notebookCoreTest" });
@@ -1423,7 +1356,7 @@ suite('regression', () => {
 
 	test('#106657. Opening a notebook from markers view is broken ', async function () {
 		assertInitalState();
-		const resource = await createRandomFile('', undefined, 'first', '.vsctestnb');
+		const resource = await createRandomFile('', undefined, '.vsctestnb');
 		await vscode.commands.executeCommand('vscode.openWith', resource, 'notebookCoreTest');
 
 		const document = vscode.window.activeNotebookEditor?.document!;
@@ -1441,7 +1374,7 @@ suite('regression', () => {
 
 	test.skip('Cannot open notebook from cell-uri with vscode.open-command', async function () {
 		assertInitalState();
-		const resource = await createRandomFile('', undefined, 'first', '.vsctestnb');
+		const resource = await createRandomFile('', undefined, '.vsctestnb');
 		await vscode.commands.executeCommand('vscode.openWith', resource, 'notebookCoreTest');
 
 		const document = vscode.window.activeNotebookEditor?.document!;
@@ -1459,7 +1392,7 @@ suite('regression', () => {
 
 	test('#97830, #97764. Support switch to other editor types', async function () {
 		assertInitalState();
-		const resource = await createRandomFile('', undefined, 'empty', '.vsctestnb');
+		const resource = await createRandomFile('', undefined, '.vsctestnb');
 		await vscode.commands.executeCommand('vscode.openWith', resource, 'notebookCoreTest');
 		await vscode.commands.executeCommand('notebook.cell.insertCodeCellBelow');
 		const edit = new vscode.WorkspaceEdit();
@@ -1469,12 +1402,9 @@ suite('regression', () => {
 		assert.strictEqual(vscode.window.activeNotebookEditor !== undefined, true, 'notebook first');
 		assert.strictEqual(vscode.window.activeNotebookEditor!.selection?.document.getText(), 'var abc = 0;');
 
-		// todo@jrieken enforce a kernel (how) and test that its language is picked
-		// assert.strictEqual(vscode.window.activeNotebookEditor!.selection?.language, 'typescript');
-
 		// no kernel -> no default language
 		assert.strictEqual(vscode.window.activeNotebookEditor!.kernel, undefined);
-		assert.strictEqual(vscode.window.activeNotebookEditor!.selection?.language, 'plaintext');
+		assert.strictEqual(vscode.window.activeNotebookEditor!.selection?.language, 'typescript');
 
 		await vscode.commands.executeCommand('vscode.openWith', resource, 'default');
 		assert.strictEqual(vscode.window.activeTextEditor?.document.uri.path, resource.path);
@@ -1485,7 +1415,7 @@ suite('regression', () => {
 	// open text editor, pin, and then open a notebook
 	test('#96105 - dirty editors', async function () {
 		assertInitalState();
-		const resource = await createRandomFile('', undefined, 'empty', '.vsctestnb');
+		const resource = await createRandomFile('', undefined, '.vsctestnb');
 		await vscode.commands.executeCommand('vscode.openWith', resource, 'default');
 		const edit = new vscode.WorkspaceEdit();
 		edit.insert(resource, new vscode.Position(0, 0), 'var abc = 0;');
@@ -1509,7 +1439,7 @@ suite('regression', () => {
 
 	test('#102423 - copy/paste shares the same text buffer', async function () {
 		assertInitalState();
-		const resource = await createRandomFile('', undefined, 'first', '.vsctestnb');
+		const resource = await createRandomFile('', undefined, '.vsctestnb');
 		await vscode.commands.executeCommand('vscode.openWith', resource, 'notebookCoreTest');
 
 		let activeCell = vscode.window.activeNotebookEditor!.selection;
@@ -1530,16 +1460,16 @@ suite('regression', () => {
 
 		await vscode.commands.executeCommand('workbench.action.closeAllEditors');
 	});
-});
+	// });
 
-suite('webview', () => {
+	// suite('webview', () => {
 	// for web, `asWebUri` gets `https`?
 	// test('asWebviewUri', async function () {
 	// 	if (vscode.env.uiKind === vscode.UIKind.Web) {
 	// 		return;
 	// 	}
 
-	// 	const resource = await createRandomFile('', undefined, 'first', '.vsctestnb');
+	// 	const resource = await createRandomFile('', undefined, '.vsctestnb');
 	// 	await vscode.commands.executeCommand('vscode.openWith', resource, 'notebookCoreTest');
 	// 	assert.strictEqual(vscode.window.activeNotebookEditor !== undefined, true, 'notebook first');
 	// 	const uri = vscode.window.activeNotebookEditor!.asWebviewUri(vscode.Uri.file('./hello.png'));

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

@@ -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');
 }

extensions/vscode-notebook-tests/package.json

@@ -34,16 +34,6 @@
       }
     ],
     "notebookProvider": [
-      {
-        "viewType": "notebookCoreTest",
-        "displayName": "Notebook Core Test",
-        "selector": [
-          {
-            "filenamePattern": "*.vsctestnb",
-            "excludeFileNamePattern": ""
-          }
-        ]
-      },
       {
         "viewType": "notebookSmokeTest",
         "displayName": "Notebook Smoke Test",

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

@@ -9,128 +9,6 @@ import { smokeTestActivate } from './notebookSmokeTestMain';
 export function activate(context: vscode.ExtensionContext): any {
 	smokeTestActivate(context);
 
-	context.subscriptions.push(vscode.notebook.registerNotebookContentProvider('notebookCoreTest', {
-		openNotebook: async (_resource: vscode.Uri): Promise<vscode.NotebookData> => {
-			if (/.*empty\-.*\.vsctestnb$/.test(_resource.path)) {
-				return {
-					metadata: {},
-					cells: []
-				};
-			}
 
-			const dto: vscode.NotebookData = {
-				metadata: {
-					custom: { testMetadata: false }
-				},
-				cells: [
-					{
-						source: 'test',
-						language: 'typescript',
-						cellKind: vscode.NotebookCellKind.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 = {
-		id: 'mainKernel',
-		label: 'Notebook Test Kernel',
-		isPreferred: true,
-		supportedLanguages: ['typescript'],
-		executeAllCells: async (_document: vscode.NotebookDocument) => {
-			const edit = new vscode.WorkspaceEdit();
-
-			edit.replaceNotebookCellOutput(_document.uri, 0, [new vscode.NotebookCellOutput([
-				new vscode.NotebookCellOutputItem('text/plain', ['my output'], undefined)
-			])]);
-			return vscode.workspace.applyEdit(edit);
-		},
-		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')) {
-				const edit = new vscode.WorkspaceEdit();
-				edit.replaceNotebookCellOutput(document.uri, cell.index, [new vscode.NotebookCellOutput([
-					new vscode.NotebookCellOutputItem('text/custom', ['test'], undefined)
-				])]);
-
-				return vscode.workspace.applyEdit(edit);
-			}
-
-			const edit = new vscode.WorkspaceEdit();
-			// const previousOutputs = cell.outputs;
-			edit.replaceNotebookCellOutput(document.uri, cell.index, [new vscode.NotebookCellOutput([
-				new vscode.NotebookCellOutputItem('text/plain', ['my output'], undefined)
-			])]);
-
-			return vscode.workspace.applyEdit(edit);
-		},
-		cancelCellExecution: async (_document: vscode.NotebookDocument, _cell: vscode.NotebookCell) => { }
-	};
-
-	const kernel2: vscode.NotebookKernel = {
-		id: 'secondaryKernel',
-		label: 'Notebook Secondary Test Kernel',
-		isPreferred: false,
-		supportedLanguages: ['typescript'],
-		executeAllCells: async (_document: vscode.NotebookDocument) => {
-			const edit = new vscode.WorkspaceEdit();
-			edit.replaceNotebookCellOutput(_document.uri, 0, [new vscode.NotebookCellOutput([
-				new vscode.NotebookCellOutputItem('text/plain', ['my second output'], undefined)
-			])]);
-
-			return vscode.workspace.applyEdit(edit);
-		},
-		cancelAllCellsExecution: async (_document: vscode.NotebookDocument) => { },
-		executeCell: async (document: vscode.NotebookDocument, cell: vscode.NotebookCell | undefined) => {
-			if (!cell) {
-				cell = document.cells[0];
-			}
-
-			const edit = new vscode.WorkspaceEdit();
-
-			if (document.uri.path.endsWith('customRenderer.vsctestnb')) {
-				edit.replaceNotebookCellOutput(document.uri, cell.index, [new vscode.NotebookCellOutput([
-					new vscode.NotebookCellOutputItem('text/custom', ['test 2'], undefined)
-				])]);
-			} else {
-				edit.replaceNotebookCellOutput(document.uri, cell.index, [new vscode.NotebookCellOutput([
-					new vscode.NotebookCellOutputItem('text/plain', ['my second output'], undefined)
-				])]);
-			}
-
-			return vscode.workspace.applyEdit(edit);
-		},
-		cancelCellExecution: async (_document: vscode.NotebookDocument, _cell: vscode.NotebookCell) => { }
-	};
-
-	context.subscriptions.push(vscode.notebook.registerNotebookKernelProvider({ filenamePattern: '*.vsctestnb' }, {
-		provideKernels: async () => {
-			return [kernel, kernel2];
-		}
-	}));
 }

src/vs/workbench/api/browser/mainThreadNotebook.ts

@@ -10,7 +10,8 @@ import { Emitter } from 'vs/base/common/event';
 import { IRelativePattern } from 'vs/base/common/glob';
 import { combinedDisposable, Disposable, DisposableStore, dispose, IDisposable, IReference } from 'vs/base/common/lifecycle';
 import { ResourceMap } from 'vs/base/common/map';
-import { IExtUri } from 'vs/base/common/resources';
+import { Schemas } from 'vs/base/common/network';
+import { IExtUri, isEqual } from 'vs/base/common/resources';
 import { URI, UriComponents } from 'vs/base/common/uri';
 import { IAccessibilityService } from 'vs/platform/accessibility/common/accessibility';
 import { IConfigurationService } from 'vs/platform/configuration/common/configuration';
@@ -30,6 +31,7 @@ import { IEditorGroup, IEditorGroupsService, preferredSideBySideGroupDirection }
 import { openEditorWith } from 'vs/workbench/services/editor/common/editorOpenWith';
 import { IEditorService, SIDE_GROUP } from 'vs/workbench/services/editor/common/editorService';
 import { IUriIdentityService } from 'vs/workbench/services/uriIdentity/common/uriIdentity';
+import { IWorkingCopyService } from 'vs/workbench/services/workingCopy/common/workingCopyService';
 import { ExtHostContext, ExtHostNotebookShape, IExtHostContext, INotebookCellStatusBarEntryDto, INotebookDocumentsAndEditorsDelta, INotebookDocumentShowOptions, INotebookModelAddedData, MainContext, MainThreadNotebookShape, NotebookEditorRevealType, NotebookExtensionDescription } from '../common/extHost.protocol';
 
 class DocumentAndEditorState {
@@ -121,6 +123,7 @@ export class MainThreadNotebooks extends Disposable implements MainThreadNoteboo
 
 	constructor(
 		extHostContext: IExtHostContext,
+		@IWorkingCopyService private readonly _workingCopyService: IWorkingCopyService,
 		@INotebookService private _notebookService: INotebookService,
 		@IConfigurationService private readonly _configurationService: IConfigurationService,
 		@IEditorService private readonly _editorService: IEditorService,
@@ -202,6 +205,22 @@ export class MainThreadNotebooks extends Disposable implements MainThreadNoteboo
 	}
 
 	registerListeners() {
+
+		// forward changes to dirty state
+		// todo@bpasero this seem way too complicated... is there an easy way to
+		// the actual resource from a working copy?
+		this._register(this._workingCopyService.onDidChangeDirty(e => {
+			if (e.resource.scheme !== Schemas.vscodeNotebook) {
+				return;
+			}
+			for (const notebook of this._notebookService.getNotebookTextModels()) {
+				if (isEqual(notebook.uri.with({ scheme: Schemas.vscodeNotebook }), e.resource)) {
+					this._proxy.$acceptDirtyStateChanged(notebook.uri, e.isDirty());
+					break;
+				}
+			}
+		}));
+
 		this._notebookService.listNotebookEditors().forEach((e) => {
 			this._addNotebookEditor(e);
 		});

src/vs/workbench/api/common/extHost.protocol.ts

@@ -1803,6 +1803,7 @@ export interface ExtHostNotebookShape {
 	$acceptNotebookActiveKernelChange(event: { uri: UriComponents, providerHandle: number | undefined, kernelFriendlyId: string | undefined }): void;
 	$onDidReceiveMessage(editorId: string, rendererId: string | undefined, message: unknown): void;
 	$acceptModelChanged(uriComponents: UriComponents, event: NotebookCellsChangedEventDto, isDirty: boolean): void;
+	$acceptDirtyStateChanged(uriComponents: UriComponents, isDirty: boolean): void;
 	$acceptModelSaved(uriComponents: UriComponents): void;
 	$acceptEditorPropertiesChanged(id: string, data: INotebookEditorPropertiesChangeData): void;
 	$acceptDocumentPropertiesChanged(uriComponents: UriComponents, data: INotebookDocumentPropertiesChangeData): void;

src/vs/workbench/api/common/extHostNotebook.ts

@@ -578,7 +578,14 @@ export class ExtHostNotebookController implements ExtHostNotebookShape, ExtHostN
 		}
 	}
 
-	public $acceptModelSaved(uriComponents: UriComponents): void {
+	$acceptDirtyStateChanged(resource: UriComponents, isDirty: boolean): void {
+		const document = this._documents.get(URI.revive(resource));
+		if (document) {
+			document.acceptModelChanged({ rawEvents: [], versionId: document.notebookDocument.version }, isDirty);
+		}
+	}
+
+	$acceptModelSaved(uriComponents: UriComponents): void {
 		const document = this._documents.get(URI.revive(uriComponents));
 		if (document) {
 			// this.$acceptDirtyStateChanged(uriComponents, false);

src/vs/workbench/contrib/notebook/common/notebookEditorModel.ts

@@ -125,6 +125,7 @@ export class NotebookEditorModel extends EditorModel implements INotebookEditorM
 	async revert(options?: IRevertOptions | undefined): Promise<void> {
 		if (options?.soft) {
 			await this._backupFileService.discardBackup(this.resource);
+			this.setDirty(false);
 			return;
 		}