xunit.ts 2.0.0 → 3.0.0

package/src/Assertions/StringContains.ts

@@ -1,4 +1,4 @@
-import { AssertionError } from "assert";
+import { AssertionError } from "node:assert";
 
 /**
  * Asserts that a string contains a given substring
@@ -16,7 +16,7 @@ import { AssertionError } from "assert";
  * this.assert.stringContains(needle, haystack);
  */
 export default function StringContains(needle: string, haystack: string | null, message?: string) {
-	if (haystack !== undefined && haystack !== null && haystack.indexOf(needle) > -1) {
+	if (haystack?.includes(needle)) {
 		return;
 	}
 

package/src/Assertions/StringDoesNotContain.ts

@@ -1,4 +1,4 @@
-import { AssertionError } from "assert";
+import { AssertionError } from "node:assert";
 
 /**
  * Asserts that a string does not contain a given substring
@@ -16,7 +16,7 @@ import { AssertionError } from "assert";
  * this.assert.stringDoesNotContain(needle, haystack);
  */
 export default function StringDoesNotContain(needle: string, haystack: string | null, message?: string) {
-	if (haystack === undefined || haystack === null || haystack.indexOf(needle) === -1) {
+	if (!haystack?.includes(needle)) {
 		return;
 	}
 

package/src/Assertions/StringDoesNotEndWith.ts

@@ -1,4 +1,4 @@
-import { AssertionError } from "assert";
+import { AssertionError } from "node:assert";
 
 /**
  * Asserts that a string does not end with a given substring
@@ -16,9 +16,7 @@ import { AssertionError } from "assert";
  * this.assert.stringDoesNotEndWith(needle, haystack);
  */
 export default function StringDoesNotEndWith(needle: string, haystack: string | null, message?: string) {
-	if (haystack === undefined || haystack === null
-		|| haystack.indexOf(needle) === -1
-		|| haystack.indexOf(needle) !== haystack.length - needle.length) {
+	if (!haystack?.endsWith(needle)) {
 		return;
 	}
 

package/src/Assertions/StringDoesNotMatch.ts

@@ -1,4 +1,4 @@
-import { AssertionError } from "assert";
+import { AssertionError } from "node:assert";
 
 /**
  * Asserts that a string does not match a given regular expression
@@ -15,7 +15,7 @@ import { AssertionError } from "assert";
  * @example
  * this.assert.stringDoesNotMatch(regex, haystack);
  */
-export default function StringDoesNotMatch(regex: RegExp, haystack: string | null, message?: string) {
+export default function StringDoesNotMatch(regex: RegExp, haystack?: string | null, message?: string) {
 	if (haystack === undefined || haystack === null || !regex.test(haystack)) {
 		return;
 	}

package/src/Assertions/StringDoesNotStartWith.ts

@@ -1,4 +1,4 @@
-import { AssertionError } from "assert";
+import { AssertionError } from "node:assert";
 
 /**
  * Asserts that a string does not begin with a given substring

package/src/Assertions/StringEndsWith.ts

@@ -1,4 +1,4 @@
-import { AssertionError } from "assert";
+import { AssertionError } from "node:assert";
 
 /**
  * Asserts that a string ends with a given substring
@@ -16,9 +16,7 @@ import { AssertionError } from "assert";
  * this.assert.stringEndsWith(needle, haystack);
  */
 export default function StringEndsWith(needle: string, haystack: string | null, message?: string) {
-	if (haystack !== undefined && haystack !== null
-		&& haystack.indexOf(needle) > -1
-		&& haystack.indexOf(needle) === haystack.length - needle.length) {
+	if (haystack?.endsWith(needle)) {
 		return;
 	}
 

package/src/Assertions/StringMatches.ts

@@ -1,4 +1,4 @@
-import { AssertionError } from "assert";
+import { AssertionError } from "node:assert";
 
 /**
  * Asserts that a string matches a given regular expression
@@ -15,7 +15,7 @@ import { AssertionError } from "assert";
  * @example
  * this.assert.stringMatches(regex, haystack);
  */
-export default function StringMatches(regex: RegExp, haystack: string | null, message?: string) {
+export default function StringMatches(regex: RegExp, haystack?: string | null, message?: string) {
 	if (haystack !== undefined && haystack !== null && regex.test(haystack)) {
 		return;
 	}

package/src/Assertions/StringStartsWith.ts

@@ -1,4 +1,4 @@
-import { AssertionError } from "assert";
+import { AssertionError } from "node:assert";
 
 /**
  * Asserts that a string begins with a given substring

package/src/Assertions/Throws.ts

@@ -1,4 +1,4 @@
-import { AssertionError } from "assert";
+import { AssertionError } from "node:assert";
 
 /**
  * Asserts that an expression throws an error/exception
@@ -14,10 +14,10 @@ import { AssertionError } from "assert";
  * @example
  * this.assert.throws(() => expression);
  */
-export default function Throws(expression: () => any, message?: string) {
+export default function Throws(expression: () => unknown, message?: string) {
 	try {
 		expression();
-	} catch (exception) {
+	} catch {
 		return;
 	}
 

package/src/Assertions/True.ts

@@ -1,4 +1,4 @@
-import { AssertionError } from "assert";
+import { AssertionError } from "node:assert";
 
 /**
  * Asserts that a given expression evaluates to `true`
@@ -14,7 +14,7 @@ import { AssertionError } from "assert";
  * @example
  * this.assert.true(expression);
  */
-export default function True(expression: any, message?: string) {
+export default function True(expression: unknown, message?: string) {
 	if (expression === true) {
 		return;
 	}

package/src/Assertions/Undefined.ts

@@ -1,4 +1,4 @@
-import { AssertionError } from "assert";
+import { AssertionError } from "node:assert";
 
 /**
  * Asserts that a given value is equal to `undefined`
@@ -14,7 +14,7 @@ import { AssertionError } from "assert";
  * @example
  * this.assert.undefined(expression);
  */
-export default function Undefined(expression: any, message?: string) {
+export default function Undefined(expression: unknown, message?: string) {
 	if (expression === undefined) {
 		return;
 	}

package/src/Assertions/index.ts

@@ -1,39 +1,27 @@
-import is_true from "./True";
-import is_false from "./False";
-
-import is_undefined from "./Undefined";
+import contains from "./Contains";
+import count from "./Count";
 import is_defined from "./Defined";
-
-import is_null from "./Null";
-import not_null from "./NotNull";
-
-import equal from "./Equal";
-import not_equal from "./NotEqual";
-
+import not_contains from "./DoesNotContain";
+import does_not_throw from "./DoesNotThrow";
 import empty from "./Empty";
+import equal from "./Equal";
+import is_false from "./False";
+import instance_of from "./InstanceOf";
 import not_empty from "./NotEmpty";
-
-import count from "./Count";
-
-import contains from "./Contains";
-import not_contains from "./DoesNotContain";
-
+import not_equal from "./NotEqual";
+import not_null from "./NotNull";
+import is_null from "./Null";
 import string_contains from "./StringContains";
 import string_not_contains from "./StringDoesNotContain";
-
-import string_starts from "./StringStartsWith";
+import string_not_ends from "./StringDoesNotEndWith";
+import string_not_matches from "./StringDoesNotMatch";
 import string_not_starts from "./StringDoesNotStartWith";
-
 import string_ends from "./StringEndsWith";
-import string_not_ends from "./StringDoesNotEndWith";
-
 import string_matches from "./StringMatches";
-import string_not_matches from "./StringDoesNotMatch";
-
-import instance_of from "./InstanceOf";
-
+import string_starts from "./StringStartsWith";
 import throws from "./Throws";
-import does_not_throw from "./DoesNotThrow";
+import is_true from "./True";
+import is_undefined from "./Undefined";
 
 export default new class AssertionLibrary {
 	true = is_true;

package/src/CLI.ts

@@ -1,10 +1,12 @@
-import Usage from "command-line-usage";
-import JUnitReporter from "./Reporters/JUnitReporter";
-import Process from "process";
+import Process from "node:process";
+
 import Args from "command-line-args";
+import Usage from "command-line-usage";
 import SafeRegex from "lodash.escaperegexp";
-import Runner from "./Runners/Runner";
+
+import JUnitReporter from "./Reporters/JUnitReporter";
 import SonarReporter from "./Reporters/SonarReporter";
+import Runner from "./Runners/Runner";
 
 export default class CLI {
 	private static readonly options: Usage.OptionDefinition[] = [
@@ -97,9 +99,10 @@ export default class CLI {
 		const runner = this.runnerFactory(args);
 
 		try {
-			const filters: string[] = args.filter ?? [];
+			const argFilter = args.filter as string[] | undefined;
+			const filters: string[] = argFilter ?? [];
 			const regexFilters = filters.map((f: string) => new RegExp(SafeRegex(f)));
-			const results = await runner.runAll(args.dir, regexFilters);
+			const results = await runner.runAll(args.dir as string, regexFilters);
 			return Runner.allTestsPassed(results);
 		} catch (error) {
 			if (error instanceof Error) {

package/src/Factory.ts

@@ -1,15 +1,17 @@
+import fs from "node:fs/promises";
+
 import Args from "command-line-args";
-import ConsoleReporter from "./Reporters/ConsoleReporter";
+
 import FileSystem from "./IO/FileSystem";
-import JUnitReporter from "./Reporters/JUnitReporter";
 import Output from "./IO/Output";
+import ConsoleReporter from "./Reporters/ConsoleReporter";
+import JUnitReporter from "./Reporters/JUnitReporter";
 import ResultReporter from "./Reporters/ResultReporter";
+import SonarReporter from "./Reporters/SonarReporter";
 import Runner from "./Runners/Runner";
 import TestRunner from "./Runners/TestRunner";
 import TestSuiteLoader from "./Runners/TestSuiteLoader";
 import TestSuiteRunner from "./Runners/TestSuiteRunner";
-import fs from "fs/promises";
-import SonarReporter from "./Reporters/SonarReporter";
 
 export default class Factory {
 	static readonly file_system = new FileSystem(fs);
@@ -23,11 +25,11 @@ export default class Factory {
 		return new Runner(loader, test_suite_runner, reporters);
 	}
 
-	static Reporters(args: Args.CommandLineOptions): ReadonlyArray<ResultReporter> {
+	static Reporters(args: Args.CommandLineOptions): readonly ResultReporter[] {
 		return [
-			!args.quiet ? new ConsoleReporter(new Output(process.stdout)) : null,
-			args.junit !== undefined ? new JUnitReporter(Factory.file_system, args.junit ?? JUnitReporter.defaultFileName) : null,
-			args.sonar !== undefined ? new SonarReporter(Factory.file_system, args.sonar ?? SonarReporter.defaultFileName) : null
-		].filter(r => r !== null) as ResultReporter[];
+			args.quiet ? null : new ConsoleReporter(new Output(process.stdout)),
+			args.junit === undefined ? null : new JUnitReporter(Factory.file_system, args.junit as string | undefined ?? JUnitReporter.defaultFileName),
+			args.sonar === undefined ? null : new SonarReporter(Factory.file_system, args.sonar as string | undefined ?? SonarReporter.defaultFileName)
+		].filter(r => r !== null);
 	}
 }

package/src/Framework/Test.ts

@@ -1,6 +1,6 @@
-import TestSuite from "./TestSuite";
 import TestInfo from "./TestInfo";
 import TestName from "./TestName";
+import TestSuite from "./TestSuite";
 
 /**
  * Annotates a test method within a {@link TestSuite}

package/src/Framework/TestInfo.ts

@@ -1,2 +1,8 @@
-type TestInfo = TypedPropertyDescriptor<() => Promise<void>>;
+type AsyncTest = () => Promise<void>;
+type SyncTest = () => void;
+
+export type AsyncTestInfo = TypedPropertyDescriptor<AsyncTest>;
+export type SyncTestInfo = TypedPropertyDescriptor<SyncTest>;
+
+type TestInfo = AsyncTestInfo | SyncTestInfo;
 export default TestInfo;

package/src/Framework/TestName.ts

@@ -1,8 +1,8 @@
 export default class TestName {
 	static toSentenceCase(test_name: string) {
 		const result = test_name
-			.replace(/_([A-Z])/gi, (substring: string, match: string) => match.toUpperCase())
-			.replace(/([A-Z])/g, " $1")
+			.replaceAll(/_([A-Z])/gi, (substring: string, match: string) => match.toUpperCase())
+			.replaceAll(/([A-Z])/g, " $1")
 			.trim();
 		return result.charAt(0).toUpperCase() + result.slice(1);
 	}

package/src/Framework/TestSuite.ts

@@ -1,5 +1,5 @@
-import TestInfo from "./TestInfo";
 import AssertionLibrary from "../Assertions";
+import TestInfo from "./TestInfo";
 
 /**
  * Defines a container of tests
@@ -13,12 +13,10 @@ import AssertionLibrary from "../Assertions";
 export default abstract class TestSuite {
 	assert = AssertionLibrary;
 
-	private tests: Record<string, TestInfo> = {};
+	private tests?: Record<string, TestInfo> = {};
 
 	addTest(name: string, info: TestInfo) {
-		if (this.tests === undefined || this.tests === null) {
-			this.tests = {};
-		}
+		this.tests ??= {};
 		this.tests[name] = info;
 	}
 
@@ -33,14 +31,18 @@ export default abstract class TestSuite {
 	}
 
 	filteredTests(filters: RegExp[]) {
-		if (!this.tests)
+		const tests = this.tests;
+		if (tests === undefined)
 			return {};
 
+		const keys = Object.keys(tests)
+			.filter(k => filters.map(f => f.test(`${this.constructor.name}.${tests[k].value?.name}`)).some(Boolean));
+
 		const filtered: Record<string, TestInfo> = {};
-		const keys = Object.keys(this.tests).filter(k => filters.map(f => f.test(`${this.constructor.name}.${this.tests[k].value?.name}`)).filter(m => m).length > 0);
 		keys.forEach(k => {
-			filtered[k] = this.tests[k];
+			filtered[k] = tests[k];
 		});
+
 		return filtered;
 	}
 }

package/src/IO/FileSystem.ts

@@ -1,5 +1,5 @@
-import fs_promises from "fs/promises";
-import path from "path";
+import fs_promises from "node:fs/promises";
+import path from "node:path";
 
 export default class FileSystem {
 
@@ -10,7 +10,7 @@ export default class FileSystem {
 
 	static extension(file: string) {
 		const match = this.matchExtension.exec(file);
-		return match !== undefined && match !== null && match.length > 1
+		return match && match.length > 1
 			? match[1]
 			: "";
 	}
@@ -27,7 +27,7 @@ export default class FileSystem {
 					: [ item_path ]);
 			}
 			return files;
-		} catch (e) {
+		} catch {
 			return [];
 		}
 	}

package/src/IO/Output.ts

@@ -1,4 +1,4 @@
-import { WriteStream } from "tty";
+import { WriteStream } from "node:tty";
 
 export default class Output {
 

package/src/Reporters/ConsoleReporter.ts

@@ -1,11 +1,14 @@
-import ResultReporter from "./ResultReporter";
-import TestSuite from "../Framework/TestSuite";
-import Output from "../IO/Output";
-import TestName from "../Framework/TestName";
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import { AssertionError } from "node:assert";
+
 import colors from "colors";
-import { AssertionError } from "assert";
-import TestSuiteResults from "../Framework/TestSuiteResults";
+
 import { ResultType } from "../Framework/ResultType";
+import TestName from "../Framework/TestName";
+import TestSuite from "../Framework/TestSuite";
+import TestSuiteResults from "../Framework/TestSuiteResults";
+import Output from "../IO/Output";
+import ResultReporter from "./ResultReporter";
 
 export default class ConsoleReporter implements ResultReporter {
 
@@ -42,11 +45,10 @@ export default class ConsoleReporter implements ResultReporter {
 	testErrored(suite: TestSuite, test_name: string, error: Error, duration: number): void {
 		this.out.write(` (${Math.round(duration)} ms)`);
 		this.out.overwrite(`  ${colors.red("✘")}\n`);
-		this.out.writeLine(`  ${error.stack}`);
+		this.out.writeLine(`  ${error.stack ?? ""}`);
 		this.out.writeLine();
 	}
 
-	// eslint-disable-next-line @typescript-eslint/no-unused-vars
 	testIncomplete(suite: TestSuite, test_name: string): void {
 		this.out.overwrite(`  ${colors.yellow("?")}\n`);
 	}
@@ -61,15 +63,15 @@ export default class ConsoleReporter implements ResultReporter {
 		this.out.writeLine();
 	}
 
-	runCompleted(suites: Record<string, TestSuiteResults>): void {
+	async runCompleted(suites: Record<string, TestSuiteResults>): Promise<void> {
 		const results = Object.values(suites);
 		if (!results.length) {
 			this.out.writeLine("No tests found!");
-			return;
+			return Promise.resolve();
 		}
 
 		const sum = (result_type?: ResultType) => results
-			.map((suite_result) => result_type !== undefined ? suite_result.count(result_type) : suite_result.total())
+			.map((suite_result) => result_type === undefined ? suite_result.total() : suite_result.count(result_type))
 			.reduce((acc, current) => acc + current, 0);
 
 		const result = (result_type?: ResultType, color: (string: string) => string = colors.white) => {

package/src/Reporters/FileReporter.ts

@@ -1,11 +1,13 @@
-import ResultReporter from "./ResultReporter";
-import TestSuiteResults from "../Framework/TestSuiteResults";
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import { AssertionError } from "node:assert";
+
 import TestSuite from "../Framework/TestSuite";
-import { AssertionError } from "assert";
+import TestSuiteResults from "../Framework/TestSuiteResults";
 import FileSystem from "../IO/FileSystem";
+import ResultReporter from "./ResultReporter";
 
 export default abstract class FileReporter implements ResultReporter {
-	/* eslint-disable @typescript-eslint/no-unused-vars */
+
 	constructor(protected readonly file_system: FileSystem, protected readonly path: string) {
 	}
 
@@ -41,5 +43,5 @@ export default abstract class FileReporter implements ResultReporter {
 		return;
 	}
 
-	abstract runCompleted(results: Record<string, TestSuiteResults>): void;
+	abstract runCompleted(results: Record<string, TestSuiteResults>): Promise<void>;
 }

package/src/Reporters/JUnitReporter.ts

@@ -1,8 +1,9 @@
-import TestSuiteResults from "../Framework/TestSuiteResults";
 import xml from "xml";
-import TestName from "../Framework/TestName";
+
 import { ResultType } from "../Framework/ResultType";
+import TestName from "../Framework/TestName";
 import TestResult from "../Framework/TestResult";
+import TestSuiteResults from "../Framework/TestSuiteResults";
 import XMLReporter from "./XMLReporter";
 
 export default class JUnitReporter extends XMLReporter {

package/src/Reporters/ResultReporter.ts

@@ -1,5 +1,6 @@
+import { AssertionError } from "node:assert";
+
 import TestSuite from "../Framework/TestSuite";
-import { AssertionError } from "assert";
 import TestSuiteResults from "../Framework/TestSuiteResults";
 
 export default interface ResultReporter {
@@ -19,5 +20,5 @@ export default interface ResultReporter {
 
 	suiteCompleted(suite: TestSuite, results: TestSuiteResults): void;
 
-	runCompleted(results: Record<string, TestSuiteResults>): void;
-}
+	runCompleted(results: Record<string, TestSuiteResults>): Promise<void>;
+};

package/src/Reporters/SonarReporter.ts

@@ -1,9 +1,11 @@
-import TestSuiteResults from "../Framework/TestSuiteResults";
+import path from "node:path";
+
 import xml from "xml";
+
 import { ResultType } from "../Framework/ResultType";
 import TestResult from "../Framework/TestResult";
+import TestSuiteResults from "../Framework/TestSuiteResults";
 import XMLReporter from "./XMLReporter";
-import path from "path";
 
 export default class SonarReporter extends XMLReporter {
 	static readonly defaultFileName: string = "sonar.xml";

package/src/Reporters/XMLReporter.ts

@@ -1,5 +1,5 @@
-import FileReporter from "./FileReporter";
-import TestSuiteResults from "../Framework/TestSuiteResults";
+import TestSuiteResults from "../Framework/TestSuiteResults";
+import FileReporter from "./FileReporter";
 
 export default abstract class XMLReporter extends FileReporter {
 	async runCompleted(results: Record<string, TestSuiteResults>): Promise<void> {

package/src/Runners/Runner.ts

@@ -1,12 +1,12 @@
+import { ResultType } from "../Framework/ResultType";
+import TestSuiteResults from "../Framework/TestSuiteResults";
+import ResultReporter from "../Reporters/ResultReporter";
 import TestSuiteLoader from "./TestSuiteLoader";
 import TestSuiteRunner from "./TestSuiteRunner";
-import ResultReporter from "../Reporters/ResultReporter";
-import TestSuiteResults from "../Framework/TestSuiteResults";
-import { ResultType } from "../Framework/ResultType";
 
 export default class Runner {
 
-	constructor(private readonly loader: TestSuiteLoader, private readonly runner: TestSuiteRunner, private readonly reporters: ReadonlyArray<ResultReporter>) {
+	constructor(private readonly loader: TestSuiteLoader, private readonly runner: TestSuiteRunner, private readonly reporters: readonly ResultReporter[]) {
 	}
 
 	static allTestsPassed(results: Record<string, TestSuiteResults>): boolean {
@@ -16,7 +16,7 @@ export default class Runner {
 	}
 
 	async runAll(dir: string, filters: RegExp[]): Promise<Record<string, TestSuiteResults>> {
-		await Promise.all(this.reporters.map(r => r.runStarted()));
+		this.reporters.map(r => r.runStarted());
 		const results: Record<string, TestSuiteResults> = {};
 		const suites = await this.loader.loadTestSuites(dir, filters);
 		for (const file of Object.keys(suites)) {

package/src/Runners/TestRunner.ts

@@ -1,13 +1,14 @@
-import TestInfo from "../Framework/TestInfo";
-import TestSuite from "../Framework/TestSuite";
+import { AssertionError } from "node:assert";
+
 import { ResultType } from "../Framework/ResultType";
-import ResultReporter from "../Reporters/ResultReporter";
+import TestInfo, { AsyncTestInfo, SyncTestInfo } from "../Framework/TestInfo";
 import TestResult from "../Framework/TestResult";
-import { AssertionError } from "assert";
+import TestSuite from "../Framework/TestSuite";
+import ResultReporter from "../Reporters/ResultReporter";
 
 export default class TestRunner {
 
-	constructor(private readonly reporters: ReadonlyArray<ResultReporter>) {
+	constructor(private readonly reporters: readonly ResultReporter[]) {
 	}
 
 	private static msSince(start: [ number, number ]) {
@@ -15,29 +16,36 @@ export default class TestRunner {
 		return duration[0] * 1_000 + duration[1] / 1_000_000;
 	}
 
+	private static isSyncTest = (test?: TestInfo): test is SyncTestInfo|undefined => test !== undefined;
+	private static isAsyncTest = (test?: TestInfo): test is AsyncTestInfo|undefined => test !== undefined;
+
 	async runTest(name: string, info: TestInfo, suite: TestSuite): Promise<TestResult> {
-		await Promise.all(this.reporters.map(r => r.testStarted(suite, name)));
+		this.reporters.map(r => r.testStarted(suite, name));
 		if (info.value === undefined) {
-			await Promise.all(this.reporters.map(r => r.testIncomplete(suite, name)));
+			this.reporters.map(r => r.testIncomplete(suite, name));
 			return new TestResult(ResultType.Incomplete, 0);
 		}
 
 		const start = process.hrtime();
 		try {
-			await info.value.call(suite);
+			if (TestRunner.isAsyncTest(info))
+				await info.value.call(suite);
+			else if (TestRunner.isSyncTest(info))
+				info.value.call(suite);
+
 			const duration = TestRunner.msSince(start);
-			await Promise.all(this.reporters.map(r => r.testPassed(suite, name, duration)));
+			this.reporters.map(r => r.testPassed(suite, name, duration));
 			return new TestResult(ResultType.Passed, duration);
 
 		} catch (error) {
 			const duration = TestRunner.msSince(start);
 			const typedError = error as Error;
 			if (typedError instanceof AssertionError) {
-				await Promise.all(this.reporters.map(r => r.testFailed(suite, name, typedError, duration)));
+				this.reporters.map(r => r.testFailed(suite, name, typedError, duration));
 				return new TestResult(ResultType.Failed, duration, typedError);
 			}
 
-			await Promise.all(this.reporters.map(r => r.testErrored(suite, name, typedError, duration)));
+			this.reporters.map(r => r.testErrored(suite, name, typedError, duration));
 			return new TestResult(ResultType.Error, duration, typedError);
 		}
 	}