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 { IFileService } from '../../../../../platform/files/common/files.js';
61
import { FileService } from '../../../../../platform/files/common/fileService.js';
62
import { Mutable } from '../../../../../base/common/types.js';
63
import { IUserDataProfileService } from '../../../../services/userDataProfile/common/userDataProfile.js';
64
import { UserDataProfileService } from '../../../../services/userDataProfile/common/userDataProfileService.js';
65
import { toUserDataProfile } from '../../../../../platform/userDataProfile/common/userDataProfile.js';
66

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

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

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

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

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

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

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

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

118
	instantiationService.stub(IRemoteAgentService, RemoteAgentService);
119

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

133
	instantiationService.stub(IUserDataProfileService, disposables.add(new UserDataProfileService(toUserDataProfile('test', 'test', URI.file('foo'), URI.file('cache')))));
134
	instantiationService.stub(IWorkbenchExtensionEnablementService, disposables.add(new TestExtensionEnablementService(instantiationService)));
135
	instantiationService.stub(ILabelService, { onDidChangeFormatters: disposables.add(new Emitter<IFormatterChangeEvent>()).event });
136

137
	instantiationService.stub(ILifecycleService, disposables.add(new TestLifecycleService()));
138
	instantiationService.stub(IExtensionTipsService, disposables.add(instantiationService.createInstance(TestExtensionTipsService)));
139
	instantiationService.stub(IExtensionRecommendationsService, {});
140
	instantiationService.stub(IURLService, NativeURLService);
141

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

148
	instantiationService.stub(IUserDataSyncEnablementService, disposables.add(instantiationService.createInstance(UserDataSyncEnablementService)));
149

150
	instantiationService.stub(IUpdateService, { onStateChange: Event.None, state: State.Uninitialized });
151
	instantiationService.set(IExtensionsWorkbenchService, disposables.add(instantiationService.createInstance(ExtensionsWorkbenchService)));
152
	instantiationService.stub(IWorkspaceTrustManagementService, disposables.add(new TestWorkspaceTrustManagementService()));
153
}
154

155

156
suite('ExtensionsActions', () => {
157

158
	const disposables = ensureNoDisposablesAreLeakedInTestSuite();
159
	setup(() => setupTest(disposables));
160

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

164
		assert.ok(!testObject.enabled);
165
	});
166

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

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

197
				assert.ok(!testObject.enabled);
198
				assert.strictEqual('Installing', testObject.label);
199
				assert.strictEqual('extension-action label install installing', testObject.class);
200
			});
201
	});
202

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

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

223
		return instantiationService.get(IExtensionsWorkbenchService).queryLocal()
224
			.then(extensions => {
225
				uninstallEvent.fire({ identifier: local.identifier, profileLocation: null! });
226
				didUninstallEvent.fire({ identifier: local.identifier, profileLocation: null! });
227
				testObject.extension = extensions[0];
228
				assert.ok(!testObject.enabled);
229
			});
230
	});
231

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

238
		return instantiationService.get(IExtensionsWorkbenchService).queryLocal()
239
			.then(extensions => {
240
				uninstallEvent.fire({ identifier: local.identifier, profileLocation: null! });
241
				didUninstallEvent.fire({ identifier: local.identifier, profileLocation: null! });
242
				testObject.extension = extensions[0];
243
				assert.ok(!testObject.enabled);
244
			});
245
	});
246

247
	test('Uninstall action is disabled when there is no extension', () => {
248
		const testObject: ExtensionsActions.UninstallAction = disposables.add(instantiationService.createInstance(ExtensionsActions.UninstallAction));
249
		disposables.add(instantiationService.createInstance(ExtensionContainers, [testObject]));
250

251
		assert.ok(!testObject.enabled);
252
	});
253

254
	test('Test Uninstall action when state is uninstalling', () => {
255
		const testObject: ExtensionsActions.UninstallAction = disposables.add(instantiationService.createInstance(ExtensionsActions.UninstallAction));
256
		disposables.add(instantiationService.createInstance(ExtensionContainers, [testObject]));
257
		const local = aLocalExtension('a');
258
		instantiationService.stubPromise(IExtensionManagementService, 'getInstalled', [local]);
259

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

270
	test('Test Uninstall action when state is installed and is user extension', () => {
271
		const testObject: ExtensionsActions.UninstallAction = disposables.add(instantiationService.createInstance(ExtensionsActions.UninstallAction));
272
		disposables.add(instantiationService.createInstance(ExtensionContainers, [testObject]));
273
		const local = aLocalExtension('a');
274
		instantiationService.stubPromise(IExtensionManagementService, 'getInstalled', [local]);
275

276
		return instantiationService.get(IExtensionsWorkbenchService).queryLocal()
277
			.then(extensions => {
278
				testObject.extension = extensions[0];
279
				assert.ok(testObject.enabled);
280
				assert.strictEqual('Uninstall', testObject.label);
281
				assert.strictEqual('extension-action label uninstall', testObject.class);
282
			});
283
	});
284

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

291
		return instantiationService.get(IExtensionsWorkbenchService).queryLocal()
292
			.then(extensions => {
293
				testObject.extension = extensions[0];
294
				assert.ok(!testObject.enabled);
295
				assert.strictEqual('Uninstall', testObject.label);
296
				assert.strictEqual('extension-action label uninstall', testObject.class);
297
			});
298
	});
299

