@cedarjs/testing 0.0.4

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Cedar
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,3 @@
+# @redwoodjs/testing
+
+This package includes Redwood's Jest config.

package/api/index.js

@@ -0,0 +1,2 @@
+/* eslint-env es6, commonjs */
+module.exports = require('../dist/api')

package/api/package.json

@@ -0,0 +1,4 @@
+{
+  "main": "./index.js",
+  "types": "../dist/api/index.d.ts"
+}

package/cache/index.js

@@ -0,0 +1,2 @@
+/* eslint-env es6, commonjs */
+module.exports = require('../dist/cache')

package/cache/package.json

@@ -0,0 +1,4 @@
+{
+  "main": "./index.js",
+  "types": "../dist/cache/index.d.ts"
+}

package/config/jest/api/RedwoodApiJestEnv.js

@@ -0,0 +1,31 @@
+const { TestEnvironment } = require('jest-environment-node')
+
+class RedwoodApiJestEnvironment extends TestEnvironment {
+  constructor(config, context) {
+    super(config, context)
+    this.testPath = context.testPath
+  }
+
+  async setup() {
+    await super.setup()
+
+    this.global.testPath = this.testPath
+  }
+
+  async teardown() {
+    await super.teardown()
+  }
+
+  getVmContext() {
+    return super.getVmContext()
+  }
+
+  // async handleTestEvent(event, state) {
+  //   if (event.name === 'test_start') {
+  //     // Link to event docs:
+  //     // https://github.com/facebook/jest/blob/master/packages/jest-types/src/Circus.ts
+  //   }
+  // }
+}
+
+module.exports = RedwoodApiJestEnvironment

package/config/jest/api/apiBabelConfig.js

@@ -0,0 +1,18 @@
+const {
+  getApiSideDefaultBabelConfig,
+  getApiSideBabelPresets,
+  getApiSideBabelPlugins,
+} = require('@cedarjs/babel-config')
+
+// Since configFile and babelrc is already passed a level up, cleaning up these keys here.
+// babelrc can not reside inside "extend"ed
+// Ref: packages/testing/config/jest/api/index.js
+const { babelrc: _b, ...defaultBabelConfig } = getApiSideDefaultBabelConfig()
+
+module.exports = {
+  ...defaultBabelConfig,
+  plugins: getApiSideBabelPlugins({ forJest: true }),
+  presets: getApiSideBabelPresets({
+    presetEnv: true, // jest needs code transpiled
+  }),
+}

package/config/jest/api/globalSetup.js

@@ -0,0 +1,46 @@
+const { getSchema } = require('@prisma/internals')
+
+const { getPaths } = require('@cedarjs/project-config')
+
+const {
+  getDefaultDb,
+  checkAndReplaceDirectUrl,
+} = require('../../../dist/api/directUrlHelpers')
+
+const rwjsPaths = getPaths()
+
+module.exports = async function () {
+  if (process.env.SKIP_DB_PUSH !== '1') {
+    const process = require('process')
+    // Load dotenvs
+    require('dotenv-defaults/config')
+
+    const defaultDb = getDefaultDb(rwjsPaths.base)
+
+    process.env.DATABASE_URL = process.env.TEST_DATABASE_URL || defaultDb
+
+    // NOTE: This is a workaround to get the directUrl from the schema
+    // Instead of using the schema, we can use the config file
+    // const prismaConfig = await getConfig(rwjsPaths.api.dbSchema)
+    // and then check for the prismaConfig.datasources[0].directUrl
+    const prismaSchema = (await getSchema(rwjsPaths.api.dbSchema)).toString()
+
+    const directUrlEnvVar = checkAndReplaceDirectUrl(prismaSchema, defaultDb)
+
+    const command =
+      process.env.TEST_DATABASE_STRATEGY === 'reset'
+        ? ['prisma', 'migrate', 'reset', '--force', '--skip-seed']
+        : ['prisma', 'db', 'push', '--force-reset', '--accept-data-loss']
+
+    const execa = require('execa')
+    execa.sync(`yarn rw`, command, {
+      cwd: rwjsPaths.api.base,
+      stdio: 'inherit',
+      shell: true,
+      env: {
+        DATABASE_URL: process.env.DATABASE_URL,
+        [directUrlEnvVar]: process.env[directUrlEnvVar],
+      },
+    })
+  }
+}

package/config/jest/api/index.js

@@ -0,0 +1,2 @@
+// This is for backwards compatibility
+module.exports = require('./jest-preset')

