xunit.ts 1.0.1 → 1.1.0

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.substring(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, filters: RegExp[]): 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, filters);
+		for (const file of Object.keys(suites)) {
+			const suite = suites[file];
+			results[file] = await this.runner.runSuite(suite, filters);
+		}
+		await Promise.all(this.reporters.map(r => r.runCompleted(results)));
+		return results;
+	}
 }

package/src/Runners/TestRunner.ts

@@ -1,43 +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);
-            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);
-            }
+		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, typedError, duration)));
-            return new TestResult(ResultType.Error, duration, typedError);
-        }
-    }
+		} 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,56 @@
-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) { }
-
-    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;
-        }
-
-        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 isFromNodeModules(dir: string) {
-        return dir.indexOf('node_modules') !== -1;
-    }
+	constructor(private readonly file_system: FileSystem) {
+	}
+
+	static async loadTestSuite(file: string, filters: RegExp[]) {
+		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(filters);
+		if (Object.keys(tests).length === 0) {
+			return null;
+		}
+
+		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.substring(0, file.length - extension.length - 1)
+			: file;
+		return `${root}${path.sep}${module_name}`;
+	}
+
+	static isFromNodeModules(dir: string) {
+		return dir.indexOf("node_modules") !== -1;
+	}
+
+	async loadTestSuites(dir: string, filters: RegExp[]): Promise<Record<string, TestSuite>> {
+		const suites: Record<string, TestSuite> = {};
+
+		const files = (await this.file_system.getFiles(dir))
+			.filter((file) => FileSystem.extension(file) === FileSystem.extension(__filename));
+
+		for (const file of files) {
+			const suite = await TestSuiteLoader.loadTestSuite(file, filters);
+			if (suite !== undefined && suite !== null) {
+				suites[file] = suite;
+			}
+		}
+		return suites;
+	}
 }

package/src/Runners/TestSuiteRunner.ts

@@ -1,34 +1,35 @@
-import ResultReporter from '../Reporters/ResultReporter';
-import TestSuite from '../Framework/TestSuite';
-import TestSuiteResults from '../Framework/TestSuiteResults';
-import TestInfo from '../Framework/TestInfo';
-import TestRunner from './TestRunner';
+import ResultReporter from "../Reporters/ResultReporter";
+import TestSuite from "../Framework/TestSuite";
+import TestSuiteResults from "../Framework/TestSuiteResults";
+import TestInfo from "../Framework/TestInfo";
+import TestRunner from "./TestRunner";
 
 export default class TestSuiteRunner {
 
-    constructor(private readonly runner: TestRunner, private readonly reporters: ReadonlyArray<ResultReporter>) { }
+	constructor(private readonly runner: TestRunner, private readonly reporters: ReadonlyArray<ResultReporter>) {
+	}
 
-    async runSuite(suite: TestSuite) {
-        await Promise.all(this.reporters.map(r => r.suiteStarted(suite)));
-        const tests = suite.getTests();
-        const results = await this.runTests(suite, tests);
-        await Promise.all(this.reporters.map(r => r.suiteCompleted(suite, results)));
-        return results;
-    }
+	async runSuite(suite: TestSuite, filters: RegExp[]) {
+		await Promise.all(this.reporters.map(r => r.suiteStarted(suite)));
+		const tests = suite.getTests(filters);
+		const results = await this.runTests(suite, tests);
+		await Promise.all(this.reporters.map(r => r.suiteCompleted(suite, results)));
+		return results;
+	}
 
-    async runTests(suite: TestSuite, tests: Record<string, TestInfo>) {
-        const results = new TestSuiteResults(suite);
-        if (tests === undefined || tests === null || Object.keys(tests).length === 0) {
-            await Promise.all(this.reporters.map(r => r.testIncomplete(suite, '(no tests found)')));
-            return results;
-        }
+	async runTests(suite: TestSuite, tests: Record<string, TestInfo>) {
+		const results = new TestSuiteResults(suite);
+		if (tests === undefined || tests === null || Object.keys(tests).length === 0) {
+			await Promise.all(this.reporters.map(r => r.testIncomplete(suite, "(no tests found)")));
+			return results;
+		}
 
-        const test_names = Object.keys(tests);
-        for (const name of test_names) {
-            const result = await this.runner.runTest(name, tests[name], suite);
-            results.addResult(name, result);
-        }
+		const test_names = Object.keys(tests);
+		for (const name of test_names) {
+			const result = await this.runner.runTest(name, tests[name], suite);
+			results.addResult(name, result);
+		}
 
-        return results;
-    }
+		return results;
+	}
 }

package/tsconfig.json

@@ -1,28 +1,28 @@
 {
-  "compilerOptions": {
-    "target": "ES2015",
-    "module": "CommonJS",
-    "outDir": "./dist/",
-    "strict": true,
-    "sourceMap": true,
-    "declaration": true,
-    "declarationMap": true,
-    "esModuleInterop": true,
-    "experimentalDecorators": true,
-    "emitDecoratorMetadata": true
-  },
-  "files": [
-    "xunit.ts",
-    "cli.ts",
-    "tsdoc.ts"
-  ],
-  "include": [
-    "src/**/*.ts",
-    "tests/**/*.ts",
-    "TSDoc/**/*.ts"
-  ],
-  "exclude": [
-    "node_modules",
-    "dist"
-  ]
+	"compilerOptions": {
+		"target": "ES2015",
+		"module": "CommonJS",
+		"outDir": "./dist/",
+		"strict": true,
+		"sourceMap": true,
+		"declaration": true,
+		"declarationMap": true,
+		"esModuleInterop": true,
+		"experimentalDecorators": true,
+		"emitDecoratorMetadata": true
+	},
+	"files": [
+		"xunit.ts",
+		"cli.ts",
+		"tsdoc.ts"
+	],
+	"include": [
+		"src/**/*.ts",
+		"tests/**/*.ts",
+		"TSDoc/**/*.ts"
+	],
+	"exclude": [
+		"node_modules",
+		"dist"
+	]
 }

package/xunit.ts

@@ -1,9 +1,9 @@
-import Test from './src/Framework/Test';
-import TestSuite from './src/Framework/TestSuite';
-import Assert from './src/Assertions';
+import Test from "./src/Framework/Test";
+import TestSuite from "./src/Framework/TestSuite";
+import Assert from "./src/Assertions";
 
 export {
-    Test,
-    TestSuite,
-    Assert
+	Test,
+	TestSuite,
+	Assert
 };