CoCalc -- extensionsActions.test.ts

GitHub Repository: microsoft/vscode
Path: blob/main/src/vs/workbench/contrib/extensions/test/electron-browser/extensionsActions.test.ts
⁵³⁴³ 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 { generateUuid } from '../../../../../base/common/uuid.js';
8
import { IExtensionsWorkbenchService, ExtensionContainers } from '../../common/extensions.js';
9
import * as ExtensionsActions from '../../browser/extensionsActions.js';
10
import { ExtensionsWorkbenchService } from '../../browser/extensionsWorkbenchService.js';
11
import {
12
	IExtensionManagementService, IExtensionGalleryService, ILocalExtension, IGalleryExtension,
13
	DidUninstallExtensionEvent, InstallExtensionEvent, IExtensionIdentifier, InstallOperation, IExtensionTipsService, InstallExtensionResult, getTargetPlatform, IExtensionsControlManifest, UninstallExtensionEvent, Metadata
14
} from '../../../../../platform/extensionManagement/common/extensionManagement.js';
15
import { IWorkbenchExtensionEnablementService, EnablementState, IExtensionManagementServerService, IExtensionManagementServer, ExtensionInstallLocation, IProfileAwareExtensionManagementService, IWorkbenchExtensionManagementService } from '../../../../services/extensionManagement/common/extensionManagement.js';
16
import { IExtensionRecommendationsService } from '../../../../services/extensionRecommendations/common/extensionRecommendations.js';
17
import { getGalleryExtensionId } from '../../../../../platform/extensionManagement/common/extensionManagementUtil.js';
18
import { TestExtensionEnablementService } from '../../../../services/extensionManagement/test/browser/extensionEnablementService.test.js';
19
import { ExtensionGalleryService } from '../../../../../platform/extensionManagement/common/extensionGalleryService.js';
20
import { IURLService } from '../../../../../platform/url/common/url.js';
21
import { TestInstantiationService } from '../../../../../platform/instantiation/test/common/instantiationServiceMock.js';
22
import { Emitter, Event } from '../../../../../base/common/event.js';
23
import { IPager } from '../../../../../base/common/paging.js';
24
import { ITelemetryService } from '../../../../../platform/telemetry/common/telemetry.js';
25
import { NullTelemetryService } from '../../../../../platform/telemetry/common/telemetryUtils.js';
26
import { IExtensionService, toExtensionDescription } from '../../../../services/extensions/common/extensions.js';
27
import { IWorkspaceContextService } from '../../../../../platform/workspace/common/workspace.js';
28
import { TestContextService, TestWorkspaceTrustManagementService } from '../../../../test/common/workbenchTestServices.js';
29
import { TestExtensionTipsService, TestSharedProcessService } from '../../../../test/electron-browser/workbenchTestServices.js';
30
import { IConfigurationService } from '../../../../../platform/configuration/common/configuration.js';
31
import { ILogService, NullLogService } from '../../../../../platform/log/common/log.js';
32
import { NativeURLService } from '../../../../../platform/url/common/urlService.js';
33
import { URI } from '../../../../../base/common/uri.js';
34
import { TestConfigurationService } from '../../../../../platform/configuration/test/common/testConfigurationService.js';
35
import { IRemoteAgentService } from '../../../../services/remote/common/remoteAgentService.js';
36
import { RemoteAgentService } from '../../../../services/remote/electron-browser/remoteAgentService.js';
37
import { IExtensionContributions, ExtensionType, IExtensionDescription, IExtension } from '../../../../../platform/extensions/common/extensions.js';
38
import { ISharedProcessService } from '../../../../../platform/ipc/electron-browser/services.js';
39
import { CancellationToken } from '../../../../../base/common/cancellation.js';
40
import { ILabelService, IFormatterChangeEvent } from '../../../../../platform/label/common/label.js';
41
import { IProductService } from '../../../../../platform/product/common/productService.js';
42
import { Schemas } from '../../../../../base/common/network.js';
43
import { IProgressService } from '../../../../../platform/progress/common/progress.js';
44
import { ProgressService } from '../../../../services/progress/browser/progressService.js';
45
import { ILifecycleService } from '../../../../services/lifecycle/common/lifecycle.js';
46
import { TestEnvironmentService, TestLifecycleService } from '../../../../test/browser/workbenchTestServices.js';
47
import { DisposableStore } from '../../../../../base/common/lifecycle.js';
48
import { INativeWorkbenchEnvironmentService } from '../../../../services/environment/electron-browser/environmentService.js';
49
import { IWorkbenchEnvironmentService } from '../../../../services/environment/common/environmentService.js';
50
import { IUserDataSyncEnablementService } from '../../../../../platform/userDataSync/common/userDataSync.js';
51
import { UserDataSyncEnablementService } from '../../../../../platform/userDataSync/common/userDataSyncEnablementService.js';
52
import { IContextKeyService } from '../../../../../platform/contextkey/common/contextkey.js';
53
import { MockContextKeyService } from '../../../../../platform/keybinding/test/common/mockKeybindingService.js';
54
import { IWorkspaceTrustManagementService } from '../../../../../platform/workspace/common/workspaceTrust.js';
55
import { IEnvironmentService, INativeEnvironmentService } from '../../../../../platform/environment/common/environment.js';
56
import { platform } from '../../../../../base/common/platform.js';
57
import { arch } from '../../../../../base/common/process.js';
58
import { ensureNoDisposablesAreLeakedInTestSuite } from '../../../../../base/test/common/utils.js';
59
import { IUpdateService, State } from '../../../../../platform/update/common/update.js';
60
import { IMeteredConnectionService } from '../../../../../platform/meteredConnection/common/meteredConnection.js';
61
import { IFileService } from '../../../../../platform/files/common/files.js';
62
import { FileService } from '../../../../../platform/files/common/fileService.js';
63
import { Mutable } from '../../../../../base/common/types.js';
64
import { IUserDataProfileService } from '../../../../services/userDataProfile/common/userDataProfile.js';
65
import { UserDataProfileService } from '../../../../services/userDataProfile/common/userDataProfileService.js';
66
import { toUserDataProfile } from '../../../../../platform/userDataProfile/common/userDataProfile.js';
67

68
let instantiationService: TestInstantiationService;
69
let installEvent: Emitter<InstallExtensionEvent>,
70
	didInstallEvent: Emitter<readonly InstallExtensionResult[]>,
71
	uninstallEvent: Emitter<UninstallExtensionEvent>,
72
	didUninstallEvent: Emitter<DidUninstallExtensionEvent>;
73

74
function setupTest(disposables: Pick<DisposableStore, 'add'>) {
75
	installEvent = disposables.add(new Emitter<InstallExtensionEvent>());
76
	didInstallEvent = disposables.add(new Emitter<readonly InstallExtensionResult[]>());
77
	uninstallEvent = disposables.add(new Emitter<UninstallExtensionEvent>());
78
	didUninstallEvent = disposables.add(new Emitter<DidUninstallExtensionEvent>());
79

80
	instantiationService = disposables.add(new TestInstantiationService());
81

82
	instantiationService.stub(IEnvironmentService, TestEnvironmentService);
83
	instantiationService.stub(IWorkbenchEnvironmentService, TestEnvironmentService);
84

85
	instantiationService.stub(ITelemetryService, NullTelemetryService);
86
	instantiationService.stub(ILogService, NullLogService);
87

88
	instantiationService.stub(IWorkspaceContextService, new TestContextService());
89
	instantiationService.stub(IFileService, disposables.add(new FileService(new NullLogService())));
90
	instantiationService.stub(IConfigurationService, new TestConfigurationService());
91
	instantiationService.stub(IProgressService, ProgressService);
92
	instantiationService.stub(IProductService, {});
93
	instantiationService.stub(IContextKeyService, new MockContextKeyService());
94

95
	instantiationService.stub(IExtensionGalleryService, ExtensionGalleryService);
96
	instantiationService.stub(ISharedProcessService, TestSharedProcessService);
97

98
	instantiationService.stub(IWorkbenchExtensionManagementService, {
99
		onDidInstallExtensions: didInstallEvent.event,
100
		// eslint-disable-next-line local/code-no-any-casts
101
		onInstallExtension: installEvent.event as any,
102
		// eslint-disable-next-line local/code-no-any-casts
103
		onUninstallExtension: uninstallEvent.event as any,
104
		// eslint-disable-next-line local/code-no-any-casts
105
		onDidUninstallExtension: didUninstallEvent.event as any,
106
		onDidUpdateExtensionMetadata: Event.None,
107
		onDidChangeProfile: Event.None,
108
		onProfileAwareDidInstallExtensions: Event.None,
109
		async getInstalled() { return []; },
110
		async getInstalledWorkspaceExtensions() { return []; },
111
		async getExtensionsControlManifest() { return { malicious: [], deprecated: {}, search: [], publisherMapping: {} }; },
112
		async updateMetadata(local: Mutable<ILocalExtension>, metadata: Partial<Metadata>) {
113
			local.identifier.uuid = metadata.id;
114
			local.publisherDisplayName = metadata.publisherDisplayName!;
115
			local.publisherId = metadata.publisherId!;
116
			return local;
117
		},
118
		async canInstall() { return true; },
119
		async getTargetPlatform() { return getTargetPlatform(platform, arch); },
120
	});
121

122
	instantiationService.stub(IRemoteAgentService, RemoteAgentService);
123

124
	const localExtensionManagementServer = { extensionManagementService: instantiationService.get(IExtensionManagementService) as IProfileAwareExtensionManagementService, label: 'local', id: 'vscode-local' };
125
	instantiationService.stub(IExtensionManagementServerService, {
126
		get localExtensionManagementServer(): IExtensionManagementServer {
127
			return localExtensionManagementServer;
128
		},
129
		getExtensionManagementServer(extension: IExtension): IExtensionManagementServer | null {
130
			if (extension.location.scheme === Schemas.file) {
131
				return localExtensionManagementServer;
132
			}
133
			throw new Error(`Invalid Extension ${extension.location}`);
134
		}
135
	});
136

137
	instantiationService.stub(IUserDataProfileService, disposables.add(new UserDataProfileService(toUserDataProfile('test', 'test', URI.file('foo'), URI.file('cache')))));
138
	instantiationService.stub(IWorkbenchExtensionEnablementService, disposables.add(new TestExtensionEnablementService(instantiationService)));
139
	instantiationService.stub(ILabelService, { onDidChangeFormatters: disposables.add(new Emitter<IFormatterChangeEvent>()).event });
140

141
	instantiationService.stub(ILifecycleService, disposables.add(new TestLifecycleService()));
142
	instantiationService.stub(IExtensionTipsService, disposables.add(instantiationService.createInstance(TestExtensionTipsService)));
143
	instantiationService.stub(IExtensionRecommendationsService, {});
144
	instantiationService.stub(IURLService, NativeURLService);
145

146
	instantiationService.stub(IExtensionGalleryService, 'isEnabled', true);
147
	instantiationService.stubPromise(IExtensionGalleryService, 'query', aPage());
148
	instantiationService.stubPromise(IExtensionGalleryService, 'getExtensions', []);
149
	instantiationService.stub(IExtensionService, { extensions: [], onDidChangeExtensions: Event.None, canAddExtension: (extension: IExtensionDescription) => false, canRemoveExtension: (extension: IExtensionDescription) => false, whenInstalledExtensionsRegistered: () => Promise.resolve(true) });
150
	(<TestExtensionEnablementService>instantiationService.get(IWorkbenchExtensionEnablementService)).reset();
151

152
	instantiationService.stub(IUserDataSyncEnablementService, disposables.add(instantiationService.createInstance(UserDataSyncEnablementService)));
153

154
	instantiationService.stub(IUpdateService, { onStateChange: Event.None, state: State.Uninitialized });
155
	instantiationService.stub(IMeteredConnectionService, { isConnectionMetered: false, onDidChangeIsConnectionMetered: Event.None });
156
	instantiationService.set(IExtensionsWorkbenchService, disposables.add(instantiationService.createInstance(ExtensionsWorkbenchService)));
157
	instantiationService.stub(IWorkspaceTrustManagementService, disposables.add(new TestWorkspaceTrustManagementService()));
158
}
159

160

