xunit.ts 1.4.0 → 2.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "xunit.ts",
-	"version": "1.4.0",
+	"version": "2.0.0",
 	"description": "A unit testing framework for TypeScript, following standard xUnit patterns",
 	"main": "dist/xunit.js",
 	"author": "ecoAPM LLC",
@@ -8,28 +8,28 @@
 	"bugs": "https://github.com/ecoAPM/xunit.ts/issues",
 	"license": "MIT",
 	"engines": {
-		"node": ">= 14"
+		"node": ">= 18"
 	},
 	"dependencies": {
 		"colors": "1.4.0",
-		"command-line-args": "5.2.1",
-		"command-line-usage": "7.0.1",
+		"command-line-args": "6.0.1",
+		"command-line-usage": "7.0.3",
 		"lodash.escaperegexp": "4.1.2",
 		"lodash.isequal": "4.5.0",
 		"xml": "1.0.1"
 	},
 	"devDependencies": {
-		"@types/command-line-args": "5.2.0",
-		"@types/command-line-usage": "5.0.2",
-		"@types/lodash.escaperegexp": "4.1.7",
-		"@types/lodash.isequal": "4.5.6",
-		"@types/node": "18.15.7",
-		"@types/xml": "1.0.8",
-		"@typescript-eslint/eslint-plugin": "5.56.0",
-		"@typescript-eslint/parser": "5.56.0",
-		"eslint": "8.36.0",
+		"@types/command-line-args": "5.2.3",
+		"@types/command-line-usage": "5.0.4",
+		"@types/lodash.escaperegexp": "4.1.9",
+		"@types/lodash.isequal": "4.5.8",
+		"@types/node": "22.10.6",
+		"@types/xml": "1.0.11",
+		"@typescript-eslint/eslint-plugin": "8.20.0",
+		"@typescript-eslint/parser": "8.20.0",
+		"eslint": "9.18.0",
 		"ts-mockito": "2.6.1",
-		"typescript": "5.0.2"
+		"typescript": "5.7.3"
 	},
 	"peerDependencies": {
 		"typescript": ">= 4"

package/src/Assertions/Contains.ts

@@ -21,7 +21,7 @@ export default function Contains<T>(needle: T, haystack: ReadonlyArray<T>, messa
 	}
 
 	throw new AssertionError({
-		message: message || "Expected array containing expression, but array did not contain expression",
+		message: message ?? "Expected array containing expression, but array did not contain expression",
 		expected: needle,
 		actual: haystack
 	});

package/src/Assertions/Count.ts

@@ -21,7 +21,7 @@ export default function Count(expected: number, array: ReadonlyArray<any>, messa
 	}
 
 	throw new AssertionError({
-		message: message || `Expected array with ${expected} elements, but array had ${array.length} elements`,
+		message: message ?? `Expected array with ${expected} elements, but array had ${array.length} elements`,
 		expected: expected,
 		actual: array.length
 	});

package/src/Assertions/Defined.ts

@@ -20,7 +20,7 @@ export default function Defined(expression: any, message?: string) {
 	}
 
 	throw new AssertionError({
-		message: message || "Expected expression to be defined, but expression is undefined",
+		message: message ?? "Expected expression to be defined, but expression is undefined",
 		expected: "(not undefined expression)",
 		actual: expression
 	});

package/src/Assertions/DoesNotContain.ts

@@ -21,7 +21,7 @@ export default function DoesNotContain<T>(needle: T, haystack: ReadonlyArray<T>,
 	}
 
 	throw new AssertionError({
-		message: message || "Expected array not containing expression, but array contained expression",
+		message: message ?? "Expected array not containing expression, but array contained expression",
 		expected: needle,
 		actual: haystack
 	});

package/src/Assertions/DoesNotThrow.ts

@@ -20,7 +20,7 @@ export default function DoesNotThrow(expression: () => any, message?: string) {
 		return;
 	} catch (exception) {
 		throw new AssertionError({
-			message: message || "Expected expression to not throw exception, but expression did throw exception",
+			message: message ?? "Expected expression to not throw exception, but expression did throw exception",
 			expected: "(no exception)",
 			actual: exception
 		});

package/src/Assertions/Empty.ts

@@ -20,7 +20,7 @@ export default function Empty(array: ReadonlyArray<any>, message?: string) {
 	}
 
 	throw new AssertionError({
-		message: message || "Expected expression to be empty, but expression was not empty",
+		message: message ?? "Expected expression to be empty, but expression was not empty",
 		expected: [],
 		actual: array
 	});

package/src/Assertions/Equal.ts

@@ -22,7 +22,7 @@ export default function Equal(expected: any, actual: any, message?: string) {
 	}
 
 	throw new AssertionError({
-		message: message || "Expected expressions to be equal, but expressions are not equal",
+		message: message ?? "Expected expressions to be equal, but expressions are not equal",
 		expected: expected,
 		actual: actual,
 	});

package/src/Assertions/False.ts

@@ -20,7 +20,7 @@ export default function False(expression: any, message?: string) {
 	}
 
 	throw new AssertionError({
-		message: message || "Expected expression to be false, but expression is not false",
+		message: message ?? "Expected expression to be false, but expression is not false",
 		expected: false,
 		actual: expression
 	});

package/src/Assertions/InstanceOf.ts

@@ -21,7 +21,7 @@ export default function InstanceOf(type: any, expression: any, message?: string)
 	}
 
 	throw new AssertionError({
-		message: message || `Expected expression of type, but was ${typeof expression}`,
+		message: message ?? `Expected expression of type, but was ${typeof expression}`,
 		expected: type.name,
 		actual: typeof expression
 	});

package/src/Assertions/NotEmpty.ts

@@ -20,7 +20,7 @@ export default function NotEmpty(array: ReadonlyArray<any>, message?: string) {
 	}
 
 	throw new AssertionError({
-		message: message || "Expected expression to be not empty, but expression was empty",
+		message: message ?? "Expected expression to be not empty, but expression was empty",
 		expected: "(non-empty expression)",
 		actual: array
 	});

package/src/Assertions/NotEqual.ts

@@ -22,7 +22,7 @@ export default function NotEqual(expected: any, actual: any, message?: string) {
 	}
 
 	throw new AssertionError({
-		message: message || "Expected expressions to be not equal, but expressions are equal",
+		message: message ?? "Expected expressions to be not equal, but expressions are equal",
 		expected: expected,
 		actual: actual,
 	});

package/src/Assertions/NotNull.ts

@@ -20,7 +20,7 @@ export default function NotNull(expression: any, message?: string) {
 	}
 
 	throw new AssertionError({
-		message: message || "Expected expression to be not null, but expression is null",
+		message: message ?? "Expected expression to be not null, but expression is null",
 		expected: "(non-null expression)",
 		actual: expression
 	});

package/src/Assertions/Null.ts

@@ -20,7 +20,7 @@ export default function Null(expression: any, message?: string) {
 	}
 
 	throw new AssertionError({
-		message: message || "Expected expression to be null, but expression is not null",
+		message: message ?? "Expected expression to be null, but expression is not null",
 		expected: null,
 		actual: expression
 	});

package/src/Assertions/StringContains.ts

@@ -21,7 +21,7 @@ export default function StringContains(needle: string, haystack: string | null,
 	}
 
 	throw new AssertionError({
-		message: message || "Expected string containing expression, but string did not contain expression",
+		message: message ?? "Expected string containing expression, but string did not contain expression",
 		expected: needle,
 		actual: haystack
 	});

package/src/Assertions/StringDoesNotContain.ts

@@ -21,7 +21,7 @@ export default function StringDoesNotContain(needle: string, haystack: string |
 	}
 
 	throw new AssertionError({
-		message: message || "Expected string not containing expression, but string did contain expression",
+		message: message ?? "Expected string not containing expression, but string did contain expression",
 		expected: needle,
 		actual: haystack
 	});

package/src/Assertions/StringDoesNotEndWith.ts

@@ -23,7 +23,7 @@ export default function StringDoesNotEndWith(needle: string, haystack: string |
 	}
 
 	throw new AssertionError({
-		message: message || "Expected string containing expression, but string did not contain expression",
+		message: message ?? "Expected string containing expression, but string did not contain expression",
 		expected: needle,
 		actual: haystack
 	});

package/src/Assertions/StringDoesNotMatch.ts

@@ -0,0 +1,28 @@
+import { AssertionError } from "assert";
+
+/**
+ * Asserts that a string does not match a given regular expression
+ *
+ * @remarks
+ * Passes if `haystack` does not pass a `regex` test
+ *
+ * Fails if `haystack` passes a `regex` test
+ *
+ * @param regex the regular expression to test
+ * @param haystack the string to search
+ * @param message (optional) message to display on failure
+ *
+ * @example
+ * this.assert.stringDoesNotMatch(regex, haystack);
+ */
+export default function StringDoesNotMatch(regex: RegExp, haystack: string | null, message?: string) {
+	if (haystack === undefined || haystack === null || !regex.test(haystack)) {
+		return;
+	}
+
+	throw new AssertionError({
+		message: message ?? "Expected string not pass regular expression test, but string did pass",
+		expected: regex.test(haystack),
+		actual: haystack
+	});
+}

package/src/Assertions/StringDoesNotStartWith.ts

@@ -16,12 +16,12 @@ import { AssertionError } from "assert";
  * this.assert.stringDoesNotStartWith(needle, haystack);
  */
 export default function StringDoesNotStartWith(needle: string, haystack: string | null, message?: string) {
-	if (haystack === undefined || haystack === null || haystack.indexOf(needle) !== 0) {
+	if (!haystack?.startsWith(needle)) {
 		return;
 	}
 
 	throw new AssertionError({
-		message: message || "Expected string containing expression, but string did not contain expression",
+		message: message ?? "Expected string containing expression, but string did not contain expression",
 		expected: needle,
 		actual: haystack
 	});

package/src/Assertions/StringEndsWith.ts

@@ -23,7 +23,7 @@ export default function StringEndsWith(needle: string, haystack: string | null,
 	}
 
 	throw new AssertionError({
-		message: message || "Expected string containing expression, but string did not contain expression",
+		message: message ?? "Expected string containing expression, but string did not contain expression",
 		expected: needle,
 		actual: haystack
 	});

package/src/Assertions/StringMatches.ts

@@ -0,0 +1,28 @@
+import { AssertionError } from "assert";
+
+/**
+ * Asserts that a string matches a given regular expression
+ *
+ * @remarks
+ * Passes if `haystack` matches a `regex` test
+ *
+ * Fails if `haystack` does not match a `regex` test
+ *
+ * @param regex the regular expression to match
+ * @param haystack the string to search
+ * @param message (optional) message to display on failure
+ *
+ * @example
+ * this.assert.stringMatches(regex, haystack);
+ */
+export default function StringMatches(regex: RegExp, haystack: string | null, message?: string) {
+	if (haystack !== undefined && haystack !== null && regex.test(haystack)) {
+		return;
+	}
+
+	throw new AssertionError({
+		message: message ?? "Expected string to match regular expression, but string did not match",
+		expected: regex,
+		actual: haystack
+	});
+}

package/src/Assertions/StringStartsWith.ts

@@ -16,12 +16,12 @@ import { AssertionError } from "assert";
  * this.assert.stringStartsWith(needle, haystack);
  */
 export default function StringStartsWith(needle: string, haystack: string | null, message?: string) {
-	if (haystack !== undefined && haystack !== null && haystack.indexOf(needle) === 0) {
+	if (haystack?.startsWith(needle)) {
 		return;
 	}
 
 	throw new AssertionError({
-		message: message || "Expected string containing expression, but string did not contain expression",
+		message: message ?? "Expected string containing expression, but string did not contain expression",
 		expected: needle,
 		actual: haystack
 	});

package/src/Assertions/Throws.ts

@@ -22,6 +22,6 @@ export default function Throws(expression: () => any, message?: string) {
 	}
 
 	throw new AssertionError({
-		message: message || "Expected expression to throw exception, but expression did not throw exception"
+		message: message ?? "Expected expression to throw exception, but expression did not throw exception"
 	});
 }

package/src/Assertions/True.ts

@@ -20,7 +20,7 @@ export default function True(expression: any, message?: string) {
 	}
 
 	throw new AssertionError({
-		message: message || "Expected expression to be true, but expression is not true",
+		message: message ?? "Expected expression to be true, but expression is not true",
 		expected: true,
 		actual: expression
 	});

package/src/Assertions/Undefined.ts

@@ -20,7 +20,7 @@ export default function Undefined(expression: any, message?: string) {
 	}
 
 	throw new AssertionError({
-		message: message || "Expected expression to be undefined, but expression is not undefined",
+		message: message ?? "Expected expression to be undefined, but expression is not undefined",
 		expected: undefined,
 		actual: expression
 	});

package/src/Assertions/index.ts

@@ -27,6 +27,9 @@ 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 throws from "./Throws";
@@ -62,6 +65,9 @@ export default new class AssertionLibrary {
 	stringEndsWith = string_ends;
 	stringDoesNotEndWith = string_not_ends;
 
+	stringMatches = string_matches;
+	stringDoesNotMatch = string_not_matches;
+
 	instanceOf = instance_of;
 
 	throws = throws;

package/src/CLI.ts

@@ -97,13 +97,14 @@ export default class CLI {
 		const runner = this.runnerFactory(args);
 
 		try {
-			const filters = args.filter ?? [];
-			const results = await runner.runAll(args.dir, filters.map(SafeRegex));
+			const filters: string[] = args.filter ?? [];
+			const regexFilters = filters.map((f: string) => new RegExp(SafeRegex(f)));
+			const results = await runner.runAll(args.dir, regexFilters);
 			return Runner.allTestsPassed(results);
 		} catch (error) {
 			if (error instanceof Error) {
 				this.process.stderr.write(`An unhandled ${error.name} occurred: ${error.message}\n`);
-				this.process.stderr.write(error.stack?.toString() || "(no call stack)\n");
+				this.process.stderr.write(error.stack?.toString() ?? "(no call stack)\n");
 			}
 			return false;
 		}

package/src/Framework/Test.ts

@@ -18,6 +18,6 @@ import TestName from "./TestName";
  */
 export default function Test(test_name?: string) {
 	return function (suite: TestSuite, method_name: string, info: TestInfo) {
-		suite.addTest(test_name || TestName.toSentenceCase(method_name), info);
+		suite.addTest(test_name ?? TestName.toSentenceCase(method_name), info);
 	};
 }

package/src/Framework/TestSuite.ts

@@ -33,6 +33,9 @@ export default abstract class TestSuite {
 	}
 
 	filteredTests(filters: RegExp[]) {
+		if (!this.tests)
+			return {};
+
 		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 => {

package/src/IO/FileSystem.ts

@@ -6,8 +6,10 @@ export default class FileSystem {
 	constructor(private readonly fs: typeof fs_promises) {
 	}
 
+	private static readonly matchExtension: RegExp = new RegExp(/\.(\w+)$/);
+
 	static extension(file: string) {
-		const match = file.match(/\.(\w+)$/);
+		const match = this.matchExtension.exec(file);
 		return match !== undefined && match !== null && match.length > 1
 			? match[1]
 			: "";

package/src/Reporters/ConsoleReporter.ts

@@ -70,7 +70,7 @@ export default class ConsoleReporter implements ResultReporter {
 
 		const sum = (result_type?: ResultType) => results
 			.map((suite_result) => result_type !== undefined ? suite_result.count(result_type) : suite_result.total())
-			.reduce((acc, current) => acc + current);
+			.reduce((acc, current) => acc + current, 0);
 
 		const result = (result_type?: ResultType, color: (string: string) => string = colors.white) => {
 			const count = sum(result_type).toString();