Skip to content

Commit

Permalink
fix stdout issue
Browse files Browse the repository at this point in the history
  • Loading branch information
@yedidyas
yedidyas committed Jan 14, 2025
1 parent 46691eb commit 2db0376
Show file tree
Hide file tree
Showing 2 changed files with 91 additions and 85 deletions.
174 changes: 90 additions & 84 deletions src/parsers/dotnet-trx/dotnet-trx-parser.ts
View file
Original file line number Diff line number Diff line change
@@ -1,186 +1,192 @@
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,
TestRunResult,
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 {
constructor(
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 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)
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);
}

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 };
}
}
}
Expand All @@ -192,6 +198,6 @@ export class DotnetTrxParser implements TestParser {
this.options.workDir ??
this.assumedWorkDir ??
(this.assumedWorkDir = getBasePath(path, this.options.trackedFiles))
)
);
}
}
2 changes: 1 addition & 1 deletion src/parsers/dotnet-trx/dotnet-trx-types.ts
View file
Original file line number Diff line number Diff line change
Expand Up @@ -51,7 +51,7 @@ export interface UnitTestResult {

export interface Output {
ErrorInfo: ErrorInfo[]
StdOut: string[]
StdOut: string[] | undefined;
}
export interface ErrorInfo {
Message: string[]
Expand Down

0 comments on commit 2db0376

Please sign in to comment.