@jaypie/testkit 1.1.0 → 1.1.2

package/src/jsonApiSchema.module.js

@@ -1,39 +0,0 @@
-export const jsonApiErrorSchema = {
-  type: "object",
-  properties: {
-    errors: {
-      type: "array",
-      items: {
-        type: "object",
-        properties: {
-          status: { type: "number" },
-          title: { type: "string" },
-          detail: { type: "string" },
-        },
-        required: ["status", "title"],
-      },
-      minItems: 1,
-    },
-  },
-  required: ["errors"],
-};
-
-export const jsonApiSchema = {
-  type: "object",
-  properties: {
-    data: {
-      type: "object",
-      properties: {
-        id: { type: "string" },
-        type: { type: "string" },
-        attributes: { type: "object" },
-        links: { type: "object" },
-        meta: { type: "object" },
-        relationships: { type: "object" },
-      },
-      required: ["id", "type"],
-    },
-    meta: { type: "object" },
-  },
-  required: ["data"],
-};

package/src/matchers/toBeCalledAboveTrace.matcher.js

@@ -1,38 +0,0 @@
-//
-//
-// Main
-//
-
-const calledAboveTrace = (log) => {
-  // TODO: what if log is not an object?
-
-  try {
-    if (
-      log.debug.mock.calls.length > 0 ||
-      log.info.mock.calls.length > 0 ||
-      log.warn.mock.calls.length > 0 ||
-      log.error.mock.calls.length > 0 ||
-      log.fatal.mock.calls.length > 0
-    ) {
-      return {
-        message: () => `expected log not to have been called above trace`,
-        pass: true,
-      };
-    }
-    // eslint-disable-next-line no-unused-vars
-  } catch (error) {
-    throw Error(`[calledAboveTrace] log is not a mock object`);
-  }
-
-  return {
-    message: () => `expected log not to have been called above trace`,
-    pass: false,
-  };
-};
-
-//
-//
-// Export
-//
-
-export default calledAboveTrace;

package/src/matchers/toBeCalledWithInitialParams.matcher.js

@@ -1,44 +0,0 @@
-import isEqual from "lodash.isequal";
-
-//
-//
-// Main
-//
-
-export default (received, ...passed) => {
-  let pass;
-
-  if (!received || typeof received !== "function" || !received.mock) {
-    return {
-      message: () =>
-        `Expectation \`toBeCalledWithInitialParams\` expected a mock function`,
-      pass: false,
-    };
-  }
-
-  received.mock.calls.forEach((call) => {
-    if (call.length >= passed.length) {
-      let matching = true;
-      for (let i = 0; i < passed.length && matching; i += 1) {
-        if (!isEqual(passed[i], call[i])) matching = false;
-      }
-      pass = pass || matching;
-    }
-  });
-
-  if (pass === undefined) pass = false;
-
-  if (pass) {
-    return {
-      message: () =>
-        `Expectation \`toBeCalledWithInitialParams\` expected call beginning with [${passed},...]`,
-      pass: true,
-    };
-  } else {
-    return {
-      message: () =>
-        `Expectation \`not.toBeCalledWithInitialParams\` did not expect call beginning with [${passed},...]`,
-      pass: false,
-    };
-  }
-};

package/src/matchers/toBeClass.matcher.js

@@ -1,34 +0,0 @@
-//
-//
-// Main
-//
-
-const toBeClass = (received) => {
-  let pass = false;
-  if (typeof received === "function") {
-    try {
-      new received();
-      pass = true;
-      // eslint-disable-next-line no-unused-vars
-    } catch (error) {
-      pass = false;
-    }
-  }
-  if (pass) {
-    return {
-      message: () => `expected ${received} not to be a class`,
-      pass: true,
-    };
-  }
-  return {
-    message: () => `expected ${received} to be a class`,
-    pass: false,
-  };
-};
-
-//
-//
-// Export
-//
-
-export default toBeClass;

package/src/matchers/toBeJaypieError.matcher.js

