xunit.ts 1.0.1 → 1.1.0

package/src/Assertions/index.ts

@@ -1,69 +1,69 @@
-import is_true from './True';
-import is_false from './False';
+import is_true from "./True";
+import is_false from "./False";
 
-import is_undefined from './Undefined';
-import is_defined from './Defined';
+import is_undefined from "./Undefined";
+import is_defined from "./Defined";
 
-import is_null from './Null';
-import not_null from './NotNull';
+import is_null from "./Null";
+import not_null from "./NotNull";
 
-import equal from './Equal';
-import not_equal from './NotEqual';
+import equal from "./Equal";
+import not_equal from "./NotEqual";
 
-import empty from './Empty';
-import not_empty from './NotEmpty';
+import empty from "./Empty";
+import not_empty from "./NotEmpty";
 
-import count from './Count';
+import count from "./Count";
 
-import contains from './Contains';
-import not_contains from './DoesNotContain';
+import contains from "./Contains";
+import not_contains from "./DoesNotContain";
 
-import string_contains from './StringContains';
-import string_not_contains from './StringDoesNotContain';
+import string_contains from "./StringContains";
+import string_not_contains from "./StringDoesNotContain";
 
-import string_starts from './StringStartsWith';
-import string_not_starts from './StringDoesNotStartWith';
+import string_starts from "./StringStartsWith";
+import string_not_starts from "./StringDoesNotStartWith";
 
-import string_ends from './StringEndsWith';
-import string_not_ends from './StringDoesNotEndWith';
+import string_ends from "./StringEndsWith";
+import string_not_ends from "./StringDoesNotEndWith";
 
-import instance_of from './InstanceOf';
+import instance_of from "./InstanceOf";
 
-import throws from './Throws';
-import does_not_throw from './DoesNotThrow';
+import throws from "./Throws";
+import does_not_throw from "./DoesNotThrow";
 
 export default new class AssertionLibrary {
-    true = is_true;
-    false = is_false;
+	true = is_true;
+	false = is_false;
 
-    undefined = is_undefined;
-    defined = is_defined;
+	undefined = is_undefined;
+	defined = is_defined;
 
-    null = is_null;
-    notNull = not_null;
+	null = is_null;
+	notNull = not_null;
 
-    equal = equal;
-    notEqual = not_equal;
+	equal = equal;
+	notEqual = not_equal;
 
-    empty = empty;
-    notEmpty = not_empty;
+	empty = empty;
+	notEmpty = not_empty;
 
-    count = count;
+	count = count;
 
-    contains = contains;
-    doesNotContain = not_contains;
+	contains = contains;
+	doesNotContain = not_contains;
 
-    stringContains = string_contains;
-    stringDoesNotContain = string_not_contains;
+	stringContains = string_contains;
+	stringDoesNotContain = string_not_contains;
 
-    stringStartsWith = string_starts;
-    stringDoesNotStartWIth = string_not_starts;
+	stringStartsWith = string_starts;
+	stringDoesNotStartWIth = string_not_starts;
 
-    stringEndsWith = string_ends;
-    stringDoesNotEndWith = string_not_ends;
+	stringEndsWith = string_ends;
+	stringDoesNotEndWith = string_not_ends;
 
-    instanceOf = instance_of;
+	instanceOf = instance_of;
 
-    throws = throws;
-    doesNotThrow = does_not_throw;
-}
+	throws = throws;
+	doesNotThrow = does_not_throw;
+};

package/src/CLI.ts

