|
1
|
"use strict"; |
|
2
|
var __defProp = Object.defineProperty; |
|
3
|
var __getOwnPropDesc = Object.getOwnPropertyDescriptor; |
|
4
|
var __getOwnPropNames = Object.getOwnPropertyNames; |
|
5
|
var __hasOwnProp = Object.prototype.hasOwnProperty; |
|
6
|
var __export = (target, all) => { |
|
7
|
for (var name in all) |
|
8
|
__defProp(target, name, { get: all[name], enumerable: true }); |
|
9
|
}; |
|
10
|
var __copyProps = (to, from, except, desc) => { |
|
11
|
if (from && typeof from === "object" || typeof from === "function") { |
|
12
|
for (let key of __getOwnPropNames(from)) |
|
13
|
if (!__hasOwnProp.call(to, key) && key !== except) |
|
14
|
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable }); |
|
15
|
} |
|
16
|
return to; |
|
17
|
}; |
|
18
|
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod); |
|
19
|
var teleReceiver_exports = {}; |
|
20
|
__export(teleReceiver_exports, { |
|
21
|
TeleReporterReceiver: () => TeleReporterReceiver, |
|
22
|
TeleSuite: () => TeleSuite, |
|
23
|
TeleTestCase: () => TeleTestCase, |
|
24
|
TeleTestResult: () => TeleTestResult, |
|
25
|
baseFullConfig: () => baseFullConfig, |
|
26
|
computeTestCaseOutcome: () => computeTestCaseOutcome, |
|
27
|
parseRegexPatterns: () => parseRegexPatterns, |
|
28
|
serializeRegexPatterns: () => serializeRegexPatterns |
|
29
|
}); |
|
30
|
module.exports = __toCommonJS(teleReceiver_exports); |
|
31
|
class TeleReporterReceiver { |
|
32
|
constructor(reporter, options = {}) { |
|
33
|
this.isListing = false; |
|
34
|
this._tests = /* @__PURE__ */ new Map(); |
|
35
|
this._rootSuite = new TeleSuite("", "root"); |
|
36
|
this._options = options; |
|
37
|
this._reporter = reporter; |
|
38
|
} |
|
39
|
reset() { |
|
40
|
this._rootSuite._entries = []; |
|
41
|
this._tests.clear(); |
|
42
|
} |
|
43
|
dispatch(message) { |
|
44
|
const { method, params } = message; |
|
45
|
if (method === "onConfigure") { |
|
46
|
this._onConfigure(params.config); |
|
47
|
return; |
|
48
|
} |
|
49
|
if (method === "onProject") { |
|
50
|
this._onProject(params.project); |
|
51
|
return; |
|
52
|
} |
|
53
|
if (method === "onBegin") { |
|
54
|
this._onBegin(); |
|
55
|
return; |
|
56
|
} |
|
57
|
if (method === "onTestBegin") { |
|
58
|
this._onTestBegin(params.testId, params.result); |
|
59
|
return; |
|
60
|
} |
|
61
|
if (method === "onTestPaused") { |
|
62
|
this._onTestPaused(params.testId, params.resultId, params.errors); |
|
63
|
return; |
|
64
|
} |
|
65
|
if (method === "onTestEnd") { |
|
66
|
this._onTestEnd(params.test, params.result); |
|
67
|
return; |
|
68
|
} |
|
69
|
if (method === "onStepBegin") { |
|
70
|
this._onStepBegin(params.testId, params.resultId, params.step); |
|
71
|
return; |
|
72
|
} |
|
73
|
if (method === "onAttach") { |
|
74
|
this._onAttach(params.testId, params.resultId, params.attachments); |
|
75
|
return; |
|
76
|
} |
|
77
|
if (method === "onStepEnd") { |
|
78
|
this._onStepEnd(params.testId, params.resultId, params.step); |
|
79
|
return; |
|
80
|
} |
|
81
|
if (method === "onError") { |
|
82
|
this._onError(params.error); |
|
83
|
return; |
|
84
|
} |
|
85
|
if (method === "onStdIO") { |
|
86
|
this._onStdIO(params.type, params.testId, params.resultId, params.data, params.isBase64); |
|
87
|
return; |
|
88
|
} |
|
89
|
if (method === "onEnd") |
|
90
|
return this._onEnd(params.result); |
|
91
|
if (method === "onExit") |
|
92
|
return this._onExit(); |
|
93
|
} |
|
94
|
_onConfigure(config) { |
|
95
|
this._rootDir = config.rootDir; |
|
96
|
this._config = this._parseConfig(config); |
|
97
|
this._reporter.onConfigure?.(this._config); |
|
98
|
} |
|
99
|
_onProject(project) { |
|
100
|
let projectSuite = this._options.mergeProjects ? this._rootSuite.suites.find((suite) => suite.project().name === project.name) : void 0; |
|
101
|
if (!projectSuite) { |
|
102
|
projectSuite = new TeleSuite(project.name, "project"); |
|
103
|
this._rootSuite._addSuite(projectSuite); |
|
104
|
} |
|
105
|
projectSuite._project = this._parseProject(project); |
|
106
|
for (const suite of project.suites) |
|
107
|
this._mergeSuiteInto(suite, projectSuite); |
|
108
|
} |
|
109
|
_onBegin() { |
|
110
|
this._reporter.onBegin?.(this._rootSuite); |
|
111
|
} |
|
112
|
_onTestBegin(testId, payload) { |
|
113
|
const test = this._tests.get(testId); |
|
114
|
if (this._options.clearPreviousResultsWhenTestBegins) |
|
115
|
test.results = []; |
|
116
|
const testResult = test._createTestResult(payload.id); |
|
117
|
testResult.retry = payload.retry; |
|
118
|
testResult.workerIndex = payload.workerIndex; |
|
119
|
testResult.parallelIndex = payload.parallelIndex; |
|
120
|
testResult.setStartTimeNumber(payload.startTime); |
|
121
|
this._reporter.onTestBegin?.(test, testResult); |
|
122
|
} |
|
123
|
_onTestPaused(testId, resultId, errors) { |
|
124
|
const test = this._tests.get(testId); |
|
125
|
const result = test.results.find((r) => r._id === resultId); |
|
126
|
result.errors.push(...errors); |
|
127
|
result.error = result.errors[0]; |
|
128
|
void this._reporter.onTestPaused?.(test, result); |
|
129
|
} |
|
130
|
_onTestEnd(testEndPayload, payload) { |
|
131
|
const test = this._tests.get(testEndPayload.testId); |
|
132
|
test.timeout = testEndPayload.timeout; |
|
133
|
test.expectedStatus = testEndPayload.expectedStatus; |
|
134
|
const result = test.results.find((r) => r._id === payload.id); |
|
135
|
result.duration = payload.duration; |
|
136
|
result.status = payload.status; |
|
137
|
result.errors.push(...payload.errors ?? []); |
|
138
|
result.error = result.errors[0]; |
|
139
|
if (!!payload.attachments) |
|
140
|
result.attachments = this._parseAttachments(payload.attachments); |
|
141
|
if (payload.annotations) { |
|
142
|
this._absoluteAnnotationLocationsInplace(payload.annotations); |
|
143
|
result.annotations = payload.annotations; |
|
144
|
test.annotations = payload.annotations; |
|
145
|
} |
|
146
|
this._reporter.onTestEnd?.(test, result); |
|
147
|
result._stepMap = /* @__PURE__ */ new Map(); |
|
148
|
} |
|
149
|
_onStepBegin(testId, resultId, payload) { |
|
150
|
const test = this._tests.get(testId); |
|
151
|
const result = test.results.find((r) => r._id === resultId); |
|
152
|
const parentStep = payload.parentStepId ? result._stepMap.get(payload.parentStepId) : void 0; |
|
153
|
const location = this._absoluteLocation(payload.location); |
|
154
|
const step = new TeleTestStep(payload, parentStep, location, result); |
|
155
|
if (parentStep) |
|
156
|
parentStep.steps.push(step); |
|
157
|
else |
|
158
|
result.steps.push(step); |
|
159
|
result._stepMap.set(payload.id, step); |
|
160
|
this._reporter.onStepBegin?.(test, result, step); |
|
161
|
} |
|
162
|
_onStepEnd(testId, resultId, payload) { |
|
163
|
const test = this._tests.get(testId); |
|
164
|
const result = test.results.find((r) => r._id === resultId); |
|
165
|
const step = result._stepMap.get(payload.id); |
|
166
|
step._endPayload = payload; |
|
167
|
step.duration = payload.duration; |
|
168
|
step.error = payload.error; |
|
169
|
this._reporter.onStepEnd?.(test, result, step); |
|
170
|
} |
|
171
|
_onAttach(testId, resultId, attachments) { |
|
172
|
const test = this._tests.get(testId); |
|
173
|
const result = test.results.find((r) => r._id === resultId); |
|
174
|
result.attachments.push(...attachments.map((a) => ({ |
|
175
|
name: a.name, |
|
176
|
contentType: a.contentType, |
|
177
|
path: a.path, |
|
178
|
body: a.base64 && globalThis.Buffer ? Buffer.from(a.base64, "base64") : void 0 |
|
179
|
}))); |
|
180
|
} |
|
181
|
_onError(error) { |
|
182
|
this._reporter.onError?.(error); |
|
183
|
} |
|
184
|
_onStdIO(type, testId, resultId, data, isBase64) { |
|
185
|
const chunk = isBase64 ? globalThis.Buffer ? Buffer.from(data, "base64") : atob(data) : data; |
|
186
|
const test = testId ? this._tests.get(testId) : void 0; |
|
187
|
const result = test && resultId ? test.results.find((r) => r._id === resultId) : void 0; |
|
188
|
if (type === "stdout") { |
|
189
|
result?.stdout.push(chunk); |
|
190
|
this._reporter.onStdOut?.(chunk, test, result); |
|
191
|
} else { |
|
192
|
result?.stderr.push(chunk); |
|
193
|
this._reporter.onStdErr?.(chunk, test, result); |
|
194
|
} |
|
195
|
} |
|
196
|
async _onEnd(result) { |
|
197
|
await this._reporter.onEnd?.({ |
|
198
|
status: result.status, |
|
199
|
startTime: new Date(result.startTime), |
|
200
|
duration: result.duration |
|
201
|
}); |
|
202
|
} |
|
203
|
_onExit() { |
|
204
|
return this._reporter.onExit?.(); |
|
205
|
} |
|
206
|
_parseConfig(config) { |
|
207
|
const result = { ...baseFullConfig, ...config }; |
|
208
|
if (this._options.configOverrides) { |
|
209
|
result.configFile = this._options.configOverrides.configFile; |
|
210
|
result.reportSlowTests = this._options.configOverrides.reportSlowTests; |
|
211
|
result.quiet = this._options.configOverrides.quiet; |
|
212
|
result.reporter = [...this._options.configOverrides.reporter]; |
|
213
|
} |
|
214
|
return result; |
|
215
|
} |
|
216
|
_parseProject(project) { |
|
217
|
return { |
|
218
|
metadata: project.metadata, |
|
219
|
name: project.name, |
|
220
|
outputDir: this._absolutePath(project.outputDir), |
|
221
|
repeatEach: project.repeatEach, |
|
222
|
retries: project.retries, |
|
223
|
testDir: this._absolutePath(project.testDir), |
|
224
|
testIgnore: parseRegexPatterns(project.testIgnore), |
|
225
|
testMatch: parseRegexPatterns(project.testMatch), |
|
226
|
timeout: project.timeout, |
|
227
|
grep: parseRegexPatterns(project.grep), |
|
228
|
grepInvert: parseRegexPatterns(project.grepInvert), |
|
229
|
dependencies: project.dependencies, |
|
230
|
teardown: project.teardown, |
|
231
|
snapshotDir: this._absolutePath(project.snapshotDir), |
|
232
|
use: project.use |
|
233
|
}; |
|
234
|
} |
|
235
|
_parseAttachments(attachments) { |
|
236
|
return attachments.map((a) => { |
|
237
|
return { |
|
238
|
...a, |
|
239
|
body: a.base64 && globalThis.Buffer ? Buffer.from(a.base64, "base64") : void 0 |
|
240
|
}; |
|
241
|
}); |
|
242
|
} |
|
243
|
_mergeSuiteInto(jsonSuite, parent) { |
|
244
|
let targetSuite = parent.suites.find((s) => s.title === jsonSuite.title); |
|
245
|
if (!targetSuite) { |
|
246
|
targetSuite = new TeleSuite(jsonSuite.title, parent.type === "project" ? "file" : "describe"); |
|
247
|
parent._addSuite(targetSuite); |
|
248
|
} |
|
249
|
targetSuite.location = this._absoluteLocation(jsonSuite.location); |
|
250
|
jsonSuite.entries.forEach((e) => { |
|
251
|
if ("testId" in e) |
|
252
|
this._mergeTestInto(e, targetSuite); |
|
253
|
else |
|
254
|
this._mergeSuiteInto(e, targetSuite); |
|
255
|
}); |
|
256
|
} |
|
257
|
_mergeTestInto(jsonTest, parent) { |
|
258
|
let targetTest = this._options.mergeTestCases ? parent.tests.find((s) => s.title === jsonTest.title && s.repeatEachIndex === jsonTest.repeatEachIndex) : void 0; |
|
259
|
if (!targetTest) { |
|
260
|
targetTest = new TeleTestCase(jsonTest.testId, jsonTest.title, this._absoluteLocation(jsonTest.location), jsonTest.repeatEachIndex); |
|
261
|
parent._addTest(targetTest); |
|
262
|
this._tests.set(targetTest.id, targetTest); |
|
263
|
} |
|
264
|
this._updateTest(jsonTest, targetTest); |
|
265
|
} |
|
266
|
_updateTest(payload, test) { |
|
267
|
test.id = payload.testId; |
|
268
|
test.location = this._absoluteLocation(payload.location); |
|
269
|
test.retries = payload.retries; |
|
270
|
test.tags = payload.tags ?? []; |
|
271
|
test.annotations = payload.annotations ?? []; |
|
272
|
this._absoluteAnnotationLocationsInplace(test.annotations); |
|
273
|
return test; |
|
274
|
} |
|
275
|
_absoluteAnnotationLocationsInplace(annotations) { |
|
276
|
for (const annotation of annotations) { |
|
277
|
if (annotation.location) |
|
278
|
annotation.location = this._absoluteLocation(annotation.location); |
|
279
|
} |
|
280
|
} |
|
281
|
_absoluteLocation(location) { |
|
282
|
if (!location) |
|
283
|
return location; |
|
284
|
return { |
|
285
|
...location, |
|
286
|
file: this._absolutePath(location.file) |
|
287
|
}; |
|
288
|
} |
|
289
|
_absolutePath(relativePath) { |
|
290
|
if (relativePath === void 0) |
|
291
|
return; |
|
292
|
return this._options.resolvePath ? this._options.resolvePath(this._rootDir, relativePath) : this._rootDir + "/" + relativePath; |
|
293
|
} |
|
294
|
} |
|
295
|
class TeleSuite { |
|
296
|
constructor(title, type) { |
|
297
|
this._entries = []; |
|
298
|
this._requireFile = ""; |
|
299
|
this._parallelMode = "none"; |
|
300
|
this.title = title; |
|
301
|
this._type = type; |
|
302
|
} |
|
303
|
get type() { |
|
304
|
return this._type; |
|
305
|
} |
|
306
|
get suites() { |
|
307
|
return this._entries.filter((e) => e.type !== "test"); |
|
308
|
} |
|
309
|
get tests() { |
|
310
|
return this._entries.filter((e) => e.type === "test"); |
|
311
|
} |
|
312
|
entries() { |
|
313
|
return this._entries; |
|
314
|
} |
|
315
|
allTests() { |
|
316
|
const result = []; |
|
317
|
const visit = (suite) => { |
|
318
|
for (const entry of suite.entries()) { |
|
319
|
if (entry.type === "test") |
|
320
|
result.push(entry); |
|
321
|
else |
|
322
|
visit(entry); |
|
323
|
} |
|
324
|
}; |
|
325
|
visit(this); |
|
326
|
return result; |
|
327
|
} |
|
328
|
titlePath() { |
|
329
|
const titlePath = this.parent ? this.parent.titlePath() : []; |
|
330
|
if (this.title || this._type !== "describe") |
|
331
|
titlePath.push(this.title); |
|
332
|
return titlePath; |
|
333
|
} |
|
334
|
project() { |
|
335
|
return this._project ?? this.parent?.project(); |
|
336
|
} |
|
337
|
_addTest(test) { |
|
338
|
test.parent = this; |
|
339
|
this._entries.push(test); |
|
340
|
} |
|
341
|
_addSuite(suite) { |
|
342
|
suite.parent = this; |
|
343
|
this._entries.push(suite); |
|
344
|
} |
|
345
|
} |
|
346
|
class TeleTestCase { |
|
347
|
constructor(id, title, location, repeatEachIndex) { |
|
348
|
this.fn = () => { |
|
349
|
}; |
|
350
|
this.results = []; |
|
351
|
this.type = "test"; |
|
352
|
this.expectedStatus = "passed"; |
|
353
|
this.timeout = 0; |
|
354
|
this.annotations = []; |
|
355
|
this.retries = 0; |
|
356
|
this.tags = []; |
|
357
|
this.repeatEachIndex = 0; |
|
358
|
this.id = id; |
|
359
|
this.title = title; |
|
360
|
this.location = location; |
|
361
|
this.repeatEachIndex = repeatEachIndex; |
|
362
|
} |
|
363
|
titlePath() { |
|
364
|
const titlePath = this.parent ? this.parent.titlePath() : []; |
|
365
|
titlePath.push(this.title); |
|
366
|
return titlePath; |
|
367
|
} |
|
368
|
outcome() { |
|
369
|
return computeTestCaseOutcome(this); |
|
370
|
} |
|
371
|
ok() { |
|
372
|
const status = this.outcome(); |
|
373
|
return status === "expected" || status === "flaky" || status === "skipped"; |
|
374
|
} |
|
375
|
_createTestResult(id) { |
|
376
|
const result = new TeleTestResult(this.results.length, id); |
|
377
|
this.results.push(result); |
|
378
|
return result; |
|
379
|
} |
|
380
|
} |
|
381
|
class TeleTestStep { |
|
382
|
constructor(payload, parentStep, location, result) { |
|
383
|
this.duration = -1; |
|
384
|
this.steps = []; |
|
385
|
this._startTime = 0; |
|
386
|
this.title = payload.title; |
|
387
|
this.category = payload.category; |
|
388
|
this.location = location; |
|
389
|
this.parent = parentStep; |
|
390
|
this._startTime = payload.startTime; |
|
391
|
this._result = result; |
|
392
|
} |
|
393
|
titlePath() { |
|
394
|
const parentPath = this.parent?.titlePath() || []; |
|
395
|
return [...parentPath, this.title]; |
|
396
|
} |
|
397
|
get startTime() { |
|
398
|
return new Date(this._startTime); |
|
399
|
} |
|
400
|
set startTime(value) { |
|
401
|
this._startTime = +value; |
|
402
|
} |
|
403
|
get attachments() { |
|
404
|
return this._endPayload?.attachments?.map((index) => this._result.attachments[index]) ?? []; |
|
405
|
} |
|
406
|
get annotations() { |
|
407
|
return this._endPayload?.annotations ?? []; |
|
408
|
} |
|
409
|
} |
|
410
|
class TeleTestResult { |
|
411
|
constructor(retry, id) { |
|
412
|
this.parallelIndex = -1; |
|
413
|
this.workerIndex = -1; |
|
414
|
this.duration = -1; |
|
415
|
this.stdout = []; |
|
416
|
this.stderr = []; |
|
417
|
this.attachments = []; |
|
418
|
this.annotations = []; |
|
419
|
this.status = "skipped"; |
|
420
|
this.steps = []; |
|
421
|
this.errors = []; |
|
422
|
this._stepMap = /* @__PURE__ */ new Map(); |
|
423
|
this._startTime = 0; |
|
424
|
this.retry = retry; |
|
425
|
this._id = id; |
|
426
|
} |
|
427
|
setStartTimeNumber(startTime) { |
|
428
|
this._startTime = startTime; |
|
429
|
} |
|
430
|
get startTime() { |
|
431
|
return new Date(this._startTime); |
|
432
|
} |
|
433
|
set startTime(value) { |
|
434
|
this._startTime = +value; |
|
435
|
} |
|
436
|
} |
|
437
|
const baseFullConfig = { |
|
438
|
forbidOnly: false, |
|
439
|
fullyParallel: false, |
|
440
|
globalSetup: null, |
|
441
|
globalTeardown: null, |
|
442
|
globalTimeout: 0, |
|
443
|
grep: /.*/, |
|
444
|
grepInvert: null, |
|
445
|
maxFailures: 0, |
|
446
|
metadata: {}, |
|
447
|
preserveOutput: "always", |
|
448
|
projects: [], |
|
449
|
reporter: [[process.env.CI ? "dot" : "list"]], |
|
450
|
reportSlowTests: { |
|
451
|
max: 5, |
|
452
|
threshold: 3e5 |
|
453
|
/* 5 minutes */ |
|
454
|
}, |
|
455
|
configFile: "", |
|
456
|
rootDir: "", |
|
457
|
quiet: false, |
|
458
|
shard: null, |
|
459
|
tags: [], |
|
460
|
updateSnapshots: "missing", |
|
461
|
updateSourceMethod: "patch", |
|
462
|
// @ts-expect-error runAgents is hidden |
|
463
|
runAgents: "none", |
|
464
|
version: "", |
|
465
|
workers: 0, |
|
466
|
webServer: null |
|
467
|
}; |
|
468
|
function serializeRegexPatterns(patterns) { |
|
469
|
if (!Array.isArray(patterns)) |
|
470
|
patterns = [patterns]; |
|
471
|
return patterns.map((s) => { |
|
472
|
if (typeof s === "string") |
|
473
|
return { s }; |
|
474
|
return { r: { source: s.source, flags: s.flags } }; |
|
475
|
}); |
|
476
|
} |
|
477
|
function parseRegexPatterns(patterns) { |
|
478
|
return patterns.map((p) => { |
|
479
|
if (p.s !== void 0) |
|
480
|
return p.s; |
|
481
|
return new RegExp(p.r.source, p.r.flags); |
|
482
|
}); |
|
483
|
} |
|
484
|
function computeTestCaseOutcome(test) { |
|
485
|
let skipped = 0; |
|
486
|
let didNotRun = 0; |
|
487
|
let expected = 0; |
|
488
|
let interrupted = 0; |
|
489
|
let unexpected = 0; |
|
490
|
for (const result of test.results) { |
|
491
|
if (result.status === "interrupted") { |
|
492
|
++interrupted; |
|
493
|
} else if (result.status === "skipped" && test.expectedStatus === "skipped") { |
|
494
|
++skipped; |
|
495
|
} else if (result.status === "skipped") { |
|
496
|
++didNotRun; |
|
497
|
} else if (result.status === test.expectedStatus) { |
|
498
|
++expected; |
|
499
|
} else { |
|
500
|
++unexpected; |
|
501
|
} |
|
502
|
} |
|
503
|
if (expected === 0 && unexpected === 0) |
|
504
|
return "skipped"; |
|
505
|
if (unexpected === 0) |
|
506
|
return "expected"; |
|
507
|
if (expected === 0 && skipped === 0) |
|
508
|
return "unexpected"; |
|
509
|
return "flaky"; |
|
510
|
} |
|
511
|
// Annotate the CommonJS export names for ESM import in node: |
|
512
|
0 && (module.exports = { |
|
513
|
TeleReporterReceiver, |
|
514
|
TeleSuite, |
|
515
|
TeleTestCase, |
|
516
|
TeleTestResult, |
|
517
|
baseFullConfig, |
|
518
|
computeTestCaseOutcome, |
|
519
|
parseRegexPatterns, |
|
520
|
serializeRegexPatterns |
|
521
|
}); |
|
522
|
|