wrangler 0.0.0-de73fa2 → 0.0.0-e151223

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

@@ -0,0 +1,29 @@
+import * as fs from "node:fs";
+import os from "node:os";
+import * as path from "node:path";
+
+const originalCwd = process.cwd();
+
+export function runInTempDir({ homedir }: { homedir?: string } = {}) {
+  let tmpDir: string;
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "wrangler-tests"));
+    process.chdir(tmpDir);
+    if (homedir !== undefined) {
+      // Override where the home directory is so that we can write our own user config,
+      // without destroying the real thing.
+      fs.mkdirSync(homedir);
+      // Note it is very important that we use the "default" value from "node:os" (e.g. `import os from "node:os";`)
+      // rather than an alias to the module (e.g. `import * as os from "node:os";`).
+      // 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);
+    }
+  });
+
+  afterEach(() => {
+    process.chdir(originalCwd);
+    fs.rmSync(tmpDir, { recursive: true });
+  });
+}

package/src/__tests__/helpers/run-wrangler.ts

@@ -0,0 +1,14 @@
+import { main } from "../../index";
+import { normalizeSlashes, stripTimings } from "./mock-console";
+
+/**
+ * A helper to 'run' wrangler commands for tests.
+ */
+export async function runWrangler(cmd?: string) {
+  try {
+    await main(cmd?.split(" ") ?? []);
+  } catch (e) {
+    e.message = normalizeSlashes(stripTimings(e.message));
+    throw e;
+  }
+}

package/src/__tests__/index.test.ts

@@ -1,22 +1,33 @@
+import * as fs from "node:fs";
 import * as fsp from "node:fs/promises";
 import * as TOML from "@iarna/toml";