@@ -1,99 +1,110 @@
-import Usage from 'command-line-usage';
-import JUnitReporter from './Reporters/JUnitReporter';
+import Usage from "command-line-usage";
+import JUnitReporter from "./Reporters/JUnitReporter";
 import Process from "process";
 import Args from "command-line-args";
 import Runner from "./Runners/Runner";
 import SonarReporter from "./Reporters/SonarReporter";
 
 export default class CLI {
-    private static readonly options: Usage.OptionDefinition[] = [
-        {
-            name: "dir",
-            alias: "d",
-            type: String,
-            defaultOption: true,
-            typeLabel: "<directory>",
-            description: "The path where tests to run are located (-d/--dir flag optional)"
-        },
-        {
-            name: "junit",
-            alias: "j",
-            type: String,
-            typeLabel: `[filename] (${JUnitReporter.defaultFileName})`,
-            description: "Save results as JUnit-formatted XML"
-        },
-        {
-            name: "sonar",
-            alias: "s",
-            type: String,
-            typeLabel: `[filename] (${SonarReporter.defaultFileName})`,
-            description: "Save results as SonarQube/SonarCloud-formatted XML"
-        },
-        {
-            name: "quiet",
-            alias: "q",
-            type: Boolean,
-            description: "Do not print test results to stdout"
-        },
-        {
-            name: "help",
-            alias: "h",
-            type: Boolean,
-            description: "Display this help page (and ignore all other options)"
-        }
-    ];
+	private static readonly options: Usage.OptionDefinition[] = [
+		{
+			name: "dir",
+			alias: "d",
+			type: String,
+			defaultOption: true,
+			typeLabel: "<directory>",
+			description: "The path where tests to run are located (-d/--dir flag optional)"
+		},
+		{
+			name: "filter",
+			alias: "f",
+			type: String,
+			multiple: true,
+			typeLabel: "<regex>",
+			description: "A regular expression to filter against TestSuiteName.TestMethodName()"
+		},
+		{
+			name: "junit",
+			alias: "j",
+			type: String,
+			typeLabel: `[filename] (${JUnitReporter.defaultFileName})`,
+			description: "Save results as JUnit-formatted XML"
+		},
+		{
+			name: "sonar",
+			alias: "s",
+			type: String,
+			typeLabel: `[filename] (${SonarReporter.defaultFileName})`,
+			description: "Save results as SonarQube/SonarCloud-formatted XML"
+		},
+		{
+			name: "quiet",
+			alias: "q",
+			type: Boolean,
+			description: "Do not print individual test results to stdout"
+		},
+		{
+			name: "help",
+			alias: "h",
+			type: Boolean,
+			description: "Display this help page (and ignore all other options)"
+		}
+	];
 
-    private static readonly sections: Usage.Section[] = [
-        {
-            header: "xunit.ts",
-            content: "A TypeScript unit testing framework, following standard xUnit patterns"
-        },
-        {
-            header: "Usage",
-            content: [
-                "<npm run | yarn> xunit [-j|--junit [filename]] [-s|--sonar [filename]]",
-                "[-q|--quiet] [-d|--dir] <directory>"
-            ]
-        },
-        {
-            header: "Examples",
-            content: [
-                "npm run xunit dist/tests",
-                "yarn xunit --junit results.xml --dir dist/tests --quiet",
-                "yarn xunit -q -s -d dist/tests"
-            ]
-        },
-        {
-            header: "Options",
-            optionList: CLI.options
-        }
-    ];
+	private static readonly sections: Usage.Section[] = [
+		{
+			header: "xunit.ts",
+			content: "A TypeScript unit testing framework, following standard xUnit patterns"
+		},
+		{
+			header: "Usage",
+			content: [
+				"<npm run | yarn> xunit [-d|--dir] <directory>",
+				"[-q|--quiet] [-j|--junit [filename]] [-s|--sonar [filename]] [-f|--filter regex]"
+			]
+		},
+		{
+			header: "Examples",
+			content: [
+				"npm run xunit dist/tests",
+				"yarn xunit --junit results.xml --dir dist/tests --quiet",
+				"yarn xunit -q -s -d dist/tests",
+				"yarn xunit dist/tests --filter MyTestSuite",
+				"yarn xunit dist/tests -f MyTestSuite.JustOneTest",
+			]
+		},
+		{
+			header: "Options",
+			optionList: CLI.options
+		}
+	];
 
-    private static readonly usage = Usage(CLI.sections);
+	private static readonly usage = Usage(CLI.sections);
 
-    constructor(private readonly runnerFactory: (args: Args.CommandLineOptions) => Runner, private readonly process: typeof Process) {
-    }
+	constructor(private readonly runnerFactory: (args: Args.CommandLineOptions) => Runner, private readonly process: typeof Process) {
+	}
 
-    async run(): Promise<boolean> {
-        const args = Args(CLI.options, {argv: this.process.argv});
+	async run(): Promise<boolean> {
+		const args = Args(CLI.options, {argv: this.process.argv});
 
-        if (args.help) {
-            this.process.stdout.write(CLI.usage);
-            this.process.stdout.write('\n');
-            return true;
-        }
+		if (args.help) {
+			this.process.stdout.write(CLI.usage);
+			this.process.stdout.write("\n");
+			return true;
+		}
 
-        const runner = this.runnerFactory(args);
+		const runner = this.runnerFactory(args);
 
-        try {
-            const results = await runner.runAll(args.dir);
-            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');
-            }
-            return false;
-        }
-    }
+		try {
+			const filters = args.filter ?? [];
+			const results = await runner.runAll(args.dir, filters.map((f: string) => new RegExp(f)));
+			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");
+			}
+			return false;
+		}
+	}
 }

