Merge from master

src/vs/platform/extensionManagement/test/electron-browser/extensionEnablementService.test.ts

@@ -2,19 +2,16 @@
  *  Copyright (c) Microsoft Corporation. All rights reserved.
  *  Licensed under the Source EULA. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
-'use strict';
-
 import * as assert from 'assert';
 import * as sinon from 'sinon';
-import { IExtensionManagementService, IExtensionEnablementService, DidUninstallExtensionEvent, EnablementState, IExtensionContributions, ILocalExtension, LocalExtensionType } from 'vs/platform/extensionManagement/common/extensionManagement';
+import { IExtensionManagementService, IExtensionEnablementService, DidUninstallExtensionEvent, EnablementState, IExtensionContributions, ILocalExtension, LocalExtensionType, DidInstallExtensionEvent, InstallOperation } from 'vs/platform/extensionManagement/common/extensionManagement';
 import { ExtensionEnablementService } from 'vs/platform/extensionManagement/common/extensionEnablementService';
 import { TestInstantiationService } from 'vs/platform/instantiation/test/common/instantiationServiceMock';
 import { Emitter } from 'vs/base/common/event';
-import { StorageService, InMemoryLocalStorage } from 'vs/platform/storage/common/storageService';
-import { IStorageService } from 'vs/platform/storage/common/storage';
 import { IWorkspaceContextService, WorkbenchState } from 'vs/platform/workspace/common/workspace';
 import { IEnvironmentService } from 'vs/platform/environment/common/environment';
-import { TPromise } from 'vs/base/common/winjs.base';
+import { IStorageService } from 'vs/platform/storage/common/storage';
+import { TestStorageService } from 'vs/workbench/test/workbenchTestServices';
 
 function storageService(instantiationService: TestInstantiationService): IStorageService {
 	let service = instantiationService.get(IStorageService);
@@ -25,18 +22,17 @@ function storageService(instantiationService: TestInstantiationService): IStorag
 				getWorkbenchState: () => WorkbenchState.FOLDER,
 			});
 		}
-		service = instantiationService.stub(IStorageService, instantiationService.createInstance(StorageService, new InMemoryLocalStorage(), new InMemoryLocalStorage()));
+		service = instantiationService.stub(IStorageService, new TestStorageService());
 	}
 	return service;
 }
 
