actions/test-reporter
1
0
Fork 0
mirror of https://github.com/dorny/test-reporter.git synced 2025-12-15 22:07:09 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions 1

Refactoring & cleanup of whole codebase

Browse source 
Improves report summary and annotations
This commit is contained in:
Michal Dorner 2021-01-31 20:47:55 +01:00
parent 07a0223ee3
commit 60b35d601a
No known key found for this signature in database
GPG key ID: 9EEE04B48DA36786
20 changed files with 38784 additions and 33667 deletions
Download patch file Download diff file Expand all files Collapse all files

2
__tests__/__outputs__/dotnet-trx.md
View file

@ -5,7 +5,7 @@
|:---|---:|---:|---:|---:|
|[DotnetTests.XUnitTests.CalculatorTests](#r0s0)|3✔️|3❌|1✖️|110ms|
### <a id="user-content-r0s0" href="#r0s0">DotnetTests.XUnitTests.CalculatorTests</a> ❌
**7** tests were completed in **109.5761ms** with **3** passed, **3** failed and **1** skipped.
**7** tests were completed in **110ms** with **3** passed, **3** failed and **1** skipped.
|Result|Test|Time|
|:---:|:---|---:|

4
__tests__/__outputs__/jest-test-results.md
View file

@ -404,7 +404,7 @@
|packages/pretty-format/src/__tests__/react.test.tsx|55✔️|||325ms|
|packages/pretty-format/src/__tests__/ReactElement.test.ts|3✔️|||64ms|
### <a id="user-content-r0s75" href="#r0s75">e2e/__tests__/jestChangedFiles.test.ts</a> ❌
**10** tests were completed in **9045ms** with **9** passed, **1** failed and **0** skipped.
**10** tests were completed in **9.045s** with **9** passed, **1** failed and **0** skipped.
|Result|Test|Time|
|:---:|:---|---:|
@ -419,7 +419,7 @@
|✔️|monitors only root paths for hg|281ms|
|✔️|handles a bad revision for "changedSince", for hg|949ms|
### <a id="user-content-r0s98" href="#r0s98">e2e/__tests__/onlyChanged.test.ts</a> ❌
**9** tests were completed in **22281ms** with **8** passed, **1** failed and **0** skipped.
**9** tests were completed in **22.281s** with **8** passed, **1** failed and **0** skipped.
|Result|Test|Time|
|:---:|:---|---:|

194
__tests__/__snapshots__/dart-json.test.ts.snap
View file

@ -1,126 +1,106 @@
// Jest Snapshot v1, https://goo.gl/fbAQLP
exports[`dart-json tests matches report snapshot 1`] = `
Object {
"annotations": Array [
Object {
"annotation_level": "failure",
"end_line": 13,
"message": "Expected: <2>
TestRunResult {
"path": "fixtures/dart-json.json",
"suites": Array [
TestSuiteResult {
"groups": Array [
TestGroupResult {
"name": "Test 1",
"tests": Array [
TestCaseResult {
"error": undefined,
"name": "Test 1 Passing test",
"result": "success",
"time": 36,
},
],
},
TestGroupResult {
"name": "Test 1 Test 1.1",
"tests": Array [
TestCaseResult {
"error": Object {
"line": 13,
"message": "Expected: <2>
Actual: <1>
package:test_api expect
",
"path": "test/main_test.dart",
"stackTrace": "package:test_api expect
test\\\\main_test.dart 13:9 main.<fn>.<fn>.<fn>
",
"path": "test/main_test.dart",
"start_line": 13,
"title": "[test\\\\main_test.dart] Test 1 Test 1.1 Failing test",
},
Object {
"annotation_level": "failure",
"end_line": 2,
"message": "Exception: Some error
package:darttest/main.dart 2:3 throwError
},
"name": "Test 1 Test 1.1 Failing test",
"result": "failed",
"time": 20,
},
TestCaseResult {
"error": Object {
"line": 2,
"message": "Exception: Some error",
"path": "lib/main.dart",
"stackTrace": "package:darttest/main.dart 2:3 throwError
test\\\\main_test.dart 17:9 main.<fn>.<fn>.<fn>
",
"path": "lib/main.dart",
"start_line": 2,
"title": "[test\\\\main_test.dart] Test 1 Test 1.1 Exception in target unit",
},
Object {
"annotation_level": "failure",
"end_line": 24,
"message": "Exception: Some error
test\\\\main_test.dart 24:7 main.<fn>.<fn>
",
"path": "test/main_test.dart",
"start_line": 24,
"title": "[test\\\\main_test.dart] Test 2 Exception in test",
},
Object {
"annotation_level": "failure",
"end_line": 5,
"message": "TimeoutException after 0:00:00.000001: Test timed out after 0 seconds.
dart:isolate _RawReceivePortImpl._handleMessage
",
"path": "test/second_test.dart",
"start_line": 5,
"title": "[test\\\\second_test.dart] Timeout test",
},
],
"testRuns": Array [
TestRunResult {
"path": "fixtures/dart-json.json",
"suites": Array [
TestSuiteResult {
"groups": Array [
TestGroupResult {
"name": "Test 1",
"tests": Array [
TestCaseResult {
"name": "Test 1 Passing test",
"result": "success",
"time": 36,
},
],
},
TestGroupResult {
"name": "Test 1 Test 1.1",
"tests": Array [
TestCaseResult {
"name": "Test 1 Test 1.1 Failing test",
"result": "failed",
"time": 20,
},
TestCaseResult {
"name": "Test 1 Test 1.1 Exception in target unit",
"result": "failed",
"time": 6,
},
],
},
TestGroupResult {
"name": "Test 2",
"tests": Array [
TestCaseResult {
"name": "Test 2 Exception in test",
"result": "failed",
"time": 12,
},
],
},
"name": "Test 1 Test 1.1 Exception in target unit",
"result": "failed",
"time": 6,
},
],
"name": "test\\\\main_test.dart",
"totalTime": undefined,
},
TestSuiteResult {
"groups": Array [
TestGroupResult {
"name": null,
"tests": Array [
TestCaseResult {
"name": "Timeout test",
"result": "failed",
"time": 37,
},
TestCaseResult {
"name": "Skipped test",
"result": "skipped",
"time": 14,
},
],
TestGroupResult {
"name": "Test 2",
"tests": Array [
TestCaseResult {
"error": Object {
"line": 24,
"message": "Exception: Some error",
"path": "test/main_test.dart",
"stackTrace": "test\\\\main_test.dart 24:7 main.<fn>.<fn>
",
},
"name": "Test 2 Exception in test",
"result": "failed",
"time": 12,
},
],
"name": "test\\\\second_test.dart",
"totalTime": undefined,
},
],
"totalTime": 3760,
"name": "test\\\\main_test.dart",
"totalTime": undefined,
},
TestSuiteResult {
"groups": Array [
TestGroupResult {
"name": null,
"tests": Array [
TestCaseResult {
"error": Object {
"line": 5,
"message": "TimeoutException after 0:00:00.000001: Test timed out after 0 seconds.",
"path": "test/second_test.dart",
"stackTrace": "dart:isolate _RawReceivePortImpl._handleMessage
",
},
"name": "Timeout test",
"result": "failed",
"time": 37,
},
TestCaseResult {
"error": undefined,
"name": "Skipped test",
"result": "skipped",
"time": 14,
},
],
},
],
"name": "test\\\\second_test.dart",
"totalTime": undefined,
},
],
"totalTime": 3760,
}
`;

10359
__tests__/__snapshots__/dotnet-trx.test.ts.snap
View file

File diff suppressed because it is too large Load diff

60055
__tests__/__snapshots__/jest-junit.test.ts.snap
View file

File diff suppressed because it is too large Load diff

23
__tests__/dart-json.test.ts
View file

@ -1,30 +1,29 @@
import * as fs from 'fs'
import * as path from 'path'
import {parseDartJson} from '../src/parsers/dart-json/dart-json-parser'
import {ParseOptions} from '../src/parsers/parser-types'
import {DartJsonParser} from '../src/parsers/dart-json/dart-json-parser'
import {ParseOptions} from '../src/test-parser'
import {getReport} from '../src/report/get-report'
import {normalizeFilePath} from '../src/utils/file-utils'
const fixturePath = path.join(__dirname, 'fixtures', 'dart-json.json')
const outputPath = path.join(__dirname, '__outputs__', 'dart-json.md')
const xmlFixture = {
path: normalizeFilePath(path.relative(__dirname, fixturePath)),
content: fs.readFileSync(fixturePath, {encoding: 'utf8'})
}
describe('dart-json tests', () => {
it('matches report snapshot', async () => {
const opts: ParseOptions = {
annotations: true,
parseErrors: true,
trackedFiles: ['lib/main.dart', 'test/main_test.dart', 'test/second_test.dart'],
workDir: 'C:/Users/Michal/Workspace/dorny/test-check/reports/dart/'
}
const result = await parseDartJson([xmlFixture], opts)
const fixturePath = path.join(__dirname, 'fixtures', 'dart-json.json')
const outputPath = path.join(__dirname, '__outputs__', 'dart-json.md')
const filePath = normalizeFilePath(path.relative(__dirname, fixturePath))
const fileContent = fs.readFileSync(fixturePath, {encoding: 'utf8'})
const parser = new DartJsonParser(opts)
const result = await parser.parse(filePath, fileContent)
expect(result).toMatchSnapshot()
const report = getReport(result.testRuns)
const report = getReport([result])
fs.mkdirSync(path.dirname(outputPath), {recursive: true})
fs.writeFileSync(outputPath, report)
})

30
__tests__/dotnet-trx.test.ts
View file

@ -1,8 +1,8 @@
import * as fs from 'fs'
import * as path from 'path'
import {parseDotnetTrx} from '../src/parsers/dotnet-trx/dotnet-trx-parser'
import {ParseOptions} from '../src/parsers/parser-types'
import {DotnetTrxParser} from '../src/parsers/dotnet-trx/dotnet-trx-parser'
import {ParseOptions} from '../src/test-parser'
import {getReport} from '../src/report/get-report'
import {normalizeFilePath} from '../src/utils/file-utils'
@ -10,21 +10,20 @@ describe('dotnet-trx tests', () => {
it('matches report snapshot', async () => {
const fixturePath = path.join(__dirname, 'fixtures', 'dotnet-trx.trx')
const outputPath = path.join(__dirname, '__outputs__', 'dotnet-trx.md')
const xmlFixture = {
path: normalizeFilePath(path.relative(__dirname, fixturePath)),
content: fs.readFileSync(fixturePath, {encoding: 'utf8'})
}
const filePath = normalizeFilePath(path.relative(__dirname, fixturePath))
const fileContent = fs.readFileSync(fixturePath, {encoding: 'utf8'})
const opts: ParseOptions = {
annotations: true,
parseErrors: true,
trackedFiles: ['DotnetTests.Unit/Calculator.cs', 'DotnetTests.XUnitTests/CalculatorTests.cs'],
workDir: 'C:/Users/Michal/Workspace/dorny/test-check/reports/dotnet/'
}
const result = await parseDotnetTrx([xmlFixture], opts)
const parser = new DotnetTrxParser(opts)
const result = await parser.parse(filePath, fileContent)
expect(result).toMatchSnapshot()
const report = getReport(result.testRuns)
const report = getReport([result])
fs.mkdirSync(path.dirname(outputPath), {recursive: true})
fs.writeFileSync(outputPath, report)
})
@ -32,21 +31,20 @@ describe('dotnet-trx tests', () => {
it('report from FluentValidation test results matches snapshot', async () => {
const fixturePath = path.join(__dirname, 'fixtures', 'external', 'FluentValidation.Tests.trx')
const outputPath = path.join(__dirname, '__outputs__', 'fluent-validation-test-results.md')
const xmlFixture = {
path: normalizeFilePath(path.relative(__dirname, fixturePath)),
content: fs.readFileSync(fixturePath, {encoding: 'utf8'})
}
const filePath = normalizeFilePath(path.relative(__dirname, fixturePath))
const fileContent = fs.readFileSync(fixturePath, {encoding: 'utf8'})
const opts: ParseOptions = {
trackedFiles: [],
annotations: true,
parseErrors: true,
workDir: ''
}
const result = await parseDotnetTrx([xmlFixture], opts)
const parser = new DotnetTrxParser(opts)
const result = await parser.parse(filePath, fileContent)
expect(result).toMatchSnapshot()
const report = getReport(result.testRuns, {listTests: 'failed'})
const report = getReport([result], {listTests: 'failed'})
fs.mkdirSync(path.dirname(outputPath), {recursive: true})
fs.writeFileSync(outputPath, report)
})

34
__tests__/jest-junit.test.ts
View file

@ -1,8 +1,8 @@
import * as fs from 'fs'
import * as path from 'path'
import {parseJestJunit} from '../src/parsers/jest-junit/jest-junit-parser'
import {ParseOptions} from '../src/parsers/parser-types'
import {JestJunitParser} from '../src/parsers/jest-junit/jest-junit-parser'
import {ParseOptions} from '../src/test-parser'
import {getReport} from '../src/report/get-report'
import {normalizeFilePath} from '../src/utils/file-utils'
@ -10,45 +10,43 @@ describe('jest-junit tests', () => {
it('report from ./reports/jest test results matches snapshot', async () => {
const fixturePath = path.join(__dirname, 'fixtures', 'jest-junit.xml')
const outputPath = path.join(__dirname, '__outputs__', 'jest-junit.md')
const xmlFixture = {
path: normalizeFilePath(path.relative(__dirname, fixturePath)),
content: fs.readFileSync(fixturePath, {encoding: 'utf8'})
}
const filePath = normalizeFilePath(path.relative(__dirname, fixturePath))
const fileContent = fs.readFileSync(fixturePath, {encoding: 'utf8'})
const opts: ParseOptions = {
annotations: true,
parseErrors: true,
trackedFiles: ['__tests__/main.test.js', '__tests__/second.test.js', 'lib/main.js'],
workDir: 'C:/Users/Michal/Workspace/dorny/test-check/reports/jest/'
}
const result = await parseJestJunit([xmlFixture], opts)
const parser = new JestJunitParser(opts)
const result = await parser.parse(filePath, fileContent)
expect(result).toMatchSnapshot()
const report = getReport(result.testRuns)
const report = getReport([result])
fs.mkdirSync(path.dirname(outputPath), {recursive: true})
fs.writeFileSync(outputPath, report)
})
it('report from facebook/jest test results matches snapshot', async () => {
const fixturePath = path.join(__dirname, 'fixtures', 'external', 'jest', 'jest-test-results.xml')
const filesPath = path.join(__dirname, 'fixtures', 'external', 'jest', 'files.txt')
const trackedFilesPath = path.join(__dirname, 'fixtures', 'external', 'jest', 'files.txt')
const outputPath = path.join(__dirname, '__outputs__', 'jest-test-results.md')
const xmlFixture = {
path: normalizeFilePath(path.relative(__dirname, fixturePath)),
content: fs.readFileSync(fixturePath, {encoding: 'utf8'})
}
const filePath = normalizeFilePath(path.relative(__dirname, fixturePath))
const fileContent = fs.readFileSync(fixturePath, {encoding: 'utf8'})
const trackedFiles = fs.readFileSync(filesPath, {encoding: 'utf8'}).split(/\n\r?/g)
const trackedFiles = fs.readFileSync(trackedFilesPath, {encoding: 'utf8'}).split(/\n\r?/g)
const opts: ParseOptions = {
parseErrors: true,
trackedFiles,
annotations: true,
workDir: '/home/dorny/dorny/jest/'
}
const result = await parseJestJunit([xmlFixture], opts)
const parser = new JestJunitParser(opts)
const result = await parser.parse(filePath, fileContent)
expect(result).toMatchSnapshot()
const report = getReport(result.testRuns, {listTests: 'failed'})
const report = getReport([result], {listTests: 'failed'})
fs.mkdirSync(path.dirname(outputPath), {recursive: true})
fs.writeFileSync(outputPath, report)
})

801
dist/index.js generated vendored
View file

@ -35,10 +35,11 @@ const core = __importStar(__nccwpck_require__(2186));
const github = __importStar(__nccwpck_require__(5438));
const fs = __importStar(__nccwpck_require__(5747));
const fast_glob_1 = __importDefault(__nccwpck_require__(3664));
const get_annotations_1 = __nccwpck_require__(5867);
const get_report_1 = __nccwpck_require__(3737);
const dart_json_parser_1 = __nccwpck_require__(4528);
const dotnet_trx_parser_1 = __nccwpck_require__(2664);
const jest_junit_parser_1 = __nccwpck_require__(1113);
const get_report_1 = __nccwpck_require__(3737);
const file_utils_1 = __nccwpck_require__(2711);
const git_1 = __nccwpck_require__(9844);
const github_utils_1 = __nccwpck_require__(3522);
@ -81,23 +82,32 @@ async function main() {
const octokit = github.getOctokit(token);
const sha = github_utils_1.getCheckRunSha();
// We won't need tracked files if we are not going to create annotations
const annotations = maxAnnotations > 0;
const trackedFiles = annotations ? await git_1.listFiles() : [];
const opts = {
const parseErrors = maxAnnotations > 0;
const trackedFiles = parseErrors ? await git_1.listFiles() : [];
const options = {
trackedFiles,
workDir,
annotations
parseErrors
};
const parser = getParser(reporter);
core.info(`Using test report parser '${reporter}'`);
const parser = getParser(reporter, options);
const files = await getFiles(path);
if (files.length === 0) {
core.setFailed(`No file matches path '${path}'`);
return;
}
core.info(`Using test report parser '${reporter}'`);
const result = await parser(files, opts);
github_utils_1.enforceCheckRunLimits(result, maxAnnotations);
const isFailed = result.testRuns.some(tr => tr.result === 'failed');
const results = [];
for (const file of files) {
core.info(`Processing test report ${file}`);
const content = await fs.promises.readFile(file, { encoding: 'utf8' });
const tr = await parser.parse(file, content);
results.push(tr);
}
core.info('Creating report summary');
const summary = get_report_1.getReport(results, { listSuites, listTests });
core.info('Creating annotations');
const annotations = get_annotations_1.getAnnotations(results, maxAnnotations);
const isFailed = results.some(tr => tr.result === 'failed');
const conclusion = isFailed ? 'failure' : 'success';
const icon = isFailed ? markdown_utils_1.Icon.fail : markdown_utils_1.Icon.success;
core.info(`Creating check run '${name}' with conclusion '${conclusion}'`);
@ -108,38 +118,42 @@ async function main() {
status: 'completed',
output: {
title: `${name} ${icon}`,
summary: get_report_1.getReport(result.testRuns, { listSuites, listTests }),
annotations: result.annotations
summary,
annotations
},
...github.context.repo
});
const passed = results.reduce((sum, tr) => sum + tr.passed, 0);
const failed = results.reduce((sum, tr) => sum + tr.failed, 0);
const skipped = results.reduce((sum, tr) => sum + tr.skipped, 0);
const time = results.reduce((sum, tr) => sum + tr.time, 0);
core.setOutput('conclusion', conclusion);
core.setOutput('passed', passed);
core.setOutput('failed', failed);
core.setOutput('skipped', skipped);
core.setOutput('time', time);
if (failOnError && isFailed) {
core.setFailed(`Failed test has been found and 'fail-on-error' option is set to ${failOnError}`);
}
}
function getParser(reporter) {
function getParser(reporter, options) {
switch (reporter) {
case 'dart-json':
return dart_json_parser_1.parseDartJson;
return new dart_json_parser_1.DartJsonParser(options);
case 'dotnet-trx':
return dotnet_trx_parser_1.parseDotnetTrx;
return new dotnet_trx_parser_1.DotnetTrxParser(options);
case 'flutter-machine':
return dart_json_parser_1.parseDartJson;
return new dart_json_parser_1.DartJsonParser(options);
case 'jest-junit':
return jest_junit_parser_1.parseJestJunit;
return new jest_junit_parser_1.JestJunitParser(options);
default:
throw new Error(`Input variable 'reporter' is set to invalid value '${reporter}'`);
}
}
async function getFiles(pattern) {
const paths = (await Promise.all(pattern.split(',').map(async (pat) => fast_glob_1.default(pat, { dot: true })))).flat();
const files = Promise.all(paths.map(async (path) => {
core.info(`Reading test report '${path}'`);
const content = await fs.promises.readFile(path, { encoding: 'utf8' });
return { path, content };
}));
return files;
const tasks = pattern.split(',').map(async (pat) => fast_glob_1.default(pat, { dot: true }));
const paths = await Promise.all(tasks);
return paths.flat();
}
exports.getFiles = getFiles;
run();
@ -172,12 +186,11 @@ var __importStar = (this && this.__importStar) || function (mod) {
return result;
};
Object.defineProperty(exports, "__esModule", ({ value: true }));
exports.parseDartJson = void 0;
exports.DartJsonParser = void 0;
const core = __importStar(__nccwpck_require__(2186));
const file_utils_1 = __nccwpck_require__(2711);
const markdown_utils_1 = __nccwpck_require__(6482);
const dart_json_types_1 = __nccwpck_require__(7887);
const test_results_1 = __nccwpck_require__(8407);
const test_results_1 = __nccwpck_require__(2768);
class TestRun {
constructor(path, suites, success, time) {
this.path = path;
@ -220,148 +233,141 @@ class TestCase {
return this.testDone !== undefined ? this.testDone.time - this.testStart.time : 0;
}
}
async function parseDartJson(files, options) {
const testRuns = files.map(f => getTestRun(f.path, f.content));
const testRunsResults = testRuns.map(getTestRunResult);
return {
testRuns: testRunsResults,
annotations: options.annotations ? getAnnotations(testRuns, options.workDir, options.trackedFiles) : []
};
}
exports.parseDartJson = parseDartJson;
function getTestRun(path, content) {
core.info(`Parsing content of '${path}'`);
const lines = content.split(/\n\r?/g);
const events = lines
.map((str, i) => {
if (str.trim() === '') {
return null;
}
try {
return JSON.parse(str);
}
catch (e) {
const col = e.columnNumber !== undefined ? `:${e.columnNumber}` : '';
new Error(`Invalid JSON at ${path}:${i + 1}${col}\n\n${e}`);
}
})
.filter(evt => evt != null);
let success = false;
let totalTime = 0;
const suites = {};
const tests = {};
for (const evt of events) {
if (dart_json_types_1.isSuiteEvent(evt)) {
suites[evt.suite.id] = new TestSuite(evt.suite);
}
else if (dart_json_types_1.isGroupEvent(evt)) {
suites[evt.group.suiteID].groups[evt.group.id] = new TestGroup(evt.group);
}
else if (dart_json_types_1.isTestStartEvent(evt) && evt.test.url !== null) {
const test = new TestCase(evt);
const suite = suites[evt.test.suiteID];
const group = suite.groups[evt.test.groupIDs[evt.test.groupIDs.length - 1]];
group.tests.push(test);
tests[evt.test.id] = test;
}
else if (dart_json_types_1.isTestDoneEvent(evt) && !evt.hidden) {
tests[evt.testID].testDone = evt;
}
else if (dart_json_types_1.isErrorEvent(evt)) {
tests[evt.testID].error = evt;
}
else if (dart_json_types_1.isDoneEvent(evt)) {
success = evt.success;
totalTime = evt.time;
}
class DartJsonParser {
constructor(options) {
this.options = options;
}
return new TestRun(path, Object.values(suites), success, totalTime);
}
function getTestRunResult(tr) {
const suites = tr.suites.map(s => {
return new test_results_1.TestSuiteResult(s.suite.path, getGroups(s));
});
return new test_results_1.TestRunResult(tr.path, suites, tr.time);
}
function getGroups(suite) {
const groups = Object.values(suite.groups).filter(grp => grp.tests.length > 0);
groups.sort((a, b) => { var _a, _b; return ((_a = a.group.line) !== null && _a !== void 0 ? _a : 0) - ((_b = b.group.line) !== null && _b !== void 0 ? _b : 0); });
return groups.map(group => {
group.tests.sort((a, b) => { var _a, _b; return ((_a = a.testStart.test.line) !== null && _a !== void 0 ? _a : 0) - ((_b = b.testStart.test.line) !== null && _b !== void 0 ? _b : 0); });
const tests = group.tests.map(t => new test_results_1.TestCaseResult(t.testStart.test.name, t.result, t.time));
return new test_results_1.TestGroupResult(group.group.name, tests);
});
}
function getAnnotations(testRuns, workDir, trackedFiles) {
const annotations = [];
for (const tr of testRuns) {
for (const suite of tr.suites) {
for (const group of Object.values(suite.groups)) {
for (const test of group.tests) {
if (test.error) {
const err = getAnnotation(test, suite, workDir, trackedFiles);
if (err !== null) {
annotations.push(err);
}
}
async parse(path, content) {
const tr = this.getTestRun(path, content);
const result = this.getTestRunResult(tr);
return Promise.resolve(result);
}
getTestRun(path, content) {
core.info(`Parsing content of '${path}'`);
const lines = content.split(/\n\r?/g);
const events = lines
.map((str, i) => {
if (str.trim() === '') {
return null;
}
try {
return JSON.parse(str);
}
catch (e) {
const col = e.columnNumber !== undefined ? `:${e.columnNumber}` : '';
new Error(`Invalid JSON at ${path}:${i + 1}${col}\n\n${e}`);
}
})
.filter(evt => evt != null);
let success = false;
let totalTime = 0;
const suites = {};
const tests = {};
for (const evt of events) {
if (dart_json_types_1.isSuiteEvent(evt)) {
suites[evt.suite.id] = new TestSuite(evt.suite);
}
else if (dart_json_types_1.isGroupEvent(evt)) {
suites[evt.group.suiteID].groups[evt.group.id] = new TestGroup(evt.group);
}
else if (dart_json_types_1.isTestStartEvent(evt) && evt.test.url !== null) {
const test = new TestCase(evt);
const suite = suites[evt.test.suiteID];
const group = suite.groups[evt.test.groupIDs[evt.test.groupIDs.length - 1]];
group.tests.push(test);
tests[evt.test.id] = test;
}
else if (dart_json_types_1.isTestDoneEvent(evt) && !evt.hidden) {
tests[evt.testID].testDone = evt;
}
else if (dart_json_types_1.isErrorEvent(evt)) {
tests[evt.testID].error = evt;
}
else if (dart_json_types_1.isDoneEvent(evt)) {
success = evt.success;
totalTime = evt.time;
}
}
return new TestRun(path, Object.values(suites), success, totalTime);
}
getTestRunResult(tr) {
const suites = tr.suites.map(s => {
return new test_results_1.TestSuiteResult(s.suite.path, this.getGroups(s));
});
return new test_results_1.TestRunResult(tr.path, suites, tr.time);
}
getGroups(suite) {
const groups = Object.values(suite.groups).filter(grp => grp.tests.length > 0);
groups.sort((a, b) => { var _a, _b; return ((_a = a.group.line) !== null && _a !== void 0 ? _a : 0) - ((_b = b.group.line) !== null && _b !== void 0 ? _b : 0); });
return groups.map(group => {
group.tests.sort((a, b) => { var _a, _b; return ((_a = a.testStart.test.line) !== null && _a !== void 0 ? _a : 0) - ((_b = b.testStart.test.line) !== null && _b !== void 0 ? _b : 0); });
const tests = group.tests.map(t => this.getTest(t));
return new test_results_1.TestGroupResult(group.group.name, tests);
});
}
getTest(tc) {
const error = this.getError(tc);
return new test_results_1.TestCaseResult(tc.testStart.test.name, tc.result, tc.time, error);
}
getError(test) {
var _a, _b, _c, _d, _e, _f;
if (!this.options.parseErrors || !test.error) {
return undefined;
}
const { workDir, trackedFiles } = this.options;
const message = (_b = (_a = test.error) === null || _a === void 0 ? void 0 : _a.error) !== null && _b !== void 0 ? _b : '';
const stackTrace = (_d = (_c = test.error) === null || _c === void 0 ? void 0 : _c.stackTrace) !== null && _d !== void 0 ? _d : '';
const src = this.exceptionThrowSource(stackTrace, trackedFiles);
let path;
let line;
if (src !== undefined) {
;
(path = src.path), (line = src.line);
}
else {
const testStartPath = this.getRelativePathFromUrl((_e = test.testStart.test.url) !== null && _e !== void 0 ? _e : '', workDir);
if (trackedFiles.includes(testStartPath)) {
path = testStartPath;
}
line = (_f = test.testStart.test.line) !== null && _f !== void 0 ? _f : undefined;
}
return {
path,
line,
message,
stackTrace
};
}
exceptionThrowSource(ex, trackedFiles) {
// imports from package which is tested are listed in stack traces as 'package:xyz/' which maps to relative path 'lib/'
const packageRe = /^package:[a-zA-z0-9_$]+\//;
const lines = ex.split(/\r?\n/).map(str => str.replace(packageRe, 'lib/'));
// regexp to extract file path and line number from stack trace
const re = /^(.*)\s+(\d+):\d+\s+/;
for (const str of lines) {
const match = str.match(re);
if (match !== null) {
const [_, pathStr, lineStr] = match;
const path = file_utils_1.normalizeFilePath(pathStr);
if (trackedFiles.includes(path)) {
const line = parseInt(lineStr);
return { path, line };
}
}
}
}
return annotations;
}
function getAnnotation(test, testSuite, workDir, trackedFiles) {
var _a, _b, _c, _d, _e, _f;
const stack = (_b = (_a = test.error) === null || _a === void 0 ? void 0 : _a.stackTrace) !== null && _b !== void 0 ? _b : '';
let src = exceptionThrowSource(stack, trackedFiles);
if (src === null) {
const file = getRelativePathFromUrl((_c = test.testStart.test.url) !== null && _c !== void 0 ? _c : '', workDir);
if (!trackedFiles.includes(file)) {
return null;
getRelativePathFromUrl(file, workDir) {
const prefix = 'file:///';
if (file.startsWith(prefix)) {
file = file.substr(prefix.length);
}
src = {
file,
line: (_d = test.testStart.test.line) !== null && _d !== void 0 ? _d : 0
};
}
return {
annotation_level: 'failure',
start_line: src.line,
end_line: src.line,
path: src.file,
message: `${markdown_utils_1.fixEol((_e = test.error) === null || _e === void 0 ? void 0 : _e.error)}\n\n${markdown_utils_1.fixEol((_f = test.error) === null || _f === void 0 ? void 0 : _f.stackTrace)}`,
title: `[${testSuite.suite.path}] ${test.testStart.test.name}`
};
}
function exceptionThrowSource(ex, trackedFiles) {
// imports from package which is tested are listed in stack traces as 'package:xyz/' which maps to relative path 'lib/'
const packageRe = /^package:[a-zA-z0-9_$]+\//;
const lines = ex.split(/\r?\n/).map(str => str.replace(packageRe, 'lib/'));
// regexp to extract file path and line number from stack trace
const re = /^(.*)\s+(\d+):\d+\s+/;
for (const str of lines) {
const match = str.match(re);
if (match !== null) {
const [_, fileStr, lineStr] = match;
const file = file_utils_1.normalizeFilePath(fileStr);
if (trackedFiles.includes(file)) {
const line = parseInt(lineStr);
return { file, line };
}
if (file.startsWith(workDir)) {
file = file.substr(workDir.length);
}
return file;
}
return null;
}
function getRelativePathFromUrl(file, workdir) {
const prefix = 'file:///';
if (file.startsWith(prefix)) {
file = file.substr(prefix.length);
}
if (file.startsWith(workdir)) {
file = file.substr(workdir.length);
}
return file;
}
exports.DartJsonParser = DartJsonParser;
/***/ }),
@ -427,13 +433,12 @@ var __importStar = (this && this.__importStar) || function (mod) {
return result;
};
Object.defineProperty(exports, "__esModule", ({ value: true }));
exports.exceptionThrowSource = exports.parseDotnetTrx = void 0;
exports.DotnetTrxParser = void 0;
const core = __importStar(__nccwpck_require__(2186));
const xml2js_1 = __nccwpck_require__(6189);
const file_utils_1 = __nccwpck_require__(2711);
const markdown_utils_1 = __nccwpck_require__(6482);
const parse_utils_1 = __nccwpck_require__(7811);
const test_results_1 = __nccwpck_require__(8407);
const test_results_1 = __nccwpck_require__(2768);
class TestClass {
constructor(name) {
this.name = name;
@ -458,113 +463,109 @@ class Test {
}
}
}
async function parseDotnetTrx(files, options) {
const testRuns = [];
const testClasses = [];
for (const file of files) {
const trx = await getTrxReport(file);
const tc = getTestClasses(trx);
const tr = getTestRunResult(file.path, trx, tc);
testRuns.push(tr);
testClasses.push(...tc);
class DotnetTrxParser {
constructor(options) {
this.options = options;
}
return {
testRuns,
annotations: options.annotations ? getAnnotations(testClasses, options.workDir, options.trackedFiles) : []
};
}
exports.parseDotnetTrx = parseDotnetTrx;
async function getTrxReport(file) {
core.info(`Parsing content of '${file.path}'`);
try {
return (await xml2js_1.parseStringPromise(file.content));
async parse(path, content) {
const trx = await this.getTrxReport(path, content);
const tc = this.getTestClasses(trx);
const tr = this.getTestRunResult(path, trx, tc);
return tr;
}
catch (e) {
throw new Error(`Invalid XML at ${file.path}\n\n${e}`);
}
}
function getTestRunResult(path, trx, testClasses) {
const times = trx.TestRun.Times[0].$;
const totalTime = parse_utils_1.parseIsoDate(times.finish).getTime() - parse_utils_1.parseIsoDate(times.start).getTime();
const suites = testClasses.map(tc => {
const tests = tc.tests.map(t => new test_results_1.TestCaseResult(t.name, t.result, t.duration));
const group = new test_results_1.TestGroupResult(null, tests);
return new test_results_1.TestSuiteResult(tc.name, [group]);
});
return new test_results_1.TestRunResult(path, suites, totalTime);
}
function getTestClasses(trx) {
var _a;
const unitTests = {};
for (const td of trx.TestRun.TestDefinitions) {
for (const ut of td.UnitTest) {
unitTests[ut.$.id] = ut.TestMethod[0];
async getTrxReport(path, content) {
core.info(`Parsing content of '${path}'`);
try {
return (await xml2js_1.parseStringPromise(content));
}
catch (e) {
throw new Error(`Invalid XML at ${path}\n\n${e}`);
}
}
const unitTestsResults = trx.TestRun.Results.flatMap(r => r.UnitTestResult).flatMap(unitTestResult => ({
unitTestResult,
testMethod: unitTests[unitTestResult.$.testId]
}));
const testClasses = {};
for (const r of unitTestsResults) {
let tc = testClasses[r.testMethod.$.className];
if (tc === undefined) {
tc = new TestClass(r.testMethod.$.className);
testClasses[tc.name] = tc;
getTestClasses(trx) {
var _a;
const unitTests = {};
for (const td of trx.TestRun.TestDefinitions) {
for (const ut of td.UnitTest) {
unitTests[ut.$.id] = ut.TestMethod[0];
}
}
const output = r.unitTestResult.Output;
const error = (output === null || output === void 0 ? void 0 : output.length) > 0 && ((_a = output[0].ErrorInfo) === null || _a === void 0 ? void 0 : _a.length) > 0 ? output[0].ErrorInfo[0] : undefined;
const duration = parse_utils_1.parseNetDuration(r.unitTestResult.$.duration);
const test = new Test(r.testMethod.$.name, r.unitTestResult.$.outcome, duration, error);
tc.tests.push(test);
const unitTestsResults = trx.TestRun.Results.flatMap(r => r.UnitTestResult).flatMap(unitTestResult => ({
unitTestResult,
testMethod: unitTests[unitTestResult.$.testId]
}));
const testClasses = {};
for (const r of unitTestsResults) {
let tc = testClasses[r.testMethod.$.className];
if (tc === undefined) {
tc = new TestClass(r.testMethod.$.className);
testClasses[tc.name] = tc;
}
const output = r.unitTestResult.Output;
const error = (output === null || output === void 0 ? void 0 : output.length) > 0 && ((_a = output[0].ErrorInfo) === null || _a === void 0 ? void 0 : _a.length) > 0 ? output[0].ErrorInfo[0] : undefined;
const duration = parse_utils_1.parseNetDuration(r.unitTestResult.$.duration);
const test = new Test(r.testMethod.$.name, r.unitTestResult.$.outcome, duration, error);
tc.tests.push(test);
}
const result = Object.values(testClasses);
result.sort((a, b) => a.name.localeCompare(b.name));
for (const tc of result) {
tc.tests.sort((a, b) => a.name.localeCompare(b.name));
}
return result;
}
const result = Object.values(testClasses);
result.sort((a, b) => a.name.localeCompare(b.name));
for (const tc of result) {
tc.tests.sort((a, b) => a.name.localeCompare(b.name));
getTestRunResult(path, trx, testClasses) {
const times = trx.TestRun.Times[0].$;
const totalTime = parse_utils_1.parseIsoDate(times.finish).getTime() - parse_utils_1.parseIsoDate(times.start).getTime();
const suites = testClasses.map(testClass => {
const tests = testClass.tests.map(test => {
const error = this.getError(test);
return new test_results_1.TestCaseResult(test.name, test.result, test.duration, error);
});
const group = new test_results_1.TestGroupResult(null, tests);
return new test_results_1.TestSuiteResult(testClass.name, [group]);
});
return new test_results_1.TestRunResult(path, suites, totalTime);
}
return result;
}
function getAnnotations(testClasses, workDir, trackedFiles) {
const annotations = [];
for (const tc of testClasses) {
for (const t of tc.tests) {
if (t.error) {
const src = exceptionThrowSource(t.error.StackTrace[0], workDir, trackedFiles);
if (src === null) {
continue;
getError(test) {
if (!this.options.parseErrors || !test.error) {
return undefined;
}
const message = test.error.Message[0];
const stackTrace = test.error.StackTrace[0];
let path;
let line;
const src = this.exceptionThrowSource(stackTrace);
if (src) {
path = src.path;
line = src.line;
}
return {
path,
line,
message,
stackTrace: `${message}\n${stackTrace}`
};
}
exceptionThrowSource(stackTrace) {
const lines = stackTrace.split(/\r*\n/);
const re = / in (.+):line (\d+)$/;
const { workDir, trackedFiles } = this.options;
for (const str of lines) {
const match = str.match(re);
if (match !== null) {
const [_, fileStr, lineStr] = match;
const filePath = file_utils_1.normalizeFilePath(fileStr);
const file = filePath.startsWith(workDir) ? filePath.substr(workDir.length) : filePath;
if (trackedFiles.includes(file)) {
const line = parseInt(lineStr);
return { path: file, line };
}
annotations.push({
annotation_level: 'failure',
start_line: src.line,
end_line: src.line,
path: src.file,
message: markdown_utils_1.fixEol(t.error.Message[0]),
title: `[${tc.name}] ${t.name}`
});
}
}
}
return annotations;
}
function exceptionThrowSource(ex, workDir, trackedFiles) {
const lines = ex.split(/\r*\n/);
const re = / in (.+):line (\d+)$/;
for (const str of lines) {
const match = str.match(re);
if (match !== null) {
const [_, fileStr, lineStr] = match;
const filePath = file_utils_1.normalizeFilePath(fileStr);
const file = filePath.startsWith(workDir) ? filePath.substr(workDir.length) : filePath;
if (trackedFiles.includes(file)) {
const line = parseInt(lineStr);
return { file, line };
}
}
}
return null;
}
exports.exceptionThrowSource = exceptionThrowSource;
exports.DotnetTrxParser = DotnetTrxParser;
/***/ }),
@ -594,119 +595,194 @@ var __importStar = (this && this.__importStar) || function (mod) {
return result;
};
Object.defineProperty(exports, "__esModule", ({ value: true }));
exports.exceptionThrowSource = exports.parseJestJunit = void 0;
exports.JestJunitParser = void 0;
const core = __importStar(__nccwpck_require__(2186));
const xml2js_1 = __nccwpck_require__(6189);
const markdown_utils_1 = __nccwpck_require__(6482);
const file_utils_1 = __nccwpck_require__(2711);
const test_results_1 = __nccwpck_require__(8407);
async function parseJestJunit(files, options) {
const junit = [];
const testRuns = [];
for (const file of files) {
const ju = await getJunitReport(file);
const tr = getTestRunResult(file.path, ju);
junit.push(ju);
testRuns.push(tr);
const test_results_1 = __nccwpck_require__(2768);
class JestJunitParser {
constructor(options) {
this.options = options;
}
return {
testRuns,
annotations: options.annotations ? getAnnotations(junit, options.workDir, options.trackedFiles) : []
};
}
exports.parseJestJunit = parseJestJunit;
async function getJunitReport(file) {
core.info(`Parsing content of '${file.path}'`);
try {
return (await xml2js_1.parseStringPromise(file.content));
async parse(path, content) {
const ju = await this.getJunitReport(path, content);
return this.getTestRunResult(path, ju);
}
catch (e) {
throw new Error(`Invalid XML at ${file.path}\n\n${e}`);
}
}
function getTestRunResult(path, junit) {
const suites = junit.testsuites.testsuite.map(ts => {
const name = ts.$.name.trim();
const time = parseFloat(ts.$.time) * 1000;
const sr = new test_results_1.TestSuiteResult(name, getGroups(ts), time);
return sr;
});
const time = parseFloat(junit.testsuites.$.time) * 1000;
return new test_results_1.TestRunResult(path, suites, time);
}
function getGroups(suite) {
const groups = [];
for (const tc of suite.testcase) {
let grp = groups.find(g => g.describe === tc.$.classname);
if (grp === undefined) {
grp = { describe: tc.$.classname, tests: [] };
groups.push(grp);
async getJunitReport(path, content) {
core.info(`Parsing content of '${path}'`);
try {
return (await xml2js_1.parseStringPromise(content));
}
catch (e) {
throw new Error(`Invalid XML at ${path}\n\n${e}`);
}
grp.tests.push(tc);
}
return groups.map(grp => {
const tests = grp.tests.map(tc => {
const name = tc.$.name.trim();
const result = getTestCaseResult(tc);
const time = parseFloat(tc.$.time) * 1000;
return new test_results_1.TestCaseResult(name, result, time);
getTestRunResult(path, junit) {
const suites = junit.testsuites.testsuite.map(ts => {
const name = ts.$.name.trim();
const time = parseFloat(ts.$.time) * 1000;
const sr = new test_results_1.TestSuiteResult(name, this.getGroups(ts), time);
return sr;
});
return new test_results_1.TestGroupResult(grp.describe, tests);
});
}
function getTestCaseResult(test) {
if (test.failure)
return 'failed';
if (test.skipped)
return 'skipped';
return 'success';
}
function getAnnotations(junitReports, workDir, trackedFiles) {
const annotations = [];
for (const junit of junitReports) {
for (const suite of junit.testsuites.testsuite) {
for (const tc of suite.testcase) {
if (!tc.failure) {
continue;
const time = parseFloat(junit.testsuites.$.time) * 1000;
return new test_results_1.TestRunResult(path, suites, time);
}
getGroups(suite) {
const groups = [];
for (const tc of suite.testcase) {
let grp = groups.find(g => g.describe === tc.$.classname);
if (grp === undefined) {
grp = { describe: tc.$.classname, tests: [] };
groups.push(grp);
}
grp.tests.push(tc);
}
return groups.map(grp => {
const tests = grp.tests.map(tc => {
const name = tc.$.name.trim();
const result = this.getTestCaseResult(tc);
const time = parseFloat(tc.$.time) * 1000;
const error = this.getTestCaseError(tc);
return new test_results_1.TestCaseResult(name, result, time, error);
});
return new test_results_1.TestGroupResult(grp.describe, tests);
});
}
getTestCaseResult(test) {
if (test.failure)
return 'failed';
if (test.skipped)
return 'skipped';
return 'success';
}
getTestCaseError(tc) {
if (!this.options.parseErrors || !tc.failure) {
return undefined;
}
const stackTrace = tc.failure[0];
let path;
let line;
const src = this.exceptionThrowSource(stackTrace);
if (src) {
path = src.path;
line = src.line;
}
return {
path,
line,
stackTrace
};
}
exceptionThrowSource(stackTrace) {
const lines = stackTrace.split(/\r?\n/);
const re = /\((.*):(\d+):\d+\)$/;
const { workDir, trackedFiles } = this.options;
for (const str of lines) {
const match = str.match(re);
if (match !== null) {
const [_, fileStr, lineStr] = match;
const filePath = file_utils_1.normalizeFilePath(fileStr);
const path = filePath.startsWith(workDir) ? filePath.substr(workDir.length) : filePath;
if (trackedFiles.includes(path)) {
const line = parseInt(lineStr);
return { path, line };
}
for (const ex of tc.failure) {
const src = exceptionThrowSource(ex, workDir, trackedFiles);
if (src === null) {
}
}
}
}
exports.JestJunitParser = JestJunitParser;
/***/ }),
/***/ 5867:
/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
"use strict";
Object.defineProperty(exports, "__esModule", ({ value: true }));
exports.getAnnotations = void 0;
const markdown_utils_1 = __nccwpck_require__(6482);
function getAnnotations(results, maxCount) {
var _a, _b, _c, _d;
if (maxCount === 0) {
return [];
}
// Collect errors from TestRunResults
// Merge duplicates if there are more test results files processed
const errors = [];
const mergeDup = results.length > 1;
for (const tr of results) {
for (const ts of tr.suites) {
for (const tg of ts.groups) {
for (const tc of tg.tests) {
const err = tc.error;
if (err === undefined) {
continue;
}
annotations.push({
annotation_level: 'failure',
start_line: src.line,
end_line: src.line,
path: src.file,
message: markdown_utils_1.fixEol(ex),
title: `[${suite.$.name}] ${tc.$.name.trim()}`
const path = (_a = err.path) !== null && _a !== void 0 ? _a : tr.path;
const line = (_b = err.line) !== null && _b !== void 0 ? _b : 0;
if (mergeDup) {
const dup = errors.find(e => path === e.path && line === e.line && err.stackTrace === e.stackTrace);
if (dup !== undefined) {
dup.testRunPaths.push(tr.path);
continue;
}
}
errors.push({
testRunPaths: [tr.path],
suiteName: ts.name,
testName: tc.name,
stackTrace: err.stackTrace,
message: (_d = (_c = err.message) !== null && _c !== void 0 ? _c : getFirstNonEmptyLine(err.stackTrace)) !== null && _d !== void 0 ? _d : 'Test failed',
path,
line
});
}
}
}
}
// Limit number of created annotations
errors.splice(maxCount + 1);
const annotations = errors.map(e => {
const message = [
'Failed test found in:',
e.testRunPaths.map(p => ` ${p}`).join('\n'),
'Error:',
ident(markdown_utils_1.fixEol(e.message), ' ')
].join('\n');
return enforceCheckRunLimits({
path: e.path,
start_line: e.line,
end_line: e.line,
annotation_level: 'failure',
title: `${e.suiteName} ► ${e.testName}`,
raw_details: markdown_utils_1.fixEol(e.stackTrace),
message
});
});
return annotations;
}
function exceptionThrowSource(ex, workDir, trackedFiles) {
const lines = ex.split(/\r?\n/);
const re = /\((.*):(\d+):(\d+)\)$/;
for (const str of lines) {
const match = str.match(re);
if (match !== null) {
const [_, fileStr, lineStr, colStr] = match;
const filePath = file_utils_1.normalizeFilePath(fileStr);
const file = filePath.startsWith(workDir) ? filePath.substr(workDir.length) : filePath;
if (trackedFiles.includes(file)) {
const line = parseInt(lineStr);
const column = parseInt(colStr);
return { file, line, column };
}
}
exports.getAnnotations = getAnnotations;
function enforceCheckRunLimits(err) {
err.title = markdown_utils_1.ellipsis(err.title || '', 255);
err.message = markdown_utils_1.ellipsis(err.message, 65535);
if (err.raw_details) {
err.raw_details = markdown_utils_1.ellipsis(err.raw_details, 65535);
}
return null;
return err;
}
function getFirstNonEmptyLine(stackTrace) {
const lines = stackTrace.split(/\r?\n/g);
return lines.find(str => !/^\s*$/.test(str));
}
function ident(text, prefix) {
return text
.split(/\n/g)
.map(line => prefix + line)
.join('\n');
}
exports.exceptionThrowSource = exceptionThrowSource;
/***/ }),
@ -824,7 +900,7 @@ function getSuitesReport(tr, runIndex, options) {
const nameLink = `<a id="${trSlug.id}" href="${trSlug.link}">${tr.path}</a>`;
const icon = getResultIcon(tr.result);
sections.push(`## ${nameLink} ${icon}`);
const time = `${(tr.time / 1000).toFixed(3)}s`;
const time = markdown_utils_1.formatTime(tr.time);
const headingLine2 = `**${tr.tests}** tests were completed in **${time}** with **${tr.passed}** passed, **${tr.failed}** failed and **${tr.skipped}** skipped.`;
sections.push(headingLine2);
const suites = options.listSuites === 'failed' ? tr.failedSuites : tr.suites;
@ -861,7 +937,8 @@ function getTestsReport(ts, runIndex, suiteIndex, options) {
const tsNameLink = `<a id="${tsSlug.id}" href="${tsSlug.link}">${tsName}</a>`;
const icon = getResultIcon(ts.result);
sections.push(`### ${tsNameLink} ${icon}`);
const headingLine2 = `**${ts.tests}** tests were completed in **${ts.time}ms** with **${ts.passed}** passed, **${ts.failed}** failed and **${ts.skipped}** skipped.`;
const tsTime = markdown_utils_1.formatTime(ts.time);
const headingLine2 = `**${ts.tests}** tests were completed in **${tsTime}** with **${ts.passed}** passed, **${ts.failed}** failed and **${ts.skipped}** skipped.`;
sections.push(headingLine2);
for (const grp of groups) {
const tests = options.listTests === 'failed' ? grp.failedTests : grp.tests;
@ -903,7 +980,7 @@ function getResultIcon(result) {
/***/ }),
/***/ 8407:
/***/ 2768:
/***/ ((__unused_webpack_module, exports) => {
"use strict";
@ -996,10 +1073,11 @@ class TestGroupResult {
}
exports.TestGroupResult = TestGroupResult;
class TestCaseResult {
constructor(name, result, time) {
constructor(name, result, time, error) {
this.name = name;
this.result = result;
this.time = time;
this.error = error;
}
}
exports.TestCaseResult = TestCaseResult;
@ -1140,9 +1218,8 @@ var __importStar = (this && this.__importStar) || function (mod) {
return result;
};
Object.defineProperty(exports, "__esModule", ({ value: true }));
exports.enforceCheckRunLimits = exports.getCheckRunSha = void 0;
exports.getCheckRunSha = void 0;
const github = __importStar(__nccwpck_require__(5438));
const markdown_utils_1 = __nccwpck_require__(6482);
function getCheckRunSha() {
if (github.context.payload.pull_request) {
const pr = github.context.payload.pull_request;
@ -1151,16 +1228,6 @@ function getCheckRunSha() {
return github.context.sha;
}
exports.getCheckRunSha = getCheckRunSha;
function enforceCheckRunLimits(result, maxAnnotations) {
// Limit number of created annotations
result.annotations.splice(maxAnnotations + 1);
// Limit number of characters in annotation fields
for (const err of result.annotations) {
err.title = markdown_utils_1.ellipsis(err.title || '', 255);
err.message = markdown_utils_1.ellipsis(err.message, 65535);
}
}
exports.enforceCheckRunLimits = enforceCheckRunLimits;
/***/ }),

2
dist/index.js.map generated vendored
View file

File diff suppressed because one or more lines are too long

86
src/main.ts
View file

@ -2,14 +2,19 @@ import * as core from '@actions/core'
import * as github from '@actions/github'
import * as fs from 'fs'
import glob from 'fast-glob'
import {parseDartJson} from './parsers/dart-json/dart-json-parser'
import {parseDotnetTrx} from './parsers/dotnet-trx/dotnet-trx-parser'
import {parseJestJunit} from './parsers/jest-junit/jest-junit-parser'
import {ParseOptions, TestParser} from './test-parser'
import {TestRunResult} from './test-results'
import {getAnnotations} from './report/get-annotations'
import {getReport} from './report/get-report'
import {FileContent, ParseOptions, ParseTestResult} from './parsers/parser-types'
import {DartJsonParser} from './parsers/dart-json/dart-json-parser'
import {DotnetTrxParser} from './parsers/dotnet-trx/dotnet-trx-parser'
import {JestJunitParser} from './parsers/jest-junit/jest-junit-parser'
import {normalizeDirPath} from './utils/file-utils'
import {listFiles} from './utils/git'
import {enforceCheckRunLimits, getCheckRunSha} from './utils/github-utils'
import {getCheckRunSha} from './utils/github-utils'
import {Icon} from './utils/markdown-utils'
async function run(): Promise<void> {
@ -56,28 +61,39 @@ async function main(): Promise<void> {
const sha = getCheckRunSha()
// We won't need tracked files if we are not going to create annotations
const annotations = maxAnnotations > 0
const trackedFiles = annotations ? await listFiles() : []
const parseErrors = maxAnnotations > 0
const trackedFiles = parseErrors ? await listFiles() : []
const opts: ParseOptions = {
const options: ParseOptions = {
trackedFiles,
workDir,
annotations
parseErrors
}
const parser = getParser(reporter)
const files = await getFiles(path)
core.info(`Using test report parser '${reporter}'`)
const parser = getParser(reporter, options)
const files = await getFiles(path)
if (files.length === 0) {
core.setFailed(`No file matches path '${path}'`)
return
}
core.info(`Using test report parser '${reporter}'`)
const result = await parser(files, opts)
const results: TestRunResult[] = []
for (const file of files) {
core.info(`Processing test report ${file}`)
const content = await fs.promises.readFile(file, {encoding: 'utf8'})
const tr = await parser.parse(file, content)
results.push(tr)
}
enforceCheckRunLimits(result, maxAnnotations)
const isFailed = result.testRuns.some(tr => tr.result === 'failed')
core.info('Creating report summary')
const summary = getReport(results, {listSuites, listTests})
core.info('Creating annotations')
const annotations = getAnnotations(results, maxAnnotations)
const isFailed = results.some(tr => tr.result === 'failed')
const conclusion = isFailed ? 'failure' : 'success'
const icon = isFailed ? Icon.fail : Icon.success
@ -89,45 +105,47 @@ async function main(): Promise<void> {
status: 'completed',
output: {
title: `${name} ${icon}`,
summary: getReport(result.testRuns, {listSuites, listTests}),
annotations: result.annotations
summary,
annotations
},
...github.context.repo
})
const passed = results.reduce((sum, tr) => sum + tr.passed, 0)
const failed = results.reduce((sum, tr) => sum + tr.failed, 0)
const skipped = results.reduce((sum, tr) => sum + tr.skipped, 0)
const time = results.reduce((sum, tr) => sum + tr.time, 0)
core.setOutput('conclusion', conclusion)
core.setOutput('passed', passed)
core.setOutput('failed', failed)
core.setOutput('skipped', skipped)
core.setOutput('time', time)
if (failOnError && isFailed) {
core.setFailed(`Failed test has been found and 'fail-on-error' option is set to ${failOnError}`)
}
}
function getParser(reporter: string): ParseTestResult {
function getParser(reporter: string, options: ParseOptions): TestParser {
switch (reporter) {
case 'dart-json':
return parseDartJson
return new DartJsonParser(options)
case 'dotnet-trx':
return parseDotnetTrx
return new DotnetTrxParser(options)
case 'flutter-machine':
return parseDartJson
return new DartJsonParser(options)
case 'jest-junit':
return parseJestJunit
return new JestJunitParser(options)
default:
throw new Error(`Input variable 'reporter' is set to invalid value '${reporter}'`)
}
}
export async function getFiles(pattern: string): Promise<FileContent[]> {
const paths = (await Promise.all(pattern.split(',').map(async pat => glob(pat, {dot: true})))).flat()
const files = Promise.all(
paths.map(async path => {
core.info(`Reading test report '${path}'`)
const content = await fs.promises.readFile(path, {encoding: 'utf8'})
return {path, content}
})
)
return files
export async function getFiles(pattern: string): Promise<string[]> {
const tasks = pattern.split(',').map(async pat => glob(pat, {dot: true}))
const paths = await Promise.all(tasks)
return paths.flat()
}
run()

264
src/parsers/dart-json/dart-json-parser.ts
View file

@ -1,8 +1,7 @@
import * as core from '@actions/core'
import {Annotation, FileContent, ParseOptions, TestResult} from '../parser-types'
import {ParseOptions, TestParser} from '../../test-parser'
import {normalizeFilePath} from '../../utils/file-utils'
import {fixEol} from '../../utils/markdown-utils'
import {
ReportEvent,
@ -24,8 +23,9 @@ import {
TestRunResult,
TestSuiteResult,
TestGroupResult,
TestCaseResult
} from '../../report/test-results'
TestCaseResult,
TestCaseError
} from '../../test-results'
class TestRun {
constructor(readonly path: string, readonly suites: TestSuite[], readonly success: boolean, readonly time: number) {}
@ -68,159 +68,143 @@ class TestCase {
}
}
export async function parseDartJson(files: FileContent[], options: ParseOptions): Promise<TestResult> {
const testRuns = files.map(f => getTestRun(f.path, f.content))
const testRunsResults = testRuns.map(getTestRunResult)
export class DartJsonParser implements TestParser {
constructor(readonly options: ParseOptions) {}
return {
testRuns: testRunsResults,
annotations: options.annotations ? getAnnotations(testRuns, options.workDir, options.trackedFiles) : []
async parse(path: string, content: string): Promise<TestRunResult> {
const tr = this.getTestRun(path, content)
const result = this.getTestRunResult(tr)
return Promise.resolve(result)
}
}
function getTestRun(path: string, content: string): TestRun {
core.info(`Parsing content of '${path}'`)
const lines = content.split(/\n\r?/g)
const events = lines
.map((str, i) => {
if (str.trim() === '') {
return null
}
try {
return JSON.parse(str)
} catch (e) {
const col = e.columnNumber !== undefined ? `:${e.columnNumber}` : ''
new Error(`Invalid JSON at ${path}:${i + 1}${col}\n\n${e}`)
private getTestRun(path: string, content: string): TestRun {
core.info(`Parsing content of '${path}'`)
const lines = content.split(/\n\r?/g)
const events = lines
.map((str, i) => {
if (str.trim() === '') {
return null
}
try {
return JSON.parse(str)
} catch (e) {
const col = e.columnNumber !== undefined ? `:${e.columnNumber}` : ''
new Error(`Invalid JSON at ${path}:${i + 1}${col}\n\n${e}`)
}
})
.filter(evt => evt != null) as ReportEvent[]
let success = false
let totalTime = 0
const suites: {[id: number]: TestSuite} = {}
const tests: {[id: number]: TestCase} = {}
for (const evt of events) {
if (isSuiteEvent(evt)) {
suites[evt.suite.id] = new TestSuite(evt.suite)
} else if (isGroupEvent(evt)) {
suites[evt.group.suiteID].groups[evt.group.id] = new TestGroup(evt.group)
} else if (isTestStartEvent(evt) && evt.test.url !== null) {
const test: TestCase = new TestCase(evt)
const suite = suites[evt.test.suiteID]
const group = suite.groups[evt.test.groupIDs[evt.test.groupIDs.length - 1]]
group.tests.push(test)
tests[evt.test.id] = test
} else if (isTestDoneEvent(evt) && !evt.hidden) {
tests[evt.testID].testDone = evt
} else if (isErrorEvent(evt)) {
tests[evt.testID].error = evt
} else if (isDoneEvent(evt)) {
success = evt.success
totalTime = evt.time
}
}
return new TestRun(path, Object.values(suites), success, totalTime)
}
private getTestRunResult(tr: TestRun): TestRunResult {
const suites = tr.suites.map(s => {
return new TestSuiteResult(s.suite.path, this.getGroups(s))
})
.filter(evt => evt != null) as ReportEvent[]
let success = false
let totalTime = 0
const suites: {[id: number]: TestSuite} = {}
const tests: {[id: number]: TestCase} = {}
return new TestRunResult(tr.path, suites, tr.time)
}
for (const evt of events) {
if (isSuiteEvent(evt)) {
suites[evt.suite.id] = new TestSuite(evt.suite)
} else if (isGroupEvent(evt)) {
suites[evt.group.suiteID].groups[evt.group.id] = new TestGroup(evt.group)
} else if (isTestStartEvent(evt) && evt.test.url !== null) {
const test: TestCase = new TestCase(evt)
const suite = suites[evt.test.suiteID]
const group = suite.groups[evt.test.groupIDs[evt.test.groupIDs.length - 1]]
group.tests.push(test)
tests[evt.test.id] = test
} else if (isTestDoneEvent(evt) && !evt.hidden) {
tests[evt.testID].testDone = evt
} else if (isErrorEvent(evt)) {
tests[evt.testID].error = evt
} else if (isDoneEvent(evt)) {
success = evt.success
totalTime = evt.time
private getGroups(suite: TestSuite): TestGroupResult[] {
const groups = Object.values(suite.groups).filter(grp => grp.tests.length > 0)
groups.sort((a, b) => (a.group.line ?? 0) - (b.group.line ?? 0))
return groups.map(group => {
group.tests.sort((a, b) => (a.testStart.test.line ?? 0) - (b.testStart.test.line ?? 0))
const tests = group.tests.map(t => this.getTest(t))
return new TestGroupResult(group.group.name, tests)
})
}
private getTest(tc: TestCase): TestCaseResult {
const error = this.getError(tc)
return new TestCaseResult(tc.testStart.test.name, tc.result, tc.time, error)
}
private getError(test: TestCase): TestCaseError | undefined {
if (!this.options.parseErrors || !test.error) {
return undefined
}
const {workDir, trackedFiles} = this.options
const message = test.error?.error ?? ''
const stackTrace = test.error?.stackTrace ?? ''
const src = this.exceptionThrowSource(stackTrace, trackedFiles)
let path
let line
if (src !== undefined) {
;(path = src.path), (line = src.line)
} else {
const testStartPath = this.getRelativePathFromUrl(test.testStart.test.url ?? '', workDir)
if (trackedFiles.includes(testStartPath)) {
path = testStartPath
}
line = test.testStart.test.line ?? undefined
}
return {
path,
line,
message,
stackTrace
}
}
return new TestRun(path, Object.values(suites), success, totalTime)
}
private exceptionThrowSource(ex: string, trackedFiles: string[]): {path: string; line: number} | undefined {
// imports from package which is tested are listed in stack traces as 'package:xyz/' which maps to relative path 'lib/'
const packageRe = /^package:[a-zA-z0-9_$]+\//
const lines = ex.split(/\r?\n/).map(str => str.replace(packageRe, 'lib/'))
function getTestRunResult(tr: TestRun): TestRunResult {
const suites = tr.suites.map(s => {
return new TestSuiteResult(s.suite.path, getGroups(s))
})
return new TestRunResult(tr.path, suites, tr.time)
}
function getGroups(suite: TestSuite): TestGroupResult[] {
const groups = Object.values(suite.groups).filter(grp => grp.tests.length > 0)
groups.sort((a, b) => (a.group.line ?? 0) - (b.group.line ?? 0))
return groups.map(group => {
group.tests.sort((a, b) => (a.testStart.test.line ?? 0) - (b.testStart.test.line ?? 0))
const tests = group.tests.map(t => new TestCaseResult(t.testStart.test.name, t.result, t.time))
return new TestGroupResult(group.group.name, tests)
})
}
function getAnnotations(testRuns: TestRun[], workDir: string, trackedFiles: string[]): Annotation[] {
const annotations: Annotation[] = []
for (const tr of testRuns) {
for (const suite of tr.suites) {
for (const group of Object.values(suite.groups)) {
for (const test of group.tests) {
if (test.error) {
const err = getAnnotation(test, suite, workDir, trackedFiles)
if (err !== null) {
annotations.push(err)
}
}
// regexp to extract file path and line number from stack trace
const re = /^(.*)\s+(\d+):\d+\s+/
for (const str of lines) {
const match = str.match(re)
if (match !== null) {
const [_, pathStr, lineStr] = match
const path = normalizeFilePath(pathStr)
if (trackedFiles.includes(path)) {
const line = parseInt(lineStr)
return {path, line}
}
}
}
}
return annotations
}
function getAnnotation(
test: TestCase,
testSuite: TestSuite,
workDir: string,
trackedFiles: string[]
): Annotation | null {
const stack = test.error?.stackTrace ?? ''
let src = exceptionThrowSource(stack, trackedFiles)
if (src === null) {
const file = getRelativePathFromUrl(test.testStart.test.url ?? '', workDir)
if (!trackedFiles.includes(file)) {
return null
private getRelativePathFromUrl(file: string, workDir: string): string {
const prefix = 'file:///'
if (file.startsWith(prefix)) {
file = file.substr(prefix.length)
}
src = {
file,
line: test.testStart.test.line ?? 0
if (file.startsWith(workDir)) {
file = file.substr(workDir.length)
}
}
return {
annotation_level: 'failure',
start_line: src.line,
end_line: src.line,
path: src.file,
message: `${fixEol(test.error?.error)}\n\n${fixEol(test.error?.stackTrace)}`,
title: `[${testSuite.suite.path}] ${test.testStart.test.name}`
return file
}
}
function exceptionThrowSource(ex: string, trackedFiles: string[]): {file: string; line: number} | null {
// imports from package which is tested are listed in stack traces as 'package:xyz/' which maps to relative path 'lib/'
const packageRe = /^package:[a-zA-z0-9_$]+\//
const lines = ex.split(/\r?\n/).map(str => str.replace(packageRe, 'lib/'))
// regexp to extract file path and line number from stack trace
const re = /^(.*)\s+(\d+):\d+\s+/
for (const str of lines) {
const match = str.match(re)
if (match !== null) {
const [_, fileStr, lineStr] = match
const file = normalizeFilePath(fileStr)
if (trackedFiles.includes(file)) {
const line = parseInt(lineStr)
return {file, line}
}
}
}
return null
}
function getRelativePathFromUrl(file: string, workdir: string): string {
const prefix = 'file:///'
if (file.startsWith(prefix)) {
file = file.substr(prefix.length)
}
if (file.startsWith(workdir)) {
file = file.substr(workdir.length)
}
return file
}

214
src/parsers/dotnet-trx/dotnet-trx-parser.ts
View file

@ -1,11 +1,10 @@
import * as core from '@actions/core'
import {ErrorInfo, Outcome, TestMethod, TrxReport} from './dotnet-trx-types'
import {Annotation, FileContent, ParseOptions, TestResult} from '../parser-types'
import {parseStringPromise} from 'xml2js'
import {ErrorInfo, Outcome, TestMethod, TrxReport} from './dotnet-trx-types'
import {ParseOptions, TestParser} from '../../test-parser'
import {normalizeFilePath} from '../../utils/file-utils'
import {fixEol} from '../../utils/markdown-utils'
import {parseIsoDate, parseNetDuration} from '../../utils/parse-utils'
import {
@ -13,8 +12,9 @@ import {
TestRunResult,
TestSuiteResult,
TestGroupResult,
TestCaseResult
} from '../../report/test-results'
TestCaseResult,
TestCaseError
} from '../../test-results'
class TestClass {
constructor(readonly name: string) {}
@ -41,125 +41,117 @@ class Test {
}
}
export async function parseDotnetTrx(files: FileContent[], options: ParseOptions): Promise<TestResult> {
const testRuns: TestRunResult[] = []
const testClasses: TestClass[] = []
export class DotnetTrxParser implements TestParser {
constructor(readonly options: ParseOptions) {}
for (const file of files) {
const trx = await getTrxReport(file)
const tc = getTestClasses(trx)
const tr = getTestRunResult(file.path, trx, tc)
testRuns.push(tr)
testClasses.push(...tc)
async parse(path: string, content: string): Promise<TestRunResult> {
const trx = await this.getTrxReport(path, content)
const tc = this.getTestClasses(trx)
const tr = this.getTestRunResult(path, trx, tc)
return tr
}
return {
testRuns,
annotations: options.annotations ? getAnnotations(testClasses, options.workDir, options.trackedFiles) : []
}
}
async function getTrxReport(file: FileContent): Promise<TrxReport> {
core.info(`Parsing content of '${file.path}'`)
try {
return (await parseStringPromise(file.content)) as TrxReport
} catch (e) {
throw new Error(`Invalid XML at ${file.path}\n\n${e}`)
}
}
function getTestRunResult(path: string, trx: TrxReport, testClasses: TestClass[]): TestRunResult {
const times = trx.TestRun.Times[0].$
const totalTime = parseIsoDate(times.finish).getTime() - parseIsoDate(times.start).getTime()
const suites = testClasses.map(tc => {
const tests = tc.tests.map(t => new TestCaseResult(t.name, t.result, t.duration))
const group = new TestGroupResult(null, tests)
return new TestSuiteResult(tc.name, [group])
})
return new TestRunResult(path, suites, totalTime)
}
function getTestClasses(trx: TrxReport): TestClass[] {
const unitTests: {[id: string]: TestMethod} = {}
for (const td of trx.TestRun.TestDefinitions) {
for (const ut of td.UnitTest) {
unitTests[ut.$.id] = ut.TestMethod[0]
private async getTrxReport(path: string, content: string): Promise<TrxReport> {
core.info(`Parsing content of '${path}'`)
try {
return (await parseStringPromise(content)) as TrxReport
} catch (e) {
throw new Error(`Invalid XML at ${path}\n\n${e}`)
}
}
const unitTestsResults = trx.TestRun.Results.flatMap(r => r.UnitTestResult).flatMap(unitTestResult => ({
unitTestResult,
testMethod: unitTests[unitTestResult.$.testId]
}))
const testClasses: {[name: string]: TestClass} = {}
for (const r of unitTestsResults) {
let tc = testClasses[r.testMethod.$.className]
if (tc === undefined) {
tc = new TestClass(r.testMethod.$.className)
testClasses[tc.name] = tc
private getTestClasses(trx: TrxReport): TestClass[] {
const unitTests: {[id: string]: TestMethod} = {}
for (const td of trx.TestRun.TestDefinitions) {
for (const ut of td.UnitTest) {
unitTests[ut.$.id] = ut.TestMethod[0]
}
}
const output = r.unitTestResult.Output
const error = output?.length > 0 && output[0].ErrorInfo?.length > 0 ? output[0].ErrorInfo[0] : undefined
const duration = parseNetDuration(r.unitTestResult.$.duration)
const test = new Test(r.testMethod.$.name, r.unitTestResult.$.outcome, duration, error)
tc.tests.push(test)
const unitTestsResults = trx.TestRun.Results.flatMap(r => r.UnitTestResult).flatMap(unitTestResult => ({
unitTestResult,
testMethod: unitTests[unitTestResult.$.testId]
}))
const testClasses: {[name: string]: TestClass} = {}
for (const r of unitTestsResults) {
let tc = testClasses[r.testMethod.$.className]
if (tc === undefined) {
tc = new TestClass(r.testMethod.$.className)
testClasses[tc.name] = tc
}
const output = r.unitTestResult.Output
const error = output?.length > 0 && output[0].ErrorInfo?.length > 0 ? output[0].ErrorInfo[0] : undefined
const duration = parseNetDuration(r.unitTestResult.$.duration)
const test = new Test(r.testMethod.$.name, r.unitTestResult.$.outcome, duration, error)
tc.tests.push(test)
}
const result = Object.values(testClasses)
result.sort((a, b) => a.name.localeCompare(b.name))
for (const tc of result) {
tc.tests.sort((a, b) => a.name.localeCompare(b.name))
}
return result
}
const result = Object.values(testClasses)
result.sort((a, b) => a.name.localeCompare(b.name))
for (const tc of result) {
tc.tests.sort((a, b) => a.name.localeCompare(b.name))
private getTestRunResult(path: string, trx: TrxReport, testClasses: TestClass[]): TestRunResult {
const times = trx.TestRun.Times[0].$
const totalTime = parseIsoDate(times.finish).getTime() - parseIsoDate(times.start).getTime()
const suites = testClasses.map(testClass => {
const tests = testClass.tests.map(test => {
const error = this.getError(test)
return new TestCaseResult(test.name, test.result, test.duration, error)
})
const group = new TestGroupResult(null, tests)
return new TestSuiteResult(testClass.name, [group])
})
return new TestRunResult(path, suites, totalTime)
}
return result
}
private getError(test: Test): TestCaseError | undefined {
if (!this.options.parseErrors || !test.error) {
return undefined
}
function getAnnotations(testClasses: TestClass[], workDir: string, trackedFiles: string[]): Annotation[] {
const annotations: Annotation[] = []
for (const tc of testClasses) {
for (const t of tc.tests) {
if (t.error) {
const src = exceptionThrowSource(t.error.StackTrace[0], workDir, trackedFiles)
if (src === null) {
continue
const message = test.error.Message[0]
const stackTrace = test.error.StackTrace[0]
let path
let line
const src = this.exceptionThrowSource(stackTrace)
if (src) {
path = src.path
line = src.line
}
return {
path,
line,
message,
stackTrace: `${message}\n${stackTrace}`
}
}
private exceptionThrowSource(stackTrace: string): {path: string; line: number} | undefined {
const lines = stackTrace.split(/\r*\n/)
const re = / in (.+):line (\d+)$/
const {workDir, trackedFiles} = this.options
for (const str of lines) {
const match = str.match(re)
if (match !== null) {
const [_, fileStr, lineStr] = match
const filePath = normalizeFilePath(fileStr)
const file = filePath.startsWith(workDir) ? filePath.substr(workDir.length) : filePath
if (trackedFiles.includes(file)) {
const line = parseInt(lineStr)
return {path: file, line}
}
annotations.push({
annotation_level: 'failure',
start_line: src.line,
end_line: src.line,
path: src.file,
message: fixEol(t.error.Message[0]),
title: `[${tc.name}] ${t.name}`
})
}
}
}
return annotations
}
export function exceptionThrowSource(
ex: string,
workDir: string,
trackedFiles: string[]
): {file: string; line: number} | null {
const lines = ex.split(/\r*\n/)
const re = / in (.+):line (\d+)$/
for (const str of lines) {
const match = str.match(re)
if (match !== null) {
const [_, fileStr, lineStr] = match
const filePath = normalizeFilePath(fileStr)
const file = filePath.startsWith(workDir) ? filePath.substr(workDir.length) : filePath
if (trackedFiles.includes(file)) {
const line = parseInt(lineStr)
return {file, line}
}
}
}
return null
}

198
src/parsers/jest-junit/jest-junit-parser.ts
View file

@ -1,9 +1,8 @@
import * as core from '@actions/core'
import {Annotation, FileContent, ParseOptions, TestResult} from '../parser-types'
import {ParseOptions, TestParser} from '../../test-parser'
import {parseStringPromise} from 'xml2js'
import {JunitReport, TestCase, TestSuite} from './jest-junit-types'
import {fixEol} from '../../utils/markdown-utils'
import {normalizeFilePath} from '../../utils/file-utils'
import {
@ -11,124 +10,107 @@ import {
TestRunResult,
TestSuiteResult,
TestGroupResult,
TestCaseResult
} from '../../report/test-results'
TestCaseResult,
TestCaseError
} from '../../test-results'
export async function parseJestJunit(files: FileContent[], options: ParseOptions): Promise<TestResult> {
const junit: JunitReport[] = []
const testRuns: TestRunResult[] = []
export class JestJunitParser implements TestParser {
constructor(readonly options: ParseOptions) {}
for (const file of files) {
const ju = await getJunitReport(file)
const tr = getTestRunResult(file.path, ju)
junit.push(ju)
testRuns.push(tr)
async parse(path: string, content: string): Promise<TestRunResult> {
const ju = await this.getJunitReport(path, content)
return this.getTestRunResult(path, ju)
}
return {
testRuns,
annotations: options.annotations ? getAnnotations(junit, options.workDir, options.trackedFiles) : []
}
}
async function getJunitReport(file: FileContent): Promise<JunitReport> {
core.info(`Parsing content of '${file.path}'`)
try {
return (await parseStringPromise(file.content)) as JunitReport
} catch (e) {
throw new Error(`Invalid XML at ${file.path}\n\n${e}`)
}
}
function getTestRunResult(path: string, junit: JunitReport): TestRunResult {
const suites = junit.testsuites.testsuite.map(ts => {
const name = ts.$.name.trim()
const time = parseFloat(ts.$.time) * 1000
const sr = new TestSuiteResult(name, getGroups(ts), time)
return sr
})
const time = parseFloat(junit.testsuites.$.time) * 1000
return new TestRunResult(path, suites, time)
}
function getGroups(suite: TestSuite): TestGroupResult[] {
const groups: {describe: string; tests: TestCase[]}[] = []
for (const tc of suite.testcase) {
let grp = groups.find(g => g.describe === tc.$.classname)
if (grp === undefined) {
grp = {describe: tc.$.classname, tests: []}
groups.push(grp)
private async getJunitReport(path: string, content: string): Promise<JunitReport> {
core.info(`Parsing content of '${path}'`)
try {
return (await parseStringPromise(content)) as JunitReport
} catch (e) {
throw new Error(`Invalid XML at ${path}\n\n${e}`)
}
grp.tests.push(tc)
}
return groups.map(grp => {
const tests = grp.tests.map(tc => {
const name = tc.$.name.trim()
const result = getTestCaseResult(tc)
const time = parseFloat(tc.$.time) * 1000
return new TestCaseResult(name, result, time)
private getTestRunResult(path: string, junit: JunitReport): TestRunResult {
const suites = junit.testsuites.testsuite.map(ts => {
const name = ts.$.name.trim()
const time = parseFloat(ts.$.time) * 1000
const sr = new TestSuiteResult(name, this.getGroups(ts), time)
return sr
})
return new TestGroupResult(grp.describe, tests)
})
}
function getTestCaseResult(test: TestCase): TestExecutionResult {
if (test.failure) return 'failed'
if (test.skipped) return 'skipped'
return 'success'
}
const time = parseFloat(junit.testsuites.$.time) * 1000
return new TestRunResult(path, suites, time)
}
function getAnnotations(junitReports: JunitReport[], workDir: string, trackedFiles: string[]): Annotation[] {
const annotations: Annotation[] = []
for (const junit of junitReports) {
for (const suite of junit.testsuites.testsuite) {
for (const tc of suite.testcase) {
if (!tc.failure) {
continue
}
for (const ex of tc.failure) {
const src = exceptionThrowSource(ex, workDir, trackedFiles)
if (src === null) {
continue
}
annotations.push({
annotation_level: 'failure',
start_line: src.line,
end_line: src.line,
path: src.file,
message: fixEol(ex),
title: `[${suite.$.name}] ${tc.$.name.trim()}`
})
private getGroups(suite: TestSuite): TestGroupResult[] {
const groups: {describe: string; tests: TestCase[]}[] = []
for (const tc of suite.testcase) {
let grp = groups.find(g => g.describe === tc.$.classname)
if (grp === undefined) {
grp = {describe: tc.$.classname, tests: []}
groups.push(grp)
}
grp.tests.push(tc)
}
return groups.map(grp => {
const tests = grp.tests.map(tc => {
const name = tc.$.name.trim()
const result = this.getTestCaseResult(tc)
const time = parseFloat(tc.$.time) * 1000
const error = this.getTestCaseError(tc)
return new TestCaseResult(name, result, time, error)
})
return new TestGroupResult(grp.describe, tests)
})
}
private getTestCaseResult(test: TestCase): TestExecutionResult {
if (test.failure) return 'failed'
if (test.skipped) return 'skipped'
return 'success'
}
private getTestCaseError(tc: TestCase): TestCaseError | undefined {
if (!this.options.parseErrors || !tc.failure) {
return undefined
}
const stackTrace = tc.failure[0]
let path
let line
const src = this.exceptionThrowSource(stackTrace)
if (src) {
path = src.path
line = src.line
}
return {
path,
line,
stackTrace
}
}
private exceptionThrowSource(stackTrace: string): {path: string; line: number} | undefined {
const lines = stackTrace.split(/\r?\n/)
const re = /\((.*):(\d+):\d+\)$/
const {workDir, trackedFiles} = this.options
for (const str of lines) {
const match = str.match(re)
if (match !== null) {
const [_, fileStr, lineStr] = match
const filePath = normalizeFilePath(fileStr)
const path = filePath.startsWith(workDir) ? filePath.substr(workDir.length) : filePath
if (trackedFiles.includes(path)) {
const line = parseInt(lineStr)
return {path, line}
}
}
}
}
return annotations
}
export function exceptionThrowSource(
ex: string,
workDir: string,
trackedFiles: string[]
): {file: string; line: number; column: number} | null {
const lines = ex.split(/\r?\n/)
const re = /\((.*):(\d+):(\d+)\)$/
for (const str of lines) {
const match = str.match(re)
if (match !== null) {
const [_, fileStr, lineStr, colStr] = match
const filePath = normalizeFilePath(fileStr)
const file = filePath.startsWith(workDir) ? filePath.substr(workDir.length) : filePath
if (trackedFiles.includes(file)) {
const line = parseInt(lineStr)
const column = parseInt(colStr)
return {file, line, column}
}
}
}
return null
}

28
src/parsers/parser-types.ts
View file

@ -1,28 +0,0 @@
import {TestRunResult} from '../report/test-results'
export type Annotation = {
path: string
start_line: number
end_line: number
start_column?: number
end_column?: number
annotation_level: 'notice' | 'warning' | 'failure'
message: string
title?: string
raw_details?: string
}
export type ParseTestResult = (files: FileContent[], options: ParseOptions) => Promise<TestResult>
export type FileContent = {path: string; content: string}
export interface ParseOptions {
annotations: boolean
workDir: string
trackedFiles: string[]
}
export interface TestResult {
testRuns: TestRunResult[]
annotations: Annotation[]
}

111
src/report/get-annotations.ts Normal file
View file

@ -0,0 +1,111 @@
import {ellipsis, fixEol} from '../utils/markdown-utils'
import {TestRunResult} from '../test-results'
type Annotation = {
path: string
start_line: number
end_line: number
start_column?: number
end_column?: number
annotation_level: 'notice' | 'warning' | 'failure'
message: string
title?: string
raw_details?: string
}
interface TestError {
testRunPaths: string[]
suiteName: string
testName: string
path: string
line: number
stackTrace: string
message: string
}
export function getAnnotations(results: TestRunResult[], maxCount: number): Annotation[] {
if (maxCount === 0) {
return []
}
// Collect errors from TestRunResults
// Merge duplicates if there are more test results files processed
const errors: TestError[] = []
const mergeDup = results.length > 1
for (const tr of results) {
for (const ts of tr.suites) {
for (const tg of ts.groups) {
for (const tc of tg.tests) {
const err = tc.error
if (err === undefined) {
continue
}
const path = err.path ?? tr.path
const line = err.line ?? 0
if (mergeDup) {
const dup = errors.find(e => path === e.path && line === e.line && err.stackTrace === e.stackTrace)
if (dup !== undefined) {
dup.testRunPaths.push(tr.path)
continue
}
}
errors.push({
testRunPaths: [tr.path],
suiteName: ts.name,
testName: tc.name,
stackTrace: err.stackTrace,
message: err.message ?? getFirstNonEmptyLine(err.stackTrace) ?? 'Test failed',
path,
line
})
}
}
}
}
// Limit number of created annotations
errors.splice(maxCount + 1)
const annotations = errors.map(e => {
const message = [
'Failed test found in:',
e.testRunPaths.map(p => ` ${p}`).join('\n'),
'Error:',
ident(fixEol(e.message), ' ')
].join('\n')
return enforceCheckRunLimits({
path: e.path,
start_line: e.line,
end_line: e.line,
annotation_level: 'failure',
title: `${e.suiteName} ► ${e.testName}`,
raw_details: fixEol(e.stackTrace),
message
})
})
return annotations
}
function enforceCheckRunLimits(err: Annotation): Annotation {
err.title = ellipsis(err.title || '', 255)
err.message = ellipsis(err.message, 65535)
if (err.raw_details) {
err.raw_details = ellipsis(err.raw_details, 65535)
}
return err
}
function getFirstNonEmptyLine(stackTrace: string): string | undefined {
const lines = stackTrace.split(/\r?\n/g)
return lines.find(str => !/^\s*$/.test(str))
}
function ident(text: string, prefix: string): string {
return text
.split(/\n/g)
.map(line => prefix + line)
.join('\n')
}

7
src/report/get-report.ts
View file

@ -1,5 +1,5 @@
import * as core from '@actions/core'
import {TestExecutionResult, TestRunResult, TestSuiteResult} from './test-results'
import {TestExecutionResult, TestRunResult, TestSuiteResult} from '../test-results'
import {Align, formatTime, Icon, link, table} from '../utils/markdown-utils'
import {slug} from '../utils/slugger'
@ -112,7 +112,7 @@ function getSuitesReport(tr: TestRunResult, runIndex: number, options: ReportOpt
const icon = getResultIcon(tr.result)
sections.push(`## ${nameLink} ${icon}`)
const time = `${(tr.time / 1000).toFixed(3)}s`
const time = formatTime(tr.time)
const headingLine2 = `**${tr.tests}** tests were completed in **${time}** with **${tr.passed}** passed, **${tr.failed}** failed and **${tr.skipped}** skipped.`
sections.push(headingLine2)
@ -161,7 +161,8 @@ function getTestsReport(ts: TestSuiteResult, runIndex: number, suiteIndex: numbe
const icon = getResultIcon(ts.result)
sections.push(`### ${tsNameLink} ${icon}`)
const headingLine2 = `**${ts.tests}** tests were completed in **${ts.time}ms** with **${ts.passed}** passed, **${ts.failed}** failed and **${ts.skipped}** skipped.`
const tsTime = formatTime(ts.time)
const headingLine2 = `**${ts.tests}** tests were completed in **${tsTime}** with **${ts.passed}** passed, **${ts.failed}** failed and **${ts.skipped}** skipped.`
sections.push(headingLine2)
for (const grp of groups) {

11
src/test-parser.ts Normal file
View file

@ -0,0 +1,11 @@
import {TestRunResult} from './test-results'
export interface ParseOptions {
parseErrors: boolean
workDir: string
trackedFiles: string[]
}
export interface TestParser {
parse(path: string, content: string): Promise<TestRunResult>
}

14
src/report/test-results.ts → src/test-results.ts
View file

@ -83,7 +83,19 @@ export class TestGroupResult {
}
export class TestCaseResult {
constructor(readonly name: string, readonly result: TestExecutionResult, readonly time: number) {}
constructor(
readonly name: string,
readonly result: TestExecutionResult,
readonly time: number,
readonly error?: TestCaseError
) {}
}
export type TestExecutionResult = 'success' | 'skipped' | 'failed' | undefined
export interface TestCaseError {
path?: string
line?: number
message?: string
stackTrace: string
}

14
src/utils/github-utils.ts
View file

@ -1,9 +1,6 @@
import * as github from '@actions/github'
import {EventPayloads} from '@octokit/webhooks'
import {TestResult} from '../parsers/parser-types'
import {ellipsis} from './markdown-utils'
export function getCheckRunSha(): string {
if (github.context.payload.pull_request) {
const pr = github.context.payload.pull_request as EventPayloads.WebhookPayloadPullRequestPullRequest
@ -12,14 +9,3 @@ export function getCheckRunSha(): string {
return github.context.sha
}
export function enforceCheckRunLimits(result: TestResult, maxAnnotations: number): void {
// Limit number of created annotations
result.annotations.splice(maxAnnotations + 1)
// Limit number of characters in annotation fields
for (const err of result.annotations) {
err.title = ellipsis(err.title || '', 255)
err.message = ellipsis(err.message, 65535)
}
}