161
suite('ExtensionsActions', () => {
162

163
	const disposables = ensureNoDisposablesAreLeakedInTestSuite();
164
	setup(() => setupTest(disposables));
165

166
	test('Install action is disabled when there is no extension', () => {
167
		const testObject: ExtensionsActions.InstallAction = disposables.add(instantiationService.createInstance(ExtensionsActions.InstallAction, { installPreReleaseVersion: false }));
168

169
		assert.ok(!testObject.enabled);
170
	});
171

172
	test('Test Install action when state is installed', () => {
173
		const workbenchService = instantiationService.get(IExtensionsWorkbenchService);
174
		const testObject: ExtensionsActions.InstallAction = disposables.add(instantiationService.createInstance(ExtensionsActions.InstallAction, { installPreReleaseVersion: false }));
175
		disposables.add(instantiationService.createInstance(ExtensionContainers, [testObject]));
176
		const local = aLocalExtension('a');
177
		instantiationService.stubPromise(IExtensionManagementService, 'getInstalled', [local]);
178
		return workbenchService.queryLocal()
179
			.then(() => {
180
				instantiationService.stubPromise(IExtensionGalleryService, 'query', aPage(aGalleryExtension('a', { identifier: local.identifier })));
181
				return workbenchService.queryGallery(CancellationToken.None)
182
					.then((paged) => {
183
						testObject.extension = paged.firstPage[0];
184
						assert.ok(!testObject.enabled);
185
						assert.strictEqual('Install', testObject.label);
186
						assert.strictEqual('extension-action label prominent install hide', testObject.class);
187
					});
188
			});
189
	});
190

191
	test('Test InstallingLabelAction when state is installing', () => {
192
		const workbenchService = instantiationService.get(IExtensionsWorkbenchService);
193
		const testObject: ExtensionsActions.InstallAction = disposables.add(instantiationService.createInstance(ExtensionsActions.InstallingLabelAction));
194
		disposables.add(instantiationService.createInstance(ExtensionContainers, [testObject]));
195
		const gallery = aGalleryExtension('a');
196
		instantiationService.stubPromise(IExtensionGalleryService, 'query', aPage(gallery));
197
		return workbenchService.queryGallery(CancellationToken.None)
198
			.then((paged) => {
199
				testObject.extension = paged.firstPage[0];
200
				installEvent.fire({ identifier: gallery.identifier, source: gallery, profileLocation: null! });
201

202
				assert.ok(!testObject.enabled);
203
				assert.strictEqual('Installing', testObject.label);
204
				assert.strictEqual('extension-action label install installing', testObject.class);
205
			});
206
	});
207

208
	test('Test Install action when state is uninstalled', async () => {
209
		const workbenchService = instantiationService.get(IExtensionsWorkbenchService);
210
		const testObject: ExtensionsActions.InstallAction = disposables.add(instantiationService.createInstance(ExtensionsActions.InstallAction, { installPreReleaseVersion: false }));
211
		disposables.add(instantiationService.createInstance(ExtensionContainers, [testObject]));
212
		const gallery = aGalleryExtension('a');
213
		instantiationService.stubPromise(IExtensionGalleryService, 'query', aPage(gallery));
214
		const paged = await workbenchService.queryGallery(CancellationToken.None);
215
		const promise = Event.toPromise(Event.filter(testObject.onDidChange, e => e.enabled === true));
216
		testObject.extension = paged.firstPage[0];
217
		await promise;
218
		assert.ok(testObject.enabled);
219
		assert.strictEqual('Install', testObject.label);
220
	});
221

222
	test('Test Install action when extension is system action', () => {
223
		const testObject: ExtensionsActions.InstallAction = disposables.add(instantiationService.createInstance(ExtensionsActions.InstallAction, { installPreReleaseVersion: false }));
224
		disposables.add(instantiationService.createInstance(ExtensionContainers, [testObject]));
225
		const local = aLocalExtension('a', {}, { type: ExtensionType.System });
226
		instantiationService.stubPromise(IExtensionManagementService, 'getInstalled', [local]);
227

228
		return instantiationService.get(IExtensionsWorkbenchService).queryLocal()
229
			.then(extensions => {
230
				uninstallEvent.fire({ identifier: local.identifier, profileLocation: null! });
231
				didUninstallEvent.fire({ identifier: local.identifier, profileLocation: null! });
232
				testObject.extension = extensions[0];
233
				assert.ok(!testObject.enabled);
234
			});
235
	});
236

237
	test('Test Install action when extension doesnot has gallery', () => {
238
		const testObject: ExtensionsActions.InstallAction = disposables.add(instantiationService.createInstance(ExtensionsActions.InstallAction, { installPreReleaseVersion: false }));
239
		disposables.add(instantiationService.createInstance(ExtensionContainers, [testObject]));
240
		const local = aLocalExtension('a');
241
		instantiationService.stubPromise(IExtensionManagementService, 'getInstalled', [local]);
242

243
		return instantiationService.get(IExtensionsWorkbenchService).queryLocal()
244
			.then(extensions => {
245
				uninstallEvent.fire({ identifier: local.identifier, profileLocation: null! });
246
				didUninstallEvent.fire({ identifier: local.identifier, profileLocation: null! });
247
				testObject.extension = extensions[0];
248
				assert.ok(!testObject.enabled);
249
			});
250
	});
251

252
	test('Uninstall action is disabled when there is no extension', () => {
253
		const testObject: ExtensionsActions.UninstallAction = disposables.add(instantiationService.createInstance(ExtensionsActions.UninstallAction));
254
		disposables.add(instantiationService.createInstance(ExtensionContainers, [testObject]));
255

256
		assert.ok(!testObject.enabled);
257
	});
258

259
	test('Test Uninstall action when state is uninstalling', () => {
260
		const testObject: ExtensionsActions.UninstallAction = disposables.add(instantiationService.createInstance(ExtensionsActions.UninstallAction));
261
		disposables.add(instantiationService.createInstance(ExtensionContainers, [testObject]));
262
		const local = aLocalExtension('a');
263
		instantiationService.stubPromise(IExtensionManagementService, 'getInstalled', [local]);
264

265
		return instantiationService.get(IExtensionsWorkbenchService).queryLocal()
266
			.then(extensions => {
267
				testObject.extension = extensions[0];
268
				uninstallEvent.fire({ identifier: local.identifier, profileLocation: null! });
269
				assert.ok(!testObject.enabled);
270
				assert.strictEqual('Uninstalling', testObject.label);
271
				assert.strictEqual('extension-action label uninstall uninstalling', testObject.class);
272
			});
273
	});
274

275
	test('Test Uninstall action when state is installed and is user extension', () => {
276
		const testObject: ExtensionsActions.UninstallAction = disposables.add(instantiationService.createInstance(ExtensionsActions.UninstallAction));
277
		disposables.add(instantiationService.createInstance(ExtensionContainers, [testObject]));
278
		const local = aLocalExtension('a');
279
		instantiationService.stubPromise(IExtensionManagementService, 'getInstalled', [local]);
280

281
		return instantiationService.get(IExtensionsWorkbenchService).queryLocal()
282
			.then(extensions => {
283
				testObject.extension = extensions[0];
284
				assert.ok(testObject.enabled);
285
				assert.strictEqual('Uninstall', testObject.label);
286
				assert.strictEqual('extension-action label uninstall', testObject.class);
287
			});
288
	});
289

290
	test('Test Uninstall action when state is installed and is system extension', () => {
291
		const testObject: ExtensionsActions.UninstallAction = disposables.add(instantiationService.createInstance(ExtensionsActions.UninstallAction));
292
		disposables.add(instantiationService.createInstance(ExtensionContainers, [testObject]));
293
		const local = aLocalExtension('a', {}, { type: ExtensionType.System });
294
		instantiationService.stubPromise(IExtensionManagementService, 'getInstalled', [local]);
295

296
		return instantiationService.get(IExtensionsWorkbenchService).queryLocal()
297
			.then(extensions => {
298
				testObject.extension = extensions[0];
299
				assert.ok(!testObject.enabled);
300
				assert.strictEqual('Uninstall', testObject.label);
301
				assert.strictEqual('extension-action label uninstall', testObject.class);
302
			});
303
	});
304

305
	test('Test Uninstall action when state is installing and is user extension', () => {
306
		const testObject: ExtensionsActions.UninstallAction = disposables.add(instantiationService.createInstance(ExtensionsActions.UninstallAction));
307
		disposables.add(instantiationService.createInstance(ExtensionContainers, [testObject]));
308
		const local = aLocalExtension('a');
309
		instantiationService.stubPromise(IExtensionManagementService, 'getInstalled', [local]);
310

311
		return instantiationService.get(IExtensionsWorkbenchService).queryLocal()
312
			.then(extensions => {
313
				const gallery = aGalleryExtension('a');
314
				const extension = extensions[0];
315
				extension.gallery = gallery;
316
				installEvent.fire({ identifier: gallery.identifier, source: gallery, profileLocation: null! });
317
				testObject.extension = extension;
318
				assert.ok(!testObject.enabled);
319
			});
320
	});
321

322
	test('Test Uninstall action after extension is installed', async () => {
323
		const testObject: ExtensionsActions.UninstallAction = disposables.add(instantiationService.createInstance(ExtensionsActions.UninstallAction));
324
		disposables.add(instantiationService.createInstance(ExtensionContainers, [testObject]));
325
		const gallery = aGalleryExtension('a');
326
		instantiationService.stubPromise(IExtensionGalleryService, 'query', aPage(gallery));
327

328
		const paged = await instantiationService.get(IExtensionsWorkbenchService).queryGallery(CancellationToken.None);
329
		testObject.extension = paged.firstPage[0];
330

331
		installEvent.fire({ identifier: gallery.identifier, source: gallery, profileLocation: null! });
332
		const promise = Event.toPromise(testObject.onDidChange);
333
		didInstallEvent.fire([{ identifier: gallery.identifier, source: gallery, operation: InstallOperation.Install, local: aLocalExtension('a', gallery, gallery), profileLocation: null! }]);
334

335
		await promise;
336
		assert.ok(testObject.enabled);
337
		assert.strictEqual('Uninstall', testObject.label);
338
		assert.strictEqual('extension-action label uninstall', testObject.class);
339
	});
340

341
	test('Test UpdateAction when there is no extension', () => {
342
		const testObject: ExtensionsActions.UpdateAction = disposables.add(instantiationService.createInstance(ExtensionsActions.UpdateAction, false));
343
		disposables.add(instantiationService.createInstance(ExtensionContainers, [testObject]));
344

345
		assert.ok(!testObject.enabled);
346
	});
347

348
	test('Test UpdateAction when extension is uninstalled', () => {
349
		const testObject: ExtensionsActions.UpdateAction = disposables.add(instantiationService.createInstance(ExtensionsActions.UpdateAction, false));
350
		disposables.add(instantiationService.createInstance(ExtensionContainers, [testObject]));
351
		const gallery = aGalleryExtension('a', { version: '1.0.0' });
352
		instantiationService.stubPromise(IExtensionGalleryService, 'query', aPage(gallery));
353
		return instantiationService.get(IExtensionsWorkbenchService).queryGallery(CancellationToken.None)
354
			.then((paged) => {
355
				testObject.extension = paged.firstPage[0];
356
				assert.ok(!testObject.enabled);
357
			});
358
	});
359

360
	test('Test UpdateAction when extension is installed and not outdated', () => {
361
		const testObject: ExtensionsActions.UpdateAction = disposables.add(instantiationService.createInstance(ExtensionsActions.UpdateAction, false));
362
		disposables.add(instantiationService.createInstance(ExtensionContainers, [testObject]));
363
		const local = aLocalExtension('a', { version: '1.0.0' });
364
		instantiationService.stubPromise(IExtensionManagementService, 'getInstalled', [local]);
365

366
		return instantiationService.get(IExtensionsWorkbenchService).queryLocal()
367
			.then(extensions => {
368
				testObject.extension = extensions[0];
369
				instantiationService.stubPromise(IExtensionGalleryService, 'query', aPage(aGalleryExtension('a', { identifier: local.identifier, version: local.manifest.version })));
370
				return instantiationService.get(IExtensionsWorkbenchService).queryGallery(CancellationToken.None)
371
					.then(extensions => assert.ok(!testObject.enabled));
372
			});
373
	});
374

375
	test('Test UpdateAction when extension is installed outdated and system extension', () => {
376
		const testObject: ExtensionsActions.UpdateAction = disposables.add(instantiationService.createInstance(ExtensionsActions.UpdateAction, false));
377
		disposables.add(instantiationService.createInstance(ExtensionContainers, [testObject]));
378
		const local = aLocalExtension('a', { version: '1.0.0' }, { type: ExtensionType.System });
379
		instantiationService.stubPromise(IExtensionManagementService, 'getInstalled', [local]);
380

381
		return instantiationService.get(IExtensionsWorkbenchService).queryLocal()
382
			.then(extensions => {
383
				testObject.extension = extensions[0];
384
				instantiationService.stubPromise(IExtensionGalleryService, 'query', aPage(aGalleryExtension('a', { identifier: local.identifier, version: '1.0.1' })));
385
				return instantiationService.get(IExtensionsWorkbenchService).queryGallery(CancellationToken.None)
386
					.then(extensions => assert.ok(!testObject.enabled));
387
			});
388
	});
389

390
	test('Test UpdateAction when extension is installed outdated and user extension', () => {
391
		const testObject: ExtensionsActions.UpdateAction = disposables.add(instantiationService.createInstance(ExtensionsActions.UpdateAction, false));
392
		disposables.add(instantiationService.createInstance(ExtensionContainers, [testObject]));
393
		const local = aLocalExtension('a', { version: '1.0.0' });
394
		instantiationService.stubPromise(IExtensionManagementService, 'getInstalled', [local]);
395

396
		const workbenchService = instantiationService.get(IExtensionsWorkbenchService);
397
		return workbenchService.queryLocal()
398
			.then(async extensions => {
399
				testObject.extension = extensions[0];
400
				const gallery = aGalleryExtension('a', { identifier: local.identifier, version: '1.0.1' });
401
				instantiationService.stubPromise(IExtensionGalleryService, 'query', aPage(gallery));
402
				instantiationService.stubPromise(IExtensionGalleryService, 'getCompatibleExtension', gallery);
403
				instantiationService.stubPromise(IExtensionGalleryService, 'getExtensions', [gallery]);
404
				assert.ok(!testObject.enabled);
405
				return new Promise<void>(c => {
406
					disposables.add(testObject.onDidChange(() => {
407
						if (testObject.enabled) {
408
							c();
409
						}
410
					}));
411
					instantiationService.get(IExtensionsWorkbenchService).queryGallery(CancellationToken.None);
412
				});
413
			});
414
	});
415

416
	test('Test UpdateAction when extension is installing and outdated and user extension', async () => {
417
		const testObject: ExtensionsActions.UpdateAction = disposables.add(instantiationService.createInstance(ExtensionsActions.UpdateAction, false));
418
		disposables.add(instantiationService.createInstance(ExtensionContainers, [testObject]));
419
		const local = aLocalExtension('a', { version: '1.0.0' });
420
		instantiationService.stubPromise(IExtensionManagementService, 'getInstalled', [local]);
421

422
		const extensions = await instantiationService.get(IExtensionsWorkbenchService).queryLocal();
423
		testObject.extension = extensions[0];
424
		const gallery = aGalleryExtension('a', { identifier: local.identifier, version: '1.0.1' });
425
		instantiationService.stubPromise(IExtensionGalleryService, 'query', aPage(gallery));
426
		instantiationService.stubPromise(IExtensionGalleryService, 'getCompatibleExtension', gallery);
427
		instantiationService.stubPromise(IExtensionGalleryService, 'getExtensions', [gallery]);
428
		await new Promise<void>(c => {
429
			disposables.add(testObject.onDidChange(() => {
430
				if (testObject.enabled) {
431
					c();
432
				}
433
			}));
434
			instantiationService.get(IExtensionsWorkbenchService).queryGallery(CancellationToken.None);
435
		});
436
		await new Promise<void>(c => {
437
			disposables.add(testObject.onDidChange(() => {
438
				if (!testObject.enabled) {
439
					c();
440
				}
441
			}));
442
			installEvent.fire({ identifier: local.identifier, source: gallery, profileLocation: null! });
443
		});
444
	});
445

446
	test('Test ManageExtensionAction when there is no extension', () => {
447
		const testObject: ExtensionsActions.ManageExtensionAction = disposables.add(instantiationService.createInstance(ExtensionsActions.ManageExtensionAction));
448
		disposables.add(instantiationService.createInstance(ExtensionContainers, [testObject]));
449

450
		assert.ok(!testObject.enabled);
451
	});
452

453
	test('Test ManageExtensionAction when extension is installed', () => {
454
		const testObject: ExtensionsActions.ManageExtensionAction = disposables.add(instantiationService.createInstance(ExtensionsActions.ManageExtensionAction));
455
		disposables.add(instantiationService.createInstance(ExtensionContainers, [testObject]));
456
		const local = aLocalExtension('a');
457
		instantiationService.stubPromise(IExtensionManagementService, 'getInstalled', [local]);
458

459
		return instantiationService.get(IExtensionsWorkbenchService).queryLocal()
460
			.then(extensions => {
461
				testObject.extension = extensions[0];
462
				assert.ok(testObject.enabled);
463
				assert.strictEqual('extension-action icon manage codicon codicon-extensions-manage', testObject.class);
464
				assert.strictEqual('Manage', testObject.tooltip);
465
			});
466
	});
467

468
	test('Test ManageExtensionAction when extension is uninstalled', () => {
469
		const testObject: ExtensionsActions.ManageExtensionAction = disposables.add(instantiationService.createInstance(ExtensionsActions.ManageExtensionAction));
470
		disposables.add(instantiationService.createInstance(ExtensionContainers, [testObject]));
471
		const gallery = aGalleryExtension('a');
472
		instantiationService.stubPromise(IExtensionGalleryService, 'query', aPage(gallery));
473

474
		return instantiationService.get(IExtensionsWorkbenchService).queryGallery(CancellationToken.None)
475
			.then(page => {
476
				testObject.extension = page.firstPage[0];
477
				assert.ok(!testObject.enabled);
478
				assert.strictEqual('extension-action icon manage codicon codicon-extensions-manage hide', testObject.class);
479
				assert.strictEqual('Manage', testObject.tooltip);
480
			});
481
	});
482

483
	test('Test ManageExtensionAction when extension is installing', () => {
484
		const testObject: ExtensionsActions.ManageExtensionAction = disposables.add(instantiationService.createInstance(ExtensionsActions.ManageExtensionAction));
485
		disposables.add(instantiationService.createInstance(ExtensionContainers, [testObject]));
486
		const gallery = aGalleryExtension('a');
487
		instantiationService.stubPromise(IExtensionGalleryService, 'query', aPage(gallery));
488

489
		return instantiationService.get(IExtensionsWorkbenchService).queryGallery(CancellationToken.None)
490
			.then(page => {
491
				testObject.extension = page.firstPage[0];
492

493
				installEvent.fire({ identifier: gallery.identifier, source: gallery, profileLocation: null! });
494
				assert.ok(!testObject.enabled);
495
				assert.strictEqual('extension-action icon manage codicon codicon-extensions-manage hide', testObject.class);
496
				assert.strictEqual('Manage', testObject.tooltip);
497
			});
498
	});
499

500
	test('Test ManageExtensionAction when extension is queried from gallery and installed', async () => {
501
		const testObject: ExtensionsActions.ManageExtensionAction = disposables.add(instantiationService.createInstance(ExtensionsActions.ManageExtensionAction));
502
		disposables.add(instantiationService.createInstance(ExtensionContainers, [testObject]));
503
		const gallery = aGalleryExtension('a');
504
		instantiationService.stubPromise(IExtensionGalleryService, 'query', aPage(gallery));
505

506
		const paged = await instantiationService.get(IExtensionsWorkbenchService).queryGallery(CancellationToken.None);
507
		testObject.extension = paged.firstPage[0];
508
		installEvent.fire({ identifier: gallery.identifier, source: gallery, profileLocation: null! });
509
		const promise = Event.toPromise(testObject.onDidChange);
510
		didInstallEvent.fire([{ identifier: gallery.identifier, source: gallery, operation: InstallOperation.Install, local: aLocalExtension('a', gallery, gallery), profileLocation: null! }]);
511

512
		await promise;
513
		assert.ok(testObject.enabled);
514
		assert.strictEqual('extension-action icon manage codicon codicon-extensions-manage', testObject.class);
515
		assert.strictEqual('Manage', testObject.tooltip);
516
	});
517

518
	test('Test ManageExtensionAction when extension is system extension', () => {
519
		const testObject: ExtensionsActions.ManageExtensionAction = disposables.add(instantiationService.createInstance(ExtensionsActions.ManageExtensionAction));
520
		disposables.add(instantiationService.createInstance(ExtensionContainers, [testObject]));
521
		const local = aLocalExtension('a', {}, { type: ExtensionType.System });
522
		instantiationService.stubPromise(IExtensionManagementService, 'getInstalled', [local]);
523

524
		return instantiationService.get(IExtensionsWorkbenchService).queryLocal()
525
			.then(extensions => {
526
				testObject.extension = extensions[0];
527
				assert.ok(testObject.enabled);
528
				assert.strictEqual('extension-action icon manage codicon codicon-extensions-manage', testObject.class);
529
				assert.strictEqual('Manage', testObject.tooltip);
530
			});
531
	});
532

533
	test('Test ManageExtensionAction when extension is uninstalling', () => {
534
		const testObject: ExtensionsActions.ManageExtensionAction = disposables.add(instantiationService.createInstance(ExtensionsActions.ManageExtensionAction));
535
		disposables.add(instantiationService.createInstance(ExtensionContainers, [testObject]));
536
		const local = aLocalExtension('a');
537
		instantiationService.stubPromise(IExtensionManagementService, 'getInstalled', [local]);
538

539
		return instantiationService.get(IExtensionsWorkbenchService).queryLocal()
540
			.then(extensions => {
541
				testObject.extension = extensions[0];
542
				uninstallEvent.fire({ identifier: local.identifier, profileLocation: null! });
543

544
				assert.ok(!testObject.enabled);
545
				assert.strictEqual('extension-action icon manage codicon codicon-extensions-manage', testObject.class);
546
				assert.strictEqual('Manage', testObject.tooltip);
547
			});
548
	});
549

550
	test('Test EnableForWorkspaceAction when there is no extension', () => {
551
		const testObject: ExtensionsActions.EnableForWorkspaceAction = disposables.add(instantiationService.createInstance(ExtensionsActions.EnableForWorkspaceAction));
552

553
		assert.ok(!testObject.enabled);
554
	});
555

556
	test('Test EnableForWorkspaceAction when there extension is not disabled', () => {
557
		const local = aLocalExtension('a');
558
		instantiationService.stubPromise(IExtensionManagementService, 'getInstalled', [local]);
559

560
		return instantiationService.get(IExtensionsWorkbenchService).queryLocal()
561
			.then(extensions => {
562
				const testObject: ExtensionsActions.EnableForWorkspaceAction = disposables.add(instantiationService.createInstance(ExtensionsActions.EnableForWorkspaceAction));
563
				testObject.extension = extensions[0];
564
				assert.ok(!testObject.enabled);
565
			});
566
	});
567

568
	test('Test EnableForWorkspaceAction when the extension is disabled globally', () => {
569
		const local = aLocalExtension('a');
570
		return instantiationService.get(IWorkbenchExtensionEnablementService).setEnablement([local], EnablementState.DisabledGlobally)
571
			.then(() => {
572
				instantiationService.stubPromise(IExtensionManagementService, 'getInstalled', [local]);
573

574
				return instantiationService.get(IExtensionsWorkbenchService).queryLocal()
575
					.then(extensions => {
576
						const testObject: ExtensionsActions.EnableForWorkspaceAction = disposables.add(instantiationService.createInstance(ExtensionsActions.EnableForWorkspaceAction));
577
						testObject.extension = extensions[0];
578
						assert.ok(testObject.enabled);
579
					});
580
			});
581
	});
582

583
	test('Test EnableForWorkspaceAction when extension is disabled for workspace', () => {
584
		const local = aLocalExtension('a');
585
		return instantiationService.get(IWorkbenchExtensionEnablementService).setEnablement([local], EnablementState.DisabledWorkspace)
586
			.then(() => {
587
				instantiationService.stubPromise(IExtensionManagementService, 'getInstalled', [local]);
588

589
				return instantiationService.get(IExtensionsWorkbenchService).queryLocal()
590
					.then(extensions => {
591
						const testObject: ExtensionsActions.EnableForWorkspaceAction = disposables.add(instantiationService.createInstance(ExtensionsActions.EnableForWorkspaceAction));
592
						testObject.extension = extensions[0];
593
						assert.ok(testObject.enabled);
594
					});
595
			});
596
	});
597

598
	test('Test EnableForWorkspaceAction when the extension is disabled globally and workspace', () => {
599
		const local = aLocalExtension('a');
600
		return instantiationService.get(IWorkbenchExtensionEnablementService).setEnablement([local], EnablementState.DisabledGlobally)
601
			.then(() => instantiationService.get(IWorkbenchExtensionEnablementService).setEnablement([local], EnablementState.DisabledWorkspace))
602
			.then(() => {
603
				instantiationService.stubPromise(IExtensionManagementService, 'getInstalled', [local]);
604

605
				return instantiationService.get(IExtensionsWorkbenchService).queryLocal()
606
					.then(extensions => {
607
						const testObject: ExtensionsActions.EnableForWorkspaceAction = disposables.add(instantiationService.createInstance(ExtensionsActions.EnableForWorkspaceAction));
608
						testObject.extension = extensions[0];
609
						assert.ok(testObject.enabled);
610
					});
611
			});
612
	});
613

614
	test('Test EnableGloballyAction when there is no extension', () => {
615
		const testObject: ExtensionsActions.EnableGloballyAction = disposables.add(instantiationService.createInstance(ExtensionsActions.EnableGloballyAction));
616

617
		assert.ok(!testObject.enabled);
618
	});
619

620
	test('Test EnableGloballyAction when the extension is not disabled', () => {
621
		const local = aLocalExtension('a');
622
		instantiationService.stubPromise(IExtensionManagementService, 'getInstalled', [local]);
623

624
		return instantiationService.get(IExtensionsWorkbenchService).queryLocal()
625
			.then(extensions => {
626
				const testObject: ExtensionsActions.EnableGloballyAction = disposables.add(instantiationService.createInstance(ExtensionsActions.EnableGloballyAction));
627
				testObject.extension = extensions[0];
628
				assert.ok(!testObject.enabled);
629
			});
630
	});
631

632
	test('Test EnableGloballyAction when the extension is disabled for workspace', () => {
633
		const local = aLocalExtension('a');
634
		return instantiationService.get(IWorkbenchExtensionEnablementService).setEnablement([local], EnablementState.DisabledWorkspace)
635
			.then(() => {
636
				instantiationService.stubPromise(IExtensionManagementService, 'getInstalled', [local]);
637

638
				return instantiationService.get(IExtensionsWorkbenchService).queryLocal()
639
					.then(extensions => {
640
						const testObject: ExtensionsActions.EnableGloballyAction = disposables.add(instantiationService.createInstance(ExtensionsActions.EnableGloballyAction));
641
						testObject.extension = extensions[0];
642
						assert.ok(!testObject.enabled);
643
					});
644
			});
645
	});
646

647
	test('Test EnableGloballyAction when the extension is disabled globally', () => {
648
		const local = aLocalExtension('a');
649
		return instantiationService.get(IWorkbenchExtensionEnablementService).setEnablement([local], EnablementState.DisabledGlobally)
650
			.then(() => {
651
				instantiationService.stubPromise(IExtensionManagementService, 'getInstalled', [local]);
652

653
				return instantiationService.get(IExtensionsWorkbenchService).queryLocal()
654
					.then(extensions => {
655
						const testObject: ExtensionsActions.EnableGloballyAction = disposables.add(instantiationService.createInstance(ExtensionsActions.EnableGloballyAction));
656
						testObject.extension = extensions[0];
657
						assert.ok(testObject.enabled);
658
					});
659
			});
660
	});
661

662
	test('Test EnableGloballyAction when the extension is disabled in both', () => {
663
		const local = aLocalExtension('a');
664
		return instantiationService.get(IWorkbenchExtensionEnablementService).setEnablement([local], EnablementState.DisabledGlobally)
665
			.then(() => instantiationService.get(IWorkbenchExtensionEnablementService).setEnablement([local], EnablementState.DisabledWorkspace))
666
			.then(() => {
667
				instantiationService.stubPromise(IExtensionManagementService, 'getInstalled', [local]);
668

669
				return instantiationService.get(IExtensionsWorkbenchService).queryLocal()
670
					.then(extensions => {
671
						const testObject: ExtensionsActions.EnableGloballyAction = disposables.add(instantiationService.createInstance(ExtensionsActions.EnableGloballyAction));
672
						testObject.extension = extensions[0];
673
						assert.ok(testObject.enabled);
674
					});
675
			});
676
	});
677

678
	test('Test EnableAction when there is no extension', () => {
679
		const testObject: ExtensionsActions.EnableDropDownAction = disposables.add(instantiationService.createInstance(ExtensionsActions.EnableDropDownAction));
680

681
		assert.ok(!testObject.enabled);
682
	});
683

684
	test('Test EnableDropDownAction when extension is installed and enabled', () => {
685
		const local = aLocalExtension('a');
686
		instantiationService.stubPromise(IExtensionManagementService, 'getInstalled', [local]);
687

688
		return instantiationService.get(IExtensionsWorkbenchService).queryLocal()
689
			.then(extensions => {
690
				const testObject: ExtensionsActions.EnableDropDownAction = disposables.add(instantiationService.createInstance(ExtensionsActions.EnableDropDownAction));
691
				testObject.extension = extensions[0];
692
				assert.ok(!testObject.enabled);
693
			});
694
	});
695

696
	test('Test EnableDropDownAction when extension is installed and disabled globally', () => {
697
		const local = aLocalExtension('a');
698
		return instantiationService.get(IWorkbenchExtensionEnablementService).setEnablement([local], EnablementState.DisabledGlobally)
699
			.then(() => {
700
				instantiationService.stubPromise(IExtensionManagementService, 'getInstalled', [local]);
701

702
				return instantiationService.get(IExtensionsWorkbenchService).queryLocal()
703
					.then(extensions => {
704
						const testObject: ExtensionsActions.EnableDropDownAction = disposables.add(instantiationService.createInstance(ExtensionsActions.EnableDropDownAction));
705
						testObject.extension = extensions[0];
706
						assert.ok(testObject.enabled);
707
					});
708
			});
709
	});
710

711
	test('Test EnableDropDownAction when extension is installed and disabled for workspace', () => {
712
		const local = aLocalExtension('a');
713
		return instantiationService.get(IWorkbenchExtensionEnablementService).setEnablement([local], EnablementState.DisabledWorkspace)
714
			.then(() => {
715
				instantiationService.stubPromise(IExtensionManagementService, 'getInstalled', [local]);
716

717
				return instantiationService.get(IExtensionsWorkbenchService).queryLocal()
718
					.then(extensions => {
719
						const testObject: ExtensionsActions.EnableDropDownAction = disposables.add(instantiationService.createInstance(ExtensionsActions.EnableDropDownAction));
720
						testObject.extension = extensions[0];
721
						assert.ok(testObject.enabled);
722
					});
723
			});
724
	});
725

726
	test('Test EnableDropDownAction when extension is uninstalled', () => {
727
		const gallery = aGalleryExtension('a');
728
		instantiationService.stubPromise(IExtensionGalleryService, 'query', aPage(gallery));
729

730
		return instantiationService.get(IExtensionsWorkbenchService).queryGallery(CancellationToken.None)
731
			.then(page => {
732
				const testObject: ExtensionsActions.EnableDropDownAction = disposables.add(instantiationService.createInstance(ExtensionsActions.EnableDropDownAction));
733
				testObject.extension = page.firstPage[0];
734
				assert.ok(!testObject.enabled);
735
			});
736
	});
737

738
	test('Test EnableDropDownAction when extension is installing', () => {
739
		const gallery = aGalleryExtension('a');
740
		instantiationService.stubPromise(IExtensionGalleryService, 'query', aPage(gallery));
741

742
		return instantiationService.get(IExtensionsWorkbenchService).queryGallery(CancellationToken.None)
743
			.then(page => {
744
				const testObject: ExtensionsActions.EnableDropDownAction = disposables.add(instantiationService.createInstance(ExtensionsActions.EnableDropDownAction));
745
				testObject.extension = page.firstPage[0];
746
				disposables.add(instantiationService.createInstance(ExtensionContainers, [testObject]));
747

748
				installEvent.fire({ identifier: gallery.identifier, source: gallery, profileLocation: null! });
749
				assert.ok(!testObject.enabled);
750
			});
751
	});
752

753
	test('Test EnableDropDownAction when extension is uninstalling', () => {
754
		const local = aLocalExtension('a');
755
		instantiationService.stubPromise(IExtensionManagementService, 'getInstalled', [local]);
756

757
		return instantiationService.get(IExtensionsWorkbenchService).queryLocal()
758
			.then(extensions => {
759
				const testObject: ExtensionsActions.EnableDropDownAction = disposables.add(instantiationService.createInstance(ExtensionsActions.EnableDropDownAction));
760
				testObject.extension = extensions[0];
761
				uninstallEvent.fire({ identifier: local.identifier, profileLocation: null! });
762
				assert.ok(!testObject.enabled);
763
			});
764
	});
765

766
	test('Test DisableForWorkspaceAction when there is no extension', () => {
767
		const testObject: ExtensionsActions.DisableForWorkspaceAction = disposables.add(instantiationService.createInstance(ExtensionsActions.DisableForWorkspaceAction));
768

769
		assert.ok(!testObject.enabled);
770
	});
771

772
	test('Test DisableForWorkspaceAction when the extension is disabled globally', () => {
773
		const local = aLocalExtension('a');
774
		return instantiationService.get(IWorkbenchExtensionEnablementService).setEnablement([local], EnablementState.DisabledGlobally)
775
			.then(() => {
776
				instantiationService.stubPromise(IExtensionManagementService, 'getInstalled', [local]);
777

778
				return instantiationService.get(IExtensionsWorkbenchService).queryLocal()
779
					.then(extensions => {
780
						const testObject: ExtensionsActions.DisableForWorkspaceAction = disposables.add(instantiationService.createInstance(ExtensionsActions.DisableForWorkspaceAction));
781
						testObject.extension = extensions[0];
782
						assert.ok(!testObject.enabled);
783
					});
784
			});
785
	});
786

787
	test('Test DisableForWorkspaceAction when the extension is disabled workspace', () => {
788
		const local = aLocalExtension('a');
789
		return instantiationService.get(IWorkbenchExtensionEnablementService).setEnablement([local], EnablementState.DisabledGlobally)
790
			.then(() => {
791
				instantiationService.stubPromise(IExtensionManagementService, 'getInstalled', [local]);
792

793
				return instantiationService.get(IExtensionsWorkbenchService).queryLocal()
794
					.then(extensions => {
795
						const testObject: ExtensionsActions.DisableForWorkspaceAction = disposables.add(instantiationService.createInstance(ExtensionsActions.DisableForWorkspaceAction));
796
						testObject.extension = extensions[0];
797
						assert.ok(!testObject.enabled);
798
					});
799
			});
800
	});
801

802
	test('Test DisableForWorkspaceAction when extension is enabled', () => {
803
		const local = aLocalExtension('a');
804
		instantiationService.stub(IExtensionService, {
805
			extensions: [toExtensionDescription(local)],
806
			onDidChangeExtensions: Event.None,
807
			whenInstalledExtensionsRegistered: () => Promise.resolve(true)
808
		});
809

810
		instantiationService.stubPromise(IExtensionManagementService, 'getInstalled', [local]);
811

812
		return instantiationService.get(IExtensionsWorkbenchService).queryLocal()
813
			.then(extensions => {
814
				const testObject: ExtensionsActions.DisableForWorkspaceAction = disposables.add(instantiationService.createInstance(ExtensionsActions.DisableForWorkspaceAction));
815
				testObject.extension = extensions[0];
816
				assert.ok(testObject.enabled);
817
			});
818
	});
819

820
	test('Test DisableGloballyAction when there is no extension', () => {
821
		const testObject: ExtensionsActions.DisableGloballyAction = disposables.add(instantiationService.createInstance(ExtensionsActions.DisableGloballyAction));
822

823
		assert.ok(!testObject.enabled);
824
	});
825

826
	test('Test DisableGloballyAction when the extension is disabled globally', () => {
827
		const local = aLocalExtension('a');
828
		return instantiationService.get(IWorkbenchExtensionEnablementService).setEnablement([local], EnablementState.DisabledGlobally)
829
			.then(() => {
830
				instantiationService.stubPromise(IExtensionManagementService, 'getInstalled', [local]);
831

832
				return instantiationService.get(IExtensionsWorkbenchService).queryLocal()
833
					.then(extensions => {
834
						const testObject: ExtensionsActions.DisableGloballyAction = disposables.add(instantiationService.createInstance(ExtensionsActions.DisableGloballyAction));
835
						testObject.extension = extensions[0];
836
						assert.ok(!testObject.enabled);
837
					});
838
			});
839
	});
840

841
	test('Test DisableGloballyAction when the extension is disabled for workspace', () => {
842
		const local = aLocalExtension('a');
843
		return instantiationService.get(IWorkbenchExtensionEnablementService).setEnablement([local], EnablementState.DisabledWorkspace)
844
			.then(() => {
845
				instantiationService.stubPromise(IExtensionManagementService, 'getInstalled', [local]);
846

847
				return instantiationService.get(IExtensionsWorkbenchService).queryLocal()
848
					.then(extensions => {
849
						const testObject: ExtensionsActions.DisableGloballyAction = disposables.add(instantiationService.createInstance(ExtensionsActions.DisableGloballyAction));
850
						testObject.extension = extensions[0];
851
						assert.ok(!testObject.enabled);
852
					});
853
			});
854
	});
855

856
	test('Test DisableGloballyAction when the extension is enabled', () => {
857
		const local = aLocalExtension('a');
858
		instantiationService.stubPromise(IExtensionManagementService, 'getInstalled', [local]);
859
		instantiationService.stub(IExtensionService, {
860
			extensions: [toExtensionDescription(local)],
861
			onDidChangeExtensions: Event.None,
862
			whenInstalledExtensionsRegistered: () => Promise.resolve(true)
863
		});
864

865
		return instantiationService.get(IExtensionsWorkbenchService).queryLocal()
866
			.then(extensions => {
867
				const testObject: ExtensionsActions.DisableGloballyAction = disposables.add(instantiationService.createInstance(ExtensionsActions.DisableGloballyAction));
868
				testObject.extension = extensions[0];
869
				assert.ok(testObject.enabled);
870
			});
871
	});
872

873
	test('Test DisableGloballyAction when extension is installed and enabled', () => {
874
		const local = aLocalExtension('a');
875
		instantiationService.stubPromise(IExtensionManagementService, 'getInstalled', [local]);
876
		instantiationService.stub(IExtensionService, {
877
			extensions: [toExtensionDescription(local)],
878
			onDidChangeExtensions: Event.None,
879
			whenInstalledExtensionsRegistered: () => Promise.resolve(true)
880
		});
881

882
		return instantiationService.get(IExtensionsWorkbenchService).queryLocal()
883
			.then(extensions => {
884
				const testObject: ExtensionsActions.DisableGloballyAction = disposables.add(instantiationService.createInstance(ExtensionsActions.DisableGloballyAction));
885
				testObject.extension = extensions[0];
886
				assert.ok(testObject.enabled);
887
			});
888
	});
889

890
	test('Test DisableGloballyAction when extension is installed and disabled globally', () => {
891
		const local = aLocalExtension('a');
892
		instantiationService.stub(IExtensionService, {
893
			extensions: [toExtensionDescription(local)],
894
			onDidChangeExtensions: Event.None,
895
			whenInstalledExtensionsRegistered: () => Promise.resolve(true)
896
		});
897

898
		return instantiationService.get(IWorkbenchExtensionEnablementService).setEnablement([local], EnablementState.DisabledGlobally)
899
			.then(() => {
900
				instantiationService.stubPromise(IExtensionManagementService, 'getInstalled', [local]);
901

902
				return instantiationService.get(IExtensionsWorkbenchService).queryLocal()
903
					.then(extensions => {
904
						const testObject: ExtensionsActions.DisableGloballyAction = disposables.add(instantiationService.createInstance(ExtensionsActions.DisableGloballyAction));
905
						testObject.extension = extensions[0];
906
						assert.ok(!testObject.enabled);
907
					});
908
			});
909
	});
910

911
	test('Test DisableGloballyAction when extension is uninstalled', () => {
912
		const gallery = aGalleryExtension('a');
913
		instantiationService.stubPromise(IExtensionGalleryService, 'query', aPage(gallery));
914
		instantiationService.stub(IExtensionService, {
915
			extensions: [toExtensionDescription(aLocalExtension('a'))],
916
			onDidChangeExtensions: Event.None,
917
			whenInstalledExtensionsRegistered: () => Promise.resolve(true)
918
		});
919

920
		return instantiationService.get(IExtensionsWorkbenchService).queryGallery(CancellationToken.None)
921
			.then(page => {
922
				const testObject: ExtensionsActions.DisableGloballyAction = disposables.add(instantiationService.createInstance(ExtensionsActions.DisableGloballyAction));
923
				testObject.extension = page.firstPage[0];
924
				assert.ok(!testObject.enabled);
925
			});
926
	});
927

928
	test('Test DisableGloballyAction when extension is installing', () => {
929
		const gallery = aGalleryExtension('a');
930
		instantiationService.stubPromise(IExtensionGalleryService, 'query', aPage(gallery));
931
		instantiationService.stub(IExtensionService, {
932
			extensions: [toExtensionDescription(aLocalExtension('a'))],
933
			onDidChangeExtensions: Event.None,
934
			whenInstalledExtensionsRegistered: () => Promise.resolve(true)
935
		});
936

937
		return instantiationService.get(IExtensionsWorkbenchService).queryGallery(CancellationToken.None)
938
			.then(page => {
939
				const testObject: ExtensionsActions.DisableGloballyAction = disposables.add(instantiationService.createInstance(ExtensionsActions.DisableGloballyAction));
940
				testObject.extension = page.firstPage[0];
941
				disposables.add(instantiationService.createInstance(ExtensionContainers, [testObject]));
942
				installEvent.fire({ identifier: gallery.identifier, source: gallery, profileLocation: null! });
943
				assert.ok(!testObject.enabled);
944
			});
945
	});
946

947
	test('Test DisableGloballyAction when extension is uninstalling', () => {
948
		const local = aLocalExtension('a');
949
		instantiationService.stubPromise(IExtensionManagementService, 'getInstalled', [local]);
950
		instantiationService.stub(IExtensionService, {
951
			extensions: [toExtensionDescription(local)],
952
			onDidChangeExtensions: Event.None,
953
			whenInstalledExtensionsRegistered: () => Promise.resolve(true)
954
		});
955

956
		return instantiationService.get(IExtensionsWorkbenchService).queryLocal()
957
			.then(extensions => {
958
				const testObject: ExtensionsActions.DisableGloballyAction = disposables.add(instantiationService.createInstance(ExtensionsActions.DisableGloballyAction));
959
				testObject.extension = extensions[0];
960
				disposables.add(instantiationService.createInstance(ExtensionContainers, [testObject]));
961
				uninstallEvent.fire({ identifier: local.identifier, profileLocation: null! });
962
				assert.ok(!testObject.enabled);
963
			});
964
	});
965

966
});
967