300
	test('Test Uninstall action when state is installing and is user extension', () => {
301
		const testObject: ExtensionsActions.UninstallAction = disposables.add(instantiationService.createInstance(ExtensionsActions.UninstallAction));
302
		disposables.add(instantiationService.createInstance(ExtensionContainers, [testObject]));
303
		const local = aLocalExtension('a');
304
		instantiationService.stubPromise(IExtensionManagementService, 'getInstalled', [local]);
305

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

317
	test('Test Uninstall action after extension is installed', async () => {
318
		const testObject: ExtensionsActions.UninstallAction = disposables.add(instantiationService.createInstance(ExtensionsActions.UninstallAction));
319
		disposables.add(instantiationService.createInstance(ExtensionContainers, [testObject]));
320
		const gallery = aGalleryExtension('a');
321
		instantiationService.stubPromise(IExtensionGalleryService, 'query', aPage(gallery));
322

323
		const paged = await instantiationService.get(IExtensionsWorkbenchService).queryGallery(CancellationToken.None);
324
		testObject.extension = paged.firstPage[0];
325

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

330
		await promise;
331
		assert.ok(testObject.enabled);
332
		assert.strictEqual('Uninstall', testObject.label);
333
		assert.strictEqual('extension-action label uninstall', testObject.class);
334
	});
335

336
	test('Test UpdateAction when there is no extension', () => {
337
		const testObject: ExtensionsActions.UpdateAction = disposables.add(instantiationService.createInstance(ExtensionsActions.UpdateAction, false));
338
		disposables.add(instantiationService.createInstance(ExtensionContainers, [testObject]));
339

340
		assert.ok(!testObject.enabled);
341
	});
342

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

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

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

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

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

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

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

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

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

441
	test('Test ManageExtensionAction when there is no extension', () => {
442
		const testObject: ExtensionsActions.ManageExtensionAction = disposables.add(instantiationService.createInstance(ExtensionsActions.ManageExtensionAction));
443
		disposables.add(instantiationService.createInstance(ExtensionContainers, [testObject]));
444

445
		assert.ok(!testObject.enabled);
446
	});
447

448
	test('Test ManageExtensionAction when extension is installed', () => {
449
		const testObject: ExtensionsActions.ManageExtensionAction = disposables.add(instantiationService.createInstance(ExtensionsActions.ManageExtensionAction));
450
		disposables.add(instantiationService.createInstance(ExtensionContainers, [testObject]));
451
		const local = aLocalExtension('a');
452
		instantiationService.stubPromise(IExtensionManagementService, 'getInstalled', [local]);
453

454
		return instantiationService.get(IExtensionsWorkbenchService).queryLocal()
455
			.then(extensions => {
456
				testObject.extension = extensions[0];
457
				assert.ok(testObject.enabled);
458
				assert.strictEqual('extension-action icon manage codicon codicon-extensions-manage', testObject.class);
459
				assert.strictEqual('Manage', testObject.tooltip);
460
			});
461
	});
462

463
	test('Test ManageExtensionAction when extension is uninstalled', () => {
464
		const testObject: ExtensionsActions.ManageExtensionAction = disposables.add(instantiationService.createInstance(ExtensionsActions.ManageExtensionAction));
465
		disposables.add(instantiationService.createInstance(ExtensionContainers, [testObject]));
466
		const gallery = aGalleryExtension('a');
467
		instantiationService.stubPromise(IExtensionGalleryService, 'query', aPage(gallery));
468

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

478
	test('Test ManageExtensionAction when extension is installing', () => {
479
		const testObject: ExtensionsActions.ManageExtensionAction = disposables.add(instantiationService.createInstance(ExtensionsActions.ManageExtensionAction));
480
		disposables.add(instantiationService.createInstance(ExtensionContainers, [testObject]));
481
		const gallery = aGalleryExtension('a');
482
		instantiationService.stubPromise(IExtensionGalleryService, 'query', aPage(gallery));
483

484
		return instantiationService.get(IExtensionsWorkbenchService).queryGallery(CancellationToken.None)
485
			.then(page => {
486
				testObject.extension = page.firstPage[0];
487

488
				installEvent.fire({ identifier: gallery.identifier, source: gallery, profileLocation: null! });
489
				assert.ok(!testObject.enabled);
490
				assert.strictEqual('extension-action icon manage codicon codicon-extensions-manage hide', testObject.class);
491
				assert.strictEqual('Manage', testObject.tooltip);
492
			});
493
	});
494

495
	test('Test ManageExtensionAction when extension is queried from gallery and installed', async () => {
496
		const testObject: ExtensionsActions.ManageExtensionAction = disposables.add(instantiationService.createInstance(ExtensionsActions.ManageExtensionAction));
497
		disposables.add(instantiationService.createInstance(ExtensionContainers, [testObject]));
498
		const gallery = aGalleryExtension('a');
499
		instantiationService.stubPromise(IExtensionGalleryService, 'query', aPage(gallery));
500

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

507
		await promise;
508
		assert.ok(testObject.enabled);
509
		assert.strictEqual('extension-action icon manage codicon codicon-extensions-manage', testObject.class);
510
		assert.strictEqual('Manage', testObject.tooltip);
511
	});
512

513
	test('Test ManageExtensionAction when extension is system extension', () => {
514
		const testObject: ExtensionsActions.ManageExtensionAction = disposables.add(instantiationService.createInstance(ExtensionsActions.ManageExtensionAction));
515
		disposables.add(instantiationService.createInstance(ExtensionContainers, [testObject]));
516
		const local = aLocalExtension('a', {}, { type: ExtensionType.System });
517
		instantiationService.stubPromise(IExtensionManagementService, 'getInstalled', [local]);
518

519
		return instantiationService.get(IExtensionsWorkbenchService).queryLocal()
520
			.then(extensions => {
521
				testObject.extension = extensions[0];
522
				assert.ok(testObject.enabled);
523
				assert.strictEqual('extension-action icon manage codicon codicon-extensions-manage', testObject.class);
524
				assert.strictEqual('Manage', testObject.tooltip);
525
			});
526
	});
527

528
	test('Test ManageExtensionAction when extension is uninstalling', () => {
529
		const testObject: ExtensionsActions.ManageExtensionAction = disposables.add(instantiationService.createInstance(ExtensionsActions.ManageExtensionAction));
530
		disposables.add(instantiationService.createInstance(ExtensionContainers, [testObject]));
531
		const local = aLocalExtension('a');
532
		instantiationService.stubPromise(IExtensionManagementService, 'getInstalled', [local]);
533

534
		return instantiationService.get(IExtensionsWorkbenchService).queryLocal()
535
			.then(extensions => {
536
				testObject.extension = extensions[0];
537
				uninstallEvent.fire({ identifier: local.identifier, profileLocation: null! });
538

539
				assert.ok(!testObject.enabled);
540
				assert.strictEqual('extension-action icon manage codicon codicon-extensions-manage', testObject.class);
541
				assert.strictEqual('Manage', testObject.tooltip);
542
			});
543
	});
544

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

548
		assert.ok(!testObject.enabled);
549
	});
550

551
	test('Test EnableForWorkspaceAction when there extension is not disabled', () => {
552
		const local = aLocalExtension('a');
553
		instantiationService.stubPromise(IExtensionManagementService, 'getInstalled', [local]);
554

555
		return instantiationService.get(IExtensionsWorkbenchService).queryLocal()
556
			.then(extensions => {
557
				const testObject: ExtensionsActions.EnableForWorkspaceAction = disposables.add(instantiationService.createInstance(ExtensionsActions.EnableForWorkspaceAction));
558
				testObject.extension = extensions[0];
559
				assert.ok(!testObject.enabled);
560
			});
561
	});
562

563
	test('Test EnableForWorkspaceAction when the extension is disabled globally', () => {
564
		const local = aLocalExtension('a');
565
		return instantiationService.get(IWorkbenchExtensionEnablementService).setEnablement([local], EnablementState.DisabledGlobally)
566
			.then(() => {
567
				instantiationService.stubPromise(IExtensionManagementService, 'getInstalled', [local]);
568

569
				return instantiationService.get(IExtensionsWorkbenchService).queryLocal()
570
					.then(extensions => {
571
						const testObject: ExtensionsActions.EnableForWorkspaceAction = disposables.add(instantiationService.createInstance(ExtensionsActions.EnableForWorkspaceAction));
572
						testObject.extension = extensions[0];
573
						assert.ok(testObject.enabled);
574
					});
575
			});
576
	});
577

578
	test('Test EnableForWorkspaceAction when extension is disabled for workspace', () => {
579
		const local = aLocalExtension('a');
580
		return instantiationService.get(IWorkbenchExtensionEnablementService).setEnablement([local], EnablementState.DisabledWorkspace)
581
			.then(() => {
582
				instantiationService.stubPromise(IExtensionManagementService, 'getInstalled', [local]);
583

584
				return instantiationService.get(IExtensionsWorkbenchService).queryLocal()
585
					.then(extensions => {
586
						const testObject: ExtensionsActions.EnableForWorkspaceAction = disposables.add(instantiationService.createInstance(ExtensionsActions.EnableForWorkspaceAction));
587
						testObject.extension = extensions[0];
588
						assert.ok(testObject.enabled);
589
					});
590
			});
591
	});
592

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

600
				return instantiationService.get(IExtensionsWorkbenchService).queryLocal()
601
					.then(extensions => {
602
						const testObject: ExtensionsActions.EnableForWorkspaceAction = disposables.add(instantiationService.createInstance(ExtensionsActions.EnableForWorkspaceAction));
603
						testObject.extension = extensions[0];
604
						assert.ok(testObject.enabled);
605
					});
606
			});
607
	});
608

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

612
		assert.ok(!testObject.enabled);
613
	});
614

615
	test('Test EnableGloballyAction when the extension is not disabled', () => {
616
		const local = aLocalExtension('a');
617
		instantiationService.stubPromise(IExtensionManagementService, 'getInstalled', [local]);
618

619
		return instantiationService.get(IExtensionsWorkbenchService).queryLocal()
620
			.then(extensions => {
621
				const testObject: ExtensionsActions.EnableGloballyAction = disposables.add(instantiationService.createInstance(ExtensionsActions.EnableGloballyAction));
622
				testObject.extension = extensions[0];
623
				assert.ok(!testObject.enabled);
624
			});
625
	});
626