-
 export class TestExtensionEnablementService extends ExtensionEnablementService {
 	constructor(instantiationService: TestInstantiationService) {
 		super(storageService(instantiationService), instantiationService.get(IWorkspaceContextService),
 			instantiationService.get(IEnvironmentService) || instantiationService.stub(IEnvironmentService, {} as IEnvironmentService),
 			instantiationService.get(IExtensionManagementService) || instantiationService.stub(IExtensionManagementService,
-				{ onDidUninstallExtension: new Emitter<DidUninstallExtensionEvent>().event } as IExtensionManagementService));
+				{ onDidInstallExtension: new Emitter<DidInstallExtensionEvent>().event, onDidUninstallExtension: new Emitter<DidUninstallExtensionEvent>().event } as IExtensionManagementService));
 	}
 
 	public async reset(): Promise<void> {
@@ -50,10 +46,11 @@ suite('ExtensionEnablementService Test', () => {
 	let testObject: IExtensionEnablementService;
 
 	const didUninstallEvent: Emitter<DidUninstallExtensionEvent> = new Emitter<DidUninstallExtensionEvent>();
+	const didInstallEvent: Emitter<DidInstallExtensionEvent> = new Emitter<DidInstallExtensionEvent>();
 
 	setup(() => {
 		instantiationService = new TestInstantiationService();
-		instantiationService.stub(IExtensionManagementService, { onDidUninstallExtension: didUninstallEvent.event, getInstalled: () => TPromise.as([]) } as IExtensionManagementService);
+		instantiationService.stub(IExtensionManagementService, { onDidUninstallExtension: didUninstallEvent.event, onDidInstallExtension: didInstallEvent.event, getInstalled: () => Promise.resolve([]) } as IExtensionManagementService);
 		testObject = new TestExtensionEnablementService(instantiationService);
 	});
 
@@ -298,6 +295,90 @@ suite('ExtensionEnablementService Test', () => {
 			.then(extensions => assert.deepEqual([], extensions));
 	});
 
+	test('test installing an extension re-eanbles it when disabled globally', async () => {
+		const local = aLocalExtension('pub.a');
+		await testObject.setEnablement(local, EnablementState.Disabled);
+		didInstallEvent.fire({ local, identifier: local.galleryIdentifier, operation: InstallOperation.Install });
+		const extensions = await testObject.getDisabledExtensions();
+		assert.deepEqual([], extensions);
+	});
+
+	test('test updating an extension does not re-eanbles it when disabled globally', async () => {
+		const local = aLocalExtension('pub.a');
+		await testObject.setEnablement(local, EnablementState.Disabled);
+		didInstallEvent.fire({ local, identifier: local.galleryIdentifier, operation: InstallOperation.Update });
+		const extensions = await testObject.getDisabledExtensions();
+		assert.deepEqual([{ id: 'pub.a' }], extensions);
+	});
+
+	test('test installing an extension fires enablement change event when disabled globally', async () => {
+		const local = aLocalExtension('pub.a');
+		await testObject.setEnablement(local, EnablementState.Disabled);
+		return new Promise((c, e) => {
+			testObject.onEnablementChanged(e => {
+				if (e.id === local.galleryIdentifier.id) {
+					c();
+				}
+			});
+			didInstallEvent.fire({ local, identifier: local.galleryIdentifier, operation: InstallOperation.Install });
+		});
+	});
+
+	test('test updating an extension does not fires enablement change event when disabled globally', async () => {
+		const target = sinon.spy();
+		const local = aLocalExtension('pub.a');
+		await testObject.setEnablement(local, EnablementState.Disabled);
+		testObject.onEnablementChanged(target);
+		didInstallEvent.fire({ local, identifier: local.galleryIdentifier, operation: InstallOperation.Update });
+		assert.ok(!target.called);
+	});
+
+	test('test installing an extension re-eanbles it when workspace disabled', async () => {
+		const local = aLocalExtension('pub.a');
+		await testObject.setEnablement(local, EnablementState.WorkspaceDisabled);
+		didInstallEvent.fire({ local, identifier: local.galleryIdentifier, operation: InstallOperation.Install });
+		const extensions = await testObject.getDisabledExtensions();
+		assert.deepEqual([], extensions);
+	});
+
+	test('test updating an extension does not re-eanbles it when workspace disabled', async () => {
+		const local = aLocalExtension('pub.a');
+		await testObject.setEnablement(local, EnablementState.WorkspaceDisabled);
+		didInstallEvent.fire({ local, identifier: local.galleryIdentifier, operation: InstallOperation.Update });
+		const extensions = await testObject.getDisabledExtensions();
+		assert.deepEqual([{ id: 'pub.a' }], extensions);
+	});
+
+	test('test installing an extension fires enablement change event when workspace disabled', async () => {
+		const local = aLocalExtension('pub.a');
+		await testObject.setEnablement(local, EnablementState.WorkspaceDisabled);
+		return new Promise((c, e) => {
+			testObject.onEnablementChanged(e => {
+				if (e.id === local.galleryIdentifier.id) {
+					c();
+				}
+			});
+			didInstallEvent.fire({ local, identifier: local.galleryIdentifier, operation: InstallOperation.Install });
+		});
+	});
+
+	test('test updating an extension does not fires enablement change event when workspace disabled', async () => {
+		const target = sinon.spy();
+		const local = aLocalExtension('pub.a');
+		await testObject.setEnablement(local, EnablementState.WorkspaceDisabled);
+		testObject.onEnablementChanged(target);
+		didInstallEvent.fire({ local, identifier: local.galleryIdentifier, operation: InstallOperation.Update });
+		assert.ok(!target.called);
+	});
+
+	test('test installing an extension should not fire enablement change event when extension is not disabled', async () => {
+		const target = sinon.spy();
+		const local = aLocalExtension('pub.a');
+		testObject.onEnablementChanged(target);
+		didInstallEvent.fire({ local, identifier: local.galleryIdentifier, operation: InstallOperation.Install });
+		assert.ok(!target.called);
+	});
+
 	test('test remove an extension from disablement list when uninstalled', () => {
 		return testObject.setEnablement(aLocalExtension('pub.a'), EnablementState.WorkspaceDisabled)
 			.then(() => testObject.setEnablement(aLocalExtension('pub.a'), EnablementState.Disabled))
@@ -356,7 +437,7 @@ suite('ExtensionEnablementService Test', () => {
 
 	test('test getDisabledExtensions include extensions disabled in enviroment', () => {
 		instantiationService.stub(IEnvironmentService, { disableExtensions: ['pub.a'] } as IEnvironmentService);
-		instantiationService.stub(IExtensionManagementService, { onDidUninstallExtension: didUninstallEvent.event, getInstalled: () => TPromise.as([aLocalExtension('pub.a'), aLocalExtension('pub.b')]) } as IExtensionManagementService);
+		instantiationService.stub(IExtensionManagementService, { onDidUninstallExtension: didUninstallEvent.event, onDidInstallExtension: didInstallEvent.event, getInstalled: () => Promise.resolve([aLocalExtension('pub.a'), aLocalExtension('pub.b')]) } as IExtensionManagementService);
 		testObject = new TestExtensionEnablementService(instantiationService);
 		return testObject.getDisabledExtensions()
 			.then(actual => {
@@ -364,6 +445,7 @@ suite('ExtensionEnablementService Test', () => {
 				assert.equal(actual[0].id, 'pub.a');
 			});
 	});
+
 });
 
 function aLocalExtension(id: string, contributes?: IExtensionContributions): ILocalExtension {

src/vs/platform/extensionManagement/test/electron-browser/extensionManagement.test.ts

@@ -2,8 +2,6 @@
  *  Copyright (c) Microsoft Corporation. All rights reserved.
  *  Licensed under the Source EULA. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
-'use strict';
-
 import * as assert from 'assert';
 import { EXTENSION_IDENTIFIER_PATTERN } from 'vs/platform/extensionManagement/common/extensionManagement';
 

src/vs/platform/extensionManagement/test/node/extensionGalleryService.test.ts

@@ -3,8 +3,6 @@
  *  Licensed under the Source EULA. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-'use strict';
-
 import * as assert from 'assert';
 import * as os from 'os';
 import * as extfs from 'vs/base/node/extfs';