package/config/jest/api/jest-preset.js

@@ -0,0 +1,67 @@
+// @ts-check
+const path = require('path')
+
+const { getApiSideDefaultBabelConfig } = require('@cedarjs/babel-config')
+const { getPaths } = require('@cedarjs/project-config')
+
+const rwjsPaths = getPaths()
+const NODE_MODULES_PATH = path.join(rwjsPaths.base, 'node_modules')
+const { babelrc } = getApiSideDefaultBabelConfig()
+
+/** @type {import('jest').Config} */
+module.exports = {
+  // To make sure other config option which depends on rootDir use
+  // correct path, for example, coverageDirectory
+  rootDir: rwjsPaths.base,
+  roots: [path.join(rwjsPaths.api.src)],
+  runner: path.join(__dirname, '../jest-serial-runner.js'),
+  testEnvironment: path.join(__dirname, './RedwoodApiJestEnv.js'),
+  globals: {
+    __RWJS__TEST_IMPORTS: {
+      apiSrcPath: rwjsPaths.api.src,
+      tearDownCachePath: path.join(
+        rwjsPaths.generated.base,
+        'scenarioTeardown.json',
+      ),
+      dbSchemaPath: rwjsPaths.api.dbSchema,
+    },
+  },
+  sandboxInjectedGlobals: ['__RWJS__TEST_IMPORTS'],
+  displayName: {
+    color: 'redBright',
+    name: 'api',
+  },
+  collectCoverageFrom: [
+    '**/*.{js,jsx,ts,tsx}',
+    '!**/node_modules/**',
+    '!**/dist/**',
+  ],
+  coverageDirectory: path.join(rwjsPaths.base, 'coverage'),
+  watchPlugins: [
+    'jest-watch-typeahead/filename',
+    'jest-watch-typeahead/testname',
+  ],
+  // This runs once before all tests
+  globalSetup: path.join(__dirname, './globalSetup.js'),
+  // Note this setup runs for each test file!
+  setupFilesAfterEnv: [path.join(__dirname, './jest.setup.js')],
+  moduleNameMapper: {
+    // @NOTE: Import @cedarjs/testing in api tests, and it automatically remaps to the api side only
+    // This is to prevent web stuff leaking into api, and vice versa
+    '^@cedarjs/testing$': path.join(NODE_MODULES_PATH, '@cedarjs/testing/api'),
+  },
+  transform: {
+    '\\.[jt]sx?$': [
+      'babel-jest',
+      // When jest runs tests in parallel, it serializes the config before passing down options to babel
+      // that's why these must be serializable. So ideally, we should just pass reference to a
+      // configFile or "extends" a config. But we need a few other option only at root level, so we'll pass
+      //  here and remove those keys inside "extend"ed config.
+      {
+        babelrc, // babelrc can not reside inside "extend"ed config, that's why we have it here
+        configFile: path.resolve(__dirname, './apiBabelConfig.js'),
+      },
+    ],
+  },
+  testPathIgnorePatterns: ['.scenarios.[jt]s$'],
+}

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

