xunit.ts 0.13.1 → 1.0.3

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

package/src/Reporters/SonarReporter.ts

@@ -1,100 +1,100 @@
-import TestSuiteResults from '../Framework/TestSuiteResults';
-import xml from 'xml';
-import {ResultType} from "../Framework/ResultType";
+import TestSuiteResults from "../Framework/TestSuiteResults";
+import xml from "xml";
+import { ResultType } from "../Framework/ResultType";
 import TestResult from "../Framework/TestResult";
 import XMLReporter from "./XMLReporter";
 import path from "path";
 
 export default class SonarReporter extends XMLReporter {
-    static readonly defaultFileName: string = 'sonar.xml';
+	static readonly defaultFileName: string = "sonar.xml";
 
-    xml(results: Record<string, TestSuiteResults>): string {
-        const data = {
-            testExecutions: [
-                {
-                    _attr: {
-                        version: 1
-                    }
-                },
-                ...Object.keys(results)
-                    .map(file => SonarReporter.testSuite(results[file], file))
-            ]
-        };
-        return xml(data, {indent: '  '});
-    }
+	private static testSuite(results: TestSuiteResults, file: string) {
+		return {
+			file: [
+				{
+					_attr: {
+						path: file.substr(file.split(path.sep)[0].length + 1).replace(/\.js$/, ".ts"),
+					}
+				},
+				...Object.keys(results.results)
+					.map(test_name => SonarReporter.testCase(test_name, results.results[test_name]))
+			]
+		};
+	}
 
-    private static testSuite(results: TestSuiteResults, file: string) {
-        return {
-            file: [
-                {
-                    _attr: {
-                        path: file.substr(file.split(path.sep)[0].length + 1).replace(/\.js$/, '.ts'),
-                    }
-                },
-                ...Object.keys(results.results)
-                    .map(test_name => SonarReporter.testCase(test_name, results.results[test_name]))
-            ]
-        };
-    }
+	private static testCase(test_name: string, result: TestResult) {
+		const testcase: object[] = [
+			{
+				_attr: {
+					name: test_name,
+					duration: Math.round(result.duration)
+				}
+			}
+		];
 
-    private static testCase(test_name: string, result: TestResult) {
-        const testcase: object[] = [
-            {
-                _attr: {
-                    name: test_name,
-                    duration: Math.round(result.duration)
-                }
-            }
-        ];
+		const details = SonarReporter.details(result);
 
-        const details = SonarReporter.details(result);
+		if (details !== null) {
+			testcase.push(details);
+		}
 
-        if (details !== null) {
-            testcase.push(details);
-        }
-        
-        
-        return {
-            testCase: testcase
-        };
-    }
 
-    private static details(result: TestResult): object|null {
-        switch(result.type) {
-            case ResultType.Incomplete:
-                return {skipped: {}};
-            case ResultType.Failed:
-                return SonarReporter.failure(result);
-            case ResultType.Error:
-                return SonarReporter.error(result);
-            default:
-                return null;
-        }
-    }
+		return {
+			testCase: testcase
+		};
+	}
 
-    private static failure(result: TestResult) {
-        return {
-            failure: [
-                {
-                    _attr: {
-                        message: result.error?.message
-                    }
-                },
-                result.error?.stack
-            ]
-        };
-    }
+	private static details(result: TestResult): object | null {
+		switch (result.type) {
+		case ResultType.Incomplete:
+			return { skipped: {} };
+		case ResultType.Failed:
+			return SonarReporter.failure(result);
+		case ResultType.Error:
+			return SonarReporter.error(result);
+		default:
+			return null;
+		}
+	}
 
-    private static error(result: TestResult) {
-        return {
-            error: [
-                {
-                    _attr: {
-                        message: result.error?.message
-                    }
-                },
-                result.error?.stack
-            ]
-        };
-    }
+	private static failure(result: TestResult) {
+		return {
+			failure: [
+				{
+					_attr: {
+						message: result.error?.message
+					}
+				},
+				result.error?.stack
+			]
+		};
+	}
+
+	private static error(result: TestResult) {
+		return {
+			error: [
+				{
+					_attr: {
+						message: result.error?.message
+					}
+				},
+				result.error?.stack
+			]
+		};
+	}
+
+	xml(results: Record<string, TestSuiteResults>): string {
+		const data = {
+			testExecutions: [
+				{
+					_attr: {
+						version: 1
+					}
+				},
+				...Object.keys(results)
+					.map(file => SonarReporter.testSuite(results[file], file))
+			]
+		};
+		return xml(data, { indent: "\t" });
+	}
 }

package/src/Reporters/XMLReporter.ts