627
	test('Test EnableGloballyAction when the extension is disabled for workspace', () => {
628
		const local = aLocalExtension('a');
629
		return instantiationService.get(IWorkbenchExtensionEnablementService).setEnablement([local], EnablementState.DisabledWorkspace)
630
			.then(() => {
631
				instantiationService.stubPromise(IExtensionManagementService, 'getInstalled', [local]);
632

633
				return instantiationService.get(IExtensionsWorkbenchService).queryLocal()
634
					.then(extensions => {
635
						const testObject: ExtensionsActions.EnableGloballyAction = disposables.add(instantiationService.createInstance(ExtensionsActions.EnableGloballyAction));
636
						testObject.extension = extensions[0];
637
						assert.ok(!testObject.enabled);
638
					});
639
			});
640
	});
641

642
	test('Test EnableGloballyAction when the extension is disabled globally', () => {
643
		const local = aLocalExtension('a');
644
		return instantiationService.get(IWorkbenchExtensionEnablementService).setEnablement([local], EnablementState.DisabledGlobally)
645
			.then(() => {
646
				instantiationService.stubPromise(IExtensionManagementService, 'getInstalled', [local]);
647

648
				return instantiationService.get(IExtensionsWorkbenchService).queryLocal()
649
					.then(extensions => {
650
						const testObject: ExtensionsActions.EnableGloballyAction = disposables.add(instantiationService.createInstance(ExtensionsActions.EnableGloballyAction));
651
						testObject.extension = extensions[0];
652
						assert.ok(testObject.enabled);
653
					});
654
			});
655
	});
656

657
	test('Test EnableGloballyAction when the extension is disabled in both', () => {
658
		const local = aLocalExtension('a');
659
		return instantiationService.get(IWorkbenchExtensionEnablementService).setEnablement([local], EnablementState.DisabledGlobally)
660
			.then(() => instantiationService.get(IWorkbenchExtensionEnablementService).setEnablement([local], EnablementState.DisabledWorkspace))
661
			.then(() => {
662
				instantiationService.stubPromise(IExtensionManagementService, 'getInstalled', [local]);
663

664
				return instantiationService.get(IExtensionsWorkbenchService).queryLocal()
665
					.then(extensions => {
666
						const testObject: ExtensionsActions.EnableGloballyAction = disposables.add(instantiationService.createInstance(ExtensionsActions.EnableGloballyAction));
667
						testObject.extension = extensions[0];
668
						assert.ok(testObject.enabled);
669
					});
670
			});
671
	});
672

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

676
		assert.ok(!testObject.enabled);
677
	});
678

679
	test('Test EnableDropDownAction when extension is installed and enabled', () => {
680
		const local = aLocalExtension('a');
681
		instantiationService.stubPromise(IExtensionManagementService, 'getInstalled', [local]);
682

683
		return instantiationService.get(IExtensionsWorkbenchService).queryLocal()
684
			.then(extensions => {
685
				const testObject: ExtensionsActions.EnableDropDownAction = disposables.add(instantiationService.createInstance(ExtensionsActions.EnableDropDownAction));
686
				testObject.extension = extensions[0];
687
				assert.ok(!testObject.enabled);
688
			});
689
	});
690

691
	test('Test EnableDropDownAction when extension is installed and disabled globally', () => {
692
		const local = aLocalExtension('a');
693
		return instantiationService.get(IWorkbenchExtensionEnablementService).setEnablement([local], EnablementState.DisabledGlobally)
694
			.then(() => {
695
				instantiationService.stubPromise(IExtensionManagementService, 'getInstalled', [local]);
696

697
				return instantiationService.get(IExtensionsWorkbenchService).queryLocal()
698
					.then(extensions => {
699
						const testObject: ExtensionsActions.EnableDropDownAction = disposables.add(instantiationService.createInstance(ExtensionsActions.EnableDropDownAction));
700
						testObject.extension = extensions[0];
701
						assert.ok(testObject.enabled);
702
					});
703
			});
704
	});
705

706
	test('Test EnableDropDownAction when extension is installed and disabled for workspace', () => {
707
		const local = aLocalExtension('a');
708
		return instantiationService.get(IWorkbenchExtensionEnablementService).setEnablement([local], EnablementState.DisabledWorkspace)
709
			.then(() => {
710
				instantiationService.stubPromise(IExtensionManagementService, 'getInstalled', [local]);
711

712
				return instantiationService.get(IExtensionsWorkbenchService).queryLocal()
713
					.then(extensions => {
714
						const testObject: ExtensionsActions.EnableDropDownAction = disposables.add(instantiationService.createInstance(ExtensionsActions.EnableDropDownAction));
715
						testObject.extension = extensions[0];
716
						assert.ok(testObject.enabled);
717
					});
718
			});
719
	});
720

721
	test('Test EnableDropDownAction when extension is uninstalled', () => {
722
		const gallery = aGalleryExtension('a');
723
		instantiationService.stubPromise(IExtensionGalleryService, 'query', aPage(gallery));
724

725
		return instantiationService.get(IExtensionsWorkbenchService).queryGallery(CancellationToken.None)
726
			.then(page => {
727
				const testObject: ExtensionsActions.EnableDropDownAction = disposables.add(instantiationService.createInstance(ExtensionsActions.EnableDropDownAction));
728
				testObject.extension = page.firstPage[0];
729
				assert.ok(!testObject.enabled);
730
			});
731
	});
732

733
	test('Test EnableDropDownAction when extension is installing', () => {
734
		const gallery = aGalleryExtension('a');
735
		instantiationService.stubPromise(IExtensionGalleryService, 'query', aPage(gallery));
736

737
		return instantiationService.get(IExtensionsWorkbenchService).queryGallery(CancellationToken.None)
738
			.then(page => {
739
				const testObject: ExtensionsActions.EnableDropDownAction = disposables.add(instantiationService.createInstance(ExtensionsActions.EnableDropDownAction));
740
				testObject.extension = page.firstPage[0];
741
				disposables.add(instantiationService.createInstance(ExtensionContainers, [testObject]));
742

743
				installEvent.fire({ identifier: gallery.identifier, source: gallery, profileLocation: null! });
744
				assert.ok(!testObject.enabled);
745
			});
746
	});
747

748
	test('Test EnableDropDownAction when extension is uninstalling', () => {
749
		const local = aLocalExtension('a');
750
		instantiationService.stubPromise(IExtensionManagementService, 'getInstalled', [local]);
751

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

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

764
		assert.ok(!testObject.enabled);
765
	});
766

767
	test('Test DisableForWorkspaceAction when the extension is disabled globally', () => {
768
		const local = aLocalExtension('a');
769
		return instantiationService.get(IWorkbenchExtensionEnablementService).setEnablement([local], EnablementState.DisabledGlobally)
770
			.then(() => {
771
				instantiationService.stubPromise(IExtensionManagementService, 'getInstalled', [local]);
772

773
				return instantiationService.get(IExtensionsWorkbenchService).queryLocal()
774
					.then(extensions => {
775
						const testObject: ExtensionsActions.DisableForWorkspaceAction = disposables.add(instantiationService.createInstance(ExtensionsActions.DisableForWorkspaceAction));
776
						testObject.extension = extensions[0];
777
						assert.ok(!testObject.enabled);
778
					});
779
			});
780
	});
781

782
	test('Test DisableForWorkspaceAction when the extension is disabled workspace', () => {
783
		const local = aLocalExtension('a');
784
		return instantiationService.get(IWorkbenchExtensionEnablementService).setEnablement([local], EnablementState.DisabledGlobally)
785
			.then(() => {
786
				instantiationService.stubPromise(IExtensionManagementService, 'getInstalled', [local]);
787

788
				return instantiationService.get(IExtensionsWorkbenchService).queryLocal()
789
					.then(extensions => {
790
						const testObject: ExtensionsActions.DisableForWorkspaceAction = disposables.add(instantiationService.createInstance(ExtensionsActions.DisableForWorkspaceAction));
791
						testObject.extension = extensions[0];
792
						assert.ok(!testObject.enabled);
793
					});
794
			});
795
	});
796

