wrangler 0.0.0-e043479 → 0.0.0-e0b9366

package/src/__tests__/dev.test.tsx

@@ -1,6 +1,7 @@
 import * as fs from "node:fs";
+import { readFileSync } from "node:fs";
 import patchConsole from "patch-console";
-import Dev from "../dev";
+import Dev from "../dev/dev";
 import { mockAccountId, mockApiToken } from "./helpers/mock-account-id";
 import { setMockResponse, unsetAllMocks } from "./helpers/mock-cfetch";
 import { mockConsoleMethods } from "./helpers/mock-console";
@@ -9,7 +10,6 @@ import { runWrangler } from "./helpers/run-wrangler";
 import writeWranglerToml from "./helpers/write-wrangler-toml";
 
 describe("Dev component", () => {
-  beforeEach(() => {});
   mockAccountId();
   mockApiToken();
   runInTempDir();
@@ -135,8 +135,8 @@ describe("Dev component", () => {
       });
     });
 
-    it("should, in order, use args.host/config.dev.host/args.routes/config.route/config.routes", async () => {
-      // This test might seem like it's testing implmentation details, but let's be specific and consider it a spec
+    it("should, in order, use args.host/config.dev.host/args.routes/(config.route|config.routes)", async () => {
+      // This test might seem like it's testing implementation details, but let's be specific and consider it a spec
 
       fs.writeFileSync("index.js", `export default {};`);
 
@@ -158,7 +158,6 @@ describe("Dev component", () => {
       writeWranglerToml({
         main: "index.js",
         route: "https://4.some-host.com/some/path/*",
-        routes: ["http://5.some-host.com/some/path/*"],
       });
       await runWrangler("dev");
       expect((Dev as jest.Mock).mock.calls[0][0].zone).toEqual({
@@ -172,7 +171,6 @@ describe("Dev component", () => {
       writeWranglerToml({
         main: "index.js",
         route: "https://4.some-host.com/some/path/*",
-        routes: ["http://5.some-host.com/some/path/*"],
       });
       await runWrangler("dev --routes http://3.some-host.com/some/path/*");
       expect((Dev as jest.Mock).mock.calls[0][0].zone).toEqual({
@@ -189,7 +187,6 @@ describe("Dev component", () => {
           host: `2.some-host.com`,
         },
         route: "4.some-host.com/some/path/*",
-        routes: ["5.some-host.com/some/path/*"],
       });
       await runWrangler("dev --routes http://3.some-host.com/some/path/*");
       expect((Dev as jest.Mock).mock.calls[0][0].zone).toEqual({
@@ -206,7 +203,6 @@ describe("Dev component", () => {
           host: `2.some-host.com`,
         },
         route: "4.some-host.com/some/path/*",
-        routes: ["5.some-host.com/some/path/*"],
       });
       await runWrangler(
         "dev --routes http://3.some-host.com/some/path/* --host 1.some-host.com"
@@ -231,6 +227,164 @@ describe("Dev component", () => {
       );
     });
   });
+
+  describe("custom builds", () => {
+    it("should run a custom build before starting `dev`", async () => {
+      writeWranglerToml({
+        build: {
+          command: `node -e "console.log('custom build'); require('fs').writeFileSync('index.js', 'export default { fetch(){ return new Response(123) } }')"`,
+        },
+      });
+
+      await runWrangler("dev index.js");
+
+      expect(readFileSync("index.js", "utf-8")).toMatchInlineSnapshot(
+        `"export default { fetch(){ return new Response(123) } }"`
+      );
+
+      // and the command would pass through
+      expect((Dev as jest.Mock).mock.calls[0][0].buildCommand).toEqual({
+        command:
+          "node -e \"console.log('custom build'); require('fs').writeFileSync('index.js', 'export default { fetch(){ return new Response(123) } }')\"",
+        cwd: undefined,
+        watch_dir: undefined,
+      });
+      expect(std.out).toMatchInlineSnapshot(
+        `"running: node -e \\"console.log('custom build'); require('fs').writeFileSync('index.js', 'export default { fetch(){ return new Response(123) } }')\\""`
+      );
+      expect(std.err).toMatchInlineSnapshot(`""`);
+      expect(std.warn).toMatchInlineSnapshot(`""`);
+    });
+
+    if (process.platform !== "win32") {
+      it("should run a custom build of multiple steps combined by && before starting `dev`", async () => {
+        writeWranglerToml({
+          build: {
+            command: `echo "custom build" && echo "export default { fetch(){ return new Response(123) } }" > index.js`,
+          },
+        });
+
+        await runWrangler("dev index.js");
+
+        expect(readFileSync("index.js", "utf-8")).toMatchInlineSnapshot(`
+          "export default { fetch(){ return new Response(123) } }
+          "
+        `);
+
+        expect(std.out).toMatchInlineSnapshot(
+          `"running: echo \\"custom build\\" && echo \\"export default { fetch(){ return new Response(123) } }\\" > index.js"`
+        );
+        expect(std.err).toMatchInlineSnapshot(`""`);
+        expect(std.warn).toMatchInlineSnapshot(`""`);
+      });
+    }
+
+    it("should throw an error if the entry doesn't exist after the build finishes", async () => {
+      writeWranglerToml({
+        main: "index.js",
+        build: {
+          command: `node -e "console.log('custom build');"`,
+        },
+      });
+
+      await expect(
+        runWrangler("dev")
+      ).rejects.toThrowErrorMatchingInlineSnapshot(
+        `"Could not resolve \\"index.js\\" after running custom build: node -e \\"console.log('custom build');\\""`
+      );
+      expect(std.out).toMatchInlineSnapshot(
+        `"running: node -e \\"console.log('custom build');\\""`
+      );
+      expect(std.err).toMatchInlineSnapshot(`
+        "Could not resolve \\"index.js\\" after running custom build: node -e \\"console.log('custom build');\\"
+
+        %s If you think this is a bug then please create an issue at https://github.com/cloudflare/wrangler2/issues/new."
+      `);
+      expect(std.warn).toMatchInlineSnapshot(`""`);
+    });
+  });
+
+  describe("upstream-protocol", () => {
+    it("should default upstream-protocol to `https`", async () => {
+      writeWranglerToml({
+        main: "index.js",
+      });
+      fs.writeFileSync("index.js", `export default {};`);
+      await runWrangler("dev");
+      expect((Dev as jest.Mock).mock.calls[0][0].upstreamProtocol).toEqual(
+        "https"
+      );
+      expect(std.out).toMatchInlineSnapshot(`""`);
+      expect(std.warn).toMatchInlineSnapshot(`""`);
+      expect(std.err).toMatchInlineSnapshot(`""`);
+    });
+
+    it("should warn if `--upstream-protocol=http` is used", async () => {
+      writeWranglerToml({
+        main: "index.js",
+      });
+      fs.writeFileSync("index.js", `export default {};`);
+      await runWrangler("dev --upstream-protocol=http");
+      expect((Dev as jest.Mock).mock.calls[0][0].upstreamProtocol).toEqual(
+        "http"
+      );
+      expect(std.out).toMatchInlineSnapshot(`""`);
+      expect(std.warn).toMatchInlineSnapshot(`
+        "Setting upstream-protocol to http is not currently implemented.
+        If this is required in your project, please add your use case to the following issue:
+        https://github.com/cloudflare/wrangler2/issues/583."
+      `);
+      expect(std.err).toMatchInlineSnapshot(`""`);
+    });
+  });
+
+  describe("local-protocol", () => {
+    it("should default local-protocol to `http`", async () => {
+      writeWranglerToml({
+        main: "index.js",
+      });
+      fs.writeFileSync("index.js", `export default {};`);
+      await runWrangler("dev");
+      expect((Dev as jest.Mock).mock.calls[0][0].localProtocol).toEqual("http");
+      expect(std.out).toMatchInlineSnapshot(`""`);
+      expect(std.warn).toMatchInlineSnapshot(`""`);
+      expect(std.err).toMatchInlineSnapshot(`""`);
+    });
+
+    it("should use to `local_protocol` from `wrangler.toml`, if available", async () => {
+      writeWranglerToml({
+        main: "index.js",
+        dev: {
+          local_protocol: "https",
+        },
+      });
+      fs.writeFileSync("index.js", `export default {};`);
+      await runWrangler("dev");
+      expect((Dev as jest.Mock).mock.calls[0][0].localProtocol).toEqual(
+        "https"
+      );
+      expect(std.out).toMatchInlineSnapshot(`""`);
+      expect(std.warn).toMatchInlineSnapshot(`""`);
+      expect(std.err).toMatchInlineSnapshot(`""`);
+    });
+
+    it("should use --local-protocol command line arg, if provided", async () => {
+      // Here we show that the command line overrides the wrangler.toml by
+      // setting the config to https, and then setting it back to http on the command line.
+      writeWranglerToml({
+        main: "index.js",
+        dev: {
+          local_protocol: "https",
+        },
+      });
+      fs.writeFileSync("index.js", `export default {};`);
+      await runWrangler("dev --local-protocol=http");
+      expect((Dev as jest.Mock).mock.calls[0][0].localProtocol).toEqual("http");
+      expect(std.out).toMatchInlineSnapshot(`""`);
+      expect(std.warn).toMatchInlineSnapshot(`""`);
+      expect(std.err).toMatchInlineSnapshot(`""`);
+    });
+  });
 });
 
 function mockGetZones(domain: string, zones: { id: string }[] = []) {

package/src/__tests__/dev2.test.tsx

@@ -0,0 +1,152 @@
+import * as fs from "node:fs";
+import React from "react";
+import TestRenderer from "react-test-renderer";
+import { mockAccountId, mockApiToken } from "./helpers/mock-account-id";
+import { unsetAllMocks } from "./helpers/mock-cfetch";
+import { mockConsoleMethods } from "./helpers/mock-console";
+import { runInTempDir } from "./helpers/run-in-tmp";
+import type { DevProps, default as DevType } from "../dev/dev";
+
+function sleep(period = 100): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, period));
+}
+
+// we use this ["mock"] form to avoid esbuild-jest from rewriting it
+jest["mock"]("../proxy", () => {
+  return {
+    usePreviewServer() {},
+    waitForPortToBeAvailable() {},
+  };
+});
+jest["mock"]("../inspect", () => {
+  return () => {};
+});
+
+const Dev: typeof DevType = jest.requireActual("../dev/dev").DevImplementation;
+
+mockAccountId();
+mockApiToken();
+runInTempDir();
+mockConsoleMethods();
+afterEach(() => {
+  unsetAllMocks();
+});
+
+describe("dev", () => {
+  it("should render", async () => {
+    fs.writeFileSync("./index.js", `export default {}`);
+
+    const testRenderer = await renderDev({
+      entry: {
+        file: "./index.js",
+        directory: process.cwd(),
+        format: "modules",
+      },
+    });
+    expect(testRenderer.toJSON()).toMatchInlineSnapshot(`
+      <ink-box
+        style={
+          Object {
+            "borderStyle": "round",
+            "flexDirection": "row",
+            "flexGrow": 0,
+            "flexShrink": 1,
+            "marginBottom": 0,
+            "marginLeft": 0,
+            "marginRight": 0,
+            "marginTop": 0,
+            "paddingBottom": 0,
+            "paddingLeft": 1,
+            "paddingRight": 1,
+            "paddingTop": 0,
+          }
+        }
+      >
+        <ink-text
+          internal_transform={[Function]}
+          style={
+            Object {
+              "flexDirection": "row",
+              "flexGrow": 0,
+              "flexShrink": 1,
+              "textWrap": "wrap",
+            }
+          }
+        >
+          B to open a browser, D to open Devtools, L to turn off local mode, X to exit
+        </ink-text>
+      </ink-box>
+    `);
+    await TestRenderer.act(async () => {
+      // TODO: get rid of these sleep statements
+      await sleep(50);
+      testRenderer.unmount();
+      await sleep(50);
+    });
+    await sleep(50);
+  });
+});
+
+async function renderDev({
+  name,
+  entry = { file: "index.js", directory: "", format: "modules" },
+  port,
+  inspectorPort = 9229,
+  accountId,
+  legacyEnv = true,
+  initialMode = "local",
+  jsxFactory,
+  jsxFragment,
+  localProtocol = "http",
+  upstreamProtocol = "https",
+  rules = [],
+  bindings = {
+    kv_namespaces: [],
+    vars: {},
+    durable_objects: { bindings: [] },
+    r2_buckets: [],
+    wasm_modules: undefined,
+    text_blobs: undefined,
+    unsafe: [],
+  },
+  public: publicDir,
+  assetPaths,
+  compatibilityDate,
+  compatibilityFlags,
+  usageModel,
+  buildCommand = {},
+  enableLocalPersistence = false,
+  env,
+  zone,
+}: Partial<DevProps>): Promise<TestRenderer.ReactTestRenderer> {
+  let instance: TestRenderer.ReactTestRenderer | undefined;
+  await TestRenderer.act(async () => {
+    instance = TestRenderer.create(
+      <Dev
+        name={name}
+        entry={entry}
+        env={env}
+        rules={rules}
+        port={port}
+        inspectorPort={inspectorPort}
+        legacyEnv={legacyEnv}
+        buildCommand={buildCommand}
+        initialMode={initialMode}
+        localProtocol={localProtocol}
+        upstreamProtocol={upstreamProtocol}
+        jsxFactory={jsxFactory}
+        jsxFragment={jsxFragment}
+        accountId={accountId}
+        assetPaths={assetPaths}
+        public={publicDir}
+        compatibilityDate={compatibilityDate}
+        compatibilityFlags={compatibilityFlags}
+        usageModel={usageModel}
+        bindings={bindings}
+        enableLocalPersistence={enableLocalPersistence}
+        zone={zone}
+      />
+    );
+  });
+  return instance as TestRenderer.ReactTestRenderer;
+}

package/src/__tests__/guess-worker-format.test.ts

@@ -1,6 +1,6 @@
 import { writeFile } from "fs/promises";
 import path from "path";
-import guessWorkerFormat from "../guess-worker-format";
+import guessWorkerFormat from "../entry";
 import { runInTempDir } from "./helpers/run-in-tmp";
 
 describe("guess worker format", () => {
@@ -10,10 +10,8 @@ describe("guess worker format", () => {
     // Note that this isn't actually a valid worker, because it's missing
     // a fetch handler. Regardless, our heuristic is simply to check for exports.
     const guess = await guessWorkerFormat(
-      {
-        file: path.join(process.cwd(), "./index.ts"),
-        directory: process.cwd(),
-      },
+      path.join(process.cwd(), "./index.ts"),
+      process.cwd(),
       undefined
     );
     expect(guess).toBe("modules");
@@ -25,10 +23,8 @@ describe("guess worker format", () => {
     // a fetch listener. Regardless, our heuristic is simply to check for
     // the lack of exports.
     const guess = await guessWorkerFormat(
-      {
-        file: path.join(process.cwd(), "./index.ts"),
-        directory: process.cwd(),
-      },
+      path.join(process.cwd(), "./index.ts"),
+      process.cwd(),
       undefined
     );
     expect(guess).toBe("service-worker");
@@ -38,10 +34,8 @@ describe("guess worker format", () => {
     await writeFile("./index.ts", "export default {};");
     await expect(
       guessWorkerFormat(
-        {
-          file: path.join(process.cwd(), "./index.ts"),
-          directory: process.cwd(),
-        },
+        path.join(process.cwd(), "./index.ts"),
+        process.cwd(),
         "service-worker"
       )
     ).rejects.toThrow(
@@ -53,10 +47,8 @@ describe("guess worker format", () => {
     await writeFile("./index.ts", "");
     await expect(
       guessWorkerFormat(
-        {
-          file: path.join(process.cwd(), "./index.ts"),
-          directory: process.cwd(),
-        },
+        path.join(process.cwd(), "./index.ts"),
+        process.cwd(),
         "modules"
       )
     ).rejects.toThrow(

package/src/__tests__/helpers/mock-account-id.ts

@@ -1,3 +1,5 @@
+import { reinitialiseAuthTokens } from "../../user";
+
 const ORIGINAL_CLOUDFLARE_API_TOKEN = process.env.CLOUDFLARE_API_TOKEN;
 const ORIGINAL_CLOUDFLARE_ACCOUNT_ID = process.env.CLOUDFLARE_ACCOUNT_ID;
 
@@ -16,6 +18,8 @@ export function mockApiToken({
     } else {
       process.env.CLOUDFLARE_API_TOKEN = apiToken;
     }
+    // Now we have updated the environment, we must reinitialize the user auth state.
+    reinitialiseAuthTokens();
   });
   afterEach(() => {
     process.env.CLOUDFLARE_API_TOKEN = ORIGINAL_CLOUDFLARE_API_TOKEN;

package/src/__tests__/helpers/mock-cfetch.ts

@@ -1,7 +1,7 @@
 import { URL, URLSearchParams } from "node:url";
 import { pathToRegexp } from "path-to-regexp";
 import { getCloudflareApiBaseUrl } from "../../cfetch";
-import type { FetchResult } from "../../cfetch";
+import type { FetchResult, FetchError } from "../../cfetch";
 import type { RequestInit } from "undici";
 
 /**
@@ -143,8 +143,8 @@ export function setMockResponse<ResponseType>(
 export async function createFetchResult<ResponseType>(
   result: ResponseType | Promise<ResponseType>,
   success = true,
-  errors = [],
-  messages = [],
+  errors: FetchError[] = [],
+  messages: string[] = [],
   result_info?: unknown
 ): Promise<FetchResult<ResponseType>> {
   return result_info

package/src/__tests__/helpers/mock-kv.ts

@@ -1,18 +1,15 @@
 import { createFetchResult, setMockRawResponse } from "./mock-cfetch";
+import type { NamespaceKeyInfo } from "../../kv";
 
 export function mockKeyListRequest(
   expectedNamespaceId: string,
-  expectedKeys: string[],
+  expectedKeys: NamespaceKeyInfo[],
   keysPerRequest = 1000,
   blankCursorValue: "" | undefined | null = undefined
 ) {
   const requests = { count: 0 };
   // See https://api.cloudflare.com/#workers-kv-namespace-list-a-namespace-s-keys
-  const expectedKeyObjects = expectedKeys.map((name) => ({
-    name,
-    expiration: 123456789,
-    metadata: {},
-  }));
+
   setMockRawResponse(
     "/accounts/:accountId/storage/kv/namespaces/:namespaceId/keys",
     "GET",
@@ -20,19 +17,15 @@ export function mockKeyListRequest(
       requests.count++;
       expect(accountId).toEqual("some-account-id");
       expect(namespaceId).toEqual(expectedNamespaceId);
-      if (expectedKeyObjects.length <= keysPerRequest) {
-        return createFetchResult(expectedKeyObjects);
+      if (expectedKeys.length <= keysPerRequest) {
+        return createFetchResult(expectedKeys);
       } else {
         const start = parseInt(query.get("cursor") ?? "0") || 0;
         const end = start + keysPerRequest;
-        const cursor = end < expectedKeyObjects.length ? end : blankCursorValue;
-        return createFetchResult(
-          expectedKeyObjects.slice(start, end),
-          true,
-          [],
-          [],
-          { cursor }
-        );
+        const cursor = end < expectedKeys.length ? end : blankCursorValue;
+        return createFetchResult(expectedKeys.slice(start, end), true, [], [], {
+          cursor,
+        });
       }
     }
   );

package/src/__tests__/helpers/run-in-tmp.ts

@@ -1,6 +1,7 @@
 import * as fs from "node:fs";
 import os from "node:os";
 import * as path from "node:path";
+import { reinitialiseAuthTokens } from "../../user";
 
 const originalCwd = process.cwd();
 
@@ -19,6 +20,8 @@ export function runInTempDir({ homedir }: { homedir?: string } = {}) {
       // This is because the module gets transpiled so that the "method" `homedir()` gets converted to a
       // getter that is not configurable (and so cannot be spied upon).
       jest.spyOn(os, "homedir").mockReturnValue(homedir);
+      // Now that we have changed the home directory location, we must reinitialize the user auth state
+      reinitialiseAuthTokens();
     }
   });
 

package/src/__tests__/https-options.test.ts

@@ -0,0 +1,127 @@
+import fs from "node:fs";
+import os from "node:os";
+import { resolve } from "node:path";
+import { getHttpsOptions } from "../https-options";
+import { mockConsoleMethods } from "./helpers/mock-console";
+import { runInTempDir } from "./helpers/run-in-tmp";
+
+describe("getHttpsOptions()", () => {
+  runInTempDir({ homedir: "./home" });
+  const std = mockConsoleMethods();
+
+  it("should use cached values if they have not expired", async () => {
+    fs.mkdirSync(resolve(os.homedir(), ".wrangler/local-cert"), {
+      recursive: true,
+    });
+    fs.writeFileSync(
+      resolve(os.homedir(), ".wrangler/local-cert/key.pem"),
+      "PRIVATE KEY"
+    );
+    fs.writeFileSync(
+      resolve(os.homedir(), ".wrangler/local-cert/cert.pem"),
+      "PUBLIC KEY"
+    );
+    const result = await getHttpsOptions();
+    expect(result.key).toEqual("PRIVATE KEY");
+    expect(result.cert).toEqual("PUBLIC KEY");
+    expect(std.out).toMatchInlineSnapshot(`""`);
+    expect(std.warn).toMatchInlineSnapshot(`""`);
+    expect(std.err).toMatchInlineSnapshot(`""`);
+  });
+
+  it("should generate and cache new keys if none are cached", async () => {
+    const result = await getHttpsOptions();
+    const key = fs.readFileSync(
+      resolve(os.homedir(), ".wrangler/local-cert/key.pem"),
+      "utf8"
+    );
+    const cert = fs.readFileSync(
+      resolve(os.homedir(), ".wrangler/local-cert/cert.pem"),
+      "utf8"
+    );
+    expect(result.key).toEqual(key);
+    expect(result.cert).toEqual(cert);
+    expect(std.out).toMatchInlineSnapshot(
+      `"Generating new self-signed certificate..."`
+    );
+    expect(std.warn).toMatchInlineSnapshot(`""`);
+    expect(std.err).toMatchInlineSnapshot(`""`);
+  });
+
+  it("should generate and cache new keys if cached files have expired", async () => {
+    fs.mkdirSync(resolve(os.homedir(), ".wrangler/local-cert"), {
+      recursive: true,
+    });
+    const ORIGINAL_KEY = "EXPIRED PRIVATE KEY";
+    const ORIGINAL_CERT = "EXPIRED PUBLIC KEY";
+    fs.writeFileSync(
+      resolve(os.homedir(), ".wrangler/local-cert/key.pem"),
+      ORIGINAL_KEY
+    );
+    fs.writeFileSync(
+      resolve(os.homedir(), ".wrangler/local-cert/cert.pem"),
+      ORIGINAL_CERT
+    );
+    mockStatSync(/\.pem$/, { mtimeMs: new Date(2000).valueOf() });
+
+    const result = await getHttpsOptions();
+    const key = fs.readFileSync(
+      resolve(os.homedir(), ".wrangler/local-cert/key.pem"),
+      "utf8"
+    );
+    const cert = fs.readFileSync(
+      resolve(os.homedir(), ".wrangler/local-cert/cert.pem"),
+      "utf8"
+    );
+    expect(key).not.toEqual(ORIGINAL_KEY);
+    expect(cert).not.toEqual(ORIGINAL_CERT);
+    expect(result.key).toEqual(key);
+    expect(result.cert).toEqual(cert);
+    expect(std.out).toMatchInlineSnapshot(
+      `"Generating new self-signed certificate..."`
+    );
+    expect(std.warn).toMatchInlineSnapshot(`""`);
+    expect(std.err).toMatchInlineSnapshot(`""`);
+  });
+
+  it("should warn if not able to write to the cache", async () => {
+    mockWriteFileSyncThrow(/\.pem$/);
+    await getHttpsOptions();
+    expect(
+      fs.existsSync(resolve(os.homedir(), ".wrangler/local-cert/key.pem"))
+    ).toBe(false);
+    expect(
+      fs.existsSync(resolve(os.homedir(), ".wrangler/local-cert/cert.pem"))
+    ).toBe(false);
+    expect(std.out).toMatchInlineSnapshot(
+      `"Generating new self-signed certificate..."`
+    );
+    expect(std.warn).toMatchInlineSnapshot(`
+      "Unable to cache generated self-signed certificate in home/.wrangler/local-cert.
+      ERROR: Cannot write file"
+    `);
+    expect(std.err).toMatchInlineSnapshot(`""`);
+  });
+});
+
+function mockStatSync(matcher: RegExp, stats: Partial<fs.Stats>) {
+  const originalStatSync = jest.requireActual("node:fs").statSync;
+  jest.spyOn(fs, "statSync").mockImplementation((statPath, options) => {
+    return matcher.test(statPath.toString())
+      ? (stats as fs.Stats)
+      : originalStatSync(statPath, options);
+  });
+}
+
+function mockWriteFileSyncThrow(matcher: RegExp) {
+  const originalWriteFileSync = jest.requireActual("node:fs").writeFileSync;
+  jest
+    .spyOn(fs, "writeFileSync")
+    .mockImplementation((filePath, data, options) => {
+      if (matcher.test(filePath.toString())) {
+        throw new Error("ERROR: Cannot write file");
+      } else {
+        return originalWriteFileSync(filePath, data, options);
+      }
+    });
+}