vitest-e2e/dist/chunk-7WPVDEFB.js

vitest e2e utils

import { testDir, page } from './chunk-7M6DEYMT.js';
import { isBuild, isWindows } from './chunk-JXTCPVDR.js';
import fs from 'fs-extra';
import path from 'node:path';
import { normalizePath } from 'vite';
import { expect } from 'vitest';

var timeout = (n) => new Promise((r) => setTimeout(r, n));
function readFile(filename) {
  return fs.readFileSync(path.resolve(testDir, filename), "utf-8");
}
function editFile(filename, replacer, runInBuild = false) {
  if (isBuild && !runInBuild)
    return;
  filename = path.resolve(testDir, filename);
  const content = fs.readFileSync(filename, "utf-8");
  const modified = replacer(content);
  fs.writeFileSync(filename, modified);
}
function addFile(filename, content) {
  fs.writeFileSync(path.resolve(testDir, filename), content);
}
function renameDir(dirname, to) {
  fs.renameSync(path.resolve(testDir, dirname), path.resolve(testDir, to));
}
function removeFile(filename) {
  fs.unlinkSync(path.resolve(testDir, filename));
}
function removeDir(dirname) {
  fs.rmSync(path.resolve(testDir, dirname), { force: true, recursive: true });
}
function listFiles(dir = "") {
  const filesDir = path.join(testDir, dir);
  return fs.readdirSync(filesDir);
}
function listAssets(base = "", assets = "assets") {
  const assetsDir = path.join(testDir, "dist", base, assets);
  return fs.readdirSync(assetsDir);
}
function findAssetFile(match, base = "", assets = "assets") {
  const assetsDir = path.join(testDir, "dist", base, assets);
  let files;
  try {
    files = fs.readdirSync(assetsDir);
  } catch (e) {
    if (e.code === "ENOENT") {
      return "";
    }
    throw e;
  }
  const file = files.find((file2) => {
    return file2.match(match);
  });
  return file ? fs.readFileSync(path.resolve(assetsDir, file), "utf-8") : "";
}
function readManifest(base = "") {
  return JSON.parse(fs.readFileSync(path.join(testDir, "dist", base, "manifest.json"), "utf-8"));
}
async function untilUpdated(poll, expected, runInBuild = false) {
  if (isBuild && !runInBuild)
    return;
  const maxTries = process.env.CI ? 200 : 50;
  for (let tries = 0; tries < maxTries; tries++) {
    const actual = await poll() ?? "";
    if (actual.includes(expected) || tries === maxTries - 1) {
      expect(actual).toMatch(expected);
      break;
    } else {
      await timeout(50);
    }
  }
}
async function withRetry(func, runInBuild = false) {
  if (isBuild && !runInBuild)
    return;
  const maxTries = process.env.CI ? 200 : 50;
  for (let tries = 0; tries < maxTries; tries++) {
    try {
      await func();
      return;
    } catch {
    }
    await timeout(50);
  }
  await func();
}
async function untilBrowserLogAfter(operation, target, arg3, arg4) {
  const expectOrder = typeof arg3 === "boolean" ? arg3 : false;
  const callback = typeof arg3 === "boolean" ? arg4 : arg3;
  const promise = untilBrowserLog(target, expectOrder);
  await operation();
  const logs = await promise;
  if (callback) {
    await callback(logs);
  }
  return logs;
}
async function untilBrowserLog(target, expectOrder = true) {
  let resolve;
  let reject;
  const promise = new Promise((_resolve, _reject) => {
    resolve = _resolve;
    reject = _reject;
  });
  const logs = [];
  try {
    const isMatch = (matcher) => (text) => typeof matcher === "string" ? text === matcher : matcher.test(text);
    let processMsg;
    if (!target) {
      processMsg = () => true;
    } else if (Array.isArray(target)) {
      if (expectOrder) {
        const remainingTargets = [...target];
        processMsg = (text) => {
          const nextTarget = remainingTargets.shift();
          expect(text).toMatch(nextTarget);
          return remainingTargets.length === 0;
        };
      } else {
        const remainingMatchers = target.map((element) => isMatch(element));
        processMsg = (text) => {
          const nextIndex = remainingMatchers.findIndex((matcher) => matcher(text));
          if (nextIndex >= 0) {
            remainingMatchers.splice(nextIndex, 1);
          }
          return remainingMatchers.length === 0;
        };
      }
    } else {
      processMsg = isMatch(target);
    }
    const handleMsg = (msg) => {
      try {
        const text = msg.text();
        if (msg.text().includes("React DevTools"))
          return;
        logs.push(text);
        const done = processMsg(text);
        if (done) {
          resolve();
        }
      } catch (err) {
        reject(err);
      }
    };
    page.on("console", handleMsg);
  } catch (err) {
    reject(err);
  }
  await promise;
  return logs;
}
var formatSourcemapForSnapshot = (map) => {
  const root = normalizePath(testDir);
  const m = { ...map };
  delete m.file;
  delete m.names;
  m.sources = m.sources.map((source) => source.replace(root, "/root"));
  return m;
};
async function killProcess(serverProcess) {
  if (isWindows) {
    try {
      const { execaCommandSync } = await import('execa');
      execaCommandSync(`taskkill /pid ${serverProcess.pid} /T /F`);
    } catch (e) {
      console.error("failed to taskkill:", e);
    }
  } else {
    serverProcess.kill("SIGTERM", { forceKillAfterTimeout: 2e3 });
  }
}

export { addFile, editFile, findAssetFile, formatSourcemapForSnapshot, killProcess, listAssets, listFiles, readFile, readManifest, removeDir, removeFile, renameDir, untilBrowserLogAfter, untilUpdated, withRetry };