@cedarjs/testing 0.6.1-next.0 → 0.6.1-next.51

package/config/jest/api/jest.setup.js

@@ -1,326 +1,267 @@
-/* eslint-env jest */
-// @ts-check
-
-// @NOTE without these imports in the setup file, mockCurrentUser
-// will remain undefined in the user's tests
-// Remember to use specific imports
-const { defineScenario } = require('@cedarjs/testing/dist/cjs/api/scenario')
-
-// @NOTE we do this because jest.setup.js runs every time in each context
-// while jest-preset runs once. This significantly reduces memory footprint, and testing time
-// The key is to reduce the amount of imports in this file, because the require.cache is not shared between each test context
-const { apiSrcPath, tearDownCachePath, dbSchemaPath } =
-  global.__RWJS__TEST_IMPORTS
-
-global.defineScenario = defineScenario
-
-// Error codes thrown by [MySQL, SQLite, Postgres] when foreign key constraint
-// fails on DELETE
-const FOREIGN_KEY_ERRORS = [1451, 1811, 23503]
-const TEARDOWN_CACHE_PATH = tearDownCachePath
-const DEFAULT_SCENARIO = 'standard'
-let teardownOrder = []
-let originalTeardownOrder = []
-
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var import_node_fs = __toESM(require("node:fs"), 1);
+var import_node_path = __toESM(require("node:path"), 1);
+var import_scenario = require("@cedarjs/testing/dist/cjs/api/scenario.js");
+const { apiSrcPath, tearDownCachePath, dbSchemaPath } = global.__RWJS__TEST_IMPORTS;
+global.defineScenario = import_scenario.defineScenario;
+const mockContextStore = /* @__PURE__ */ new Map();
+const mockContext = new Proxy(
+  {},
+  {
+    get: (_target, prop) => {
+      if (prop === "toJSON") {
+        return () => mockContextStore.get("context");
+      }
+      return mockContextStore.get("context")[prop];
+    },
+    set: (_target, prop, value) => {
+      const ctx = mockContextStore.get("context");
+      ctx[prop] = value;
+      return true;
+    }
+  }
+);
+global.mockCurrentUser = (currentUser) => {
+  mockContextStore.set("context", { currentUser });
+};
+const FOREIGN_KEY_ERRORS = [1451, 1811, 23503];
+const TEARDOWN_CACHE_PATH = tearDownCachePath;
+const DEFAULT_SCENARIO = "standard";
+let teardownOrder = [];
+let originalTeardownOrder = [];
 const deepCopy = (obj) => {
-  return JSON.parse(JSON.stringify(obj))
-}
-
+  return JSON.parse(JSON.stringify(obj));
+};
 const isIdenticalArray = (a, b) => {
-  return JSON.stringify(a) === JSON.stringify(b)
-}
-
+  return JSON.stringify(a) === JSON.stringify(b);
+};
 const configureTeardown = async () => {
-  const { getDMMF, getSchema } = require('@prisma/internals')
-  const fs = require('fs')
-
-  // @NOTE prisma utils are available in cli lib/schemaHelpers
-  // But avoid importing them, to prevent memory leaks in jest
-  const datamodel = await getSchema(dbSchemaPath)
-  const schema = await getDMMF({ datamodel })
-  const schemaModels = schema.datamodel.models.map((m) => m.dbName || m.name)
-
-  // check if pre-defined delete order already exists and if so, use it to start
-  if (fs.existsSync(TEARDOWN_CACHE_PATH)) {
-    teardownOrder = JSON.parse(fs.readFileSync(TEARDOWN_CACHE_PATH).toString())
+  const { getDMMF, getSchema } = require("@prisma/internals");
+  const datamodel = await getSchema(dbSchemaPath);
+  const schema = await getDMMF({ datamodel });
+  const schemaModels = schema.datamodel.models.map(
+    (m) => m.dbName || m.name
+  );
+  if (import_node_fs.default.existsSync(TEARDOWN_CACHE_PATH)) {
+    teardownOrder = JSON.parse(import_node_fs.default.readFileSync(TEARDOWN_CACHE_PATH).toString());
   }
-
-  // check the number of models in case we've added/removed since cache was built
   if (teardownOrder.length !== schemaModels.length) {
-    teardownOrder = schemaModels
+    teardownOrder = schemaModels;
   }
-
-  // keep a copy of the original order to compare against
-  originalTeardownOrder = deepCopy(teardownOrder)
-}
-
-let quoteStyle
-// determine what kind of quotes are needed around table names in raw SQL
+  originalTeardownOrder = deepCopy(teardownOrder);
+};
+let quoteStyle;
 const getQuoteStyle = async () => {
-  const { getConfig: getPrismaConfig, getSchema } = require('@prisma/internals')
-
-  // @NOTE prisma utils are available in cli lib/schemaHelpers
-  // But avoid importing them, to prevent memory leaks in jest
-  const datamodel = await getSchema(dbSchemaPath)
-
+  const { getConfig: getPrismaConfig, getSchema } = require("@prisma/internals");
+  const datamodel = await getSchema(dbSchemaPath);
   if (!quoteStyle) {
     const config = await getPrismaConfig({
-      datamodel,
-    })
-
+      datamodel
+    });
     switch (config.datasources?.[0]?.provider) {
-      case 'mysql':
-        quoteStyle = '`'
-        break
+      case "mysql":
+        quoteStyle = "`";
+        break;
       default:
-        quoteStyle = '"'
+        quoteStyle = '"';
     }
   }
