nitro-test-utils/dist/shared/nitro-test-utils.Dm9MOO54.mjs

Testing environment and utilities for Nitro

import { listen } from 'listhen';
import { createNitro, createDevServer, prepare, build, copyPublicAssets, prerender } from 'nitropack';
import { resolve, join } from 'pathe';
import { existsSync, readFileSync } from 'node:fs';
import process from 'node:process';
import * as dotenv from 'dotenv';

let currentContext;
async function createTestContext(options) {
  const {
    mode = "development",
    rootDir = process.cwd(),
    isGlobal = false
  } = options;
  const isDev = mode === "development";
  const preset = isDev ? "nitro-dev" : "node";
  const outDir = resolve(rootDir, ".output");
  setupDotenv({ rootDir });
  const ctx = {
    options: {
      rootDir,
      mode
    },
    isGlobal,
    isDev,
    nitro: await createNitro({
      preset,
      dev: isDev,
      rootDir,
      buildDir: join(outDir, ".nitro"),
      serveStatic: !isDev,
      output: {
        dir: outDir
      },
      timing: true,
      replace: {
        "import.meta.test": JSON.stringify(true)
      }
    })
  };
  provideTestContext(ctx);
  return ctx;
}
function injectTestContext() {
  return currentContext;
}
function provideTestContext(context) {
  currentContext = context;
}
function clearTestContext() {
  currentContext = void 0;
}
function setupDotenv({
  rootDir = process.cwd(),
  fileName = ".env.test",
  override = true
} = {}) {
  const environment = /* @__PURE__ */ Object.create(null);
  const dotenvFile = resolve(rootDir, fileName);
  if (existsSync(dotenvFile)) {
    const parsed = dotenv.parse(readFileSync(dotenvFile, "utf8"));
    Object.assign(environment, parsed);
  }
  for (const key in environment) {
    if (override || process.env[key] === void 0)
      process.env[key] = environment[key];
  }
  return environment;
}

async function startServer() {
  const ctx = injectTestContext();
  if (!ctx) {
    throw new Error("Nitro test context is not initialized.");
  }
  if (!ctx.isGlobal) {
    await stopServer();
  }
  if (ctx.isDev) {
    const server = createDevServer(ctx.nitro);
    ctx.server = await server.listen({});
    await prepare(ctx.nitro);
    const ready = new Promise((resolve2) => {
      ctx.nitro.hooks.hook("dev:reload", () => resolve2());
    });
    await build(ctx.nitro);
    await ready;
  } else {
    await prepare(ctx.nitro);
    await copyPublicAssets(ctx.nitro);
    await prerender(ctx.nitro);
    await build(ctx.nitro);
    const entryPath = resolve(ctx.nitro.options.output.dir, "server", "index.mjs");
    const { listener } = await import(entryPath);
    ctx.server = await listen(listener);
  }
  if (ctx.isGlobal) {
    console.log("> Nitro server running at", ctx.server.url);
  }
  return ctx;
}
async function stopServer() {
  const ctx = injectTestContext();
  if (ctx?.server)
    await ctx.server.close();
  if (ctx?.nitro)
    await ctx.nitro.close();
}

export { stopServer as a, clearTestContext as b, createTestContext as c, injectTestContext as i, startServer as s };