xunit.ts 0.13.1 → 1.0.3

package/package.json

@@ -1,36 +1,44 @@
 {
-  "name": "xunit.ts",
-  "version": "0.13.1",
-  "description": "A unit testing framework for TypeScript, following standard xUnit patterns",
-  "main": "dist/xunit.js",
-  "author": "ecoAPM LLC",
-  "license": "MIT",
-  "dependencies": {
-    "colors": "1.4.0",
-    "command-line-args": "5.2.0",
-    "command-line-usage": "6.1.1",
-    "lodash.isequal": "4.5.0",
-    "typescript": "4.3.5",
-    "xml": "1.0.1"
-  },
-  "devDependencies": {
-    "@microsoft/tsdoc": "0.13.2",
-    "@types/command-line-args": "5.2.0",
-    "@types/command-line-usage": "5.0.2",
-    "@types/lodash.isequal": "4.5.5",
-    "@types/node": "16.6.0",
-    "@types/xml": "1.0.6",
-    "notosans": "4.0.1",
-    "ts-mockito": "2.6.1",
-    "ts-node": "10.2.0"
-  },
-  "scripts": {
-    "clean": "rm -rf dist",
-    "build": "tsc",
-    "test": "node dist/cli.js dist/tests",
-    "tsdoc": "cp -r node_modules/notosans/noto.css node_modules/notosans/dist docs/assets &&  ts-node tsdoc.ts"
-  },
-  "bin": {
-    "xunit": "dist/cli.js"
-  }
-}
+	"name": "xunit.ts",
+	"version": "1.0.3",
+	"description": "A unit testing framework for TypeScript, following standard xUnit patterns",
+	"main": "dist/xunit.js",
+	"author": "ecoAPM LLC",
+	"homepage": "https://github.com/ecoAPM/xunit.ts",
+	"bugs": "https://github.com/ecoAPM/xunit.ts/issues",
+	"license": "MIT",
+	"dependencies": {
+		"colors": "1.4.0",
+		"command-line-args": "5.2.0",
+		"command-line-usage": "6.1.1",
+		"lodash.isequal": "4.5.0",
+		"xml": "1.0.1"
+	},
+	"devDependencies": {
+		"@microsoft/tsdoc": "0.13.2",
+		"@types/command-line-args": "5.2.0",
+		"@types/command-line-usage": "5.0.2",
+		"@types/lodash.isequal": "4.5.5",
+		"@types/node": "17.0.4",
+		"@types/xml": "1.0.7",
+		"@typescript-eslint/eslint-plugin": "5.8.0",
+		"@typescript-eslint/parser": "5.8.0",
+		"eslint": "8.5.0",
+		"notosans": "5.0.0",
+		"ts-mockito": "2.6.1",
+		"ts-node": "10.4.0",
+		"typescript": "4.5.4"
+	},
+	"peerDependencies": {
+		"typescript": "^4.0.0"
+	},
+	"scripts": {
+		"clean": "rm -rf dist",
+		"build": "tsc",
+		"test": "node dist/cli.js dist/tests",
+		"tsdoc": "cp -r node_modules/notosans/* docs/assets && ts-node tsdoc.ts"
+	},
+	"bin": {
+		"xunit": "dist/cli.js"
+	}
+}

package/sonar-project.properties

@@ -1,6 +1,6 @@
 sonar.organization=ecoapm
 sonar.projectKey=ecoAPM_xunit.ts
-sonar.sources=src
+sonar.sources=src,TSDoc
 sonar.tests=tests
 sonar.testExecutionReportPaths=sonar.xml
 sonar.javascript.lcov.reportPaths=coverage/lcov.info

package/src/Assertions/Contains.ts

@@ -2,10 +2,10 @@ import { AssertionError } from "assert";
 
 /**
  * Asserts that an array contains a given element
- * 
+ *
  * @remarks
  * Passes if array `haystack` contains an element with a value of `needle`
- * 
+ *
  * Fails if array `haystack` does not contain an element with a value of `needle`
  *
  * @param needle the element to find
@@ -16,13 +16,13 @@ import { AssertionError } from "assert";
  * this.assert.contains(needle, haystack);
  */
 export default function Contains<T>(needle: T, haystack: ReadonlyArray<T>, message?: string) {
-    if(haystack.includes(needle)) {
-        return;
-    }
+	if (haystack.includes(needle)) {
+		return;
+	}
 
-    throw new AssertionError({
-        message: message || 'Expected array containing expression, but array did not contain expression',
-        expected: needle,
-        actual: haystack
-    });
+	throw new AssertionError({
+		message: message || "Expected array containing expression, but array did not contain expression",
+		expected: needle,
+		actual: haystack
+	});
 }

