xunit.ts 0.13.1 → 1.0.3

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 {
-    private static readonly file_system = new FileSystem(fs);
+	static readonly file_system = new FileSystem(fs);
 
-    static Runner(args: Args.CommandLineOptions) {
-        const loader = new TestSuiteLoader(this.file_system);
-        const reporters = this.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(this.file_system, args.junit ?? JUnitReporter.defaultFileName) : null,
-            args.sonar !== undefined ? new SonarReporter(this.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,32 @@
-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() {
+		return this.tests;
+	}
 }

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);
+	}
 }

package/src/IO/Output.ts

@@ -2,29 +2,30 @@ import { WriteStream } from "tty";
 
 export default class Output {
 
-    constructor(private readonly out: WriteStream) { }
+	constructor(private readonly out: WriteStream) {
+	}
 
-    write(data: string) {
-        this.out.write(data);
-    }
+	write(data: string) {
+		this.out.write(data);
+	}
 
-    writeLine(data: string = "") {
-        this.out.write(data + "\n");
-    }
+	writeLine(data = "") {
+		this.out.write(data + "\n");
+	}
 
-    overwrite(data: string) {
-        this.deleteLine();
-        this.write(data);
-    }
+	overwrite(data: string) {
+		this.deleteLine();
+		this.write(data);
+	}
 
-    overwriteLine(data: string) {
-        this.deleteLine();
-        this.writeLine(data);
-    }
+	overwriteLine(data: string) {
+		this.deleteLine();
+		this.writeLine(data);
+	}
 
-    deleteLine() {
-        if (this.out.isTTY) {
-            this.out.cursorTo(0);
-        }
-    }
+	deleteLine() {
+		if (this.out.isTTY) {
+			this.out.cursorTo(0);
+		}
+	}
 }

package/src/Reporters/ConsoleReporter.ts

@@ -3,95 +3,96 @@ import TestSuite from "../Framework/TestSuite";
 import Output from "../IO/Output";
 import TestName from "../Framework/TestName";
 import colors from "colors";
-import {AssertionError} from "assert";
+import { AssertionError } from "assert";
 import TestSuiteResults from "../Framework/TestSuiteResults";
-import {ResultType} from "../Framework/ResultType";
+import { ResultType } from "../Framework/ResultType";
 
 export default class ConsoleReporter implements ResultReporter {
 
-    constructor(private readonly out: Output) {
-    }
-
-    runStarted(): void {
-        this.out.writeLine('Starting xunit.ts...');
-        this.out.writeLine();
-    }
-
-    suiteStarted(suite: TestSuite): void {
-        this.out.writeLine(TestName.toSentenceCase(suite.constructor.name));
-    }
-
-    testStarted(suite: TestSuite, test_name: string): void {
-        this.out.write(`  ${colors.white('⋯')} ${test_name}`);
-    }
-
-    testPassed(suite: TestSuite, test_name: string, duration: number): void {
-        this.out.write(` (${Math.round(duration)} ms)`);
-        this.out.overwrite(`  ${colors.green('✓')}\n`);
-    }
-
-    testFailed(suite: TestSuite, test_name: string, error: AssertionError, duration: number): void {
-        this.out.write(` (${Math.round(duration)} ms)`);
-        this.out.overwrite(`  ${colors.red('✘')}\n`);
-        this.out.writeLine(`      ${error.message}`);
-        this.out.writeLine(`        Expected: ${colors.green(String(error.expected))}`);
-        this.out.writeLine(`          Actual: ${colors.red(String(error.actual))}`);
-        this.out.writeLine();
-    }
-
-    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();
-    }
-
-    testIncomplete(suite: TestSuite, test_name: string): void {
-        this.out.overwrite(`  ${colors.yellow('?')}\n`);
-    }
-
-    suiteCompleted(suite: TestSuite, results: TestSuiteResults): void {
-        const passed = results.count(ResultType.Passed);
-        const total = results.total();
-        const time = results.time();
-        const color = passed === total ? colors.green : colors.red;
-        const fraction = `${passed} / ${total}`;
-        this.out.writeLine(`  ${color(fraction)} passed (${Math.round(time)} ms)`);
-        this.out.writeLine();
-    }
-
-    runCompleted(suites: Record<string, TestSuiteResults>): void {
-        const results = Object.values(suites);
-        if (!results.length) {
-            this.out.writeLine('No tests found!');
-            return;
-        }
-
-        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);
-
-        const result = (result_type?: ResultType, color: (string: string) => string = colors.white) => {
-            const count = sum(result_type).toString();
-            const pad = sum().toString().length;
-            return color(count.padStart(pad));
-        }
-
-        this.out.writeLine(`    Passed: ${result(ResultType.Passed, colors.green)}`);
-
-        if (sum(ResultType.Failed)) {
-            this.out.writeLine(`    Failed: ${result(ResultType.Failed, colors.red)}`);
-        }
-
-        if (sum(ResultType.Error)) {
-            this.out.writeLine(`     Error: ${result(ResultType.Error, colors.red)}`);
-        }
-
-        if (sum(ResultType.Incomplete)) {
-            this.out.writeLine(`Incomplete: ${result(ResultType.Incomplete, colors.yellow)}`);
-        }
-        
-        this.out.writeLine(`     Total: ${result(undefined, sum() === sum(ResultType.Passed) ? colors.green : undefined)}`);
-        this.out.writeLine();
-    }
+	constructor(private readonly out: Output) {
+	}
+
+	runStarted(): void {
+		this.out.writeLine("Starting xunit.ts...");
+		this.out.writeLine();
+	}
+
+	suiteStarted(suite: TestSuite): void {
+		this.out.writeLine(TestName.toSentenceCase(suite.constructor.name));
+	}
+
+	testStarted(suite: TestSuite, test_name: string): void {
+		this.out.write(`  ${colors.white("⋯")} ${test_name}`);
+	}
+
+	testPassed(suite: TestSuite, test_name: string, duration: number): void {
+		this.out.write(` (${Math.round(duration)} ms)`);
+		this.out.overwrite(`  ${colors.green("✓")}\n`);
+	}
+
+	testFailed(suite: TestSuite, test_name: string, error: AssertionError, duration: number): void {
+		this.out.write(` (${Math.round(duration)} ms)`);
+		this.out.overwrite(`  ${colors.red("✘")}\n`);
+		this.out.writeLine(`      ${error.message}`);
+		this.out.writeLine(`        Expected: ${colors.green(String(error.expected))}`);
+		this.out.writeLine(`          Actual: ${colors.red(String(error.actual))}`);
+		this.out.writeLine();
+	}
+
+	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();
+	}
+
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	testIncomplete(suite: TestSuite, test_name: string): void {
+		this.out.overwrite(`  ${colors.yellow("?")}\n`);
+	}
+
+	suiteCompleted(suite: TestSuite, results: TestSuiteResults): void {
+		const passed = results.count(ResultType.Passed);
+		const total = results.total();
+		const time = results.time();
+		const color = passed === total ? colors.green : colors.red;
+		const fraction = `${passed} / ${total}`;
+		this.out.writeLine(`  ${color(fraction)} passed (${Math.round(time)} ms)`);
+		this.out.writeLine();
+	}
+
+	runCompleted(suites: Record<string, TestSuiteResults>): void {
+		const results = Object.values(suites);
+		if (!results.length) {
+			this.out.writeLine("No tests found!");
+			return;
+		}
+
+		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);
+
+		const result = (result_type?: ResultType, color: (string: string) => string = colors.white) => {
+			const count = sum(result_type).toString();
+			const pad = sum().toString().length;
+			return color(count.padStart(pad));
+		};
+
+		this.out.writeLine(`    Passed: ${result(ResultType.Passed, colors.green)}`);
+
+		if (sum(ResultType.Failed)) {
+			this.out.writeLine(`    Failed: ${result(ResultType.Failed, colors.red)}`);
+		}
+
+		if (sum(ResultType.Error)) {
+			this.out.writeLine(`     Error: ${result(ResultType.Error, colors.red)}`);
+		}
+
+		if (sum(ResultType.Incomplete)) {
+			this.out.writeLine(`Incomplete: ${result(ResultType.Incomplete, colors.yellow)}`);
+		}
+
+		this.out.writeLine(`     Total: ${result(undefined, sum() === sum(ResultType.Passed) ? colors.green : undefined)}`);
+		this.out.writeLine();
+	}
 }