@@ -0,0 +1,326 @@
+/* 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/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 = []
+
+const deepCopy = (obj) => {
+  return JSON.parse(JSON.stringify(obj))
+}
+
+const isIdenticalArray = (a, 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())
+  }
+
+  // check the number of models in case we've added/removed since cache was built
+  if (teardownOrder.length !== schemaModels.length) {
+    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
+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)
+
+  if (!quoteStyle) {
+    const config = await getPrismaConfig({
+      datamodel,
+    })
+
+    switch (config.datasources?.[0]?.provider) {
+      case 'mysql':
+        quoteStyle = '`'
+        break
+      default:
+        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
+
+    if (args.length === 3) {
+      ;[scenarioName, testName, testFunc] = args
+    } else if (args.length === 2) {
+      scenarioName = DEFAULT_SCENARIO
+      ;[testName, testFunc] = args
+    } else {
+      throw new Error('scenario() requires 2 or 3 arguments')
+    }
+
+    return itFunc(testName, async () => {
+      let { scenario } = loadScenarios(testPath, scenarioName)
+
+      const scenarioData = await seedScenario(scenario)
+      try {
+        const result = await testFunc(scenarioData)
+
+        return result
+      } finally {
+        // Make sure to cleanup, even if test fails
+        if (wasDbUsed()) {
+          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
+
+    if (args.length === 3) {
+      ;[scenarioName, describeBlockName, describeBlock] = args
+    } else if (args.length === 2) {
+      scenarioName = DEFAULT_SCENARIO
+      ;[describeBlockName, describeBlock] = args
+    } else {
+      throw new Error('describeScenario() requires 2 or 3 arguments')
+    }
+
+    return describeFunc(describeBlockName, () => {
+      let scenarioData
+      beforeAll(async () => {
+        let { scenario } = loadScenarios(testPath, scenarioName)
+        scenarioData = await seedScenario(scenario)
+      })
+
+      afterAll(async () => {
+        if (wasDbUsed()) {
+          await teardown()
+        }
+      })
+
+      const getScenario = () => scenarioData
+
+      describeBlock(getScenario)
+    })
+  }
+
+const teardown = async () => {
+  const fs = require('fs')
+
+  const quoteStyle = await getQuoteStyle()
+
+  for (const modelName of teardownOrder) {
+    try {
+      await getProjectDb().$executeRawUnsafe(
+        `DELETE FROM ${quoteStyle}${modelName}${quoteStyle}`,
+      )
+    } catch (e) {
+      const match = e.message.match(/Code: `(\d+)`/)
+      if (match && FOREIGN_KEY_ERRORS.includes(parseInt(match[1]))) {
+        const index = teardownOrder.indexOf(modelName)
+        teardownOrder[index] = null
+        teardownOrder.push(modelName)
+      } else {
+        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))
+  }
+}
+
+const seedScenario = async (scenario) => {
+  if (scenario) {
+    const scenarios = {}
+    for (const [model, namedFixtures] of Object.entries(scenario)) {
+      scenarios[model] = {}
+      for (const [name, createArgs] of Object.entries(namedFixtures)) {
+        if (typeof createArgs === 'function') {
+          scenarios[model][name] = await getProjectDb()[model].create(
+            createArgs(scenarios),
+          )
+        } else {
+          scenarios[model][name] =
+            await getProjectDb()[model].create(createArgs)
+        }
+      }
+    }
+    return scenarios
+  } else {
+    return {}
+  }
+}
+
+global.scenario = buildScenario(global.it, global.testPath)
+global.scenario.only = buildScenario(global.it.only, 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.
+ */
+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
+  }
+}
+
+// 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', () => {
+  return {
+    context: mockContext,
+    setContext: (newContext) => {
+      mockContextStore.set('context', newContext)
+    },
+  }
+})
+beforeEach(() => {
+  mockContextStore.set('context', {})
+})
+global.mockCurrentUser = (currentUser) => {
+  mockContextStore.set('context', { currentUser })
+}
+
+beforeAll(async () => {
+  if (wasDbUsed()) {
+    await configureTeardown()
+  }
+})
+
+afterAll(async () => {
+  if (wasDbUsed()) {
+    getProjectDb().$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
+
+  try {
+    allScenarios = require(testFilePath)
+  } catch (e) {
+    // ignore error if scenario file not found, otherwise re-throw
+    if (e.code !== 'MODULE_NOT_FOUND') {
+      throw e
+    }
+  }
+
+  if (allScenarios) {
+    if (allScenarios[scenarioName]) {
+      scenario = allScenarios[scenarioName]
+    } else {
+      throw new Error(
+        `UndefinedScenario: There is no scenario named "${scenarioName}" in ${testFilePath}.{js,ts}`,
+      )
+    }
+  }
+  return { scenario }
+}

package/config/jest/jest-serial-runner.js

@@ -0,0 +1,13 @@
+// Originally from https://github.com/gabrieli/jest-serial-runner/blob/master/index.js
+// with fixed module export
+
+const TestRunner = require('jest-runner').default
+
+class SerialRunner extends TestRunner {
+  constructor(...attr) {
+    super(...attr)
+    this.isSerial = true
+  }
+}
+
+module.exports = SerialRunner

package/config/jest/web/RedwoodWebJestEnv.js

@@ -0,0 +1,17 @@
+const { TestEnvironment } = require('jest-environment-jsdom')
+
+// Due to issue: https://github.com/jsdom/jsdom/issues/2524
+// Fix from: https://github.com/jsdom/jsdom/issues/2524#issuecomment-736672511
+module.exports = class RedwoodWebJestEnv extends TestEnvironment {
+  async setup() {
+    await super.setup()
+    if (typeof this.global.TextEncoder === 'undefined') {
+      const { TextEncoder, TextDecoder } = require('util')
+      this.global.TextEncoder = TextEncoder
+      this.global.TextDecoder = TextDecoder
+    }
+    if (typeof this.global.crypto.subtle === 'undefined') {
+      this.global.crypto.subtle = {} // To make tests work with auth that use WebCrypto like auth0
+    }
+  }
+}

package/config/jest/web/index.js

@@ -0,0 +1,2 @@
+// This is for backwards compatibility
+module.exports = require('./jest-preset')

package/config/jest/web/jest-preset.js

@@ -0,0 +1,89 @@
+const path = require('path')
+
+const { getPaths } = require('@cedarjs/project-config')
+
+const rwjsPaths = getPaths()
+const NODE_MODULES_PATH = path.join(rwjsPaths.base, 'node_modules')
+
+/** @type {import('jest').Config} */
+module.exports = {
+  // To make sure other config option which depends on rootDir always
+  // use correct path, for example, coverageDirectory
+  rootDir: rwjsPaths.base,
+  roots: [path.join(rwjsPaths.web.src)],
+  testEnvironment: path.join(__dirname, './RedwoodWebJestEnv.js'),
+  displayName: {
+    color: 'blueBright',
+    name: 'web',
+  },
+  globals: {
+    __RWJS_TESTROOT_DIR: path.join(rwjsPaths.web.src), // used in jest setup to load mocks
+    RWJS_ENV: {
+      RWJS_API_URL: '',
+      RWJS_API_GRAPHQL_URL: '/',
+      __REDWOOD__APP_TITLE: 'Redwood App',
+    },
+    RWJS_DEBUG_ENV: {
+      RWJS_SRC_ROOT: rwjsPaths.web.src,
+    },
+  },
+  collectCoverageFrom: [
+    '**/*.{js,jsx,ts,tsx}',
+    '!**/node_modules/**',
+    '!**/dist/**',
+  ],
+  coverageDirectory: path.join(rwjsPaths.base, 'coverage'),
+  watchPlugins: [
+    'jest-watch-typeahead/filename',
+    'jest-watch-typeahead/testname',
+  ],
+  setupFilesAfterEnv: [path.resolve(__dirname, './jest.setup.js')],
+  moduleNameMapper: {
+    /**
+     * Make sure modules that require different versions of these
+     * dependencies end up using the same one.
+     */
+    '^react$': path.join(NODE_MODULES_PATH, 'react'),
+    '^react-dom$': path.join(NODE_MODULES_PATH, 'react-dom'),
+    '^@apollo/client/react$': path.join(
+      NODE_MODULES_PATH,
+      '@apollo/client/react',
+    ),
+    // We replace imports to "@cedarjs/router" with our own "mock" implementation.
+    '^@cedarjs/router$': path.join(
+      NODE_MODULES_PATH,
+      '@cedarjs/testing/dist/web/MockRouter.js',
+    ),
+    '^@cedarjs/web$': path.join(NODE_MODULES_PATH, '@cedarjs/web/dist/cjs'),
+
+    // This allows us to mock `createAuthentication` which is used by auth
+    // clients, which in turn lets us mock `useAuth` in tests
+    '^@cedarjs/auth$': path.join(
+      NODE_MODULES_PATH,
+      '@cedarjs/testing/dist/web/mockAuth.js',
+    ),
+
+    // @NOTE: Import @cedarjs/testing in web tests, and it automatically remaps to the web side only
+    // This is to prevent web stuff leaking into api, and vice versa
+    '^@cedarjs/testing$': path.join(NODE_MODULES_PATH, '@cedarjs/testing/web'),
+    '~__REDWOOD__USER_ROUTES_FOR_MOCK': rwjsPaths.web.routes,
+    '~__REDWOOD__USER_AUTH_FOR_MOCK': path.join(rwjsPaths.web.src, 'auth'),
+    /**
+     * Mock out files that aren't particularly useful in tests. See fileMock.js for more info.
+     */
+    '\\.(jpg|jpeg|png|gif|eot|otf|webp|svg|ttf|woff|woff2|mp4|webm|wav|mp3|m4a|aac|oga|css)$':
+      '@cedarjs/testing/dist/web/fileMock.js',
+  },
+  transform: {
+    '\\.[jt]sx?$': [
+      'babel-jest',
+      // When jest runs tests in parallel, it serializes the config before passing down options to babel
+      // that's why these must be serializable. Passing the reference to a config instead.
+      {
+        configFile: path.resolve(__dirname, './webBabelConfig.js'),
+      },
+    ],
+  },
+  resolver: path.resolve(__dirname, './resolver.js'),
+  testPathIgnorePatterns: ['.(stories|mock).[jt]sx?$'],
+}