Add ability to use error factory in matcher. Add jest tests for the matcher.

Author: MichaelOates

.gitignore

@@ -102,3 +102,5 @@ dist
 
 # TernJS port file
 .tern-port
+
+.idea/

jest.config.js

@@ -0,0 +1,5 @@
+module.exports = {
+  preset: 'ts-jest',
+  testEnvironment: 'node',
+
+};

package.json

@@ -24,10 +24,12 @@
   "scripts": {
     "build": "rm -rf ./dist; tsc",
     "lint:check": "eslint . --ext .ts",
-    "lint": "yarn lint:check --fix"
+    "lint": "yarn lint:check --fix",
+    "test": "yarn jest --no-colors"
   },
   "devDependencies": {
-    "@types/jest": "^25.2.1",
+    "@types/jest": "^25.2.3",
+    "@types/node": "^13.13.0",
     "@typescript-eslint/eslint-plugin": "^2.28.0",
     "@typescript-eslint/parser": "^2.28.0",
     "eslint": "^6.8.0",
@@ -37,10 +39,9 @@
     "eslint-plugin-node": "^11.1.0",
     "eslint-plugin-prettier": "^3.1.3",
     "eslint-plugin-simple-import-sort": "^5.0.2",
-    "jest": "^25.4.0",
+    "jest": "^26.0.1",
     "prettier": "^2.0.4",
-    "ts-jest": "^25.4.0",
-    "typescript": "^3.8.3",
-    "@types/node": "^13.13.0"
+    "ts-jest": "^26.0.0",
+    "typescript": "^3.8.3"
   }
 }

src/matcher.ts

@@ -11,35 +11,56 @@ function errorToObject(error: Error) {
   };
 }
 
+type ErrorFactory = Error | (() => void);
+function unwrapErrorFactory(value: ErrorFactory): Error | undefined {
+  if (typeof value === 'function') {
+    try {
+      value();
+    } catch(error) {
+      return error;
+    }
+  } else {
+    return value;
+  }
+}
+
 export function toMatchError(
   this: MatcherContext,
-  gotError: Error,
+  gotErrorFactory: Error | (() => void),
   expectedError: Error
 ): CustomMatcherResult {
-  const got = errorToObject(gotError);
+  const gotError = unwrapErrorFactory(gotErrorFactory);
   const expected = errorToObject(expectedError);
 
   const diff: string[] = [];
-
-  if (got.class !== expected.class) {
+  if (gotError === undefined) {
     diff.push(
-      "Error class is not the same:",
-      this.utils.diff(got.class, expected.class) as string
+        "Expected to receive an error, but no error was thrown"
     );
-  }
+  } else {
 
-  if (got.message !== expected.message) {
-    diff.push(
-      "Error message is not the same:",
-      this.utils.diff(got.message, expected.message) as string
-    );
-  }
+    const got = errorToObject(gotError);
 
-  if (!this.equals(got.publicFields, expected.publicFields)) {
-    diff.push(
-      "Error public fields is not the same:",
-      this.utils.diff(got.publicFields, expected.publicFields) as string
-    );
+    if (got.class !== expected.class) {
+      diff.push(
+          "Error class is not the same:",
+          this.utils.diff(got.class, expected.class) as string
+      );
+    }
+
+    if (got.message !== expected.message) {
+      diff.push(
+          "Error message is not the same:",
+          this.utils.diff(got.message, expected.message) as string
+      );
+    }
+
+    if (!this.equals(got.publicFields, expected.publicFields)) {
+      diff.push(
+          "Error public fields is not the same:",
+          this.utils.diff(got.publicFields, expected.publicFields) as string
+      );
+    }
   }
 
   return {

test/__snapshots__/matcher.test.ts.snap

@@ -0,0 +1,41 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`matcher error factory should fail if no error is thrown 1`] = `"Expected to receive an error, but no error was thrown"`;
+
+exports[`matcher error factory should throw error if different messages 1`] = `
+"Error message is not the same:
+- Expected
++ Received
+
+- test
++ test2"
+`;
+
+exports[`matcher error factory should throw error if different properties 1`] = `
+"Error public fields is not the same:
+- Expected
++ Received
+
+  Object {
+-   \\"other\\": Object {},
++   \\"other\\": false,
+  }"
+`;
+
+exports[`matcher error factory should throw error if different types 1`] = `
+"Error class is not the same:
+- Expected
++ Received
+
+- [Function SpecificError2]
++ [Function SpecificError]"
+`;
+
+exports[`matcher rejected promises should throw an error if error factory result does not match 1`] = `
+"Error class is not the same:
+- Expected
++ Received
+
+- [Function SpecificError]
++ [Function SpecificError2]"
+`;

test/matcher.test.ts

@@ -0,0 +1,75 @@
+import "../src";
+
+class SpecificError extends Error {
+  constructor(message: string, readonly other: any = {}) {
+    super(message);
+  }
+}
+
+class SpecificError2 extends Error {
+  constructor(message: string, readonly other: any = {}) {
+    super(message);
+  }
+}
+
+function throwError(err: Error) {
+  return () => {
+    throw err;
+  };
+}
+
+describe("matcher", () => {
+  describe("error factory", () => {
+    it("should be successful if the error factory result matches", () => {
+      expect(throwError(new SpecificError("test"))).toMatchError(
+        new SpecificError("test")
+      );
+    });
+
+    it("should throw error if different types", () => {
+      expect(() => {
+        expect(throwError(new SpecificError2("test"))).toMatchError(
+          new SpecificError("test")
+        );
+      }).toThrowErrorMatchingSnapshot();
+    });
+
+    it("should throw error if different messages", () => {
+      expect(() => {
+        expect(throwError(new SpecificError("test"))).toMatchError(
+          new SpecificError("test2")
+        );
+      }).toThrowErrorMatchingSnapshot();
+    });
+
+    it("should throw error if different properties", () => {
+      expect(() => {
+        expect(throwError(new SpecificError("test"))).toMatchError(
+            new SpecificError("test", false)
+        );
+      }).toThrowErrorMatchingSnapshot();
+    });
+
+    it("should fail if no error is thrown", () => {
+      expect(() => {
+        expect(() => true).toMatchError(new SpecificError("test"));
+      }).toThrowErrorMatchingSnapshot();
+    });
+  });
+
+  describe("rejected promises", () => {
+    it("should be successful if the error factory result matches", async () => {
+      await expect(
+        Promise.reject(new SpecificError("test"))
+      ).rejects.toMatchError(new SpecificError("test"));
+    });
+
+    it("should throw an error if error factory result does not match", async () => {
+      await expect(async () => {
+        await expect(
+          Promise.reject(new SpecificError("test"))
+        ).rejects.toMatchError(new SpecificError2("test"));
+      }).rejects.toThrowErrorMatchingSnapshot();
+    });
+  });
+});