|
1
|
"use strict"; |
|
2
|
var __create = Object.create; |
|
3
|
var __defProp = Object.defineProperty; |
|
4
|
var __getOwnPropDesc = Object.getOwnPropertyDescriptor; |
|
5
|
var __getOwnPropNames = Object.getOwnPropertyNames; |
|
6
|
var __getProtoOf = Object.getPrototypeOf; |
|
7
|
var __hasOwnProp = Object.prototype.hasOwnProperty; |
|
8
|
var __export = (target, all) => { |
|
9
|
for (var name in all) |
|
10
|
__defProp(target, name, { get: all[name], enumerable: true }); |
|
11
|
}; |
|
12
|
var __copyProps = (to, from, except, desc) => { |
|
13
|
if (from && typeof from === "object" || typeof from === "function") { |
|
14
|
for (let key of __getOwnPropNames(from)) |
|
15
|
if (!__hasOwnProp.call(to, key) && key !== except) |
|
16
|
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable }); |
|
17
|
} |
|
18
|
return to; |
|
19
|
}; |
|
20
|
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps( |
|
21
|
// If the importer is in node compatibility mode or this is not an ESM |
|
22
|
// file that has been converted to a CommonJS file using a Babel- |
|
23
|
// compatible transform (i.e. "__esModule" has not been set), then set |
|
24
|
// "default" to the CommonJS "module.exports" for node compatibility. |
|
25
|
isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, |
|
26
|
mod |
|
27
|
)); |
|
28
|
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod); |
|
29
|
var tasks_exports = {}; |
|
30
|
__export(tasks_exports, { |
|
31
|
TestRun: () => TestRun, |
|
32
|
createApplyRebaselinesTask: () => createApplyRebaselinesTask, |
|
33
|
createClearCacheTask: () => createClearCacheTask, |
|
34
|
createGlobalSetupTasks: () => createGlobalSetupTasks, |
|
35
|
createListFilesTask: () => createListFilesTask, |
|
36
|
createLoadTask: () => createLoadTask, |
|
37
|
createPluginSetupTasks: () => createPluginSetupTasks, |
|
38
|
createReportBeginTask: () => createReportBeginTask, |
|
39
|
createRunTestsTasks: () => createRunTestsTasks, |
|
40
|
createStartDevServerTask: () => createStartDevServerTask, |
|
41
|
runTasks: () => runTasks, |
|
42
|
runTasksDeferCleanup: () => runTasksDeferCleanup |
|
43
|
}); |
|
44
|
module.exports = __toCommonJS(tasks_exports); |
|
45
|
var import_fs = __toESM(require("fs")); |
|
46
|
var import_path = __toESM(require("path")); |
|
47
|
var import_util = require("util"); |
|
48
|
var import_utils = require("playwright-core/lib/utils"); |
|
49
|
var import_utilsBundle = require("playwright-core/lib/utilsBundle"); |
|
50
|
var import_dispatcher = require("./dispatcher"); |
|
51
|
var import_failureTracker = require("./failureTracker"); |
|
52
|
var import_loadUtils = require("./loadUtils"); |
|
53
|
var import_projectUtils = require("./projectUtils"); |
|
54
|
var import_rebase = require("./rebase"); |
|
55
|
var import_taskRunner = require("./taskRunner"); |
|
56
|
var import_vcs = require("./vcs"); |
|
57
|
var import_test = require("../common/test"); |
|
58
|
var import_testGroups = require("../runner/testGroups"); |
|
59
|
var import_compilationCache = require("../transform/compilationCache"); |
|
60
|
var import_util2 = require("../util"); |
|
61
|
const readDirAsync = (0, import_util.promisify)(import_fs.default.readdir); |
|
62
|
class TestRun { |
|
63
|
constructor(config, reporter, options) { |
|
64
|
this.rootSuite = void 0; |
|
65
|
this.phases = []; |
|
66
|
this.projectFiles = /* @__PURE__ */ new Map(); |
|
67
|
this.projectSuites = /* @__PURE__ */ new Map(); |
|
68
|
this.topLevelProjects = []; |
|
69
|
this.config = config; |
|
70
|
this.reporter = reporter; |
|
71
|
this.failureTracker = new import_failureTracker.FailureTracker(config, options); |
|
72
|
} |
|
73
|
} |
|
74
|
async function runTasks(testRun, tasks, globalTimeout, cancelPromise) { |
|
75
|
const deadline = globalTimeout ? (0, import_utils.monotonicTime)() + globalTimeout : 0; |
|
76
|
const taskRunner = new import_taskRunner.TaskRunner(testRun.reporter, globalTimeout || 0); |
|
77
|
for (const task of tasks) |
|
78
|
taskRunner.addTask(task); |
|
79
|
testRun.reporter.onConfigure(testRun.config.config); |
|
80
|
const status = await taskRunner.run(testRun, deadline, cancelPromise); |
|
81
|
return await finishTaskRun(testRun, status); |
|
82
|
} |
|
83
|
async function runTasksDeferCleanup(testRun, tasks) { |
|
84
|
const taskRunner = new import_taskRunner.TaskRunner(testRun.reporter, 0); |
|
85
|
for (const task of tasks) |
|
86
|
taskRunner.addTask(task); |
|
87
|
testRun.reporter.onConfigure(testRun.config.config); |
|
88
|
const { status, cleanup } = await taskRunner.runDeferCleanup(testRun, 0); |
|
89
|
return { status: await finishTaskRun(testRun, status), cleanup }; |
|
90
|
} |
|
91
|
async function finishTaskRun(testRun, status) { |
|
92
|
if (status === "passed") |
|
93
|
status = testRun.failureTracker.result(); |
|
94
|
const modifiedResult = await testRun.reporter.onEnd({ status }); |
|
95
|
if (modifiedResult && modifiedResult.status) |
|
96
|
status = modifiedResult.status; |
|
97
|
await testRun.reporter.onExit(); |
|
98
|
return status; |
|
99
|
} |
|
100
|
function createGlobalSetupTasks(config) { |
|
101
|
const tasks = []; |
|
102
|
if (!config.configCLIOverrides.preserveOutputDir) |
|
103
|
tasks.push(createRemoveOutputDirsTask()); |
|
104
|
tasks.push( |
|
105
|
...createPluginSetupTasks(config), |
|
106
|
...config.globalTeardowns.map((file) => createGlobalTeardownTask(file, config)).reverse(), |
|
107
|
...config.globalSetups.map((file) => createGlobalSetupTask(file, config)) |
|
108
|
); |
|
109
|
return tasks; |
|
110
|
} |
|
111
|
function createRunTestsTasks(config) { |
|
112
|
return [ |
|
113
|
createPhasesTask(), |
|
114
|
createReportBeginTask(), |
|
115
|
...config.plugins.map((plugin) => createPluginBeginTask(plugin)), |
|
116
|
createRunTestsTask() |
|
117
|
]; |
|
118
|
} |
|
119
|
function createClearCacheTask(config) { |
|
120
|
return { |
|
121
|
title: "clear cache", |
|
122
|
setup: async () => { |
|
123
|
await (0, import_util2.removeDirAndLogToConsole)(import_compilationCache.cacheDir); |
|
124
|
for (const plugin of config.plugins) |
|
125
|
await plugin.instance?.clearCache?.(); |
|
126
|
} |
|
127
|
}; |
|
128
|
} |
|
129
|
function createReportBeginTask() { |
|
130
|
return { |
|
131
|
title: "report begin", |
|
132
|
setup: async (testRun) => { |
|
133
|
testRun.reporter.onBegin?.(testRun.rootSuite); |
|
134
|
}, |
|
135
|
teardown: async ({}) => { |
|
136
|
} |
|
137
|
}; |
|
138
|
} |
|
139
|
function createPluginSetupTasks(config) { |
|
140
|
return config.plugins.map((plugin) => ({ |
|
141
|
title: "plugin setup", |
|
142
|
setup: async ({ reporter }) => { |
|
143
|
if (typeof plugin.factory === "function") |
|
144
|
plugin.instance = await plugin.factory(); |
|
145
|
else |
|
146
|
plugin.instance = plugin.factory; |
|
147
|
await plugin.instance?.setup?.(config.config, config.configDir, reporter); |
|
148
|
}, |
|
149
|
teardown: async () => { |
|
150
|
await plugin.instance?.teardown?.(); |
|
151
|
} |
|
152
|
})); |
|
153
|
} |
|
154
|
function createPluginBeginTask(plugin) { |
|
155
|
return { |
|
156
|
title: "plugin begin", |
|
157
|
setup: async (testRun) => { |
|
158
|
await plugin.instance?.begin?.(testRun.rootSuite); |
|
159
|
}, |
|
160
|
teardown: async () => { |
|
161
|
await plugin.instance?.end?.(); |
|
162
|
} |
|
163
|
}; |
|
164
|
} |
|
165
|
function createGlobalSetupTask(file, config) { |
|
166
|
let title = "global setup"; |
|
167
|
if (config.globalSetups.length > 1) |
|
168
|
title += ` (${file})`; |
|
169
|
let globalSetupResult; |
|
170
|
return { |
|
171
|
title, |
|
172
|
setup: async ({ config: config2 }) => { |
|
173
|
const setupHook = await (0, import_loadUtils.loadGlobalHook)(config2, file); |
|
174
|
globalSetupResult = await setupHook(config2.config); |
|
175
|
}, |
|
176
|
teardown: async () => { |
|
177
|
if (typeof globalSetupResult === "function") |
|
178
|
await globalSetupResult(); |
|
179
|
} |
|
180
|
}; |
|
181
|
} |
|
182
|
function createGlobalTeardownTask(file, config) { |
|
183
|
let title = "global teardown"; |
|
184
|
if (config.globalTeardowns.length > 1) |
|
185
|
title += ` (${file})`; |
|
186
|
return { |
|
187
|
title, |
|
188
|
teardown: async ({ config: config2 }) => { |
|
189
|
const teardownHook = await (0, import_loadUtils.loadGlobalHook)(config2, file); |
|
190
|
await teardownHook(config2.config); |
|
191
|
} |
|
192
|
}; |
|
193
|
} |
|
194
|
function createRemoveOutputDirsTask() { |
|
195
|
return { |
|
196
|
title: "clear output", |
|
197
|
setup: async ({ config }) => { |
|
198
|
const outputDirs = /* @__PURE__ */ new Set(); |
|
199
|
const projects = (0, import_projectUtils.filterProjects)(config.projects, config.cliProjectFilter); |
|
200
|
projects.forEach((p) => outputDirs.add(p.project.outputDir)); |
|
201
|
await Promise.all(Array.from(outputDirs).map((outputDir) => (0, import_utils.removeFolders)([outputDir]).then(async ([error]) => { |
|
202
|
if (!error) |
|
203
|
return; |
|
204
|
if (error.code === "EBUSY") { |
|
205
|
const entries = await readDirAsync(outputDir).catch((e) => []); |
|
206
|
await Promise.all(entries.map((entry) => (0, import_utils.removeFolders)([import_path.default.join(outputDir, entry)]))); |
|
207
|
} else { |
|
208
|
throw error; |
|
209
|
} |
|
210
|
}))); |
|
211
|
} |
|
212
|
}; |
|
213
|
} |
|
214
|
function createListFilesTask() { |
|
215
|
return { |
|
216
|
title: "load tests", |
|
217
|
setup: async (testRun, errors) => { |
|
218
|
const { rootSuite, topLevelProjects } = await (0, import_loadUtils.createRootSuite)(testRun, errors, false); |
|
219
|
testRun.rootSuite = rootSuite; |
|
220
|
testRun.failureTracker.onRootSuite(rootSuite, topLevelProjects); |
|
221
|
await (0, import_loadUtils.collectProjectsAndTestFiles)(testRun, false); |
|
222
|
for (const [project, files] of testRun.projectFiles) { |
|
223
|
const projectSuite = new import_test.Suite(project.project.name, "project"); |
|
224
|
projectSuite._fullProject = project; |
|
225
|
testRun.rootSuite._addSuite(projectSuite); |
|
226
|
const suites = files.map((file) => { |
|
227
|
const title = import_path.default.relative(testRun.config.config.rootDir, file); |
|
228
|
const suite = new import_test.Suite(title, "file"); |
|
229
|
suite.location = { file, line: 0, column: 0 }; |
|
230
|
projectSuite._addSuite(suite); |
|
231
|
return suite; |
|
232
|
}); |
|
233
|
testRun.projectSuites.set(project, suites); |
|
234
|
} |
|
235
|
} |
|
236
|
}; |
|
237
|
} |
|
238
|
function createLoadTask(mode, options) { |
|
239
|
return { |
|
240
|
title: "load tests", |
|
241
|
setup: async (testRun, errors, softErrors) => { |
|
242
|
await (0, import_loadUtils.collectProjectsAndTestFiles)(testRun, !!options.doNotRunDepsOutsideProjectFilter); |
|
243
|
await (0, import_loadUtils.loadFileSuites)(testRun, mode, options.failOnLoadErrors ? errors : softErrors); |
|
244
|
if (testRun.config.cliOnlyChanged || options.populateDependencies) { |
|
245
|
for (const plugin of testRun.config.plugins) |
|
246
|
await plugin.instance?.populateDependencies?.(); |
|
247
|
} |
|
248
|
if (testRun.config.cliOnlyChanged) { |
|
249
|
const changedFiles = await (0, import_vcs.detectChangedTestFiles)(testRun.config.cliOnlyChanged, testRun.config.configDir); |
|
250
|
testRun.config.preOnlyTestFilters.push((test) => changedFiles.has(test.location.file)); |
|
251
|
} |
|
252
|
if (testRun.config.cliTestList) { |
|
253
|
const testListFilter = await (0, import_loadUtils.loadTestList)(testRun.config, testRun.config.cliTestList); |
|
254
|
testRun.config.preOnlyTestFilters.push(testListFilter); |
|
255
|
} |
|
256
|
if (testRun.config.cliTestListInvert) { |
|
257
|
const testListInvertFilter = await (0, import_loadUtils.loadTestList)(testRun.config, testRun.config.cliTestListInvert); |
|
258
|
testRun.config.preOnlyTestFilters.push((test) => !testListInvertFilter(test)); |
|
259
|
} |
|
260
|
const { rootSuite, topLevelProjects } = await (0, import_loadUtils.createRootSuite)(testRun, options.failOnLoadErrors ? errors : softErrors, !!options.filterOnly); |
|
261
|
testRun.rootSuite = rootSuite; |
|
262
|
testRun.failureTracker.onRootSuite(rootSuite, topLevelProjects); |
|
263
|
if (options.failOnLoadErrors && !testRun.rootSuite.allTests().length && !testRun.config.cliPassWithNoTests && !testRun.config.config.shard && !testRun.config.cliOnlyChanged && !testRun.config.cliTestList && !testRun.config.cliTestListInvert) { |
|
264
|
if (testRun.config.cliArgs.length) { |
|
265
|
throw new Error([ |
|
266
|
`No tests found.`, |
|
267
|
`Make sure that arguments are regular expressions matching test files.`, |
|
268
|
`You may need to escape symbols like "$" or "*" and quote the arguments.` |
|
269
|
].join("\n")); |
|
270
|
} |
|
271
|
throw new Error(`No tests found`); |
|
272
|
} |
|
273
|
} |
|
274
|
}; |
|
275
|
} |
|
276
|
function createApplyRebaselinesTask() { |
|
277
|
return { |
|
278
|
title: "apply rebaselines", |
|
279
|
setup: async () => { |
|
280
|
(0, import_rebase.clearSuggestedRebaselines)(); |
|
281
|
}, |
|
282
|
teardown: async ({ config, reporter }) => { |
|
283
|
await (0, import_rebase.applySuggestedRebaselines)(config, reporter); |
|
284
|
} |
|
285
|
}; |
|
286
|
} |
|
287
|
function createPhasesTask() { |
|
288
|
return { |
|
289
|
title: "create phases", |
|
290
|
setup: async (testRun) => { |
|
291
|
let maxConcurrentTestGroups = 0; |
|
292
|
const processed = /* @__PURE__ */ new Set(); |
|
293
|
const projectToSuite = new Map(testRun.rootSuite.suites.map((suite) => [suite._fullProject, suite])); |
|
294
|
const allProjects = [...projectToSuite.keys()]; |
|
295
|
const teardownToSetups = (0, import_projectUtils.buildTeardownToSetupsMap)(allProjects); |
|
296
|
const teardownToSetupsDependents = /* @__PURE__ */ new Map(); |
|
297
|
for (const [teardown, setups] of teardownToSetups) { |
|
298
|
const closure = (0, import_projectUtils.buildDependentProjects)(setups, allProjects); |
|
299
|
closure.delete(teardown); |
|
300
|
teardownToSetupsDependents.set(teardown, [...closure]); |
|
301
|
} |
|
302
|
for (let i = 0; i < projectToSuite.size; i++) { |
|
303
|
const phaseProjects = []; |
|
304
|
for (const project of projectToSuite.keys()) { |
|
305
|
if (processed.has(project)) |
|
306
|
continue; |
|
307
|
const projectsThatShouldFinishFirst = [...project.deps, ...teardownToSetupsDependents.get(project) || []]; |
|
308
|
if (projectsThatShouldFinishFirst.find((p) => !processed.has(p))) |
|
309
|
continue; |
|
310
|
phaseProjects.push(project); |
|
311
|
} |
|
312
|
for (const project of phaseProjects) |
|
313
|
processed.add(project); |
|
314
|
if (phaseProjects.length) { |
|
315
|
let testGroupsInPhase = 0; |
|
316
|
const phase = { dispatcher: new import_dispatcher.Dispatcher(testRun.config, testRun.reporter, testRun.failureTracker), projects: [] }; |
|
317
|
testRun.phases.push(phase); |
|
318
|
for (const project of phaseProjects) { |
|
319
|
const projectSuite = projectToSuite.get(project); |
|
320
|
const testGroups = (0, import_testGroups.createTestGroups)(projectSuite, testRun.config.config.workers); |
|
321
|
phase.projects.push({ project, projectSuite, testGroups }); |
|
322
|
testGroupsInPhase += Math.min(project.workers ?? Number.MAX_SAFE_INTEGER, testGroups.length); |
|
323
|
} |
|
324
|
(0, import_utilsBundle.debug)("pw:test:task")(`created phase #${testRun.phases.length} with ${phase.projects.map((p) => p.project.project.name).sort()} projects, ${testGroupsInPhase} testGroups`); |
|
325
|
maxConcurrentTestGroups = Math.max(maxConcurrentTestGroups, testGroupsInPhase); |
|
326
|
} |
|
327
|
} |
|
328
|
testRun.config.config.metadata.actualWorkers = Math.min(testRun.config.config.workers, maxConcurrentTestGroups); |
|
329
|
} |
|
330
|
}; |
|
331
|
} |
|
332
|
function createRunTestsTask() { |
|
333
|
return { |
|
334
|
title: "test suite", |
|
335
|
setup: async ({ phases, failureTracker }) => { |
|
336
|
const successfulProjects = /* @__PURE__ */ new Set(); |
|
337
|
const extraEnvByProjectId = /* @__PURE__ */ new Map(); |
|
338
|
const teardownToSetups = (0, import_projectUtils.buildTeardownToSetupsMap)(phases.map((phase) => phase.projects.map((p) => p.project)).flat()); |
|
339
|
for (const { dispatcher, projects } of phases) { |
|
340
|
const phaseTestGroups = []; |
|
341
|
for (const { project, testGroups } of projects) { |
|
342
|
let extraEnv = {}; |
|
343
|
for (const dep of project.deps) |
|
344
|
extraEnv = { ...extraEnv, ...extraEnvByProjectId.get(dep.id) }; |
|
345
|
for (const setup of teardownToSetups.get(project) || []) |
|
346
|
extraEnv = { ...extraEnv, ...extraEnvByProjectId.get(setup.id) }; |
|
347
|
extraEnvByProjectId.set(project.id, extraEnv); |
|
348
|
const hasFailedDeps = project.deps.some((p) => !successfulProjects.has(p)); |
|
349
|
if (!hasFailedDeps) |
|
350
|
phaseTestGroups.push(...testGroups); |
|
351
|
} |
|
352
|
if (phaseTestGroups.length) { |
|
353
|
await dispatcher.run(phaseTestGroups, extraEnvByProjectId); |
|
354
|
await dispatcher.stop(); |
|
355
|
for (const [projectId, envProduced] of dispatcher.producedEnvByProjectId()) { |
|
356
|
const extraEnv = extraEnvByProjectId.get(projectId) || {}; |
|
357
|
extraEnvByProjectId.set(projectId, { ...extraEnv, ...envProduced }); |
|
358
|
} |
|
359
|
} |
|
360
|
if (!failureTracker.hasWorkerErrors()) { |
|
361
|
for (const { project, projectSuite } of projects) { |
|
362
|
const hasFailedDeps = project.deps.some((p) => !successfulProjects.has(p)); |
|
363
|
if (!hasFailedDeps && !projectSuite.allTests().some((test) => !test.ok())) |
|
364
|
successfulProjects.add(project); |
|
365
|
} |
|
366
|
} |
|
367
|
} |
|
368
|
}, |
|
369
|
teardown: async ({ phases }) => { |
|
370
|
for (const { dispatcher } of phases.reverse()) |
|
371
|
await dispatcher.stop(); |
|
372
|
} |
|
373
|
}; |
|
374
|
} |
|
375
|
function createStartDevServerTask() { |
|
376
|
return { |
|
377
|
title: "start dev server", |
|
378
|
setup: async ({ config }, errors, softErrors) => { |
|
379
|
if (config.plugins.some((plugin) => !!plugin.devServerCleanup)) { |
|
380
|
errors.push({ message: `DevServer is already running` }); |
|
381
|
return; |
|
382
|
} |
|
383
|
for (const plugin of config.plugins) |
|
384
|
plugin.devServerCleanup = await plugin.instance?.startDevServer?.(); |
|
385
|
if (!config.plugins.some((plugin) => !!plugin.devServerCleanup)) |
|
386
|
errors.push({ message: `DevServer is not available in the package you are using. Did you mean to use component testing?` }); |
|
387
|
}, |
|
388
|
teardown: async ({ config }) => { |
|
389
|
for (const plugin of config.plugins) { |
|
390
|
await plugin.devServerCleanup?.(); |
|
391
|
plugin.devServerCleanup = void 0; |
|
392
|
} |
|
393
|
} |
|
394
|
}; |
|
395
|
} |
|
396
|
// Annotate the CommonJS export names for ESM import in node: |
|
397
|
0 && (module.exports = { |
|
398
|
TestRun, |
|
399
|
createApplyRebaselinesTask, |
|
400
|
createClearCacheTask, |
|
401
|
createGlobalSetupTasks, |
|
402
|
createListFilesTask, |
|
403
|
createLoadTask, |
|
404
|
createPluginSetupTasks, |
|
405
|
createReportBeginTask, |
|
406
|
createRunTestsTasks, |
|
407
|
createStartDevServerTask, |
|
408
|
runTasks, |
|
409
|
runTasksDeferCleanup |
|
410
|
}); |
|
411
|
|