package/src/Assertions/Count.ts

@@ -2,27 +2,27 @@ import { AssertionError } from "assert";
 
 /**
  * Asserts that an array contains a certain number of elements
- * 
+ *
  * @remarks
  * Passes if `array` contains `expected` number of elements
- * 
+ *
  * Fails if `array` does not contain `expected` number of elements
  *
  * @param expected the number of array elements expected
  * @param array the array to check the length of
  * @param message (optional) message to display on failure
- * 
+ *
  * @example
  * this.assert.count(expected, array);
  */
 export default function Count(expected: number, array: ReadonlyArray<any>, message?: string) {
-    if(array.length === expected) {
-        return;
-    }
+	if (array.length === expected) {
+		return;
+	}
 
-    throw new AssertionError({
-        message: message || `Expected array with ${expected} elements, but array had ${array.length} elements`,
-        expected: expected,
-        actual: array.length
-    });
+	throw new AssertionError({
+		message: message || `Expected array with ${expected} elements, but array had ${array.length} elements`,
+		expected: expected,
+		actual: array.length
+	});
 }

package/src/Assertions/Defined.ts

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

package/src/Assertions/DoesNotContain.ts

@@ -2,27 +2,27 @@ import { AssertionError } from "assert";
 
 /**
  * Asserts that an array does not contain a given element
- * 
+ *
  * @remarks
  * Passes if array `haystack` does not contain an element with a value of `needle`
- * 
+ *
  * Fails if array `haystack` contains an element with a value of `needle`
  *
  * @param needle the element to find
  * @param haystack the array to search
  * @param message (optional) message to display on failure
- * 
+ *
  * @example
  * this.assert.doesNotContain(needle, haystack);
  */
 export default function DoesNotContain<T>(needle: T, haystack: ReadonlyArray<T>, message?: string) {
-    if(!haystack.includes(needle)) {
-        return;
-    }
+	if (!haystack.includes(needle)) {
+		return;
+	}
 
-    throw new AssertionError({
-        message: message || 'Expected array not containing expression, but array contained expression',
-        expected: needle,
-        actual: haystack
-    });
+	throw new AssertionError({
+		message: message || "Expected array not containing expression, but array contained expression",
+		expected: needle,
+		actual: haystack
+	});
 }

package/src/Assertions/DoesNotThrow.ts

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

package/src/Assertions/Empty.ts

@@ -2,26 +2,26 @@ import { AssertionError } from "assert";
 
 /**
  * Asserts that an array is empty
- * 
+ *
  * @remarks
  * Passes if `array` contains zero elements
- * 
+ *
  * Fails if `array` contains any elements
  *
  * @param array the array to check
  * @param message (optional) message to display on failure
- * 
+ *
  * @example
  * this.assert.empty(array);
  */
 export default function Empty(array: ReadonlyArray<any>, message?: string) {
-    if(array.length === 0) {
-        return;
-    }
+	if (array.length === 0) {
+		return;
+	}
 
-    throw new AssertionError({
-        message: message || 'Expected expression to be empty, but expression was not empty',
-        expected: [],
-        actual: array
-    })
+	throw new AssertionError({
+		message: message || "Expected expression to be empty, but expression was not empty",
+		expected: [],
+		actual: array
+	});
 }

package/src/Assertions/Equal.ts

@@ -1,14 +1,14 @@
 import { AssertionError } from "assert";
-import equal from 'lodash.isequal';
+import equal from "lodash.isequal";
 
 /**
  * Asserts that two values are equal
- * 
+ *
  * @remarks
  * Passes if `actual` and `expected` evaluate to equal values
- * 
+ *
  * Fails if `actual` and `expected` do not evaluate to equal values
- * 
+ *
  * @param expected the expected value
  * @param actual the actual value
  * @param message (optional) message to display on failure
@@ -17,13 +17,13 @@ import equal from 'lodash.isequal';
  * this.assert.equal(expected, actual);
  */
 export default function Equal(expected: any, actual: any, message?: string) {
-    if(equal(actual, expected)) {
-        return;
-    }
+	if (equal(actual, expected)) {
+		return;
+	}
 
-    throw new AssertionError({
-        message: message || 'Expected expressions to be equal, but expressions are not equal',
-        expected: expected,
-        actual: actual,
-    });
+	throw new AssertionError({
+		message: message || "Expected expressions to be equal, but expressions are not equal",
+		expected: expected,
+		actual: actual,
+	});
 }

