green extensions tests

src/vs/platform/driver/common/driver.ts

@@ -131,10 +131,12 @@ export class DriverChannelClient implements IDriver {
 
 export interface IWindowDriverRegistry {
 	registerWindowDriver(windowId: number): TPromise<void>;
+	reloadWindowDriver(windowId: number): TPromise<void>;
 }
 
 export interface IWindowDriverRegistryChannel extends IChannel {
 	call(command: 'registerWindowDriver', arg: number): TPromise<void>;
+	call(command: 'reloadWindowDriver', arg: number): TPromise<void>;
 	call(command: string, arg: any): TPromise<any>;
 }
 
@@ -145,6 +147,7 @@ export class WindowDriverRegistryChannel implements IWindowDriverRegistryChannel
 	call(command: string, arg?: any): TPromise<any> {
 		switch (command) {
 			case 'registerWindowDriver': return this.registry.registerWindowDriver(arg);
+			case 'reloadWindowDriver': return this.registry.reloadWindowDriver(arg);
 		}
 
 		return undefined;
@@ -160,6 +163,10 @@ export class WindowDriverRegistryChannelClient implements IWindowDriverRegistry
 	registerWindowDriver(windowId: number): TPromise<void> {
 		return this.channel.call('registerWindowDriver', windowId);
 	}
+
+	reloadWindowDriver(windowId: number): TPromise<void> {
+		return this.channel.call('reloadWindowDriver', windowId);
+	}
 }
 
 export interface IWindowDriver {

src/vs/platform/driver/electron-browser/driver.ts

@@ -6,7 +6,7 @@
 'use strict';
 
 import { TPromise } from 'vs/base/common/winjs.base';
-import { IDisposable } from 'vs/base/common/lifecycle';
+import { IDisposable, toDisposable, combinedDisposable } from 'vs/base/common/lifecycle';
 import { IWindowDriver, IElement, WindowDriverChannel, WindowDriverRegistryChannelClient } from 'vs/platform/driver/common/driver';
 import { IPCClient } from 'vs/base/parts/ipc/common/ipc';
 import { IInstantiationService } from 'vs/platform/instantiation/common/instantiation';
@@ -180,5 +180,6 @@ export async function registerWindowDriver(
 
 	await windowDriverRegistry.registerWindowDriver(windowId);
 
-	return client;
+	const disposable = toDisposable(() => windowDriverRegistry.reloadWindowDriver(windowId));
+	return combinedDisposable([disposable, client]);
 }
\ No newline at end of file

src/vs/platform/driver/electron-main/driver.ts

@@ -15,6 +15,7 @@ import { IPCServer, IClientRouter } from 'vs/base/parts/ipc/common/ipc';
 import { SimpleKeybinding, KeyCode } from 'vs/base/common/keyCodes';
 import { USLayoutResolvedKeybinding } from 'vs/platform/keybinding/common/usLayoutResolvedKeybinding';
 import { OS } from 'vs/base/common/platform';
+import { Emitter, toPromise } from 'vs/base/common/event';
 
 // TODO@joao: bad layering!
 import { KeybindingIO } from 'vs/workbench/services/keybinding/common/keybindingIO';
@@ -38,24 +39,33 @@ export class Driver implements IDriver, IWindowDriverRegistry {
 	_serviceBrand: any;
 
 	private registeredWindowIds = new Set<number>();
+	private reloadingWindowIds = new Set<number>();
+	private onDidReloadingChange = new Emitter<void>();
 
 	constructor(
 		private windowServer: IPCServer,
 		@IWindowsMainService private windowsService: IWindowsMainService
 	) { }
 
-	registerWindowDriver(windowId: number): TPromise<void> {
+	async registerWindowDriver(windowId: number): TPromise<void> {
 		this.registeredWindowIds.add(windowId);
-		return TPromise.as(null);
+		this.reloadingWindowIds.delete(windowId);
+		this.onDidReloadingChange.fire();
+	}
+
+	async reloadWindowDriver(windowId: number): TPromise<void> {
+		this.reloadingWindowIds.add(windowId);
 	}
 
 	async getWindowIds(): TPromise<number[]> {
 		return this.windowsService.getWindows()
 			.map(w => w.id)
-			.filter(id => this.registeredWindowIds.has(id));
+			.filter(id => this.registeredWindowIds.has(id) && !this.reloadingWindowIds.has(id));
 	}
 
 	async dispatchKeybinding(windowId: number, keybinding: string): TPromise<void> {
+		await this.whenUnfrozen(windowId);
+
 		const [first, second] = KeybindingIO._readUserBinding(keybinding);
 
 		await this._dispatchKeybinding(windowId, first);
@@ -105,56 +115,64 @@ export class Driver implements IDriver, IWindowDriverRegistry {
 		await TPromise.timeout(100);
 	}
 
-	click(windowId: number, selector: string, xoffset?: number, yoffset?: number): TPromise<void> {
-		const windowDriver = this.getWindowDriver(windowId);
+	async click(windowId: number, selector: string, xoffset?: number, yoffset?: number): TPromise<void> {
+		const windowDriver = await this.getWindowDriver(windowId);
 		return windowDriver.click(selector, xoffset, yoffset);
 	}
 
-	doubleClick(windowId: number, selector: string): TPromise<void> {
-		const windowDriver = this.getWindowDriver(windowId);
+	async doubleClick(windowId: number, selector: string): TPromise<void> {
+		const windowDriver = await this.getWindowDriver(windowId);
 		return windowDriver.doubleClick(selector);
 	}
 
-	move(windowId: number, selector: string): TPromise<void> {
-		const windowDriver = this.getWindowDriver(windowId);
+	async move(windowId: number, selector: string): TPromise<void> {
+		const windowDriver = await this.getWindowDriver(windowId);
 		return windowDriver.move(selector);
 	}
 
-	setValue(windowId: number, selector: string, text: string): TPromise<void> {
-		const windowDriver = this.getWindowDriver(windowId);
+	async setValue(windowId: number, selector: string, text: string): TPromise<void> {
+		const windowDriver = await this.getWindowDriver(windowId);
 		return windowDriver.setValue(selector, text);
 	}
 
-	getTitle(windowId: number): TPromise<string> {
-		const windowDriver = this.getWindowDriver(windowId);
+	async getTitle(windowId: number): TPromise<string> {
+		const windowDriver = await this.getWindowDriver(windowId);
 		return windowDriver.getTitle();
 	}
 
-	isActiveElement(windowId: number, selector: string): TPromise<boolean> {
-		const windowDriver = this.getWindowDriver(windowId);
+	async isActiveElement(windowId: number, selector: string): TPromise<boolean> {
+		const windowDriver = await this.getWindowDriver(windowId);
 		return windowDriver.isActiveElement(selector);
 	}
 
-	getElements(windowId: number, selector: string, recursive: boolean): TPromise<IElement[]> {
-		const windowDriver = this.getWindowDriver(windowId);
+	async getElements(windowId: number, selector: string, recursive: boolean): TPromise<IElement[]> {
+		const windowDriver = await this.getWindowDriver(windowId);
 		return windowDriver.getElements(selector, recursive);
 	}
 
-	typeInEditor(windowId: number, selector: string, text: string): TPromise<void> {
-		const windowDriver = this.getWindowDriver(windowId);
+	async typeInEditor(windowId: number, selector: string, text: string): TPromise<void> {
+		const windowDriver = await this.getWindowDriver(windowId);
 		return windowDriver.typeInEditor(selector, text);
 	}
 
-	getTerminalBuffer(windowId: number, selector: string): TPromise<string[]> {
-		const windowDriver = this.getWindowDriver(windowId);
+	async getTerminalBuffer(windowId: number, selector: string): TPromise<string[]> {
+		const windowDriver = await this.getWindowDriver(windowId);
 		return windowDriver.getTerminalBuffer(selector);
 	}
 
-	private getWindowDriver(windowId: number): IWindowDriver {
+	private async getWindowDriver(windowId: number): TPromise<IWindowDriver> {
+		await this.whenUnfrozen(windowId);
+
 		const router = new WindowRouter(windowId);
 		const windowDriverChannel = this.windowServer.getChannel<IWindowDriverChannel>('windowDriver', router);
 		return new WindowDriverChannelClient(windowDriverChannel);
 	}
+
+	private async whenUnfrozen(windowId: number): TPromise<void> {
+		while (this.reloadingWindowIds.has(windowId)) {
+			await toPromise(this.onDidReloadingChange.event);
+		}
+	}
 }
 
 export async function serve(

test/smoke/src/application.ts

@@ -120,8 +120,10 @@ export class SpectronApplication {
 	}
 
 	async reload(): Promise<any> {
-		await this.workbench.runCommand('Reload Window');
-		// TODO @sandy: Find a proper condition to wait for reload
+		this.workbench.runCommand('Reload Window')
+			.catch(err => null); // ignore the connection drop errors
+
+		// needs to be enough to propagate the 'Reload Window' command
 		await new Promise(c => setTimeout(c, 1500));
 		await this.checkWindowReady();
 	}
@@ -278,7 +280,7 @@ export class SpectronApplication {
 
 		let retries = 0;
 
-		while (++retries < 50) {
+		while (++retries < 300) { // 30 seconds
 			const ids = await this.codeInstance.driver.getWindowIds();
 
 			if (ids.length > 0) {

test/smoke/src/areas/extensions/extensions.ts

@@ -30,14 +30,10 @@ export class Extensions extends Viewlet {
 		await this.api.setValue(SEARCH_BOX, name);
 	}
 
-	async installExtension(name: string): Promise<boolean> {
+	async installExtension(name: string): Promise<void> {
 		await this.searchForExtension(name);
 
-		// we might want to wait for a while longer since the Marketplace can be slow
-		// a minute should do
-		await this.api.waitFor(() => this.api.waitAndClick(`div.extensions-viewlet[id="workbench.view.extensions"] .monaco-list-row[aria-label="${name}"] .extension li[class='action-item'] .extension-action.install`), void 0, 'waiting for install button', 600);
-
+		await this.api.waitAndClick(`div.extensions-viewlet[id="workbench.view.extensions"] .monaco-list-row[aria-label="${name}"] .extension li[class='action-item'] .extension-action.install`);
 		await this.api.waitForElement(`div.extensions-viewlet[id="workbench.view.extensions"] .monaco-list-row[aria-label="${name}"] .extension li[class='action-item'] .extension-action.reload`);
-		return true;
 	}
 }
\ No newline at end of file