wrangler 0.0.0-e22f9d7 → 0.0.0-e452a04

package/src/__tests__/dev.test.tsx

@@ -1,67 +1,405 @@
-import { render } from "ink-testing-library";
+import * as fs from "node:fs";
+import { readFileSync } from "node:fs";
 import patchConsole from "patch-console";
-import React from "react";
-import Dev from "../dev";
-import type { DevProps } 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";
+import { runInTempDir } from "./helpers/run-in-tmp";
+import { runWrangler } from "./helpers/run-wrangler";
+import writeWranglerToml from "./helpers/write-wrangler-toml";
 
 describe("Dev component", () => {
-  let restoreConsole;
-  beforeEach(() => (restoreConsole = patchConsole(() => {})));
-  afterEach(() => restoreConsole());
-
-  it("should throw if format is service-worker and there is a public directory", () => {
-    const { lastFrame } = renderDev({
-      format: "service-worker",
-      accountId: "some-account-id",
-      public: "some/public/path",
-    });
-    expect(lastFrame().split("\n").slice(0, 2).join("\n"))
-      .toMatchInlineSnapshot(`
-      "Something went wrong:
-      Error: You cannot use the service worker format with a \`public\` directory."
-    `);
+  mockAccountId();
+  mockApiToken();
+  runInTempDir();
+  const std = mockConsoleMethods();
+  afterEach(() => {
+    (Dev as jest.Mock).mockClear();
+    patchConsole(() => {});
+    unsetAllMocks();
+  });
+
+  describe("entry-points", () => {
+    it("should error if there is no entry-point specified", async () => {
+      writeWranglerToml();
+
+      await expect(
+        runWrangler("dev")
+      ).rejects.toThrowErrorMatchingInlineSnapshot(
+        `"Missing entry-point: The entry-point should be specified via the command line (e.g. \`wrangler dev path/to/script\`) or the \`main\` config field."`
+      );
+
+      expect(std.out).toMatchInlineSnapshot(`""`);
+      expect(std.err).toMatchInlineSnapshot(`
+        "Missing entry-point: The entry-point should be specified via the command line (e.g. \`wrangler dev path/to/script\`) or the \`main\` config field.
+
+        %s If you think this is a bug then please create an issue at https://github.com/cloudflare/wrangler2/issues/new."
+      `);
+    });
+  });
+
+  describe("host", () => {
+    it("should resolve a host to its zone", async () => {
+      writeWranglerToml({
+        main: "index.js",
+      });
+      fs.writeFileSync("index.js", `export default {};`);
+      mockGetZones("some-host.com", [{ id: "some-zone-id" }]);
+      await runWrangler("dev --host some-host.com");
+      expect((Dev as jest.Mock).mock.calls[0][0].zone).toEqual({
+        host: "some-host.com",
+        id: "some-zone-id",
+      });
+    });
+
+    it("should read wrangler.toml's dev.host", async () => {
+      writeWranglerToml({
+        main: "index.js",
+        dev: {
+          host: "some-host.com",
+        },
+      });
+      fs.writeFileSync("index.js", `export default {};`);
+      mockGetZones("some-host.com", [{ id: "some-zone-id" }]);
+      await runWrangler("dev");
+      expect((Dev as jest.Mock).mock.calls[0][0].zone.host).toEqual(
+        "some-host.com"
+      );
+    });
+
+    it("should read --route", async () => {
+      writeWranglerToml({
+        main: "index.js",
+      });
+      fs.writeFileSync("index.js", `export default {};`);
+      mockGetZones("some-host.com", [{ id: "some-zone-id" }]);
+      await runWrangler("dev --route http://some-host.com/some/path/*");
+      expect((Dev as jest.Mock).mock.calls[0][0].zone.host).toEqual(
+        "some-host.com"
+      );
+    });
+
+    it("should read wrangler.toml's routes", async () => {
+      writeWranglerToml({
+        main: "index.js",
+        routes: [
+          "http://some-host.com/some/path/*",
+          "http://some-other-host.com/path/*",
+        ],
+      });
+      fs.writeFileSync("index.js", `export default {};`);
+      mockGetZones("some-host.com", [{ id: "some-zone-id" }]);
+      await runWrangler("dev");
+      expect((Dev as jest.Mock).mock.calls[0][0].zone.host).toEqual(
+        "some-host.com"
+      );
+    });
+
+    it("should read wrangler.toml's environment specific routes", async () => {
+      writeWranglerToml({
+        main: "index.js",
+        routes: [
+          "http://a-host.com/some/path/*",
+          "http://another-host.com/path/*",
+        ],
+        env: {
+          staging: {
+            routes: [
+              "http://some-host.com/some/path/*",
+              "http://some-other-host.com/path/*",
+            ],
+          },
+        },
+      });
+      fs.writeFileSync("index.js", `export default {};`);
+      mockGetZones("some-host.com", [{ id: "some-zone-id" }]);
+      await runWrangler("dev --env staging");
+      expect((Dev as jest.Mock).mock.calls[0][0].zone.host).toEqual(
+        "some-host.com"
+      );
+    });
+
+    it("given a long host, it should use the longest subdomain that resolves to a zone", async () => {
+      writeWranglerToml({
+        main: "index.js",
+      });
+      fs.writeFileSync("index.js", `export default {};`);
+      mockGetZones("111.222.333.some-host.com", []);
+      mockGetZones("222.333.some-host.com", []);
+      mockGetZones("333.some-host.com", [{ id: "some-zone-id" }]);
+      await runWrangler("dev --host 111.222.333.some-host.com");
+      expect((Dev as jest.Mock).mock.calls[0][0].zone).toEqual({
+        host: "111.222.333.some-host.com",
+        id: "some-zone-id",
+      });
+    });
+
+    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 {};`);
+
+      // config.routes
+      mockGetZones("5.some-host.com", [{ id: "some-zone-id-5" }]);
+      writeWranglerToml({
+        main: "index.js",
+        routes: ["http://5.some-host.com/some/path/*"],
+      });
+      await runWrangler("dev");
+      expect((Dev as jest.Mock).mock.calls[0][0].zone).toEqual({
+        host: "5.some-host.com",
+        id: "some-zone-id-5",
+      });
+      (Dev as jest.Mock).mockClear();
+
+      // config.route
+      mockGetZones("4.some-host.com", [{ id: "some-zone-id-4" }]);
+      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({
+        host: "4.some-host.com",
+        id: "some-zone-id-4",
+      });
+      (Dev as jest.Mock).mockClear();
+
+      // --routes
+      mockGetZones("3.some-host.com", [{ id: "some-zone-id-3" }]);
+      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({
+        host: "3.some-host.com",
+        id: "some-zone-id-3",
+      });
+      (Dev as jest.Mock).mockClear();
+
+      // config.dev.host
+      mockGetZones("2.some-host.com", [{ id: "some-zone-id-2" }]);
+      writeWranglerToml({
+        main: "index.js",
+        dev: {
+          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({
+        host: "2.some-host.com",
+        id: "some-zone-id-2",
+      });
+      (Dev as jest.Mock).mockClear();
+
+      // --host
+      mockGetZones("1.some-host.com", [{ id: "some-zone-id-1" }]);
+      writeWranglerToml({
+        main: "index.js",
+        dev: {
+          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"
+      );
+      expect((Dev as jest.Mock).mock.calls[0][0].zone).toEqual({
+        host: "1.some-host.com",
+        id: "some-zone-id-1",
+      });
+      (Dev as jest.Mock).mockClear();
+    });
+
+    it("should error if a host can't resolve to a zone", async () => {
+      writeWranglerToml({
+        main: "index.js",
+      });
+      fs.writeFileSync("index.js", `export default {};`);
+      mockGetZones("some-host.com", []);
+      await expect(
+        runWrangler("dev --host some-host.com")
+      ).rejects.toThrowErrorMatchingInlineSnapshot(
+        `"Could not find zone for some-host.com"`
+      );
+    });
+  });
+
+  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(`""`);
+    });
   });
 });
 
-/**
- * Helper function to make it easier to setup and render the `Dev` component.
- *
- * All the `Dev` props are optional here, with sensible defaults for testing.
- */
-function renderDev({
-  name,
-  entry = "some/entry.ts",
-  port,
-  format,
-  accountId,
-  initialMode = "remote",
-  jsxFactory,
-  jsxFragment,
-  bindings = {},
-  public: publicDir,
-  site,
-  compatibilityDate,
-  compatibilityFlags,
-  usageModel,
-  buildCommand = {},
-}: Partial<DevProps>) {
-  return render(
-    <Dev
-      name={name}
-      entry={entry}
-      port={port}
-      buildCommand={buildCommand}
-      format={format}
-      initialMode={initialMode}
-      jsxFactory={jsxFactory}
-      jsxFragment={jsxFragment}
-      accountId={accountId}
-      site={site}
-      public={publicDir}
-      compatibilityDate={compatibilityDate}
-      compatibilityFlags={compatibilityFlags}
-      usageModel={usageModel}
-      bindings={bindings}
-    />
+function mockGetZones(domain: string, zones: { id: string }[] = []) {
+  const removeMock = setMockResponse(
+    "/zones",
+    "GET",
+    (_urlPieces, _init, queryParams) => {
+      expect([...queryParams.entries()]).toEqual([["name", domain]]);
+      // Because the API URL `/zones` is the same for each request, we can get into a situation where earlier mocks get triggered for later requests. So, we simply clear the mock on every trigger.
+      removeMock();
+      return zones;
+    }
   );
 }

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

@@ -0,0 +1,58 @@
+import { writeFile } from "fs/promises";
+import path from "path";
+import guessWorkerFormat from "../entry";
+import { runInTempDir } from "./helpers/run-in-tmp";
+
+describe("guess worker format", () => {
+  runInTempDir();
+  it('should detect a "modules" worker', async () => {
+    await writeFile("./index.ts", "export default {};");
+    // 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(
+      path.join(process.cwd(), "./index.ts"),
+      process.cwd(),
+      undefined
+    );
+    expect(guess).toBe("modules");
+  });
+
+  it('should detect a "service-worker" worker', async () => {
+    await writeFile("./index.ts", "");
+    // Note that this isn't actually a valid worker, because it's missing
+    // a fetch listener. Regardless, our heuristic is simply to check for
+    // the lack of exports.
+    const guess = await guessWorkerFormat(
+      path.join(process.cwd(), "./index.ts"),
+      process.cwd(),
+      undefined
+    );
+    expect(guess).toBe("service-worker");
+  });
+
+  it("should throw an error when the hint doesn't match the guess (modules - service-worker)", async () => {
+    await writeFile("./index.ts", "export default {};");
+    await expect(
+      guessWorkerFormat(
+        path.join(process.cwd(), "./index.ts"),
+        process.cwd(),
+        "service-worker"
+      )
+    ).rejects.toThrow(
+      "You configured this worker to be a 'service-worker', but the file you are trying to build appears to have ES module exports. Please pass `--format modules`, or simply remove the configuration."
+    );
+  });
+
+  it("should throw an error when the hint doesn't match the guess (service-worker - modules)", async () => {
+    await writeFile("./index.ts", "");
+    await expect(
+      guessWorkerFormat(
+        path.join(process.cwd(), "./index.ts"),
+        process.cwd(),
+        "modules"
+      )
+    ).rejects.toThrow(
+      "You configured this worker to be 'modules', but the file you are trying to build doesn't export a handler. Please pass `--format service-worker`, or simply remove the configuration."
+    );
+  });
+});

package/src/__tests__/helpers/cmd-shim.d.ts

@@ -0,0 +1,11 @@
+/**
+ * The typings file available at `@types/cmd-shim` are out of date.
+ */
+module "cmd-shim" {
+  /**
+   *
+   * Create a cmd shim at `to` for the command line program at `from`.
+   *
+   */
+  export default function cmdShim(from: string, to: string): Promise<void>;
+}