-
-  return quoteStyle
-}
-
-const getProjectDb = () => {
-  const { db } = require(`${apiSrcPath}/lib/db`)
-
-  return db
-}
-
-/**
- * Wraps "it" or "test", to seed and teardown the scenario after each test
- * This one passes scenario data to the test function
- */
-const buildScenario =
-  (itFunc, testPath) =>
-  (...args) => {
-    let scenarioName, testName, testFunc
-
+  return quoteStyle;
+};
+const getProjectDb = async () => {
+  const { db } = require(`${apiSrcPath}/lib/db`);
+  return db;
+};
+function buildScenario(itFunc, testPath) {
+  const scenarioFunc = (...args) => {
+    let scenarioName, testName, testFunc;
     if (args.length === 3) {
-      ;[scenarioName, testName, testFunc] = args
+      ;
+      [scenarioName, testName, testFunc] = args;
     } else if (args.length === 2) {
-      scenarioName = DEFAULT_SCENARIO
-      ;[testName, testFunc] = args
+      scenarioName = DEFAULT_SCENARIO;
+      [testName, testFunc] = args;
     } else {
-      throw new Error('scenario() requires 2 or 3 arguments')
+      throw new Error("scenario() requires 2 or 3 arguments");
     }
-
     return itFunc(testName, async () => {
-      let { scenario } = loadScenarios(testPath, scenarioName)
-
-      const scenarioData = await seedScenario(scenario)
+      const { scenario } = await loadScenarios(testPath, scenarioName);
+      const scenarioData = await seedScenario(scenario);
       try {
-        const result = await testFunc(scenarioData)
-
-        return result
+        const result = await testFunc(scenarioData);
+        return result;
       } finally {
-        // Make sure to cleanup, even if test fails
         if (wasDbUsed()) {
-          await teardown()
+          await teardown();
         }
       }
-    })
-  }
-
-/**
- * This creates a describe() block that will seed the scenario ONCE before all tests in the block
- * Note that you need to use the getScenario() function to get the data.
- */
-const buildDescribeScenario =
-  (describeFunc, testPath) =>
-  (...args) => {
-    let scenarioName, describeBlockName, describeBlock
-
+    });
+  };
+  return Object.assign(scenarioFunc, { only: scenarioFunc });
+}
+function buildDescribeScenario(describeFunc, testPath) {
+  const describeScenarioFunc = (...args) => {
+    let scenarioName, describeBlockName, describeBlock;
     if (args.length === 3) {
-      ;[scenarioName, describeBlockName, describeBlock] = args
+      ;
+      [scenarioName, describeBlockName, describeBlock] = args;
     } else if (args.length === 2) {
-      scenarioName = DEFAULT_SCENARIO
-      ;[describeBlockName, describeBlock] = args
+      scenarioName = DEFAULT_SCENARIO;
+      [describeBlockName, describeBlock] = args;
     } else {
-      throw new Error('describeScenario() requires 2 or 3 arguments')
+      throw new Error("describeScenario() requires 2 or 3 arguments");
     }
-
     return describeFunc(describeBlockName, () => {
-      let scenarioData
+      let scenarioData;
       beforeAll(async () => {
-        let { scenario } = loadScenarios(testPath, scenarioName)
-        scenarioData = await seedScenario(scenario)
-      })
-
+        const { scenario } = await loadScenarios(testPath, scenarioName);
+        scenarioData = await seedScenario(scenario);
+      });
       afterAll(async () => {
         if (wasDbUsed()) {
-          await teardown()
+          await teardown();
         }
-      })
-
-      const getScenario = () => scenarioData
-
-      describeBlock(getScenario)
-    })
-  }
-
+      });
+      const getScenario = () => scenarioData;
+      describeBlock(getScenario);
+    });
+  };
+  return Object.assign(describeScenarioFunc, { only: describeScenarioFunc });
+}
 const teardown = async () => {
-  const fs = require('fs')
-
-  const quoteStyle = await getQuoteStyle()
-
-  for (const modelName of teardownOrder) {
+  const quoteStyle2 = await getQuoteStyle();
+  for (let i = 0; i < teardownOrder.length; i++) {
+    const modelName = teardownOrder[i];
+    if (!modelName) {
+      continue;
+    }
     try {
-      await getProjectDb().$executeRawUnsafe(
-        `DELETE FROM ${quoteStyle}${modelName}${quoteStyle}`,
-      )
+      const db = await getProjectDb();
+      await db.$executeRawUnsafe(
+        `DELETE FROM ${quoteStyle2}${modelName}${quoteStyle2}`
+      );
     } catch (e) {
-      const match = e.message.match(/Code: `(\d+)`/)
+      const message = isErrorWithMessage(e) ? e.message : "";
+      const match = message.match(/Code: `(\d+)`/);
       if (match && FOREIGN_KEY_ERRORS.includes(parseInt(match[1]))) {
-        const index = teardownOrder.indexOf(modelName)
-        teardownOrder[index] = null
-        teardownOrder.push(modelName)
+        teardownOrder.splice(i, 1);
+        teardownOrder.push(modelName);
+        i--;
       } else {
-        throw e
+        throw e;
       }
     }
   }
-
-  // remove nulls
-  teardownOrder = teardownOrder.filter((val) => val)
-
-  // if the order of delete changed, write out the cached file again
   if (!isIdenticalArray(teardownOrder, originalTeardownOrder)) {
-    originalTeardownOrder = deepCopy(teardownOrder)
-    fs.writeFileSync(TEARDOWN_CACHE_PATH, JSON.stringify(teardownOrder))
+    originalTeardownOrder = deepCopy(teardownOrder);
+    import_node_fs.default.writeFileSync(TEARDOWN_CACHE_PATH, JSON.stringify(teardownOrder));
   }
-}
-
+};
 const seedScenario = async (scenario) => {
   if (scenario) {
-    const scenarios = {}
+    const scenarios = {};
+    const db = await getProjectDb();
     for (const [model, namedFixtures] of Object.entries(scenario)) {
-      scenarios[model] = {}
+      scenarios[model] = {};
       for (const [name, createArgs] of Object.entries(namedFixtures)) {
-        if (typeof createArgs === 'function') {
-          scenarios[model][name] = await getProjectDb()[model].create(
-            createArgs(scenarios),
-          )
+        if (typeof createArgs === "function") {
+          scenarios[model][name] = await db[model].create(createArgs(scenarios));
         } else {
-          scenarios[model][name] =
-            await getProjectDb()[model].create(createArgs)
+          scenarios[model][name] = await db[model].create(createArgs);
         }
       }
     }
-    return scenarios
+    return scenarios;
   } else {
-    return {}
+    return {};
   }
-}
-
-global.scenario = buildScenario(global.it, global.testPath)
-global.scenario.only = buildScenario(global.it.only, global.testPath)
+};
+global.scenario = buildScenario(global.it, global.testPath);
 global.describeScenario = buildDescribeScenario(
   global.describe,
-  global.testPath,
-)
-global.describeScenario.only = buildDescribeScenario(
-  global.describe.only,
-  global.testPath,
-)
-
-/**
- *
- * All these hooks run in the VM/Context that the test runs in since we're using "setupAfterEnv".
- * There's a new context for each test-suite i.e. each test file
- *
- * Doing this means if the db isn't used in the current test context,
- * no need to do any of the teardown logic - allowing simple tests to run faster
- * At the same time, if the db is used, disconnecting it in this context prevents connection limit errors.
- * Just disconnecting db in jest-preset is not enough, because
- * the Prisma client is created in a different context.
- */
+  global.testPath
+);
 const wasDbUsed = () => {
   try {
-    const libDbPath = require.resolve(`${apiSrcPath}/lib/db`)
-    return Object.keys(require.cache).some((module) => {
-      return module === libDbPath
-    })
-  } catch (e) {
-    // If db wasn't resolved, no point trying to perform db resets
-    return false
+    const libDbPath = require.resolve(`${apiSrcPath}/lib/db`);
+    return Object.keys(require.cache).some((module2) => {
+      return module2 === libDbPath;
+    });
+  } catch {
+    return false;
   }
-}
-
-// Attempt to emulate the request context isolation behavior
-// This is a little more complicated than it would necessarily need to be
-// but we're following the same pattern as in `@cedarjs/context`
-const mockContextStore = new Map()
-const mockContext = new Proxy(
-  {},
-  {
-    get: (_target, prop) => {
-      // Handle toJSON() calls, i.e. JSON.stringify(context)
-      if (prop === 'toJSON') {
-        return () => mockContextStore.get('context')
-      }
-      return mockContextStore.get('context')[prop]
-    },
-    set: (_target, prop, value) => {
-      const ctx = mockContextStore.get('context')
-      ctx[prop] = value
-      return true
-    },
-  },
-)
-jest.mock('@cedarjs/context', () => {
+};
+jest.mock("@cedarjs/context", () => {
   return {
     context: mockContext,
     setContext: (newContext) => {
-      mockContextStore.set('context', newContext)
-    },
-  }
-})
+      mockContextStore.set("context", newContext);
+    }
+  };
+});
 beforeEach(() => {
-  mockContextStore.set('context', {})
-})
-global.mockCurrentUser = (currentUser) => {
-  mockContextStore.set('context', { currentUser })
-}
-
+  mockContextStore.set("context", {});
+});
 beforeAll(async () => {
   if (wasDbUsed()) {
-    await configureTeardown()
+    await configureTeardown();
   }
-})
-
+});
 afterAll(async () => {
   if (wasDbUsed()) {
-    getProjectDb().$disconnect()
+    const db = await getProjectDb();
+    db.$disconnect();
   }
-})
-
-function loadScenarios(testPath, scenarioName) {
-  const path = require('path')
-  const testFileDir = path.parse(testPath)
-  // e.g. ['comments', 'test'] or ['signup', 'state', 'machine', 'test']
-  const testFileNameParts = testFileDir.name.split('.')
-  const testFilePath = `${testFileDir.dir}/${testFileNameParts
-    .slice(0, testFileNameParts.length - 1)
-    .join('.')}.scenarios`
-  let allScenarios, scenario
-
+});
+async function loadScenarios(testPath, scenarioName) {
+  const testFileDir = import_node_path.default.parse(testPath);
+  const testFileNameParts = testFileDir.name.split(".");
+  const testFilePath = `${testFileDir.dir}/${testFileNameParts.slice(0, testFileNameParts.length - 1).join(".")}.scenarios`;
+  let allScenarios;
+  let scenario;
   try {
-    allScenarios = require(testFilePath)
+    allScenarios = require(testFilePath);
   } catch (e) {
-    // ignore error if scenario file not found, otherwise re-throw
-    if (e.code !== 'MODULE_NOT_FOUND') {
-      throw e
+    if (isErrorWithCode(e) && e.code !== "MODULE_NOT_FOUND") {
+      throw new Error(`Failed to load scenario: ${e}`);
     }
   }
-
   if (allScenarios) {
     if (allScenarios[scenarioName]) {
-      scenario = allScenarios[scenarioName]
+      scenario = allScenarios[scenarioName];
     } else {
       throw new Error(
-        `UndefinedScenario: There is no scenario named "${scenarioName}" in ${testFilePath}.{js,ts}`,
-      )
+        `UndefinedScenario: There is no scenario named "${scenarioName}" in ${testFilePath}.{js,ts}`
+      );
     }
   }
-  return { scenario }
+  return { scenario };
+}
+function isErrorWithCode(error) {
+  return !!error && typeof error === "object" && "code" in error && typeof error.code === "string";
+}
+function isErrorWithMessage(error) {
+  return !!error && typeof error === "object" && "message" in error && typeof error.message === "string";
 }