797
	test('Test DisableForWorkspaceAction when extension is enabled', () => {
798
		const local = aLocalExtension('a');
799
		instantiationService.stub(IExtensionService, {
800
			extensions: [toExtensionDescription(local)],
801
			onDidChangeExtensions: Event.None,
802
			whenInstalledExtensionsRegistered: () => Promise.resolve(true)
803
		});
804

805
		instantiationService.stubPromise(IExtensionManagementService, 'getInstalled', [local]);
806

807
		return instantiationService.get(IExtensionsWorkbenchService).queryLocal()
808
			.then(extensions => {
809
				const testObject: ExtensionsActions.DisableForWorkspaceAction = disposables.add(instantiationService.createInstance(ExtensionsActions.DisableForWorkspaceAction));
810
				testObject.extension = extensions[0];
811
				assert.ok(testObject.enabled);
812
			});
813
	});
814

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

818
		assert.ok(!testObject.enabled);
819
	});
820

821
	test('Test DisableGloballyAction when the extension is disabled globally', () => {
822
		const local = aLocalExtension('a');
823
		return instantiationService.get(IWorkbenchExtensionEnablementService).setEnablement([local], EnablementState.DisabledGlobally)
824
			.then(() => {
825
				instantiationService.stubPromise(IExtensionManagementService, 'getInstalled', [local]);
826

827
				return instantiationService.get(IExtensionsWorkbenchService).queryLocal()
828
					.then(extensions => {
829
						const testObject: ExtensionsActions.DisableGloballyAction = disposables.add(instantiationService.createInstance(ExtensionsActions.DisableGloballyAction));
830
						testObject.extension = extensions[0];
831
						assert.ok(!testObject.enabled);
832
					});
833
			});
834
	});
835

836
	test('Test DisableGloballyAction when the extension is disabled for workspace', () => {
837
		const local = aLocalExtension('a');
838
		return instantiationService.get(IWorkbenchExtensionEnablementService).setEnablement([local], EnablementState.DisabledWorkspace)
839
			.then(() => {
840
				instantiationService.stubPromise(IExtensionManagementService, 'getInstalled', [local]);
841

842
				return instantiationService.get(IExtensionsWorkbenchService).queryLocal()
843
					.then(extensions => {
844
						const testObject: ExtensionsActions.DisableGloballyAction = disposables.add(instantiationService.createInstance(ExtensionsActions.DisableGloballyAction));
845
						testObject.extension = extensions[0];
846
						assert.ok(!testObject.enabled);
847
					});
848
			});
849
	});
850

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

860
		return instantiationService.get(IExtensionsWorkbenchService).queryLocal()
861
			.then(extensions => {
862
				const testObject: ExtensionsActions.DisableGloballyAction = disposables.add(instantiationService.createInstance(ExtensionsActions.DisableGloballyAction));
863
				testObject.extension = extensions[0];
864
				assert.ok(testObject.enabled);
865
			});
866
	});
867

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

877
		return instantiationService.get(IExtensionsWorkbenchService).queryLocal()
878
			.then(extensions => {
879
				const testObject: ExtensionsActions.DisableGloballyAction = disposables.add(instantiationService.createInstance(ExtensionsActions.DisableGloballyAction));
880
				testObject.extension = extensions[0];
881
				assert.ok(testObject.enabled);
882
			});
883
	});
884

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

893
		return instantiationService.get(IWorkbenchExtensionEnablementService).setEnablement([local], EnablementState.DisabledGlobally)
894
			.then(() => {
895
				instantiationService.stubPromise(IExtensionManagementService, 'getInstalled', [local]);
896

897
				return instantiationService.get(IExtensionsWorkbenchService).queryLocal()
898
					.then(extensions => {
899
						const testObject: ExtensionsActions.DisableGloballyAction = disposables.add(instantiationService.createInstance(ExtensionsActions.DisableGloballyAction));
900
						testObject.extension = extensions[0];
901
						assert.ok(!testObject.enabled);
902
					});
903
			});
904
	});
905

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

915
		return instantiationService.get(IExtensionsWorkbenchService).queryGallery(CancellationToken.None)
916
			.then(page => {
917
				const testObject: ExtensionsActions.DisableGloballyAction = disposables.add(instantiationService.createInstance(ExtensionsActions.DisableGloballyAction));
918
				testObject.extension = page.firstPage[0];
919
				assert.ok(!testObject.enabled);
920
			});
921
	});
922

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

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

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

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

961
});
962

963
suite('ExtensionRuntimeStateAction', () => {
964

965
	const disposables = ensureNoDisposablesAreLeakedInTestSuite();
966

967
	setup(() => setupTest(disposables));
968

969
	test('Test Runtime State when there is no extension', () => {
970
		const testObject: ExtensionsActions.ExtensionRuntimeStateAction = disposables.add(instantiationService.createInstance(ExtensionsActions.ExtensionRuntimeStateAction));
971
		disposables.add(instantiationService.createInstance(ExtensionContainers, [testObject]));
972

973
		assert.ok(!testObject.enabled);
974
	});
975

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

986
		assert.ok(!testObject.enabled);
987
	});
988

989
	test('Test Runtime State when extension state is uninstalling', async () => {
990
		const testObject: ExtensionsActions.ExtensionRuntimeStateAction = disposables.add(instantiationService.createInstance(ExtensionsActions.ExtensionRuntimeStateAction));
991
		disposables.add(instantiationService.createInstance(ExtensionContainers, [testObject]));
992
		const local = aLocalExtension('a');
993
		instantiationService.stubPromise(IExtensionManagementService, 'getInstalled', [local]);
994

995
		const extensions = await instantiationService.get(IExtensionsWorkbenchService).queryLocal();
996
		testObject.extension = extensions[0];
997
		uninstallEvent.fire({ identifier: local.identifier, profileLocation: null! });
998
		assert.ok(!testObject.enabled);
999
	});
1000

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

1014
		const paged = await instantiationService.get(IExtensionsWorkbenchService).queryGallery(CancellationToken.None);
1015
		testObject.extension = paged.firstPage[0];
1016
		assert.ok(!testObject.enabled);
1017

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

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

1040
		const paged = await instantiationService.get(IExtensionsWorkbenchService).queryGallery(CancellationToken.None);
1041
		testObject.extension = paged.firstPage[0];
1042
		assert.ok(!testObject.enabled);
1043

1044
		installEvent.fire({ identifier: gallery.identifier, source: gallery, profileLocation: null! });
1045
		didInstallEvent.fire([{ identifier: gallery.identifier, source: gallery, operation: InstallOperation.Install, local: aLocalExtension('a', gallery, gallery), profileLocation: null! }]);
1046
		assert.ok(!testObject.enabled);
1047
	});
1048

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

1063
		testObject.extension = paged.firstPage[0];
1064
		const identifier = gallery.identifier;
1065
		installEvent.fire({ identifier, source: gallery, profileLocation: null! });
1066
		didInstallEvent.fire([{ identifier, source: gallery, operation: InstallOperation.Install, local: aLocalExtension('a', gallery, { identifier }), profileLocation: null! }]);
1067
		uninstallEvent.fire({ identifier, profileLocation: null! });
1068
		didUninstallEvent.fire({ identifier, profileLocation: null! });
1069

1070
		assert.ok(!testObject.enabled);
1071
	});
1072

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

1089
		uninstallEvent.fire({ identifier: local.identifier, profileLocation: null! });
1090
		didUninstallEvent.fire({ identifier: local.identifier, profileLocation: null! });
1091
		assert.ok(testObject.enabled);
1092
		assert.strictEqual(testObject.tooltip, `Please restart extensions to complete the uninstallation of this extension.`);
1093
	});
1094

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

1110
		uninstallEvent.fire({ identifier: local.identifier, profileLocation: null! });
1111
		didUninstallEvent.fire({ identifier: local.identifier, profileLocation: null! });
1112
		assert.ok(!testObject.enabled);
1113
	});
1114

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

1130
		testObject.extension = extensions[0];
1131
		uninstallEvent.fire({ identifier: local.identifier, profileLocation: null! });
1132
		didUninstallEvent.fire({ identifier: local.identifier, profileLocation: null! });
1133

1134
		const gallery = aGalleryExtension('a');
