xunit.ts 0.13.1 → 1.0.3

package/src/Assertions/StringDoesNotContain.ts

@@ -2,27 +2,27 @@ import { AssertionError } from "assert";
 
 /**
  * Asserts that a string does not contain a given substring
- * 
+ *
  * @remarks
  * Passes if `needle` is not a substring of `haystack`
- * 
+ *
  * Fails if `needle` is a substring of `haystack`
  *
  * @param needle the substring to find
  * @param haystack the string to search
  * @param message (optional) message to display on failure
- * 
+ *
  * @example
  * this.assert.stringDoesNotContain(needle, haystack);
  */
-export default function StringDoesNotContain(needle: string, haystack: string|null, message?: string) {
-    if(haystack === undefined || haystack === null || haystack.indexOf(needle) === -1) {
-        return;
-    }
+export default function StringDoesNotContain(needle: string, haystack: string | null, message?: string) {
+	if (haystack === undefined || haystack === null || haystack.indexOf(needle) === -1) {
+		return;
+	}
 
-    throw new AssertionError({
-        message: message || 'Expected string not containing expression, but string did contain expression',
-        expected: needle,
-        actual: haystack
-    });
+	throw new AssertionError({
+		message: message || "Expected string not containing expression, but string did contain expression",
+		expected: needle,
+		actual: haystack
+	});
 }

package/src/Assertions/StringDoesNotEndWith.ts

@@ -2,27 +2,29 @@ import { AssertionError } from "assert";
 
 /**
  * Asserts that a string does not end with a given substring
- * 
+ *
  * @remarks
  * Passes if the final characters of `haystack` do not match `needle`
- * 
+ *
  * Fails if the final characters of `haystack` match `needle`
  *
  * @param needle the substring to find
  * @param haystack the string to search
  * @param message (optional) message to display on failure
- * 
+ *
  * @example
  * this.assert.stringDoesNotEndWith(needle, haystack);
  */
-export default function StringDoesNotEndWith(needle: string, haystack: string|null, message?: string) {
-    if(haystack === undefined || haystack === null || haystack.indexOf(needle) !== haystack.length - needle.length) {
-        return;
-    }
+export default function StringDoesNotEndWith(needle: string, haystack: string | null, message?: string) {
+	if (haystack === undefined || haystack === null
+		|| haystack.indexOf(needle) === -1
+		|| haystack.indexOf(needle) !== haystack.length - needle.length) {
+		return;
+	}
 
-    throw new AssertionError({
-        message: message || 'Expected string containing expression, but string did not contain expression',
-        expected: needle,
-        actual: haystack
-    });
+	throw new AssertionError({
+		message: message || "Expected string containing expression, but string did not contain expression",
+		expected: needle,
+		actual: haystack
+	});
 }

package/src/Assertions/StringDoesNotStartWith.ts

@@ -2,27 +2,27 @@ import { AssertionError } from "assert";
 
 /**
  * Asserts that a string does not begin with a given substring
- * 
+ *
  * @remarks
  * Passes if the first characters of `haystack` do not match `needle`
- * 
+ *
  * Fails if the first characters of `haystack` match `needle`
  *
  * @param needle the substring to find
  * @param haystack the string to search
  * @param message (optional) message to display on failure
- * 
+ *
  * @example
  * this.assert.stringDoesNotStartWith(needle, haystack);
  */
-export default function StringDoesNotStartWith(needle: string, haystack: string|null, message?: string) {
-    if(haystack === undefined || haystack === null || haystack.indexOf(needle) !== 0) {
-        return;
-    }
+export default function StringDoesNotStartWith(needle: string, haystack: string | null, message?: string) {
+	if (haystack === undefined || haystack === null || haystack.indexOf(needle) !== 0) {
+		return;
+	}
 
-    throw new AssertionError({
-        message: message || 'Expected string containing expression, but string did not contain expression',
-        expected: needle,
-        actual: haystack
-    });
+	throw new AssertionError({
+		message: message || "Expected string containing expression, but string did not contain expression",
+		expected: needle,
+		actual: haystack
+	});
 }

package/src/Assertions/StringEndsWith.ts

@@ -2,27 +2,29 @@ import { AssertionError } from "assert";
 
 /**
  * Asserts that a string ends with a given substring
- * 
+ *
  * @remarks
  * Passes if the final characters of `haystack` match `needle`
- * 
+ *
  * Fails if the final characters of `haystack` do not match `needle`
  *
  * @param needle the substring to find
  * @param haystack the string to search
  * @param message (optional) message to display on failure
- * 
+ *
  * @example
  * this.assert.stringEndsWith(needle, haystack);
  */
-export default function StringEndsWith(needle: string, haystack: string|null, message?: string) {
-    if(haystack !== undefined && haystack !== null && haystack.indexOf(needle) === haystack.length - needle.length) {
-        return;
-    }
+export default function StringEndsWith(needle: string, haystack: string | null, message?: string) {
+	if (haystack !== undefined && haystack !== null
+		&& haystack.indexOf(needle) > -1
+		&& haystack.indexOf(needle) === haystack.length - needle.length) {
+		return;
+	}
 
-    throw new AssertionError({
-        message: message || 'Expected string containing expression, but string did not contain expression',
-        expected: needle,
-        actual: haystack
-    });
+	throw new AssertionError({
+		message: message || "Expected string containing expression, but string did not contain expression",
+		expected: needle,
+		actual: haystack
+	});
 }

package/src/Assertions/StringStartsWith.ts

@@ -2,27 +2,27 @@ import { AssertionError } from "assert";
 
 /**
  * Asserts that a string begins with a given substring
- * 
+ *
  * @remarks
  * Passes if the first characters of `haystack` match `needle`
- * 
+ *
  * Fails if the first characters of `haystack` do not match `needle`
  *
  * @param needle the substring to find
  * @param haystack the string to search
  * @param message (optional) message to display on failure
- * 
+ *
  * @example
  * this.assert.stringStartsWith(needle, haystack);
  */
-export default function StringStartsWith(needle: string, haystack: string|null, message?: string) {
-    if(haystack !== undefined && haystack !== null && haystack.indexOf(needle) === 0) {
-        return;
-    }
+export default function StringStartsWith(needle: string, haystack: string | null, message?: string) {
+	if (haystack !== undefined && haystack !== null && haystack.indexOf(needle) === 0) {
+		return;
+	}
 
-    throw new AssertionError({
-        message: message || 'Expected string containing expression, but string did not contain expression',
-        expected: needle,
-        actual: haystack
-    });
+	throw new AssertionError({
+		message: message || "Expected string containing expression, but string did not contain expression",
+		expected: needle,
+		actual: haystack
+	});
 }

package/src/Assertions/Throws.ts

@@ -2,26 +2,26 @@ import { AssertionError } from "assert";
 
 /**
  * Asserts that an expression throws an error/exception
- * 
+ *
  * @remarks
  * Passes if calling `expression` throws an error/exception
- * 
+ *
  * Fails if calling `expression` does not throw an error/exception
  *
  * @param expression the expression to run
  * @param message (optional) message to display on failure
- * 
+ *
  * @example
  * this.assert.throws(() => expression);
  */
 export default function Throws(expression: () => any, message?: string) {
-    try {
-        expression();
-    } catch (exception) {
-        return;
-    }
+	try {
+		expression();
+	} catch (exception) {
+		return;
+	}
 
-    throw new AssertionError({
-        message: message || 'Expected expression to throw exception, but expression did not throw exception'
-    });
+	throw new AssertionError({
+		message: message || "Expected expression to throw exception, but expression did not throw exception"
+	});
 }

package/src/Assertions/True.ts

@@ -2,12 +2,12 @@ import { AssertionError } from "assert";
 
 /**
  * Asserts that a given expression evaluates to `true`
- * 
+ *
  * @remarks
  * Passes if `expression` evaluates to `true`
- * 
+ *
  * Fails if `expression` does not evaluate to `true`
- * 
+ *
  * @param expression the value to check
  * @param message (optional) message to display on failure
  *
@@ -15,13 +15,13 @@ import { AssertionError } from "assert";
  * this.assert.true(expression);
  */
 export default function True(expression: any, message?: string) {
-    if(expression === true) {
-        return;
-    }
+	if (expression === true) {
+		return;
+	}
 
-    throw new AssertionError({
-        message: message || 'Expected expression to be true, but expression is not true',
-        expected: true,
-        actual: expression
-    });
+	throw new AssertionError({
+		message: message || "Expected expression to be true, but expression is not true",
+		expected: true,
+		actual: expression
+	});
 }

package/src/Assertions/Undefined.ts

@@ -2,26 +2,26 @@ import { AssertionError } from "assert";
 
 /**
  * Asserts that a given value is equal to `undefined`
- * 
+ *
  * @remarks
  * Passes if `expression` evaluates to `undefined`
- * 
+ *
  * Fails if `expression` does not evaluate to `undefined`
- * 
+ *
  * @param expression the value to check
  * @param message (optional) message to display on failure
- * 
+ *
  * @example
  * this.assert.undefined(expression);
  */
 export default function Undefined(expression: any, message?: string) {
-    if(expression === undefined) {
-        return;
-    }
+	if (expression === undefined) {
+		return;
+	}
 
-    throw new AssertionError({
-        message: message || 'Expected expression to be undefined, but expression is not undefined',
-        expected: undefined,
-        actual: expression
-    });
+	throw new AssertionError({
+		message: message || "Expected expression to be undefined, but expression is not undefined",
+		expected: undefined,
+		actual: expression
+	});
 }

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,98 +1,99 @@
-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 Factory from "./Factory";
 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: "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 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 [-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 usage = Usage(CLI.sections);
+	private static readonly usage = Usage(CLI.sections);
 
-    constructor(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 = Factory.Runner(args);
+		const runner = this.runnerFactory(args);
 
-        try {
-            const results = await runner.runAll(args.dir);
-            return Runner.allTestsPassed(results);
-        } catch (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 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;
+		}
+	}
 }