@@ -1,52 +0,0 @@
-import { matchers as jsonSchemaMatchers } from "jest-json-schema";
-import { jsonApiErrorSchema } from "../jsonApiSchema.module.js";
-
-//
-//
-// Helper Functions
-//
-
-function isErrorObjectJaypieError(error) {
-  if (error.isProjectError) {
-    return {
-      message: () => `expected "${error}" not to be a Jaypie error`,
-      pass: true,
-    };
-  }
-  return {
-    message: () => `expected "${error}" to be a Jaypie error`,
-    pass: false,
-  };
-}
-
-//
-//
-// Main
-//
-
-const toBeJaypieError = (received) => {
-  // See if it is an instance of error:
-  if (received instanceof Error) {
-    return isErrorObjectJaypieError(received);
-  }
-
-  const result = jsonSchemaMatchers.toMatchSchema(received, jsonApiErrorSchema);
-  if (result.pass) {
-    return {
-      message: () => `expected ${received} not to be a Jaypie error`,
-      pass: true,
-    };
-  } else {
-    return {
-      message: () => `expected ${received} to be a Jaypie error`,
-      pass: false,
-    };
-  }
-};
-
-//
-//
-// Export
-//
-
-export default toBeJaypieError;

package/src/matchers/toMatch.matcher.js

@@ -1,76 +0,0 @@
-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

@@ -1,111 +0,0 @@
-import {
-  BadGatewayError,
-  BadRequestError,
-  ConfigurationError,
-  ForbiddenError,
-  GatewayTimeoutError,
-  InternalError,
-  isJaypieError,
-  NotFoundError,
-  UnauthorizedError,
-  UnavailableError,
-} 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 toThrowBadGatewayError = (received) =>
-  toThrowJaypieError(received, BadGatewayError);
-const toThrowBadRequestError = (received) =>
-  toThrowJaypieError(received, BadRequestError);
-const toThrowConfigurationError = (received) =>
-  toThrowJaypieError(received, ConfigurationError);
-const toThrowForbiddenError = (received) =>
-  toThrowJaypieError(received, ForbiddenError);
-const toThrowGatewayTimeoutError = (received) =>
-  toThrowJaypieError(received, GatewayTimeoutError);
-const toThrowInternalError = (received) =>
-  toThrowJaypieError(received, InternalError);
-const toThrowNotFoundError = (received) =>
-  toThrowJaypieError(received, NotFoundError);
-const toThrowUnauthorizedError = (received) =>
-  toThrowJaypieError(received, UnauthorizedError);
-const toThrowUnavailableError = (received) =>
-  toThrowJaypieError(received, UnavailableError);
-
-//
-//
-// Export
-//
-
-export default toThrowJaypieError;
-
-export {
-  toThrowBadGatewayError,
-  toThrowBadRequestError,
-  toThrowConfigurationError,
-  toThrowForbiddenError,
-  toThrowGatewayTimeoutError,
-  toThrowInternalError,
-  toThrowNotFoundError,
-  toThrowUnauthorizedError,
-  toThrowUnavailableError,
-};

package/src/matchers.module.js

@@ -1,58 +0,0 @@
-import { matchers as jsonSchemaMatchers } from "jest-json-schema";
-
-import toBeCalledAboveTrace from "./matchers/toBeCalledAboveTrace.matcher.js";
-import toBeCalledWithInitialParams from "./matchers/toBeCalledWithInitialParams.matcher.js";
-import toBeClass from "./matchers/toBeClass.matcher.js";
-import toBeJaypieError from "./matchers/toBeJaypieError.matcher.js";
-import toThrowJaypieError, {
-  toThrowBadGatewayError,
-  toThrowBadRequestError,
-  toThrowConfigurationError,
-  toThrowForbiddenError,
-  toThrowGatewayTimeoutError,
-  toThrowInternalError,
-  toThrowNotFoundError,
-  toThrowUnauthorizedError,
-  toThrowUnavailableError,
-} from "./matchers/toThrowJaypieError.matcher.js";
-
-import {
-  toMatchBase64,
-  toMatchJwt,
-  toMatchMongoId,
-  toMatchSignedCookie,
-  toMatchUuid4,
-  toMatchUuid5,
-  toMatchUuid,
-} from "./matchers/toMatch.matcher.js";
-
-//
-//
-// Export
-//
-
-export default {
-  toBeCalledAboveTrace,
-  toBeCalledWithInitialParams,
-  toBeClass,
-  toBeJaypieError,
-  toBeValidSchema: jsonSchemaMatchers.toBeValidSchema,
-  toMatchBase64,
-  toMatchJwt,
-  toMatchMongoId,
-  toMatchSchema: jsonSchemaMatchers.toMatchSchema,
-  toMatchSignedCookie,
-  toMatchUuid4,
-  toMatchUuid5,
-  toMatchUuid,
-  toThrowBadGatewayError,
-  toThrowBadRequestError,
-  toThrowConfigurationError,
-  toThrowForbiddenError,
-  toThrowGatewayTimeoutError,
-  toThrowInternalError,
-  toThrowJaypieError,
-  toThrowNotFoundError,
-  toThrowUnauthorizedError,
-  toThrowUnavailableError,
-};

