Book a Demo!
CoCalc Logo Icon
StoreFeaturesDocsShareSupportNewsAboutPoliciesSign UpSign In
microsoft
GitHub Repository: microsoft/vscode
 Path: blob/main/src/vs/workbench/services/extensions/test/browser/extensionService.test.ts
5251 views
1
/*---------------------------------------------------------------------------------------------

2
 *  Copyright (c) Microsoft Corporation. All rights reserved.

3
 *  Licensed under the MIT License. See License.txt in the project root for license information.

4
 *--------------------------------------------------------------------------------------------*/

5


6
import assert from 'assert';

7
import { Event } from '../../../../../base/common/event.js';

8
import { DisposableStore } from '../../../../../base/common/lifecycle.js';

9
import { mock } from '../../../../../base/test/common/mock.js';

10
import { ensureNoDisposablesAreLeakedInTestSuite } from '../../../../../base/test/common/utils.js';

11
import { IConfigurationService } from '../../../../../platform/configuration/common/configuration.js';

12
import { TestConfigurationService } from '../../../../../platform/configuration/test/common/testConfigurationService.js';

13
import { TestDialogService } from '../../../../../platform/dialogs/test/common/testDialogService.js';

14
import { ExtensionKind, IEnvironmentService } from '../../../../../platform/environment/common/environment.js';

15
import { ExtensionIdentifier, IExtension, IExtensionDescription } from '../../../../../platform/extensions/common/extensions.js';

16
import { IFileService } from '../../../../../platform/files/common/files.js';

17
import { IInstantiationService } from '../../../../../platform/instantiation/common/instantiation.js';

18
import { TestInstantiationService, createServices } from '../../../../../platform/instantiation/test/common/instantiationServiceMock.js';

19
import { ILogService, NullLogService } from '../../../../../platform/log/common/log.js';

20
import { INotificationService } from '../../../../../platform/notification/common/notification.js';

21
import { TestNotificationService } from '../../../../../platform/notification/test/common/testNotificationService.js';

22
import product from '../../../../../platform/product/common/product.js';

23
import { IProductService } from '../../../../../platform/product/common/productService.js';

24
import { RemoteAuthorityResolverService } from '../../../../../platform/remote/browser/remoteAuthorityResolverService.js';

25
import { IRemoteAuthorityResolverService, ResolverResult } from '../../../../../platform/remote/common/remoteAuthorityResolver.js';

26
import { IRemoteExtensionsScannerService } from '../../../../../platform/remote/common/remoteExtensionsScanner.js';

27
import { ITelemetryService } from '../../../../../platform/telemetry/common/telemetry.js';

28
import { NullTelemetryService } from '../../../../../platform/telemetry/common/telemetryUtils.js';

29
import { IUriIdentityService } from '../../../../../platform/uriIdentity/common/uriIdentity.js';

30
import { UriIdentityService } from '../../../../../platform/uriIdentity/common/uriIdentityService.js';

31
import { IUserDataProfilesService, UserDataProfilesService } from '../../../../../platform/userDataProfile/common/userDataProfile.js';

32
import { IWorkspaceContextService } from '../../../../../platform/workspace/common/workspace.js';

33
import { IWorkspaceTrustEnablementService } from '../../../../../platform/workspace/common/workspaceTrust.js';

34
import { IWorkbenchEnvironmentService } from '../../../environment/common/environmentService.js';

35
import { IWebExtensionsScannerService, IWorkbenchExtensionEnablementService, IWorkbenchExtensionManagementService } from '../../../extensionManagement/common/extensionManagement.js';

36
import { BrowserExtensionHostKindPicker } from '../../browser/extensionService.js';

37
import { AbstractExtensionService, IExtensionHostFactory, ResolvedExtensions } from '../../common/abstractExtensionService.js';

38
import { ExtensionHostKind, ExtensionRunningPreference } from '../../common/extensionHostKind.js';

39
import { IExtensionHostManager } from '../../common/extensionHostManagers.js';

40
import { ExtensionManifestPropertiesService, IExtensionManifestPropertiesService } from '../../common/extensionManifestPropertiesService.js';

41
import { ExtensionRunningLocation } from '../../common/extensionRunningLocation.js';

42
import { ExtensionRunningLocationTracker } from '../../common/extensionRunningLocationTracker.js';