1135
		const identifier = gallery.identifier;
1136
		installEvent.fire({ identifier, source: gallery, profileLocation: null! });
1137
		didInstallEvent.fire([{ identifier, source: gallery, operation: InstallOperation.Install, local, profileLocation: null! }]);
1138

1139
		assert.ok(!testObject.enabled);
1140
	});
1141

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

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

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

1188
		const gallery = aGalleryExtension('a', { identifier: local.identifier, version: '1.0.2' });
1189
		installEvent.fire({ identifier: gallery.identifier, source: gallery, profileLocation: null! });
1190
		didInstallEvent.fire([{ identifier: gallery.identifier, source: gallery, operation: InstallOperation.Update, local: aLocalExtension('a', gallery, gallery), profileLocation: null! }]);
1191

1192
		assert.ok(!testObject.enabled);
1193
	});
1194

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

1214
		assert.ok(testObject.enabled);
1215
		assert.strictEqual(`Please restart extensions to disable this extension.`, testObject.tooltip);
1216
	});
1217

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

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

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

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

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

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

1321
		const paged = await instantiationService.get(IExtensionsWorkbenchService).queryGallery(CancellationToken.None);
1322
		testObject.extension = paged.firstPage[0];
1323
		assert.ok(!testObject.enabled);
1324

1325
		installEvent.fire({ identifier: gallery.identifier, source: gallery, profileLocation: null! });
1326
		didInstallEvent.fire([{ identifier: gallery.identifier, source: gallery, operation: InstallOperation.Install, local: aLocalExtension('a', { ...gallery, ...{ contributes: <IExtensionContributions>{ localizations: [{ languageId: 'de', translations: [] }] } } }, gallery), profileLocation: null! }]);
1327
		assert.ok(!testObject.enabled);
1328
	});
1329

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

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

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

1370
		const testObject: ExtensionsActions.ExtensionRuntimeStateAction = disposables.add(instantiationService.createInstance(ExtensionsActions.ExtensionRuntimeStateAction));
1371
		disposables.add(instantiationService.createInstance(ExtensionContainers, [testObject]));
1372
		instantiationService.stubPromise(IExtensionGalleryService, 'query', aPage(gallery));
1373

1374
		await workbenchService.queryGallery(CancellationToken.None);
1375
		const extensions = await workbenchService.queryLocal(extensionManagementServerService.localExtensionManagementServer!);
1376
		testObject.extension = extensions[0];
1377
		assert.ok(testObject.extension);
1378
		assert.ok(!testObject.enabled);
1379
	});
1380

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

1404
		const testObject: ExtensionsActions.ExtensionRuntimeStateAction = disposables.add(instantiationService.createInstance(ExtensionsActions.ExtensionRuntimeStateAction));
1405
		disposables.add(instantiationService.createInstance(ExtensionContainers, [testObject]));
1406
		instantiationService.stubPromise(IExtensionGalleryService, 'query', aPage(gallery));
1407

1408
		await workbenchService.queryGallery(CancellationToken.None);
1409
		const extensions = await workbenchService.queryLocal(extensionManagementServerService.localExtensionManagementServer!);
1410
		testObject.extension = extensions[0];
1411
		assert.ok(testObject.extension);
1412
		assert.ok(!testObject.enabled);
1413

1414
		uninstallEvent.fire({ identifier: localExtension.identifier, profileLocation: null! });
1415
		didUninstallEvent.fire({ identifier: localExtension.identifier, profileLocation: null! });
1416

1417
		assert.ok(!testObject.enabled);
1418
	});
1419

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

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

1444
		await workbenchService.queryGallery(CancellationToken.None);
1445
		const extensions = await workbenchService.queryLocal(extensionManagementServerService.localExtensionManagementServer!);
1446
		testObject.extension = extensions[0];
1447
		assert.ok(testObject.extension);
1448
		assert.ok(!testObject.enabled);
1449

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

1454
		await promise;
1455
		assert.ok(testObject.enabled);
1456
		assert.strictEqual(testObject.tooltip, `Please reload window to enable this extension.`);
1457
	});
1458

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

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

1483
		await workbenchService.queryGallery(CancellationToken.None);
1484
		const extensions = await workbenchService.queryLocal(extensionManagementServerService.remoteExtensionManagementServer!);
1485
		testObject.extension = extensions[0];
1486
		assert.ok(testObject.extension);
1487
		assert.ok(!testObject.enabled);
1488

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

1493
		await promise;
1494
		assert.ok(testObject.enabled);
1495
		assert.strictEqual(testObject.tooltip, `Please reload window to enable this extension.`);
1496
	});
1497

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

1519
		const testObject: ExtensionsActions.ExtensionRuntimeStateAction = disposables.add(instantiationService.createInstance(ExtensionsActions.ExtensionRuntimeStateAction));
1520
		disposables.add(instantiationService.createInstance(ExtensionContainers, [testObject]));
1521
		instantiationService.stubPromise(IExtensionGalleryService, 'query', aPage(gallery));
1522

1523
		await workbenchService.queryGallery(CancellationToken.None);
1524
		const extensions = await workbenchService.queryLocal(extensionManagementServerService.remoteExtensionManagementServer!);
1525
		testObject.extension = extensions[0];
1526
		assert.ok(testObject.extension);
1527
		assert.ok(!testObject.enabled);
1528
	});
1529

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

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

1555
		await workbenchService.queryGallery(CancellationToken.None);
1556
		const extensions = await workbenchService.queryLocal(extensionManagementServerService.remoteExtensionManagementServer!);
1557
		testObject.extension = extensions[0];
1558
		assert.ok(testObject.extension);
1559
		assert.ok(testObject.enabled);
1560
	});
1561

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

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

1587
		await workbenchService.queryGallery(CancellationToken.None);
1588
		const extensions = await workbenchService.queryLocal(extensionManagementServerService.localExtensionManagementServer!);
1589
		testObject.extension = extensions[0];
1590
		assert.ok(testObject.extension);
1591
		assert.ok(testObject.enabled);
1592
	});
1593

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

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

1619
		await workbenchService.queryGallery(CancellationToken.None);
1620
		const extensions = await workbenchService.queryLocal(extensionManagementServerService.localExtensionManagementServer!);
1621
		testObject.extension = extensions[0];
1622
		assert.ok(testObject.extension);
1623
		assert.ok(testObject.enabled);
1624
	});
1625

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

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

1651
		await workbenchService.queryGallery(CancellationToken.None);
1652
		const extensions = await workbenchService.queryLocal(extensionManagementServerService.remoteExtensionManagementServer!);
1653
		testObject.extension = extensions[0];
1654
		assert.ok(testObject.extension);
1655
		assert.ok(testObject.enabled);
1656
	});
1657

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

1675
		const testObject: ExtensionsActions.ExtensionRuntimeStateAction = disposables.add(instantiationService.createInstance(ExtensionsActions.ExtensionRuntimeStateAction));
1676
		disposables.add(instantiationService.createInstance(ExtensionContainers, [testObject]));
1677
		instantiationService.stubPromise(IExtensionGalleryService, 'query', aPage(gallery));
1678

1679
		await workbenchService.queryGallery(CancellationToken.None);
1680
		const extensions = await workbenchService.queryLocal(extensionManagementServerService.remoteExtensionManagementServer!);
1681
		testObject.extension = extensions[0];
1682
		assert.ok(testObject.extension);
1683
		assert.ok(!testObject.enabled);
1684
	});
1685

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

1703
		const testObject: ExtensionsActions.ExtensionRuntimeStateAction = disposables.add(instantiationService.createInstance(ExtensionsActions.ExtensionRuntimeStateAction));
1704
		disposables.add(instantiationService.createInstance(ExtensionContainers, [testObject]));
1705
		instantiationService.stubPromise(IExtensionGalleryService, 'query', aPage(gallery));
1706

1707
		await workbenchService.queryGallery(CancellationToken.None);
1708
		const extensions = await workbenchService.queryLocal(extensionManagementServerService.remoteExtensionManagementServer!);