package/src/Assertions/False.ts

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

package/src/Assertions/InstanceOf.ts

@@ -2,27 +2,27 @@ import { AssertionError } from "assert";
 
 /**
  * Asserts that a value is an instance of a certain type
- * 
+ *
  * @remarks
  * Passes if `object`'s type matches `type`
- * 
- * Fails if `object`'s type does not match `type` 
+ *
+ * Fails if `object`'s type does not match `type`
  *
  * @param type the expected type of the value
  * @param expression the value to check
  * @param message (optional) message to display on failure
- * 
+ *
  * @example
  * this.assert.instanceOf(type, object);
  */
-export default function InstanceOf<T>(type: any, expression: any, message?: string) {
-    if (expression instanceof type) {
-        return;
-    }
+export default function InstanceOf(type: any, expression: any, message?: string) {
+	if (expression instanceof type) {
+		return;
+	}
 
-    throw new AssertionError({
-        message: message || `Expected expression of type, but was ${typeof expression}`,
-        expected: type,
-        actual: typeof expression
-    })
+	throw new AssertionError({
+		message: message || `Expected expression of type, but was ${typeof expression}`,
+		expected: type.name,
+		actual: typeof expression
+	});
 }

package/src/Assertions/NotEmpty.ts

@@ -2,26 +2,26 @@ import { AssertionError } from "assert";
 
 /**
  * Asserts that an array is not empty
- * 
+ *
  * @remarks
  * Passes if `array` contains any elements
- * 
+ *
  * Fails if `array` contains zero elements
  *
  * @param array the array to check
  * @param message (optional) message to display on failure
- * 
+ *
  * @example
  * this.assert.notEmpty(array);
  */
 export default function NotEmpty(array: ReadonlyArray<any>, message?: string) {
-    if(array.length > 0) {
-        return;
-    }
+	if (array.length > 0) {
+		return;
+	}
 
-    throw new AssertionError({
-        message: message || 'Expected expression to be not empty, but expression was empty',
-        expected: '(non-empty expression)',
-        actual: array
-    })
+	throw new AssertionError({
+		message: message || "Expected expression to be not empty, but expression was empty",
+		expected: "(non-empty expression)",
+		actual: array
+	});
 }

package/src/Assertions/NotEqual.ts

@@ -1,14 +1,14 @@
 import { AssertionError } from "assert";
-import equal from 'lodash.isequal';
+import equal from "lodash.isequal";
 
 /**
  * Asserts that two values are not equal
- * 
+ *
  * @remarks
  * Passes if `actual` and `expected` do not evaluate to equal values
- * 
+ *
  * Fails if `actual` and `expected` evaluate to equal values
- * 
+ *
  * @param expected the expected value
  * @param actual the actual value
  * @param message (optional) message to display on failure
@@ -17,13 +17,13 @@ import equal from 'lodash.isequal';
  * this.assert.notEqual(expected, actual);
  */
 export default function NotEqual(expected: any, actual: any, message?: string) {
-    if(!equal(actual, expected)) {
-        return;
-    }
+	if (!equal(actual, expected)) {
+		return;
+	}
 
-    throw new AssertionError({
-        message: message || 'Expected expressions to be not equal, but expressions are equal',
-        expected: expected,
-        actual: actual,
-    });
+	throw new AssertionError({
+		message: message || "Expected expressions to be not equal, but expressions are equal",
+		expected: expected,
+		actual: actual,
+	});
 }

package/src/Assertions/NotNull.ts

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

package/src/Assertions/Null.ts

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

package/src/Assertions/StringContains.ts

@@ -2,27 +2,27 @@ import { AssertionError } from "assert";
 
 /**
  * Asserts that a string contains a given substring
- * 
+ *
  * @remarks
  * Passes if `needle` is a substring of `haystack`
- * 
+ *
  * Fails if `needle` is not 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.stringContains(needle, haystack);
  */
-export default function StringContains(needle: string, haystack: string|null, message?: string) {
-    if(haystack !== undefined && haystack !== null && haystack.indexOf(needle) !== -1) {
-        return;
-    }
+export default function StringContains(needle: string, haystack: string | null, message?: string) {
+	if (haystack !== undefined && haystack !== null && haystack.indexOf(needle) > -1) {
+		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
+	});
 }