43
import { ActivationKind, IExtensionHost, IExtensionService, IWillActivateEvent } from '../../common/extensions.js';

44
import { ExtensionsProposedApi } from '../../common/extensionsProposedApi.js';

45
import { ILifecycleService } from '../../../lifecycle/common/lifecycle.js';

46
import { IRemoteAgentService } from '../../../remote/common/remoteAgentService.js';

47
import { IUserDataProfileService } from '../../../userDataProfile/common/userDataProfile.js';

48
import { WorkspaceTrustEnablementService } from '../../../workspaces/common/workspaceTrust.js';

49
import { TestEnvironmentService, TestLifecycleService, TestRemoteAgentService, TestRemoteExtensionsScannerService, TestWebExtensionsScannerService, TestWorkbenchExtensionEnablementService, TestWorkbenchExtensionManagementService } from '../../../../test/browser/workbenchTestServices.js';

50
import { TestContextService, TestFileService, TestUserDataProfileService } from '../../../../test/common/workbenchTestServices.js';

51


52
suite('BrowserExtensionService', () => {

53


54
	ensureNoDisposablesAreLeakedInTestSuite();

55


56
	test('pickRunningLocation', () => {

57
		assert.deepStrictEqual(BrowserExtensionHostKindPicker.pickRunningLocation([], false, false, ExtensionRunningPreference.None), null);

58
		assert.deepStrictEqual(BrowserExtensionHostKindPicker.pickRunningLocation([], false, true, ExtensionRunningPreference.None), null);

59
		assert.deepStrictEqual(BrowserExtensionHostKindPicker.pickRunningLocation([], true, false, ExtensionRunningPreference.None), null);

60
		assert.deepStrictEqual(BrowserExtensionHostKindPicker.pickRunningLocation([], true, true, ExtensionRunningPreference.None), null);

61


62
		assert.deepStrictEqual(BrowserExtensionHostKindPicker.pickRunningLocation(['ui'], false, false, ExtensionRunningPreference.None), null);

63
		assert.deepStrictEqual(BrowserExtensionHostKindPicker.pickRunningLocation(['ui'], false, true, ExtensionRunningPreference.None), ExtensionHostKind.Remote);

64
		assert.deepStrictEqual(BrowserExtensionHostKindPicker.pickRunningLocation(['ui'], true, false, ExtensionRunningPreference.None), null);

65
		assert.deepStrictEqual(BrowserExtensionHostKindPicker.pickRunningLocation(['ui'], true, true, ExtensionRunningPreference.None), ExtensionHostKind.Remote);

66


67
		assert.deepStrictEqual(BrowserExtensionHostKindPicker.pickRunningLocation(['workspace'], false, false, ExtensionRunningPreference.None), null);

68
		assert.deepStrictEqual(BrowserExtensionHostKindPicker.pickRunningLocation(['workspace'], false, true, ExtensionRunningPreference.None), ExtensionHostKind.Remote);

69
		assert.deepStrictEqual(BrowserExtensionHostKindPicker.pickRunningLocation(['workspace'], true, false, ExtensionRunningPreference.None), null);

70
		assert.deepStrictEqual(BrowserExtensionHostKindPicker.pickRunningLocation(['workspace'], true, true, ExtensionRunningPreference.None), ExtensionHostKind.Remote);

71


72
		assert.deepStrictEqual(BrowserExtensionHostKindPicker.pickRunningLocation(['web'], false, false, ExtensionRunningPreference.None), null);

73
		assert.deepStrictEqual(BrowserExtensionHostKindPicker.pickRunningLocation(['web'], false, true, ExtensionRunningPreference.None), ExtensionHostKind.LocalWebWorker);

74
		assert.deepStrictEqual(BrowserExtensionHostKindPicker.pickRunningLocation(['web'], true, false, ExtensionRunningPreference.None), ExtensionHostKind.LocalWebWorker);

75
		assert.deepStrictEqual(BrowserExtensionHostKindPicker.pickRunningLocation(['web'], true, true, ExtensionRunningPreference.None), ExtensionHostKind.LocalWebWorker);

76


77


78
		assert.deepStrictEqual(BrowserExtensionHostKindPicker.pickRunningLocation(['ui', 'workspace'], false, false, ExtensionRunningPreference.None), null);

79
		assert.deepStrictEqual(BrowserExtensionHostKindPicker.pickRunningLocation(['ui', 'workspace'], false, true, ExtensionRunningPreference.None), ExtensionHostKind.Remote);

80
		assert.deepStrictEqual(BrowserExtensionHostKindPicker.pickRunningLocation(['ui', 'workspace'], true, false, ExtensionRunningPreference.None), null);

81
		assert.deepStrictEqual(BrowserExtensionHostKindPicker.pickRunningLocation(['ui', 'workspace'], true, true, ExtensionRunningPreference.None), ExtensionHostKind.Remote);

82
		assert.deepStrictEqual(BrowserExtensionHostKindPicker.pickRunningLocation(['workspace', 'ui'], false, false, ExtensionRunningPreference.None), null);

83
		assert.deepStrictEqual(BrowserExtensionHostKindPicker.pickRunningLocation(['workspace', 'ui'], false, true, ExtensionRunningPreference.None), ExtensionHostKind.Remote);

84
		assert.deepStrictEqual(BrowserExtensionHostKindPicker.pickRunningLocation(['workspace', 'ui'], true, false, ExtensionRunningPreference.None), null);

85
		assert.deepStrictEqual(BrowserExtensionHostKindPicker.pickRunningLocation(['workspace', 'ui'], true, true, ExtensionRunningPreference.None), ExtensionHostKind.Remote);

86


87
		assert.deepStrictEqual(BrowserExtensionHostKindPicker.pickRunningLocation(['web', 'workspace'], false, false, ExtensionRunningPreference.None), null);

88
		assert.deepStrictEqual(BrowserExtensionHostKindPicker.pickRunningLocation(['web', 'workspace'], false, true, ExtensionRunningPreference.None), ExtensionHostKind.LocalWebWorker);

89
		assert.deepStrictEqual(BrowserExtensionHostKindPicker.pickRunningLocation(['web', 'workspace'], true, false, ExtensionRunningPreference.None), ExtensionHostKind.LocalWebWorker);

90
		assert.deepStrictEqual(BrowserExtensionHostKindPicker.pickRunningLocation(['web', 'workspace'], true, true, ExtensionRunningPreference.None), ExtensionHostKind.LocalWebWorker);

91
		assert.deepStrictEqual(BrowserExtensionHostKindPicker.pickRunningLocation(['workspace', 'web'], false, false, ExtensionRunningPreference.None), null);

92
		assert.deepStrictEqual(BrowserExtensionHostKindPicker.pickRunningLocation(['workspace', 'web'], false, true, ExtensionRunningPreference.None), ExtensionHostKind.Remote);

93
		assert.deepStrictEqual(BrowserExtensionHostKindPicker.pickRunningLocation(['workspace', 'web'], true, false, ExtensionRunningPreference.None), ExtensionHostKind.LocalWebWorker);

94
		assert.deepStrictEqual(BrowserExtensionHostKindPicker.pickRunningLocation(['workspace', 'web'], true, true, ExtensionRunningPreference.None), ExtensionHostKind.Remote);

95


96
		assert.deepStrictEqual(BrowserExtensionHostKindPicker.pickRunningLocation(['ui', 'web'], false, false, ExtensionRunningPreference.None), null);

97
		assert.deepStrictEqual(BrowserExtensionHostKindPicker.pickRunningLocation(['ui', 'web'], false, true, ExtensionRunningPreference.None), ExtensionHostKind.LocalWebWorker);

98
		assert.deepStrictEqual(BrowserExtensionHostKindPicker.pickRunningLocation(['ui', 'web'], true, false, ExtensionRunningPreference.None), ExtensionHostKind.LocalWebWorker);

99
		assert.deepStrictEqual(BrowserExtensionHostKindPicker.pickRunningLocation(['ui', 'web'], true, true, ExtensionRunningPreference.None), ExtensionHostKind.LocalWebWorker);

100
		assert.deepStrictEqual(BrowserExtensionHostKindPicker.pickRunningLocation(['web', 'ui'], false, false, ExtensionRunningPreference.None), null);

101
		assert.deepStrictEqual(BrowserExtensionHostKindPicker.pickRunningLocation(['web', 'ui'], false, true, ExtensionRunningPreference.None), ExtensionHostKind.LocalWebWorker);

102
		assert.deepStrictEqual(BrowserExtensionHostKindPicker.pickRunningLocation(['web', 'ui'], true, false, ExtensionRunningPreference.None), ExtensionHostKind.LocalWebWorker);

103
		assert.deepStrictEqual(BrowserExtensionHostKindPicker.pickRunningLocation(['web', 'ui'], true, true, ExtensionRunningPreference.None), ExtensionHostKind.LocalWebWorker);

104


105


106
		assert.deepStrictEqual(BrowserExtensionHostKindPicker.pickRunningLocation(['ui', 'web', 'workspace'], false, false, ExtensionRunningPreference.None), null);

107
		assert.deepStrictEqual(BrowserExtensionHostKindPicker.pickRunningLocation(['ui', 'web', 'workspace'], false, true, ExtensionRunningPreference.None), ExtensionHostKind.LocalWebWorker);

108
		assert.deepStrictEqual(BrowserExtensionHostKindPicker.pickRunningLocation(['ui', 'web', 'workspace'], true, false, ExtensionRunningPreference.None), ExtensionHostKind.LocalWebWorker);

109
		assert.deepStrictEqual(BrowserExtensionHostKindPicker.pickRunningLocation(['ui', 'web', 'workspace'], true, true, ExtensionRunningPreference.None), ExtensionHostKind.LocalWebWorker);

110
		assert.deepStrictEqual(BrowserExtensionHostKindPicker.pickRunningLocation(['ui', 'workspace', 'web'], false, false, ExtensionRunningPreference.None), null);

111
		assert.deepStrictEqual(BrowserExtensionHostKindPicker.pickRunningLocation(['ui', 'workspace', 'web'], false, true, ExtensionRunningPreference.None), ExtensionHostKind.Remote);

112
		assert.deepStrictEqual(BrowserExtensionHostKindPicker.pickRunningLocation(['ui', 'workspace', 'web'], true, false, ExtensionRunningPreference.None), ExtensionHostKind.LocalWebWorker);

113
		assert.deepStrictEqual(BrowserExtensionHostKindPicker.pickRunningLocation(['ui', 'workspace', 'web'], true, true, ExtensionRunningPreference.None), ExtensionHostKind.Remote);

114


115
		assert.deepStrictEqual(BrowserExtensionHostKindPicker.pickRunningLocation(['web', 'ui', 'workspace'], false, false, ExtensionRunningPreference.None), null);

116
		assert.deepStrictEqual(BrowserExtensionHostKindPicker.pickRunningLocation(['web', 'ui', 'workspace'], false, true, ExtensionRunningPreference.None), ExtensionHostKind.LocalWebWorker);

117
		assert.deepStrictEqual(BrowserExtensionHostKindPicker.pickRunningLocation(['web', 'ui', 'workspace'], true, false, ExtensionRunningPreference.None), ExtensionHostKind.LocalWebWorker);

118
		assert.deepStrictEqual(BrowserExtensionHostKindPicker.pickRunningLocation(['web', 'ui', 'workspace'], true, true, ExtensionRunningPreference.None), ExtensionHostKind.LocalWebWorker);

119
		assert.deepStrictEqual(BrowserExtensionHostKindPicker.pickRunningLocation(['web', 'workspace', 'ui'], false, false, ExtensionRunningPreference.None), null);

120
		assert.deepStrictEqual(BrowserExtensionHostKindPicker.pickRunningLocation(['web', 'workspace', 'ui'], false, true, ExtensionRunningPreference.None), ExtensionHostKind.LocalWebWorker);

121
		assert.deepStrictEqual(BrowserExtensionHostKindPicker.pickRunningLocation(['web', 'workspace', 'ui'], true, false, ExtensionRunningPreference.None), ExtensionHostKind.LocalWebWorker);

122
		assert.deepStrictEqual(BrowserExtensionHostKindPicker.pickRunningLocation(['web', 'workspace', 'ui'], true, true, ExtensionRunningPreference.None), ExtensionHostKind.LocalWebWorker);

123


124
		assert.deepStrictEqual(BrowserExtensionHostKindPicker.pickRunningLocation(['workspace', 'ui', 'web'], false, false, ExtensionRunningPreference.None), null);

125
		assert.deepStrictEqual(BrowserExtensionHostKindPicker.pickRunningLocation(['workspace', 'ui', 'web'], false, true, ExtensionRunningPreference.None), ExtensionHostKind.Remote);

126
		assert.deepStrictEqual(BrowserExtensionHostKindPicker.pickRunningLocation(['workspace', 'ui', 'web'], true, false, ExtensionRunningPreference.None), ExtensionHostKind.LocalWebWorker);

127
		assert.deepStrictEqual(BrowserExtensionHostKindPicker.pickRunningLocation(['workspace', 'ui', 'web'], true, true, ExtensionRunningPreference.None), ExtensionHostKind.Remote);

128
		assert.deepStrictEqual(BrowserExtensionHostKindPicker.pickRunningLocation(['workspace', 'web', 'ui'], false, false, ExtensionRunningPreference.None), null);

129
		assert.deepStrictEqual(BrowserExtensionHostKindPicker.pickRunningLocation(['workspace', 'web', 'ui'], false, true, ExtensionRunningPreference.None), ExtensionHostKind.Remote);

130
		assert.deepStrictEqual(BrowserExtensionHostKindPicker.pickRunningLocation(['workspace', 'web', 'ui'], true, false, ExtensionRunningPreference.None), ExtensionHostKind.LocalWebWorker);

131
		assert.deepStrictEqual(BrowserExtensionHostKindPicker.pickRunningLocation(['workspace', 'web', 'ui'], true, true, ExtensionRunningPreference.None), ExtensionHostKind.Remote);

132
	});

133
});