1709
		testObject.extension = extensions[0];
1710
		assert.ok(testObject.extension);
1711
		assert.ok(!testObject.enabled);
1712
	});
1713
});
1714

1715
suite('RemoteInstallAction', () => {
1716

1717
	const disposables = ensureNoDisposablesAreLeakedInTestSuite();
1718

1719
	setup(() => setupTest(disposables));
1720

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

1730
		instantiationService.stubPromise(IExtensionGalleryService, 'query', aPage(aGalleryExtension('a', { identifier: localWorkspaceExtension.identifier })));
1731
		const testObject = disposables.add(instantiationService.createInstance(ExtensionsActions.RemoteInstallAction, false));
1732
		disposables.add(instantiationService.createInstance(ExtensionContainers, [testObject]));
1733

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

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

1755
		const gallery = aGalleryExtension('a', { identifier: localWorkspaceExtension.identifier });
1756
		instantiationService.stubPromise(IExtensionGalleryService, 'query', aPage(gallery));
1757
		const testObject = disposables.add(instantiationService.createInstance(ExtensionsActions.RemoteInstallAction, false));
1758
		disposables.add(instantiationService.createInstance(ExtensionContainers, [testObject]));
1759

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

1767
		onInstallExtension.fire({ identifier: localWorkspaceExtension.identifier, source: gallery, profileLocation: null! });
1768
		assert.ok(testObject.enabled);
1769
		assert.strictEqual('Installing', testObject.label);
1770
		assert.strictEqual('extension-action label install-other-server installing', testObject.class);
1771
	});
1772

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

1788
		const gallery = aGalleryExtension('a', { identifier: localWorkspaceExtension.identifier });
1789
		instantiationService.stubPromise(IExtensionGalleryService, 'query', aPage(gallery));
1790
		const testObject = disposables.add(instantiationService.createInstance(ExtensionsActions.RemoteInstallAction, false));
1791
		disposables.add(instantiationService.createInstance(ExtensionContainers, [testObject]));
1792

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

1800
		onInstallExtension.fire({ identifier: localWorkspaceExtension.identifier, source: gallery, profileLocation: null! });
1801
		assert.ok(testObject.enabled);
1802
		assert.strictEqual('Installing', testObject.label);
1803
		assert.strictEqual('extension-action label install-other-server installing', testObject.class);
1804

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

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

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

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

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

1844
		await instantiationService.get(IWorkbenchExtensionEnablementService).setEnablement([localWorkspaceExtension], EnablementState.DisabledGlobally);
1845
		instantiationService.stubPromise(IExtensionGalleryService, 'query', aPage(aGalleryExtension('a', { identifier: localWorkspaceExtension.identifier })));
1846
		const testObject = disposables.add(instantiationService.createInstance(ExtensionsActions.RemoteInstallAction, false));
1847
		disposables.add(instantiationService.createInstance(ExtensionContainers, [testObject]));
1848

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

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

1866
		await instantiationService.get(IWorkbenchExtensionEnablementService).setEnablement([localWorkspaceExtension], EnablementState.DisabledGlobally);
1867
		instantiationService.stubPromise(IExtensionGalleryService, 'query', aPage(aGalleryExtension('a', { identifier: localWorkspaceExtension.identifier })));
1868
		const testObject = disposables.add(instantiationService.createInstance(ExtensionsActions.RemoteInstallAction, true));
1869
		disposables.add(instantiationService.createInstance(ExtensionContainers, [testObject]));
1870

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

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

1888
		await instantiationService.get(IWorkbenchExtensionEnablementService).setEnablement([localWorkspaceExtension], EnablementState.DisabledGlobally);
1889
		instantiationService.stubPromise(IExtensionGalleryService, 'query', aPage(aGalleryExtension('a', { identifier: localWorkspaceExtension.identifier })));
1890
		const testObject = disposables.add(instantiationService.createInstance(ExtensionsActions.RemoteInstallAction, false));
1891
		disposables.add(instantiationService.createInstance(ExtensionContainers, [testObject]));
1892

1893
		const extensions = await workbenchService.queryLocal(extensionManagementServerService.localExtensionManagementServer!);
1894
		await workbenchService.queryGallery(CancellationToken.None);
1895
		testObject.extension = extensions[0];
1896
		assert.ok(!testObject.enabled);
1897
	});
1898

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

1907
		instantiationService.stubPromise(IExtensionGalleryService, 'query', aPage(aGalleryExtension('a', { identifier: localWorkspaceExtension.identifier })));
1908
		const testObject = disposables.add(instantiationService.createInstance(ExtensionsActions.RemoteInstallAction, false));
1909
		disposables.add(instantiationService.createInstance(ExtensionContainers, [testObject]));
1910

1911
		await workbenchService.queryLocal(extensionManagementServerService.localExtensionManagementServer!);
1912
		await workbenchService.queryGallery(CancellationToken.None);
1913
		assert.ok(!testObject.enabled);
1914
	});
1915

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

1924
		instantiationService.stubPromise(IExtensionGalleryService, 'query', aPage(aGalleryExtension('a')));
1925
		const testObject = disposables.add(instantiationService.createInstance(ExtensionsActions.RemoteInstallAction, false));
1926
		disposables.add(instantiationService.createInstance(ExtensionContainers, [testObject]));
1927

1928
		const pager = await workbenchService.queryGallery(CancellationToken.None);
1929
		testObject.extension = pager.firstPage[0];
1930
		assert.ok(testObject.extension);
1931
		assert.ok(!testObject.enabled);
1932
	});
1933

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

1948
		instantiationService.stubPromise(IExtensionGalleryService, 'query', aPage(aGalleryExtension('a', { identifier: localWorkspaceExtension.identifier })));
1949
		const testObject = disposables.add(instantiationService.createInstance(ExtensionsActions.RemoteInstallAction, false));
1950
		disposables.add(instantiationService.createInstance(ExtensionContainers, [testObject]));
1951

1952
		const extensions = await workbenchService.queryLocal(extensionManagementServerService.localExtensionManagementServer!);
1953
		await workbenchService.queryGallery(CancellationToken.None);
1954
		testObject.extension = extensions[0];
1955
		assert.ok(testObject.extension);
1956
		assert.ok(!testObject.enabled);
1957
	});
1958

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

1969
		const extensions = await workbenchService.queryLocal(extensionManagementServerService.localExtensionManagementServer!);
1970
		await workbenchService.queryGallery(CancellationToken.None);
1971
		testObject.extension = extensions[0];
1972
		assert.ok(testObject.extension);
1973
		assert.ok(!testObject.enabled);
1974
	});
1975

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

1987
		instantiationService.stubPromise(IExtensionGalleryService, 'query', aPage(aGalleryExtension('a', { identifier: localWorkspaceExtension.identifier })));
1988
		const testObject = disposables.add(instantiationService.createInstance(ExtensionsActions.RemoteInstallAction, false));
1989
		disposables.add(instantiationService.createInstance(ExtensionContainers, [testObject]));
1990

1991
		const extensions = await workbenchService.queryLocal(extensionManagementServerService.localExtensionManagementServer!);
1992
		await workbenchService.queryGallery(CancellationToken.None);
1993
		testObject.extension = extensions[0];
1994
		assert.ok(testObject.enabled);
1995
		assert.strictEqual('Install in remote', testObject.label);
1996

1997
		uninstallEvent.fire({ identifier: localWorkspaceExtension.identifier, profileLocation: null! });
1998
		assert.ok(!testObject.enabled);
1999
	});
2000

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

2011
		instantiationService.stubPromise(IExtensionGalleryService, 'query', aPage(aGalleryExtension('a', { identifier: localWorkspaceExtension.identifier })));
2012
		const testObject = disposables.add(instantiationService.createInstance(ExtensionsActions.RemoteInstallAction, false));
2013
		disposables.add(instantiationService.createInstance(ExtensionContainers, [testObject]));
2014

2015
		const extensions = await workbenchService.queryLocal(extensionManagementServerService.localExtensionManagementServer!);