@@ -2,10 +2,10 @@
 import TestSuiteResults from "../Framework/TestSuiteResults";
 
 export default abstract class XMLReporter extends FileReporter {
-    async runCompleted(results: Record<string, TestSuiteResults>): Promise<void> {
-        const xmlString = this.xml(results);
-        await this.file_system.save(xmlString, this.path);
-    }
-    
-    abstract xml(results: Record<string, TestSuiteResults>): string;
+	async runCompleted(results: Record<string, TestSuiteResults>): Promise<void> {
+		const xmlString = this.xml(results);
+		await this.file_system.save(xmlString, this.path);
+	}
+
+	abstract xml(results: Record<string, TestSuiteResults>): string;
 }

package/src/Runners/Runner.ts

@@ -1,29 +1,29 @@
-import TestSuiteLoader from './TestSuiteLoader';
-import TestSuiteRunner from './TestSuiteRunner';
+import TestSuiteLoader from "./TestSuiteLoader";
+import TestSuiteRunner from "./TestSuiteRunner";
 import ResultReporter from "../Reporters/ResultReporter";
 import TestSuiteResults from "../Framework/TestSuiteResults";
-import {ResultType} from '../Framework/ResultType';
+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: ReadonlyArray<ResultReporter>) {
+	}
 
-    async runAll(dir: string): Promise<Record<string, TestSuiteResults>> {
-        await Promise.all(this.reporters.map(r => r.runStarted()));
-        const results: Record<string, TestSuiteResults> = {};
-        const suites = await this.loader.loadTestSuites(dir);
-        for (const file of Object.keys(suites)) {
-            const suite = suites[file];
-            results[file] = await this.runner.runSuite(suite);
-        }
-        await Promise.all(this.reporters.map(r => r.runCompleted(results)));
-        return results;
-    }
+	static allTestsPassed(results: Record<string, TestSuiteResults>): boolean {
+		const tests_with_results = Object.values(results).filter(result => result.total() > 0);
+		return tests_with_results.length > 0
+			&& tests_with_results.filter(result => result.count(ResultType.Passed) < result.total()).length === 0;
+	}
 
-    static allTestsPassed(results: Record<string, TestSuiteResults>): boolean {
-        const tests_with_results = Object.values(results).filter(result => result.total() > 0);
-        return tests_with_results.length > 0
-            && tests_with_results.filter(result => result.count(ResultType.Passed) < result.total()).length === 0;
-    }
+	async runAll(dir: string): Promise<Record<string, TestSuiteResults>> {
+		await Promise.all(this.reporters.map(r => r.runStarted()));
+		const results: Record<string, TestSuiteResults> = {};
+		const suites = await this.loader.loadTestSuites(dir);
+		for (const file of Object.keys(suites)) {
+			const suite = suites[file];
+			results[file] = await this.runner.runSuite(suite);
+		}
+		await Promise.all(this.reporters.map(r => r.runCompleted(results)));
+		return results;
+	}
 }

package/src/Runners/TestRunner.ts

@@ -1,42 +1,44 @@
-import TestInfo from '../Framework/TestInfo';
-import TestSuite from '../Framework/TestSuite';
-import { ResultType } from '../Framework/ResultType';
-import ResultReporter from '../Reporters/ResultReporter';
+import TestInfo from "../Framework/TestInfo";
+import TestSuite from "../Framework/TestSuite";
+import { ResultType } from "../Framework/ResultType";
+import ResultReporter from "../Reporters/ResultReporter";
 import TestResult from "../Framework/TestResult";
-import {AssertionError} from "assert";
+import { AssertionError } from "assert";
 
 export default class TestRunner {
 
-    constructor(private readonly reporters: ReadonlyArray<ResultReporter>) { }
+	constructor(private readonly reporters: ReadonlyArray<ResultReporter>) {
+	}
 
-    async runTest(name: string, info: TestInfo, suite: TestSuite): Promise<TestResult> {
-        await Promise.all(this.reporters.map(r => r.testStarted(suite, name)));
-        if (info.value === undefined) {
-            await Promise.all(this.reporters.map(r => r.testIncomplete(suite, name)));
-            return new TestResult(ResultType.Incomplete, 0);
-        }
+	private static msSince(start: [ number, number ]) {
+		const duration = process.hrtime(start);
+		return duration[0] * 1_000 + duration[1] / 1_000_000;
+	}
 
-        const start = process.hrtime();
-        try {
-            await info.value.call(suite);
-            const duration = TestRunner.msSince(start);
-            await Promise.all(this.reporters.map(r => r.testPassed(suite, name, duration)));
-            return new TestResult(ResultType.Passed, duration);
+	async runTest(name: string, info: TestInfo, suite: TestSuite): Promise<TestResult> {
+		await Promise.all(this.reporters.map(r => r.testStarted(suite, name)));
+		if (info.value === undefined) {
+			await Promise.all(this.reporters.map(r => r.testIncomplete(suite, name)));
+			return new TestResult(ResultType.Incomplete, 0);
+		}
 
-        } catch (error) {
-            const duration = TestRunner.msSince(start);
-            if (error instanceof AssertionError) {
-                await Promise.all(this.reporters.map(r => r.testFailed(suite, name, error, duration)));
-                return new TestResult(ResultType.Failed, duration, error);
-            }
+		const start = process.hrtime();
+		try {
+			await info.value.call(suite);
+			const duration = TestRunner.msSince(start);
+			await Promise.all(this.reporters.map(r => r.testPassed(suite, name, duration)));
+			return new TestResult(ResultType.Passed, duration);
 
-            await Promise.all(this.reporters.map(r => r.testErrored(suite, name, error, duration)));
-            return new TestResult(ResultType.Error, duration, error);
-        }
-    }
+		} 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)));
+				return new TestResult(ResultType.Failed, duration, typedError);
+			}
 
