Further wrangler init tests (and refactorings)

.changeset/forty-cooks-flash.md

@@ -0,0 +1,11 @@
+---
+"wrangler": patch
+---
+
+Error and exit if the `--type` option is used for the `init` command.
+
+The `--type` option is no longer needed, nor supported.
+
+The type of a project is implicitly javascript, even if it includes a wasm (e.g. built from rust).
+
+Projects that would have had the `webpack` type need to be configured separately to have a custom build.

.changeset/short-humans-repeat.md

@@ -0,0 +1,5 @@
+---
+"wrangler": patch
+---
+
+Allow the developer to exit `init` if there is already a toml file

packages/wrangler/package.json

@@ -96,6 +96,7 @@
     "node": ">=16.7.0"
   },
   "jest": {
+    "restoreMocks": true,
     "testRegex": ".*.(test|spec)\\.[jt]sx?$",
     "transformIgnorePatterns": [
       "node_modules/(?!node-fetch|fetch-blob|find-up|locate-path|p-locate|p-limit|yocto-queue|path-exists|data-uri-to-buffer|formdata-polyfill|execa|strip-final-newline|npm-run-path|path-key|onetime|mimic-fn|human-signals|is-stream)"

packages/wrangler/src/__tests__/index.test.ts

@@ -4,46 +4,33 @@ import * as path from "node:path";
 import * as TOML from "@iarna/toml";
 import { main } from "../index";
 import { setMock, unsetAllMocks } from "./mock-cfetch";
+import { existsSync } from "node:fs";
+import { dialogs } from "../dialogs";
 
 jest.mock("../cfetch", () => jest.requireActual("./mock-cfetch"));
 
-async function w(cmd: void | string, options?: { tap: boolean }) {
-  const tapped = options?.tap ? tap() : undefined;
-  await main([...(cmd ? cmd.split(" ") : [])]);
-  tapped?.off();
-  return { stdout: tapped?.out, stderr: tapped?.err };
-}
-
-function tap() {
-  const oldLog = console.log;
-  const oldError = console.error;
-
-  const toReturn = {
-    off: () => {
-      console.log = oldLog;
-      console.error = oldError;
-    },
-    out: "",
-    err: "",
-  };
-
-  console.log = (...args) => {
-    toReturn.out += args.join("");
-    oldLog.apply(console, args);
-    // console.trace(...args); // use this if you want to find the true source of your console.log
-  };
-  console.error = (...args) => {
-    toReturn.err += args.join("");
-    oldError.apply(console, args);
-  };
-
-  return toReturn;
+async function w(cmd?: string) {
+  const logSpy = jest.spyOn(console, "log").mockImplementation();
+  const errorSpy = jest.spyOn(console, "error").mockImplementation();
+  const warnSpy = jest.spyOn(console, "warn").mockImplementation();
+  try {
+    await main(cmd?.split(" ") ?? []);
+    return {
+      stdout: logSpy.mock.calls.flat(2).join("\n"),
+      stderr: errorSpy.mock.calls.flat(2).join("\n"),
+      warnings: warnSpy.mock.calls.flat(2).join("\n"),
+    };
+  } finally {
+    logSpy.mockRestore();
+    errorSpy.mockRestore();
+    warnSpy.mockRestore();
+  }
 }
 
 describe("wrangler", () => {
   describe("no command", () => {
     it("should display a list of available commands", async () => {
-      const { stdout, stderr } = await w(undefined, { tap: true });
+      const { stdout, stderr } = await w();
 
       expect(stdout).toMatchInlineSnapshot(`
         "wrangler
@@ -68,13 +55,13 @@ describe("wrangler", () => {
           -l, --local  Run on my machine  [boolean] [default: false]"
       `);
 
-      expect(stderr).toEqual("");
+      expect(stderr).toMatchInlineSnapshot(`""`);
     });
   });
 
   describe("invalid command", () => {
     it("should display an error", async () => {
-      const { stdout, stderr } = await w("invalid-command", { tap: true });
+      const { stdout, stderr } = await w("invalid-command");
 
       expect(stdout).toMatchInlineSnapshot(`
         "wrangler
@@ -114,7 +101,9 @@ describe("wrangler", () => {
     });
 
     afterEach(async () => {
-      await fsp.rm("./wrangler.toml");
+      if (existsSync("./wrangler.toml")) {
+        await fsp.rm("./wrangler.toml");
+      }
       process.chdir(ogcwd);
     });
 
@@ -124,10 +113,57 @@ describe("wrangler", () => {
       expect(typeof parsed.compatibility_date).toBe("string");
     });
 
-    it("should error when wrangler.toml already exists", async () => {
+    it("should display warning when wrangler.toml already exists, and exit if user does not want to carry on", async () => {
       fs.closeSync(fs.openSync("./wrangler.toml", "w"));
-      const { stderr } = await w("init", { tap: true });
-      expect(stderr.endsWith("wrangler.toml already exists.")).toBe(true);
+      mockConfirm({
+        text: "Do you want to continue initializing this project?",
+        result: false,
+      });
+      const { stderr } = await w("init");
+      expect(stderr).toContain("wrangler.toml file already exists!");
+      const parsed = TOML.parse(await fsp.readFile("./wrangler.toml", "utf-8"));
+      expect(typeof parsed.compatibility_date).toBe("undefined");
+    });
+
+    it("should display warning when wrangler.toml already exists, but continue if user does want to carry on", async () => {
+      fs.closeSync(fs.openSync("./wrangler.toml", "w"));
+      mockConfirm({
+        text: "Do you want to continue initializing this project?",
+        result: true,
+      });
+      const { stderr } = await w("init");
+      expect(stderr).toContain("wrangler.toml file already exists!");
+      const parsed = TOML.parse(await fsp.readFile("./wrangler.toml", "utf-8"));
+      expect(typeof parsed.compatibility_date).toBe("string");
+    });
+
+    it("should error if `--type` is used", async () => {
+      const noValue = await w("init --type");
+      expect(noValue.stderr).toMatchInlineSnapshot(
+        `"The --type option is no longer supported."`
+      );
+    });
+
+    it("should error if `--type javascript` is used", async () => {
+      const javascriptValue = await w("init --type javascript");
+      expect(javascriptValue.stderr).toMatchInlineSnapshot(
+        `"The --type option is no longer supported."`
+      );
+    });
+
+    it("should error if `--type rust` is used", async () => {
+      const rustValue = await w("init --type rust");
+      expect(rustValue.stderr).toMatchInlineSnapshot(
+        `"The --type option is no longer supported."`
+      );
+    });
+
+    it("should error if `--type webpack` is used", async () => {
+      const webpackValue = await w("init --type webpack");
+      expect(webpackValue.stderr).toMatchInlineSnapshot(`
+        "The --type option is no longer supported.
+        If you wish to use webpack then you will need to create a custom build."
+      `);
     });
   });
 
@@ -160,7 +196,7 @@ describe("wrangler", () => {
           return KVNamespaces;
         }
       );
-      const { stdout } = await w("kv:namespace list", { tap: true });
+      const { stdout } = await w("kv:namespace list");
       const namespaces = JSON.parse(stdout);
       createdNamespace = namespaces.find(
         (ns) => ns.title === "worker-UnitTestNamespace"
@@ -186,3 +222,22 @@ describe("wrangler", () => {
     });
   });
 });
+
+/**
+ * Create a mock version of `confirm()` that will respond with configured results
+ * for configured confirmation text messages.
+ *
+ * If there is a call to `confirm()` that does not match any of the expectations
+ * then an error is thrown.
+ */
+function mockConfirm(...expectations: { text: string; result: boolean }[]) {
+  const mockImplementation = async (text: string) => {
+    for (const { text: expectedText, result } of expectations) {
+      if (text === expectedText) {
+        return result;
+      }
+    }
+    throw new Error(`Unexpected confirmation message: ${text}`);
+  };
+  return jest.spyOn(dialogs, "confirm").mockImplementation(mockImplementation);
+}

packages/wrangler/src/dialogs.tsx

@@ -23,7 +23,7 @@ function Confirm(props: ConfirmProps) {
   );
 }
 
-export function confirm(text: string): Promise<boolean> {
+function confirm(text: string): Promise<boolean> {
   return new Promise((resolve) => {
     const { unmount } = render(
       <Confirm
@@ -61,7 +61,7 @@ function Prompt(props: PromptProps) {
   );
 }
 
-export async function prompt(text: string, type: "text" | "password" = "text") {
+async function prompt(text: string, type: "text" | "password" = "text") {
   return new Promise((resolve) => {
     const { unmount } = render(
       <Prompt
@@ -83,3 +83,9 @@ export async function prompt(text: string, type: "text" | "password" = "text") {
 // ): Promise<{ label: string; value: string }>{
 
 // }
+
+// Export as an object so that it is easier to mock for testing
+export const dialogs = {
+  confirm,
+  prompt,
+};

packages/wrangler/src/index.tsx

@@ -8,7 +8,7 @@ import type yargs from "yargs";
 import { findUp } from "find-up";
 import TOML from "@iarna/toml";
 import type { Config } from "./config";
-import { confirm, prompt } from "./dialogs";
+import { dialogs } from "./dialogs";
 import { version as wranglerVersion } from "../package.json";
 import {
   login,
@@ -187,32 +187,51 @@ export async function main(argv: string[]): Promise<void> {
         type: "string",
       });
     },
-    async () => {
+    async (args) => {
+      if ("type" in args) {
+        let message = "The --type option is no longer supported.";
+        if (args.type === "webpack") {
+          message +=
+            "\nIf you wish to use webpack then you will need to create a custom build.";
+          // TODO: Add a link to docs
+        }
+        console.error(message);
+        return;
+      }
+
       const destination = path.join(process.cwd(), "wrangler.toml");
       if (fs.existsSync(destination)) {
-        console.error(`${destination} already exists.`);
-      } else {
-        const compatibilityDate = new Date().toISOString().substring(0, 10);
-        try {
-          await writeFile(
-            destination,
-            `compatibility_date = "${compatibilityDate}"` + "\n"
-          );
-          console.log(`✨ Succesfully created wrangler.toml`);
-          // TODO: suggest next steps?
-        } catch (err) {
-          console.error(`Failed to create wrangler.toml`);
-          console.error(err);
-          throw err;
+        console.error(`${destination} file already exists!`);
+        const result = await dialogs.confirm(
+          "Do you want to continue initializing this project?"
+        );
+        if (!result) {
+          return;
         }
       }
 
+      const compatibilityDate = new Date().toISOString().substring(0, 10);
+      try {
+        await writeFile(
+          destination,
+          `compatibility_date = "${compatibilityDate}"` + "\n"
+        );
+        console.log(`✨ Succesfully created wrangler.toml`);
+        // TODO: suggest next steps?
+      } catch (err) {
+        console.error(`Failed to create wrangler.toml`);
+        console.error(err);
+        throw err;
+      }
+
       // if no package.json, ask, and if yes, create one
       let pathToPackageJson = await findUp("package.json");
 
       if (!pathToPackageJson) {
         if (
-          await confirm("No package.json found. Would you like to create one?")
+          await dialogs.confirm(
+            "No package.json found. Would you like to create one?"
+          )
         ) {
           await writeFile(
             path.join(process.cwd(), "package.json"),
@@ -237,7 +256,7 @@ export async function main(argv: string[]): Promise<void> {
       // and make a tsconfig?
       let pathToTSConfig = await findUp("tsconfig.json");
       if (!pathToTSConfig) {
-        if (await confirm("Would you like to use typescript?")) {
+        if (await dialogs.confirm("Would you like to use typescript?")) {
           await writeFile(
             path.join(process.cwd(), "tsconfig.json"),
             JSON.stringify(
@@ -896,7 +915,7 @@ export async function main(argv: string[]): Promise<void> {
 
             // -- snip, end --
 
-            const secretValue = await prompt(
+            const secretValue = await dialogs.prompt(
               "Enter a secret value:",
               "password"
             );
@@ -996,7 +1015,11 @@ export async function main(argv: string[]): Promise<void> {
 
             // -- snip, end --
 
-            if (await confirm("Are you sure you want to delete this secret?")) {
+            if (
+              await dialogs.confirm(
+                "Are you sure you want to delete this secret?"
+              )
+            ) {
               console.log(
                 `Deleting the secret ${args.key} on script ${scriptName}.`
               );