711 lines
20 KiB
TypeScript
711 lines
20 KiB
TypeScript
import * as plugins from './tapbundle.plugins.js';
|
|
|
|
import { type IPreTaskFunction, PreTask } from './tapbundle.classes.pretask.js';
|
|
import { TapTest, type ITestFunction } from './tapbundle.classes.taptest.js';
|
|
import { ProtocolEmitter, type ITestEvent } from '../dist_ts_tapbundle_protocol/index.js';
|
|
import type { ITapSettings } from './tapbundle.interfaces.js';
|
|
import { SettingsManager } from './tapbundle.classes.settingsmanager.js';
|
|
|
|
export interface ITestSuite {
|
|
description: string;
|
|
tests: TapTest<any>[];
|
|
beforeEach?: ITestFunction<any>;
|
|
afterEach?: ITestFunction<any>;
|
|
parent?: ITestSuite;
|
|
children: ITestSuite[];
|
|
}
|
|
|
|
class TestBuilder<T> {
|
|
private _tap: Tap<T>;
|
|
private _tags: string[] = [];
|
|
private _priority: 'high' | 'medium' | 'low' = 'medium';
|
|
private _retryCount?: number;
|
|
private _timeoutMs?: number;
|
|
|
|
constructor(tap: Tap<T>) {
|
|
this._tap = tap;
|
|
}
|
|
|
|
tags(...tags: string[]) {
|
|
this._tags = tags;
|
|
return this;
|
|
}
|
|
|
|
priority(level: 'high' | 'medium' | 'low') {
|
|
this._priority = level;
|
|
return this;
|
|
}
|
|
|
|
retry(count: number) {
|
|
this._retryCount = count;
|
|
return this;
|
|
}
|
|
|
|
timeout(ms: number) {
|
|
this._timeoutMs = ms;
|
|
return this;
|
|
}
|
|
|
|
test(description: string, testFunction: ITestFunction<T>) {
|
|
const test = this._tap.test(description, testFunction, 'normal');
|
|
|
|
// Apply settings to the test
|
|
if (this._tags.length > 0) {
|
|
test.tags = this._tags;
|
|
}
|
|
test.priority = this._priority;
|
|
|
|
if (this._retryCount !== undefined) {
|
|
test.tapTools.retry(this._retryCount);
|
|
}
|
|
if (this._timeoutMs !== undefined) {
|
|
test.timeoutMs = this._timeoutMs;
|
|
}
|
|
|
|
return test;
|
|
}
|
|
|
|
testOnly(description: string, testFunction: ITestFunction<T>) {
|
|
const test = this._tap.test(description, testFunction, 'only');
|
|
|
|
// Apply settings to the test
|
|
if (this._tags.length > 0) {
|
|
test.tags = this._tags;
|
|
}
|
|
test.priority = this._priority;
|
|
|
|
if (this._retryCount !== undefined) {
|
|
test.tapTools.retry(this._retryCount);
|
|
}
|
|
if (this._timeoutMs !== undefined) {
|
|
test.timeoutMs = this._timeoutMs;
|
|
}
|
|
|
|
return test;
|
|
}
|
|
|
|
testSkip(description: string, testFunction: ITestFunction<T>) {
|
|
const test = this._tap.test(description, testFunction, 'skip');
|
|
|
|
// Apply settings to the test
|
|
if (this._tags.length > 0) {
|
|
test.tags = this._tags;
|
|
}
|
|
test.priority = this._priority;
|
|
|
|
if (this._retryCount !== undefined) {
|
|
test.tapTools.retry(this._retryCount);
|
|
}
|
|
if (this._timeoutMs !== undefined) {
|
|
test.timeoutMs = this._timeoutMs;
|
|
}
|
|
|
|
return test;
|
|
}
|
|
}
|
|
|
|
export class Tap<T> {
|
|
private protocolEmitter = new ProtocolEmitter();
|
|
private settingsManager = new SettingsManager();
|
|
private _skipCount = 0;
|
|
private _filterTags: string[] = [];
|
|
|
|
constructor() {
|
|
// Get filter tags from environment
|
|
if (typeof process !== 'undefined' && process.env && process.env.TSTEST_FILTER_TAGS) {
|
|
this._filterTags = process.env.TSTEST_FILTER_TAGS.split(',');
|
|
}
|
|
}
|
|
|
|
// Fluent test builder
|
|
public tags(...tags: string[]) {
|
|
const builder = new TestBuilder<T>(this);
|
|
return builder.tags(...tags);
|
|
}
|
|
|
|
public priority(level: 'high' | 'medium' | 'low') {
|
|
const builder = new TestBuilder<T>(this);
|
|
return builder.priority(level);
|
|
}
|
|
|
|
public retry(count: number) {
|
|
const builder = new TestBuilder<T>(this);
|
|
return builder.retry(count);
|
|
}
|
|
|
|
public timeout(ms: number) {
|
|
const builder = new TestBuilder<T>(this);
|
|
return builder.timeout(ms);
|
|
}
|
|
|
|
/**
|
|
* skips a test
|
|
* tests marked with tap.skip.test() are never executed
|
|
*/
|
|
public skip = {
|
|
test: (descriptionArg: string, functionArg: ITestFunction<T>) => {
|
|
const skippedTest = this.test(descriptionArg, functionArg, 'skip');
|
|
return skippedTest;
|
|
},
|
|
testParallel: (descriptionArg: string, functionArg: ITestFunction<T>) => {
|
|
const skippedTest = new TapTest<T>({
|
|
description: descriptionArg,
|
|
testFunction: functionArg,
|
|
parallel: true,
|
|
});
|
|
|
|
// Mark as skip mode
|
|
skippedTest.tapTools.markAsSkipped('Marked as skip');
|
|
|
|
// Add to appropriate test list
|
|
if (this._currentSuite) {
|
|
this._currentSuite.tests.push(skippedTest);
|
|
} else {
|
|
this._tapTests.push(skippedTest);
|
|
}
|
|
|
|
return skippedTest;
|
|
},
|
|
};
|
|
|
|
/**
|
|
* only executes tests marked as ONLY
|
|
*/
|
|
public only = {
|
|
test: (descriptionArg: string, testFunctionArg: ITestFunction<T>) => {
|
|
return this.test(descriptionArg, testFunctionArg, 'only');
|
|
},
|
|
testParallel: (descriptionArg: string, testFunctionArg: ITestFunction<T>) => {
|
|
const onlyTest = new TapTest<T>({
|
|
description: descriptionArg,
|
|
testFunction: testFunctionArg,
|
|
parallel: true,
|
|
});
|
|
|
|
// Add to only tests list
|
|
this._tapTestsOnly.push(onlyTest);
|
|
|
|
return onlyTest;
|
|
},
|
|
};
|
|
|
|
/**
|
|
* mark a test as todo (not yet implemented)
|
|
*/
|
|
public todo = {
|
|
test: (descriptionArg: string, functionArg?: ITestFunction<T>) => {
|
|
const defaultFunc = (async () => {}) as ITestFunction<T>;
|
|
const todoTest = new TapTest<T>({
|
|
description: descriptionArg,
|
|
testFunction: functionArg || defaultFunc,
|
|
parallel: false,
|
|
});
|
|
|
|
// Mark as todo
|
|
todoTest.tapTools.todo('Marked as todo');
|
|
|
|
// Add to appropriate test list
|
|
if (this._currentSuite) {
|
|
this._currentSuite.tests.push(todoTest);
|
|
} else {
|
|
this._tapTests.push(todoTest);
|
|
}
|
|
|
|
return todoTest;
|
|
},
|
|
testParallel: (descriptionArg: string, functionArg?: ITestFunction<T>) => {
|
|
const defaultFunc = (async () => {}) as ITestFunction<T>;
|
|
const todoTest = new TapTest<T>({
|
|
description: descriptionArg,
|
|
testFunction: functionArg || defaultFunc,
|
|
parallel: true,
|
|
});
|
|
|
|
// Mark as todo
|
|
todoTest.tapTools.todo('Marked as todo');
|
|
|
|
// Add to appropriate test list
|
|
if (this._currentSuite) {
|
|
this._currentSuite.tests.push(todoTest);
|
|
} else {
|
|
this._tapTests.push(todoTest);
|
|
}
|
|
|
|
return todoTest;
|
|
},
|
|
};
|
|
|
|
private _tapPreTasks: PreTask[] = [];
|
|
private _tapTests: TapTest<any>[] = [];
|
|
private _tapTestsOnly: TapTest<any>[] = [];
|
|
private _currentSuite: ITestSuite | null = null;
|
|
private _rootSuites: ITestSuite[] = [];
|
|
|
|
/**
|
|
* Configure global test settings
|
|
*/
|
|
public settings(settings: ITapSettings): this {
|
|
this.settingsManager.setGlobalSettings(settings);
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Get current test settings
|
|
*/
|
|
public getSettings(): ITapSettings {
|
|
return this.settingsManager.getSettings();
|
|
}
|
|
|
|
/**
|
|
* Normal test function, will run one by one
|
|
* @param testDescription - A description of what the test does
|
|
* @param testFunction - A Function that returns a Promise and resolves or rejects
|
|
*/
|
|
public test(
|
|
testDescription: string,
|
|
testFunction: ITestFunction<T>,
|
|
modeArg: 'normal' | 'only' | 'skip' = 'normal'
|
|
): TapTest<T> {
|
|
const localTest = new TapTest<T>({
|
|
description: testDescription,
|
|
testFunction,
|
|
parallel: false,
|
|
});
|
|
|
|
// Apply default settings from settings manager
|
|
const settings = this.settingsManager.getSettings();
|
|
if (settings.timeout !== undefined) {
|
|
localTest.timeoutMs = settings.timeout;
|
|
}
|
|
if (settings.retries !== undefined) {
|
|
localTest.tapTools.retry(settings.retries);
|
|
}
|
|
|
|
// Handle skip mode
|
|
if (modeArg === 'skip') {
|
|
localTest.tapTools.markAsSkipped('Marked as skip');
|
|
}
|
|
|
|
// If we're in a suite, add test to the suite
|
|
if (this._currentSuite) {
|
|
this._currentSuite.tests.push(localTest);
|
|
} else {
|
|
// Otherwise add to global test list
|
|
if (modeArg === 'normal' || modeArg === 'skip') {
|
|
this._tapTests.push(localTest);
|
|
} else if (modeArg === 'only') {
|
|
this._tapTestsOnly.push(localTest);
|
|
}
|
|
}
|
|
return localTest;
|
|
}
|
|
|
|
public preTask(descriptionArg: string, functionArg: IPreTaskFunction) {
|
|
this._tapPreTasks.push(new PreTask(descriptionArg, functionArg));
|
|
}
|
|
|
|
/**
|
|
* A parallel test that will not be waited for before the next starts.
|
|
* @param testDescription - A description of what the test does
|
|
* @param testFunction - A Function that returns a Promise and resolves or rejects
|
|
*/
|
|
public testParallel(testDescription: string, testFunction: ITestFunction<T>) {
|
|
const localTest = new TapTest({
|
|
description: testDescription,
|
|
testFunction,
|
|
parallel: true,
|
|
});
|
|
|
|
// Apply default settings from settings manager
|
|
const settings = this.settingsManager.getSettings();
|
|
if (settings.timeout !== undefined) {
|
|
localTest.timeoutMs = settings.timeout;
|
|
}
|
|
if (settings.retries !== undefined) {
|
|
localTest.tapTools.retry(settings.retries);
|
|
}
|
|
|
|
if (this._currentSuite) {
|
|
this._currentSuite.tests.push(localTest);
|
|
} else {
|
|
this._tapTests.push(localTest);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Create a test suite for grouping related tests
|
|
*/
|
|
public describe(description: string, suiteFunction: () => void) {
|
|
const suite: ITestSuite = {
|
|
description,
|
|
tests: [],
|
|
children: [],
|
|
parent: this._currentSuite,
|
|
};
|
|
|
|
// Add to parent or root
|
|
if (this._currentSuite) {
|
|
this._currentSuite.children.push(suite);
|
|
} else {
|
|
this._rootSuites.push(suite);
|
|
}
|
|
|
|
// Execute suite function in context
|
|
const previousSuite = this._currentSuite;
|
|
this._currentSuite = suite;
|
|
try {
|
|
suiteFunction();
|
|
} finally {
|
|
this._currentSuite = previousSuite;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Set up a function to run before each test in the current suite
|
|
*/
|
|
public beforeEach(setupFunction: ITestFunction<any>) {
|
|
if (this._currentSuite) {
|
|
this._currentSuite.beforeEach = setupFunction;
|
|
} else {
|
|
throw new Error('beforeEach can only be used inside a describe block');
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Set up a function to run after each test in the current suite
|
|
*/
|
|
public afterEach(teardownFunction: ITestFunction<any>) {
|
|
if (this._currentSuite) {
|
|
this._currentSuite.afterEach = teardownFunction;
|
|
} else {
|
|
throw new Error('afterEach can only be used inside a describe block');
|
|
}
|
|
}
|
|
|
|
/**
|
|
* collect all tests from suites
|
|
*/
|
|
private _collectTests(suite: ITestSuite, tests: TapTest<any>[] = []): TapTest<any>[] {
|
|
tests.push(...suite.tests);
|
|
for (const childSuite of suite.children) {
|
|
this._collectTests(childSuite, tests);
|
|
}
|
|
return tests;
|
|
}
|
|
|
|
/**
|
|
* starts the test evaluation
|
|
*/
|
|
public async start(optionsArg?: { throwOnError: boolean }) {
|
|
// lets set the tapbundle promise
|
|
const smartenvInstance = new plugins.smartenv.Smartenv();
|
|
const globalPromise = plugins.smartpromise.defer();
|
|
smartenvInstance.isBrowser
|
|
? ((globalThis as any).tapbundleDeferred = globalPromise)
|
|
: null;
|
|
// Also set tapPromise for backwards compatibility
|
|
smartenvInstance.isBrowser
|
|
? ((globalThis as any).tapPromise = globalPromise.promise)
|
|
: null;
|
|
|
|
// Path helpers will be initialized by the Node.js environment if available
|
|
|
|
// lets continue with running the tests
|
|
const promiseArray: Array<Promise<any>> = [];
|
|
|
|
// Collect all tests including those in suites
|
|
let allTests: TapTest<any>[] = [...this._tapTests];
|
|
for (const suite of this._rootSuites) {
|
|
this._collectTests(suite, allTests);
|
|
}
|
|
|
|
// safeguard against empty test array
|
|
if (allTests.length === 0 && this._tapTestsOnly.length === 0) {
|
|
console.log('no tests specified. Ending here!');
|
|
return;
|
|
}
|
|
|
|
// determine which tests to run
|
|
let concerningTests: TapTest[];
|
|
if (this._tapTestsOnly.length > 0) {
|
|
concerningTests = this._tapTestsOnly;
|
|
} else {
|
|
concerningTests = allTests;
|
|
}
|
|
|
|
// Filter tests by tags if specified
|
|
if (this._filterTags.length > 0) {
|
|
concerningTests = concerningTests.filter(test => {
|
|
// Skip tests without tags when filtering is active
|
|
if (!test.tags || test.tags.length === 0) {
|
|
return false;
|
|
}
|
|
// Check if test has any of the filter tags
|
|
return test.tags.some(tag => this._filterTags.includes(tag));
|
|
});
|
|
}
|
|
|
|
// lets run the pretasks
|
|
for (const preTask of this._tapPreTasks) {
|
|
await preTask.run();
|
|
}
|
|
|
|
// Emit protocol header and TAP version
|
|
console.log(this.protocolEmitter.emitProtocolHeader());
|
|
console.log(this.protocolEmitter.emitTapVersion(13));
|
|
|
|
// Emit test plan
|
|
const plan = {
|
|
start: 1,
|
|
end: concerningTests.length
|
|
};
|
|
console.log(this.protocolEmitter.emitPlan(plan));
|
|
|
|
// Run global beforeAll hook if configured
|
|
const settings = this.settingsManager.getSettings();
|
|
if (settings.beforeAll) {
|
|
try {
|
|
await settings.beforeAll();
|
|
} catch (error) {
|
|
console.error('Error in beforeAll hook:', error);
|
|
throw error;
|
|
}
|
|
}
|
|
|
|
// Run tests from suites with lifecycle hooks
|
|
let testKey = 0;
|
|
|
|
// Run root suite tests with lifecycle hooks
|
|
if (this._rootSuites.length > 0) {
|
|
await this._runSuite(null, this._rootSuites, promiseArray, { testKey });
|
|
// Update testKey after running suite tests
|
|
for (const suite of this._rootSuites) {
|
|
const suiteTests = this._collectTests(suite);
|
|
testKey += suiteTests.length;
|
|
}
|
|
}
|
|
|
|
// Run non-suite tests (tests added directly without describe)
|
|
const nonSuiteTests = concerningTests.filter(test => {
|
|
// Check if test is not in any suite
|
|
for (const suite of this._rootSuites) {
|
|
const suiteTests = this._collectTests(suite);
|
|
if (suiteTests.includes(test)) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
});
|
|
|
|
for (const currentTest of nonSuiteTests) {
|
|
// Wrap test function with global lifecycle hooks
|
|
const originalFunction = currentTest.testFunction;
|
|
const testName = currentTest.description;
|
|
currentTest.testFunction = async (tapTools) => {
|
|
// Run global beforeEach if configured
|
|
if (settings.beforeEach) {
|
|
await settings.beforeEach(testName);
|
|
}
|
|
|
|
// Run the actual test
|
|
let testPassed = true;
|
|
let result: any;
|
|
try {
|
|
result = await originalFunction(tapTools);
|
|
} catch (error) {
|
|
testPassed = false;
|
|
throw error;
|
|
} finally {
|
|
// Run global afterEach if configured
|
|
if (settings.afterEach) {
|
|
await settings.afterEach(testName, testPassed);
|
|
}
|
|
}
|
|
|
|
return result;
|
|
};
|
|
|
|
const testPromise = currentTest.run(testKey++);
|
|
if (currentTest.parallel) {
|
|
promiseArray.push(testPromise);
|
|
} else {
|
|
await testPromise;
|
|
}
|
|
}
|
|
|
|
await Promise.all(promiseArray);
|
|
|
|
// when tests have been run and all promises are fullfilled
|
|
const failReasons: string[] = [];
|
|
const executionNotes: string[] = [];
|
|
// collect failed tests
|
|
for (const tapTest of concerningTests) {
|
|
if (tapTest.status !== 'success' && tapTest.status !== 'skipped') {
|
|
failReasons.push(
|
|
`Test ${tapTest.testKey + 1} failed with status ${tapTest.status}:\n` +
|
|
`|| ${tapTest.description}\n` +
|
|
`|| for more information please take a look the logs above`,
|
|
);
|
|
}
|
|
}
|
|
|
|
// render fail Reasons
|
|
for (const failReason of failReasons) {
|
|
console.log(failReason);
|
|
}
|
|
|
|
// Run global afterAll hook if configured
|
|
if (settings.afterAll) {
|
|
try {
|
|
await settings.afterAll();
|
|
} catch (error) {
|
|
console.error('Error in afterAll hook:', error);
|
|
// Don't throw here, we want to complete the test run
|
|
}
|
|
}
|
|
|
|
if (optionsArg && optionsArg.throwOnError && failReasons.length > 0) {
|
|
if (!smartenvInstance.isBrowser && typeof process !== 'undefined') process.exit(1);
|
|
}
|
|
if (smartenvInstance.isBrowser) {
|
|
globalPromise.resolve();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Emit an event
|
|
*/
|
|
private emitEvent(event: ITestEvent) {
|
|
console.log(this.protocolEmitter.emitEvent(event));
|
|
}
|
|
|
|
/**
|
|
* Run tests in a suite with lifecycle hooks
|
|
*/
|
|
private async _runSuite(
|
|
parentSuite: ITestSuite | null,
|
|
suites: ITestSuite[],
|
|
promiseArray: Promise<any>[],
|
|
context: { testKey: number }
|
|
) {
|
|
for (const suite of suites) {
|
|
// Emit suite:started event
|
|
this.emitEvent({
|
|
eventType: 'suite:started',
|
|
timestamp: Date.now(),
|
|
data: {
|
|
suiteName: suite.description
|
|
}
|
|
});
|
|
// Run beforeEach from parent suites
|
|
const beforeEachFunctions: ITestFunction<any>[] = [];
|
|
let currentSuite: ITestSuite | null = suite;
|
|
while (currentSuite) {
|
|
if (currentSuite.beforeEach) {
|
|
beforeEachFunctions.unshift(currentSuite.beforeEach);
|
|
}
|
|
currentSuite = currentSuite.parent || null;
|
|
}
|
|
|
|
// Run tests in this suite
|
|
for (const test of suite.tests) {
|
|
// Create wrapper test function that includes lifecycle hooks
|
|
const originalFunction = test.testFunction;
|
|
const testName = test.description;
|
|
test.testFunction = async (tapTools) => {
|
|
// Run global beforeEach if configured
|
|
const settings = this.settingsManager.getSettings();
|
|
if (settings.beforeEach) {
|
|
await settings.beforeEach(testName);
|
|
}
|
|
|
|
// Run all suite beforeEach hooks
|
|
for (const beforeEach of beforeEachFunctions) {
|
|
await beforeEach(tapTools);
|
|
}
|
|
|
|
// Run the actual test
|
|
let testPassed = true;
|
|
let result: any;
|
|
try {
|
|
result = await originalFunction(tapTools);
|
|
} catch (error) {
|
|
testPassed = false;
|
|
throw error;
|
|
} finally {
|
|
// Run afterEach hooks in reverse order
|
|
const afterEachFunctions: ITestFunction<any>[] = [];
|
|
currentSuite = suite;
|
|
while (currentSuite) {
|
|
if (currentSuite.afterEach) {
|
|
afterEachFunctions.push(currentSuite.afterEach);
|
|
}
|
|
currentSuite = currentSuite.parent || null;
|
|
}
|
|
|
|
for (const afterEach of afterEachFunctions) {
|
|
await afterEach(tapTools);
|
|
}
|
|
|
|
// Run global afterEach if configured
|
|
if (settings.afterEach) {
|
|
await settings.afterEach(testName, testPassed);
|
|
}
|
|
}
|
|
|
|
return result;
|
|
};
|
|
|
|
const testPromise = test.run(context.testKey++);
|
|
if (test.parallel) {
|
|
promiseArray.push(testPromise);
|
|
} else {
|
|
await testPromise;
|
|
}
|
|
}
|
|
|
|
// Recursively run child suites
|
|
await this._runSuite(suite, suite.children, promiseArray, context);
|
|
|
|
// Emit suite:completed event
|
|
this.emitEvent({
|
|
eventType: 'suite:completed',
|
|
timestamp: Date.now(),
|
|
data: {
|
|
suiteName: suite.description
|
|
}
|
|
});
|
|
}
|
|
}
|
|
|
|
public async stopForcefully(codeArg = 0, directArg = false) {
|
|
console.log(`tap stopping forcefully! Code: ${codeArg} / Direct: ${directArg}`);
|
|
if (typeof process !== 'undefined') {
|
|
if (directArg) {
|
|
process.exit(codeArg);
|
|
} else {
|
|
setTimeout(() => {
|
|
process.exit(codeArg);
|
|
}, 10);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* handle errors
|
|
*/
|
|
public threw(err: Error) {
|
|
console.log(err);
|
|
}
|
|
|
|
/**
|
|
* Explicitly fail the current test with a custom message
|
|
* @param message - The failure message to display
|
|
*/
|
|
public fail(message: string = 'Test failed'): never {
|
|
throw new Error(message);
|
|
}
|
|
}
|
|
|
|
export const tap = new Tap();
|