@ideasonpurpose/build-tools-wordpress 1.1.5 → 1.1.6

package/CHANGELOG.md

@@ -4,6 +4,12 @@ All notable changes to this project will be documented in this file. Dates are d
 
 Generated by [`auto-changelog`](https://github.com/CookPete/auto-changelog).
 
+#### v1.1.5
+
+> 25 January 2024
+
+- move the localPort stuff into devserver-proxy
+
 #### v1.1.4
 
 > 25 January 2024

package/README.md

@@ -1,6 +1,6 @@
 # @ideasonpurpose/build-tools-wordpress
 
-#### Version 1.1.5
+#### Version 1.1.6
 
 ![NPM Version](https://img.shields.io/npm/v/%40ideasonpurpose%2Fbuild-tools-wordpress?logo=npm)
 ![GitHub Actions Workflow Status](https://img.shields.io/github/actions/workflow/status/ideasonpurpose/build-tools-wordpress/npm-publish.yml?logo=github&logoColor=white)

package/bin/port-reporter.js

@@ -15,7 +15,7 @@ const main = async () => {
       "\n",
       " 🚀 ",
       chalk.bold("Local WP site:"),
-      chalk.magenta(`http://${info.hostname}:${chalk.bold(info.port)}`),
+      chalk.yellow(`http://${info.hostname}:${chalk.bold(info.port)}`),
       "\n",
     );
   } else {

package/bin/zip.js

@@ -0,0 +1,231 @@
+import fs from "fs-extra";
+import { posix as path } from "path";
+import url from "url";
+import { fileURLToPath, pathToFileURL } from "node:url";
+
+import archiver from "archiver";
+import chalk from "chalk";
+import { cosmiconfig, cosmiconfigSync } from "cosmiconfig";
+import { filesize } from "filesize";
+import { globby } from "globby";
+import isTextPath from "is-text-path";
+import cliTruncate from "cli-truncate";
+import stringLength from "string-length";
+import replaceStream from "replacestream";
+
+import buildConfig from "./lib/buildConfig.js";
+import { prettierHrtime } from "./lib/prettier-hrtime.js";
+
+
+
+export async function  zip()  {
+  // const siteDir = new URL("../site", import.meta.url).pathname;
+  const siteDir = new URL(import.meta.url).pathname;
+  // const explorerSync = cosmiconfigSync("ideasonpurpose");
+  const explorer = cosmiconfig("ideasonpurpose");
+  // const configFile = explorerSync.search(siteDir);
+  const configFile = await explorer.search(siteDir);
+}
+
+zip()
+
+/**
+ * This script expects to the site to live in /usr/src/site/ to
+ * match the webpack config. It can also be called with a single
+ * path argument which will be evaluated relative to the script.
+ * This can be used for testing, or to bundle any directory while
+ * excluding src, node_modules, etc.
+ */
+let siteDirBase = process.argv[2] || "/usr/src/site/";
+siteDirBase += siteDirBase.endsWith("/") ? "" : "/";
+// const siteDir = new URL(siteDirBase, import.meta.url);
+
+// const explorerSync = cosmiconfigSync("ideasonpurpose");
+// const configFile = explorerSync.search(siteDir.pathname) || {
+//   config: {},
+//   filepath: siteDir.pathname,
+// };
+// const configFileUrl = url.pathToFileURL(configFile.filepath);
+// const config = buildConfig(configFile);
+
+// const explorerSync = cosmiconfigSync("ideasonpurpose");
+// const configFile = explorerSync.search(siteDir);
+
+const configFile = {
+  filepath: fileURLToPath(
+    new URL("../site/ideasonpurpose.config.js", import.meta.url)
+  ),
+};
+const configFileUrl = pathToFileURL(configFile.filepath);
+
+// import buildConfig from "./lib/buildConfig.js";
+import siteConfig from "../site/ideasonpurpose.config.js";
+
+console.log({ configFile, configFileUrl });
+
+
+return ;
+// const config = buildConfig(configFile ?? siteConfig);
+const config = buildConfig({ config: siteConfig });
+
+const packageJson = fs.readJsonSync(new URL("package.json", configFileUrl));
+packageJson.version ??= "";
+
+const archiveName = packageJson.name || "archive";
+
+const versionDirName = packageJson.version
+  ? `${archiveName}-${packageJson.version}`.replace(/[ .]/g, "_")
+  : archiveName;
+
+const zipFileName = `${versionDirName}.zip`;
+const zipFile = new URL(`_builds/${zipFileName}`, configFileUrl).pathname;
+
+fs.ensureFileSync(zipFile);
+const output = fs.createWriteStream(zipFile);
+
+output.on("finish", finishReporter);
+
+const archive = archiver("zip", { zlib: { level: 9 } });
+archive.pipe(output);
+
+console.log(chalk.bold("Bundling Project for Deployment"));
+const start = process.hrtime();
+
+/**
+ * Set projectDir to the parent directory of config.src, all bundled
+ * files will be found relative to this.
+ */
+const projectDir = new URL(`${config.src}/../`, configFileUrl);
+
+/**
+ * Counters for total uncompressed size and number of files
+ * and a re-usable scoped continuer for file info
+ */
+let inBytes = 0;
+let fileCount = 0;
+
+const globOpts = { cwd: projectDir.pathname, nodir: false };
+globby(["**/*", "!src", "!_builds", "!**/*.sql", "!**/node_modules"], globOpts)
+  .then((fileList) => {
+    /**
+     * Throw an error and bail out if there are no files to zip
+     */
+    if (!fileList.length) {
+      throw new Error("No files found.");
+    }
+    return fileList;
+  })
+  .then((fileList) =>
+    fileList.map((f) => {
+      const file = {
+        path: f,
+        stat: fs.statSync(new URL(f, projectDir)),
+        contents: fs.createReadStream(path.join(globOpts.cwd, f)),
+      };
+
+      /**
+       * Replace the dev folder name with the versioned folder name in hard-coded
+       * include paths. These replacements are only run against webpack's compiled
+       * assets and Composer's generated autoloaders.
+       */
+      if (isTextPath(f)) {
+        const devPath = new RegExp(`wp-content/themes/${archiveName}/`, "gi");
+
+        file.contents = file.contents.pipe(
+          replaceStream(devPath, `wp-content/themes/${versionDirName}/`)
+        );
+      }
+
+      file.contents.on("data", (chunk) => {
+        inBytes += chunk.length;
+      });
+
+      file.contents.on("end", () => foundReporter(file));
+
+      /**
+       * Adding a data handler changes a stream's mode from paused to flowing
+       * so we need to change it back or the streams will be truncated
+       */
+      file.contents.pause();
+      return file;
+    })
+  )
+  .then((fileList) =>
+    fileList.map((f) =>
+      archive.append(f.contents, {
+        name: f.path,
+        prefix: versionDirName,
+      })
+    )
+  )
+  .then(() => archive.finalize())
+  .catch(console.error);
+
+function foundReporter(file) {
+  fileCount += 1;
+  let outString = [
+    "🔍 ",
+    chalk.yellow("Found"),
+    chalk.magenta(fileCount),
+    chalk.yellow("files..."),
+    chalk.gray(`(Uncompressed: ${filesize(inBytes)}) `),
+  ].join(" ");
+
+  /**
+   * calculate width of terminal then shorten paths
+   */
+  const cols = process.stdout.columns - stringLength(outString) - 1;
+  outString += chalk.blue(cliTruncate(file.path, cols, { position: "middle" }));
+
+  if (fileCount % 25 == 0) {
+    process.stdout.clearLine();
+    process.stdout.cursorTo(0);
+    process.stdout.write(outString);
+  }
+}
+
+function finishReporter() {
+  const outBytes = archive.pointer();
+  const end = process.hrtime(start);
+  const duration = prettierHrtime(end);
+  const savedBytes = inBytes - outBytes;
+  const savedPercent = ((1 - outBytes / inBytes) * 100).toFixed(2);
+
+  process.stdout.clearLine();
+  process.stdout.cursorTo(0);
+
+  console.log(
+    "🔍 ",
+    chalk.yellow("Found"),
+    chalk.magenta(fileCount),
+    chalk.yellow("files"),
+    chalk.gray(`(Uncompressed: ${filesize(inBytes)})`)
+  );
+  console.log(
+    "👀 ",
+    chalk.yellow("Webpack Bundle Analyzer report:"),
+    chalk.magenta("webpack/stats/index.html")
+  );
+  console.log(
+    "📦 ",
+    chalk.yellow("Created"),
+    chalk.magenta(filesize(outBytes)),
+    chalk.yellow("Zip archive"),
+    chalk.gray(`(Saved ${filesize(savedBytes)}, ${savedPercent}%)`)
+  );
+  console.log(
+    "🎁 ",
+    chalk.yellow("Theme archive"),
+    chalk.magenta(
+      `${path.basename(path.dirname(zipFile))}/${chalk.bold(zipFileName)}`
+    ),
+    chalk.yellow("created in"),
+    chalk.magenta(duration)
+  );
+  console.log("⏳");
+  console.log(
+    "🚀 ",
+    chalk.bold(`Remember to push to ${chalk.cyan("GitHub!")}`)
+  );
+  console.log("✨");
+}

package/lib/AfterDoneReporterPlugin.js

@@ -23,7 +23,16 @@ export class AfterDoneReporterPlugin {
   apply(compiler) {
     compiler.hooks.done.tapPromise(this.name, async (stats) => {
       if (this.config.echo) {
-        // console.log(compiler.options, stats);
+        /**
+         * NOTE: As of webpack-dev-server vXX.XX.XXX, auto-assigned ports are
+         * not propagated into the compiler.options.devServer object.
+         *
+         * As a workaround, this relies on the follining line being added to
+         * the webpack.config file's devServer.setupMiddlewares method:
+         *
+         *    devServer.compiler.options.devServer.port = devServer.options.port;
+         *
+         */
         const { host, port } = compiler.options.devServer;
         const { startTime, endTime, modules, assetsInfo } = stats.compilation;
         const hostname = host === "0.0.0.0" ? "localhost" : host;
@@ -45,7 +54,23 @@ export class AfterDoneReporterPlugin {
         setTimeout(() =>
           console.log("\n" + this.config.prefix + " " + messages),
         );
+
+        setTimeout(() => {
+          // console.log(Object.keys(compiler));
+          // console.log(compiler.options);
+        });
       }
     });
+
+
+    // compiler.hooks.done.tapPromise("webpack-dev-server", async (stats) => {
+    //   await stats;
+    //   setTimeout(() => {
+    //     console.log(chalk.bold.magenta("in webpack-dev-server hook"), {
+    //       stats, thing: Object.keys( compiler.options),
+    //     });
+    //   });
+    // });
+
   }
 }

package/lib/WatchRunReporterPlugin.js

@@ -12,7 +12,7 @@ export class WatchRunReporterPlugin {
     const defaults = {
       echo: true,
       prefix: `🟢${chalk.gray("(iop)")}:`,
-      message: chalk.bold("Compiling..."),
+      message: chalk.bold("Compiling...", ""),
     };
     this.config = { ...defaults, ...options };
     this.name = "IOP Reporter Plugin";

package/lib/buildConfig.js

@@ -14,7 +14,7 @@ const defaultConfig = {
   contentBase: "/dist/", // TODO: Should this be false?
   manifestFile: "./dependency-manifest.json",
   sass: "sass-embedded",
-  // port: 8080,
+  devtool: false,
   transpileDependencies: ["ansi-regex", "normalize-url"],
   proxy: "wordpress",
 };

package/lib/devserver-proxy.js

@@ -2,101 +2,64 @@
 
 // DO NOT destructure this or we won't be able to mock it
 // import {promises as dnsPromises} from "dns";
-import dns from "dns";
+// import dns from "dns";
 import chalk from "chalk";
 import { isIP } from "net";
 
+import { findLocalPort } from "./find-local-docker-port.js";
 /**
  * If config.proxy is explicitly not false, return a {proxy} object
  * otherwise return an empty object.
  */
 export async function devserverProxy(config) {
-  let target;
+  let target = config.proxy;
 
-  // console.log({config});
-
-  // if (
-  //   config.proxy ===
-  //   "http://devserver-proxy-token--d939bef2a41c4aa154ddb8db903ce19fff338b61"
-  // ) {
-  //   /**
-  //    * Deal with the legacy service hostname, re-map to 'wordpress' which will
-  //    * be resolved to an IP address.
-  //    *
-  //    *  TODO: Remove this warning after 2023-02 (extended another year, not hurting anything)
-  //    */
-
-  //   console.log(
-  //     "⚠️ ",
-  //     `The ${chalk.magenta(
-  //       "devserver-proxy-token"
-  //     )} value is no longer necessary`,
-  //     "and can be safely removed from docker-compose"
-  //   );
-
-  //   /**
-  //    * 'wordpress' is the internal hostname used by docker
-  //    */
-  //   target = await dns.promises.resolve("wordpress").catch(() => false);
-  //   if (target) {
-  //     target = "http://" + target.pop();
-  //   }
-  // } else if (!!isIP(config.proxy)) {
-  if (!!isIP(config.proxy)) {
+  if (config.proxy === true) {
+    const localPort = await findLocalPort();
+    // console.log({ localPort });
+    if (localPort && localPort.hostname && localPort.port) {
+      target = new URL(`http://${localPort.hostname}:${localPort.port}`);
+      console.log(
+        chalk.cyan.bold(
+          `PORT FROM DEVSERVER-PROXY: TRUE ${localPort.port}`,
+          target,
+        ),
+      );
+    }
+  } else if (!!isIP(config.proxy)) {
     /**
      * Bare IP addresses
      * net.isIP() returns 4, 6 or 0(IPv4, IPv6 or not-an-IP address)
      */
-    target = `http://${config.proxy}`;
-  } else if (
-    typeof config.proxy == "string" &&
-    !config.proxy.match(/^https?:\/\//i)
-  ) {
+    target = new URL(`http://${config.proxy}`);
+  } else if (typeof config.proxy === "string") {
     /**
-     * Handle plain strings that don't start with http:// or https://
-     * Attempt to resolve these to IP addresses
+     * It's a string, first see if it can be made into a URL, then try it as
+     * a docker container name, then fail.
      */
-    target = await dns.promises.resolve(config.proxy).catch(() => false);
-
-    if (target) {
-      target = "http://" + target.pop();
+    try {
+      target = new URL(config.proxy);
+    } catch (err) {
+      const localPort = await findLocalPort(config.proxy);
+      if (localPort && localPort.hostname && localPort.port) {
+        target = new URL(`http://${localPort.hostname}:${localPort.port}`);
+        console.log(
+          chalk.cyan.bold(
+            `PORT FROM DEVSERVER-PROXY: "${config.proxy} ${localPort.port}`,
+            target,
+          ),
+        );
+      }
     }
-  } else {
-    /**
-     * Pass anything else straight through
-     */
-    target = config.proxy;
-
-    // TODO: This obliterates any default values, sort out this setting.
-
-    const localPort = await findLocalPort();
-
-    target = `http://${localPort.hostname}:${localPort.port}`;
-    console.log(
-      chalk.cyan.bold(
-        `FOUND THE PORT IN BUILDCONFIG ${localPort.port}`,
-        target,
-      ),
-    );
   }
 
-  /**
-   * Note: This is a sticky bit of code. Everything above gets bottlenecked here, and
-   * if aa previous value of target can't be converted to a URL, the whole proxy will
-   * return an empty object.
-   */
-  try {
-    config.proxyUrl = new URL(target);
-  } catch (err) {
-    // Invalid URL, unable to configure proxy.
+  if (!target) {
     return {};
   }
 
-  // console.log({ target , proxyUrl: config.proxyUrl});
-
   const proxy = {
     "**": {
-      target,
+      target: target.origin,
       secure: false,
       autoRewrite: true,
       selfHandleResponse: true, // necessary to avoid res.end being called automatically
@@ -108,7 +71,7 @@ export async function devserverProxy(config) {
         if (err.code === "ECONNRESET") {
           console.log(chalk.yellow("Caught ECONNRESET error, ignoring..."));
         } else {
-          console.log("PROXY ERROR: ", req.url, err, err.stack);
+          console.log("Devserver Proxy Error: ", req.url, err, err.stack);
           res.writeHead(500, { "Content-Type": "text-plain" });
           res.end("Webpack DevServer Proxy Error: " + err);
         }
@@ -141,7 +104,7 @@ export async function devserverProxy(config) {
             let header = proxyRes.headers[key];
             if (typeof header == "string") {
               header = header.replace(
-                new RegExp(config.proxyUrl.host, "gi"),
+                new RegExp(target.host, "gi"),
                 req.headers.host,
               );
             }
@@ -155,7 +118,7 @@ export async function devserverProxy(config) {
             "^/wp-(?:admin|includes|content/plugins).*(?:css|js|map)$",
           );
           const originRegExp = new RegExp(
-            `(http:\\\\/\\\\/|http://)${config.proxyUrl.host}`,
+            `(http:\\\\/\\\\/|http://)${target.host}`,
             "gi",
           );
 

package/lib/find-local-docker-port.js

@@ -1,19 +1,38 @@
 import { exec } from "node:child_process";
 
-export function findLocalPort() {
-  // export default () => {
-      return new Promise((resolve, reject) => {
-    exec("docker compose port wordpress 80", (error, stdout, stderr) => {
+/**
+ * Export this separately so it can be tested. The exec method
+ * in findLocalPort will be replaced with a mock.
+ */
+export function successHandler(execResponse) {
+  const [addr, port] = execResponse.trim().split(":");
+  const hostname = addr === "0.0.0.0" ? "localhost" : addr;
+  return { hostname, port };
+}
+
+export function findLocalPort(serviceName = "wordpress", timeout = 3000) {
+  /* v8 ignore start */
+  return new Promise((resolve, reject) => {
+    exec(`docker compose port ${serviceName} 80`, (error, stdout, stderr) => {
       if (error) {
         reject(error);
         return;
       }
 
       if (stdout) {
-        const [addr, port] = stdout.trim().split(":");
-        const hostname = addr === "0.0.0.0" ? "localhost" : addr;
-        resolve({ hostname, port, stdout: stdout.trim() });
+        const { hostname, port } = successHandler(stdout);
+        resolve({
+          hostname,
+          port,
+          stdout: stdout.trim(),
+          stderr: stderr.trim(),
+        });
       }
+      /* v8 ignore stop */
     });
+    setTimeout(() => {
+      const timeoutError = new Error("The `exec` command timed out.");
+      reject(timeoutError);
+    }, timeout);
   });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ideasonpurpose/build-tools-wordpress",
-  "version": "1.1.5",
+  "version": "1.1.6",
   "description": "Build scripts and dependencies for IOP's WordPress development environments.",
   "homepage": "https://github.com/ideasonpurpose/build-tools-wordpress#readme",
   "bugs": {
@@ -19,7 +19,8 @@
   "type": "module",
   "main": "index.js",
   "bin": {
-    "iop-build-port-reporter": "./bin/port-reporter.js"
+    "iop-build-port-reporter": "./bin/port-reporter.js",
+    "iop-build-zip-archive": "./bin/zip.js"
   },
   "directories": {
     "lib": "lib"
@@ -99,5 +100,9 @@
     "files": [
       "README.md"
     ]
+  },
+  "devDependencies": {
+    "@vitest/coverage-v8": "^1.2.2",
+    "vitest": "^1.2.1"
   }
 }

package/test/devserver-proxy.test.ts

@@ -0,0 +1,297 @@
+import { afterEach, beforeEach, describe, expect, test, vi } from "vitest";
+
+import fs from "fs";
+import dns from "dns";
+
+import { devserverProxy } from "../lib/devserver-proxy.js";
+import { findLocalPort } from "../lib/find-local-docker-port.js";
+
+const expected = "11.22.33.44";
+
+const expectedPort = 56789;
+const expectedHostName = "stella.dog";
+const expectedTarget = `http://${expectedHostName}:${expectedPort}`;
+
+vi.mock("../lib/find-local-docker-port.js");
+
+let localPort;
+
+beforeEach(() => {
+  localPort = new Promise((resolve) => {
+    resolve({
+      port: expectedPort,
+      hostname: expectedHostName,
+    });
+  });
+  vi.mocked(findLocalPort).mockReturnValue(localPort);
+});
+
+afterEach(() => {
+  vi.restoreAllMocks();
+});
+// beforeEach(() => {
+//   jest.spyOn(dns, "promises", "get").mockImplementation(() => {
+//     return { resolve: async () => [expected] };
+//   });
+
+//   console.log = jest.fn();
+// });
+
+// afterEach(() => {
+//   jest.clearAllMocks();
+//   jest.resetAllMocks();
+//   // mockResolve.mockResolvedValue(["11.22.33.44"]);
+// });
+
+// disabled because we're now mocking the library
+// test.skip("dns works normally", async () => {
+//   const actual = await dns.promises.resolve("apple.com");
+//   expect(actual[0]).toMatch(/^17\.253/);
+// });
+
+// test("mock dns.promises.resolve", async () => {
+//   const actual = await dns.promises.resolve("hello");
+//   expect(actual).toBe(expected);
+// });
+
+// test("resolve from file", async () => {
+//   const actual = await resolveFromFile("wordpress");
+//   expect(actual).toBe(expected);
+// });
+
+
+// test("Send legacy token where there's no wordpress service", async () => {
+//   jest.spyOn(dns, "promises", "get").mockImplementation(() => {
+//     // console.log("ONLY ONCE");
+//     return { resolve: () => new Promise((resolve, reject) => reject()) };
+//   });
+
+//   let proxy =
+//     "http://devserver-proxy-token--d939bef2a41c4aa154ddb8db903ce19fff338b61";
+
+//   const logSpy = jest.spyOn(console, "log");
+//   const actual = await devserverProxy({ proxy });
+
+//   expect(actual).toStrictEqual({});
+//   // expect(logSpy).toHaveBeenCalledWith(expect.stringContaining("ONCE"));
+//   expect(logSpy).toHaveBeenCalledWith(
+//     expect.any(String),
+//     expect.stringContaining("devserver-proxy-token"),
+//     expect.any(String)
+//   );
+// });
+
+// test("prefix http onto string", async () => {
+//   jest.spyOn(dns, "promises", "get").mockImplementation(() => {
+//     return {
+//       resolve: () => new Promise((resolve, reject) => resolve(["fake-url"])),
+//     };
+//   });
+
+//   let proxy = "placeholder string";
+//   const actual = await devserverProxy({ proxy });
+//   expect(actual).toHaveProperty("proxy.**.target", "http://fake-url");
+// });
+
+// test("fail to prefix http onto string", async () => {
+//   jest.spyOn(dns, "promises", "get").mockImplementation(() => {
+//     return {
+//       resolve: () => new Promise((resolve, reject) => reject()),
+//     };
+//   });
+
+//   let proxy = "placeholder string";
+//   const actual = await devserverProxy({ proxy });
+//   expect(actual).toStrictEqual({});
+// });
+
+test("Test proxy settings", async () => {
+  let proxy = true;
+  const actual = await devserverProxy({ proxy });
+  console.log(actual);
+  expect(actual).toHaveProperty("proxy.**.target");
+  expect(actual.proxy["**"].target).toMatch("stella");
+});
+
+test("proxy is bare IP address", async () => {
+  let proxy = "4.3.2.1";
+  const actual = await devserverProxy({ proxy });
+  expect(actual).toHaveProperty("proxy.**.target", "http://4.3.2.1");
+});
+
+test("proxy is a url", async () => {
+  let proxy = "https://example.com/";
+  const actual = await devserverProxy({ proxy });
+  expect(actual).toHaveProperty("proxy.**.target", "https://example.com");
+});
+
+test("proxy is a plain string", async () => {
+  let proxy = "sandwich";
+  const actual = await devserverProxy({ proxy });
+  expect(actual).toHaveProperty("proxy.**.target", expectedTarget);
+  expect(findLocalPort).toHaveBeenCalledWith(proxy);
+});
+
+test("Proxy boolean true", async () => {
+  vi.mocked(findLocalPort).mockReturnValue(localPort);
+  const proxy = true;
+  const actual = await devserverProxy({ proxy });
+  expect(actual).toHaveProperty("proxy.**.target", expectedTarget);
+});
+
+test("Proxy boolean false", async () => {
+  const proxy = false;
+  expect(await devserverProxy({ proxy })).toStrictEqual({});
+});
+
+test("test the returned proxy onError handler", async () => {
+  let proxy = "wordpress";
+  const logSpy = vi.spyOn(console, "log");
+  const actual = await devserverProxy({ proxy: true });
+
+  // console.log(actual);
+  expect(actual).toHaveProperty("proxy.**");
+
+  const route = actual.proxy["**"];
+  let err = new Error("boom");
+  err.code = "ECONNRESET";
+  route.onError(err);
+
+  expect(route).toHaveProperty("onError");
+  expect(logSpy).toHaveBeenLastCalledWith(
+    expect.stringContaining("ECONNRESET"),
+  );
+
+  const writeHead = vi.fn();
+  const end = vi.fn();
+  const res = { writeHead, end };
+  const req = { url: "url" };
+
+  err = new Error("boom-again ");
+  err.code = "Unknown Error Code";
+  route.onError(err, req, res);
+
+  // expect(logSpy).toHaveBeenCalledWith('PROXY ERROR');
+  // expect(logSpy.mock.calls[1][0]).toMatch(/^PROXY ERROR/);
+  // expect(end.mock.calls[0][0]).toMatch(/^Webpack DevServer/);
+});
+
+// test("test proxy's onProxyRes handler", async () => {
+//   let proxy = "https://example.com";
+//   const logSpy = jest.spyOn(console, "log");
+//   const actual = await devserverProxy({ proxy });
+
+//   const route = actual.proxy["**"];
+//   const mockProxyRes = fs.createReadStream(new URL(import.meta.url));
+
+//   mockProxyRes.headers = {
+//     headerKey: "value",
+//     host: "example.com",
+//     "content-type": "text/html; charset=utf-8",
+//   };
+//   mockProxyRes.statusCode = "statusCode";
+//   mockProxyRes.statusMessage = "statusMessage";
+
+//   const events = {};
+//   jest.spyOn(mockProxyRes, "on").mockImplementation((event, handler) => {
+//     events[event] = handler;
+//     return mockProxyRes;
+//   });
+
+//   const setHeader = jest.fn();
+//   const end = jest.fn();
+
+//   const res = { setHeader, end };
+//   const req = {
+//     headers: { host: "req.headers.host" },
+//     path: "path",
+//   };
+
+//   route.onProxyRes(mockProxyRes, req, res);
+//   events.data(Buffer.from("A string with 28 characters."));
+//   events.end();
+
+//   expect(res.statusCode).toBe(mockProxyRes.statusCode);
+//   expect(res.statusMessage).toBe(mockProxyRes.statusMessage);
+//   expect(req.headers.host).toBe("req.headers.host");
+//   expect(setHeader).toHaveBeenLastCalledWith("Content-Length", 28);
+// });
+
+// test("test proxy's onProxyRes handler onEnd passthrough", async () => {
+//   let proxy = "https://example.com";
+//   // const logSpy = jest.spyOn(console, "log");
+//   const actual = await devserverProxy({ proxy });
+
+//   const route = actual.proxy["**"];
+//   const mockProxyRes = fs.createReadStream(new URL(import.meta.url));
+
+//   console.log("hello");
+//   mockProxyRes.headers = {
+//     headerKey: "value",
+//     host: "example.com",
+//     "Content-Length": 123,
+//   };
+
+//   const events = {};
+//   jest.spyOn(mockProxyRes, "on").mockImplementation((event, handler) => {
+//     events[event] = handler;
+//     return mockProxyRes;
+//   });
+
+//   const setHeader = jest.fn();
+//   const end = jest.fn();
+
+//   const res = { setHeader, end };
+//   const req = {
+//     headers: { host: "req.headers.host" },
+//     path: "/wp-admin/fake.css",
+//   };
+
+//   route.onProxyRes(mockProxyRes, req, res);
+//   events.end();
+
+//   expect(end).toHaveBeenCalled();
+// });
+
+// test("proxy should rewrite http:// and http:\\/\\/", async () => {
+//   let proxy = "wordpress";
+
+//   const logSpy = jest.spyOn(console, "log");
+//   const actual = await devserverProxy({ proxy });
+//   const route = actual.proxy["**"];
+//   const mockProxyRes = fs.createReadStream(new URL(import.meta.url));
+
+//   mockProxyRes.headers = {
+//     headerKey: "value",
+//     host: "example.com",
+//     "content-type": "text/html; charset=utf-8",
+//   };
+
+//   const events = {};
+//   jest.spyOn(mockProxyRes, "on").mockImplementation((event, handler) => {
+//     events[event] = handler;
+//     return mockProxyRes;
+//   });
+
+//   const setHeader = jest.fn();
+//   const end = jest.fn();
+
+//   const res = { setHeader, end };
+//   const req = {
+//     headers: { host: "req.headers.host" },
+//     path: "path",
+//   };
+
+//   route.onProxyRes(mockProxyRes, req, res);
+//   events.data(Buffer.from("http://11.22.33.44\n"));
+//   events.data(Buffer.from("http:\\/\\/11.22.33.44\n"));
+//   events.end();
+
+//   expect(end.mock.calls[0][0].toString("utf8")).toMatch(
+//     /http:\/\/req.headers.host/
+//   );
+
+//   expect(end.mock.calls[0][0].toString("utf8")).toMatch(
+//     /http:\\\/\\\/req.headers.host/
+//   );
+// });

package/test/find-local-docker-port.test.ts

@@ -0,0 +1,39 @@
+import { afterEach, beforeEach, describe, expect, test, vi } from "vitest";
+
+import { exec } from "node:child_process";
+
+import {
+  findLocalPort,
+  successHandler,
+} from "../lib/find-local-docker-port.js";
+
+vi.mock("node:child_process");
+
+afterEach(() => {
+  vi.restoreAllMocks();
+});
+
+// Proof of concept: None of the tests matter if this doesn't work
+test("Mock child_process.exec", async () => {
+  const serviceName = "wp";
+  await findLocalPort(serviceName, 200).catch((err) => {
+    expect(err).toBeInstanceOf(Error);
+  });
+
+  expect(exec).toHaveBeenCalledWith(
+    `docker compose port ${serviceName} 80`,
+    expect.any(Function),
+  );
+
+  expect(exec).toHaveBeenCalledTimes(1);
+});
+
+test("successHandler returns", () => {
+  let actual;
+  actual = successHandler("0.0.0.0:55555\n");
+  expect(actual).toHaveProperty("port", "55555");
+  expect(actual).toHaveProperty("hostname", "localhost");
+
+  actual = successHandler("example.com:55555\n");
+  expect(actual).toHaveProperty("hostname", "example.com");
+});

package/vitest.config.ts

@@ -0,0 +1,18 @@
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+  test: {
+    threads: false,
+    coverage: {
+      enabled: true,
+      reportOnFailure: true,
+      reporter: ["lcov", "clover", "json", "text"],
+    },
+    // This project doesn't use a bundler, so disable
+    // deps.interopDefault. See note at the end of docs:
+    // @link https://vitest.dev/config/#deps-interopdefault
+    deps: {
+      interopDefault: false,
+    },
+  },
+});