134


135
suite('ExtensionService', () => {

136


137
	class MyTestExtensionService extends AbstractExtensionService {

138


139
		constructor(

140
			@IInstantiationService instantiationService: IInstantiationService,

141
			@INotificationService notificationService: INotificationService,

142
			@IWorkbenchEnvironmentService environmentService: IWorkbenchEnvironmentService,

143
			@ITelemetryService telemetryService: ITelemetryService,

144
			@IWorkbenchExtensionEnablementService extensionEnablementService: IWorkbenchExtensionEnablementService,

145
			@IFileService fileService: IFileService,

146
			@IProductService productService: IProductService,

147
			@IWorkbenchExtensionManagementService extensionManagementService: IWorkbenchExtensionManagementService,

148
			@IWorkspaceContextService contextService: IWorkspaceContextService,

149
			@IConfigurationService configurationService: IConfigurationService,

150
			@IExtensionManifestPropertiesService extensionManifestPropertiesService: IExtensionManifestPropertiesService,

151
			@ILogService logService: ILogService,

152
			@IRemoteAgentService remoteAgentService: IRemoteAgentService,

153
			@IRemoteExtensionsScannerService remoteExtensionsScannerService: IRemoteExtensionsScannerService,

154
			@ILifecycleService lifecycleService: ILifecycleService,

155
			@IRemoteAuthorityResolverService remoteAuthorityResolverService: IRemoteAuthorityResolverService,

156
		) {

157
			const extensionsProposedApi = instantiationService.createInstance(ExtensionsProposedApi);

158
			const extensionHostFactory = new class implements IExtensionHostFactory {

159
				createExtensionHost(runningLocations: ExtensionRunningLocationTracker, runningLocation: ExtensionRunningLocation, isInitialStart: boolean): IExtensionHost | null {

160
					return new class extends mock<IExtensionHost>() {

161
						override runningLocation = runningLocation;

162
					};

163
				}

164
			};

165
			super(

166
				{ allowRemoteExtensionsInLocalWebWorker: false, hasLocalProcess: true },

167
				extensionsProposedApi,

168
				extensionHostFactory,

169
				null!,

170
				instantiationService,

171
				notificationService,

172
				environmentService,

173
				telemetryService,

174
				extensionEnablementService,

175
				fileService,

176
				productService,

177
				extensionManagementService,

178
				contextService,

179
				configurationService,

180
				extensionManifestPropertiesService,

181
				logService,

182
				remoteAgentService,

183
				remoteExtensionsScannerService,

184
				lifecycleService,

185
				remoteAuthorityResolverService,

186
				new TestDialogService()

187
			);

188


189
			this._initializeIfNeeded();

190
		}

191


192
		private _extHostId = 0;

193
		public readonly order: string[] = [];

194
		public readonly activationEvents: { event: string; activationKind: ActivationKind; kind: ExtensionHostKind }[] = [];

195
		protected _pickExtensionHostKind(extensionId: ExtensionIdentifier, extensionKinds: ExtensionKind[], isInstalledLocally: boolean, isInstalledRemotely: boolean, preference: ExtensionRunningPreference): ExtensionHostKind | null {

196
			throw new Error('Method not implemented.');

197
		}

198
		protected override _doCreateExtensionHostManager(extensionHost: IExtensionHost, initialActivationEvents: string[]): IExtensionHostManager {

199
			const order = this.order;

200
			const activationEvents = this.activationEvents;

201
			const extensionHostId = ++this._extHostId;

202
			const extHostKind = extensionHost.runningLocation.kind;

203
			order.push(`create ${extensionHostId}`);

204
			return new class extends mock<IExtensionHostManager>() {

205
				override onDidExit = Event.None;

206
				override onDidChangeResponsiveState = Event.None;

207
				override kind = extHostKind;

208
				override disconnect() {

209
					return Promise.resolve();

210
				}

211
				override start(): Promise<void> {

212
					return Promise.resolve();

213
				}

214
				override dispose(): void {

215
					order.push(`dispose ${extensionHostId}`);

216
				}

217
				override representsRunningLocation(runningLocation: ExtensionRunningLocation): boolean {

218
					return extensionHost.runningLocation.equals(runningLocation);

219
				}

220
				override activateByEvent(event: string, activationKind: ActivationKind): Promise<void> {

221
					activationEvents.push({ event, activationKind, kind: extHostKind });

222
					return Promise.resolve();

223
				}

224
				override ready(): Promise<void> {

225
					return Promise.resolve();

226
				}

227
			};

228
		}

229
		protected async *_resolveExtensions(): AsyncIterable<ResolvedExtensions> {

230
			// Return empty iterable - no extensions to resolve in tests

231
		}

232
		protected _scanSingleExtension(extension: IExtension): Promise<IExtensionDescription | null> {

233
			throw new Error('Method not implemented.');

234
		}

235
		protected _onExtensionHostExit(code: number): Promise<void> {

236
			throw new Error('Method not implemented.');

237
		}

238
		protected _resolveAuthority(remoteAuthority: string): Promise<ResolverResult> {

239
			throw new Error('Method not implemented.');

240
		}

241
	}

242


243
	let disposables: DisposableStore;

244
	let instantiationService: TestInstantiationService;

245
	let extService: MyTestExtensionService;

246


247
	setup(() => {

248
		disposables = new DisposableStore();

249
		const testProductService = { _serviceBrand: undefined, ...product };

250
		disposables.add(instantiationService = createServices(disposables, [

251
			// custom

252
			[IExtensionService, MyTestExtensionService],

253
			// default

254
			[ILifecycleService, TestLifecycleService],

255
			[IWorkbenchExtensionManagementService, TestWorkbenchExtensionManagementService],

256
			[INotificationService, TestNotificationService],

257
			[IRemoteAgentService, TestRemoteAgentService],

258
			[ILogService, NullLogService],

259
			[IWebExtensionsScannerService, TestWebExtensionsScannerService],

260
			[IExtensionManifestPropertiesService, ExtensionManifestPropertiesService],

261
			[IConfigurationService, TestConfigurationService],

262
			[IWorkspaceContextService, TestContextService],

263
			[IProductService, testProductService],

264
			[IFileService, TestFileService],

265
			[IWorkbenchExtensionEnablementService, TestWorkbenchExtensionEnablementService],

266
			[ITelemetryService, NullTelemetryService],

267
			[IEnvironmentService, TestEnvironmentService],

268
			[IWorkspaceTrustEnablementService, WorkspaceTrustEnablementService],

269
			[IUserDataProfilesService, UserDataProfilesService],

270
			[IUserDataProfileService, TestUserDataProfileService],

271
			[IUriIdentityService, UriIdentityService],

272
			[IRemoteExtensionsScannerService, TestRemoteExtensionsScannerService],

273
			[IRemoteAuthorityResolverService, new RemoteAuthorityResolverService(false, undefined, undefined, undefined, testProductService, new NullLogService())]

274
		]));

275
		extService = <MyTestExtensionService>instantiationService.get(IExtensionService);

276
	});

277


278
	teardown(async () => {

279
		disposables.dispose();

280
	});

281


282
	ensureNoDisposablesAreLeakedInTestSuite();

283


284
	test('issue #152204: Remote extension host not disposed after closing vscode client', async () => {

285
		await extService.stopExtensionHosts('foo');

286
		assert.deepStrictEqual(extService.order, (['create 1', 'create 2', 'create 3', 'dispose 3', 'dispose 2', 'dispose 1']));

287
	});

288


289
	test('Extension host disposed when awaited', async () => {

290
		await extService.stopExtensionHosts('foo');

291
		assert.deepStrictEqual(extService.order, (['create 1', 'create 2', 'create 3', 'dispose 3', 'dispose 2', 'dispose 1']));

292
	});

293


294
	test('Extension host not disposed when vetoed (sync)', async () => {

295


296
		disposables.add(extService.onWillStop(e => e.veto(true, 'test 1')));

297
		disposables.add(extService.onWillStop(e => e.veto(false, 'test 2')));

298


299
		await extService.stopExtensionHosts('foo');

300
		assert.deepStrictEqual(extService.order, (['create 1', 'create 2', 'create 3']));

301
	});

302


303
	test('Extension host not disposed when vetoed (async)', async () => {

304


305
		disposables.add(extService.onWillStop(e => e.veto(false, 'test 1')));

306
		disposables.add(extService.onWillStop(e => e.veto(Promise.resolve(true), 'test 2')));

307
		disposables.add(extService.onWillStop(e => e.veto(Promise.resolve(false), 'test 3')));

308


309
		await extService.stopExtensionHosts('foo');

310
		assert.deepStrictEqual(extService.order, (['create 1', 'create 2', 'create 3']));

311
	});

312


313
	test('onWillActivateByEvent includes activationKind for Normal activation', async () => {

314


315
		const events: IWillActivateEvent[] = [];

316
		disposables.add(extService.onWillActivateByEvent(e => events.push(e)));

317


318
		await extService.activateByEvent('onTest', ActivationKind.Normal);

319


320
		assert.strictEqual(events.length, 1);

321
		assert.strictEqual(events[0].event, 'onTest');

322
		assert.strictEqual(events[0].activationKind, ActivationKind.Normal);

323
	});

324


325
	test('onWillActivateByEvent includes activationKind for Immediate activation', async () => {

326


327
		const events: IWillActivateEvent[] = [];

328
		disposables.add(extService.onWillActivateByEvent(e => events.push(e)));

329


330
		await extService.activateByEvent('onTest', ActivationKind.Immediate);

331


332
		assert.strictEqual(events.length, 1);

333
		assert.strictEqual(events[0].event, 'onTest');

334
		assert.strictEqual(events[0].activationKind, ActivationKind.Immediate);

335
	});

336


337
	test('Immediate activation only activates local extension hosts', async () => {

338
		extService.activationEvents.length = 0; // Clear any initial activations

339


340
		await extService.activateByEvent('onTest', ActivationKind.Immediate);

341


342
		// Should only activate on local hosts (LocalProcess and LocalWebWorker), not Remote

343
		const activatedKinds = extService.activationEvents.map(e => e.kind);

344
		assert.ok(activatedKinds.includes(ExtensionHostKind.LocalProcess), 'Should activate on LocalProcess');

345
		assert.ok(activatedKinds.includes(ExtensionHostKind.LocalWebWorker), 'Should activate on LocalWebWorker');

346
		assert.ok(!activatedKinds.includes(ExtensionHostKind.Remote), 'Should NOT activate on Remote');

347
	});

348


349
	test('Normal activation activates all extension hosts', async () => {

350
		extService.activationEvents.length = 0; // Clear any initial activations

351


352
		await extService.activateByEvent('onTest', ActivationKind.Normal);

353


354
		// Should activate on all hosts

355
		const activatedKinds = extService.activationEvents.map(e => e.kind);

356
		assert.ok(activatedKinds.includes(ExtensionHostKind.LocalProcess), 'Should activate on LocalProcess');

357
		assert.ok(activatedKinds.includes(ExtensionHostKind.LocalWebWorker), 'Should activate on LocalWebWorker');

358
		assert.ok(activatedKinds.includes(ExtensionHostKind.Remote), 'Should activate on Remote');

359
	});

360
});

361


362