2016
		await workbenchService.queryGallery(CancellationToken.None);
2017
		testObject.extension = extensions[0];
2018
		assert.ok(testObject.extension);
2019
		assert.ok(!testObject.enabled);
2020
	});
2021

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

2031
		instantiationService.stubPromise(IExtensionGalleryService, 'query', aPage(aGalleryExtension('a', { identifier: localWorkspaceExtension.identifier })));
2032
		const testObject = disposables.add(instantiationService.createInstance(ExtensionsActions.RemoteInstallAction, false));
2033
		disposables.add(instantiationService.createInstance(ExtensionContainers, [testObject]));
2034

2035
		const extensions = await workbenchService.queryLocal(extensionManagementServerService.localExtensionManagementServer!);
2036
		testObject.extension = extensions[0];
2037
		assert.ok(testObject.extension);
2038
		assert.ok(testObject.enabled);
2039
	});
2040

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

2050
		instantiationService.stubPromise(IExtensionGalleryService, 'query', aPage(aGalleryExtension('a', { identifier: localWorkspaceSystemExtension.identifier })));
2051
		const testObject = disposables.add(instantiationService.createInstance(ExtensionsActions.RemoteInstallAction, false));
2052
		disposables.add(instantiationService.createInstance(ExtensionContainers, [testObject]));
2053

2054
		const extensions = await workbenchService.queryLocal(extensionManagementServerService.localExtensionManagementServer!);
2055
		testObject.extension = extensions[0];
2056
		assert.ok(testObject.extension);
2057
		assert.ok(!testObject.enabled);
2058
	});
2059

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

2069
		instantiationService.stubPromise(IExtensionGalleryService, 'query', aPage(aGalleryExtension('a', { identifier: localUIExtension.identifier })));
2070
		const testObject = disposables.add(instantiationService.createInstance(ExtensionsActions.RemoteInstallAction, false));
2071
		disposables.add(instantiationService.createInstance(ExtensionContainers, [testObject]));
2072

2073
		const extensions = await workbenchService.queryLocal(extensionManagementServerService.localExtensionManagementServer!);
2074
		testObject.extension = extensions[0];
2075
		assert.ok(testObject.extension);
2076
		assert.ok(!testObject.enabled);
2077
	});
2078

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

2089
		instantiationService.stubPromise(IExtensionGalleryService, 'query', aPage(aGalleryExtension('a', { identifier: localUIExtension.identifier })));
2090
		const testObject = disposables.add(instantiationService.createInstance(ExtensionsActions.RemoteInstallAction, false));
2091
		disposables.add(instantiationService.createInstance(ExtensionContainers, [testObject]));
2092

2093
		const extensions = await workbenchService.queryLocal(extensionManagementServerService.localExtensionManagementServer!);
2094
		testObject.extension = extensions[0];
2095
		assert.ok(testObject.extension);
2096
		assert.ok(!testObject.enabled);
2097
	});
2098

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

2108
		instantiationService.stubPromise(IExtensionGalleryService, 'query', aPage(aGalleryExtension('a', { identifier: languagePackExtension.identifier })));
2109
		const testObject = disposables.add(instantiationService.createInstance(ExtensionsActions.RemoteInstallAction, false));
2110
		disposables.add(instantiationService.createInstance(ExtensionContainers, [testObject]));
2111

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

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

2131
		instantiationService.stubPromise(IExtensionGalleryService, 'query', aPage(aGalleryExtension('a', { identifier: languagePackExtension.identifier })));
2132
		const testObject = disposables.add(instantiationService.createInstance(ExtensionsActions.RemoteInstallAction, false));
2133
		disposables.add(instantiationService.createInstance(ExtensionContainers, [testObject]));
2134

2135
		const extensions = await workbenchService.queryLocal(extensionManagementServerService.localExtensionManagementServer!);
2136
		await workbenchService.queryGallery(CancellationToken.None);
2137
		testObject.extension = extensions[0];
2138
		assert.ok(testObject.enabled);
2139
		assert.strictEqual('Install in remote', testObject.label);
2140

2141
		uninstallEvent.fire({ identifier: languagePackExtension.identifier, profileLocation: null! });
2142
		assert.ok(!testObject.enabled);
2143
	});
2144
});
2145

2146
suite('LocalInstallAction', () => {
2147

2148
	const disposables = ensureNoDisposablesAreLeakedInTestSuite();
2149

2150
	setup(() => setupTest(disposables));
2151

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

2161
		instantiationService.stubPromise(IExtensionGalleryService, 'query', aPage(aGalleryExtension('a', { identifier: remoteUIExtension.identifier })));
2162
		const testObject = disposables.add(instantiationService.createInstance(ExtensionsActions.LocalInstallAction));
2163
		disposables.add(instantiationService.createInstance(ExtensionContainers, [testObject]));
2164

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

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

2182
		instantiationService.stubPromise(IExtensionGalleryService, 'query', aPage(aGalleryExtension('a', { identifier: remoteUIExtension.identifier })));
2183
		const testObject = disposables.add(instantiationService.createInstance(ExtensionsActions.LocalInstallAction));
2184
		disposables.add(instantiationService.createInstance(ExtensionContainers, [testObject]));
2185

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

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

2207
		const gallery = aGalleryExtension('a', { identifier: remoteUIExtension.identifier });
2208
		instantiationService.stubPromise(IExtensionGalleryService, 'query', aPage(gallery));
2209
		const testObject = disposables.add(instantiationService.createInstance(ExtensionsActions.LocalInstallAction));
2210
		disposables.add(instantiationService.createInstance(ExtensionContainers, [testObject]));
2211

2212
		const extensions = await workbenchService.queryLocal(extensionManagementServerService.remoteExtensionManagementServer!);
2213
		await workbenchService.queryGallery(CancellationToken.None);
2214
		testObject.extension = extensions[0];
2215
		assert.ok(testObject.enabled);
2216
		assert.strictEqual('Install Locally', testObject.label);
2217
		assert.strictEqual('extension-action label prominent install-other-server', testObject.class);
2218

2219
		onInstallExtension.fire({ identifier: remoteUIExtension.identifier, source: gallery, profileLocation: null! });
2220
		assert.ok(testObject.enabled);
2221
		assert.strictEqual('Installing', testObject.label);
2222
		assert.strictEqual('extension-action label install-other-server installing', testObject.class);
2223
	});
2224

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

2240
		const gallery = aGalleryExtension('a', { identifier: remoteUIExtension.identifier });
2241
		instantiationService.stubPromise(IExtensionGalleryService, 'query', aPage(gallery));
2242
		const testObject = disposables.add(instantiationService.createInstance(ExtensionsActions.LocalInstallAction));
2243
		disposables.add(instantiationService.createInstance(ExtensionContainers, [testObject]));
2244

2245
		const extensions = await workbenchService.queryLocal(extensionManagementServerService.remoteExtensionManagementServer!);
2246
		await workbenchService.queryGallery(CancellationToken.None);
2247
		testObject.extension = extensions[0];
2248
		assert.ok(testObject.enabled);
2249
		assert.strictEqual('Install Locally', testObject.label);
2250
		assert.strictEqual('extension-action label prominent install-other-server', testObject.class);
2251

2252
		onInstallExtension.fire({ identifier: remoteUIExtension.identifier, source: gallery, profileLocation: null! });
2253
		assert.ok(testObject.enabled);
2254
		assert.strictEqual('Installing', testObject.label);
2255
		assert.strictEqual('extension-action label install-other-server installing', testObject.class);
2256

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

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

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

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

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

2295
		instantiationService.stubPromise(IExtensionGalleryService, 'query', aPage(aGalleryExtension('a', { identifier: remoteUIExtension.identifier })));
2296
		const testObject = disposables.add(instantiationService.createInstance(ExtensionsActions.LocalInstallAction));
2297
		disposables.add(instantiationService.createInstance(ExtensionContainers, [testObject]));
2298

2299
		await workbenchService.queryLocal(extensionManagementServerService.remoteExtensionManagementServer!);