package/src/Factory.ts

@@ -1,33 +1,33 @@
-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 ResultReporter from './Reporters/ResultReporter';
-import Runner from './Runners/Runner';
-import TestRunner from './Runners/TestRunner';
-import TestSuiteLoader from './Runners/TestSuiteLoader';
-import TestSuiteRunner from './Runners/TestSuiteRunner';
+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 ResultReporter from "./Reporters/ResultReporter";
+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);
+	static readonly file_system = new FileSystem(fs);
 
-    static Runner(args: Args.CommandLineOptions) {
-        const loader = new TestSuiteLoader(Factory.file_system);
-        const reporters = Factory.Reporters(args);
-        const test_runner = new TestRunner(reporters);
-        const test_suite_runner = new TestSuiteRunner(test_runner, reporters);
+	static Runner(args: Args.CommandLineOptions) {
+		const loader = new TestSuiteLoader(Factory.file_system);
+		const reporters = Factory.Reporters(args);
+		const test_runner = new TestRunner(reporters);
+		const test_suite_runner = new TestSuiteRunner(test_runner, reporters);
 
-        return new Runner(loader, test_suite_runner, reporters);
-    }
+		return new Runner(loader, test_suite_runner, reporters);
+	}
 
-    static Reporters(args: Args.CommandLineOptions): ReadonlyArray<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[];
-    }
+	static Reporters(args: Args.CommandLineOptions): ReadonlyArray<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[];
+	}
 }

package/src/Framework/ResultType.ts

@@ -1,6 +1,6 @@
 export enum ResultType {
-    Error = -2,
-    Failed = -1,
-    Incomplete = 0,
-    Passed = 1
+	Error = -2,
+	Failed = -1,
+	Incomplete = 0,
+	Passed = 1
 }

package/src/Framework/Test.ts

@@ -4,12 +4,12 @@ import TestName from "./TestName";
 
 /**
  * Annotates a test method within a {@link TestSuite}
- * 
+ *
  * @remarks
  * This instructs `xunit.ts` to run this method as part of its {@link TestSuite}
- *   
+ *
  * @param test_name (optional) the test's display name; if not set, a sentence case version of the method name will be used
- * 
+ *
  * @example
  * ```
  * @Test()
@@ -17,7 +17,7 @@ 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);
-    }
+	return function (suite: TestSuite, method_name: string, info: TestInfo) {
+		suite.addTest(test_name || TestName.toSentenceCase(method_name), info);
+	};
 }

package/src/Framework/TestName.ts

@@ -1,9 +1,9 @@
 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")
-            .trim();
-        return result.charAt(0).toUpperCase() + result.slice(1);
-    }
+	static toSentenceCase(test_name: string) {
+		const result = test_name
+			.replace(/_([A-Z])/gi, (substring: string, match: string) => match.toUpperCase())
+			.replace(/([A-Z])/g, " $1")
+			.trim();
+		return result.charAt(0).toUpperCase() + result.slice(1);
+	}
 }

package/src/Framework/TestResult.ts

@@ -1,5 +1,6 @@
-import {ResultType} from "./ResultType";
+import { ResultType } from "./ResultType";
 
 export default class TestResult {
-    constructor(readonly type: ResultType, readonly duration: number, readonly error: Error|null = null) { }
+	constructor(readonly type: ResultType, readonly duration: number, readonly error: Error | null = null) {
+	}
 }

package/src/Framework/TestSuite.ts

@@ -1,32 +1,43 @@
-import TestInfo from './TestInfo';
-import AssertionLibrary from '../Assertions';
+import TestInfo from "./TestInfo";
+import AssertionLibrary from "../Assertions";
 
 /**
  * Defines a container of tests
- * 
+ *
  * @remarks
  * Extend this class for `xunit.ts` load its tests
- * 
+ *
  * @example
  * export default class CustomClassTests extends TestSuite { ... }
  */
 export default abstract class TestSuite {
-    assert = AssertionLibrary;
+	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[name] = info;
-    }
+	addTest(name: string, info: TestInfo) {
+		if (this.tests === undefined || this.tests === null) {
+			this.tests = {};
+		}
+		this.tests[name] = info;
+	}
 
