debt: adopt ensureNoDisposablesAreLeakedInTestSuite (#192226)

Finishes adoption in test I own

Author: connor4312

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

@@ -606,6 +606,11 @@ class TestRunTracker extends Disposable {
 
 		this.proxy.$addTestsToRun(this.dto.controllerId, this.dto.id, chain);
 	}
+
+	public override dispose(): void {
+		this.markEnded();
+		super.dispose();
+	}
 }
 
 /**
@@ -676,7 +681,7 @@ export class TestRunCoordinator {
 		});
 
 		const tracker = this.getTracker(request, dto, extension);
-		tracker.onEnd(() => {
+		Event.once(tracker.onEnd)(() => {
 			this.proxy.$finishedExtensionTestRun(dto.id);
 			tracker.dispose();
 		});
@@ -687,7 +692,7 @@ export class TestRunCoordinator {
 	private getTracker(req: vscode.TestRunRequest, dto: TestRunDto, extension: IRelaxedExtensionDescription, token?: CancellationToken) {
 		const tracker = new TestRunTracker(dto, this.proxy, extension, token);
 		this.tracked.set(req, tracker);
-		tracker.onEnd(() => this.tracked.delete(req));
+		Event.once(tracker.onEnd)(() => this.tracked.delete(req));
 		return tracker;
 	}
 }

src/vs/workbench/api/test/browser/extHostTesting.test.ts

@@ -10,6 +10,7 @@ import { CancellationTokenSource } from 'vs/base/common/cancellation';
 import { Iterable } from 'vs/base/common/iterator';
 import { URI } from 'vs/base/common/uri';
 import { mockObject, MockObject } from 'vs/base/test/common/mock';
+import { ensureNoDisposablesAreLeakedInTestSuite } from 'vs/base/test/common/utils';
 import * as editorRange from 'vs/editor/common/core/range';
 import { IRelaxedExtensionDescription } from 'vs/platform/extensions/common/extensions';
 import { MainThreadTestingShape } from 'vs/workbench/api/common/extHost.protocol';
@@ -71,11 +72,17 @@ suite('ExtHost Testing', () => {
 		}
 	}
 
+	teardown(() => {
+		sinon.restore();
+	});
+
+	const ds = ensureNoDisposablesAreLeakedInTestSuite();
+
 	let single: TestExtHostTestItemCollection;
 	setup(() => {
-		single = new TestExtHostTestItemCollection('ctrlId', 'root', {
+		single = ds.add(new TestExtHostTestItemCollection('ctrlId', 'root', {
 			getDocument: () => undefined,
-		} as Partial<ExtHostDocumentsAndEditors> as ExtHostDocumentsAndEditors);
+		} as Partial<ExtHostDocumentsAndEditors> as ExtHostDocumentsAndEditors));
 		single.resolveHandler = item => {
 			if (item === undefined) {
 				const a = new TestItemImpl('ctrlId', 'id-a', 'a', URI.file('/'));
@@ -89,12 +96,7 @@ suite('ExtHost Testing', () => {
 			}
 		};
 
-		single.onDidGenerateDiff(d => single.setDiff(d /* don't clear during testing */));
-	});
-
-	teardown(() => {
-		single.dispose();
-		sinon.restore();
+		ds.add(single.onDidGenerateDiff(d => single.setDiff(d /* don't clear during testing */)));
 	});
 
 	suite('OwnedTestCollection', () => {
@@ -623,7 +625,7 @@ suite('ExtHost Testing', () => {
 		});
 
 		test('tracks a run started from a main thread request', () => {
-			const tracker = c.prepareForMainThreadTestRun(req, dto, ext, cts.token);
+			const tracker = ds.add(c.prepareForMainThreadTestRun(req, dto, ext, cts.token));
 			assert.strictEqual(tracker.hasRunningTasks, false);
 
 			const task1 = c.createTestRun(ext, 'ctrl', single, req, 'run1', true);
@@ -648,10 +650,10 @@ suite('ExtHost Testing', () => {
 		test('run cancel force ends after a timeout', () => {
 			const clock = sinon.useFakeTimers();
 			try {
-				const tracker = c.prepareForMainThreadTestRun(req, dto, ext, cts.token);
+				const tracker = ds.add(c.prepareForMainThreadTestRun(req, dto, ext, cts.token));
 				const task = c.createTestRun(ext, 'ctrl', single, req, 'run1', true);
 				const onEnded = sinon.stub();
-				tracker.onEnd(onEnded);
+				ds.add(tracker.onEnd(onEnded));
 
 				assert.strictEqual(task.token.isCancellationRequested, false);
 				assert.strictEqual(tracker.hasRunningTasks, true);
@@ -673,10 +675,10 @@ suite('ExtHost Testing', () => {
 		});
 
 		test('run cancel force ends on second cancellation request', () => {
-			const tracker = c.prepareForMainThreadTestRun(req, dto, ext, cts.token);
+			const tracker = ds.add(c.prepareForMainThreadTestRun(req, dto, ext, cts.token));
 			const task = c.createTestRun(ext, 'ctrl', single, req, 'run1', true);
 			const onEnded = sinon.stub();
-			tracker.onEnd(onEnded);
+			ds.add(tracker.onEnd(onEnded));
 
 			assert.strictEqual(task.token.isCancellationRequested, false);
 			assert.strictEqual(tracker.hasRunningTasks, true);
@@ -753,6 +755,8 @@ suite('ExtHost Testing', () => {
 
 			task1.passed(single.root.children.get('id-a')!.children.get('id-ab')!);
 			assert.deepStrictEqual(proxy.$addTestsToRun.args, expectedArgs);
+
+			task1.end();
 		});
 
 		test('adds test messages to run', () => {
@@ -796,6 +800,8 @@ suite('ExtHost Testing', () => {
 					location: convert.location.from({ uri: test2.uri!, range: test2.range! }),
 				}]
 			]);
+
+			task.end();
 		});
 
 		test('guards calls after runs are ended', () => {
@@ -829,6 +835,7 @@ suite('ExtHost Testing', () => {
 				TestResultState.Passed,
 				undefined,
 			]]);
+			task.end();
 		});
 
 		test('sets state of test with identical local IDs (#131827)', () => {
@@ -856,6 +863,8 @@ suite('ExtHost Testing', () => {
 					[single.root, testB, childB].map(t => convert.TestItem.from(t as TestItemImpl)),
 				],
 			]);
+
+			task1.end();
 		});
 	});
 });

src/vs/workbench/api/test/browser/mainThreadManagedSockets.test.ts

@@ -10,12 +10,15 @@ import { Emitter } from 'vs/base/common/event';
 import { DisposableStore } from 'vs/base/common/lifecycle';
 import { SocketCloseEvent } from 'vs/base/parts/ipc/common/ipc.net';
 import { mock } from 'vs/base/test/common/mock';
+import { ensureNoDisposablesAreLeakedInTestSuite } from 'vs/base/test/common/utils';
 import { RemoteSocketHalf } from 'vs/platform/remote/common/managedSocket';
 import { MainThreadManagedSocket } from 'vs/workbench/api/browser/mainThreadManagedSockets';
 import { ExtHostManagedSocketsShape } from 'vs/workbench/api/common/extHost.protocol';
 
 suite('MainThreadManagedSockets', () => {
 
+	const ds = ensureNoDisposablesAreLeakedInTestSuite();
+
 	suite('ManagedSocket', () => {
 		let extHost: ExtHostMock;
 		let half: RemoteSocketHalf;
@@ -72,7 +75,7 @@ suite('MainThreadManagedSockets', () => {
 			const socket = MainThreadManagedSocket.connect(1, extHost, '/hello', 'world=true', '', half);
 			await extHost.expectEvent(evt => evt.data && evt.data.startsWith('GET ws://localhost/hello?world=true&skipWebSocketFrames=true HTTP/1.1\r\nConnection: Upgrade\r\nUpgrade: websocket\r\nSec-WebSocket-Key:'), 'websocket open event');
 			half.onData.fire(VSBuffer.fromString('Opened successfully ;)\r\n\r\n'));
-			return await socket;
+			return ds.add(await socket);
 		}
 
 		test('connects', async () => {
@@ -83,18 +86,18 @@ suite('MainThreadManagedSockets', () => {
 			const socketProm = MainThreadManagedSocket.connect(1, extHost, '/hello', 'world=true', '', half);
 			await extHost.expectEvent(evt => evt.data && evt.data.includes('GET ws://localhost'), 'websocket open event');
 			half.onData.fire(VSBuffer.fromString('Opened successfully ;)\r\n\r\nSome trailing data'));
-			const socket = await socketProm;
+			const socket = ds.add(await socketProm);
 
 			const data: string[] = [];
-			socket.onData(d => data.push(d.toString()));
+			ds.add(socket.onData(d => data.push(d.toString())));
 			await timeout(1); // allow microtasks to flush
 			assert.deepStrictEqual(data, ['Some trailing data']);
 		});
 
 		test('round trips data', async () => {
 			const socket = await doConnect();
 			const data: string[] = [];
-			socket.onData(d => data.push(d.toString()));
+			ds.add(socket.onData(d => data.push(d.toString())));
 
 			socket.write(VSBuffer.fromString('ping'));
 			await extHost.expectEvent(evt => evt.data === 'ping', 'expected ping');

src/vs/workbench/api/test/browser/mainThreadTreeViews.test.ts

@@ -4,8 +4,8 @@
  *--------------------------------------------------------------------------------------------*/
 
 import * as assert from 'assert';
-import { DisposableStore } from 'vs/base/common/lifecycle';
 import { mock } from 'vs/base/test/common/mock';
+import { ensureNoDisposablesAreLeakedInTestSuite } from 'vs/base/test/common/utils';
 import { SyncDescriptor } from 'vs/platform/instantiation/common/descriptors';
 import { TestInstantiationService } from 'vs/platform/instantiation/test/common/instantiationServiceMock';
 import { NullLogService } from 'vs/platform/log/common/log';
@@ -45,25 +45,29 @@ suite('MainThreadHostTreeView', function () {
 	let container: ViewContainer;
 	let mainThreadTreeViews: MainThreadTreeViews;
 	let extHostTreeViewsShape: MockExtHostTreeViewsShape;
-	let disposables: DisposableStore;
+
+	teardown(() => {
+		ViewsRegistry.deregisterViews(ViewsRegistry.getViews(container), container);
+	});
+
+	const disposables = ensureNoDisposablesAreLeakedInTestSuite();
 
 	setup(async () => {
-		disposables = new DisposableStore();
 		const instantiationService: TestInstantiationService = <TestInstantiationService>workbenchInstantiationService(undefined, disposables);
-		const viewDescriptorService = instantiationService.createInstance(ViewDescriptorService);
+		const viewDescriptorService = disposables.add(instantiationService.createInstance(ViewDescriptorService));
 		instantiationService.stub(IViewDescriptorService, viewDescriptorService);
 		container = Registry.as<IViewContainersRegistry>(Extensions.ViewContainersRegistry).registerViewContainer({ id: 'testContainer', title: { value: 'test', original: 'test' }, ctorDescriptor: new SyncDescriptor(<any>{}) }, ViewContainerLocation.Sidebar);
 		const viewDescriptor: ITreeViewDescriptor = {
 			id: testTreeViewId,
 			ctorDescriptor: null!,
 			name: 'Test View 1',
-			treeView: instantiationService.createInstance(CustomTreeView, 'testTree', 'Test Title', 'extension.id'),
+			treeView: disposables.add(instantiationService.createInstance(CustomTreeView, 'testTree', 'Test Title', 'extension.id')),
 		};
 		ViewsRegistry.registerViews([viewDescriptor], container);
 
 		const testExtensionService = new TestExtensionService();
 		extHostTreeViewsShape = new MockExtHostTreeViewsShape();
-		mainThreadTreeViews = new MainThreadTreeViews(
+		mainThreadTreeViews = disposables.add(new MainThreadTreeViews(
 			new class implements IExtHostContext {
 				remoteAuthority = '';
 				extensionHostKind = ExtensionHostKind.LocalProcess;
@@ -74,16 +78,11 @@ suite('MainThreadHostTreeView', function () {
 					return extHostTreeViewsShape;
 				}
 				drain(): any { return null; }
-			}, new TestViewsService(), new TestNotificationService(), testExtensionService, new NullLogService());
+			}, new TestViewsService(), new TestNotificationService(), testExtensionService, new NullLogService()));
 		mainThreadTreeViews.$registerTreeViewDataProvider(testTreeViewId, { showCollapseAll: false, canSelectMany: false, dropMimeTypes: [], dragMimeTypes: [], hasHandleDrag: false, hasHandleDrop: false, manuallyManageCheckboxes: false });
 		await testExtensionService.whenInstalledExtensionsRegistered();
 	});
 
-	teardown(() => {
-		ViewsRegistry.deregisterViews(ViewsRegistry.getViews(container), container);
-		disposables.dispose();
-	});
-
 	test('getChildren keeps custom properties', async () => {
 		const treeView: ITreeView = (<ITreeViewDescriptor>ViewsRegistry.getView(testTreeViewId)).treeView;
 		const children = await treeView.dataProvider?.getChildren({ handle: 'root', collapsibleState: TreeItemCollapsibleState.Expanded });

src/vs/workbench/contrib/notebook/test/browser/notebookRendererMessagingService.test.ts

@@ -8,17 +8,20 @@ import { stub } from 'sinon';
 import { NotebookRendererMessagingService } from 'vs/workbench/contrib/notebook/browser/services/notebookRendererMessagingServiceImpl';
 import * as assert from 'assert';
 import { timeout } from 'vs/base/common/async';
+import { ensureNoDisposablesAreLeakedInTestSuite } from 'vs/base/test/common/utils';
 
 suite('NotebookRendererMessaging', () => {
 	let extService: NullExtensionService;
 	let m: NotebookRendererMessagingService;
 	let sent: unknown[] = [];
 
+	const ds = ensureNoDisposablesAreLeakedInTestSuite();
+
 	setup(() => {
 		sent = [];
 		extService = new NullExtensionService();
-		m = new NotebookRendererMessagingService(extService);
-		m.onShouldPostMessage(e => sent.push(e));
+		m = ds.add(new NotebookRendererMessagingService(extService));
+		ds.add(m.onShouldPostMessage(e => sent.push(e)));
 	});
 
 	test('activates on prepare', () => {