-import { mockConfirm } from "./mock-dialogs";
-import { runWrangler } from "./run-wrangler";
-import { runInTempDir } from "./run-in-tmp";
-import * as fs from "node:fs";
+import { version as wranglerVersion } from "../../package.json";
+import { npm } from "../npm-installer";
+import { mockConsoleMethods } from "./helpers/mock-console";
+import { mockConfirm } from "./helpers/mock-dialogs";
+import { runInTempDir } from "./helpers/run-in-tmp";
+import { runWrangler } from "./helpers/run-wrangler";
 
 describe("wrangler", () => {
   runInTempDir();
 
+  beforeEach(() => {
+    jest.spyOn(npm, "addDevDeps").mockResolvedValue();
+    jest.spyOn(npm, "install").mockResolvedValue();
+  });
+
+  const std = mockConsoleMethods();
+
   describe("no command", () => {
     it("should display a list of available commands", async () => {
-      const { stdout, stderr } = await runWrangler();
+      await runWrangler();
 
-      expect(stdout).toMatchInlineSnapshot(`
+      expect(std.out).toMatchInlineSnapshot(`
         "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 publish [script]  🆙 Publish your Worker to Cloudflare.
           wrangler tail [name]       🦚 Starts a log tailing session for a deployed Worker.
@@ -35,20 +46,25 @@ describe("wrangler", () => {
           -l, --local  Run on my machine  [boolean] [default: false]"
       `);
 
-      expect(stderr).toMatchInlineSnapshot(`""`);
+      expect(std.err).toMatchInlineSnapshot(`""`);
     });
   });
 
   describe("invalid command", () => {
     it("should display an error", async () => {
-      const { error, stdout, stderr } = await runWrangler("invalid-command");
+      await expect(
+        runWrangler("invalid-command")
+      ).rejects.toThrowErrorMatchingInlineSnapshot(
+        `"Unknown command: invalid-command."`
+      );
 
-      expect(stdout).toMatchInlineSnapshot(`""`);
-      expect(stderr).toMatchInlineSnapshot(`
+      expect(std.out).toMatchInlineSnapshot(`""`);
+      expect(std.err).toMatchInlineSnapshot(`
         "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 publish [script]  🆙 Publish your Worker to Cloudflare.
           wrangler tail [name]       🦚 Starts a log tailing session for a deployed Worker.
@@ -68,9 +84,6 @@ describe("wrangler", () => {
 
         Unknown command: invalid-command."
       `);
-      expect(error).toMatchInlineSnapshot(
-        `[Error: Unknown command: invalid-command.]`
-      );
     });
   });
 
@@ -88,19 +101,27 @@ describe("wrangler", () => {
     });
 
     it("should display warning when wrangler.toml already exists, and exit if user does not want to carry on", async () => {
-      fs.writeFileSync("./wrangler.toml", "", "utf-8");
+      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: false,
       });
-      const { warnings } = await runWrangler("init");
-      expect(warnings).toContain("wrangler.toml file already exists!");
+      await runWrangler("init");
+      expect(std.warn).toContain("wrangler.toml file already exists!");
       const parsed = TOML.parse(await fsp.readFile("./wrangler.toml", "utf-8"));
-      expect(typeof parsed.compatibility_date).toBe("undefined");
+      expect(parsed.compatibility_date).toBe("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", "", "utf-8");
+      fs.writeFileSync(
+        "./wrangler.toml",
+        `compatibility_date="something-else"`,
+        "utf-8"
+      );
       mockConfirm(
         {
           text: "Do you want to continue initializing this project?",
@@ -111,10 +132,10 @@ describe("wrangler", () => {
           result: false,
         }
       );
-      const { warnings } = await runWrangler("init");
-      expect(warnings).toContain("wrangler.toml file already exists!");
+      await runWrangler("init");
+      expect(std.warn).toContain("wrangler.toml file already exists!");
       const parsed = TOML.parse(await fsp.readFile("./wrangler.toml", "utf-8"));
-      expect(typeof parsed.compatibility_date).toBe("string");
+      expect(parsed.compatibility_date).toBe("something-else");
     });
 
     it("should create a package.json if none is found and user confirms", async () => {
@@ -134,15 +155,25 @@ describe("wrangler", () => {
         fs.readFileSync("./package.json", "utf-8")
       );
       expect(packageJson.name).toEqual("worker"); // TODO: should we infer the name from the directory?
-      expect(packageJson.version).toEqual("0.0.1");
+      expect(packageJson.version).toEqual("0.0.0");
+      expect(packageJson.devDependencies).toEqual({
+        wrangler: expect.any(String),
+      });
       expect(fs.existsSync("./tsconfig.json")).toBe(false);
+      expect(npm.install).toHaveBeenCalled();
     });
 
     it("should not touch an existing package.json in the same directory", async () => {
-      mockConfirm({
-        text: "Would you like to use typescript?",
-        result: false,
-      });
+      mockConfirm(
+        {
+          text: "Would you like to install wrangler into your package.json?",
+          result: false,
+        },
+        {
+          text: "Would you like to use typescript?",
+          result: false,
+        }
+      );
 
       fs.writeFileSync(
         "./package.json",
@@ -158,11 +189,46 @@ describe("wrangler", () => {
       expect(packageJson.version).toEqual("1.0.0");
     });
 
+    it("should offer to install wrangler into an existing package.json", async () => {
+      mockConfirm(
+        {
+          text: "Would you like to install wrangler into your package.json?",
+          result: true,
+        },
+        {
+          text: "Would you like to use typescript?",
+          result: false,
+        }
+      );
+
+      fs.writeFileSync(
+        "./package.json",
+        JSON.stringify({ name: "test", version: "1.0.0" }),
+        "utf-8"
+      );
+
+      await runWrangler("init");
+      const packageJson = JSON.parse(
+        fs.readFileSync("./package.json", "utf-8")
+      );
+      expect(packageJson.name).toEqual("test");
+      expect(packageJson.version).toEqual("1.0.0");
+      expect(npm.addDevDeps).toHaveBeenCalledWith(
+        `wrangler@${wranglerVersion}`
+      );
+    });
+
     it("should not touch an existing package.json in an ancestor directory", async () => {
-      mockConfirm({
-        text: "Would you like to use typescript?",
-        result: false,
-      });
+      mockConfirm(
+        {
+          text: "Would you like to install wrangler into your package.json?",
+          result: false,
+        },
+        {
+          text: "Would you like to use typescript?",
+          result: false,
+        }
+      );
 
       fs.writeFileSync(
         "./package.json",
@@ -180,8 +246,12 @@ describe("wrangler", () => {
       const packageJson = JSON.parse(
         fs.readFileSync("../../package.json", "utf-8")
       );
-      expect(packageJson.name).toEqual("test");
-      expect(packageJson.version).toEqual("1.0.0");
+      expect(packageJson).toMatchInlineSnapshot(`
+        Object {
+          "name": "test",
+          "version": "1.0.0",
+        }
+      `);
     });
 
     it("should create a tsconfig.json and install `workers-types` if none is found and user confirms", async () => {
@@ -203,18 +273,23 @@ describe("wrangler", () => {
       expect(tsconfigJson.compilerOptions.types).toEqual([
         "@cloudflare/workers-types",
       ]);
-      const packageJson = JSON.parse(
-        fs.readFileSync("./package.json", "utf-8")
+      expect(npm.addDevDeps).toHaveBeenCalledWith(
+        "@cloudflare/workers-types",
+        "typescript"
       );
-      expect(packageJson.devDependencies).toEqual({
-        "@cloudflare/workers-types": expect.any(String),
-      });
     });
 
     it("should not touch an existing tsconfig.json in the same directory", async () => {
       fs.writeFileSync(
         "./package.json",
-        JSON.stringify({ name: "test", version: "1.0.0" }),
+        JSON.stringify({
+          name: "test",
+          version: "1.0.0",
+          devDependencies: {
+            wrangler: "0.0.0",
+            "@cloudflare/workers-types": "0.0.0",
+          },
+        }),
         "utf-8"
       );
       fs.writeFileSync(
@@ -230,10 +305,51 @@ describe("wrangler", () => {
       expect(tsconfigJson.compilerOptions).toEqual({});
     });
 
-    it("should not touch an existing package.json in an ancestor directory", async () => {
+    it("should offer to install type definitions in an existing typescript project", async () => {
+      mockConfirm(
+        {
+          text: "Would you like to install wrangler into your package.json?",
+          result: false,
+        },
+        {
+          text: "Would you like to install the type definitions for Workers into your package.json?",
+          result: true,
+        }
+      );
       fs.writeFileSync(
         "./package.json",
-        JSON.stringify({ name: "test", version: "1.0.0" }),
+        JSON.stringify({
+          name: "test",
+          version: "1.0.0",
+        }),
+        "utf-8"
+      );
+      fs.writeFileSync(
+        "./tsconfig.json",
+        JSON.stringify({ compilerOptions: {} }),
+        "utf-8"
+      );
+
+      await runWrangler("init");
+      const tsconfigJson = JSON.parse(
+        fs.readFileSync("./tsconfig.json", "utf-8")
+      );
+      // unchanged tsconfig
+      expect(tsconfigJson.compilerOptions).toEqual({});
+      expect(npm.addDevDeps).toHaveBeenCalledWith("@cloudflare/workers-types");
+    });
+
+    it("should not touch an existing tsconfig.json in an ancestor directory", async () => {
+      fs.writeFileSync(
+        "./package.json",
+        JSON.stringify({
+          name: "test",
+          version: "1.0.0",
+          devDependencies: {
+            wrangler: "0.0.0",
+            "@cloudflare/workers-types": "0.0.0",
+          },
+        }),
         "utf-8"
       );
       fs.writeFileSync(
@@ -256,32 +372,35 @@ describe("wrangler", () => {
     });
 
     it("should error if `--type` is used", async () => {
-      const { error } = await runWrangler("init --type");
-      expect(error).toMatchInlineSnapshot(
-        `[Error: The --type option is no longer supported.]`
+      await expect(
+        runWrangler("init --type")
+      ).rejects.toThrowErrorMatchingInlineSnapshot(
+        `"The --type option is no longer supported."`
       );
     });
 
     it("should error if `--type javascript` is used", async () => {
-      const { error } = await runWrangler("init --type javascript");
-      expect(error).toMatchInlineSnapshot(
-        `[Error: The --type option is no longer supported.]`
+      await expect(
+        runWrangler("init --type javascript")
+      ).rejects.toThrowErrorMatchingInlineSnapshot(
+        `"The --type option is no longer supported."`
       );
     });
 
     it("should error if `--type rust` is used", async () => {
-      const { error } = await runWrangler("init --type rust");
-      expect(error).toMatchInlineSnapshot(
-        `[Error: The --type option is no longer supported.]`
+      await expect(
+        runWrangler("init --type rust")
+      ).rejects.toThrowErrorMatchingInlineSnapshot(
+        `"The --type option is no longer supported."`
       );
     });
 
     it("should error if `--type webpack` is used", async () => {
-      const { error } = await runWrangler("init --type webpack");
-      expect(error).toMatchInlineSnapshot(`
-        [Error: The --type option is no longer supported.
-        If you wish to use webpack then you will need to create a custom build.]
-      `);
+      await expect(runWrangler("init --type webpack")).rejects
+        .toThrowErrorMatchingInlineSnapshot(`
+              "The --type option is no longer supported.
+              If you wish to use webpack then you will need to create a custom build."
+            `);
     });
   });
 });

package/src/__tests__/jest.setup.ts

@@ -1,6 +1,18 @@
-import { mockFetchInternal } from "./mock-cfetch";
-import { confirm, prompt } from "../dialogs";
+import fetchMock from "jest-fetch-mock";
 import { fetchInternal } from "../cfetch/internal";
+import { confirm, prompt } from "../dialogs";
+import { mockFetchInternal } from "./helpers/mock-cfetch";
+
+jest.mock("undici", () => {
+  return {
+    ...jest.requireActual("undici"),
+    fetch: jest.requireActual("jest-fetch-mock"),
+  };
+});
+fetchMock.doMock(() => {
+  // Any un-mocked fetches should throw
+  throw new Error("Unexpected fetch request");
+});
 
 jest.mock("../cfetch/internal");
 (fetchInternal as jest.Mock).mockImplementation(mockFetchInternal);