968
suite('ExtensionRuntimeStateAction', () => {
969

970
	const disposables = ensureNoDisposablesAreLeakedInTestSuite();
971

972
	setup(() => setupTest(disposables));
973

974
	test('Test Runtime State when there is no extension', () => {
975
		const testObject: ExtensionsActions.ExtensionRuntimeStateAction = disposables.add(instantiationService.createInstance(ExtensionsActions.ExtensionRuntimeStateAction));
976
		disposables.add(instantiationService.createInstance(ExtensionContainers, [testObject]));
977

978
		assert.ok(!testObject.enabled);
979
	});
980

981
	test('Test Runtime State when extension state is installing', async () => {
982
		const testObject: ExtensionsActions.ExtensionRuntimeStateAction = disposables.add(instantiationService.createInstance(ExtensionsActions.ExtensionRuntimeStateAction));
983
		disposables.add(instantiationService.createInstance(ExtensionContainers, [testObject]));
984
		const workbenchService = instantiationService.get(IExtensionsWorkbenchService);
985
		const gallery = aGalleryExtension('a');
986
		instantiationService.stubPromise(IExtensionGalleryService, 'query', aPage(gallery));
987
		const paged = await workbenchService.queryGallery(CancellationToken.None);
988
		testObject.extension = paged.firstPage[0];
989
		installEvent.fire({ identifier: gallery.identifier, source: gallery, profileLocation: null! });
990

991
		assert.ok(!testObject.enabled);
992
	});
993

994
	test('Test Runtime State when extension state is uninstalling', async () => {
995
		const testObject: ExtensionsActions.ExtensionRuntimeStateAction = disposables.add(instantiationService.createInstance(ExtensionsActions.ExtensionRuntimeStateAction));
996
		disposables.add(instantiationService.createInstance(ExtensionContainers, [testObject]));
997
		const local = aLocalExtension('a');
998
		instantiationService.stubPromise(IExtensionManagementService, 'getInstalled', [local]);
999

1000
		const extensions = await instantiationService.get(IExtensionsWorkbenchService).queryLocal();
1001
		testObject.extension = extensions[0];
1002
		uninstallEvent.fire({ identifier: local.identifier, profileLocation: null! });
1003
		assert.ok(!testObject.enabled);
1004
	});
1005

1006
	test('Test Runtime State when extension is newly installed', async () => {
1007
		const onDidChangeExtensionsEmitter = new Emitter<{ added: IExtensionDescription[]; removed: IExtensionDescription[] }>();
1008
		instantiationService.stub(IExtensionService, {
1009
			extensions: [toExtensionDescription(aLocalExtension('b'))],
1010
			onDidChangeExtensions: onDidChangeExtensionsEmitter.event,
1011
			canAddExtension: (extension) => false,
1012
			whenInstalledExtensionsRegistered: () => Promise.resolve(true)
1013
		});
1014
		const testObject: ExtensionsActions.ExtensionRuntimeStateAction = disposables.add(instantiationService.createInstance(ExtensionsActions.ExtensionRuntimeStateAction));
1015
		disposables.add(instantiationService.createInstance(ExtensionContainers, [testObject]));
1016
		const gallery = aGalleryExtension('a');
1017
		instantiationService.stubPromise(IExtensionGalleryService, 'query', aPage(gallery));
1018

1019
		const paged = await instantiationService.get(IExtensionsWorkbenchService).queryGallery(CancellationToken.None);
1020
		testObject.extension = paged.firstPage[0];
1021
		assert.ok(!testObject.enabled);
1022

1023
		installEvent.fire({ identifier: gallery.identifier, source: gallery, profileLocation: null! });
1024
		const promise = Event.toPromise(testObject.onDidChange);
1025
		didInstallEvent.fire([{ identifier: gallery.identifier, source: gallery, operation: InstallOperation.Install, local: aLocalExtension('a', gallery, gallery), profileLocation: null! }]);
1026
		await promise;
1027
		assert.ok(testObject.enabled);
1028
		assert.strictEqual(testObject.tooltip, `Please restart extensions to enable this extension.`);
1029
	});
1030

1031
	test('Test Runtime State when extension is newly installed and ext host restart is not required', async () => {
1032
		const onDidChangeExtensionsEmitter = new Emitter<{ added: IExtensionDescription[]; removed: IExtensionDescription[] }>();
1033
		instantiationService.stub(IExtensionService, {
1034
			extensions: [toExtensionDescription(aLocalExtension('b'))],
1035
			onDidChangeExtensions: onDidChangeExtensionsEmitter.event,
1036
			canAddExtension: (extension) => true,
1037
			whenInstalledExtensionsRegistered: () => Promise.resolve(true)
1038
		});
1039
		instantiationService.set(IExtensionsWorkbenchService, disposables.add(instantiationService.createInstance(ExtensionsWorkbenchService)));
1040
		const testObject: ExtensionsActions.ExtensionRuntimeStateAction = disposables.add(instantiationService.createInstance(ExtensionsActions.ExtensionRuntimeStateAction));
1041
		disposables.add(instantiationService.createInstance(ExtensionContainers, [testObject]));
1042
		const gallery = aGalleryExtension('a');
1043
		instantiationService.stubPromise(IExtensionGalleryService, 'query', aPage(gallery));
1044

1045
		const paged = await instantiationService.get(IExtensionsWorkbenchService).queryGallery(CancellationToken.None);
1046
		testObject.extension = paged.firstPage[0];
1047
		assert.ok(!testObject.enabled);
1048

1049
		installEvent.fire({ identifier: gallery.identifier, source: gallery, profileLocation: null! });
1050
		didInstallEvent.fire([{ identifier: gallery.identifier, source: gallery, operation: InstallOperation.Install, local: aLocalExtension('a', gallery, gallery), profileLocation: null! }]);
1051
		assert.ok(!testObject.enabled);
1052
	});
1053

1054
	test('Test Runtime State when extension is installed and uninstalled', async () => {
1055
		instantiationService.stub(IExtensionService, {
1056
			extensions: [toExtensionDescription(aLocalExtension('b'))],
1057
			onDidChangeExtensions: Event.None,
1058
			canRemoveExtension: (extension) => false,
1059
			canAddExtension: (extension) => false,
1060
			whenInstalledExtensionsRegistered: () => Promise.resolve(true)
1061
		});
1062
		const testObject: ExtensionsActions.ExtensionRuntimeStateAction = disposables.add(instantiationService.createInstance(ExtensionsActions.ExtensionRuntimeStateAction));
1063
		disposables.add(instantiationService.createInstance(ExtensionContainers, [testObject]));
1064
		const gallery = aGalleryExtension('a');
1065
		instantiationService.stubPromise(IExtensionGalleryService, 'query', aPage(gallery));
1066
		const paged = await instantiationService.get(IExtensionsWorkbenchService).queryGallery(CancellationToken.None);
1067

1068
		testObject.extension = paged.firstPage[0];
1069
		const identifier = gallery.identifier;
1070
		installEvent.fire({ identifier, source: gallery, profileLocation: null! });
1071
		didInstallEvent.fire([{ identifier, source: gallery, operation: InstallOperation.Install, local: aLocalExtension('a', gallery, { identifier }), profileLocation: null! }]);
1072
		uninstallEvent.fire({ identifier, profileLocation: null! });
1073
		didUninstallEvent.fire({ identifier, profileLocation: null! });
1074

1075
		assert.ok(!testObject.enabled);
1076
	});
1077

1078
	test('Test Runtime State when extension is uninstalled', async () => {
1079
		instantiationService.stub(IExtensionService, {
1080
			extensions: [toExtensionDescription(aLocalExtension('a', { version: '1.0.0' }))],
1081
			onDidChangeExtensions: Event.None,
1082
			canRemoveExtension: (extension) => false,
1083
			canAddExtension: (extension) => false,
1084
			whenInstalledExtensionsRegistered: () => Promise.resolve(true)
1085
		});
1086
		instantiationService.set(IExtensionsWorkbenchService, disposables.add(instantiationService.createInstance(ExtensionsWorkbenchService)));
1087
		const testObject: ExtensionsActions.ExtensionRuntimeStateAction = disposables.add(instantiationService.createInstance(ExtensionsActions.ExtensionRuntimeStateAction));
1088
		disposables.add(instantiationService.createInstance(ExtensionContainers, [testObject]));
1089
		const local = aLocalExtension('a');
1090
		instantiationService.stubPromise(IExtensionManagementService, 'getInstalled', [local]);
1091
		const extensions = await instantiationService.get(IExtensionsWorkbenchService).queryLocal();
1092
		testObject.extension = extensions[0];
1093

1094
		uninstallEvent.fire({ identifier: local.identifier, profileLocation: null! });
1095
		didUninstallEvent.fire({ identifier: local.identifier, profileLocation: null! });
1096
		assert.ok(testObject.enabled);
1097
		assert.strictEqual(testObject.tooltip, `Please restart extensions to complete the uninstallation of this extension.`);
1098
	});
1099

1100
	test('Test Runtime State when extension is uninstalled and can be removed', async () => {
1101
		const local = aLocalExtension('a');
1102
		instantiationService.stub(IExtensionService, {
1103
			extensions: [toExtensionDescription(local)],
1104
			onDidChangeExtensions: Event.None,
1105
			canRemoveExtension: (extension) => true,
1106
			canAddExtension: (extension) => true,
1107
			whenInstalledExtensionsRegistered: () => Promise.resolve(true)
1108
		});
1109
		const testObject: ExtensionsActions.ExtensionRuntimeStateAction = disposables.add(instantiationService.createInstance(ExtensionsActions.ExtensionRuntimeStateAction));
1110
		disposables.add(instantiationService.createInstance(ExtensionContainers, [testObject]));
1111
		instantiationService.stubPromise(IExtensionManagementService, 'getInstalled', [local]);
1112
		const extensions = await instantiationService.get(IExtensionsWorkbenchService).queryLocal();
1113
		testObject.extension = extensions[0];
1114

1115
		uninstallEvent.fire({ identifier: local.identifier, profileLocation: null! });
1116
		didUninstallEvent.fire({ identifier: local.identifier, profileLocation: null! });
1117
		assert.ok(!testObject.enabled);
1118
	});
1119

1120
	test('Test Runtime State when extension is uninstalled and installed', async () => {
1121
		instantiationService.stub(IExtensionService, {
1122
			extensions: [toExtensionDescription(aLocalExtension('a', { version: '1.0.0' }))],
1123
			onDidChangeExtensions: Event.None,
1124
			canRemoveExtension: (extension) => false,
1125
			canAddExtension: (extension) => false,
1126
			whenInstalledExtensionsRegistered: () => Promise.resolve(true)
1127
		});
1128
		instantiationService.set(IExtensionsWorkbenchService, disposables.add(instantiationService.createInstance(ExtensionsWorkbenchService)));
1129
		const testObject: ExtensionsActions.ExtensionRuntimeStateAction = disposables.add(instantiationService.createInstance(ExtensionsActions.ExtensionRuntimeStateAction));
1130
		disposables.add(instantiationService.createInstance(ExtensionContainers, [testObject]));
1131
		const local = aLocalExtension('a');
1132
		instantiationService.stubPromise(IExtensionManagementService, 'getInstalled', [local]);
1133
		const extensions = await instantiationService.get(IExtensionsWorkbenchService).queryLocal();
1134

1135
		testObject.extension = extensions[0];
1136
		uninstallEvent.fire({ identifier: local.identifier, profileLocation: null! });
1137
		didUninstallEvent.fire({ identifier: local.identifier, profileLocation: null! });
1138

1139
		const gallery = aGalleryExtension('a');
1140
		const identifier = gallery.identifier;
1141
		installEvent.fire({ identifier, source: gallery, profileLocation: null! });
1142
		didInstallEvent.fire([{ identifier, source: gallery, operation: InstallOperation.Install, local, profileLocation: null! }]);
1143

1144
		assert.ok(!testObject.enabled);
1145
	});
1146

1147
	test('Test Runtime State when extension is updated while running', async () => {
1148
		instantiationService.stub(IExtensionService, {
1149
			extensions: [toExtensionDescription(aLocalExtension('a', { version: '1.0.1' }))],
1150
			onDidChangeExtensions: Event.None,
1151
			canRemoveExtension: (extension) => true,
1152
			canAddExtension: (extension) => false,
1153
			whenInstalledExtensionsRegistered: () => Promise.resolve(true)
1154
		});
1155
		instantiationService.set(IExtensionsWorkbenchService, disposables.add(instantiationService.createInstance(ExtensionsWorkbenchService)));
1156
		const testObject: ExtensionsActions.ExtensionRuntimeStateAction = disposables.add(instantiationService.createInstance(ExtensionsActions.ExtensionRuntimeStateAction));
1157
		disposables.add(instantiationService.createInstance(ExtensionContainers, [testObject]));
1158
		const local = aLocalExtension('a', { version: '1.0.1' });
1159
		const workbenchService = instantiationService.get(IExtensionsWorkbenchService);
1160
		instantiationService.stubPromise(IExtensionManagementService, 'getInstalled', [local]);
1161
		const extensions = await workbenchService.queryLocal();
1162
		testObject.extension = extensions[0];
1163

1164
		return new Promise<void>(c => {
1165
			disposables.add(testObject.onDidChange(() => {
1166
				if (testObject.enabled && testObject.tooltip === `Please restart extensions to enable the updated extension.`) {
1167
					c();
1168
				}
1169
			}));
1170
			const gallery = aGalleryExtension('a', { uuid: local.identifier.id, version: '1.0.2' });
1171
			installEvent.fire({ identifier: gallery.identifier, source: gallery, profileLocation: null! });
1172
			didInstallEvent.fire([{ identifier: gallery.identifier, source: gallery, operation: InstallOperation.Install, local: aLocalExtension('a', gallery, gallery), profileLocation: null! }]);
1173
		});
1174
	});
1175

1176
	test('Test Runtime State when extension is updated when not running', async () => {
1177
		instantiationService.stub(IExtensionService, {
1178
			extensions: [toExtensionDescription(aLocalExtension('b'))],
1179
			onDidChangeExtensions: Event.None,
1180
			canRemoveExtension: (extension) => false,
1181
			canAddExtension: (extension) => false,
1182
			whenInstalledExtensionsRegistered: () => Promise.resolve(true)
1183
		});
1184
		const local = aLocalExtension('a', { version: '1.0.1' });
1185
		await instantiationService.get(IWorkbenchExtensionEnablementService).setEnablement([local], EnablementState.DisabledGlobally);
1186
		const testObject: ExtensionsActions.ExtensionRuntimeStateAction = disposables.add(instantiationService.createInstance(ExtensionsActions.ExtensionRuntimeStateAction));
1187
		disposables.add(instantiationService.createInstance(ExtensionContainers, [testObject]));
1188
		const workbenchService = instantiationService.get(IExtensionsWorkbenchService);
1189
		instantiationService.stubPromise(IExtensionManagementService, 'getInstalled', [local]);
1190
		const extensions = await workbenchService.queryLocal();
1191
		testObject.extension = extensions[0];
1192

1193
		const gallery = aGalleryExtension('a', { identifier: local.identifier, version: '1.0.2' });
1194
		installEvent.fire({ identifier: gallery.identifier, source: gallery, profileLocation: null! });
1195
		didInstallEvent.fire([{ identifier: gallery.identifier, source: gallery, operation: InstallOperation.Update, local: aLocalExtension('a', gallery, gallery), profileLocation: null! }]);
1196

1197
		assert.ok(!testObject.enabled);
1198
	});
1199

1200
	test('Test Runtime State when extension is disabled when running', async () => {
1201
		instantiationService.stub(IExtensionService, {
1202
			extensions: [toExtensionDescription(aLocalExtension('a'))],
1203
			onDidChangeExtensions: Event.None,
1204
			canRemoveExtension: (extension) => false,
1205
			canAddExtension: (extension) => false,
1206
			whenInstalledExtensionsRegistered: () => Promise.resolve(true)
1207
		});
1208
		instantiationService.set(IExtensionsWorkbenchService, disposables.add(instantiationService.createInstance(ExtensionsWorkbenchService)));
1209
		const testObject: ExtensionsActions.ExtensionRuntimeStateAction = disposables.add(instantiationService.createInstance(ExtensionsActions.ExtensionRuntimeStateAction));
1210
		disposables.add(instantiationService.createInstance(ExtensionContainers, [testObject]));
1211
		const local = aLocalExtension('a');
1212
		const workbenchService = instantiationService.get(IExtensionsWorkbenchService);
1213
		instantiationService.stubPromise(IExtensionManagementService, 'getInstalled', [local]);
1214
		const extensions = await workbenchService.queryLocal();
1215
		testObject.extension = extensions[0];
1216
		await workbenchService.setEnablement(extensions[0], EnablementState.DisabledGlobally);
1217
		await testObject.update();
1218

1219
		assert.ok(testObject.enabled);
1220
		assert.strictEqual(`Please restart extensions to disable this extension.`, testObject.tooltip);
1221
	});
1222

1223
	test('Test Runtime State when extension enablement is toggled when running', async () => {
1224
		instantiationService.stub(IExtensionService, {
1225
			extensions: [toExtensionDescription(aLocalExtension('a', { version: '1.0.0' }))],
1226
			onDidChangeExtensions: Event.None,
1227
			canRemoveExtension: (extension) => false,
1228
			canAddExtension: (extension) => false,
1229
			whenInstalledExtensionsRegistered: () => Promise.resolve(true)
1230
		});
1231
		instantiationService.set(IExtensionsWorkbenchService, disposables.add(instantiationService.createInstance(ExtensionsWorkbenchService)));
1232
		const testObject: ExtensionsActions.ExtensionRuntimeStateAction = disposables.add(instantiationService.createInstance(ExtensionsActions.ExtensionRuntimeStateAction));
1233
		disposables.add(instantiationService.createInstance(ExtensionContainers, [testObject]));
1234
		const local = aLocalExtension('a');
1235
		const workbenchService = instantiationService.get(IExtensionsWorkbenchService);
1236
		instantiationService.stubPromise(IExtensionManagementService, 'getInstalled', [local]);
1237
		const extensions = await workbenchService.queryLocal();
1238
		testObject.extension = extensions[0];
1239
		await workbenchService.setEnablement(extensions[0], EnablementState.DisabledGlobally);
1240
		await workbenchService.setEnablement(extensions[0], EnablementState.EnabledGlobally);
1241
		assert.ok(!testObject.enabled);
1242
	});
1243

1244
	test('Test Runtime State when extension is enabled when not running', async () => {
1245
		instantiationService.stub(IExtensionService, {
1246
			extensions: [toExtensionDescription(aLocalExtension('b'))],
1247
			onDidChangeExtensions: Event.None,
1248
			canRemoveExtension: (extension) => false,
1249
			canAddExtension: (extension) => false,
1250
			whenInstalledExtensionsRegistered: () => Promise.resolve(true)
1251
		});
1252
		const local = aLocalExtension('a');
1253
		await instantiationService.get(IWorkbenchExtensionEnablementService).setEnablement([local], EnablementState.DisabledGlobally);
1254
		const testObject: ExtensionsActions.ExtensionRuntimeStateAction = disposables.add(instantiationService.createInstance(ExtensionsActions.ExtensionRuntimeStateAction));
1255
		disposables.add(instantiationService.createInstance(ExtensionContainers, [testObject]));
1256
		const workbenchService = instantiationService.get(IExtensionsWorkbenchService);
1257
		instantiationService.stubPromise(IExtensionManagementService, 'getInstalled', [local]);
1258
		const extensions = await workbenchService.queryLocal();
1259
		testObject.extension = extensions[0];
1260
		await workbenchService.setEnablement(extensions[0], EnablementState.EnabledGlobally);
1261
		await testObject.update();
1262
		assert.ok(testObject.enabled);
1263
		assert.strictEqual(`Please restart extensions to enable this extension.`, testObject.tooltip);
1264
	});
1265

1266
	test('Test Runtime State when extension enablement is toggled when not running', async () => {
1267
		instantiationService.stub(IExtensionService, {
1268
			extensions: [toExtensionDescription(aLocalExtension('b'))],
1269
			onDidChangeExtensions: Event.None,
1270
			canRemoveExtension: (extension) => false,
1271
			canAddExtension: (extension) => false,
1272
			whenInstalledExtensionsRegistered: () => Promise.resolve(true)
1273
		});
1274
		const local = aLocalExtension('a');
1275
		await instantiationService.get(IWorkbenchExtensionEnablementService).setEnablement([local], EnablementState.DisabledGlobally);
1276
		const testObject: ExtensionsActions.ExtensionRuntimeStateAction = disposables.add(instantiationService.createInstance(ExtensionsActions.ExtensionRuntimeStateAction));
1277
		disposables.add(instantiationService.createInstance(ExtensionContainers, [testObject]));
1278
		const workbenchService = instantiationService.get(IExtensionsWorkbenchService);
1279
		instantiationService.stubPromise(IExtensionManagementService, 'getInstalled', [local]);
1280
		const extensions = await workbenchService.queryLocal();
1281
		testObject.extension = extensions[0];
1282
		await workbenchService.setEnablement(extensions[0], EnablementState.EnabledGlobally);
1283
		await workbenchService.setEnablement(extensions[0], EnablementState.DisabledGlobally);
1284
		assert.ok(!testObject.enabled);
1285
	});
1286

1287
	test('Test Runtime State when extension is updated when not running and enabled', async () => {
1288
		instantiationService.stub(IExtensionService, {
1289
			extensions: [toExtensionDescription(aLocalExtension('a'))],
1290
			onDidChangeExtensions: Event.None,
1291
			canRemoveExtension: (extension) => false,
1292
			canAddExtension: (extension) => false,
1293
			whenInstalledExtensionsRegistered: () => Promise.resolve(true)
1294
		});
1295
		const local = aLocalExtension('a', { version: '1.0.1' });
1296
		await instantiationService.get(IWorkbenchExtensionEnablementService).setEnablement([local], EnablementState.DisabledGlobally);
1297
		const testObject: ExtensionsActions.ExtensionRuntimeStateAction = disposables.add(instantiationService.createInstance(ExtensionsActions.ExtensionRuntimeStateAction));
1298
		disposables.add(instantiationService.createInstance(ExtensionContainers, [testObject]));
1299
		const workbenchService = instantiationService.get(IExtensionsWorkbenchService);
1300
		instantiationService.stubPromise(IExtensionManagementService, 'getInstalled', [local]);
1301
		const extensions = await workbenchService.queryLocal();
1302
		testObject.extension = extensions[0];
1303

1304
		const gallery = aGalleryExtension('a', { identifier: local.identifier, version: '1.0.2' });
1305
		installEvent.fire({ identifier: gallery.identifier, source: gallery, profileLocation: null! });
1306
		didInstallEvent.fire([{ identifier: gallery.identifier, source: gallery, operation: InstallOperation.Install, local: aLocalExtension('a', gallery, gallery), profileLocation: null! }]);
1307
		await workbenchService.setEnablement(extensions[0], EnablementState.EnabledGlobally);
1308
		await testObject.update();
1309
		assert.ok(testObject.enabled);
1310
		assert.strictEqual(`Please restart extensions to enable this extension.`, testObject.tooltip);
1311
	});
1312

1313
	test('Test Runtime State when a localization extension is newly installed', async () => {
1314
		instantiationService.stub(IExtensionService, {
1315
			extensions: [toExtensionDescription(aLocalExtension('b'))],
1316
			onDidChangeExtensions: Event.None,
1317
			canRemoveExtension: (extension) => false,
1318
			canAddExtension: (extension) => false,
1319
			whenInstalledExtensionsRegistered: () => Promise.resolve(true)
1320
		});
1321
		const testObject: ExtensionsActions.ExtensionRuntimeStateAction = disposables.add(instantiationService.createInstance(ExtensionsActions.ExtensionRuntimeStateAction));
1322
		disposables.add(instantiationService.createInstance(ExtensionContainers, [testObject]));
1323
		const gallery = aGalleryExtension('a');
1324
		instantiationService.stubPromise(IExtensionGalleryService, 'query', aPage(gallery));
1325

1326
		const paged = await instantiationService.get(IExtensionsWorkbenchService).queryGallery(CancellationToken.None);
1327
		testObject.extension = paged.firstPage[0];
1328
		assert.ok(!testObject.enabled);
1329

1330
		installEvent.fire({ identifier: gallery.identifier, source: gallery, profileLocation: null! });
1331
		didInstallEvent.fire([{ identifier: gallery.identifier, source: gallery, operation: InstallOperation.Install, local: aLocalExtension('a', { ...gallery, ...{ contributes: <IExtensionContributions>{ localizations: [{ languageId: 'de', translations: [] }] } } }, gallery), profileLocation: null! }]);
1332
		assert.ok(!testObject.enabled);
1333
	});
1334

1335
	test('Test Runtime State when a localization extension is updated while running', async () => {
1336
		instantiationService.stub(IExtensionService, {
1337
			extensions: [toExtensionDescription(aLocalExtension('a', { version: '1.0.1' }))],
1338
			onDidChangeExtensions: Event.None,
1339
			canRemoveExtension: (extension) => false,
1340
			canAddExtension: (extension) => false,
1341
			whenInstalledExtensionsRegistered: () => Promise.resolve(true)
1342
		});
1343
		const testObject: ExtensionsActions.ExtensionRuntimeStateAction = disposables.add(instantiationService.createInstance(ExtensionsActions.ExtensionRuntimeStateAction));
1344
		disposables.add(instantiationService.createInstance(ExtensionContainers, [testObject]));
1345
		const local = aLocalExtension('a', { version: '1.0.1', contributes: <IExtensionContributions>{ localizations: [{ languageId: 'de', translations: [] }] } });
1346
		const workbenchService = instantiationService.get(IExtensionsWorkbenchService);
1347
		instantiationService.stubPromise(IExtensionManagementService, 'getInstalled', [local]);
1348
		const extensions = await workbenchService.queryLocal();
1349
		testObject.extension = extensions[0];
1350

1351
		const gallery = aGalleryExtension('a', { uuid: local.identifier.id, version: '1.0.2' });
1352
		installEvent.fire({ identifier: gallery.identifier, source: gallery, profileLocation: null! });
1353
		didInstallEvent.fire([{ identifier: gallery.identifier, source: gallery, operation: InstallOperation.Install, local: aLocalExtension('a', { ...gallery, ...{ contributes: <IExtensionContributions>{ localizations: [{ languageId: 'de', translations: [] }] } } }, gallery), profileLocation: null! }]);
1354
		assert.ok(!testObject.enabled);
1355
	});
1356

1357
	test('Test Runtime State when extension is not installed but extension from different server is installed and running', async () => {
1358
		// multi server setup
1359
		const gallery = aGalleryExtension('a');
1360
		const localExtension = aLocalExtension('a', { extensionKind: ['workspace'] }, { location: URI.file('pub.a') });
1361
		const remoteExtension = aLocalExtension('a', { extensionKind: ['workspace'] }, { location: URI.file('pub.a').with({ scheme: Schemas.vscodeRemote }) });
1362
		const extensionManagementServerService = aMultiExtensionManagementServerService(instantiationService, createExtensionManagementService([localExtension]), createExtensionManagementService([remoteExtension]));
1363
		instantiationService.stub(IExtensionManagementServerService, extensionManagementServerService);
1364
		instantiationService.stub(IWorkbenchExtensionEnablementService, disposables.add(new TestExtensionEnablementService(instantiationService)));
1365
		const onDidChangeExtensionsEmitter = new Emitter<{ added: IExtensionDescription[]; removed: IExtensionDescription[] }>();
1366
		instantiationService.stub(IExtensionService, {
1367
			extensions: [toExtensionDescription(remoteExtension)],
1368
			onDidChangeExtensions: onDidChangeExtensionsEmitter.event,
1369
			canAddExtension: (extension) => false,
1370
			whenInstalledExtensionsRegistered: () => Promise.resolve(true)
1371
		});
1372
		const workbenchService: IExtensionsWorkbenchService = disposables.add(instantiationService.createInstance(ExtensionsWorkbenchService));
1373
		instantiationService.set(IExtensionsWorkbenchService, workbenchService);
1374

1375
		const testObject: ExtensionsActions.ExtensionRuntimeStateAction = disposables.add(instantiationService.createInstance(ExtensionsActions.ExtensionRuntimeStateAction));
1376
		disposables.add(instantiationService.createInstance(ExtensionContainers, [testObject]));
1377
		instantiationService.stubPromise(IExtensionGalleryService, 'query', aPage(gallery));
1378

1379
		await workbenchService.queryGallery(CancellationToken.None);
1380
		const extensions = await workbenchService.queryLocal(extensionManagementServerService.localExtensionManagementServer!);
1381
		testObject.extension = extensions[0];
1382
		assert.ok(testObject.extension);
1383
		assert.ok(!testObject.enabled);
1384
	});
1385

1386
	test('Test Runtime State when extension is uninstalled but extension from different server is installed and running', async () => {
1387
		// multi server setup
1388
		const gallery = aGalleryExtension('a');
1389
		const localExtension = aLocalExtension('a', { extensionKind: ['workspace'] }, { location: URI.file('pub.a') });
1390
		const remoteExtension = aLocalExtension('a', { extensionKind: ['workspace'] }, { location: URI.file('pub.a').with({ scheme: Schemas.vscodeRemote }) });
1391
		const localExtensionManagementService = createExtensionManagementService([localExtension]);
1392
		const uninstallEvent = new Emitter<UninstallExtensionEvent>();
1393
		const onDidUninstallEvent = new Emitter<{ identifier: IExtensionIdentifier; profileLocation: URI }>();
1394
		localExtensionManagementService.onUninstallExtension = uninstallEvent.event;
1395
		localExtensionManagementService.onDidUninstallExtension = onDidUninstallEvent.event;
1396
		const extensionManagementServerService = aMultiExtensionManagementServerService(instantiationService, localExtensionManagementService, createExtensionManagementService([remoteExtension]));
1397
		instantiationService.stub(IExtensionManagementServerService, extensionManagementServerService);
1398
		instantiationService.stub(IWorkbenchExtensionEnablementService, disposables.add(new TestExtensionEnablementService(instantiationService)));
1399
		const onDidChangeExtensionsEmitter = new Emitter<{ added: IExtensionDescription[]; removed: IExtensionDescription[] }>();
1400
		instantiationService.stub(IExtensionService, {
1401
			extensions: [toExtensionDescription(remoteExtension)],
1402
			onDidChangeExtensions: onDidChangeExtensionsEmitter.event,
1403
			canAddExtension: (extension) => false,
1404
			whenInstalledExtensionsRegistered: () => Promise.resolve(true)
1405
		});
1406
		const workbenchService: IExtensionsWorkbenchService = disposables.add(instantiationService.createInstance(ExtensionsWorkbenchService));
1407
		instantiationService.set(IExtensionsWorkbenchService, workbenchService);
1408

1409
		const testObject: ExtensionsActions.ExtensionRuntimeStateAction = disposables.add(instantiationService.createInstance(ExtensionsActions.ExtensionRuntimeStateAction));
1410
		disposables.add(instantiationService.createInstance(ExtensionContainers, [testObject]));
1411
		instantiationService.stubPromise(IExtensionGalleryService, 'query', aPage(gallery));
1412

1413
		await workbenchService.queryGallery(CancellationToken.None);
1414
		const extensions = await workbenchService.queryLocal(extensionManagementServerService.localExtensionManagementServer!);
1415
		testObject.extension = extensions[0];
1416
		assert.ok(testObject.extension);
1417
		assert.ok(!testObject.enabled);
1418

1419
		uninstallEvent.fire({ identifier: localExtension.identifier, profileLocation: null! });
1420
		didUninstallEvent.fire({ identifier: localExtension.identifier, profileLocation: null! });
1421

1422
		assert.ok(!testObject.enabled);
1423
	});
1424

1425
	test('Test Runtime State when workspace extension is disabled on local server and installed in remote server', async () => {
1426
		// multi server setup
1427
		const gallery = aGalleryExtension('a');
1428
		const remoteExtensionManagementService = createExtensionManagementService([]);
1429
		const onDidInstallEvent = new Emitter<readonly InstallExtensionResult[]>();
1430
		remoteExtensionManagementService.onDidInstallExtensions = onDidInstallEvent.event;
1431
		const localExtension = aLocalExtension('a', { extensionKind: ['workspace'] }, { location: URI.file('pub.a') });
1432
		const extensionManagementServerService = aMultiExtensionManagementServerService(instantiationService, createExtensionManagementService([localExtension]), remoteExtensionManagementService);
1433
		instantiationService.stub(IExtensionManagementServerService, extensionManagementServerService);
1434
		instantiationService.stub(IWorkbenchExtensionEnablementService, disposables.add(new TestExtensionEnablementService(instantiationService)));
1435
		const workbenchService: IExtensionsWorkbenchService = disposables.add(instantiationService.createInstance(ExtensionsWorkbenchService));
1436
		instantiationService.set(IExtensionsWorkbenchService, workbenchService);
1437

1438
		const onDidChangeExtensionsEmitter = new Emitter<{ added: IExtensionDescription[]; removed: IExtensionDescription[] }>();
1439
		instantiationService.stub(IExtensionService, {
1440
			extensions: [],
1441
			onDidChangeExtensions: onDidChangeExtensionsEmitter.event,
1442
			canAddExtension: (extension) => false,
1443
			whenInstalledExtensionsRegistered: () => Promise.resolve(true)
1444
		});
1445
		const testObject: ExtensionsActions.ExtensionRuntimeStateAction = disposables.add(instantiationService.createInstance(ExtensionsActions.ExtensionRuntimeStateAction));
1446
		disposables.add(instantiationService.createInstance(ExtensionContainers, [testObject]));
1447
		instantiationService.stubPromise(IExtensionGalleryService, 'query', aPage(gallery));
1448

1449
		await workbenchService.queryGallery(CancellationToken.None);
1450
		const extensions = await workbenchService.queryLocal(extensionManagementServerService.localExtensionManagementServer!);
1451
		testObject.extension = extensions[0];
1452
		assert.ok(testObject.extension);
1453
		assert.ok(!testObject.enabled);
1454

1455
		const remoteExtension = aLocalExtension('a', { extensionKind: ['workspace'] }, { location: URI.file('pub.a').with({ scheme: Schemas.vscodeRemote }) });
1456
		const promise = Event.toPromise(testObject.onDidChange);
1457
		onDidInstallEvent.fire([{ identifier: remoteExtension.identifier, local: remoteExtension, operation: InstallOperation.Install, profileLocation: null! }]);
1458

1459
		await promise;
1460
		assert.ok(testObject.enabled);
1461
		assert.strictEqual(testObject.tooltip, `Please reload window to enable this extension.`);
1462
	});
1463

1464
	test('Test Runtime State when ui extension is disabled on remote server and installed in local server', async () => {
1465
		// multi server setup
1466
		const gallery = aGalleryExtension('a');
1467
		const localExtensionManagementService = createExtensionManagementService([]);
1468
		const onDidInstallEvent = new Emitter<readonly InstallExtensionResult[]>();
1469
		localExtensionManagementService.onDidInstallExtensions = onDidInstallEvent.event;
1470
		const remoteExtension = aLocalExtension('a', { extensionKind: ['ui'] }, { location: URI.file('pub.a').with({ scheme: Schemas.vscodeRemote }) });
1471
		const extensionManagementServerService = aMultiExtensionManagementServerService(instantiationService, localExtensionManagementService, createExtensionManagementService([remoteExtension]));
1472
		instantiationService.stub(IExtensionManagementServerService, extensionManagementServerService);
1473
		instantiationService.stub(IWorkbenchExtensionEnablementService, disposables.add(new TestExtensionEnablementService(instantiationService)));
1474
		const workbenchService: IExtensionsWorkbenchService = disposables.add(instantiationService.createInstance(ExtensionsWorkbenchService));
1475
		instantiationService.set(IExtensionsWorkbenchService, workbenchService);
1476

1477
		const onDidChangeExtensionsEmitter = new Emitter<{ added: IExtensionDescription[]; removed: IExtensionDescription[] }>();
1478
		instantiationService.stub(IExtensionService, {
1479
			extensions: [],
1480
			onDidChangeExtensions: onDidChangeExtensionsEmitter.event,
1481
			canAddExtension: (extension) => false,
1482
			whenInstalledExtensionsRegistered: () => Promise.resolve(true)
1483
		});
1484
		const testObject: ExtensionsActions.ExtensionRuntimeStateAction = disposables.add(instantiationService.createInstance(ExtensionsActions.ExtensionRuntimeStateAction));
1485
		disposables.add(instantiationService.createInstance(ExtensionContainers, [testObject]));
1486
		instantiationService.stubPromise(IExtensionGalleryService, 'query', aPage(gallery));
1487

1488
		await workbenchService.queryGallery(CancellationToken.None);
1489
		const extensions = await workbenchService.queryLocal(extensionManagementServerService.remoteExtensionManagementServer!);
1490
		testObject.extension = extensions[0];
1491
		assert.ok(testObject.extension);
1492
		assert.ok(!testObject.enabled);
1493

1494
		const localExtension = aLocalExtension('a', { extensionKind: ['ui'] }, { location: URI.file('pub.a') });
1495
		const promise = Event.toPromise(Event.filter(testObject.onDidChange, () => testObject.enabled));
1496
		onDidInstallEvent.fire([{ identifier: localExtension.identifier, local: localExtension, operation: InstallOperation.Install, profileLocation: null! }]);
1497

1498
		await promise;
1499
		assert.ok(testObject.enabled);
1500
		assert.strictEqual(testObject.tooltip, `Please reload window to enable this extension.`);
1501
	});
1502

1503
	test('Test Runtime State for remote ui extension is disabled when it is installed and enabled in local server', async () => {
1504
		// multi server setup
1505
		const gallery = aGalleryExtension('a');
1506
		const localExtension = aLocalExtension('a', { extensionKind: ['ui'] }, { location: URI.file('pub.a') });
1507
		const localExtensionManagementService = createExtensionManagementService([localExtension]);
1508
		const onDidInstallEvent = new Emitter<readonly InstallExtensionResult[]>();
1509
		localExtensionManagementService.onDidInstallExtensions = onDidInstallEvent.event;
1510
		const remoteExtension = aLocalExtension('a', { extensionKind: ['ui'] }, { location: URI.file('pub.a').with({ scheme: Schemas.vscodeRemote }) });
1511
		const extensionManagementServerService = aMultiExtensionManagementServerService(instantiationService, localExtensionManagementService, createExtensionManagementService([remoteExtension]));
1512
		instantiationService.stub(IExtensionManagementServerService, extensionManagementServerService);
1513
		instantiationService.stub(IWorkbenchExtensionEnablementService, disposables.add(new TestExtensionEnablementService(instantiationService)));
1514
		const onDidChangeExtensionsEmitter = new Emitter<{ added: IExtensionDescription[]; removed: IExtensionDescription[] }>();
1515
		instantiationService.stub(IExtensionService, {
1516
			extensions: [toExtensionDescription(localExtension)],
1517
			onDidChangeExtensions: onDidChangeExtensionsEmitter.event,
1518
			canAddExtension: (extension) => false,
1519
			whenInstalledExtensionsRegistered: () => Promise.resolve(true)
1520
		});
1521
		const workbenchService: IExtensionsWorkbenchService = disposables.add(instantiationService.createInstance(ExtensionsWorkbenchService));
1522
		instantiationService.set(IExtensionsWorkbenchService, workbenchService);
1523

1524
		const testObject: ExtensionsActions.ExtensionRuntimeStateAction = disposables.add(instantiationService.createInstance(ExtensionsActions.ExtensionRuntimeStateAction));
1525
		disposables.add(instantiationService.createInstance(ExtensionContainers, [testObject]));
1526
		instantiationService.stubPromise(IExtensionGalleryService, 'query', aPage(gallery));
1527

1528
		await workbenchService.queryGallery(CancellationToken.None);
1529
		const extensions = await workbenchService.queryLocal(extensionManagementServerService.remoteExtensionManagementServer!);
1530
		testObject.extension = extensions[0];
1531
		assert.ok(testObject.extension);
1532
		assert.ok(!testObject.enabled);
1533
	});
1534

1535
	test('Test Runtime State for remote workspace+ui extension is enabled when it is installed and enabled in local server', async () => {
1536
		// multi server setup
1537
		const gallery = aGalleryExtension('a');
1538
		const localExtension = aLocalExtension('a', { extensionKind: ['workspace', 'ui'] }, { location: URI.file('pub.a') });
1539
		const localExtensionManagementService = createExtensionManagementService([localExtension]);
1540
		const onDidInstallEvent = new Emitter<readonly InstallExtensionResult[]>();
1541
		localExtensionManagementService.onDidInstallExtensions = onDidInstallEvent.event;
1542
		const remoteExtension = aLocalExtension('a', { extensionKind: ['workspace', 'ui'] }, { location: URI.file('pub.a').with({ scheme: Schemas.vscodeRemote }) });
1543
		const extensionManagementServerService = aMultiExtensionManagementServerService(instantiationService, localExtensionManagementService, createExtensionManagementService([remoteExtension]));
1544
		instantiationService.stub(IExtensionManagementServerService, extensionManagementServerService);
1545
		instantiationService.stub(IWorkbenchExtensionEnablementService, disposables.add(new TestExtensionEnablementService(instantiationService)));
1546
		const workbenchService: IExtensionsWorkbenchService = disposables.add(instantiationService.createInstance(ExtensionsWorkbenchService));
1547
		instantiationService.set(IExtensionsWorkbenchService, workbenchService);
1548

1549
		const onDidChangeExtensionsEmitter = new Emitter<{ added: IExtensionDescription[]; removed: IExtensionDescription[] }>();
1550
		instantiationService.stub(IExtensionService, {
1551
			extensions: [toExtensionDescription(localExtension)],
1552
			onDidChangeExtensions: onDidChangeExtensionsEmitter.event,
1553
			canAddExtension: (extension) => false,
1554
			whenInstalledExtensionsRegistered: () => Promise.resolve(true)
1555
		});
1556
		const testObject: ExtensionsActions.ExtensionRuntimeStateAction = disposables.add(instantiationService.createInstance(ExtensionsActions.ExtensionRuntimeStateAction));
1557
		disposables.add(instantiationService.createInstance(ExtensionContainers, [testObject]));
1558
		instantiationService.stubPromise(IExtensionGalleryService, 'query', aPage(gallery));
1559

1560
		await workbenchService.queryGallery(CancellationToken.None);
1561
		const extensions = await workbenchService.queryLocal(extensionManagementServerService.remoteExtensionManagementServer!);
1562
		testObject.extension = extensions[0];
1563
		assert.ok(testObject.extension);
1564
		assert.ok(testObject.enabled);
1565
	});
1566

1567
	test('Test Runtime State for local ui+workspace extension is enabled when it is installed and enabled in remote server', async () => {
1568
		// multi server setup
1569
		const gallery = aGalleryExtension('a');
1570
		const localExtension = aLocalExtension('a', { extensionKind: ['ui', 'workspace'] }, { location: URI.file('pub.a') });
1571
		const remoteExtension = aLocalExtension('a', { extensionKind: ['ui', 'workspace'] }, { location: URI.file('pub.a').with({ scheme: Schemas.vscodeRemote }) });
1572
		const remoteExtensionManagementService = createExtensionManagementService([remoteExtension]);
1573
		const onDidInstallEvent = new Emitter<readonly InstallExtensionResult[]>();
1574
		remoteExtensionManagementService.onDidInstallExtensions = onDidInstallEvent.event;
1575
		const extensionManagementServerService = aMultiExtensionManagementServerService(instantiationService, createExtensionManagementService([localExtension]), remoteExtensionManagementService);
1576
		instantiationService.stub(IExtensionManagementServerService, extensionManagementServerService);
1577
		instantiationService.stub(IWorkbenchExtensionEnablementService, disposables.add(new TestExtensionEnablementService(instantiationService)));
1578
		const workbenchService: IExtensionsWorkbenchService = disposables.add(instantiationService.createInstance(ExtensionsWorkbenchService));
1579
		instantiationService.set(IExtensionsWorkbenchService, workbenchService);
1580

1581
		const onDidChangeExtensionsEmitter = new Emitter<{ added: IExtensionDescription[]; removed: IExtensionDescription[] }>();
1582
		instantiationService.stub(IExtensionService, {
1583
			extensions: [toExtensionDescription(remoteExtension)],
1584
			onDidChangeExtensions: onDidChangeExtensionsEmitter.event,
1585
			canAddExtension: (extension) => false,
1586
			whenInstalledExtensionsRegistered: () => Promise.resolve(true)
1587
		});
1588
		const testObject: ExtensionsActions.ExtensionRuntimeStateAction = disposables.add(instantiationService.createInstance(ExtensionsActions.ExtensionRuntimeStateAction));
1589
		disposables.add(instantiationService.createInstance(ExtensionContainers, [testObject]));
1590
		instantiationService.stubPromise(IExtensionGalleryService, 'query', aPage(gallery));
1591

1592
		await workbenchService.queryGallery(CancellationToken.None);
1593
		const extensions = await workbenchService.queryLocal(extensionManagementServerService.localExtensionManagementServer!);
1594
		testObject.extension = extensions[0];
1595
		assert.ok(testObject.extension);
1596
		assert.ok(testObject.enabled);
1597
	});
1598

1599
	test('Test Runtime State for local workspace+ui extension is enabled when it is installed in both servers but running in local server', async () => {
1600
		// multi server setup
1601
		const gallery = aGalleryExtension('a');
1602
		const localExtension = aLocalExtension('a', { extensionKind: ['workspace', 'ui'] }, { location: URI.file('pub.a') });
1603
		const localExtensionManagementService = createExtensionManagementService([localExtension]);
1604
		const onDidInstallEvent = new Emitter<readonly InstallExtensionResult[]>();
1605
		localExtensionManagementService.onDidInstallExtensions = onDidInstallEvent.event;
1606
		const remoteExtension = aLocalExtension('a', { extensionKind: ['workspace', 'ui'] }, { location: URI.file('pub.a').with({ scheme: Schemas.vscodeRemote }) });
1607
		const extensionManagementServerService = aMultiExtensionManagementServerService(instantiationService, localExtensionManagementService, createExtensionManagementService([remoteExtension]));
1608
		instantiationService.stub(IExtensionManagementServerService, extensionManagementServerService);
1609
		instantiationService.stub(IWorkbenchExtensionEnablementService, disposables.add(new TestExtensionEnablementService(instantiationService)));
1610
		const workbenchService: IExtensionsWorkbenchService = disposables.add(instantiationService.createInstance(ExtensionsWorkbenchService));
1611
		instantiationService.set(IExtensionsWorkbenchService, workbenchService);
1612

1613
		const onDidChangeExtensionsEmitter = new Emitter<{ added: IExtensionDescription[]; removed: IExtensionDescription[] }>();
1614
		instantiationService.stub(IExtensionService, {
1615
			extensions: [toExtensionDescription(localExtension)],
1616
			onDidChangeExtensions: onDidChangeExtensionsEmitter.event,
1617
			canAddExtension: (extension) => false,
1618
			whenInstalledExtensionsRegistered: () => Promise.resolve(true)
1619
		});
1620
		const testObject: ExtensionsActions.ExtensionRuntimeStateAction = disposables.add(instantiationService.createInstance(ExtensionsActions.ExtensionRuntimeStateAction));
1621
		disposables.add(instantiationService.createInstance(ExtensionContainers, [testObject]));
1622
		instantiationService.stubPromise(IExtensionGalleryService, 'query', aPage(gallery));
1623

1624
		await workbenchService.queryGallery(CancellationToken.None);
1625
		const extensions = await workbenchService.queryLocal(extensionManagementServerService.localExtensionManagementServer!);
1626
		testObject.extension = extensions[0];
1627
		assert.ok(testObject.extension);
1628
		assert.ok(testObject.enabled);
1629
	});
1630

1631
	test('Test Runtime State for remote ui+workspace extension is enabled when it is installed on both servers but running in remote server', async () => {
1632
		// multi server setup
1633
		const gallery = aGalleryExtension('a');
1634
		const localExtension = aLocalExtension('a', { extensionKind: ['ui', 'workspace'] }, { location: URI.file('pub.a') });
1635
		const remoteExtension = aLocalExtension('a', { extensionKind: ['ui', 'workspace'] }, { location: URI.file('pub.a').with({ scheme: Schemas.vscodeRemote }) });
1636
		const remoteExtensionManagementService = createExtensionManagementService([remoteExtension]);
1637
		const onDidInstallEvent = new Emitter<readonly InstallExtensionResult[]>();
1638
		remoteExtensionManagementService.onDidInstallExtensions = onDidInstallEvent.event;
1639
		const extensionManagementServerService = aMultiExtensionManagementServerService(instantiationService, createExtensionManagementService([localExtension]), remoteExtensionManagementService);
1640
		instantiationService.stub(IExtensionManagementServerService, extensionManagementServerService);
1641
		instantiationService.stub(IWorkbenchExtensionEnablementService, disposables.add(new TestExtensionEnablementService(instantiationService)));
1642
		const workbenchService: IExtensionsWorkbenchService = disposables.add(instantiationService.createInstance(ExtensionsWorkbenchService));
1643
		instantiationService.set(IExtensionsWorkbenchService, workbenchService);
1644

1645
		const onDidChangeExtensionsEmitter = new Emitter<{ added: IExtensionDescription[]; removed: IExtensionDescription[] }>();
1646
		instantiationService.stub(IExtensionService, {
1647
			extensions: [toExtensionDescription(remoteExtension)],
1648
			onDidChangeExtensions: onDidChangeExtensionsEmitter.event,
1649
			canAddExtension: (extension) => false,
1650
			whenInstalledExtensionsRegistered: () => Promise.resolve(true)
1651
		});
1652
		const testObject: ExtensionsActions.ExtensionRuntimeStateAction = disposables.add(instantiationService.createInstance(ExtensionsActions.ExtensionRuntimeStateAction));
1653
		disposables.add(instantiationService.createInstance(ExtensionContainers, [testObject]));
1654
		instantiationService.stubPromise(IExtensionGalleryService, 'query', aPage(gallery));
1655

1656
		await workbenchService.queryGallery(CancellationToken.None);
1657
		const extensions = await workbenchService.queryLocal(extensionManagementServerService.remoteExtensionManagementServer!);
1658
		testObject.extension = extensions[0];
1659
		assert.ok(testObject.extension);
1660
		assert.ok(testObject.enabled);
1661
	});
1662

1663
	test('Test Runtime State when ui+workspace+web extension is installed in web and remote and running in remote', async () => {
1664
		// multi server setup
1665
		const gallery = aGalleryExtension('a');
1666
		const webExtension = aLocalExtension('a', { extensionKind: ['ui', 'workspace'], 'browser': 'browser.js' }, { location: URI.file('pub.a').with({ scheme: Schemas.vscodeUserData }) });
1667
		const remoteExtension = aLocalExtension('a', { extensionKind: ['ui', 'workspace'], 'browser': 'browser.js' }, { location: URI.file('pub.a').with({ scheme: Schemas.vscodeRemote }) });
1668
		const extensionManagementServerService = aMultiExtensionManagementServerService(instantiationService, null, createExtensionManagementService([remoteExtension]), createExtensionManagementService([webExtension]));
1669
		instantiationService.stub(IExtensionManagementServerService, extensionManagementServerService);
1670
		instantiationService.stub(IWorkbenchExtensionEnablementService, disposables.add(new TestExtensionEnablementService(instantiationService)));
1671
		instantiationService.stub(IExtensionService, {
1672
			extensions: [toExtensionDescription(remoteExtension)],
1673
			onDidChangeExtensions: Event.None,
1674
			canAddExtension: (extension) => false,
1675
			whenInstalledExtensionsRegistered: () => Promise.resolve(true)
1676
		});
1677
		const workbenchService: IExtensionsWorkbenchService = disposables.add(instantiationService.createInstance(ExtensionsWorkbenchService));
1678
		instantiationService.set(IExtensionsWorkbenchService, workbenchService);
1679

1680
		const testObject: ExtensionsActions.ExtensionRuntimeStateAction = disposables.add(instantiationService.createInstance(ExtensionsActions.ExtensionRuntimeStateAction));
1681
		disposables.add(instantiationService.createInstance(ExtensionContainers, [testObject]));
1682
		instantiationService.stubPromise(IExtensionGalleryService, 'query', aPage(gallery));
1683

1684
		await workbenchService.queryGallery(CancellationToken.None);
1685
		const extensions = await workbenchService.queryLocal(extensionManagementServerService.remoteExtensionManagementServer!);
1686
		testObject.extension = extensions[0];
1687
		assert.ok(testObject.extension);
1688
		assert.ok(!testObject.enabled);
1689
	});
1690

1691
	test('Test Runtime State when workspace+ui+web extension is installed in web and local and running in local', async () => {
1692
		// multi server setup
1693
		const gallery = aGalleryExtension('a');
1694
		const webExtension = aLocalExtension('a', { extensionKind: ['workspace', 'ui'], 'browser': 'browser.js' }, { location: URI.file('pub.a').with({ scheme: Schemas.vscodeUserData }) });
1695
		const localExtension = aLocalExtension('a', { extensionKind: ['workspace', 'ui'], 'browser': 'browser.js' }, { location: URI.file('pub.a') });
1696
		const extensionManagementServerService = aMultiExtensionManagementServerService(instantiationService, createExtensionManagementService([localExtension]), null, createExtensionManagementService([webExtension]));
1697
		instantiationService.stub(IExtensionManagementServerService, extensionManagementServerService);
1698
		instantiationService.stub(IWorkbenchExtensionEnablementService, disposables.add(new TestExtensionEnablementService(instantiationService)));
1699
		instantiationService.stub(IExtensionService, {
1700
			extensions: [toExtensionDescription(localExtension)],
1701
			onDidChangeExtensions: Event.None,
1702
			canAddExtension: (extension) => false,
1703
			whenInstalledExtensionsRegistered: () => Promise.resolve(true)
1704
		});
1705
		const workbenchService: IExtensionsWorkbenchService = disposables.add(instantiationService.createInstance(ExtensionsWorkbenchService));
1706
		instantiationService.set(IExtensionsWorkbenchService, workbenchService);
1707

1708
		const testObject: ExtensionsActions.ExtensionRuntimeStateAction = disposables.add(instantiationService.createInstance(ExtensionsActions.ExtensionRuntimeStateAction));
1709
		disposables.add(instantiationService.createInstance(ExtensionContainers, [testObject]));
1710
		instantiationService.stubPromise(IExtensionGalleryService, 'query', aPage(gallery));
1711

1712
		await workbenchService.queryGallery(CancellationToken.None);
1713
		const extensions = await workbenchService.queryLocal(extensionManagementServerService.remoteExtensionManagementServer!);
1714
		testObject.extension = extensions[0];
1715
		assert.ok(testObject.extension);
1716
		assert.ok(!testObject.enabled);
1717
	});
1718
});
1719