-    private static msSince(start: [number, number]) {
-        const duration = process.hrtime(start);
-        return duration[0] * 1_000 + duration[1] / 1_000_000;
-    }
+			await Promise.all(this.reporters.map(r => r.testErrored(suite, name, typedError, duration)));
+			return new TestResult(ResultType.Error, duration, typedError);
+		}
+	}
 }

package/src/Runners/TestSuiteLoader.ts

@@ -1,49 +1,50 @@
-import TestSuite from '../Framework/TestSuite';
-import FileSystem from '../IO/FileSystem';
-import path from 'path';
+import TestSuite from "../Framework/TestSuite";
+import FileSystem from "../IO/FileSystem";
+import path from "path";
 
 export default class TestSuiteLoader {
 
-    constructor(private readonly file_system: FileSystem) { }
+	constructor(private readonly file_system: FileSystem) {
+	}
 
-    async loadTestSuites(dir: string): Promise<Record<string, TestSuite>> {
-        const files = (await this.file_system.getFiles(dir))
-            .filter((file) => FileSystem.extension(file) === FileSystem.extension(__filename));
-        const suites: Record<string, TestSuite> = {};
-        for (const file of files) {
-            const suite = await TestSuiteLoader.loadTestSuite(file);
-            if (suite !== undefined && suite !== null) {
-                suites[file] = suite;
-            }
-        }
-        return suites;
-    }
+	static async loadTestSuite(file: string) {
+		const module_path = TestSuiteLoader.getModulePath(__dirname, file);
+		const test_class = await import(module_path);
+		if (!(test_class.default.prototype instanceof TestSuite)) {
+			return null;
+		}
 
-    static async loadTestSuite(file: string) {
-        const module_path = TestSuiteLoader.getModulePath(__dirname, file);
-        const test_class = await import(module_path);
-        if (!(test_class.default.prototype instanceof TestSuite)) {
-            return null;
-        }
+		const tests = test_class.default.prototype.getTests();
+		const suite: TestSuite = new test_class.default();
+		suite.setTests(tests);
+		return suite;
+	}
 
-        const tests = test_class.default.prototype.getTests();
-        const suite: TestSuite = new test_class.default();
-        suite.setTests(tests);
-        return suite;
-    }
+	static getModulePath(current_dir: string, file: string) {
+		const root = TestSuiteLoader.isFromNodeModules(path.resolve(current_dir))
+			? `..${path.sep}..${path.sep}..${path.sep}..${path.sep}..`
+			: `..${path.sep}..${path.sep}..`;
+		const extension = FileSystem.extension(file);
+		const module_name = extension.length > 0
+			? file.substr(0, file.length - extension.length - 1)
+			: file;
+		return `${root}${path.sep}${module_name}`;
+	}
 
-    static getModulePath(current_dir: string, file: string) {
-        const root = TestSuiteLoader.isFromNodeModules(path.resolve(current_dir))
-            ? `..${path.sep}..${path.sep}..${path.sep}..${path.sep}..`
-            : `..${path.sep}..${path.sep}..`;
-        const extension = FileSystem.extension(file);
-        const module_name = extension.length > 0
-            ? file.substr(0, file.length - extension.length - 1)
-            : file;
-        return `${root}${path.sep}${module_name}`;
-    }
+	static isFromNodeModules(dir: string) {
+		return dir.indexOf("node_modules") !== -1;
+	}
 
-    static isFromNodeModules(dir: string) {
-        return dir.indexOf('node_modules') !== -1;
-    }
+	async loadTestSuites(dir: string): Promise<Record<string, TestSuite>> {
+		const files = (await this.file_system.getFiles(dir))
+			.filter((file) => FileSystem.extension(file) === FileSystem.extension(__filename));
+		const suites: Record<string, TestSuite> = {};
+		for (const file of files) {
+			const suite = await TestSuiteLoader.loadTestSuite(file);
+			if (suite !== undefined && suite !== null) {
+				suites[file] = suite;
+			}
+		}
+		return suites;
+	}
 }