-    setTests(tests: Record<string, TestInfo>) {
-        this.tests = tests;
-    }
+	setTests(tests: Record<string, TestInfo>) {
+		this.tests = tests;
+	}
 
-    getTests() {
-        return this.tests;
-    }
+	getTests(filters: RegExp[]) {
+		return filters.length > 0
+			? this.filteredTests(filters)
+			: this.tests;
+	}
+
+	filteredTests(filters: RegExp[]) {
+		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 => {
+			return filtered[k] = this.tests[k];
+		});
+		return filtered;
+	}
 }

package/src/Framework/TestSuiteResults.ts

@@ -1,26 +1,27 @@
-import { ResultType } from './ResultType';
+import { ResultType } from "./ResultType";
 import TestResult from "./TestResult";
 import TestSuite from "./TestSuite";
 
 export default class TestSuiteResults {
 
-    readonly results: Record<string, TestResult> = {};
-    
-    constructor(readonly suite: TestSuite) { }
+	readonly results: Record<string, TestResult> = {};
 
-    addResult(name: string, result: TestResult) {
-        this.results[name] = result;
-    }
+	constructor(readonly suite: TestSuite) {
+	}
 
-    total() {
-        return Object.values(this.results).length;
-    }
+	addResult(name: string, result: TestResult) {
+		this.results[name] = result;
+	}
 
-    count(result_type: ResultType) {
-        return Object.values(this.results).filter(result => result.type === result_type).length;
-    }
+	total() {
+		return Object.values(this.results).length;
+	}
 
-    time() {
-        return Object.values(this.results).reduce((sum, result) => sum + result.duration, 0);
-    }
+	count(result_type: ResultType) {
+		return Object.values(this.results).filter(result => result.type === result_type).length;
+	}
+
+	time() {
+		return Object.values(this.results).reduce((sum, result) => sum + result.duration, 0);
+	}
 }

package/src/IO/FileSystem.ts

@@ -1,37 +1,36 @@
-import fs_promises from 'fs/promises';
+import fs_promises from "fs/promises";
 import path from "path";
 
 export default class FileSystem {
 
-    constructor(private readonly fs: typeof fs_promises) {
-    }
+	constructor(private readonly fs: typeof fs_promises) {
+	}
 
-    async getFiles(dir: string): Promise<string[]> {
-        try {
-            const files = [];
-            const contents = await this.fs.readdir(dir);
-            for (const item of contents) {
-                const item_path = `${dir}${path.sep}${item}`;
-                const stats = await this.fs.stat(item_path);
-                files.push(...stats.isDirectory()
-                    ? await this.getFiles(item_path)
-                    : [item_path]);
-            }
-            return files;
-        } catch (e) {
-            return [];
-        }
-    }
+	static extension(file: string) {
+		const match = file.match(/\.(\w+)$/);
+		return match !== undefined && match !== null && match.length > 1
+			? match[1]
+			: "";
+	}
 
+	async getFiles(dir: string): Promise<string[]> {
+		try {
+			const files = [];
+			const contents = await this.fs.readdir(dir);
+			for (const item of contents) {
+				const item_path = `${dir}${path.sep}${item}`;
+				const stats = await this.fs.stat(item_path);
+				files.push(...stats.isDirectory()
+					? await this.getFiles(item_path)
+					: [ item_path ]);
+			}
+			return files;
+		} catch (e) {
+			return [];
+		}
+	}
 
-    static extension(file: string) {
-        const match = file.match(/\.(\w+)$/);
-        return match !== undefined && match !== null && match.length > 1
-            ? match[1]
-            : '';
-    }
-
-    async save(data: string, file_path: string) {
-        await this.fs.writeFile(file_path, data);
-    }
+	async save(data: string, file_path: string) {
+		await this.fs.writeFile(file_path, data);
+	}
 }