1720
suite('RemoteInstallAction', () => {
1721

1722
	const disposables = ensureNoDisposablesAreLeakedInTestSuite();
1723

1724
	setup(() => setupTest(disposables));
1725

1726
	test('Test remote install action is enabled for local workspace extension', async () => {
1727
		// multi server setup
1728
		const localWorkspaceExtension = aLocalExtension('a', { extensionKind: ['workspace'] }, { location: URI.file(`pub.a`) });
1729
		const extensionManagementServerService = aMultiExtensionManagementServerService(instantiationService, createExtensionManagementService([localWorkspaceExtension]));
1730
		instantiationService.stub(IExtensionManagementServerService, extensionManagementServerService);
1731
		instantiationService.stub(IWorkbenchExtensionEnablementService, disposables.add(new TestExtensionEnablementService(instantiationService)));
1732
		const workbenchService: IExtensionsWorkbenchService = disposables.add(instantiationService.createInstance(ExtensionsWorkbenchService));
1733
		instantiationService.set(IExtensionsWorkbenchService, workbenchService);
1734

1735
		instantiationService.stubPromise(IExtensionGalleryService, 'query', aPage(aGalleryExtension('a', { identifier: localWorkspaceExtension.identifier })));
1736
		const testObject = disposables.add(instantiationService.createInstance(ExtensionsActions.RemoteInstallAction, false));
1737
		disposables.add(instantiationService.createInstance(ExtensionContainers, [testObject]));
1738

1739
		const extensions = await workbenchService.queryLocal(extensionManagementServerService.localExtensionManagementServer!);
1740
		await workbenchService.queryGallery(CancellationToken.None);
1741
		testObject.extension = extensions[0];
1742
		assert.ok(testObject.enabled);
1743
		assert.strictEqual('Install in remote', testObject.label);
1744
		assert.strictEqual('extension-action label prominent install-other-server', testObject.class);
1745
	});
1746

1747
	test('Test remote install action when installing local workspace extension', async () => {
1748
		// multi server setup
1749
		const remoteExtensionManagementService = createExtensionManagementService();
1750
		const onInstallExtension = new Emitter<InstallExtensionEvent>();
1751
		remoteExtensionManagementService.onInstallExtension = onInstallExtension.event;
1752
		const localWorkspaceExtension = aLocalExtension('a', { extensionKind: ['workspace'] }, { location: URI.file(`pub.a`) });
1753
		const extensionManagementServerService = aMultiExtensionManagementServerService(instantiationService, createExtensionManagementService([localWorkspaceExtension]), remoteExtensionManagementService);
1754
		instantiationService.stub(IExtensionManagementServerService, extensionManagementServerService);
1755
		instantiationService.stub(IWorkbenchExtensionEnablementService, disposables.add(new TestExtensionEnablementService(instantiationService)));
1756
		const workbenchService: IExtensionsWorkbenchService = disposables.add(instantiationService.createInstance(ExtensionsWorkbenchService));
1757
		instantiationService.stub(IExtensionsWorkbenchService, workbenchService, 'open', undefined);
1758
		instantiationService.set(IExtensionsWorkbenchService, workbenchService);
1759

1760
		const gallery = aGalleryExtension('a', { identifier: localWorkspaceExtension.identifier });
1761
		instantiationService.stubPromise(IExtensionGalleryService, 'query', aPage(gallery));
1762
		const testObject = disposables.add(instantiationService.createInstance(ExtensionsActions.RemoteInstallAction, false));
1763
		disposables.add(instantiationService.createInstance(ExtensionContainers, [testObject]));
1764

1765
		const extensions = await workbenchService.queryLocal(extensionManagementServerService.localExtensionManagementServer!);
1766
		await workbenchService.queryGallery(CancellationToken.None);
1767
		testObject.extension = extensions[0];
1768
		assert.ok(testObject.enabled);
1769
		assert.strictEqual('Install in remote', testObject.label);
1770
		assert.strictEqual('extension-action label prominent install-other-server', testObject.class);
1771

1772
		onInstallExtension.fire({ identifier: localWorkspaceExtension.identifier, source: gallery, profileLocation: null! });
1773
		assert.ok(testObject.enabled);
1774
		assert.strictEqual('Installing', testObject.label);
1775
		assert.strictEqual('extension-action label install-other-server installing', testObject.class);
1776
	});
1777

1778
	test('Test remote install action when installing local workspace extension is finished', async () => {
1779
		// multi server setup
1780
		const remoteExtensionManagementService = createExtensionManagementService();
1781
		const onInstallExtension = new Emitter<InstallExtensionEvent>();
1782
		remoteExtensionManagementService.onInstallExtension = onInstallExtension.event;
1783
		const onDidInstallEvent = new Emitter<readonly InstallExtensionResult[]>();
1784
		remoteExtensionManagementService.onDidInstallExtensions = onDidInstallEvent.event;
1785
		const localWorkspaceExtension = aLocalExtension('a', { extensionKind: ['workspace'] }, { location: URI.file(`pub.a`) });
1786
		const extensionManagementServerService = aMultiExtensionManagementServerService(instantiationService, createExtensionManagementService([localWorkspaceExtension]), remoteExtensionManagementService);
1787
		instantiationService.stub(IExtensionManagementServerService, extensionManagementServerService);
1788
		instantiationService.stub(IWorkbenchExtensionEnablementService, disposables.add(new TestExtensionEnablementService(instantiationService)));
1789
		const workbenchService: IExtensionsWorkbenchService = disposables.add(instantiationService.createInstance(ExtensionsWorkbenchService));
1790
		instantiationService.stub(IExtensionsWorkbenchService, workbenchService, 'open', undefined);
1791
		instantiationService.set(IExtensionsWorkbenchService, workbenchService);
1792

1793
		const gallery = aGalleryExtension('a', { identifier: localWorkspaceExtension.identifier });
1794
		instantiationService.stubPromise(IExtensionGalleryService, 'query', aPage(gallery));
1795
		const testObject = disposables.add(instantiationService.createInstance(ExtensionsActions.RemoteInstallAction, false));
1796
		disposables.add(instantiationService.createInstance(ExtensionContainers, [testObject]));
1797

1798
		const extensions = await workbenchService.queryLocal(extensionManagementServerService.localExtensionManagementServer!);
1799
		await workbenchService.queryGallery(CancellationToken.None);
1800
		testObject.extension = extensions[0];
1801
		assert.ok(testObject.enabled);
1802
		assert.strictEqual('Install in remote', testObject.label);
1803
		assert.strictEqual('extension-action label prominent install-other-server', testObject.class);
1804

1805
		onInstallExtension.fire({ identifier: localWorkspaceExtension.identifier, source: gallery, profileLocation: null! });
1806
		assert.ok(testObject.enabled);
1807
		assert.strictEqual('Installing', testObject.label);
1808
		assert.strictEqual('extension-action label install-other-server installing', testObject.class);
1809

1810
		const installedExtension = aLocalExtension('a', { extensionKind: ['workspace'] }, { location: URI.file(`pub.a`).with({ scheme: Schemas.vscodeRemote }) });
1811
		const promise = Event.toPromise(testObject.onDidChange);
1812
		onDidInstallEvent.fire([{ identifier: installedExtension.identifier, local: installedExtension, operation: InstallOperation.Install, profileLocation: null! }]);
1813
		await promise;
1814
		assert.ok(!testObject.enabled);
1815
	});
1816

1817
	test('Test remote install action is enabled for disabled local workspace extension', async () => {
1818
		// multi server setup
1819
		const localWorkspaceExtension = aLocalExtension('a', { extensionKind: ['workspace'] }, { location: URI.file(`pub.a`) });
1820
		const extensionManagementServerService = aMultiExtensionManagementServerService(instantiationService, createExtensionManagementService([localWorkspaceExtension]));
1821
		instantiationService.stub(IExtensionManagementServerService, extensionManagementServerService);
1822
		instantiationService.stub(IWorkbenchExtensionEnablementService, disposables.add(new TestExtensionEnablementService(instantiationService)));
1823
		const workbenchService: IExtensionsWorkbenchService = disposables.add(instantiationService.createInstance(ExtensionsWorkbenchService));
1824
		instantiationService.set(IExtensionsWorkbenchService, workbenchService);
1825

1826
		const remoteWorkspaceExtension = aLocalExtension('a', { extensionKind: ['workspace'] }, { location: URI.file(`pub.a`).with({ scheme: Schemas.vscodeRemote }) });
1827
		await instantiationService.get(IWorkbenchExtensionEnablementService).setEnablement([remoteWorkspaceExtension], EnablementState.DisabledGlobally);
1828
		instantiationService.stubPromise(IExtensionGalleryService, 'query', aPage(aGalleryExtension('a', { identifier: localWorkspaceExtension.identifier })));
1829
		const testObject = disposables.add(instantiationService.createInstance(ExtensionsActions.RemoteInstallAction, false));
1830
		disposables.add(instantiationService.createInstance(ExtensionContainers, [testObject]));
1831

1832
		const extensions = await workbenchService.queryLocal(extensionManagementServerService.localExtensionManagementServer!);
1833
		await workbenchService.queryGallery(CancellationToken.None);
1834
		testObject.extension = extensions[0];
1835
		assert.ok(testObject.enabled);
1836
		assert.strictEqual('Install in remote', testObject.label);
1837
		assert.strictEqual('extension-action label prominent install-other-server', testObject.class);
1838
	});
1839

1840
	test('Test remote install action is enabled local workspace+ui extension', async () => {
1841
		// multi server setup
1842
		const localWorkspaceExtension = aLocalExtension('a', { extensionKind: ['workspace', 'ui'] }, { location: URI.file(`pub.a`) });
1843
		const extensionManagementServerService = aMultiExtensionManagementServerService(instantiationService, createExtensionManagementService([localWorkspaceExtension]));
1844
		instantiationService.stub(IExtensionManagementServerService, extensionManagementServerService);
1845
		instantiationService.stub(IWorkbenchExtensionEnablementService, disposables.add(new TestExtensionEnablementService(instantiationService)));
1846
		const workbenchService: IExtensionsWorkbenchService = disposables.add(instantiationService.createInstance(ExtensionsWorkbenchService));
1847
		instantiationService.set(IExtensionsWorkbenchService, workbenchService);
1848

1849
		await instantiationService.get(IWorkbenchExtensionEnablementService).setEnablement([localWorkspaceExtension], EnablementState.DisabledGlobally);
1850
		instantiationService.stubPromise(IExtensionGalleryService, 'query', aPage(aGalleryExtension('a', { identifier: localWorkspaceExtension.identifier })));
1851
		const testObject = disposables.add(instantiationService.createInstance(ExtensionsActions.RemoteInstallAction, false));
1852
		disposables.add(instantiationService.createInstance(ExtensionContainers, [testObject]));
1853

1854
		const extensions = await workbenchService.queryLocal(extensionManagementServerService.localExtensionManagementServer!);
1855
		await workbenchService.queryGallery(CancellationToken.None);
1856
		testObject.extension = extensions[0];
1857
		assert.ok(testObject.enabled);
1858
		assert.strictEqual('Install in remote', testObject.label);
1859
		assert.strictEqual('extension-action label prominent install-other-server', testObject.class);
1860
	});
1861

1862
	test('Test remote install action is enabled for local ui+workapace extension if can install is true', async () => {
1863
		// multi server setup
1864
		const localWorkspaceExtension = aLocalExtension('a', { extensionKind: ['ui', 'workspace'] }, { location: URI.file(`pub.a`) });
1865
		const extensionManagementServerService = aMultiExtensionManagementServerService(instantiationService, createExtensionManagementService([localWorkspaceExtension]));
1866
		instantiationService.stub(IExtensionManagementServerService, extensionManagementServerService);
1867
		instantiationService.stub(IWorkbenchExtensionEnablementService, disposables.add(new TestExtensionEnablementService(instantiationService)));
1868
		const workbenchService: IExtensionsWorkbenchService = disposables.add(instantiationService.createInstance(ExtensionsWorkbenchService));
1869
		instantiationService.set(IExtensionsWorkbenchService, workbenchService);
1870

1871
		await instantiationService.get(IWorkbenchExtensionEnablementService).setEnablement([localWorkspaceExtension], EnablementState.DisabledGlobally);
1872
		instantiationService.stubPromise(IExtensionGalleryService, 'query', aPage(aGalleryExtension('a', { identifier: localWorkspaceExtension.identifier })));
1873
		const testObject = disposables.add(instantiationService.createInstance(ExtensionsActions.RemoteInstallAction, true));
1874
		disposables.add(instantiationService.createInstance(ExtensionContainers, [testObject]));
1875

1876
		const extensions = await workbenchService.queryLocal(extensionManagementServerService.localExtensionManagementServer!);
1877
		await workbenchService.queryGallery(CancellationToken.None);
1878
		testObject.extension = extensions[0];
1879
		assert.ok(testObject.enabled);
1880
		assert.strictEqual('Install in remote', testObject.label);
1881
		assert.strictEqual('extension-action label prominent install-other-server', testObject.class);
1882
	});
1883

1884
	test('Test remote install action is disabled for local ui+workapace extension if can install is false', async () => {
1885
		// multi server setup
1886
		const localWorkspaceExtension = aLocalExtension('a', { extensionKind: ['ui', 'workspace'] }, { location: URI.file(`pub.a`) });
1887
		const extensionManagementServerService = aMultiExtensionManagementServerService(instantiationService, createExtensionManagementService([localWorkspaceExtension]));
1888
		instantiationService.stub(IExtensionManagementServerService, extensionManagementServerService);
1889
		instantiationService.stub(IWorkbenchExtensionEnablementService, disposables.add(new TestExtensionEnablementService(instantiationService)));
1890
		const workbenchService: IExtensionsWorkbenchService = disposables.add(instantiationService.createInstance(ExtensionsWorkbenchService));
1891
		instantiationService.set(IExtensionsWorkbenchService, workbenchService);
1892

1893
		await instantiationService.get(IWorkbenchExtensionEnablementService).setEnablement([localWorkspaceExtension], EnablementState.DisabledGlobally);
1894
		instantiationService.stubPromise(IExtensionGalleryService, 'query', aPage(aGalleryExtension('a', { identifier: localWorkspaceExtension.identifier })));
1895
		const testObject = disposables.add(instantiationService.createInstance(ExtensionsActions.RemoteInstallAction, false));
1896
		disposables.add(instantiationService.createInstance(ExtensionContainers, [testObject]));
1897

1898
		const extensions = await workbenchService.queryLocal(extensionManagementServerService.localExtensionManagementServer!);
1899
		await workbenchService.queryGallery(CancellationToken.None);
1900
		testObject.extension = extensions[0];
1901
		assert.ok(!testObject.enabled);
1902
	});
1903

1904
	test('Test remote install action is disabled when extension is not set', async () => {
1905
		// multi server setup
1906
		const localWorkspaceExtension = aLocalExtension('a', { extensionKind: ['workspace'] }, { location: URI.file(`pub.a`) });
1907
		const extensionManagementServerService = aMultiExtensionManagementServerService(instantiationService, createExtensionManagementService([localWorkspaceExtension]));
1908
		instantiationService.stub(IWorkbenchExtensionEnablementService, disposables.add(new TestExtensionEnablementService(instantiationService)));
1909
		const workbenchService: IExtensionsWorkbenchService = disposables.add(instantiationService.createInstance(ExtensionsWorkbenchService));
1910
		instantiationService.set(IExtensionsWorkbenchService, workbenchService);
1911

1912
		instantiationService.stubPromise(IExtensionGalleryService, 'query', aPage(aGalleryExtension('a', { identifier: localWorkspaceExtension.identifier })));
1913
		const testObject = disposables.add(instantiationService.createInstance(ExtensionsActions.RemoteInstallAction, false));
1914
		disposables.add(instantiationService.createInstance(ExtensionContainers, [testObject]));
1915

1916
		await workbenchService.queryLocal(extensionManagementServerService.localExtensionManagementServer!);
1917
		await workbenchService.queryGallery(CancellationToken.None);
1918
		assert.ok(!testObject.enabled);
1919
	});
1920

1921
	test('Test remote install action is disabled for extension which is not installed', async () => {
1922
		// multi server setup
1923
		const extensionManagementServerService = aMultiExtensionManagementServerService(instantiationService);
1924
		instantiationService.stub(IExtensionManagementServerService, extensionManagementServerService);
1925
		instantiationService.stub(IWorkbenchExtensionEnablementService, disposables.add(new TestExtensionEnablementService(instantiationService)));
1926
		const workbenchService: IExtensionsWorkbenchService = disposables.add(instantiationService.createInstance(ExtensionsWorkbenchService));
1927
		instantiationService.set(IExtensionsWorkbenchService, workbenchService);
1928

1929
		instantiationService.stubPromise(IExtensionGalleryService, 'query', aPage(aGalleryExtension('a')));
1930
		const testObject = disposables.add(instantiationService.createInstance(ExtensionsActions.RemoteInstallAction, false));
1931
		disposables.add(instantiationService.createInstance(ExtensionContainers, [testObject]));
1932

1933
		const pager = await workbenchService.queryGallery(CancellationToken.None);
1934
		testObject.extension = pager.firstPage[0];
1935
		assert.ok(testObject.extension);
1936
		assert.ok(!testObject.enabled);
1937
	});
1938

1939
	test('Test remote install action is disabled for local workspace extension which is disabled in env', async () => {
1940
		// multi server setup
1941
		const localWorkspaceExtension = aLocalExtension('a', { extensionKind: ['workspace'] }, { location: URI.file(`pub.a`) });
1942
		const extensionManagementServerService = aMultiExtensionManagementServerService(instantiationService, createExtensionManagementService([localWorkspaceExtension]));
1943
		const environmentService = { disableExtensions: true } as INativeWorkbenchEnvironmentService;
1944
		instantiationService.stub(IEnvironmentService, environmentService);
1945
		instantiationService.stub(INativeEnvironmentService, environmentService);
1946
		instantiationService.stub(IWorkbenchEnvironmentService, environmentService);
1947
		instantiationService.stub(INativeWorkbenchEnvironmentService, environmentService);
1948
		instantiationService.stub(IExtensionManagementServerService, extensionManagementServerService);
1949
		instantiationService.stub(IWorkbenchExtensionEnablementService, disposables.add(new TestExtensionEnablementService(instantiationService)));
1950
		const workbenchService: IExtensionsWorkbenchService = disposables.add(instantiationService.createInstance(ExtensionsWorkbenchService));
1951
		instantiationService.set(IExtensionsWorkbenchService, workbenchService);
1952

1953
		instantiationService.stubPromise(IExtensionGalleryService, 'query', aPage(aGalleryExtension('a', { identifier: localWorkspaceExtension.identifier })));
1954
		const testObject = disposables.add(instantiationService.createInstance(ExtensionsActions.RemoteInstallAction, false));
1955
		disposables.add(instantiationService.createInstance(ExtensionContainers, [testObject]));
1956

1957
		const extensions = await workbenchService.queryLocal(extensionManagementServerService.localExtensionManagementServer!);
1958
		await workbenchService.queryGallery(CancellationToken.None);
1959
		testObject.extension = extensions[0];
1960
		assert.ok(testObject.extension);
1961
		assert.ok(!testObject.enabled);
1962
	});
1963

1964
	test('Test remote install action is disabled when remote server is not available', async () => {
1965
		// single server setup
1966
		const workbenchService = instantiationService.get(IExtensionsWorkbenchService);
1967
		const extensionManagementServerService = instantiationService.get(IExtensionManagementServerService);
1968
		const localWorkspaceExtension = aLocalExtension('a', { extensionKind: ['workspace'] }, { location: URI.file(`pub.a`) });
1969
		instantiationService.stubPromise(IExtensionManagementService, 'getInstalled', [localWorkspaceExtension]);
1970
		instantiationService.stubPromise(IExtensionGalleryService, 'query', aPage(aGalleryExtension('a', { identifier: localWorkspaceExtension.identifier })));
1971
		const testObject = disposables.add(instantiationService.createInstance(ExtensionsActions.RemoteInstallAction, false));
1972
		disposables.add(instantiationService.createInstance(ExtensionContainers, [testObject]));
1973

1974
		const extensions = await workbenchService.queryLocal(extensionManagementServerService.localExtensionManagementServer!);
1975
		await workbenchService.queryGallery(CancellationToken.None);
1976
		testObject.extension = extensions[0];
1977
		assert.ok(testObject.extension);
1978
		assert.ok(!testObject.enabled);
1979
	});
1980

1981
	test('Test remote install action is disabled for local workspace extension if it is uninstalled locally', async () => {
1982
		// multi server setup
1983
		const extensionManagementService = instantiationService.get(IExtensionManagementService) as IProfileAwareExtensionManagementService;
1984
		const extensionManagementServerService = aMultiExtensionManagementServerService(instantiationService, extensionManagementService);
1985
		instantiationService.stub(IExtensionManagementServerService, extensionManagementServerService);
1986
		instantiationService.stub(IWorkbenchExtensionEnablementService, disposables.add(new TestExtensionEnablementService(instantiationService)));
1987
		const localWorkspaceExtension = aLocalExtension('a', { extensionKind: ['workspace'] }, { location: URI.file(`pub.a`) });
1988
		instantiationService.stubPromise(IExtensionManagementService, 'getInstalled', [localWorkspaceExtension]);
1989
		const workbenchService: IExtensionsWorkbenchService = disposables.add(instantiationService.createInstance(ExtensionsWorkbenchService));
1990
		instantiationService.set(IExtensionsWorkbenchService, workbenchService);
1991

1992
		instantiationService.stubPromise(IExtensionGalleryService, 'query', aPage(aGalleryExtension('a', { identifier: localWorkspaceExtension.identifier })));
1993
		const testObject = disposables.add(instantiationService.createInstance(ExtensionsActions.RemoteInstallAction, false));
1994
		disposables.add(instantiationService.createInstance(ExtensionContainers, [testObject]));
1995

1996
		const extensions = await workbenchService.queryLocal(extensionManagementServerService.localExtensionManagementServer!);
1997
		await workbenchService.queryGallery(CancellationToken.None);
1998
		testObject.extension = extensions[0];
1999
		assert.ok(testObject.enabled);
2000
		assert.strictEqual('Install in remote', testObject.label);
2001

2002
		uninstallEvent.fire({ identifier: localWorkspaceExtension.identifier, profileLocation: null! });
2003
		assert.ok(!testObject.enabled);
2004
	});
2005

2006
	test('Test remote install action is disabled for local workspace extension if it is installed in remote', async () => {
2007
		// multi server setup
2008
		const localWorkspaceExtension = aLocalExtension('a', { extensionKind: ['workspace'] }, { location: URI.file(`pub.a`) });
2009
		const remoteWorkspaceExtension = aLocalExtension('a', { extensionKind: ['workspace'] }, { location: URI.file(`pub.a`).with({ scheme: Schemas.vscodeRemote }) });
2010
		const extensionManagementServerService = aMultiExtensionManagementServerService(instantiationService, createExtensionManagementService([localWorkspaceExtension]), createExtensionManagementService([remoteWorkspaceExtension]));
2011
		instantiationService.stub(IExtensionManagementServerService, extensionManagementServerService);
2012
		instantiationService.stub(IWorkbenchExtensionEnablementService, disposables.add(new TestExtensionEnablementService(instantiationService)));
2013
		const workbenchService: IExtensionsWorkbenchService = disposables.add(instantiationService.createInstance(ExtensionsWorkbenchService));
2014
		instantiationService.set(IExtensionsWorkbenchService, workbenchService);
2015

2016
		instantiationService.stubPromise(IExtensionGalleryService, 'query', aPage(aGalleryExtension('a', { identifier: localWorkspaceExtension.identifier })));
2017
		const testObject = disposables.add(instantiationService.createInstance(ExtensionsActions.RemoteInstallAction, false));
2018
		disposables.add(instantiationService.createInstance(ExtensionContainers, [testObject]));
2019

2020
		const extensions = await workbenchService.queryLocal(extensionManagementServerService.localExtensionManagementServer!);
2021
		await workbenchService.queryGallery(CancellationToken.None);
2022
		testObject.extension = extensions[0];
2023
		assert.ok(testObject.extension);
2024
		assert.ok(!testObject.enabled);
2025
	});
2026

2027
	test('Test remote install action is enabled for local workspace extension if it has not gallery', async () => {
2028
		// multi server setup
2029
		const localWorkspaceExtension = aLocalExtension('a', { extensionKind: ['workspace'] }, { location: URI.file(`pub.a`) });
2030
		const extensionManagementServerService = aMultiExtensionManagementServerService(instantiationService, createExtensionManagementService([localWorkspaceExtension]));
2031
		instantiationService.stub(IExtensionManagementServerService, extensionManagementServerService);
2032
		instantiationService.stub(IWorkbenchExtensionEnablementService, disposables.add(new TestExtensionEnablementService(instantiationService)));
2033
		const workbenchService: IExtensionsWorkbenchService = disposables.add(instantiationService.createInstance(ExtensionsWorkbenchService));
2034
		instantiationService.set(IExtensionsWorkbenchService, workbenchService);
2035

2036
		instantiationService.stubPromise(IExtensionGalleryService, 'query', aPage(aGalleryExtension('a', { identifier: localWorkspaceExtension.identifier })));
2037
		const testObject = disposables.add(instantiationService.createInstance(ExtensionsActions.RemoteInstallAction, false));
2038
		disposables.add(instantiationService.createInstance(ExtensionContainers, [testObject]));
2039

2040
		const extensions = await workbenchService.queryLocal(extensionManagementServerService.localExtensionManagementServer!);
2041
		testObject.extension = extensions[0];
2042
		assert.ok(testObject.extension);
2043
		assert.ok(testObject.enabled);
2044
	});
2045

2046
	test('Test remote install action is disabled for local workspace system extension', async () => {
2047
		// multi server setup
2048
		const localWorkspaceSystemExtension = aLocalExtension('a', { extensionKind: ['workspace'] }, { location: URI.file(`pub.a`), type: ExtensionType.System });
2049
		const extensionManagementServerService = aMultiExtensionManagementServerService(instantiationService, createExtensionManagementService([localWorkspaceSystemExtension]));
2050
		instantiationService.stub(IExtensionManagementServerService, extensionManagementServerService);
2051
		instantiationService.stub(IWorkbenchExtensionEnablementService, disposables.add(new TestExtensionEnablementService(instantiationService)));
2052
		const workbenchService: IExtensionsWorkbenchService = disposables.add(instantiationService.createInstance(ExtensionsWorkbenchService));
2053
		instantiationService.set(IExtensionsWorkbenchService, workbenchService);
2054

2055
		instantiationService.stubPromise(IExtensionGalleryService, 'query', aPage(aGalleryExtension('a', { identifier: localWorkspaceSystemExtension.identifier })));
2056
		const testObject = disposables.add(instantiationService.createInstance(ExtensionsActions.RemoteInstallAction, false));
2057
		disposables.add(instantiationService.createInstance(ExtensionContainers, [testObject]));
2058

2059
		const extensions = await workbenchService.queryLocal(extensionManagementServerService.localExtensionManagementServer!);
2060
		testObject.extension = extensions[0];
2061
		assert.ok(testObject.extension);
2062
		assert.ok(!testObject.enabled);
2063
	});
2064

2065
	test('Test remote install action is disabled for local ui extension if it is not installed in remote', async () => {
2066
		// multi server setup
2067
		const localUIExtension = aLocalExtension('a', { extensionKind: ['ui'] }, { location: URI.file(`pub.a`) });
2068
		const extensionManagementServerService = aMultiExtensionManagementServerService(instantiationService, createExtensionManagementService([localUIExtension]));
2069
		instantiationService.stub(IExtensionManagementServerService, extensionManagementServerService);
2070
		instantiationService.stub(IWorkbenchExtensionEnablementService, disposables.add(new TestExtensionEnablementService(instantiationService)));
2071
		const workbenchService: IExtensionsWorkbenchService = disposables.add(instantiationService.createInstance(ExtensionsWorkbenchService));
2072
		instantiationService.set(IExtensionsWorkbenchService, workbenchService);
2073

2074
		instantiationService.stubPromise(IExtensionGalleryService, 'query', aPage(aGalleryExtension('a', { identifier: localUIExtension.identifier })));
2075
		const testObject = disposables.add(instantiationService.createInstance(ExtensionsActions.RemoteInstallAction, false));
2076
		disposables.add(instantiationService.createInstance(ExtensionContainers, [testObject]));
2077

2078
		const extensions = await workbenchService.queryLocal(extensionManagementServerService.localExtensionManagementServer!);
2079
		testObject.extension = extensions[0];
2080
		assert.ok(testObject.extension);
2081
		assert.ok(!testObject.enabled);
2082
	});
2083

2084
	test('Test remote install action is disabled for local ui extension if it is also installed in remote', async () => {
2085
		// multi server setup
2086
		const localUIExtension = aLocalExtension('a', { extensionKind: ['ui'] }, { location: URI.file(`pub.a`) });
2087
		const remoteUIExtension = aLocalExtension('a', { extensionKind: ['ui'] }, { location: URI.file(`pub.a`).with({ scheme: Schemas.vscodeRemote }) });
2088
		const extensionManagementServerService = aMultiExtensionManagementServerService(instantiationService, createExtensionManagementService([localUIExtension]), createExtensionManagementService([remoteUIExtension]));
2089
		instantiationService.stub(IExtensionManagementServerService, extensionManagementServerService);
2090
		instantiationService.stub(IWorkbenchExtensionEnablementService, disposables.add(new TestExtensionEnablementService(instantiationService)));
2091
		const workbenchService: IExtensionsWorkbenchService = disposables.add(instantiationService.createInstance(ExtensionsWorkbenchService));
2092
		instantiationService.set(IExtensionsWorkbenchService, workbenchService);
2093

2094
		instantiationService.stubPromise(IExtensionGalleryService, 'query', aPage(aGalleryExtension('a', { identifier: localUIExtension.identifier })));
2095
		const testObject = disposables.add(instantiationService.createInstance(ExtensionsActions.RemoteInstallAction, false));
2096
		disposables.add(instantiationService.createInstance(ExtensionContainers, [testObject]));
2097

2098
		const extensions = await workbenchService.queryLocal(extensionManagementServerService.localExtensionManagementServer!);
2099
		testObject.extension = extensions[0];
2100
		assert.ok(testObject.extension);
2101
		assert.ok(!testObject.enabled);
2102
	});
2103

2104
	test('Test remote install action is enabled for locally installed language pack extension', async () => {
2105
		// multi server setup
2106
		const languagePackExtension = aLocalExtension('a', { contributes: <IExtensionContributions>{ localizations: [{ languageId: 'de', translations: [] }] } }, { location: URI.file(`pub.a`) });
2107
		const extensionManagementServerService = aMultiExtensionManagementServerService(instantiationService, createExtensionManagementService([languagePackExtension]));
2108
		instantiationService.stub(IExtensionManagementServerService, extensionManagementServerService);
2109
		instantiationService.stub(IWorkbenchExtensionEnablementService, disposables.add(new TestExtensionEnablementService(instantiationService)));
2110
		const workbenchService: IExtensionsWorkbenchService = disposables.add(instantiationService.createInstance(ExtensionsWorkbenchService));
2111
		instantiationService.set(IExtensionsWorkbenchService, workbenchService);
2112

2113
		instantiationService.stubPromise(IExtensionGalleryService, 'query', aPage(aGalleryExtension('a', { identifier: languagePackExtension.identifier })));
2114
		const testObject = disposables.add(instantiationService.createInstance(ExtensionsActions.RemoteInstallAction, false));
2115
		disposables.add(instantiationService.createInstance(ExtensionContainers, [testObject]));
2116

2117
		const extensions = await workbenchService.queryLocal(extensionManagementServerService.localExtensionManagementServer!);
2118
		await workbenchService.queryGallery(CancellationToken.None);
2119
		testObject.extension = extensions[0];
2120
		assert.ok(testObject.enabled);
2121
		assert.strictEqual('Install in remote', testObject.label);
2122
		assert.strictEqual('extension-action label prominent install-other-server', testObject.class);
2123
	});
2124

2125
	test('Test remote install action is disabled if local language pack extension is uninstalled', async () => {
2126
		// multi server setup
2127
		const extensionManagementService = instantiationService.get(IExtensionManagementService) as IProfileAwareExtensionManagementService;
2128
		const extensionManagementServerService = aMultiExtensionManagementServerService(instantiationService, extensionManagementService);
2129
		instantiationService.stub(IExtensionManagementServerService, extensionManagementServerService);
2130
		instantiationService.stub(IWorkbenchExtensionEnablementService, disposables.add(new TestExtensionEnablementService(instantiationService)));
2131
		const languagePackExtension = aLocalExtension('a', { contributes: <IExtensionContributions>{ localizations: [{ languageId: 'de', translations: [] }] } }, { location: URI.file(`pub.a`) });
2132
		instantiationService.stubPromise(IExtensionManagementService, 'getInstalled', [languagePackExtension]);
2133
		const workbenchService: IExtensionsWorkbenchService = disposables.add(instantiationService.createInstance(ExtensionsWorkbenchService));
2134
		instantiationService.set(IExtensionsWorkbenchService, workbenchService);
2135

2136
		instantiationService.stubPromise(IExtensionGalleryService, 'query', aPage(aGalleryExtension('a', { identifier: languagePackExtension.identifier })));
2137
		const testObject = disposables.add(instantiationService.createInstance(ExtensionsActions.RemoteInstallAction, false));
2138
		disposables.add(instantiationService.createInstance(ExtensionContainers, [testObject]));
2139

2140
		const extensions = await workbenchService.queryLocal(extensionManagementServerService.localExtensionManagementServer!);
2141
		await workbenchService.queryGallery(CancellationToken.None);
2142
		testObject.extension = extensions[0];
2143
		assert.ok(testObject.enabled);
2144
		assert.strictEqual('Install in remote', testObject.label);
2145

2146
		uninstallEvent.fire({ identifier: languagePackExtension.identifier, profileLocation: null! });
2147
		assert.ok(!testObject.enabled);
2148
	});
2149
});
2150

