xunit.ts 1.0.1 → 1.1.0

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

package/src/Reporters/JUnitReporter.ts

@@ -1,94 +1,94 @@
-import TestSuiteResults from '../Framework/TestSuiteResults';
-import xml from 'xml';
+import TestSuiteResults from "../Framework/TestSuiteResults";
+import xml from "xml";
 import TestName from "../Framework/TestName";
-import {ResultType} from "../Framework/ResultType";
+import { ResultType } from "../Framework/ResultType";
 import TestResult from "../Framework/TestResult";
 import XMLReporter from "./XMLReporter";
 
 export default class JUnitReporter extends XMLReporter {
-    static readonly defaultFileName: string = 'junit.xml';
+	static readonly defaultFileName: string = "junit.xml";
 
-    xml(results: Record<string, TestSuiteResults>): string {
-        const data = {
-            testsuites: Object.values(results).map((result, index) => JUnitReporter.testSuite(result, index))
-        };
-        return xml(data, {indent: '  '});
-    }
+	private static testSuite(results: TestSuiteResults, id: number) {
+		return {
+			testsuite: [
+				{
+					_attr: {
+						id: id,
+						name: TestName.toSentenceCase(results.suite.constructor.name),
+						tests: results.total(),
+						failures: results.count(ResultType.Failed),
+						errors: results.count(ResultType.Error),
+						skipped: results.count(ResultType.Incomplete),
+						time: results.time() / 1_000
+					}
+				},
+				...Object.keys(results.results)
+					.map(test_name => JUnitReporter.testCase(test_name, results.suite.constructor.name, results.results[test_name]))
+			]
+		};
+	}
 
-    private static testSuite(results: TestSuiteResults, id: number) {
-        return {
-            testsuite: [
-                {
-                    _attr: {
-                        id: id,
-                        name: TestName.toSentenceCase(results.suite.constructor.name),
-                        tests: results.total(),
-                        failures: results.count(ResultType.Failed),
-                        errors: results.count(ResultType.Error),
-                        skipped: results.count(ResultType.Incomplete),
-                        time: results.time() / 1_000
-                    }
-                },
-                ...Object.keys(results.results)
-                    .map(test_name => JUnitReporter.testCase(test_name, results.suite.constructor.name, results.results[test_name]))
-            ]
-        };
-    }
+	private static testCase(test_name: string, suite_name: string, result: TestResult) {
+		const testcase: object[] = [
+			{
+				_attr: {
+					name: test_name,
+					classname: suite_name,
+					time: result.duration / 1_000
+				}
+			}
+		];
 
-    private static testCase(test_name: string, suite_name: string, result: TestResult) {
-        const testcase: object[] = [
-            {
-                _attr: {
-                    name: test_name,
-                    classname: suite_name,
-                    time: result.duration / 1_000
-                }
-            }
-        ];
+		const details = JUnitReporter.details(result);
 
-        const details = JUnitReporter.details(result);
+		if (details !== null) {
+			testcase.push(details);
+		}
 
-        if (details !== null) {
-            testcase.push(details);
-        }
-        
-        return {
-            testcase: testcase
-        };
-    }
+		return {
+			testcase: testcase
+		};
+	}
 
-    private static details(result: TestResult): object|null {
-        switch(result.type) {
-            case ResultType.Incomplete:
-                return {skipped: {}};
-            case ResultType.Failed:
-                return JUnitReporter.failure(result);
-            case ResultType.Error:
-                return JUnitReporter.error(result);
-            default:
-                return null;
-        }
-    }
+	private static details(result: TestResult): object | null {
+		switch (result.type) {
+		case ResultType.Incomplete:
+			return { skipped: {} };
+		case ResultType.Failed:
+			return JUnitReporter.failure(result);
+		case ResultType.Error:
+			return JUnitReporter.error(result);
+		default:
+			return null;
+		}
+	}
 
-    private static failure(result: TestResult) {
-        return {
-            failure: {
-                _attr: {
-                    type: result.error?.name,
-                    message: result.error?.message
-                }
-            }
-        };
-    }
+	private static failure(result: TestResult) {
+		return {
+			failure: {
+				_attr: {
+					type: result.error?.name,
+					message: result.error?.message
+				}
+			}
+		};
+	}
 
-    private static error(result: TestResult) {
-        return {
-            error: {
-                _attr: {
-                    type: result.error?.name,
-                    message: result.error?.message
-                }
-            }
-        };
-    }
+	private static error(result: TestResult) {
+		return {
+			error: {
+				_attr: {
+					type: result.error?.name,
+					message: result.error?.message
+				}
+			}
+		};
+	}
+
+	xml(results: Record<string, TestSuiteResults>): string {
+		const data = {
+			"testsuites": Object.values(results).map((result, index) => JUnitReporter.testSuite(result, index))
+		};
+		return xml(data, { indent: "\t" });
+	}
 }

package/src/Reporters/ResultReporter.ts

@@ -1,15 +1,23 @@
-import TestSuite from '../Framework/TestSuite';
-import { AssertionError } from 'assert';
-import TestSuiteResults from '../Framework/TestSuiteResults';
+import TestSuite from "../Framework/TestSuite";
+import { AssertionError } from "assert";
+import TestSuiteResults from "../Framework/TestSuiteResults";
 
 export default interface ResultReporter {
-    runStarted(): void;
-    suiteStarted(suite: TestSuite): void;
-    testStarted(suite: TestSuite, test_name: string): void;
-    testPassed(suite: TestSuite, test_name: string, duration: number): void;
-    testFailed(suite: TestSuite, test_name: string, error: AssertionError, duration: number): void;
-    testErrored(suite: TestSuite, test_name: string, error: Error, duration: number): void;
-    testIncomplete(suite: TestSuite, test_name: string): void;
-    suiteCompleted(suite: TestSuite, results: TestSuiteResults): void;
-    runCompleted(results: Record<string, TestSuiteResults>): void;
+	runStarted(): void;
+
+	suiteStarted(suite: TestSuite): void;
+
+	testStarted(suite: TestSuite, test_name: string): void;
+
+	testPassed(suite: TestSuite, test_name: string, duration: number): void;
+
+	testFailed(suite: TestSuite, test_name: string, error: AssertionError, duration: number): void;
+
+	testErrored(suite: TestSuite, test_name: string, error: Error, duration: number): void;
+
+	testIncomplete(suite: TestSuite, test_name: string): void;
+
+	suiteCompleted(suite: TestSuite, results: TestSuiteResults): void;
+
+	runCompleted(results: Record<string, TestSuiteResults>): void;
 }