-
Notifications
You must be signed in to change notification settings - Fork 177
/
steps.ts
188 lines (158 loc) · 5.72 KB
/
steps.ts
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
/**
* @license
* Copyright (c) 2014 The Polymer Project Authors. All rights reserved.
* This code may only be used under the BSD style license found at
* http://polymer.github.io/LICENSE.txt
* The complete set of authors may be found at
* http://polymer.github.io/AUTHORS.txt
* The complete set of contributors may be found at
* http://polymer.github.io/CONTRIBUTORS.txt
* Code distributed by Google as part of the polymer project is also
* subject to an additional IP rights grant found at
* http://polymer.github.io/PATENTS.txt
*/
import * as http from 'http';
import * as _ from 'lodash';
import * as socketIO from 'socket.io';
import {BrowserRunner} from './browserrunner';
import * as config from './config';
import {Context} from './context';
import {Plugin} from './plugin';
import {webserver} from './webserver';
interface ClientMessage<T> {
browserId: number;
event: string;
data: T;
}
// Steps (& Hooks)
export async function setupOverrides(context: Context): Promise<void> {
if (context.options.registerHooks) {
context.options.registerHooks(context);
}
}
export async function loadPlugins(context: Context): Promise<Plugin[]> {
context.emit('log:debug', 'step: loadPlugins');
const plugins = await context.plugins();
// built in quasi-plugin.
webserver(context);
// Actual plugins.
await Promise.all(plugins.map((plugin) => plugin.execute(context)));
return plugins;
}
export async function configure(context: Context): Promise<void> {
context.emit('log:debug', 'step: configure');
const options = context.options;
await config.expand(context);
// Note that we trigger the configure hook _after_ filling in the `options`
// object.
//
// If you want to modify options prior to this; do it during plugin init.
await context.emitHook('configure');
// Even if the options don't validate; useful debugging info.
const cleanOptions = _.omit(options, 'output');
context.emit('log:debug', 'configuration:', cleanOptions);
await config.validate(options);
}
/**
* The prepare step is where a lot of the runner's initialization occurs. This
* is also typically where a plugin will want to spin up any long-running
* process it requires.
*
* Note that some "plugins" are also built directly into WCT (webserver).
*/
export async function prepare(context: Context): Promise<void> {
await context.emitHook('prepare');
}
export async function runTests(context: Context): Promise<void> {
context.emit('log:debug', 'step: runTests');
const result = runBrowsers(context);
const runners = result.runners;
context._testRunners = runners;
context._socketIOServers = context._httpServers.map((httpServer) => {
const socketIOServer = socketIO(httpServer);
socketIOServer.on('connection', function(socket) {
context.emit('log:debug', 'Test client opened sideband socket');
socket.on('client-event', function(data: ClientMessage<any>) {
const runner = runners[data.browserId];
if (!runner) {
throw new Error(
`Unable to find browser runner for ` +
`browser with id: ${data.browserId}`);
}
runner.onEvent(data.event, data.data);
});
});
return socketIOServer;
});
await result.completionPromise;
}
export function cancelTests(context: Context): void {
if (!context._testRunners) {
return;
}
context._testRunners.forEach(function(tr) {
tr.quit();
});
}
// Helpers
function runBrowsers(context: Context) {
const options = context.options;
const numActiveBrowsers = options.activeBrowsers.length;
if (numActiveBrowsers === 0) {
throw new Error('No browsers configured to run');
}
// TODO(nevir): validate browser definitions.
// Up the socket limit so that we can maintain more active requests.
// TODO(nevir): We should be queueing the browsers above some limit too.
http.globalAgent.maxSockets =
Math.max(http.globalAgent.maxSockets, numActiveBrowsers * 2);
context.emit('run-start', options);
const errors: any[] = [];
const promises: Promise<void>[] = [];
const runners: BrowserRunner[] = [];
let id = 0;
for (const originalBrowserDef of options.activeBrowsers) {
let waitFor: undefined|Promise<void> = undefined;
for (const server of options.webserver._servers) {
// Needed by both `BrowserRunner` and `CliReporter`.
const browserDef = _.clone(originalBrowserDef);
browserDef.id = id++;
browserDef.variant = server.variant;
_.defaultsDeep(browserDef, options.browserOptions);
const runner =
new BrowserRunner(context, browserDef, options, server.url, waitFor);
promises.push(runner.donePromise.then(
() => {
context.emit('log:debug', browserDef, 'BrowserRunner complete');
},
(error) => {
context.emit('log:debug', browserDef, 'BrowserRunner complete');
errors.push(error);
}));
runners.push(runner);
if (browserDef.browserName === 'safari') {
// Control to Safari must be serialized. We can't launch two instances
// simultaneously, because security lol.
// https://webkit.org/blog/6900/webdriver-support-in-safari-10/
waitFor = runner.donePromise.catch(() => {
// The next runner doesn't care about errors, just wants to know when
// it can start.
return undefined;
});
}
}
}
return {
runners,
completionPromise: (async function() {
await Promise.all(promises);
const error = errors.length > 0 ? _.union(errors).join(', ') : null;
context.emit('run-end', error);
// TODO(nevir): Better rationalize run-end and hook.
await context.emitHook('cleanup');
if (error) {
throw new Error(error);
}
}())
};
}