package/src/mockLog.module.js

@@ -1,99 +0,0 @@
-import { vi } from "vitest";
-
-export function mockLogFactory() {
-  // Create skeleton of mock objects, as much as possible
-  const mock = {
-    debug: vi.fn(),
-    error: vi.fn(),
-    fatal: vi.fn(),
-    info: vi.fn(),
-    init: vi.fn(),
-    lib: vi.fn(),
-    tag: vi.fn(),
-    trace: vi.fn(),
-    untag: vi.fn(),
-    var: vi.fn(),
-    warn: vi.fn(),
-    with: vi.fn(),
-  };
-  // Fill out nested mocks
-  mock.debug.var = mock.var;
-  mock.error.var = mock.var;
-  mock.fatal.var = mock.var;
-  mock.info.var = mock.var;
-  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);
-
-  // Create something in the shape of the module
-  const module = {
-    debug: mock.debug,
-    error: mock.error,
-    fatal: mock.fatal,
-    info: mock.info,
-    init: mock.init,
-    lib: mock.lib,
-    tag: mock.tag,
-    trace: mock.trace,
-    untag: mock.untag,
-    var: mock.var,
-    warn: mock.warn,
-    with: mock.with,
-  };
-
-  // Pin mocks to the module
-  module.mock = mock;
-
-  // return the module
-  return module;
-}
-
-// export default mockLogFactory();
-
-const logMethodNames = [
-  "debug",
-  "error",
-  "fatal",
-  "info",
-  "init",
-  "lib",
-  "tag",
-  "trace",
-  "untag",
-  "var",
-  "warn",
-  "with",
-];
-const originalLogMethods = new WeakMap();
-
-export function spyLog(log) {
-  if (!originalLogMethods.has(log)) {
-    const mockLog = mockLogFactory();
-    const originalMethods = {};
-    logMethodNames.forEach((method) => {
-      originalMethods[method] = log[method];
-      log[method] = mockLog[method];
-    });
-    // Add custom properties
-    originalMethods.mock = log.mock;
-    log.mock = mockLog.mock;
-
-    originalLogMethods.set(log, originalMethods);
-  }
-}
-
-export function restoreLog(log) {
-  const originalMethods = originalLogMethods.get(log);
-  if (originalMethods) {
-    logMethodNames.forEach((method) => {
-      log[method] = originalMethods[method];
-    });
-    // Restore custom properties
-    log.mock = originalMethods.mock;
-
-    originalLogMethods.delete(log);
-  }
-}

package/src/sqsTestRecords.function.js

@@ -1,42 +0,0 @@
-import { v4 as uuid } from "uuid";
-
-//
-//
-// Main
-//
-
-const sqsTestRecords = (...args) => {
-  const records = [];
-
-  // See if only a single array was passed in and spread it
-  if (args.length === 1 && Array.isArray(args[0])) {
-    [args] = args;
-  }
-
-  for (let i = 0; i < args.length; i += 1) {
-    const item = args[i];
-    let body;
-    if (item && typeof item === "object") {
-      body = JSON.stringify(item);
-    } else {
-      // Cast item to string
-      body = String(item);
-    }
-    const record = {
-      messageId: uuid(),
-      body,
-    };
-    records.push(record);
-  }
-
-  return {
-    Records: records,
-  };
-};
-
-//
-//
-// Export
-//
-
-export default sqsTestRecords;