package/config/jest/babelPlugins/babel-plugin-redwood-cell.d.ts

@@ -0,0 +1,11 @@
+import type { PluginObj, PluginPass } from '@babel/core';
+import type * as t from '@babel/types';
+interface PluginState extends PluginPass {
+    exportNames: string[];
+    hasDefaultExport: boolean;
+}
+export default function ({ types, }: {
+    types: typeof t;
+}): PluginObj<PluginState>;
+export {};
+//# sourceMappingURL=babel-plugin-redwood-cell.d.ts.map

package/config/jest/babelPlugins/babel-plugin-redwood-cell.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"babel-plugin-redwood-cell.d.ts","sourceRoot":"","sources":["../../../../../src/config/jest/babelPlugins/babel-plugin-redwood-cell.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,aAAa,CAAA;AACxD,OAAO,KAAK,KAAK,CAAC,MAAM,cAAc,CAAA;AAqCtC,UAAU,WAAY,SAAQ,UAAU;IAKtC,WAAW,EAAE,MAAM,EAAE,CAAA;IACrB,gBAAgB,EAAE,OAAO,CAAA;CAC1B;AAED,MAAM,CAAC,OAAO,WAAW,EACvB,KAAK,GACN,EAAE;IACD,KAAK,EAAE,OAAO,CAAC,CAAA;CAChB,GAAG,SAAS,CAAC,WAAW,CAAC,CAkHzB"}