fix stdout issue

This commit is contained in:
yedidyas 2025-01-14 20:36:13 +02:00
parent 46691ebeaf
commit 2db037664f
2 changed files with 89 additions and 83 deletions

View file

@ -1,10 +1,10 @@
import {parseStringPromise} from 'xml2js'
import { parseStringPromise } from 'xml2js';
import {ErrorInfo, Outcome, TrxReport, UnitTest, UnitTestResult} from './dotnet-trx-types'
import {ParseOptions, TestParser} from '../../test-parser'
import { ErrorInfo, Outcome, TrxReport, UnitTest, UnitTestResult } from './dotnet-trx-types';
import { ParseOptions, TestParser } from '../../test-parser';
import {getBasePath, normalizeFilePath} from '../../utils/path-utils'
import {parseIsoDate, parseNetDuration} from '../../utils/parse-utils'
import { getBasePath, normalizeFilePath } from '../../utils/path-utils';
import { parseIsoDate, parseNetDuration } from '../../utils/parse-utils';
import {
TestExecutionResult,
@ -12,12 +12,12 @@ import {
TestSuiteResult,
TestGroupResult,
TestCaseResult,
TestCaseError
} from '../../test-results'
TestCaseError,
} from '../../test-results';
class TestClass {
constructor(readonly name: string) {}
readonly tests: Test[] = []
readonly tests: Test[] = [];
}
class Test {
@ -25,162 +25,168 @@ class Test {
readonly name: string,
readonly outcome: Outcome,
readonly duration: number,
readonly error?: ErrorInfo
readonly error?: ErrorInfo,
readonly stdOut?: string
) {}
get result(): TestExecutionResult | undefined {
switch (this.outcome) {
case 'Passed':
return 'success'
return 'success';
case 'NotExecuted':
return 'skipped'
return 'skipped';
case 'Failed':
return 'failed'
return 'failed';
}
}
}
export class DotnetTrxParser implements TestParser {
assumedWorkDir: string | undefined
assumedWorkDir: string | undefined;
constructor(readonly options: ParseOptions) {}
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)
tr.sort(true)
return tr
const trx = await this.getTrxReport(path, content);
const tc = this.getTestClasses(trx);
const tr = this.getTestRunResult(path, trx, tc);
tr.sort(true);
return tr;
}
private async getTrxReport(path: string, content: string): Promise<TrxReport> {
try {
return (await parseStringPromise(content)) as TrxReport
return (await parseStringPromise(content)) as TrxReport;
} catch (e) {
throw new Error(`Invalid XML at ${path}\n\n${e}`)
throw new Error(`Invalid XML at ${path}\n\n${e}`);
}
}
private getTestClasses(trx: TrxReport): TestClass[] {
if (trx.TestRun.TestDefinitions === undefined || trx.TestRun.Results === undefined) {
return []
return [];
}
const unitTests: {[id: string]: UnitTest} = {}
const unitTests: { [id: string]: UnitTest } = {};
for (const td of trx.TestRun.TestDefinitions) {
for (const ut of td.UnitTest) {
unitTests[ut.$.id] = ut
unitTests[ut.$.id] = ut;
}
}
const unitTestsResults = trx.TestRun.Results.flatMap(r => r.UnitTestResult).flatMap(result => ({
result,
test: unitTests[result.$.testId]
}))
const unitTestsResults = trx.TestRun.Results.flatMap((r) =>
r.UnitTestResult.map((result) => ({
result,
test: unitTests[result.$.testId],
}))
);
const testClasses: {[name: string]: TestClass} = {}
const testClasses: { [name: string]: TestClass } = {};
for (const r of unitTestsResults) {
const className = r.test.TestMethod[0].$.className
let tc = testClasses[className]
const className = r.test.TestMethod[0].$.className;
let tc = testClasses[className];
if (tc === undefined) {
tc = new TestClass(className)
testClasses[tc.name] = tc
tc = new TestClass(className);
testClasses[tc.name] = tc;
}
const error = this.getErrorInfo(r.result)
const durationAttr = r.result.$.duration
const duration = durationAttr ? parseNetDuration(durationAttr) : 0
const resultTestName = r.result.$.testName
const error = this.getErrorInfo(r.result);
const durationAttr = r.result.$.duration;
const duration = durationAttr ? parseNetDuration(durationAttr) : 0;
const stdOut = r.result.Output?.[0]?.StdOut?.join('\n') || ''; // Extract StdOut
const resultTestName = r.result.$.testName;
const testName =
resultTestName.startsWith(className) && resultTestName[className.length] === '.'
? resultTestName.substr(className.length + 1)
: resultTestName
const test = new Test(testName, r.result.$.outcome, duration, error)
tc.tests.push(test)
: resultTestName;
const test = new Test(testName, r.result.$.outcome, duration, error, stdOut);
tc.tests.push(test);
}
const result = Object.values(testClasses)
return result
const result = Object.values(testClasses);
return result;
}
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 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])
})
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 new TestRunResult(path, suites, totalTime);
}
private getErrorInfo(testResult: UnitTestResult): ErrorInfo | undefined {
if (testResult.$.outcome !== 'Failed') {
return undefined
return undefined;
}
const output = testResult.Output
const error = output?.length > 0 && output[0].ErrorInfo?.length > 0 ? output[0].ErrorInfo[0] : undefined
return error
const output = testResult.Output;
const error = output?.length > 0 && output[0].ErrorInfo?.length > 0 ? output[0].ErrorInfo[0] : undefined;
return error;
}
private getError(test: Test): TestCaseError | undefined {
if (!this.options.parseErrors || !test.error) {
return undefined
return undefined;
}
const error = test.error
const error = test.error;
if (
!Array.isArray(error.Message) ||
error.Message.length === 0 ||
!Array.isArray(error.StackTrace) ||
error.StackTrace.length === 0
) {
return undefined
return undefined;
}
const message = test.error.Message[0]
const stackTrace = test.error.StackTrace[0]
const stdOut = test.error.StdOut?.join('\n') || ''
let path
let line
const message = error.Message[0];
const stackTrace = error.StackTrace[0];
const stdOut = test.stdOut || ''; // Use StdOut from Test object
let path;
let line;
const src = this.exceptionThrowSource(stackTrace)
const src = this.exceptionThrowSource(stackTrace);
if (src) {
path = src.path
line = src.line
path = src.path;
line = src.line;
}
return {
path,
line,
message,
details: `${message}\n${stackTrace}\n${stdOut}`
}
details: `${message}\n${stackTrace}\n${stdOut}`,
};
}
private exceptionThrowSource(stackTrace: string): {path: string; line: number} | undefined {
const lines = stackTrace.split(/\r*\n/)
const re = / in (.+):line (\d+)$/
const {trackedFiles} = this.options
private exceptionThrowSource(stackTrace: string): { path: string; line: number } | undefined {
const lines = stackTrace.split(/\r*\n/);
const re = / in (.+):line (\d+)$/;
const { trackedFiles } = this.options;
for (const str of lines) {
const match = str.match(re)
const match = str.match(re);
if (match !== null) {
const [_, fileStr, lineStr] = match
const filePath = normalizeFilePath(fileStr)
const workDir = this.getWorkDir(filePath)
const [_, fileStr, lineStr] = match;
const filePath = normalizeFilePath(fileStr);
const workDir = this.getWorkDir(filePath);
if (workDir) {
const file = filePath.substr(workDir.length)
const file = filePath.substr(workDir.length);
if (trackedFiles.includes(file)) {
const line = parseInt(lineStr)
return {path: file, line}
const line = parseInt(lineStr);
return { path: file, line };
}
}
}
@ -192,6 +198,6 @@ export class DotnetTrxParser implements TestParser {
this.options.workDir ??
this.assumedWorkDir ??
(this.assumedWorkDir = getBasePath(path, this.options.trackedFiles))
)
);
}
}

View file

@ -51,7 +51,7 @@ export interface UnitTestResult {
export interface Output {
ErrorInfo: ErrorInfo[]
StdOut: string[]
StdOut: string[] | undefined;
}
export interface ErrorInfo {
Message: string[]