2151
suite('LocalInstallAction', () => {
2152

2153
	const disposables = ensureNoDisposablesAreLeakedInTestSuite();
2154

2155
	setup(() => setupTest(disposables));
2156

2157
	test('Test local install action is enabled for remote ui extension', async () => {
2158
		// multi server setup
2159
		const remoteUIExtension = aLocalExtension('a', { extensionKind: ['ui'] }, { location: URI.file(`pub.a`).with({ scheme: Schemas.vscodeRemote }) });
2160
		const extensionManagementServerService = aMultiExtensionManagementServerService(instantiationService, createExtensionManagementService(), createExtensionManagementService([remoteUIExtension]));
2161
		instantiationService.stub(IExtensionManagementServerService, extensionManagementServerService);
2162
		instantiationService.stub(IWorkbenchExtensionEnablementService, disposables.add(new TestExtensionEnablementService(instantiationService)));
2163
		const workbenchService: IExtensionsWorkbenchService = disposables.add(instantiationService.createInstance(ExtensionsWorkbenchService));
2164
		instantiationService.set(IExtensionsWorkbenchService, workbenchService);
2165

2166
		instantiationService.stubPromise(IExtensionGalleryService, 'query', aPage(aGalleryExtension('a', { identifier: remoteUIExtension.identifier })));
2167
		const testObject = disposables.add(instantiationService.createInstance(ExtensionsActions.LocalInstallAction));
2168
		disposables.add(instantiationService.createInstance(ExtensionContainers, [testObject]));
2169

2170
		const extensions = await workbenchService.queryLocal(extensionManagementServerService.remoteExtensionManagementServer!);
2171
		await workbenchService.queryGallery(CancellationToken.None);
2172
		testObject.extension = extensions[0];
2173
		assert.ok(testObject.enabled);
2174
		assert.strictEqual('Install Locally', testObject.label);
2175
		assert.strictEqual('extension-action label prominent install-other-server', testObject.class);
2176
	});
2177

2178
	test('Test local install action is enabled for remote ui+workspace extension', async () => {
2179
		// multi server setup
2180
		const remoteUIExtension = aLocalExtension('a', { extensionKind: ['ui', 'workspace'] }, { location: URI.file(`pub.a`).with({ scheme: Schemas.vscodeRemote }) });
2181
		const extensionManagementServerService = aMultiExtensionManagementServerService(instantiationService, createExtensionManagementService(), createExtensionManagementService([remoteUIExtension]));
2182
		instantiationService.stub(IExtensionManagementServerService, extensionManagementServerService);
2183
		instantiationService.stub(IWorkbenchExtensionEnablementService, disposables.add(new TestExtensionEnablementService(instantiationService)));
2184
		const workbenchService: IExtensionsWorkbenchService = disposables.add(instantiationService.createInstance(ExtensionsWorkbenchService));
2185
		instantiationService.set(IExtensionsWorkbenchService, workbenchService);
2186

2187
		instantiationService.stubPromise(IExtensionGalleryService, 'query', aPage(aGalleryExtension('a', { identifier: remoteUIExtension.identifier })));
2188
		const testObject = disposables.add(instantiationService.createInstance(ExtensionsActions.LocalInstallAction));
2189
		disposables.add(instantiationService.createInstance(ExtensionContainers, [testObject]));
2190

2191
		const extensions = await workbenchService.queryLocal(extensionManagementServerService.remoteExtensionManagementServer!);
2192
		await workbenchService.queryGallery(CancellationToken.None);
2193
		testObject.extension = extensions[0];
2194
		assert.ok(testObject.enabled);
2195
		assert.strictEqual('Install Locally', testObject.label);
2196
		assert.strictEqual('extension-action label prominent install-other-server', testObject.class);
2197
	});
2198

2199
	test('Test local install action when installing remote ui extension', async () => {
2200
		// multi server setup
2201
		const localExtensionManagementService = createExtensionManagementService();
2202
		const onInstallExtension = new Emitter<InstallExtensionEvent>();
2203
		localExtensionManagementService.onInstallExtension = onInstallExtension.event;
2204
		const remoteUIExtension = aLocalExtension('a', { extensionKind: ['ui'] }, { location: URI.file(`pub.a`).with({ scheme: Schemas.vscodeRemote }) });
2205
		const extensionManagementServerService = aMultiExtensionManagementServerService(instantiationService, localExtensionManagementService, createExtensionManagementService([remoteUIExtension]));
2206
		instantiationService.stub(IExtensionManagementServerService, extensionManagementServerService);
2207
		instantiationService.stub(IWorkbenchExtensionEnablementService, disposables.add(new TestExtensionEnablementService(instantiationService)));
2208
		const workbenchService: IExtensionsWorkbenchService = disposables.add(instantiationService.createInstance(ExtensionsWorkbenchService));
2209
		instantiationService.stub(IExtensionsWorkbenchService, workbenchService, 'open', undefined);
2210
		instantiationService.set(IExtensionsWorkbenchService, workbenchService);
2211

2212
		const gallery = aGalleryExtension('a', { identifier: remoteUIExtension.identifier });
2213
		instantiationService.stubPromise(IExtensionGalleryService, 'query', aPage(gallery));
2214
		const testObject = disposables.add(instantiationService.createInstance(ExtensionsActions.LocalInstallAction));
2215
		disposables.add(instantiationService.createInstance(ExtensionContainers, [testObject]));
2216

2217
		const extensions = await workbenchService.queryLocal(extensionManagementServerService.remoteExtensionManagementServer!);
2218
		await workbenchService.queryGallery(CancellationToken.None);
2219
		testObject.extension = extensions[0];
2220
		assert.ok(testObject.enabled);
2221
		assert.strictEqual('Install Locally', testObject.label);
2222
		assert.strictEqual('extension-action label prominent install-other-server', testObject.class);
2223

2224
		onInstallExtension.fire({ identifier: remoteUIExtension.identifier, source: gallery, profileLocation: null! });
2225
		assert.ok(testObject.enabled);
2226
		assert.strictEqual('Installing', testObject.label);
2227
		assert.strictEqual('extension-action label install-other-server installing', testObject.class);
2228
	});
2229

2230
	test('Test local install action when installing remote ui extension is finished', async () => {
2231
		// multi server setup
2232
		const localExtensionManagementService = createExtensionManagementService();
2233
		const onInstallExtension = new Emitter<InstallExtensionEvent>();
2234
		localExtensionManagementService.onInstallExtension = onInstallExtension.event;
2235
		const onDidInstallEvent = new Emitter<readonly InstallExtensionResult[]>();
2236
		localExtensionManagementService.onDidInstallExtensions = onDidInstallEvent.event;
2237
		const remoteUIExtension = aLocalExtension('a', { extensionKind: ['ui'] }, { location: URI.file(`pub.a`).with({ scheme: Schemas.vscodeRemote }) });
2238
		const extensionManagementServerService = aMultiExtensionManagementServerService(instantiationService, localExtensionManagementService, createExtensionManagementService([remoteUIExtension]));
2239
		instantiationService.stub(IExtensionManagementServerService, extensionManagementServerService);
2240
		instantiationService.stub(IWorkbenchExtensionEnablementService, disposables.add(new TestExtensionEnablementService(instantiationService)));
2241
		const workbenchService: IExtensionsWorkbenchService = disposables.add(instantiationService.createInstance(ExtensionsWorkbenchService));
2242
		instantiationService.stub(IExtensionsWorkbenchService, workbenchService, 'open', undefined);
2243
		instantiationService.set(IExtensionsWorkbenchService, workbenchService);
2244

2245
		const gallery = aGalleryExtension('a', { identifier: remoteUIExtension.identifier });
2246
		instantiationService.stubPromise(IExtensionGalleryService, 'query', aPage(gallery));
2247
		const testObject = disposables.add(instantiationService.createInstance(ExtensionsActions.LocalInstallAction));
2248
		disposables.add(instantiationService.createInstance(ExtensionContainers, [testObject]));
2249

2250
		const extensions = await workbenchService.queryLocal(extensionManagementServerService.remoteExtensionManagementServer!);
2251
		await workbenchService.queryGallery(CancellationToken.None);
2252
		testObject.extension = extensions[0];
2253
		assert.ok(testObject.enabled);
2254
		assert.strictEqual('Install Locally', testObject.label);
2255
		assert.strictEqual('extension-action label prominent install-other-server', testObject.class);
2256

2257
		onInstallExtension.fire({ identifier: remoteUIExtension.identifier, source: gallery, profileLocation: null! });
2258
		assert.ok(testObject.enabled);
2259
		assert.strictEqual('Installing', testObject.label);
2260
		assert.strictEqual('extension-action label install-other-server installing', testObject.class);
2261

2262
		const installedExtension = aLocalExtension('a', { extensionKind: ['ui'] }, { location: URI.file(`pub.a`) });
2263
		const promise = Event.toPromise(testObject.onDidChange);
2264
		onDidInstallEvent.fire([{ identifier: installedExtension.identifier, local: installedExtension, operation: InstallOperation.Install, profileLocation: null! }]);
2265
		await promise;
2266
		assert.ok(!testObject.enabled);
2267
	});
2268

2269
	test('Test local install action is enabled for disabled remote ui extension', async () => {
2270
		// multi server setup
2271
		const remoteUIExtension = aLocalExtension('a', { extensionKind: ['ui'] }, { location: URI.file(`pub.a`).with({ scheme: Schemas.vscodeRemote }) });
2272
		const extensionManagementServerService = aMultiExtensionManagementServerService(instantiationService, createExtensionManagementService(), createExtensionManagementService([remoteUIExtension]));
2273
		instantiationService.stub(IExtensionManagementServerService, extensionManagementServerService);
2274
		instantiationService.stub(IWorkbenchExtensionEnablementService, disposables.add(new TestExtensionEnablementService(instantiationService)));
2275
		const workbenchService: IExtensionsWorkbenchService = disposables.add(instantiationService.createInstance(ExtensionsWorkbenchService));
2276
		instantiationService.set(IExtensionsWorkbenchService, workbenchService);
2277

2278
		const localUIExtension = aLocalExtension('a', { extensionKind: ['ui'] }, { location: URI.file(`pub.a`) });
2279
		await instantiationService.get(IWorkbenchExtensionEnablementService).setEnablement([localUIExtension], EnablementState.DisabledGlobally);
2280
		instantiationService.stubPromise(IExtensionGalleryService, 'query', aPage(aGalleryExtension('a', { identifier: remoteUIExtension.identifier })));
2281
		const testObject = disposables.add(instantiationService.createInstance(ExtensionsActions.LocalInstallAction));
2282
		disposables.add(instantiationService.createInstance(ExtensionContainers, [testObject]));
2283

2284
		const extensions = await workbenchService.queryLocal(extensionManagementServerService.remoteExtensionManagementServer!);
2285
		await workbenchService.queryGallery(CancellationToken.None);
2286
		testObject.extension = extensions[0];
2287
		assert.ok(testObject.enabled);
2288
		assert.strictEqual('Install Locally', testObject.label);
2289
		assert.strictEqual('extension-action label prominent install-other-server', testObject.class);
2290
	});
2291

2292
	test('Test local install action is disabled when extension is not set', async () => {
2293
		// multi server setup
2294
		const remoteUIExtension = aLocalExtension('a', { extensionKind: ['ui'] }, { location: URI.file(`pub.a`).with({ scheme: Schemas.vscodeRemote }) });
2295
		const extensionManagementServerService = aMultiExtensionManagementServerService(instantiationService, createExtensionManagementService(), createExtensionManagementService([remoteUIExtension]));
2296
		instantiationService.stub(IWorkbenchExtensionEnablementService, disposables.add(new TestExtensionEnablementService(instantiationService)));
2297
		const workbenchService: IExtensionsWorkbenchService = disposables.add(instantiationService.createInstance(ExtensionsWorkbenchService));
2298
		instantiationService.set(IExtensionsWorkbenchService, workbenchService);
2299

2300
		instantiationService.stubPromise(IExtensionGalleryService, 'query', aPage(aGalleryExtension('a', { identifier: remoteUIExtension.identifier })));
2301
		const testObject = disposables.add(instantiationService.createInstance(ExtensionsActions.LocalInstallAction));
2302
		disposables.add(instantiationService.createInstance(ExtensionContainers, [testObject]));
2303

2304
		await workbenchService.queryLocal(extensionManagementServerService.remoteExtensionManagementServer!);
2305
		await workbenchService.queryGallery(CancellationToken.None);
2306
		assert.ok(!testObject.enabled);
2307
	});
2308

2309
	test('Test local install action is disabled for extension which is not installed', async () => {
2310
		// multi server setup
2311
		const extensionManagementServerService = aMultiExtensionManagementServerService(instantiationService);
2312
		instantiationService.stub(IExtensionManagementServerService, extensionManagementServerService);
2313
		instantiationService.stub(IWorkbenchExtensionEnablementService, disposables.add(new TestExtensionEnablementService(instantiationService)));
2314
		const workbenchService: IExtensionsWorkbenchService = disposables.add(instantiationService.createInstance(ExtensionsWorkbenchService));
2315
		instantiationService.set(IExtensionsWorkbenchService, workbenchService);
2316

2317
		instantiationService.stubPromise(IExtensionGalleryService, 'query', aPage(aGalleryExtension('a')));
2318
		const testObject = disposables.add(instantiationService.createInstance(ExtensionsActions.LocalInstallAction));
2319
		disposables.add(instantiationService.createInstance(ExtensionContainers, [testObject]));
2320

2321
		const pager = await workbenchService.queryGallery(CancellationToken.None);
2322
		testObject.extension = pager.firstPage[0];
2323
		assert.ok(testObject.extension);
2324
		assert.ok(!testObject.enabled);
2325
	});
2326

2327
	test('Test local install action is disabled for remote ui extension which is disabled in env', async () => {
2328
		// multi server setup
2329
		const remoteUIExtension = aLocalExtension('a', { extensionKind: ['ui'] }, { location: URI.file(`pub.a`).with({ scheme: Schemas.vscodeRemote }) });
2330
		const environmentService = { disableExtensions: true } as INativeWorkbenchEnvironmentService;
2331
		instantiationService.stub(IEnvironmentService, environmentService);
2332
		instantiationService.stub(INativeEnvironmentService, environmentService);
2333
		instantiationService.stub(IWorkbenchEnvironmentService, environmentService);
2334
		instantiationService.stub(INativeWorkbenchEnvironmentService, environmentService);
2335
		const extensionManagementServerService = aMultiExtensionManagementServerService(instantiationService, createExtensionManagementService(), createExtensionManagementService([remoteUIExtension]));
2336
		instantiationService.stub(IExtensionManagementServerService, extensionManagementServerService);
2337
		instantiationService.stub(IWorkbenchExtensionEnablementService, disposables.add(new TestExtensionEnablementService(instantiationService)));
2338
		const workbenchService: IExtensionsWorkbenchService = disposables.add(instantiationService.createInstance(ExtensionsWorkbenchService));
2339
		instantiationService.set(IExtensionsWorkbenchService, workbenchService);
2340

2341
		instantiationService.stubPromise(IExtensionGalleryService, 'query', aPage(aGalleryExtension('a', { identifier: remoteUIExtension.identifier })));
2342
		const testObject = disposables.add(instantiationService.createInstance(ExtensionsActions.LocalInstallAction));
2343
		disposables.add(instantiationService.createInstance(ExtensionContainers, [testObject]));
2344

2345
		const extensions = await workbenchService.queryLocal(extensionManagementServerService.remoteExtensionManagementServer!);
2346
		await workbenchService.queryGallery(CancellationToken.None);
2347
		testObject.extension = extensions[0];
2348
		assert.ok(testObject.extension);
2349
		assert.ok(!testObject.enabled);
2350
	});
2351

2352
	test('Test local install action is disabled when local server is not available', async () => {
2353
		// single server setup
2354
		const remoteUIExtension = aLocalExtension('a', { extensionKind: ['ui'] }, { location: URI.file(`pub.a`).with({ scheme: Schemas.vscodeRemote }) });
2355
		const extensionManagementServerService = aSingleRemoteExtensionManagementServerService(instantiationService, createExtensionManagementService([remoteUIExtension]));
2356
		instantiationService.stub(IExtensionManagementServerService, extensionManagementServerService);
2357
		instantiationService.stub(IWorkbenchExtensionEnablementService, disposables.add(new TestExtensionEnablementService(instantiationService)));
2358
		const workbenchService: IExtensionsWorkbenchService = disposables.add(instantiationService.createInstance(ExtensionsWorkbenchService));
2359
		instantiationService.set(IExtensionsWorkbenchService, workbenchService);
2360

2361
		instantiationService.stubPromise(IExtensionGalleryService, 'query', aPage(aGalleryExtension('a', { identifier: remoteUIExtension.identifier })));
2362
		const testObject = disposables.add(instantiationService.createInstance(ExtensionsActions.LocalInstallAction));
2363
		disposables.add(instantiationService.createInstance(ExtensionContainers, [testObject]));
2364

2365
		const extensions = await workbenchService.queryLocal(extensionManagementServerService.remoteExtensionManagementServer!);
2366
		await workbenchService.queryGallery(CancellationToken.None);
2367
		testObject.extension = extensions[0];
2368
		assert.ok(testObject.extension);
2369
		assert.ok(!testObject.enabled);
2370
	});
2371

2372
	test('Test local install action is disabled for remote ui extension if it is installed in local', async () => {
2373
		// multi server setup
2374
		const localUIExtension = aLocalExtension('a', { extensionKind: ['ui'] }, { location: URI.file(`pub.a`) });
2375
		const remoteUIExtension = aLocalExtension('a', { extensionKind: ['ui'] }, { location: URI.file(`pub.a`).with({ scheme: Schemas.vscodeRemote }) });
2376
		const extensionManagementServerService = aMultiExtensionManagementServerService(instantiationService, createExtensionManagementService([localUIExtension]), createExtensionManagementService([remoteUIExtension]));
2377
		instantiationService.stub(IExtensionManagementServerService, extensionManagementServerService);
2378
		instantiationService.stub(IWorkbenchExtensionEnablementService, disposables.add(new TestExtensionEnablementService(instantiationService)));
2379
		const workbenchService: IExtensionsWorkbenchService = disposables.add(instantiationService.createInstance(ExtensionsWorkbenchService));
2380
		instantiationService.set(IExtensionsWorkbenchService, workbenchService);
2381

2382
		instantiationService.stubPromise(IExtensionGalleryService, 'query', aPage(aGalleryExtension('a', { identifier: localUIExtension.identifier })));
2383
		const testObject = disposables.add(instantiationService.createInstance(ExtensionsActions.LocalInstallAction));
2384
		disposables.add(instantiationService.createInstance(ExtensionContainers, [testObject]));
2385

2386
		const extensions = await workbenchService.queryLocal(extensionManagementServerService.remoteExtensionManagementServer!);
2387
		await workbenchService.queryGallery(CancellationToken.None);
2388
		testObject.extension = extensions[0];
2389
		assert.ok(testObject.extension);
2390
		assert.ok(!testObject.enabled);
2391
	});
2392

2393
	test('Test local install action is disabled for remoteUI extension if it is uninstalled locally', async () => {
2394
		// multi server setup
2395
		const extensionManagementService = instantiationService.get(IExtensionManagementService) as IProfileAwareExtensionManagementService;
2396
		const extensionManagementServerService = aMultiExtensionManagementServerService(instantiationService, createExtensionManagementService(), extensionManagementService);
2397
		instantiationService.stub(IExtensionManagementServerService, extensionManagementServerService);
2398
		instantiationService.stub(IWorkbenchExtensionEnablementService, disposables.add(new TestExtensionEnablementService(instantiationService)));
2399
		const remoteUIExtension = aLocalExtension('a', { extensionKind: ['ui'] }, { location: URI.file(`pub.a`).with({ scheme: Schemas.vscodeRemote }) });
2400
		instantiationService.stubPromise(IExtensionManagementService, 'getInstalled', [remoteUIExtension]);
2401
		const workbenchService: IExtensionsWorkbenchService = disposables.add(instantiationService.createInstance(ExtensionsWorkbenchService));
2402
		instantiationService.set(IExtensionsWorkbenchService, workbenchService);
2403

2404
		instantiationService.stubPromise(IExtensionGalleryService, 'query', aPage(aGalleryExtension('a', { identifier: remoteUIExtension.identifier })));
2405
		const testObject = disposables.add(instantiationService.createInstance(ExtensionsActions.LocalInstallAction));
2406
		disposables.add(instantiationService.createInstance(ExtensionContainers, [testObject]));
2407

2408
		const extensions = await workbenchService.queryLocal(extensionManagementServerService.remoteExtensionManagementServer!);
2409
		await workbenchService.queryGallery(CancellationToken.None);
2410
		testObject.extension = extensions[0];
2411
		assert.ok(testObject.enabled);
2412
		assert.strictEqual('Install Locally', testObject.label);
2413

2414
		uninstallEvent.fire({ identifier: remoteUIExtension.identifier, profileLocation: null! });
2415
		assert.ok(!testObject.enabled);
2416
	});
2417

2418
	test('Test local install action is enabled for remote UI extension if it has gallery', async () => {
2419
		// multi server setup
2420
		const remoteUIExtension = aLocalExtension('a', { extensionKind: ['ui'] }, { location: URI.file(`pub.a`).with({ scheme: Schemas.vscodeRemote }) });
2421
		const extensionManagementServerService = aMultiExtensionManagementServerService(instantiationService, createExtensionManagementService(), createExtensionManagementService([remoteUIExtension]));
2422
		instantiationService.stub(IExtensionManagementServerService, extensionManagementServerService);
2423
		instantiationService.stub(IWorkbenchExtensionEnablementService, disposables.add(new TestExtensionEnablementService(instantiationService)));
2424
		const workbenchService: IExtensionsWorkbenchService = disposables.add(instantiationService.createInstance(ExtensionsWorkbenchService));
2425
		instantiationService.set(IExtensionsWorkbenchService, workbenchService);
2426

2427
		instantiationService.stubPromise(IExtensionGalleryService, 'query', aPage(aGalleryExtension('a', { identifier: remoteUIExtension.identifier })));
2428
		const testObject = disposables.add(instantiationService.createInstance(ExtensionsActions.LocalInstallAction));
2429
		disposables.add(instantiationService.createInstance(ExtensionContainers, [testObject]));
2430

2431
		const extensions = await workbenchService.queryLocal(extensionManagementServerService.remoteExtensionManagementServer!);
2432
		testObject.extension = extensions[0];
2433
		assert.ok(testObject.extension);
2434
		assert.ok(testObject.enabled);
2435
	});
2436

2437
	test('Test local install action is disabled for remote UI system extension', async () => {
2438
		// multi server setup
2439
		const remoteUISystemExtension = aLocalExtension('a', { extensionKind: ['ui'] }, { location: URI.file(`pub.a`).with({ scheme: Schemas.vscodeRemote }), type: ExtensionType.System });
2440
		const extensionManagementServerService = aMultiExtensionManagementServerService(instantiationService, createExtensionManagementService(), createExtensionManagementService([remoteUISystemExtension]));
2441
		instantiationService.stub(IExtensionManagementServerService, extensionManagementServerService);
2442
		instantiationService.stub(IWorkbenchExtensionEnablementService, disposables.add(new TestExtensionEnablementService(instantiationService)));
2443
		const workbenchService: IExtensionsWorkbenchService = disposables.add(instantiationService.createInstance(ExtensionsWorkbenchService));
2444
		instantiationService.set(IExtensionsWorkbenchService, workbenchService);
2445

2446
		instantiationService.stubPromise(IExtensionGalleryService, 'query', aPage(aGalleryExtension('a', { identifier: remoteUISystemExtension.identifier })));
2447
		const testObject = disposables.add(instantiationService.createInstance(ExtensionsActions.LocalInstallAction));
2448
		disposables.add(instantiationService.createInstance(ExtensionContainers, [testObject]));
2449

2450
		const extensions = await workbenchService.queryLocal(extensionManagementServerService.remoteExtensionManagementServer!);
2451
		testObject.extension = extensions[0];
2452
		assert.ok(testObject.extension);
2453
		assert.ok(!testObject.enabled);
2454
	});
2455

2456
	test('Test local install action is disabled for remote workspace extension if it is not installed in local', async () => {
2457
		// multi server setup
2458
		const remoteWorkspaceExtension = aLocalExtension('a', { extensionKind: ['workspace'] }, { location: URI.file(`pub.a`).with({ scheme: Schemas.vscodeRemote }) });
2459
		const extensionManagementServerService = aMultiExtensionManagementServerService(instantiationService, createExtensionManagementService(), createExtensionManagementService([remoteWorkspaceExtension]));
2460
		instantiationService.stub(IExtensionManagementServerService, extensionManagementServerService);
2461
		instantiationService.stub(IWorkbenchExtensionEnablementService, disposables.add(new TestExtensionEnablementService(instantiationService)));
2462
		const workbenchService: IExtensionsWorkbenchService = disposables.add(instantiationService.createInstance(ExtensionsWorkbenchService));
2463
		instantiationService.set(IExtensionsWorkbenchService, workbenchService);
2464

2465
		instantiationService.stubPromise(IExtensionGalleryService, 'query', aPage(aGalleryExtension('a', { identifier: remoteWorkspaceExtension.identifier })));
2466
		const testObject = disposables.add(instantiationService.createInstance(ExtensionsActions.LocalInstallAction));
2467
		disposables.add(instantiationService.createInstance(ExtensionContainers, [testObject]));
2468

2469
		const extensions = await workbenchService.queryLocal(extensionManagementServerService.remoteExtensionManagementServer!);
2470
		testObject.extension = extensions[0];
2471
		assert.ok(testObject.extension);
2472
		assert.ok(!testObject.enabled);
2473
	});
2474

2475
	test('Test local install action is disabled for remote workspace extension if it is also installed in local', async () => {
2476
		// multi server setup
2477
		const localWorkspaceExtension = aLocalExtension('a', { extensionKind: ['workspae'] }, { location: URI.file(`pub.a`) });
2478
		const remoteWorkspaceExtension = aLocalExtension('a', { extensionKind: ['workspace'] }, { location: URI.file(`pub.a`).with({ scheme: Schemas.vscodeRemote }) });
2479
		const extensionManagementServerService = aMultiExtensionManagementServerService(instantiationService, createExtensionManagementService([localWorkspaceExtension]), createExtensionManagementService([remoteWorkspaceExtension]));
2480
		instantiationService.stub(IExtensionManagementServerService, extensionManagementServerService);
2481
		instantiationService.stub(IWorkbenchExtensionEnablementService, disposables.add(new TestExtensionEnablementService(instantiationService)));
2482
		const workbenchService: IExtensionsWorkbenchService = disposables.add(instantiationService.createInstance(ExtensionsWorkbenchService));
2483
		instantiationService.set(IExtensionsWorkbenchService, workbenchService);
2484

2485
		instantiationService.stubPromise(IExtensionGalleryService, 'query', aPage(aGalleryExtension('a', { identifier: localWorkspaceExtension.identifier })));
2486
		const testObject = disposables.add(instantiationService.createInstance(ExtensionsActions.LocalInstallAction));
2487
		disposables.add(instantiationService.createInstance(ExtensionContainers, [testObject]));
2488

2489
		const extensions = await workbenchService.queryLocal(extensionManagementServerService.remoteExtensionManagementServer!);
2490
		testObject.extension = extensions[0];
2491
		assert.ok(testObject.extension);
2492
		assert.ok(!testObject.enabled);
2493
	});
2494

2495
	test('Test local install action is enabled for remotely installed language pack extension', async () => {
2496
		// multi server setup
2497
		const languagePackExtension = aLocalExtension('a', { contributes: <IExtensionContributions>{ localizations: [{ languageId: 'de', translations: [] }] } }, { location: URI.file(`pub.a`).with({ scheme: Schemas.vscodeRemote }) });
2498
		const extensionManagementServerService = aMultiExtensionManagementServerService(instantiationService, createExtensionManagementService(), createExtensionManagementService([languagePackExtension]));
2499
		instantiationService.stub(IExtensionManagementServerService, extensionManagementServerService);
2500
		instantiationService.stub(IWorkbenchExtensionEnablementService, disposables.add(new TestExtensionEnablementService(instantiationService)));
2501
		const workbenchService: IExtensionsWorkbenchService = disposables.add(instantiationService.createInstance(ExtensionsWorkbenchService));
2502
		instantiationService.set(IExtensionsWorkbenchService, workbenchService);
2503

2504
		instantiationService.stubPromise(IExtensionGalleryService, 'query', aPage(aGalleryExtension('a', { identifier: languagePackExtension.identifier })));
2505
		const testObject = disposables.add(instantiationService.createInstance(ExtensionsActions.LocalInstallAction));
2506
		disposables.add(instantiationService.createInstance(ExtensionContainers, [testObject]));
2507

2508
		const extensions = await workbenchService.queryLocal(extensionManagementServerService.remoteExtensionManagementServer!);
2509
		await workbenchService.queryGallery(CancellationToken.None);
2510
		testObject.extension = extensions[0];
2511
		assert.ok(testObject.enabled);
2512
		assert.strictEqual('Install Locally', testObject.label);
2513
		assert.strictEqual('extension-action label prominent install-other-server', testObject.class);
2514
	});
2515

2516
	test('Test local install action is disabled if remote language pack extension is uninstalled', async () => {
2517
		// multi server setup
2518
		const extensionManagementService = instantiationService.get(IExtensionManagementService) as IProfileAwareExtensionManagementService;
2519
		const extensionManagementServerService = aMultiExtensionManagementServerService(instantiationService, createExtensionManagementService(), extensionManagementService);
2520
		instantiationService.stub(IExtensionManagementServerService, extensionManagementServerService);
2521
		instantiationService.stub(IWorkbenchExtensionEnablementService, disposables.add(new TestExtensionEnablementService(instantiationService)));
2522
		const languagePackExtension = aLocalExtension('a', { contributes: <IExtensionContributions>{ localizations: [{ languageId: 'de', translations: [] }] } }, { location: URI.file(`pub.a`).with({ scheme: Schemas.vscodeRemote }) });
2523
		instantiationService.stubPromise(IExtensionManagementService, 'getInstalled', [languagePackExtension]);
2524
		const workbenchService: IExtensionsWorkbenchService = disposables.add(instantiationService.createInstance(ExtensionsWorkbenchService));
2525
		instantiationService.set(IExtensionsWorkbenchService, workbenchService);
2526

2527
		instantiationService.stubPromise(IExtensionGalleryService, 'query', aPage(aGalleryExtension('a', { identifier: languagePackExtension.identifier })));
2528
		const testObject = disposables.add(instantiationService.createInstance(ExtensionsActions.LocalInstallAction));
2529
		disposables.add(instantiationService.createInstance(ExtensionContainers, [testObject]));
2530

2531
		const extensions = await workbenchService.queryLocal(extensionManagementServerService.remoteExtensionManagementServer!);
2532
		await workbenchService.queryGallery(CancellationToken.None);
2533
		testObject.extension = extensions[0];
2534
		assert.ok(testObject.enabled);
2535
		assert.strictEqual('Install Locally', testObject.label);
2536

2537
		uninstallEvent.fire({ identifier: languagePackExtension.identifier, profileLocation: null! });
2538
		assert.ok(!testObject.enabled);
2539
	});
2540

2541
});
2542