2300
		await workbenchService.queryGallery(CancellationToken.None);
2301
		assert.ok(!testObject.enabled);
2302
	});
2303

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

2312
		instantiationService.stubPromise(IExtensionGalleryService, 'query', aPage(aGalleryExtension('a')));
2313
		const testObject = disposables.add(instantiationService.createInstance(ExtensionsActions.LocalInstallAction));
2314
		disposables.add(instantiationService.createInstance(ExtensionContainers, [testObject]));
2315

2316
		const pager = await workbenchService.queryGallery(CancellationToken.None);
2317
		testObject.extension = pager.firstPage[0];
2318
		assert.ok(testObject.extension);
2319
		assert.ok(!testObject.enabled);
2320
	});
2321

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

2336
		instantiationService.stubPromise(IExtensionGalleryService, 'query', aPage(aGalleryExtension('a', { identifier: remoteUIExtension.identifier })));
2337
		const testObject = disposables.add(instantiationService.createInstance(ExtensionsActions.LocalInstallAction));
2338
		disposables.add(instantiationService.createInstance(ExtensionContainers, [testObject]));
2339

2340
		const extensions = await workbenchService.queryLocal(extensionManagementServerService.remoteExtensionManagementServer!);
2341
		await workbenchService.queryGallery(CancellationToken.None);
2342
		testObject.extension = extensions[0];
2343
		assert.ok(testObject.extension);
2344
		assert.ok(!testObject.enabled);
2345
	});
2346

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

2356
		instantiationService.stubPromise(IExtensionGalleryService, 'query', aPage(aGalleryExtension('a', { identifier: remoteUIExtension.identifier })));
2357
		const testObject = disposables.add(instantiationService.createInstance(ExtensionsActions.LocalInstallAction));
2358
		disposables.add(instantiationService.createInstance(ExtensionContainers, [testObject]));
2359

2360
		const extensions = await workbenchService.queryLocal(extensionManagementServerService.remoteExtensionManagementServer!);
2361
		await workbenchService.queryGallery(CancellationToken.None);
2362
		testObject.extension = extensions[0];
2363
		assert.ok(testObject.extension);
2364
		assert.ok(!testObject.enabled);
2365
	});
2366

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

2377
		instantiationService.stubPromise(IExtensionGalleryService, 'query', aPage(aGalleryExtension('a', { identifier: localUIExtension.identifier })));
2378
		const testObject = disposables.add(instantiationService.createInstance(ExtensionsActions.LocalInstallAction));
2379
		disposables.add(instantiationService.createInstance(ExtensionContainers, [testObject]));
2380

2381
		const extensions = await workbenchService.queryLocal(extensionManagementServerService.remoteExtensionManagementServer!);
2382
		await workbenchService.queryGallery(CancellationToken.None);
2383
		testObject.extension = extensions[0];
2384
		assert.ok(testObject.extension);
2385
		assert.ok(!testObject.enabled);
2386
	});
2387

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

2399
		instantiationService.stubPromise(IExtensionGalleryService, 'query', aPage(aGalleryExtension('a', { identifier: remoteUIExtension.identifier })));
2400
		const testObject = disposables.add(instantiationService.createInstance(ExtensionsActions.LocalInstallAction));
2401
		disposables.add(instantiationService.createInstance(ExtensionContainers, [testObject]));
2402

2403
		const extensions = await workbenchService.queryLocal(extensionManagementServerService.remoteExtensionManagementServer!);
2404
		await workbenchService.queryGallery(CancellationToken.None);
2405
		testObject.extension = extensions[0];
2406
		assert.ok(testObject.enabled);
2407
		assert.strictEqual('Install Locally', testObject.label);
2408

2409
		uninstallEvent.fire({ identifier: remoteUIExtension.identifier, profileLocation: null! });
2410
		assert.ok(!testObject.enabled);
2411
	});
2412

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

2422
		instantiationService.stubPromise(IExtensionGalleryService, 'query', aPage(aGalleryExtension('a', { identifier: remoteUIExtension.identifier })));
2423
		const testObject = disposables.add(instantiationService.createInstance(ExtensionsActions.LocalInstallAction));
2424
		disposables.add(instantiationService.createInstance(ExtensionContainers, [testObject]));
2425

2426
		const extensions = await workbenchService.queryLocal(extensionManagementServerService.remoteExtensionManagementServer!);
2427
		testObject.extension = extensions[0];
2428
		assert.ok(testObject.extension);
2429
		assert.ok(testObject.enabled);
2430
	});
2431

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

2441
		instantiationService.stubPromise(IExtensionGalleryService, 'query', aPage(aGalleryExtension('a', { identifier: remoteUISystemExtension.identifier })));
2442
		const testObject = disposables.add(instantiationService.createInstance(ExtensionsActions.LocalInstallAction));
2443
		disposables.add(instantiationService.createInstance(ExtensionContainers, [testObject]));
2444

2445
		const extensions = await workbenchService.queryLocal(extensionManagementServerService.remoteExtensionManagementServer!);
2446
		testObject.extension = extensions[0];
2447
		assert.ok(testObject.extension);
2448
		assert.ok(!testObject.enabled);
2449
	});
2450

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

2460
		instantiationService.stubPromise(IExtensionGalleryService, 'query', aPage(aGalleryExtension('a', { identifier: remoteWorkspaceExtension.identifier })));
2461
		const testObject = disposables.add(instantiationService.createInstance(ExtensionsActions.LocalInstallAction));
2462
		disposables.add(instantiationService.createInstance(ExtensionContainers, [testObject]));
2463

2464
		const extensions = await workbenchService.queryLocal(extensionManagementServerService.remoteExtensionManagementServer!);
2465
		testObject.extension = extensions[0];
2466
		assert.ok(testObject.extension);
2467
		assert.ok(!testObject.enabled);
2468
	});
2469

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

2480
		instantiationService.stubPromise(IExtensionGalleryService, 'query', aPage(aGalleryExtension('a', { identifier: localWorkspaceExtension.identifier })));
2481
		const testObject = disposables.add(instantiationService.createInstance(ExtensionsActions.LocalInstallAction));
2482
		disposables.add(instantiationService.createInstance(ExtensionContainers, [testObject]));
2483

2484
		const extensions = await workbenchService.queryLocal(extensionManagementServerService.remoteExtensionManagementServer!);
2485
		testObject.extension = extensions[0];
2486
		assert.ok(testObject.extension);
2487
		assert.ok(!testObject.enabled);
2488
	});
2489

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

2499
		instantiationService.stubPromise(IExtensionGalleryService, 'query', aPage(aGalleryExtension('a', { identifier: languagePackExtension.identifier })));
2500
		const testObject = disposables.add(instantiationService.createInstance(ExtensionsActions.LocalInstallAction));
2501
		disposables.add(instantiationService.createInstance(ExtensionContainers, [testObject]));
2502

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

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

2522
		instantiationService.stubPromise(IExtensionGalleryService, 'query', aPage(aGalleryExtension('a', { identifier: languagePackExtension.identifier })));
2523
		const testObject = disposables.add(instantiationService.createInstance(ExtensionsActions.LocalInstallAction));
2524
		disposables.add(instantiationService.createInstance(ExtensionContainers, [testObject]));
2525

2526
		const extensions = await workbenchService.queryLocal(extensionManagementServerService.remoteExtensionManagementServer!);
2527
		await workbenchService.queryGallery(CancellationToken.None);
2528
		testObject.extension = extensions[0];
2529
		assert.ok(testObject.enabled);
2530
		assert.strictEqual('Install Locally', testObject.label);
2531

2532
		uninstallEvent.fire({ identifier: languagePackExtension.identifier, profileLocation: null! });
2533
		assert.ok(!testObject.enabled);
2534
	});
2535

2536
});
2537

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

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

2561
function aPage<T>(...objects: T[]): IPager<T> {
2562
	return { firstPage: objects, total: objects.length, pageSize: objects.length, getPage: () => null! };
2563
}
2564

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

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

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

2661
Product

Resources

Company
