maxmustermann/vscode
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity

remove TPromise.wrapError

Browse source 
related to #63897
This commit is contained in:
Joao Moreno 2018-12-10 11:27:48 +01:00
parent 2f863c62b3
commit a901902ce6
4 changed files with 124 additions and 117 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

73
src/vs/platform/driver/electron-browser/driver.ts
View file

@ -3,7 +3,6 @@
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
import { TPromise } from 'vs/base/common/winjs.base';
import { IDisposable, toDisposable, combinedDisposable } from 'vs/base/common/lifecycle';
import { IWindowDriver, IElement, WindowDriverChannel, WindowDriverRegistryChannelClient } from 'vs/platform/driver/node/driver';
import { IPCClient } from 'vs/base/parts/ipc/node/ipc';
@ -50,19 +49,19 @@ class WindowDriver implements IWindowDriver {
@IWindowService private windowService: IWindowService
) { }
click(selector: string, xoffset?: number, yoffset?: number): TPromise<void> {
click(selector: string, xoffset?: number, yoffset?: number): Promise<void> {
return this._click(selector, 1, xoffset, yoffset);
}
doubleClick(selector: string): TPromise<void> {
doubleClick(selector: string): Promise<void> {
return this._click(selector, 2);
}
private _getElementXY(selector: string, xoffset?: number, yoffset?: number): TPromise<{ x: number; y: number; }> {
private async _getElementXY(selector: string, xoffset?: number, yoffset?: number): Promise<{ x: number; y: number; }> {
const element = document.querySelector(selector);
if (!element) {
return TPromise.wrapError(new Error(`Element not found: ${selector}`));
return Promise.reject(new Error(`Element not found: ${selector}`));
}
const { left, top } = getTopLeftOffset(element as HTMLElement);
@ -80,27 +79,25 @@ class WindowDriver implements IWindowDriver {
x = Math.round(x);
y = Math.round(y);
return TPromise.as({ x, y });
return { x, y };
}
private _click(selector: string, clickCount: number, xoffset?: number, yoffset?: number): TPromise<void> {
return this._getElementXY(selector, xoffset, yoffset).then(({ x, y }) => {
private async _click(selector: string, clickCount: number, xoffset?: number, yoffset?: number): Promise<void> {
const { x, y } = await this._getElementXY(selector, xoffset, yoffset);
const webContents: electron.WebContents = (electron as any).remote.getCurrentWebContents();
webContents.sendInputEvent({ type: 'mouseDown', x, y, button: 'left', clickCount } as any);
const webContents: electron.WebContents = (electron as any).remote.getCurrentWebContents();
webContents.sendInputEvent({ type: 'mouseDown', x, y, button: 'left', clickCount } as any);
await timeout(10);
return TPromise.wrap(timeout(10)).then(() => {
webContents.sendInputEvent({ type: 'mouseUp', x, y, button: 'left', clickCount } as any);
return TPromise.wrap(timeout(100));
});
});
webContents.sendInputEvent({ type: 'mouseUp', x, y, button: 'left', clickCount } as any);
await timeout(100);
}
setValue(selector: string, text: string): TPromise<void> {
async setValue(selector: string, text: string): Promise<void> {
const element = document.querySelector(selector);
if (!element) {
return TPromise.wrapError(new Error(`Element not found: ${selector}`));
return Promise.reject(new Error(`Element not found: ${selector}`));
}
const inputElement = element as HTMLInputElement;
@ -108,15 +105,13 @@ class WindowDriver implements IWindowDriver {
const event = new Event('input', { bubbles: true, cancelable: true });
inputElement.dispatchEvent(event);
return TPromise.as(null);
}
getTitle(): TPromise<string> {
return TPromise.as(document.title);
async getTitle(): Promise<string> {
return document.title;
}
isActiveElement(selector: string): TPromise<boolean> {
async isActiveElement(selector: string): Promise<boolean> {
const element = document.querySelector(selector);
if (element !== document.activeElement) {
@ -132,13 +127,13 @@ class WindowDriver implements IWindowDriver {
el = el.parentElement;
}
return TPromise.wrapError(new Error(`Active element not found. Current active element is '${chain.join(' > ')}'. Looking for ${selector}`));
throw new Error(`Active element not found. Current active element is '${chain.join(' > ')}'. Looking for ${selector}`);
}
return TPromise.as(true);
return true;
}
getElements(selector: string, recursive: boolean): TPromise<IElement[]> {
async getElements(selector: string, recursive: boolean): Promise<IElement[]> {
const query = document.querySelectorAll(selector);
const result: IElement[] = [];
@ -147,14 +142,14 @@ class WindowDriver implements IWindowDriver {
result.push(serializeElement(element, recursive));
}
return TPromise.as(result);
return result;
}
typeInEditor(selector: string, text: string): TPromise<void> {
async typeInEditor(selector: string, text: string): Promise<void> {
const element = document.querySelector(selector);
if (!element) {
return TPromise.wrapError(new Error(`Editor not found: ${selector}`));
throw new Error(`Editor not found: ${selector}`);
}
const textarea = element as HTMLTextAreaElement;
@ -168,21 +163,19 @@ class WindowDriver implements IWindowDriver {
const event = new Event('input', { 'bubbles': true, 'cancelable': true });
textarea.dispatchEvent(event);
return TPromise.as(null);
}
getTerminalBuffer(selector: string): TPromise<string[]> {
async getTerminalBuffer(selector: string): Promise<string[]> {
const element = document.querySelector(selector);
if (!element) {
return TPromise.wrapError(new Error(`Terminal not found: ${selector}`));
throw new Error(`Terminal not found: ${selector}`);
}
const xterm: Terminal = (element as any).xterm;
if (!xterm) {
return TPromise.wrapError(new Error(`Xterm not found: ${selector}`));
throw new Error(`Xterm not found: ${selector}`);
}
const lines: string[] = [];
@ -191,29 +184,27 @@ class WindowDriver implements IWindowDriver {
lines.push(xterm._core.buffer.translateBufferLineToString(i, true));
}
return TPromise.as(lines);
return lines;
}
writeInTerminal(selector: string, text: string): TPromise<void> {
async writeInTerminal(selector: string, text: string): Promise<void> {
const element = document.querySelector(selector);
if (!element) {
return TPromise.wrapError(new Error(`Element not found: ${selector}`));
throw new Error(`Element not found: ${selector}`);
}
const xterm: Terminal = (element as any).xterm;
if (!xterm) {
return TPromise.wrapError(new Error(`Xterm not found: ${selector}`));
throw new Error(`Xterm not found: ${selector}`);
}
xterm._core.handler(text);
return TPromise.as(null);
}
openDevTools(): TPromise<void> {
return this.windowService.openDevTools({ mode: 'detach' });
async openDevTools(): Promise<void> {
await this.windowService.openDevTools({ mode: 'detach' });
}
}

147
src/vs/platform/driver/node/driver.ts
View file

@ -4,7 +4,6 @@
*--------------------------------------------------------------------------------------------*/
import { connect as connectNet, Client } from 'vs/base/parts/ipc/node/ipc.net';
import { TPromise } from 'vs/base/common/winjs.base';
import { createDecorator } from 'vs/platform/instantiation/common/instantiation';
import { IChannel, IServerChannel } from 'vs/base/parts/ipc/node/ipc';
import { Event } from 'vs/base/common/event';
@ -28,19 +27,19 @@ export interface IElement {
export interface IDriver {
_serviceBrand: any;
getWindowIds(): TPromise<number[]>;
capturePage(windowId: number): TPromise<string>;
reloadWindow(windowId: number): TPromise<void>;
dispatchKeybinding(windowId: number, keybinding: string): TPromise<void>;
click(windowId: number, selector: string, xoffset?: number | undefined, yoffset?: number | undefined): TPromise<void>;
doubleClick(windowId: number, selector: string): TPromise<void>;
setValue(windowId: number, selector: string, text: string): TPromise<void>;
getTitle(windowId: number): TPromise<string>;
isActiveElement(windowId: number, selector: string): TPromise<boolean>;
getElements(windowId: number, selector: string, recursive?: boolean): TPromise<IElement[]>;
typeInEditor(windowId: number, selector: string, text: string): TPromise<void>;
getTerminalBuffer(windowId: number, selector: string): TPromise<string[]>;
writeInTerminal(windowId: number, selector: string, text: string): TPromise<void>;
getWindowIds(): Thenable<number[]>;
capturePage(windowId: number): Thenable<string>;
reloadWindow(windowId: number): Thenable<void>;
dispatchKeybinding(windowId: number, keybinding: string): Thenable<void>;
click(windowId: number, selector: string, xoffset?: number | undefined, yoffset?: number | undefined): Thenable<void>;
doubleClick(windowId: number, selector: string): Thenable<void>;
setValue(windowId: number, selector: string, text: string): Thenable<void>;
getTitle(windowId: number): Thenable<string>;
isActiveElement(windowId: number, selector: string): Thenable<boolean>;
getElements(windowId: number, selector: string, recursive?: boolean): Thenable<IElement[]>;
typeInEditor(windowId: number, selector: string, text: string): Thenable<void>;
getTerminalBuffer(windowId: number, selector: string): Thenable<string[]>;
writeInTerminal(windowId: number, selector: string, text: string): Thenable<void>;
}
//*END
@ -52,7 +51,7 @@ export class DriverChannel implements IServerChannel {
throw new Error('No event found');
}
call(_, command: string, arg?: any): TPromise<any> {
call(_, command: string, arg?: any): Thenable<any> {
switch (command) {
case 'getWindowIds': return this.driver.getWindowIds();
case 'capturePage': return this.driver.capturePage(arg);
@ -79,56 +78,56 @@ export class DriverChannelClient implements IDriver {
constructor(private channel: IChannel) { }
getWindowIds(): TPromise<number[]> {
return TPromise.wrap(this.channel.call('getWindowIds'));
getWindowIds(): Thenable<number[]> {
return this.channel.call('getWindowIds');
}
capturePage(windowId: number): TPromise<string> {
return TPromise.wrap(this.channel.call('capturePage', windowId));
capturePage(windowId: number): Thenable<string> {
return this.channel.call('capturePage', windowId);
}
reloadWindow(windowId: number): TPromise<void> {
return TPromise.wrap(this.channel.call('reloadWindow', windowId));
reloadWindow(windowId: number): Thenable<void> {
return this.channel.call('reloadWindow', windowId);
}
dispatchKeybinding(windowId: number, keybinding: string): TPromise<void> {
return TPromise.wrap(this.channel.call('dispatchKeybinding', [windowId, keybinding]));
dispatchKeybinding(windowId: number, keybinding: string): Thenable<void> {
return this.channel.call('dispatchKeybinding', [windowId, keybinding]);
}
click(windowId: number, selector: string, xoffset: number | undefined, yoffset: number | undefined): TPromise<void> {
return TPromise.wrap(this.channel.call('click', [windowId, selector, xoffset, yoffset]));
click(windowId: number, selector: string, xoffset: number | undefined, yoffset: number | undefined): Thenable<void> {
return this.channel.call('click', [windowId, selector, xoffset, yoffset]);
}
doubleClick(windowId: number, selector: string): TPromise<void> {
return TPromise.wrap(this.channel.call('doubleClick', [windowId, selector]));
doubleClick(windowId: number, selector: string): Thenable<void> {
return this.channel.call('doubleClick', [windowId, selector]);
}
setValue(windowId: number, selector: string, text: string): TPromise<void> {
return TPromise.wrap(this.channel.call('setValue', [windowId, selector, text]));
setValue(windowId: number, selector: string, text: string): Thenable<void> {
return this.channel.call('setValue', [windowId, selector, text]);
}
getTitle(windowId: number): TPromise<string> {
return TPromise.wrap(this.channel.call('getTitle', [windowId]));
getTitle(windowId: number): Thenable<string> {
return this.channel.call('getTitle', [windowId]);
}
isActiveElement(windowId: number, selector: string): TPromise<boolean> {
return TPromise.wrap(this.channel.call('isActiveElement', [windowId, selector]));
isActiveElement(windowId: number, selector: string): Thenable<boolean> {
return this.channel.call('isActiveElement', [windowId, selector]);
}
getElements(windowId: number, selector: string, recursive: boolean): TPromise<IElement[]> {
return TPromise.wrap(this.channel.call('getElements', [windowId, selector, recursive]));
getElements(windowId: number, selector: string, recursive: boolean): Thenable<IElement[]> {
return this.channel.call('getElements', [windowId, selector, recursive]);
}
typeInEditor(windowId: number, selector: string, text: string): TPromise<void> {
return TPromise.wrap(this.channel.call('typeInEditor', [windowId, selector, text]));
typeInEditor(windowId: number, selector: string, text: string): Thenable<void> {
return this.channel.call('typeInEditor', [windowId, selector, text]);
}
getTerminalBuffer(windowId: number, selector: string): TPromise<string[]> {
return TPromise.wrap(this.channel.call('getTerminalBuffer', [windowId, selector]));
getTerminalBuffer(windowId: number, selector: string): Thenable<string[]> {
return this.channel.call('getTerminalBuffer', [windowId, selector]);
}
writeInTerminal(windowId: number, selector: string, text: string): TPromise<void> {
return TPromise.wrap(this.channel.call('writeInTerminal', [windowId, selector, text]));
writeInTerminal(windowId: number, selector: string, text: string): Thenable<void> {
return this.channel.call('writeInTerminal', [windowId, selector, text]);
}
}
@ -137,8 +136,8 @@ export interface IDriverOptions {
}
export interface IWindowDriverRegistry {
registerWindowDriver(windowId: number): TPromise<IDriverOptions>;
reloadWindowDriver(windowId: number): TPromise<void>;
registerWindowDriver(windowId: number): Thenable<IDriverOptions>;
reloadWindowDriver(windowId: number): Thenable<void>;
}
export class WindowDriverRegistryChannel implements IServerChannel {
@ -165,25 +164,25 @@ export class WindowDriverRegistryChannelClient implements IWindowDriverRegistry
constructor(private channel: IChannel) { }
registerWindowDriver(windowId: number): TPromise<IDriverOptions> {
return TPromise.wrap(this.channel.call('registerWindowDriver', windowId));
registerWindowDriver(windowId: number): Thenable<IDriverOptions> {
return this.channel.call('registerWindowDriver', windowId);
}
reloadWindowDriver(windowId: number): TPromise<void> {
return TPromise.wrap(this.channel.call('reloadWindowDriver', windowId));
reloadWindowDriver(windowId: number): Thenable<void> {
return this.channel.call('reloadWindowDriver', windowId);
}
}
export interface IWindowDriver {
click(selector: string, xoffset?: number | undefined, yoffset?: number | undefined): TPromise<void>;
doubleClick(selector: string): TPromise<void>;
setValue(selector: string, text: string): TPromise<void>;
getTitle(): TPromise<string>;
isActiveElement(selector: string): TPromise<boolean>;
getElements(selector: string, recursive: boolean): TPromise<IElement[]>;
typeInEditor(selector: string, text: string): TPromise<void>;
getTerminalBuffer(selector: string): TPromise<string[]>;
writeInTerminal(selector: string, text: string): TPromise<void>;
click(selector: string, xoffset?: number | undefined, yoffset?: number | undefined): Thenable<void>;
doubleClick(selector: string): Thenable<void>;
setValue(selector: string, text: string): Thenable<void>;
getTitle(): Thenable<string>;
isActiveElement(selector: string): Thenable<boolean>;
getElements(selector: string, recursive: boolean): Thenable<IElement[]>;
typeInEditor(selector: string, text: string): Thenable<void>;
getTerminalBuffer(selector: string): Thenable<string[]>;
writeInTerminal(selector: string, text: string): Thenable<void>;
}
export class WindowDriverChannel implements IServerChannel {
@ -217,40 +216,40 @@ export class WindowDriverChannelClient implements IWindowDriver {
constructor(private channel: IChannel) { }
click(selector: string, xoffset?: number, yoffset?: number): TPromise<void> {
return TPromise.wrap(this.channel.call('click', [selector, xoffset, yoffset]));
click(selector: string, xoffset?: number, yoffset?: number): Thenable<void> {
return this.channel.call('click', [selector, xoffset, yoffset]);
}
doubleClick(selector: string): TPromise<void> {
return TPromise.wrap(this.channel.call('doubleClick', selector));
doubleClick(selector: string): Thenable<void> {
return this.channel.call('doubleClick', selector);
}
setValue(selector: string, text: string): TPromise<void> {
return TPromise.wrap(this.channel.call('setValue', [selector, text]));
setValue(selector: string, text: string): Thenable<void> {
return this.channel.call('setValue', [selector, text]);
}
getTitle(): TPromise<string> {
return TPromise.wrap(this.channel.call('getTitle'));
getTitle(): Thenable<string> {
return this.channel.call('getTitle');
}
isActiveElement(selector: string): TPromise<boolean> {
return TPromise.wrap(this.channel.call('isActiveElement', selector));
isActiveElement(selector: string): Thenable<boolean> {
return this.channel.call('isActiveElement', selector);
}
getElements(selector: string, recursive: boolean): TPromise<IElement[]> {
return TPromise.wrap(this.channel.call('getElements', [selector, recursive]));
getElements(selector: string, recursive: boolean): Thenable<IElement[]> {
return this.channel.call('getElements', [selector, recursive]);
}
typeInEditor(selector: string, text: string): TPromise<void> {
return TPromise.wrap(this.channel.call('typeInEditor', [selector, text]));
typeInEditor(selector: string, text: string): Thenable<void> {
return this.channel.call('typeInEditor', [selector, text]);
}
getTerminalBuffer(selector: string): TPromise<string[]> {
return TPromise.wrap(this.channel.call('getTerminalBuffer', selector));
getTerminalBuffer(selector: string): Thenable<string[]> {
return this.channel.call('getTerminalBuffer', selector);
}
writeInTerminal(selector: string, text: string): TPromise<void> {
return TPromise.wrap(this.channel.call('writeInTerminal', [selector, text]));
writeInTerminal(selector: string, text: string): Thenable<void> {
return this.channel.call('writeInTerminal', [selector, text]);
}
}

4
test/smoke/src/vscode/code.ts
View file

@ -7,7 +7,7 @@ import * as path from 'path';
import * as cp from 'child_process';
import * as os from 'os';
import { tmpName } from 'tmp';
import { IDriver, connect as connectDriver, IDisposable, IElement } from './driver';
import { IDriver, connect as connectDriver, IDisposable, IElement, Thenable } from './driver';
import { Logger } from '../logger';
const repoPath = path.join(__dirname, '../../../..');
@ -147,7 +147,7 @@ export async function spawn(options: SpawnOptions): Promise<Code> {
}
async function poll<T>(
fn: () => Promise<T>,
fn: () => Thenable<T>,
acceptFn: (result: T) => boolean,
timeoutMessage: string,
retryCount: number = 200,

17
test/smoke/tools/copy-driver-definition.js
View file

@ -18,6 +18,23 @@ contents = `/*------------------------------------------------------------------
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
/**
* Thenable is a common denominator between ES6 promises, Q, jquery.Deferred, WinJS.Promise,
* and others. This API makes no assumption about what promise library is being used which
* enables reusing existing code without migrating to a specific promise implementation. Still,
* we recommend the use of native promises which are available in this editor.
*/
interface Thenable<T> {
/**
* Attaches callbacks for the resolution and/or rejection of the Promise.
* @param onfulfilled The callback to execute when the Promise is resolved.
* @param onrejected The callback to execute when the Promise is rejected.
* @returns A Promise for the completion of which ever callback is executed.
*/
then<TResult>(onfulfilled?: (value: T) => TResult | Thenable<TResult>, onrejected?: (reason: any) => TResult | Thenable<TResult>): Thenable<TResult>;
then<TResult>(onfulfilled?: (value: T) => TResult | Thenable<TResult>, onrejected?: (reason: any) => void): Thenable<TResult>;
}
${contents}
export interface IDisposable {