2543
function aLocalExtension(name: string = 'someext', manifest: any = {}, properties: any = {}): ILocalExtension {
2544
	manifest = { name, publisher: 'pub', version: '1.0.0', ...manifest };
2545
	properties = {
2546
		type: ExtensionType.User,
2547
		location: URI.file(`pub.${name}`),
2548
		identifier: { id: getGalleryExtensionId(manifest.publisher, manifest.name) },
2549
		...properties,
2550
		isValid: properties.isValid ?? true,
2551
	};
2552
	properties.isBuiltin = properties.type === ExtensionType.System;
2553
	return <ILocalExtension>Object.create({ manifest, ...properties });
2554
}
2555

2556
function aGalleryExtension(name: string, properties: any = {}, galleryExtensionProperties: any = {}, assets: any = {}): IGalleryExtension {
2557
	const targetPlatform = getTargetPlatform(platform, arch);
2558
	const galleryExtension = <IGalleryExtension>Object.create({ name, publisher: 'pub', version: '1.0.0', allTargetPlatforms: [targetPlatform], properties: {}, assets: {}, isSigned: true, ...properties });
2559
	galleryExtension.properties = { ...galleryExtension.properties, dependencies: [], targetPlatform, ...galleryExtensionProperties };
2560
	galleryExtension.assets = { ...galleryExtension.assets, ...assets };
2561
	galleryExtension.identifier = { id: getGalleryExtensionId(galleryExtension.publisher, galleryExtension.name), uuid: generateUuid() };
2562
	galleryExtension.hasReleaseVersion = true;
2563
	return <IGalleryExtension>galleryExtension;
2564
}
2565

