refactor(deepnote): Improve mock child process and server output management

- Enhanced `createMockChildProcess` to provide a more comprehensive mock implementation for testing.
- Updated `DeepnoteServerStarter` to ensure proper disposal of existing disposables when monitoring server output, improving resource management.
- Adjusted error handling in server startup to streamline diagnostics and output tracking.

Author: tkislan

src/kernels/deepnote/deepnoteServerStarter.node.ts

@@ -280,7 +280,7 @@ export class DeepnoteServerStarter implements IDeepnoteServerStarter, IExtension
 
             throw new DeepnoteServerStartupError(
                 interpreter.uri.fsPath,
-                serverInfo?.jupyterPort ?? 0,
+                0,
                 'unknown',
                 capturedOutput?.stdout || '',
                 capturedOutput?.stderr || '',
@@ -402,6 +402,12 @@ export class DeepnoteServerStarter implements IDeepnoteServerStarter, IExtension
      */
     private monitorServerOutput(fileKey: string, serverInfo: DeepnoteServerInfo): void {
         const proc = serverInfo.process;
+        const existing = this.disposablesByFile.get(fileKey);
+        if (existing) {
+            for (const d of existing) {
+                d.dispose();
+            }
+        }
         const disposables: IDisposable[] = [];
         this.disposablesByFile.set(fileKey, disposables);
 

src/kernels/deepnote/deepnoteTestHelpers.node.ts

@@ -5,11 +5,66 @@ import type { ChildProcess } from 'node:child_process';
  * Satisfies the ChildProcess interface with minimal stub values.
  */
 export function createMockChildProcess(overrides?: Partial<ChildProcess>): ChildProcess {
-    return {
+    const mockProcess: ChildProcess = {
         pid: undefined,
+        stdio: [null, null, null, null, null],
+        stdin: null,
         stdout: null,
         stderr: null,
         exitCode: null,
+        killed: false,
+        connected: false,
+        signalCode: null,
+        spawnargs: [],
+        spawnfile: '',
+        kill: () => true,
+        send: () => true,
+        disconnect: () => true,
+        unref: () => true,
+        ref: () => true,
+        addListener: function () {
+            return this;
+        },
+        emit: () => true,
+        on: function () {
+            return this;
+        },
+        once: function () {
+            return this;
+        },
+        removeListener: function () {
+            return this;
+        },
+        removeAllListeners: function () {
+            return this;
+        },
+        prependListener: function () {
+            return this;
+        },
+        prependOnceListener: function () {
+            return this;
+        },
+        [Symbol.dispose]: () => {
+            return undefined;
+        },
+        off: function () {
+            return this;
+        },
+        setMaxListeners: function () {
+            return this;
+        },
+        getMaxListeners: () => 10,
+        listeners: function () {
+            return [];
+        },
+        rawListeners: function () {
+            return [];
+        },
+        eventNames: function () {
+            return [];
+        },
+        listenerCount: () => 0,
         ...overrides
-    } as ChildProcess;
+    };
+    return mockProcess;
 }

src/notebooks/deepnote/deepnoteFileChangeWatcher.unit.test.ts

@@ -1264,7 +1264,6 @@ project:
 
     suite('multi-notebook file sync', () => {
         let workspaceSetCaptures: { uriKey: string; cellSourceJoined: string }[] = [];
-        let workspaceEditSetStub: sinon.SinonStub | undefined;
 
         setup(() => {
             reset(mockedNotebookManager);
@@ -1273,24 +1272,27 @@ project:
             when(mockedNotebookManager.clearNotebookSelection(anything())).thenReturn();
             resetCalls(mockedNotebookManager);
             workspaceSetCaptures = [];
-            workspaceEditSetStub = sinon.stub(WorkspaceEdit.prototype, 'set').callsFake((uri: Uri, edits: unknown) => {
-                if (!Array.isArray(edits) || edits.length === 0) {
-                    return;
-                }
+            when(mockedVSCodeNamespaces.workspace.applyEdit(anything())).thenCall((wsEdit: WorkspaceEdit) => {
+                applyEditCount++;
+
+                const ext = wsEdit as WorkspaceEdit & { notebookEntries(): [Uri, NotebookEdit[]][] };
 
-                const firstEdit = edits[0] as NotebookEdit;
-                if (firstEdit?.newCells && firstEdit.newCells.length > 0) {
-                    workspaceSetCaptures.push({
-                        uriKey: uri.toString(),
-                        cellSourceJoined: firstEdit.newCells.map((c) => c.value).join('\n')
-                    });
+                for (const [uri, edits] of ext.notebookEntries()) {
+                    if (!edits.length) {
+                        continue;
+                    }
+
+                    const firstEdit = edits[0];
+                    if (firstEdit?.newCells && firstEdit.newCells.length > 0) {
+                        workspaceSetCaptures.push({
+                            uriKey: uri.toString(),
+                            cellSourceJoined: firstEdit.newCells.map((c) => c.value).join('\n')
+                        });
+                    }
                 }
-            });
-        });
 
-        teardown(() => {
-            workspaceEditSetStub?.restore();
-            workspaceEditSetStub = undefined;
+                return Promise.resolve(true);
+            });
         });
 
         test('should reload each notebook with its own content when multiple notebooks are open', async () => {

src/test/mocks/vsc/extHostedTypes.ts

@@ -707,6 +707,7 @@ export namespace vscMockExtHostedTypes {
         private _seqPool: number = 0;
 
         private _resourceEdits: { seq: number; from: vscUri.URI; to: vscUri.URI }[] = [];
+        private _notebookEdits = new Map<string, { uri: vscUri.URI; edits: NotebookEdit[] }>();
         private _textEdits = new Map<string, { seq: number; uri: vscUri.URI; edits: TextEdit[] }>();
 
         // createResource(uri: vscode.Uri): void {
@@ -759,7 +760,20 @@ export namespace vscMockExtHostedTypes {
         }
 
         has(uri: vscUri.URI): boolean {
-            return this._textEdits.has(uri.toString());
+            return this._textEdits.has(uri.toString()) || this._notebookEdits.has(uri.toString());
+        }
+
+        /**
+         * Notebook edits passed to {@link set} (for tests that inspect edits via workspace.applyEdit).
+         */
+        notebookEntries(): [vscUri.URI, NotebookEdit[]][] {
+            const res: [vscUri.URI, NotebookEdit[]][] = [];
+
+            this._notebookEdits.forEach((value) => {
+                res.push([value.uri, value.edits.slice()]);
+            });
+
+            return res.slice();
         }
 
         set(uri: vscode.Uri, edits: NotebookEdit[]): void;
@@ -779,17 +793,54 @@ export namespace vscMockExtHostedTypes {
                       | [TextEdit | SnippetTextEdit, vscode.WorkspaceEditEntryMetadata]
                   )[]
         ): void {
-            let data = this._textEdits.get(uri.toString());
+            const uriKey = uri.toString();
+
+            if (!edits) {
+                const data = this._textEdits.get(uriKey);
+                if (data) {
+                    // @ts-ignore
+                    data.edits = undefined;
+                }
+                this._notebookEdits.delete(uriKey);
+
+                return;
+            }
+
+            if (edits.length === 0) {
+                let data = this._textEdits.get(uriKey);
+                if (!data) {
+                    data = { seq: this._seqPool++, uri, edits: [] };
+                    this._textEdits.set(uriKey, data);
+                }
+                data.edits = [];
+
+                return;
+            }
+
+            const first = edits[0];
+            const firstEdit = Array.isArray(first) ? first[0] : first;
+
+            if (firstEdit instanceof NotebookEdit) {
+                const normalized: NotebookEdit[] = edits.map((item) => {
+                    if (Array.isArray(item)) {
+                        return item[0] as NotebookEdit;
+                    }
+
+                    return item as NotebookEdit;
+                });
+
+                this._notebookEdits.set(uriKey, { uri, edits: normalized });
+
+                return;
+            }
+
+            let data = this._textEdits.get(uriKey);
             if (!data) {
                 data = { seq: this._seqPool++, uri, edits: [] };
-                this._textEdits.set(uri.toString(), data);
-            }
-            if (!edits) {
-                // @ts-ignore
-                data.edits = undefined;
-            } else {
-                //data.edits = edits.slice(0);
+                this._textEdits.set(uriKey, data);
             }
+
+            data.edits = edits.slice(0) as TextEdit[];
         }
 
         get(uri: vscUri.URI): TextEdit[] {
@@ -825,7 +876,7 @@ export namespace vscMockExtHostedTypes {
         }
 
         get size(): number {
-            return this._textEdits.size + this._resourceEdits.length;
+            return this._textEdits.size + this._notebookEdits.size + this._resourceEdits.length;
         }
 
         toJSON(): any {