package/src/Reporters/FileReporter.ts

@@ -1,45 +1,45 @@
 import ResultReporter from "./ResultReporter";
 import TestSuiteResults from "../Framework/TestSuiteResults";
 import TestSuite from "../Framework/TestSuite";
-import {AssertionError} from "assert";
+import { AssertionError } from "assert";
 import FileSystem from "../IO/FileSystem";
 
 export default abstract class FileReporter implements ResultReporter {
+	/* eslint-disable @typescript-eslint/no-unused-vars */
+	constructor(protected readonly file_system: FileSystem, protected readonly path: string) {
+	}
 
-    constructor(protected readonly file_system: FileSystem, protected readonly path: string) {
-    }
+	runStarted(): void {
+		return;
+	}
 
-    runStarted(): void {
-        return;
-    }
+	suiteStarted(suite: TestSuite): void {
+		return;
+	}
 
-    suiteStarted(suite: TestSuite): void {
-        return;
-    }
+	testStarted(suite: TestSuite, test_name: string): void {
+		return;
+	}
 
-    testStarted(suite: TestSuite, test_name: string): void {
-        return;
-    }
+	testErrored(suite: TestSuite, test_name: string, error: Error, duration: number): void {
+		return;
+	}
 
-    testErrored(suite: TestSuite, test_name: string, error: Error, duration: number): void {
-        return;
-    }
+	testFailed(suite: TestSuite, test_name: string, error: AssertionError, duration: number): void {
+		return;
+	}
 
-    testFailed(suite: TestSuite, test_name: string, error: AssertionError, duration: number): void {
-        return;
-    }
+	testIncomplete(suite: TestSuite, test_name: string): void {
+		return;
+	}
 
-    testIncomplete(suite: TestSuite, test_name: string): void {
-        return;
-    }
+	testPassed(suite: TestSuite, test_name: string, duration: number): void {
+		return;
+	}
 
-    testPassed(suite: TestSuite, test_name: string, duration: number): void {
-        return;
-    }
+	suiteCompleted(suite: TestSuite, results: TestSuiteResults): void {
+		return;
+	}
 
-    suiteCompleted(suite: TestSuite, results: TestSuiteResults): void {
-        return;
-    }
-
-    abstract runCompleted(results: Record<string, TestSuiteResults>): void;
+	abstract runCompleted(results: Record<string, TestSuiteResults>): void;
 }