2566
function aPage<T>(...objects: T[]): IPager<T> {
2567
	return { firstPage: objects, total: objects.length, pageSize: objects.length, getPage: () => null! };
2568
}
2569

2570
function aSingleRemoteExtensionManagementServerService(instantiationService: TestInstantiationService, remoteExtensionManagementService?: IProfileAwareExtensionManagementService): IExtensionManagementServerService {
2571
	const remoteExtensionManagementServer: IExtensionManagementServer = {
2572
		id: 'vscode-remote',
2573
		label: 'remote',
2574
		extensionManagementService: remoteExtensionManagementService || createExtensionManagementService(),
2575
	};
2576
	return {
2577
		_serviceBrand: undefined,
2578
		localExtensionManagementServer: null,
2579
		remoteExtensionManagementServer,
2580
		webExtensionManagementServer: null,
2581
		getExtensionManagementServer: (extension: IExtension) => {
2582
			if (extension.location.scheme === Schemas.vscodeRemote) {
2583
				return remoteExtensionManagementServer;
2584
			}
2585
			return null;
2586
		},
2587
		getExtensionInstallLocation(extension: IExtension): ExtensionInstallLocation | null {
2588
			const server = this.getExtensionManagementServer(extension);
2589
			return server === remoteExtensionManagementServer ? ExtensionInstallLocation.Remote : ExtensionInstallLocation.Local;
2590
		}
2591
	};
2592
}
2593

