@jaypie/testkit 1.0.18 → 1.0.20

package/README.md

@@ -117,6 +117,30 @@ A [JSON Schema](https://json-schema.org/) validator for the [JSON:API](https://j
 
 ### `matchers`
 
+```javascript
+export default {
+  toBeCalledWithInitialParams,
+  toBeClass,
+  toBeJaypieError,
+  toBeValidSchema: jsonSchemaMatchers.toBeValidSchema,
+  toMatchBase64,
+  toMatchJwt,
+  toMatchMongoId,
+  toMatchSchema: jsonSchemaMatchers.toMatchSchema,
+  toMatchSignedCookie,
+  toMatchUuid4,
+  toMatchUuid5,
+  toMatchUuid,
+  toThrowBadRequestError,
+  toThrowConfigurationError,
+  toThrowForbiddenError,
+  toThrowInternalError,
+  toThrowJaypieError,
+  toThrowNotFoundError,
+  toThrowUnauthorizedError,
+};
+```
+
 testSetup.js
 
 ```javascript
@@ -174,6 +198,45 @@ expect(json).not.toMatchSchema(jsonApiSchema);
 
 From `jest-json-schema`; see [README](https://github.com/americanexpress/jest-json-schema?tab=readme-ov-file#tomatchschemaschema)
 
+
+#### `expect(subject).toMatch*()` Regular Expression Matchers
+
+Note: these regular expressions matchers so not verify the value is value, only that it matches the pattern (it "looks like" something). For example, `expect("123e4567-e89b-12d3-a456-426614174000").toMatchUuid()` will pass because the string matches a UUID pattern, even though it is not a valid UUID. 
+
+* `toMatchBase64`
+* `toMatchJwt`
+* `toMatchMongoId`
+* `toMatchSignedCookie`
+* `toMatchUuid4`
+* `toMatchUuid5`
+* `toMatchUuid`
+
+#### `expect(subject).toThrowJaypieError()`
+
+```javascript
+import { ConfigurationError } from "@jaypie/core";
+
+const error = new ConfigurationError();
+expect(() => {
+  throw error;
+}).toThrowJaypieError();
+```
+
+Do not forget to `await expect` when passing `async` functions:
+
+```javascript
+import { ConfigurationError } from "@jaypie/core";
+
+const error = new ConfigurationError();
+await expect(async () => {
+  throw error;
+}).toThrowJaypieError();
+
+// Breaks and causes a false-positive because `expect` did not `await`
+// expect(async () => {}).toThrowJaypieError();
+// > Error: Expected function to throw a JaypieError, but it did not throw.
+```
+
 ### `mockLogFactory()`
 
 Creates a mock of the `log` provided by `@jaypie/core`.
@@ -234,7 +297,6 @@ const event = sqsTestRecords(
 * matcher toBeJaypieData
 * matcher toBeJaypieDataObject
 * matcher toBeJaypieDataArray
-* matcher toThrowJaypieError
 * ...@knowdev/jest
 
 ## 📝 Changelog

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jaypie/testkit",
-  "version": "1.0.18",
+  "version": "1.0.20",
   "author": "Finlayson Studio",
   "type": "module",
   "main": "src/index.js",
@@ -8,10 +8,18 @@
     "format": "npm run format:package && npm run format:lint",
     "format:lint": "eslint --fix .",
     "format:package": "sort-package-json ./package.json",
+    "init:commander": "hygen jaypie commander-init",
     "init:deploy": "hygen jaypie workflow-npm",
     "lint": "eslint .",
     "new": "hygen jaypie vite",
+    "new:command": "hygen jaypie command",
+    "new:constants": "hygen jaypie constants",
+    "new:hygen": "hygen jaypie hygen",
+    "new:index": "hygen jaypie index",
+    "new:model": "hygen jaypie model",
+    "new:test": "hygen jaypie vitest",
     "test": "vitest",
+    "test:spec:constants": "vitest run ./src/__tests__/constants.spec.js",
     "test:spec:index": "vitest run ./src/__tests__/index.spec.js",
     "test:spec:jsonApiSchema.module": "vitest run ./src/__tests__/jsonApiSchema.module.spec.js",
     "test:spec:matchers.module": "vitest run ./src/__tests__/matchers.module.spec.js",
@@ -19,20 +27,19 @@
     "test:spec:sqsTestRecords.function": "vitest run ./src/__tests__/sqsTestRecords.function.spec.js",
     "test:spec:toBeCalledWithInitialParams.matcher": "vitest run ./src/matchers/__tests__/toBeCalledWithInitialParams.matcher.spec.js",
     "test:spec:toBeClass.matcher": "vitest run ./src/matchers/__tests__/toBeClass.matcher.spec.js",
-    "test:spec:toBeJaypieError.matcher": "vitest run ./src/matchers/__tests__/toBeJaypieError.matcher.spec.js"
+    "test:spec:toBeJaypieError.matcher": "vitest run ./src/matchers/__tests__/toBeJaypieError.matcher.spec.js",
+    "test:spec:toMatch.matcher": "vitest run ./src/matchers/__tests__/toMatch.matcher.spec.js",
+    "test:spec:toThrowJaypieError.matcher": "vitest run ./src/matchers/__tests__/toThrowJaypieError.matcher.spec.js"
   },
   "dependencies": {
-    "@jaypie/core": "^1.0.23",
+    "@jaypie/core": "^1.0.33",
     "jest-json-schema": "^6.1.0",
     "lodash.isequal": "^4.5.0",
     "uuid": "^9.0.1"
   },
   "devDependencies": {
     "eslint": "^8.57.0",
-    "eslint-config-prettier": "^9.1.0",
-    "eslint-plugin-import": "^2.29.1",
-    "eslint-plugin-prettier": "^5.1.3",
-    "eslint-plugin-vitest": "^0.3.26",
+    "eslint-config-jaypie": "^1.0.7",
     "hygen": "^6.2.11",
     "jest-extended": "^4.0.2",
     "prettier": "^3.2.5",

package/src/constants.js

@@ -0,0 +1,28 @@
+//
+//
+// Constants
+//
+
+export const LOG = {
+  LEVEL: {
+    ALL: "all",
+    DEBUG: "debug",
+    ERROR: "error",
+    FATAL: "fatal",
+    INFO: "info",
+    SILENT: "silent",
+    TRACE: "trace",
+    WARN: "warn",
+  },
+};
+
+export const RE_BASE64_PATTERN = /^[a-zA-Z0-9\\+\\/]+$/;
+export const RE_JWT_PATTERN = /^([^.]+)\.([^.]+)\.([^.]+)$/;
+export const RE_MONGO_ID_PATTERN = /^[a-f0-9]{24}$/i;
+export const RE_SIGNED_COOKIE_PATTERN = /^s:([^.]+)\.([^.]+)$/;
+export const RE_UUID_4_PATTERN =
+  /^[a-f0-9]{8}-?[a-f0-9]{4}-?4[a-f0-9]{3}-?[89ab][a-f0-9]{3}-?[a-f0-9]{12}$/i;
+export const RE_UUID_5_PATTERN =
+  /^[a-f0-9]{8}-?[a-f0-9]{4}-?5[a-f0-9]{3}-?[89ab][a-f0-9]{3}-?[a-f0-9]{12}$/i;
+export const RE_UUID_PATTERN =
+  /^[a-f0-9]{8}-?[a-f0-9]{4}-?[a-f0-9]{4}-?[89ab][a-f0-9]{3}-?[a-f0-9]{12}$/i;

package/src/index.js

@@ -3,19 +3,7 @@
 // Constants
 //
 
-export const LOG = {
-  LEVEL: {
-    ALL: "all",
-    DEBUG: "debug",
-    ERROR: "error",
-    FATAL: "fatal",
-    INFO: "info",
-    SILENT: "silent",
-    TRACE: "trace",
-    WARN: "warn",
-  },
-};
-
+export { LOG } from "./constants.js";
 //
 //
 // Export

package/src/matchers/toMatch.matcher.js

@@ -0,0 +1,76 @@
+import {
+  RE_BASE64_PATTERN,
+  RE_JWT_PATTERN,
+  RE_MONGO_ID_PATTERN,
+  RE_SIGNED_COOKIE_PATTERN,
+  RE_UUID_4_PATTERN,
+  RE_UUID_5_PATTERN,
+  RE_UUID_PATTERN,
+} from "../constants.js";
+
+//
+//
+// Helper
+//
+
+function forSubjectToMatchPattern(
+  subject,
+  pattern,
+  { patternName = "pattern" } = {},
+) {
+  if (pattern.test(subject)) {
+    return {
+      message: () => `expected "${subject}" not to match ${patternName}`,
+      pass: true,
+    };
+  }
+  return {
+    message: () => `expected "${subject}" to match ${patternName}`,
+    pass: false,
+  };
+}
+
+//
+//
+// Main
+//
+
+export const toMatchBase64 = (subject) =>
+  forSubjectToMatchPattern(subject, RE_BASE64_PATTERN, {
+    patternName: "Base64",
+  });
+
+export const toMatchJwt = (subject) =>
+  forSubjectToMatchPattern(subject, RE_JWT_PATTERN, {
+    patternName: "JWT",
+  });
+
+export const toMatchMongoId = (subject) =>
+  forSubjectToMatchPattern(subject, RE_MONGO_ID_PATTERN, {
+    patternName: "MongoDbId",
+  });
+
+export const toMatchSignedCookie = (subject) =>
+  forSubjectToMatchPattern(subject, RE_SIGNED_COOKIE_PATTERN, {
+    patternName: "Signed-Cookie",
+  });
+
+export const toMatchUuid4 = (subject) =>
+  forSubjectToMatchPattern(subject, RE_UUID_4_PATTERN, {
+    patternName: "UUIDv4",
+  });
+
+export const toMatchUuid5 = (subject) =>
+  forSubjectToMatchPattern(subject, RE_UUID_5_PATTERN, {
+    patternName: "UUIDv5",
+  });
+
+/**
+ * Determines if subject matches a UUID pattern.
+ * Does _NOT_ check if the UUID is valid.
+ * @param {String} subject
+ */
+export const toMatchUuid = (subject) =>
+  forSubjectToMatchPattern(subject, RE_UUID_PATTERN, {
+    patternName: "UUID",
+  });

package/src/matchers/toThrowJaypieError.matcher.js

@@ -0,0 +1,99 @@
+import {
+  BadRequestError,
+  ConfigurationError,
+  ForbiddenError,
+  InternalError,
+  isJaypieError,
+  NotFoundError,
+  UnauthorizedError,
+} from "@jaypie/core";
+
+//
+//
+// Main
+//
+
+const toThrowJaypieError = async (received, expected) => {
+  const isAsync =
+    received.constructor.name === "AsyncFunction" ||
+    received.constructor.name === "Promise";
+
+  // If expected is a function, call it
+  if (typeof expected === "function") {
+    expected = expected();
+  }
+
+  try {
+    const result = received();
+
+    if (isAsync) {
+      await result;
+    }
+
+    // If no error is thrown, fail the test
+    return {
+      pass: false,
+      message: () =>
+        "Expected function to throw a JaypieError, but it did not throw.",
+    };
+  } catch (error) {
+    if (isJaypieError(error)) {
+      // If expected is also a JaypieError, check if the error matches
+      if (isJaypieError(expected)) {
+        // If the error does not match, fail the test
+        if (error._type !== expected._type) {
+          return {
+            pass: false,
+            message: () =>
+              `Expected function to throw "${expected._type}", but it threw "${error._type}"`,
+          };
+        }
+      }
+      return {
+        pass: true,
+        message: () =>
+          `Expected function not to throw a JaypieError, but it threw ${error}`,
+      };
+    }
+
+    return {
+      pass: false,
+      message: () =>
+        `Expected function to throw a JaypieError, but it threw ${error}`,
+    };
+  }
+};
+
+//
+//
+// Convenience Methods
+//
+
+const toThrowBadRequestError = (received) =>
+  toThrowJaypieError(received, BadRequestError);
+const toThrowConfigurationError = (received) =>
+  toThrowJaypieError(received, ConfigurationError);
+const toThrowForbiddenError = (received) =>
+  toThrowJaypieError(received, ForbiddenError);
+const toThrowInternalError = (received) =>
+  toThrowJaypieError(received, InternalError);
+const toThrowNotFoundError = (received) =>
+  toThrowJaypieError(received, NotFoundError);
+const toThrowUnauthorizedError = (received) =>
+  toThrowJaypieError(received, UnauthorizedError);
+
+//
+//
+// Export
+//
+
+export default toThrowJaypieError;
+
+export {
+  toThrowBadRequestError,
+  toThrowConfigurationError,
+  toThrowForbiddenError,
+  toThrowInternalError,
+  toThrowNotFoundError,
+  toThrowUnauthorizedError,
+};

package/src/matchers.module.js

@@ -3,6 +3,24 @@ import { matchers as jsonSchemaMatchers } from "jest-json-schema";
 import toBeCalledWithInitialParams from "./matchers/toBeCalledWithInitialParams.matcher.js";
 import toBeClass from "./matchers/toBeClass.matcher.js";
 import toBeJaypieError from "./matchers/toBeJaypieError.matcher.js";
+import toThrowJaypieError, {
+  toThrowBadRequestError,
+  toThrowConfigurationError,
+  toThrowForbiddenError,
+  toThrowInternalError,
+  toThrowNotFoundError,
+  toThrowUnauthorizedError,
+} from "./matchers/toThrowJaypieError.matcher.js";
+
+import {
+  toMatchBase64,
+  toMatchJwt,
+  toMatchMongoId,
+  toMatchSignedCookie,
+  toMatchUuid4,
+  toMatchUuid5,
+  toMatchUuid,
+} from "./matchers/toMatch.matcher.js";
 
 //
 //
@@ -14,5 +32,19 @@ export default {
   toBeClass,
   toBeJaypieError,
   toBeValidSchema: jsonSchemaMatchers.toBeValidSchema,
+  toMatchBase64,
+  toMatchJwt,
+  toMatchMongoId,
   toMatchSchema: jsonSchemaMatchers.toMatchSchema,
+  toMatchSignedCookie,
+  toMatchUuid4,
+  toMatchUuid5,
+  toMatchUuid,
+  toThrowBadRequestError,
+  toThrowConfigurationError,
+  toThrowForbiddenError,
+  toThrowInternalError,
+  toThrowJaypieError,
+  toThrowNotFoundError,
+  toThrowUnauthorizedError,
 };

package/src/mockLog.module.js

@@ -7,6 +7,7 @@ export function mockLogFactory() {
     error: vi.fn(),
     fatal: vi.fn(),
     info: vi.fn(),
+    init: vi.fn(),
     lib: vi.fn(),
     tag: vi.fn(),
     trace: vi.fn(),
@@ -23,6 +24,7 @@ export function mockLogFactory() {
   mock.trace.var = mock.var;
   mock.warn.var = mock.var;
   // Have modules return correct objects
+  mock.init.mockReturnValue(null);
   mock.lib.mockReturnValue(mock);
   mock.with.mockReturnValue(mock);
 
@@ -32,6 +34,7 @@ export function mockLogFactory() {
     error: mock.error,
     fatal: mock.fatal,
     info: mock.info,
+    init: mock.init,
     lib: mock.lib,
     tag: mock.tag,
     trace: mock.trace,
@@ -55,6 +58,8 @@ const logMethodNames = [
   "error",
   "fatal",
   "info",
+  "init",
+  "lib",
   "tag",
   "trace",
   "untag",