wrangler 0.0.0-e2a26a0 → 0.0.0-e2b7352

package/src/__tests__/index.test.ts

@@ -1,6 +1,7 @@
 import * as fs from "node:fs";
 import * as fsp from "node:fs/promises";
 import * as TOML from "@iarna/toml";
+import { parseConfigFileTextToJson } from "typescript";
 import { version as wranglerVersion } from "../../package.json";
 import { getPackageManager } from "../package-manager";
 import { mockConsoleMethods } from "./helpers/mock-console";
@@ -15,6 +16,9 @@ describe("wrangler", () => {
 
   beforeEach(() => {
     mockPackageManager = {
+      cwd: process.cwd(),
+      // @ts-expect-error we're making a fake package manager here
+      type: "mockpm",
       addDevDeps: jest.fn(),
       install: jest.fn(),
     };
@@ -33,22 +37,21 @@ describe("wrangler", () => {
         Commands:
           wrangler init [name]       📥 Create a wrangler.toml configuration file
           wrangler whoami            🕵️  Retrieve your user info and test your auth config
-          wrangler dev <filename>    👂 Start a local server for developing your worker
+          wrangler dev [script]      👂 Start a local server for developing your worker
           wrangler publish [script]  🆙 Publish your Worker to Cloudflare.
-          wrangler tail [name]       🦚 Starts a log tailing session for a deployed Worker.
+          wrangler tail [name]       🦚 Starts a log tailing session for a published Worker.
           wrangler secret            🤫 Generate a secret that can be referenced in the worker script
           wrangler kv:namespace      🗂️  Interact with your Workers KV Namespaces
           wrangler kv:key            🔑 Individually manage Workers KV key-value pairs
           wrangler kv:bulk           💪 Interact with multiple Workers KV key-value pairs at once
           wrangler pages             ⚡️ Configure Cloudflare Pages
+          wrangler r2                📦 Interact with an R2 store
 
         Flags:
-          -c, --config   Path to .toml configuration file  [string]
-          -h, --help     Show help  [boolean]
-          -v, --version  Show version number  [boolean]
-
-        Options:
-          -l, --local  Run on my machine  [boolean] [default: false]"
+          -c, --config      Path to .toml configuration file  [string]
+          -h, --help        Show help  [boolean]
+          -v, --version     Show version number  [boolean]
+              --legacy-env  Use legacy environments  [boolean]"
       `);
 
       expect(std.err).toMatchInlineSnapshot(`""`);
@@ -60,7 +63,7 @@ describe("wrangler", () => {
       await expect(
         runWrangler("invalid-command")
       ).rejects.toThrowErrorMatchingInlineSnapshot(
-        `"Unknown command: invalid-command."`
+        `"Unknown argument: invalid-command"`
       );
 
       expect(std.out).toMatchInlineSnapshot(`""`);
@@ -70,24 +73,23 @@ describe("wrangler", () => {
         Commands:
           wrangler init [name]       📥 Create a wrangler.toml configuration file
           wrangler whoami            🕵️  Retrieve your user info and test your auth config
-          wrangler dev <filename>    👂 Start a local server for developing your worker
+          wrangler dev [script]      👂 Start a local server for developing your worker
           wrangler publish [script]  🆙 Publish your Worker to Cloudflare.
-          wrangler tail [name]       🦚 Starts a log tailing session for a deployed Worker.
+          wrangler tail [name]       🦚 Starts a log tailing session for a published Worker.
           wrangler secret            🤫 Generate a secret that can be referenced in the worker script
           wrangler kv:namespace      🗂️  Interact with your Workers KV Namespaces
           wrangler kv:key            🔑 Individually manage Workers KV key-value pairs
           wrangler kv:bulk           💪 Interact with multiple Workers KV key-value pairs at once
           wrangler pages             ⚡️ Configure Cloudflare Pages
+          wrangler r2                📦 Interact with an R2 store
 
         Flags:
-          -c, --config   Path to .toml configuration file  [string]
-          -h, --help     Show help  [boolean]
-          -v, --version  Show version number  [boolean]
-
-        Options:
-          -l, --local  Run on my machine  [boolean] [default: false]
+          -c, --config      Path to .toml configuration file  [string]
+          -h, --help        Show help  [boolean]
+          -v, --version     Show version number  [boolean]
+              --legacy-env  Use legacy environments  [boolean]
 
-        Unknown command: invalid-command."
+        Unknown argument: invalid-command"
       `);
     });
   });
@@ -101,10 +103,26 @@ describe("wrangler", () => {
       await runWrangler("init");
       const parsed = TOML.parse(await fsp.readFile("./wrangler.toml", "utf-8"));
       expect(typeof parsed.compatibility_date).toBe("string");
+      expect(parsed.name).toContain("wrangler-tests");
       expect(fs.existsSync("./package.json")).toBe(false);
       expect(fs.existsSync("./tsconfig.json")).toBe(false);
     });
 
+    it("should create a wrangler.toml and a directory for a named Worker ", async () => {
+      mockConfirm({
+        text: "No package.json found. Would you like to create one?",
+        result: false,
+      });
+      await runWrangler("init my-worker");
+      const parsed = TOML.parse(
+        await fsp.readFile("./my-worker/wrangler.toml", "utf-8")
+      );
+      expect(typeof parsed.compatibility_date).toBe("string");
+      expect(parsed.name).toBe("my-worker");
+      expect(fs.existsSync("./my-worker/package.json")).toBe(false);
+      expect(fs.existsSync("./my-worker/tsconfig.json")).toBe(false);
+    });
+
     it("should display warning when wrangler.toml already exists, and exit if user does not want to carry on", async () => {
       fs.writeFileSync(
         "./wrangler.toml",
@@ -121,6 +139,37 @@ describe("wrangler", () => {
       expect(parsed.compatibility_date).toBe("something-else");
     });
 
+    it("should not overwrite an existing wrangler.toml, after agreeing to other prompts", async () => {
+      fs.writeFileSync(
+        "./wrangler.toml",
+        'compatibility_date="something-else"', // use a fake value to make sure the file is not overwritten
+        "utf-8"
+      );
+      mockConfirm(
+        {
+          text: "Do you want to continue initializing this project?",
+          result: true,
+        },
+        {
+          text: "No package.json found. Would you like to create one?",
+          result: true,
+        },
+        {
+          text: "Would you like to use TypeScript?",
+          result: true,
+        },
+        {
+          text: "Would you like to create a Worker at src/index.ts?",
+          result: true,
+        }
+      );
+
+      await runWrangler("init");
+      expect(fs.readFileSync("./wrangler.toml", "utf-8")).toMatchInlineSnapshot(
+        `"compatibility_date=\\"something-else\\""`
+      );
+    });
+
     it("should display warning when wrangler.toml already exists, but continue if user does want to carry on", async () => {
       fs.writeFileSync(
         "./wrangler.toml",
@@ -163,7 +212,7 @@ describe("wrangler", () => {
       const packageJson = JSON.parse(
         fs.readFileSync("./package.json", "utf-8")
       );
-      expect(packageJson.name).toEqual("worker"); // TODO: should we infer the name from the directory?
+      expect(packageJson.name).toContain("wrangler-tests");
       expect(packageJson.version).toEqual("0.0.0");
       expect(packageJson.devDependencies).toEqual({
         wrangler: expect.any(String),
@@ -172,6 +221,28 @@ describe("wrangler", () => {
       expect(mockPackageManager.install).toHaveBeenCalled();
     });
 
+    it("should create a package.json, with the specified name, if none is found and user confirms", async () => {
+      mockConfirm(
+        {
+          text: "No package.json found. Would you like to create one?",
+          result: true,
+        },
+        {
+          text: "Would you like to use TypeScript?",
+          result: false,
+        },
+        {
+          text: "Would you like to create a Worker at src/index.js?",
+          result: false,
+        }
+      );
+      await runWrangler("init my-worker");
+      const packageJson = JSON.parse(
+        fs.readFileSync("./my-worker/package.json", "utf-8")
+      );
+      expect(packageJson.name).toBe("my-worker");
+    });
+
     it("should not touch an existing package.json in the same directory", async () => {
       mockConfirm(
         {
@@ -329,6 +400,180 @@ describe("wrangler", () => {
       expect(fs.existsSync("./src/index.ts")).toBe(true);
     });
 
+    it("should add scripts for a typescript project with .ts extension", async () => {
+      mockConfirm(
+        {
+          text: "No package.json found. Would you like to create one?",
+          result: true,
+        },
+        {
+          text: "Would you like to install wrangler into your package.json?",
+          result: false,
+        },
+        {
+          text: "Would you like to use TypeScript?",
+          result: true,
+        },
+        {
+          text: "Would you like to create a Worker at src/index.ts?",
+          result: true,
+        }
+      );
+      await runWrangler("init");
+
+      expect(fs.existsSync("./package.json")).toBe(true);
+      const packageJson = JSON.parse(
+        fs.readFileSync("./package.json", "utf-8")
+      );
+
+      expect(fs.existsSync("./src/index.js")).toBe(false);
+      expect(fs.existsSync("./src/index.ts")).toBe(true);
+
+      expect(packageJson.scripts.start).toBe("wrangler dev");
+      expect(packageJson.scripts.publish).toBe("wrangler publish");
+      expect(packageJson.name).toContain("wrangler-tests");
+      expect(packageJson.version).toEqual("0.0.0");
+      expect(std.out).toMatchInlineSnapshot(`
+        "✨ Successfully created wrangler.toml
+        ✨ Created package.json
+        ✨ Created tsconfig.json, installed @cloudflare/workers-types into devDependencies
+        ✨ Created src/index.ts
+
+        To start developing your Worker, run \`npm start\`
+        To publish your Worker to the Internet, run \`npm run publish\`"
+      `);
+    });
+
+    it("should not overwrite package.json scripts for a typescript project", async () => {
+      mockConfirm(
+        {
+          text: "Would you like to install wrangler into your package.json?",
+          result: false,
+        },
+        {
+          text: "Would you like to use TypeScript?",
+          result: true,
+        },
+        {
+          text: "Would you like to create a Worker at src/index.ts?",
+          result: true,
+        }
+      );
+      await fsp.writeFile(
+        "./package.json",
+        JSON.stringify({
+          scripts: {
+            start: "test-start",
+            publish: "test-publish",
+          },
+        })
+      );
+      const packageJson = JSON.parse(
+        fs.readFileSync("./package.json", "utf-8")
+      );
+      await runWrangler("init");
+
+      expect(fs.existsSync("./src/index.js")).toBe(false);
+      expect(fs.existsSync("./src/index.ts")).toBe(true);
+
+      expect(packageJson.scripts.start).toBe("test-start");
+      expect(packageJson.scripts.publish).toBe("test-publish");
+      expect(std.out).toMatchInlineSnapshot(`
+        "✨ Successfully created wrangler.toml
+        ✨ Created tsconfig.json, installed @cloudflare/workers-types into devDependencies
+        ✨ Created src/index.ts
+
+        To start developing your Worker, run \`npx wrangler dev\`
+        To publish your Worker to the Internet, run \`npx wrangler publish\`"
+      `);
+    });
+
+    it("should add missing scripts for a non-ts project with .js extension", async () => {
+      mockConfirm(
+        {
+          text: "No package.json found. Would you like to create one?",
+          result: true,
+        },
+        {
+          text: "Would you like to install wrangler into your package.json?",
+          result: false,
+        },
+        {
+          text: "Would you like to use TypeScript?",
+          result: false,
+        },
+        {
+          text: "Would you like to create a Worker at src/index.js?",
+          result: true,
+        }
+      );
+      await runWrangler("init");
+
+      expect(fs.existsSync("./package.json")).toBe(true);
+      const packageJson = JSON.parse(
+        fs.readFileSync("./package.json", "utf-8")
+      );
+
+      expect(fs.existsSync("./src/index.js")).toBe(true);
+      expect(fs.existsSync("./src/index.ts")).toBe(false);
+
+      expect(packageJson.scripts.start).toBe("wrangler dev");
+      expect(packageJson.scripts.publish).toBe("wrangler publish");
+      expect(packageJson.name).toContain("wrangler-tests");
+      expect(packageJson.version).toEqual("0.0.0");
+      expect(std.out).toMatchInlineSnapshot(`
+        "✨ Successfully created wrangler.toml
+        ✨ Created package.json
+        ✨ Created src/index.js
+
+        To start developing your Worker, run \`npm start\`
+        To publish your Worker to the Internet, run \`npm run publish\`"
+      `);
+    });
+
+    it("should not overwrite package.json scripts for a non-ts project with .js extension", async () => {
+      mockConfirm(
+        {
+          text: "Would you like to install wrangler into your package.json?",
+          result: false,
+        },
+        {
+          text: "Would you like to use TypeScript?",
+          result: false,
+        },
+        {
+          text: "Would you like to create a Worker at src/index.js?",
+          result: true,
+        }
+      );
+      await fsp.writeFile(
+        "./package.json",
+        JSON.stringify({
+          scripts: {
+            start: "test-start",
+            publish: "test-publish",
+          },
+        })
+      );
+      const packageJson = JSON.parse(
+        fs.readFileSync("./package.json", "utf-8")
+      );
+      await runWrangler("init");
+
+      expect(fs.existsSync("./src/index.js")).toBe(true);
+      expect(fs.existsSync("./src/index.ts")).toBe(false);
+
+      expect(packageJson.scripts.start).toBe("test-start");
+      expect(packageJson.scripts.publish).toBe("test-publish");
+      expect(std.out).toMatchInlineSnapshot(`
+        "✨ Successfully created wrangler.toml
+        ✨ Created src/index.js
+
+        To start developing your Worker, run \`npx wrangler dev\`
+        To publish your Worker to the Internet, run \`npx wrangler publish\`"
+      `);
+    });
+
     it("should not offer to create a worker in a non-ts project if a file already exists at the location", async () => {
       mockConfirm(
         {
@@ -398,9 +643,12 @@ describe("wrangler", () => {
       );
       await runWrangler("init");
       expect(fs.existsSync("./tsconfig.json")).toBe(true);
-      const tsconfigJson = JSON.parse(
-        fs.readFileSync("./tsconfig.json", "utf-8")
-      );
+      const { config: tsconfigJson, error: tsConfigParseError } =
+        parseConfigFileTextToJson(
+          "./tsconfig.json",
+          fs.readFileSync("./tsconfig.json", "utf-8")
+        );
+      expect(tsConfigParseError).toBeUndefined();
       expect(tsconfigJson.compilerOptions.types).toEqual([
         "@cloudflare/workers-types",
       ]);
@@ -508,12 +756,60 @@ describe("wrangler", () => {
       expect(tsconfigJson.compilerOptions).toEqual({});
     });
 
-    it("should error if `--type` is used", async () => {
-      await expect(
-        runWrangler("init --type")
-      ).rejects.toThrowErrorMatchingInlineSnapshot(
-        `"The --type option is no longer supported."`
+    it("should initialize with no interactive prompts if `--yes` is used", async () => {
+      await runWrangler("init --yes");
+
+      expect(fs.existsSync("./src/index.js")).toBe(false);
+      expect(fs.existsSync("./src/index.ts")).toBe(true);
+      expect(fs.existsSync("./tsconfig.json")).toBe(true);
+      expect(fs.existsSync("./package.json")).toBe(true);
+      expect(fs.existsSync("./wrangler.toml")).toBe(true);
+      expect(std.out).toMatchInlineSnapshot(`
+        "✨ Successfully created wrangler.toml
+        ✨ Created package.json
+        ✨ Created tsconfig.json, installed @cloudflare/workers-types into devDependencies
+        ✨ Created src/index.ts
+
+        To start developing your Worker, run \`npm start\`
+        To publish your Worker to the Internet, run \`npm run publish\`"
+      `);
+      expect(std.err).toMatchInlineSnapshot(`""`);
+      expect(std.warn).toMatchInlineSnapshot(`""`);
+    });
+
+    it("should initialize with no interactive prompts if `--yes` is used (named worker)", async () => {
+      await runWrangler("init my-worker --yes");
+
+      expect(fs.existsSync("./my-worker/src/index.js")).toBe(false);
+      expect(fs.existsSync("./my-worker/src/index.ts")).toBe(true);
+      expect(fs.existsSync("./my-worker/tsconfig.json")).toBe(true);
+      expect(fs.existsSync("./my-worker/package.json")).toBe(true);
+      expect(fs.existsSync("./my-worker/wrangler.toml")).toBe(true);
+      const parsedWranglerToml = TOML.parse(
+        fs.readFileSync("./my-worker/wrangler.toml", "utf-8")
       );
+      expect(parsedWranglerToml.main).toEqual("src/index.ts");
+      expect(std.out).toMatchInlineSnapshot(`
+        "✨ Successfully created wrangler.toml
+        ✨ Created package.json
+        ✨ Created tsconfig.json, installed @cloudflare/workers-types into devDependencies
+        ✨ Created src/index.ts
+
+        To start developing your Worker, run \`cd my-worker && npm start\`
+        To publish your Worker to the Internet, run \`npm run publish\`"
+      `);
+      expect(std.err).toMatchInlineSnapshot(`""`);
+      expect(std.warn).toMatchInlineSnapshot(`""`);
+    });
+
+    it("should initialize with no interactive prompts if `-y` is used", async () => {
+      await runWrangler("init -y");
+
+      expect(fs.existsSync("./src/index.js")).toBe(false);
+      expect(fs.existsSync("./src/index.ts")).toBe(true);
+      expect(fs.existsSync("./tsconfig.json")).toBe(true);
+      expect(fs.existsSync("./package.json")).toBe(true);
+      expect(fs.existsSync("./wrangler.toml")).toBe(true);
     });
 
     it("should error if `--type javascript` is used", async () => {
@@ -540,4 +836,148 @@ describe("wrangler", () => {
             `);
     });
   });
+
+  describe("preview", () => {
+    it("should throw an error if the deprecated command is used with positional arguments", async () => {
+      await expect(runWrangler("preview GET")).rejects
+        .toThrowErrorMatchingInlineSnapshot(`
+              "DEPRECATION WARNING:
+              The \`wrangler preview\` command has been deprecated.
+              Try using \`wrangler dev\` to to try out a worker during development.
+              "
+            `);
+      await expect(runWrangler(`preview GET "SomeBody"`)).rejects
+        .toThrowErrorMatchingInlineSnapshot(`
+              "DEPRECATION WARNING:
+              The \`wrangler preview\` command has been deprecated.
+              Try using \`wrangler dev\` to to try out a worker during development.
+              "
+            `);
+    });
+  });
+
+  describe("subcommand implicit help ran on imcomplete command execution", () => {
+    function endEventLoop() {
+      return new Promise((resolve) => setImmediate(resolve));
+    }
+    it("no subcommand for 'secret' should display a list of available subcommands", async () => {
+      await runWrangler("secret");
+      await endEventLoop();
+      expect(std.out).toMatchInlineSnapshot(`
+        "wrangler secret
+
+        🤫 Generate a secret that can be referenced in the worker script
+
+        Commands:
+          wrangler secret put <key>     Create or update a secret variable for a script
+          wrangler secret delete <key>  Delete a secret variable from a script
+          wrangler secret list          List all secrets for a script
+
+        Flags:
+          -c, --config      Path to .toml configuration file  [string]
+          -h, --help        Show help  [boolean]
+          -v, --version     Show version number  [boolean]
+              --legacy-env  Use legacy environments  [boolean]"
+      `);
+    });
+
+    it("no subcommand 'kv:namespace' should display a list of available subcommands", async () => {
+      await runWrangler("kv:namespace");
+      await endEventLoop();
+      expect(std.out).toMatchInlineSnapshot(`
+         "wrangler kv:namespace
+
+         🗂️  Interact with your Workers KV Namespaces
+
+         Commands:
+           wrangler kv:namespace create <namespace>  Create a new namespace
+           wrangler kv:namespace list                Outputs a list of all KV namespaces associated with your account id.
+           wrangler kv:namespace delete              Deletes a given namespace.
+
+         Flags:
+           -c, --config      Path to .toml configuration file  [string]
+           -h, --help        Show help  [boolean]
+           -v, --version     Show version number  [boolean]
+               --legacy-env  Use legacy environments  [boolean]"
+      `);
+    });
+
+    it("no subcommand 'kv:key' should display a list of available subcommands", async () => {
+      await runWrangler("kv:key");
+      await endEventLoop();
+      expect(std.out).toMatchInlineSnapshot(`
+               "wrangler kv:key
+
+               🔑 Individually manage Workers KV key-value pairs
+
+               Commands:
+                 wrangler kv:key put <key> [value]  Writes a single key/value pair to the given namespace.
+                 wrangler kv:key list               Outputs a list of all keys in a given namespace.
+                 wrangler kv:key get <key>          Reads a single value by key from the given namespace.
+                 wrangler kv:key delete <key>       Removes a single key value pair from the given namespace.
+
+               Flags:
+                 -c, --config      Path to .toml configuration file  [string]
+                 -h, --help        Show help  [boolean]
+                 -v, --version     Show version number  [boolean]
+                     --legacy-env  Use legacy environments  [boolean]"
+            `);
+    });
+
+    it("no subcommand 'kv:bulk' should display a list of available subcommands", async () => {
+      await runWrangler("kv:bulk");
+      await endEventLoop();
+      expect(std.out).toMatchInlineSnapshot(`
+               "wrangler kv:bulk
+
+               💪 Interact with multiple Workers KV key-value pairs at once
+
+               Commands:
+                 wrangler kv:bulk put <filename>     Upload multiple key-value pairs to a namespace
+                 wrangler kv:bulk delete <filename>  Delete multiple key-value pairs from a namespace
+
+               Flags:
+                 -c, --config      Path to .toml configuration file  [string]
+                 -h, --help        Show help  [boolean]
+                 -v, --version     Show version number  [boolean]
+                     --legacy-env  Use legacy environments  [boolean]"
+            `);
+    });
+    it("no subcommand 'r2' should display a list of available subcommands", async () => {
+      await runWrangler("r2");
+      await endEventLoop();
+      expect(std.out).toMatchInlineSnapshot(`
+               "wrangler r2
+
+               📦 Interact with an R2 store
+
+               Commands:
+                 wrangler r2 bucket  Manage R2 buckets
+
+               Flags:
+                 -c, --config      Path to .toml configuration file  [string]
+                 -h, --help        Show help  [boolean]
+                 -v, --version     Show version number  [boolean]
+                     --legacy-env  Use legacy environments  [boolean]"
+            `);
+    });
+  });
+  describe("Deprecated commands", () => {
+    it("should print a deprecation message for 'generate'", async () => {
+      await runWrangler("generate").catch((err) => {
+        expect(err.message).toMatchInlineSnapshot(`
+          "DEPRECATION WARNING:
+          \`wrangler generate\` has been deprecated, please refer to https://github.com/cloudflare/wrangler2/blob/main/docs/deprecations.md#generate for alternatives"
+        `);
+      });
+    });
+    it("should print a deprecation message for 'build'", async () => {
+      await runWrangler("build").catch((err) => {
+        expect(err.message).toMatchInlineSnapshot(`
+          "DEPRECATION WARNING:
+          \`wrangler build\` has been deprecated, please refer to https://github.com/cloudflare/wrangler2/blob/main/docs/deprecations.md#build for alternatives"
+        `);
+      });
+    });
+  });
 });

package/src/__tests__/jest.setup.ts

@@ -1,7 +1,19 @@
 import fetchMock from "jest-fetch-mock";
-import { fetchInternal, fetchKVGetValue } from "../cfetch/internal";
+import {
+  fetchInternal,
+  fetchKVGetValue,
+  getCloudflareAPIBaseURL,
+} from "../cfetch/internal";
 import { confirm, prompt } from "../dialogs";
 import { mockFetchInternal, mockFetchKVGetValue } from "./helpers/mock-cfetch";
+import { MockWebSocket } from "./helpers/mock-web-socket";
+
+jest.mock("ws", () => {
+  return {
+    __esModule: true,
+    default: MockWebSocket,
+  };
+});
 
 jest.mock("undici", () => {
   return {
@@ -9,6 +21,11 @@ jest.mock("undici", () => {
     fetch: jest.requireActual("jest-fetch-mock"),
   };
 });
+
+// Outside of the Sentry tests themselves, we mock Sentry to ensure that it doesn't actually send any data and
+// that it doesn't interfere with the rest of the tests.
+jest.mock("../reporting");
+
 fetchMock.doMock(() => {
   // Any un-mocked fetches should throw
   throw new Error("Unexpected fetch request");
@@ -19,19 +36,34 @@ jest.mock("../package-manager");
 jest.mock("../cfetch/internal");
 (fetchInternal as jest.Mock).mockImplementation(mockFetchInternal);
 (fetchKVGetValue as jest.Mock).mockImplementation(mockFetchKVGetValue);
+(getCloudflareAPIBaseURL as jest.Mock).mockReturnValue(
+  "https://api.cloudflare.com/client/v4"
+);
 
 jest.mock("../dialogs");
 
 // By default (if not configured by mockConfirm()) calls to `confirm()` should throw.
-(confirm as jest.Mock).mockImplementation(() => {
+(confirm as jest.Mock).mockImplementation((text: string) => {
   throw new Error(
-    "Unexpected call to `confirm()`. You should use `mockConfirm()` to mock calls to `confirm()` with expectations. Search the codebase for `mockConfirm` to learn more."
+    `Unexpected call to \`confirm("${text}")\`.\nYou should use \`mockConfirm()\` to mock calls to \`confirm()\` with expectations. Search the codebase for \`mockConfirm\` to learn more.`
   );
 });
 
 // By default (if not configured by mockPrompt()) calls to `prompt()` should throw.
-(prompt as jest.Mock).mockImplementation(() => {
+(prompt as jest.Mock).mockImplementation((text: string) => {
   throw new Error(
-    "Unexpected call to `prompt()`. You should use `mockPrompt()` to mock calls to `prompt()` with expectations. Search the codebase for `mockPrompt` to learn more."
+    `Unexpected call to \`prompt(${text}, ...)\`.\nYou should use \`mockPrompt()\` to mock calls to \`prompt()\` with expectations. Search the codebase for \`mockPrompt\` to learn more.`
   );
 });
+
+jest.mock("../dev/dev", () => {
+  const { useApp } = jest.requireActual("ink");
+  const { useEffect } = jest.requireActual("react");
+  return jest.fn().mockImplementation(() => {
+    const { exit } = useApp();
+    useEffect(() => {
+      exit();
+    });
+    return null;
+  });
+});