2594
function aMultiExtensionManagementServerService(instantiationService: TestInstantiationService, localExtensionManagementService?: IProfileAwareExtensionManagementService | null, remoteExtensionManagementService?: IProfileAwareExtensionManagementService | null, webExtensionManagementService?: IProfileAwareExtensionManagementService): IExtensionManagementServerService {
2595
	const localExtensionManagementServer: IExtensionManagementServer | null = localExtensionManagementService === null ? null : {
2596
		id: 'vscode-local',
2597
		label: 'local',
2598
		extensionManagementService: localExtensionManagementService || createExtensionManagementService(),
2599
	};
2600
	const remoteExtensionManagementServer: IExtensionManagementServer | null = remoteExtensionManagementService === null ? null : {
2601
		id: 'vscode-remote',
2602
		label: 'remote',
2603
		extensionManagementService: remoteExtensionManagementService || createExtensionManagementService(),
2604
	};
2605
	const webExtensionManagementServer: IExtensionManagementServer | null = webExtensionManagementService ? {
2606
		id: 'vscode-web',
2607
		label: 'web',
2608
		extensionManagementService: webExtensionManagementService,
2609
	} : null;
2610
	return {
2611
		_serviceBrand: undefined,
2612
		localExtensionManagementServer,
2613
		remoteExtensionManagementServer,
2614
		webExtensionManagementServer,
2615
		getExtensionManagementServer: (extension: IExtension) => {
2616
			if (extension.location.scheme === Schemas.file) {
2617
				return localExtensionManagementServer;
2618
			}
2619
			if (extension.location.scheme === Schemas.vscodeRemote) {
2620
				return remoteExtensionManagementServer;
2621
			}
2622
			if (extension.location.scheme === Schemas.vscodeUserData) {
2623
				return webExtensionManagementServer;
2624
			}
2625
			throw new Error('');
2626
		},
2627
		getExtensionInstallLocation(extension: IExtension): ExtensionInstallLocation | null {
2628
			const server = this.getExtensionManagementServer(extension);
2629
			if (server === null) {
2630
				return null;
2631
			}
2632
			if (server === remoteExtensionManagementServer) {
2633
				return ExtensionInstallLocation.Remote;
2634
			}
2635
			if (server === webExtensionManagementServer) {
2636
				return ExtensionInstallLocation.Web;
2637
			}
2638
			return ExtensionInstallLocation.Local;
2639
		}
2640
	};
2641
}
2642

2643
function createExtensionManagementService(installed: ILocalExtension[] = []): IProfileAwareExtensionManagementService {
2644
	return <IProfileAwareExtensionManagementService>{
2645
		onInstallExtension: Event.None,
2646
		onDidInstallExtensions: Event.None,
2647
		onUninstallExtension: Event.None,
2648
		onDidUninstallExtension: Event.None,
2649
		onDidChangeProfile: Event.None,
2650
		onDidUpdateExtensionMetadata: Event.None,
2651
		onProfileAwareDidInstallExtensions: Event.None,
2652
		getInstalled: () => Promise.resolve<ILocalExtension[]>(installed),
2653
		canInstall: async (extension: IGalleryExtension) => { return true; },
2654
		installFromGallery: (extension: IGalleryExtension) => Promise.reject(new Error('not supported')),
2655
		updateMetadata: async (local: Mutable<ILocalExtension>, metadata: Partial<Metadata>, profileLocation: URI) => {
2656
			local.identifier.uuid = metadata.id;
2657
			local.publisherDisplayName = metadata.publisherDisplayName!;
2658
			local.publisherId = metadata.publisherId!;
2659
			return local;
2660
		},
2661
		async getTargetPlatform() { return getTargetPlatform(platform, arch); },
2662
		async getExtensionsControlManifest() { return <IExtensionsControlManifest>{ malicious: [], deprecated: {}, search: [], publisherMapping: {} }; },
2663
	};
2664
}
2665

2666
Product

Resources

Company
