wrangler 0.0.13 → 0.0.17

package/src/__tests__/index.test.ts

@@ -1,14 +1,26 @@
+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 { mockConsoleMethods } from "./mock-console";
-import * as fs from "node:fs";
+import { version as wranglerVersion } from "../../package.json";
+import { getPackageManager } from "../package-manager";
+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";
+import type { PackageManager } from "../package-manager";
 
 describe("wrangler", () => {
+  let mockPackageManager: PackageManager;
   runInTempDir();
 
+  beforeEach(() => {
+    mockPackageManager = {
+      addDevDeps: jest.fn(),
+      install: jest.fn(),
+    };
+    (getPackageManager as jest.Mock).mockResolvedValue(mockPackageManager);
+  });
+
   const std = mockConsoleMethods();
 
   describe("no command", () => {
@@ -21,7 +33,7 @@ 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 secret            🤫 Generate a secret that can be referenced in the worker script
@@ -29,6 +41,7 @@ describe("wrangler", () => {
           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]
@@ -45,14 +58,11 @@ describe("wrangler", () => {
 
   describe("invalid command", () => {
     it("should display an error", async () => {
-      let err: Error | undefined;
-      try {
-        await runWrangler("invalid-command");
-      } catch (e) {
-        err = e;
-      } finally {
-        expect(err?.message).toBe(`Unknown command: invalid-command.`);
-      }
+      await expect(
+        runWrangler("invalid-command")
+      ).rejects.toThrowErrorMatchingInlineSnapshot(
+        `"Unknown command: invalid-command."`
+      );
 
       expect(std.out).toMatchInlineSnapshot(`""`);
       expect(std.err).toMatchInlineSnapshot(`
@@ -61,7 +71,7 @@ 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 secret            🤫 Generate a secret that can be referenced in the worker script
@@ -69,6 +79,7 @@ describe("wrangler", () => {
           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]
@@ -92,6 +103,20 @@ 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 named Worker wrangler.toml", 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("./wrangler.toml", "utf-8"));
+      expect(typeof parsed.compatibility_date).toBe("string");
+      expect(parsed.name).toBe("my-worker");
       expect(fs.existsSync("./package.json")).toBe(false);
       expect(fs.existsSync("./tsconfig.json")).toBe(false);
     });
@@ -141,7 +166,11 @@ describe("wrangler", () => {
           result: true,
         },
         {
-          text: "Would you like to use typescript?",
+          text: "Would you like to use TypeScript?",
+          result: false,
+        },
+        {
+          text: "Would you like to create a Worker at src/index.js?",
           result: false,
         }
       );
@@ -150,12 +179,35 @@ 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.version).toEqual("0.0.1");
+      expect(packageJson.name).toContain("wrangler-tests");
+      expect(packageJson.version).toEqual("0.0.0");
       expect(packageJson.devDependencies).toEqual({
         wrangler: expect.any(String),
       });
       expect(fs.existsSync("./tsconfig.json")).toBe(false);
+      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("./package.json", "utf-8")
+      );
+      expect(packageJson.name).toBe("my-worker");
     });
 
     it("should not touch an existing package.json in the same directory", async () => {
@@ -165,7 +217,11 @@ describe("wrangler", () => {
           result: false,
         },
         {
-          text: "Would you like to use typescript?",
+          text: "Would you like to use TypeScript?",
+          result: false,
+        },
+        {
+          text: "Would you like to create a Worker at src/index.js?",
           result: false,
         }
       );
@@ -191,7 +247,11 @@ describe("wrangler", () => {
           result: true,
         },
         {
-          text: "Would you like to use typescript?",
+          text: "Would you like to use TypeScript?",
+          result: false,
+        },
+        {
+          text: "Would you like to create a Worker at src/index.js?",
           result: false,
         }
       );
@@ -208,9 +268,9 @@ describe("wrangler", () => {
       );
       expect(packageJson.name).toEqual("test");
       expect(packageJson.version).toEqual("1.0.0");
-      expect(packageJson.devDependencies).toEqual({
-        wrangler: expect.any(String),
-      });
+      expect(mockPackageManager.addDevDeps).toHaveBeenCalledWith(
+        `wrangler@${wranglerVersion}`
+      );
     });
 
     it("should not touch an existing package.json in an ancestor directory", async () => {
@@ -220,7 +280,11 @@ describe("wrangler", () => {
           result: false,
         },
         {
-          text: "Would you like to use typescript?",
+          text: "Would you like to use TypeScript?",
+          result: false,
+        },
+        {
+          text: "Would you like to create a Worker at src/index.js?",
           result: false,
         }
       );
@@ -249,6 +313,282 @@ describe("wrangler", () => {
       `);
     });
 
+    it("should offer to create a worker in a non-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: false,
+        },
+        {
+          text: "Would you like to create a Worker at src/index.js?",
+          result: true,
+        }
+      );
+
+      fs.writeFileSync(
+        "./package.json",
+        JSON.stringify({ name: "test", version: "1.0.0" }),
+        "utf-8"
+      );
+
+      await runWrangler("init");
+      expect(fs.existsSync("./src/index.js")).toBe(true);
+      expect(fs.existsSync("./src/index.ts")).toBe(false);
+    });
+
+    it("should offer to create a worker in 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,
+        }
+      );
+
+      fs.writeFileSync(
+        "./package.json",
+        JSON.stringify({ name: "test", version: "1.0.0" }),
+        "utf-8"
+      );
+
+      await runWrangler("init");
+      expect(fs.existsSync("./src/index.js")).toBe(false);
+      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 src/index.ts");
+      expect(packageJson.scripts.deploy).toBe("wrangler publish src/index.ts");
+      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
+              To start developing on your worker, run npm start.
+              To publish your worker on to the internet, run npm run deploy.
+              ✨ Created src/index.ts"
+            `);
+    });
+
+    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",
+            deploy: "test-deploy",
+          },
+        })
+      );
+      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.deploy).toBe("test-deploy");
+      expect(std.out).toMatchInlineSnapshot(`
+              "✨ Successfully created wrangler.toml
+              ✨ Created tsconfig.json, installed @cloudflare/workers-types into devDependencies
+              To start developing on your worker, npx wrangler dev src/index.ts
+              To publish your worker on to the internet, npx wrangler publish src/index.ts
+              ✨ Created src/index.ts"
+            `);
+    });
+
+    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 src/index.js");
+      expect(packageJson.scripts.deploy).toBe("wrangler publish src/index.js");
+      expect(packageJson.name).toContain("wrangler-tests");
+      expect(packageJson.version).toEqual("0.0.0");
+      expect(std.out).toMatchInlineSnapshot(`
+              "✨ Successfully created wrangler.toml
+              ✨ Created package.json
+              To start developing on your worker, run npm start.
+              To publish your worker on to the internet, run npm run deploy.
+              ✨ Created src/index.js"
+            `);
+    });
+
+    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",
+            deploy: "test-deploy",
+          },
+        })
+      );
+      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.deploy).toBe("test-deploy");
+      expect(std.out).toMatchInlineSnapshot(`
+              "✨ Successfully created wrangler.toml
+              To start developing on your worker, npx wrangler dev src/index.js
+              To publish your worker on to the internet, npx wrangler publish src/index.js
+              ✨ Created src/index.js"
+            `);
+    });
+
+    it("should not offer to create a worker in a non-ts project if a file already exists at the location", async () => {
+      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",
+        JSON.stringify({ name: "test", version: "1.0.0" }),
+        "utf-8"
+      );
+      fs.mkdirSync("./src", { recursive: true });
+      const PLACEHOLDER = "/* placeholder text */";
+      fs.writeFileSync("./src/index.js", PLACEHOLDER, "utf-8");
+
+      await runWrangler("init");
+      expect(fs.readFileSync("./src/index.js", "utf-8")).toBe(PLACEHOLDER);
+      expect(fs.existsSync("./src/index.ts")).toBe(false);
+    });
+
+    it("should not offer to create a worker in a ts project if a file already exists at the location", async () => {
+      mockConfirm(
+        {
+          text: "Would you like to install wrangler into your package.json?",
+          result: false,
+        },
+        {
+          text: "Would you like to use TypeScript?",
+          result: true,
+        }
+      );
+
+      fs.writeFileSync(
+        "./package.json",
+        JSON.stringify({ name: "test", version: "1.0.0" }),
+        "utf-8"
+      );
+      fs.mkdirSync("./src", { recursive: true });
+      const PLACEHOLDER = "/* placeholder text */";
+      fs.writeFileSync("./src/index.ts", PLACEHOLDER, "utf-8");
+
+      await runWrangler("init");
+      expect(fs.existsSync("./src/index.js")).toBe(false);
+      expect(fs.readFileSync("./src/index.ts", "utf-8")).toBe(PLACEHOLDER);
+    });
+
     it("should create a tsconfig.json and install `workers-types` if none is found and user confirms", async () => {
       mockConfirm(
         {
@@ -256,8 +596,12 @@ describe("wrangler", () => {
           result: true,
         },
         {
-          text: "Would you like to use typescript?",
+          text: "Would you like to use TypeScript?",
           result: true,
+        },
+        {
+          text: "Would you like to create a Worker at src/index.ts?",
+          result: false,
         }
       );
       await runWrangler("init");
@@ -268,13 +612,10 @@ describe("wrangler", () => {
       expect(tsconfigJson.compilerOptions.types).toEqual([
         "@cloudflare/workers-types",
       ]);
-      const packageJson = JSON.parse(
-        fs.readFileSync("./package.json", "utf-8")
+      expect(mockPackageManager.addDevDeps).toHaveBeenCalledWith(
+        "@cloudflare/workers-types",
+        "typescript"
       );
-      expect(packageJson.devDependencies).toEqual({
-        "@cloudflare/workers-types": expect.any(String),
-        wrangler: expect.any(String),
-      });
     });
 
     it("should not touch an existing tsconfig.json in the same directory", async () => {
@@ -312,6 +653,10 @@ describe("wrangler", () => {
         {
           text: "Would you like to install the type definitions for Workers into your package.json?",
           result: true,
+        },
+        {
+          text: "Would you like to create a Worker at src/index.ts?",
+          result: false,
         }
       );
       fs.writeFileSync(
@@ -334,12 +679,9 @@ describe("wrangler", () => {
       );
       // unchanged tsconfig
       expect(tsconfigJson.compilerOptions).toEqual({});
-      const packageJson = JSON.parse(
-        fs.readFileSync("./package.json", "utf-8")
+      expect(mockPackageManager.addDevDeps).toHaveBeenCalledWith(
+        "@cloudflare/workers-types"
       );
-      expect(packageJson.devDependencies).toEqual({
-        "@cloudflare/workers-types": expect.any(String),
-      });
     });
 
     it("should not touch an existing tsconfig.json in an ancestor directory", async () => {
@@ -374,51 +716,56 @@ describe("wrangler", () => {
       expect(tsconfigJson.compilerOptions).toEqual({});
     });
 
+    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);
+    });
+
+    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` is used", async () => {
-      let err: undefined | Error;
-      try {
-        await runWrangler("init --type");
-      } catch (e) {
-        err = e;
-      } finally {
-        expect(err?.message).toBe(`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 () => {
-      let err: undefined | Error;
-      try {
-        await runWrangler("init --type javascript");
-      } catch (e) {
-        err = e;
-      } finally {
-        expect(err?.message).toBe(`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 () => {
-      let err: undefined | Error;
-      try {
-        await runWrangler("init --type rust");
-      } catch (e) {
-        err = e;
-      } finally {
-        expect(err?.message).toBe(`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 () => {
-      let err: undefined | Error;
-      try {
-        await runWrangler("init --type webpack");
-      } catch (e) {
-        err = e;
-      } finally {
-        expect(err?.message).toBe(
-          `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,9 +1,37 @@
-import { mockFetchInternal } from "./mock-cfetch";
+import fetchMock from "jest-fetch-mock";
+import { fetchInternal, fetchKVGetValue } from "../cfetch/internal";
 import { confirm, prompt } from "../dialogs";
-import { fetchInternal } from "../cfetch/internal";
+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 {
+    ...jest.requireActual("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");
+});
+
+jest.mock("../package-manager");
 
 jest.mock("../cfetch/internal");
 (fetchInternal as jest.Mock).mockImplementation(mockFetchInternal);
+(fetchKVGetValue as jest.Mock).mockImplementation(mockFetchKVGetValue);
 
 jest.mock("../dialogs");