355 lines
12 KiB
TypeScript
355 lines
12 KiB
TypeScript
import { ChildProcess } from 'child_process';
|
|
import { coloredString as cs } from '@push.rocks/consolecolor';
|
|
|
|
// ============
|
|
// combines different tap test files to an overall result
|
|
// ============
|
|
import * as plugins from './tstest.plugins.js';
|
|
import { TapTestResult } from './tstest.classes.tap.testresult.js';
|
|
import * as logPrefixes from './tstest.logprefixes.js';
|
|
import { TsTestLogger } from './tstest.logging.js';
|
|
|
|
export class TapParser {
|
|
testStore: TapTestResult[] = [];
|
|
|
|
expectedTestsRegex = /([0-9]*)\.\.([0-9]*)$/;
|
|
expectedTests: number;
|
|
receivedTests: number;
|
|
|
|
testStatusRegex = /(ok|not\sok)\s([0-9]+)\s-\s(.*?)(\s#\s(.*))?$/;
|
|
activeTapTestResult: TapTestResult;
|
|
collectingErrorDetails: boolean = false;
|
|
currentTestError: string[] = [];
|
|
|
|
pretaskRegex = /^::__PRETASK:(.*)$/;
|
|
|
|
private logger: TsTestLogger;
|
|
|
|
/**
|
|
* the constructor for TapParser
|
|
*/
|
|
constructor(public fileName: string, logger?: TsTestLogger) {
|
|
this.logger = logger;
|
|
}
|
|
|
|
/**
|
|
* Handle test file timeout
|
|
*/
|
|
public handleTimeout(timeoutSeconds: number) {
|
|
// Create a fake failing test result for timeout
|
|
this._getNewTapTestResult();
|
|
this.activeTapTestResult.testOk = false;
|
|
this.activeTapTestResult.testSettled = true;
|
|
this.testStore.push(this.activeTapTestResult);
|
|
|
|
// Set expected vs received to force failure
|
|
this.expectedTests = 1;
|
|
this.receivedTests = 0;
|
|
|
|
// Log the timeout error
|
|
if (this.logger) {
|
|
this.logger.testResult(
|
|
`Test file timeout`,
|
|
false,
|
|
timeoutSeconds * 1000,
|
|
`Error: Test file exceeded timeout of ${timeoutSeconds} seconds`
|
|
);
|
|
this.logger.testErrorDetails(`Test execution was terminated after ${timeoutSeconds} seconds`);
|
|
// Force file end with failure
|
|
this.logger.testFileEnd(0, 1, timeoutSeconds * 1000);
|
|
}
|
|
}
|
|
|
|
private _getNewTapTestResult() {
|
|
this.activeTapTestResult = new TapTestResult(this.testStore.length + 1);
|
|
}
|
|
|
|
private _processLog(logChunk: Buffer | string) {
|
|
if (Buffer.isBuffer(logChunk)) {
|
|
logChunk = logChunk.toString();
|
|
}
|
|
const logLineArray = logChunk.split('\n');
|
|
if (logLineArray[logLineArray.length - 1] === '') {
|
|
logLineArray.pop();
|
|
}
|
|
|
|
// lets parse the log information
|
|
for (const logLine of logLineArray) {
|
|
let logLineIsTapProtocol = false;
|
|
if (!this.expectedTests && this.expectedTestsRegex.test(logLine)) {
|
|
logLineIsTapProtocol = true;
|
|
const regexResult = this.expectedTestsRegex.exec(logLine);
|
|
this.expectedTests = parseInt(regexResult[2]);
|
|
if (this.logger) {
|
|
this.logger.tapOutput(`Expecting ${this.expectedTests} tests!`);
|
|
}
|
|
|
|
// initiating first TapResult
|
|
this._getNewTapTestResult();
|
|
} else if (this.pretaskRegex.test(logLine)) {
|
|
logLineIsTapProtocol = true;
|
|
const pretaskContentMatch = this.pretaskRegex.exec(logLine);
|
|
if (pretaskContentMatch && pretaskContentMatch[1]) {
|
|
if (this.logger) {
|
|
this.logger.tapOutput(`Pretask -> ${pretaskContentMatch[1]}: Success.`);
|
|
}
|
|
}
|
|
} else if (this.testStatusRegex.test(logLine)) {
|
|
logLineIsTapProtocol = true;
|
|
const regexResult = this.testStatusRegex.exec(logLine);
|
|
// const testId = parseInt(regexResult[2]); // Currently unused
|
|
const testOk = (() => {
|
|
if (regexResult[1] === 'ok') {
|
|
return true;
|
|
}
|
|
return false;
|
|
})();
|
|
|
|
const testSubject = regexResult[3].trim();
|
|
const testMetadata = regexResult[5]; // This will be either "time=XXXms" or "SKIP reason" or "TODO reason"
|
|
|
|
let testDuration = 0;
|
|
|
|
if (testMetadata) {
|
|
const timeMatch = testMetadata.match(/time=(\d+)ms/);
|
|
// const skipMatch = testMetadata.match(/SKIP\s*(.*)/); // Currently unused
|
|
// const todoMatch = testMetadata.match(/TODO\s*(.*)/); // Currently unused
|
|
|
|
if (timeMatch) {
|
|
testDuration = parseInt(timeMatch[1]);
|
|
}
|
|
// Skip/todo handling could be added here in the future
|
|
}
|
|
|
|
// test for protocol error - disabled as it's not critical
|
|
// The test ID mismatch can occur when tests are filtered, skipped, or use todo
|
|
// if (testId !== this.activeTapTestResult.id) {
|
|
// if (this.logger) {
|
|
// this.logger.error('Something is strange! Test Ids are not equal!');
|
|
// }
|
|
// }
|
|
this.activeTapTestResult.setTestResult(testOk);
|
|
|
|
if (testOk) {
|
|
if (this.logger) {
|
|
this.logger.testResult(testSubject, true, testDuration);
|
|
}
|
|
} else {
|
|
// Start collecting error details for failed test
|
|
this.collectingErrorDetails = true;
|
|
this.currentTestError = [];
|
|
if (this.logger) {
|
|
this.logger.testResult(testSubject, false, testDuration);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!logLineIsTapProtocol) {
|
|
if (this.activeTapTestResult) {
|
|
this.activeTapTestResult.addLogLine(logLine);
|
|
}
|
|
|
|
// Check for snapshot communication
|
|
const snapshotMatch = logLine.match(/###SNAPSHOT###(.+)###SNAPSHOT###/);
|
|
if (snapshotMatch) {
|
|
const base64Data = snapshotMatch[1];
|
|
try {
|
|
const snapshotData = JSON.parse(Buffer.from(base64Data, 'base64').toString());
|
|
this.handleSnapshot(snapshotData);
|
|
} catch (error) {
|
|
if (this.logger) {
|
|
this.logger.testConsoleOutput(`Error parsing snapshot data: ${error.message}`);
|
|
}
|
|
}
|
|
} else {
|
|
// Check if we're collecting error details
|
|
if (this.collectingErrorDetails) {
|
|
// Check if this line is an error detail (starts with Error: or has stack trace characteristics)
|
|
if (logLine.trim().startsWith('Error:') || logLine.trim().match(/^\s*at\s/)) {
|
|
this.currentTestError.push(logLine);
|
|
} else if (this.currentTestError.length > 0) {
|
|
// End of error details, show the error
|
|
const errorMessage = this.currentTestError.join('\n');
|
|
if (this.logger) {
|
|
this.logger.testErrorDetails(errorMessage);
|
|
}
|
|
this.collectingErrorDetails = false;
|
|
this.currentTestError = [];
|
|
}
|
|
}
|
|
|
|
// Don't output TAP error details as console output when we're collecting them
|
|
if (!this.collectingErrorDetails || (!logLine.trim().startsWith('Error:') && !logLine.trim().match(/^\s*at\s/))) {
|
|
if (this.logger) {
|
|
// This is console output from the test file, not TAP protocol
|
|
this.logger.testConsoleOutput(logLine);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (this.activeTapTestResult && this.activeTapTestResult.testSettled) {
|
|
// Ensure any pending error is shown before settling the test
|
|
if (this.collectingErrorDetails && this.currentTestError.length > 0) {
|
|
const errorMessage = this.currentTestError.join('\n');
|
|
if (this.logger) {
|
|
this.logger.testErrorDetails(errorMessage);
|
|
}
|
|
this.collectingErrorDetails = false;
|
|
this.currentTestError = [];
|
|
}
|
|
|
|
this.testStore.push(this.activeTapTestResult);
|
|
this._getNewTapTestResult();
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* returns all tests that are not completed
|
|
*/
|
|
public getUncompletedTests() {
|
|
// TODO:
|
|
}
|
|
|
|
/**
|
|
* returns all tests that threw an error
|
|
*/
|
|
public getErrorTests() {
|
|
return this.testStore.filter((tapTestArg) => {
|
|
return !tapTestArg.testOk;
|
|
});
|
|
}
|
|
|
|
/**
|
|
* returns a test overview as string
|
|
*/
|
|
getTestOverviewAsString() {
|
|
let overviewString = '';
|
|
for (const test of this.testStore) {
|
|
if (overviewString !== '') {
|
|
overviewString += ' | ';
|
|
}
|
|
if (test.testOk) {
|
|
overviewString += cs(`T${test.id} ${plugins.figures.tick}`, 'green');
|
|
} else {
|
|
overviewString += cs(`T${test.id} ${plugins.figures.cross}`, 'red');
|
|
}
|
|
}
|
|
return overviewString;
|
|
}
|
|
|
|
/**
|
|
* handles a tap process
|
|
* @param childProcessArg
|
|
*/
|
|
public async handleTapProcess(childProcessArg: ChildProcess) {
|
|
const done = plugins.smartpromise.defer();
|
|
childProcessArg.stdout.on('data', (data) => {
|
|
this._processLog(data);
|
|
});
|
|
childProcessArg.stderr.on('data', (data) => {
|
|
this._processLog(data);
|
|
});
|
|
childProcessArg.on('exit', async () => {
|
|
await this.evaluateFinalResult();
|
|
done.resolve();
|
|
});
|
|
await done.promise;
|
|
}
|
|
|
|
public async handleTapLog(tapLog: string) {
|
|
this._processLog(tapLog);
|
|
}
|
|
|
|
/**
|
|
* Handle snapshot data from the test
|
|
*/
|
|
private async handleSnapshot(snapshotData: { path: string; content: string; action: string }) {
|
|
try {
|
|
const smartfile = await import('@push.rocks/smartfile');
|
|
|
|
if (snapshotData.action === 'compare') {
|
|
// Try to read existing snapshot
|
|
try {
|
|
const existingSnapshot = await smartfile.fs.toStringSync(snapshotData.path);
|
|
if (existingSnapshot !== snapshotData.content) {
|
|
// Snapshot mismatch
|
|
if (this.logger) {
|
|
this.logger.testConsoleOutput(`Snapshot mismatch: ${snapshotData.path}`);
|
|
this.logger.testConsoleOutput(`Expected:\n${existingSnapshot}`);
|
|
this.logger.testConsoleOutput(`Received:\n${snapshotData.content}`);
|
|
}
|
|
// TODO: Communicate failure back to the test
|
|
} else {
|
|
if (this.logger) {
|
|
this.logger.testConsoleOutput(`Snapshot matched: ${snapshotData.path}`);
|
|
}
|
|
}
|
|
} catch (error: any) {
|
|
if (error.code === 'ENOENT') {
|
|
// Snapshot doesn't exist, create it
|
|
const dirPath = snapshotData.path.substring(0, snapshotData.path.lastIndexOf('/'));
|
|
await smartfile.fs.ensureDir(dirPath);
|
|
await smartfile.memory.toFs(snapshotData.content, snapshotData.path);
|
|
if (this.logger) {
|
|
this.logger.testConsoleOutput(`Snapshot created: ${snapshotData.path}`);
|
|
}
|
|
} else {
|
|
throw error;
|
|
}
|
|
}
|
|
} else if (snapshotData.action === 'update') {
|
|
// Update snapshot
|
|
const dirPath = snapshotData.path.substring(0, snapshotData.path.lastIndexOf('/'));
|
|
await smartfile.fs.ensureDir(dirPath);
|
|
await smartfile.memory.toFs(snapshotData.content, snapshotData.path);
|
|
if (this.logger) {
|
|
this.logger.testConsoleOutput(`Snapshot updated: ${snapshotData.path}`);
|
|
}
|
|
}
|
|
} catch (error: any) {
|
|
if (this.logger) {
|
|
this.logger.testConsoleOutput(`Error handling snapshot: ${error.message}`);
|
|
}
|
|
}
|
|
}
|
|
|
|
public async evaluateFinalResult() {
|
|
this.receivedTests = this.testStore.length;
|
|
|
|
// check wether all tests ran
|
|
if (this.expectedTests === this.receivedTests) {
|
|
if (this.logger) {
|
|
this.logger.tapOutput(`${this.receivedTests} out of ${this.expectedTests} Tests completed!`);
|
|
}
|
|
} else {
|
|
if (this.logger) {
|
|
this.logger.error(`Only ${this.receivedTests} out of ${this.expectedTests} completed!`);
|
|
}
|
|
}
|
|
if (!this.expectedTests && this.receivedTests === 0) {
|
|
if (this.logger) {
|
|
this.logger.error('No tests were defined. Therefore the testfile failed!');
|
|
this.logger.testFileEnd(0, 1, 0); // Count as 1 failure
|
|
}
|
|
} else if (this.expectedTests !== this.receivedTests) {
|
|
if (this.logger) {
|
|
this.logger.error('The amount of received tests and expectedTests is unequal! Therefore the testfile failed');
|
|
const errorCount = this.getErrorTests().length || 1; // At least 1 error
|
|
this.logger.testFileEnd(this.receivedTests - errorCount, errorCount, 0);
|
|
}
|
|
} else if (this.getErrorTests().length === 0) {
|
|
if (this.logger) {
|
|
this.logger.tapOutput('All tests are successfull!!!');
|
|
this.logger.testFileEnd(this.receivedTests, 0, 0);
|
|
}
|
|
} else {
|
|
if (this.logger) {
|
|
this.logger.tapOutput(`${this.getErrorTests().length} tests threw an error!!!`, true);
|
|
this.logger.testFileEnd(this.receivedTests - this.getErrorTests().length, this.getErrorTests().length, 0);
|
|
}
|
|
}
|
|
}
|
|
}
|