wrangler 0.0.0-e5d3690 → 0.0.0-e88a54e

package/src/__tests__/dev2.test.tsx

@@ -0,0 +1,154 @@
+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,
+  ip = "localhost",
+  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}
+        ip={ip}
+        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>;
+}

package/src/__tests__/helpers/faye-websocket.d.ts

@@ -0,0 +1,6 @@
+module "faye-websocket" {
+  /**
+   * Standards-compliant WebSocket client and server.
+   */
+  export default WebSocket;
+}

package/src/__tests__/helpers/mock-account-id.ts

@@ -0,0 +1,48 @@
+import { reinitialiseAuthTokens } from "../../user";
+
+const ORIGINAL_CLOUDFLARE_API_TOKEN = process.env.CLOUDFLARE_API_TOKEN;
+const ORIGINAL_CLOUDFLARE_ACCOUNT_ID = process.env.CLOUDFLARE_ACCOUNT_ID;
+
+/**
+ * Mock the API token so that we don't need to read it from user configuration files.
+ *
+ * Note that you can remove any API token from the environment by setting the value to `null`.
+ * This is useful if a higher `describe()` block has already called `mockApiToken()`.
+ */
+export function mockApiToken({
+  apiToken = "some-api-token",
+}: { apiToken?: string | null } = {}) {
+  beforeEach(() => {
+    if (apiToken === null) {
+      delete process.env.CLOUDFLARE_API_TOKEN;
+    } else {
+      process.env.CLOUDFLARE_API_TOKEN = apiToken;
+    }
+    // Now we have updated the environment, we must reinitialize the user auth state.
+    reinitialiseAuthTokens();
+  });
+  afterEach(() => {
+    process.env.CLOUDFLARE_API_TOKEN = ORIGINAL_CLOUDFLARE_API_TOKEN;
+  });
+}
+
+/**
+ * Mock the current account ID so that we don't need to read it from configuration files.
+ *
+ * Note that you can remove any account ID from the environment by setting the value to `null`.
+ * This is useful if a higher `describe()` block has already called `mockAccountId()`.
+ */
+export function mockAccountId({
+  accountId = "some-account-id",
+}: { accountId?: string | null } = {}) {
+  beforeEach(() => {
+    if (accountId === null) {
+      delete process.env.CLOUDFLARE_ACCOUNT_ID;
+    } else {
+      process.env.CLOUDFLARE_ACCOUNT_ID = accountId;
+    }
+  });
+  afterEach(() => {
+    process.env.CLOUDFLARE_ACCOUNT_ID = ORIGINAL_CLOUDFLARE_ACCOUNT_ID;
+  });
+}

package/src/__tests__/helpers/mock-bin.ts

@@ -0,0 +1,36 @@
+import { chmodSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { basename, resolve } from "node:path";
+import cmdShim from "cmd-shim";
+
+const nodeShebang = "#!/usr/bin/env node";
+
+/**
+ * Create a binary file in a temp directory and make it available on the PATH.
+ */
+export async function mockBinary(
+  binaryName: string,
+  code: string
+): Promise<() => void> {
+  // Ensure there is a directory to put the mock binary in.
+  const tmpDir = resolve(mkdtempSync(".mock-binary-"));
+
+  // Use a fake extension on Windows because we will create a cmd-shim to run the binary.
+  const extension = process.platform === "win32" ? ".x-mock-bin" : "";
+  const filePath = resolve(tmpDir, `${binaryName}${extension}`);
+  writeFileSync(filePath, nodeShebang + "\n" + code);
+  chmodSync(filePath, 0o777);
+
+  if (process.platform === "win32") {
+    await cmdShim(filePath, basename(filePath, ".x-mock-bin"));
+  }
+
+  // Update PATH using the appropriate separator for the platform.
+  const oldPath = process.env.PATH;
+  const sep = process.platform === "win32" ? ";" : ":";
+  process.env.PATH = tmpDir + sep + oldPath;
+
+  return function unMock() {
+    rmSync(tmpDir, { recursive: true });
+    process.env.PATH = process.env.PATH?.replace(tmpDir + sep, "");
+  };
+}

package/src/__tests__/{mock-cfetch.ts → helpers/mock-cfetch.ts}

@@ -1,8 +1,8 @@
-import type { RequestInit } from "node-fetch";
-import { URLSearchParams } from "node:url";
+import { URL, URLSearchParams } from "node:url";
 import { pathToRegexp } from "path-to-regexp";
-import { CF_API_BASE_URL } from "../cfetch";
-import type { FetchResult } from "../cfetch";
+import { getCloudflareApiBaseUrl } from "../../cfetch";
+import type { FetchResult, FetchError } from "../../cfetch";
+import type { RequestInit } from "undici";
 
 /**
  * The signature of the function that will handle a mock request.
@@ -11,7 +11,7 @@ export type MockHandler<ResponseType> = (
   uri: RegExpExecArray,
   init: RequestInit,
   queryParams: URLSearchParams
-) => ResponseType;
+) => ResponseType | Promise<ResponseType>;
 
 type RemoveMockFn = () => void;
 
@@ -35,13 +35,13 @@ export async function mockFetchInternal(
   queryParams: URLSearchParams = new URLSearchParams()
 ) {
   for (const { regexp, method, handler } of mocks) {
-    const resourcePath = new URL(resource, CF_API_BASE_URL).pathname;
+    const resourcePath = new URL(resource, getCloudflareApiBaseUrl()).pathname;
     const uri = regexp.exec(resourcePath);
     // Do the resource path and (if specified) the HTTP method match?
     if (uri !== null && (!method || method === (init.method ?? "GET"))) {
       // The `resource` regular expression will extract the labelled groups from the URL.
       // These are passed through to the `handler` call, to allow it to do additional checks or behaviour.
-      return handler(uri, init, queryParams); // TODO: should we have some kind of fallthrough system? we'll see.
+      return await handler(uri, init, queryParams); // TODO: should we have some kind of fallthrough system? we'll see.
     }
   }
   throw new Error(
@@ -140,23 +140,23 @@ export function setMockResponse<ResponseType>(
 /**
  * A helper to make it easier to create `FetchResult` objects in tests.
  */
-export function createFetchResult<ResponseType>(
-  result: ResponseType,
+export async function createFetchResult<ResponseType>(
+  result: ResponseType | Promise<ResponseType>,
   success = true,
-  errors = [],
-  messages = [],
+  errors: FetchError[] = [],
+  messages: string[] = [],
   result_info?: unknown
-): FetchResult<ResponseType> {
+): Promise<FetchResult<ResponseType>> {
   return result_info
     ? {
-        result,
+        result: await result,
         success,
         errors,
         messages,
         result_info,
       }
     : {
-        result,
+        result: await result,
         success,
         errors,
         messages,
@@ -171,3 +171,37 @@ export function createFetchResult<ResponseType>(
 export function unsetAllMocks() {
   mocks.length = 0;
 }
+
+/**
+ * We special-case fetching the request for `kv:key get`, because it's
+ * the only cloudflare API endpoint that returns a plain string as the
+ * value, and not as the "standard" FetchResult-style json. Hence, we also
+ * special-case mocking it here.
+ */
+
+const kvGetMocks = new Map<string, string>();
+
+export function mockFetchKVGetValue(
+  accountId: string,
+  namespaceId: string,
+  key: string
+) {
+  const mapKey = `${accountId}/${namespaceId}/${key}`;
+  if (kvGetMocks.has(mapKey)) {
+    return kvGetMocks.get(mapKey);
+  }
+  throw new Error(`no mock value found for \`kv:key get\` - ${mapKey}`);
+}
+
+export function setMockFetchKVGetValue(
+  accountId: string,
+  namespaceId: string,
+  key: string,
+  value: string
+) {
+  kvGetMocks.set(`${accountId}/${namespaceId}/${key}`, value);
+}
+
+export function unsetMockFetchKVGetValues() {
+  kvGetMocks.clear();
+}

package/src/__tests__/helpers/mock-console.ts

@@ -0,0 +1,70 @@
+import * as util from "node:util";
+
+/**
+ * We use this module to mock console methods, and optionally
+ * assert on the values they're called with in our tests.
+ */
+
+let logSpy: jest.SpyInstance,
+  errorSpy: jest.SpyInstance,
+  warnSpy: jest.SpyInstance;
+
+const std = {
+  get out() {
+    return normalizeOutput(logSpy);
+  },
+  get err() {
+    return normalizeOutput(errorSpy);
+  },
+  get warn() {
+    return normalizeOutput(warnSpy);
+  },
+};
+
+function normalizeOutput(spy: jest.SpyInstance): string {
+  return stripTrailingWhitespace(
+    normalizeSlashes(stripTimings(captureCalls(spy)))
+  );
+}
+
+function captureCalls(spy: jest.SpyInstance): string {
+  return spy.mock.calls
+    .map((args: unknown[]) => util.format("%s", ...args))
+    .join("\n");
+}
+
+export function mockConsoleMethods() {
+  beforeEach(() => {
+    logSpy = jest.spyOn(console, "log").mockImplementation();
+    errorSpy = jest.spyOn(console, "error").mockImplementation();
+    warnSpy = jest.spyOn(console, "warn").mockImplementation();
+  });
+  afterEach(() => {
+    logSpy.mockRestore();
+    errorSpy.mockRestore();
+    warnSpy.mockRestore();
+  });
+  return std;
+}
+
+/**
+ * Ensure slashes in the `str` are OS file-system agnostic.
+ *
+ * Use this in snapshot tests to be resilient to file-system differences.
+ */
+export function normalizeSlashes(str: string): string {
+  return str.replace(/\\/g, "/");
+}
+
+/**
+ * Strip "timing data" out of the `stdout` string, since this is not always deterministic.
+ *
+ * Use this in snapshot tests to be resilient to slight changes in timing of processing.
+ */
+export function stripTimings(stdout: string): string {
+  return stdout.replace(/\(\d+\.\d+ sec\)/g, "(TIMINGS)");
+}
+
+export function stripTrailingWhitespace(str: string): string {
+  return str.replace(/[^\S\n]+\n/g, "\n");
+}

package/src/__tests__/{mock-dialogs.ts → helpers/mock-dialogs.ts}

@@ -1,4 +1,4 @@
-import { confirm, prompt } from "../dialogs";
+import { confirm, prompt } from "../../dialogs";
 
 /**
  * The expected values for a confirmation request.

package/src/__tests__/helpers/mock-kv.ts

@@ -0,0 +1,33 @@
+import { createFetchResult, setMockRawResponse } from "./mock-cfetch";
+import type { NamespaceKeyInfo } from "../../kv";
+
+export function mockKeyListRequest(
+  expectedNamespaceId: string,
+  expectedKeys: NamespaceKeyInfo[],
+  keysPerRequest = 1000,
+  blankCursorValue: "" | undefined | null = undefined
+) {
+  const requests = { count: 0 };
+  // See https://api.cloudflare.com/#workers-kv-namespace-list-a-namespace-s-keys
+
+  setMockRawResponse(
+    "/accounts/:accountId/storage/kv/namespaces/:namespaceId/keys",
+    "GET",
+    ([_url, accountId, namespaceId], _init, query) => {
+      requests.count++;
+      expect(accountId).toEqual("some-account-id");
+      expect(namespaceId).toEqual(expectedNamespaceId);
+      if (expectedKeys.length <= keysPerRequest) {
+        return createFetchResult(expectedKeys);
+      } else {
+        const start = parseInt(query.get("cursor") ?? "0") || 0;
+        const end = start + keysPerRequest;
+        const cursor = end < expectedKeys.length ? end : blankCursorValue;
+        return createFetchResult(expectedKeys.slice(start, end), true, [], [], {
+          cursor,
+        });
+      }
+    }
+  );
+  return requests;
+}

package/src/__tests__/helpers/mock-stdin.ts

@@ -0,0 +1,103 @@
+const ORIGINAL_STDIN = process.stdin;
+
+/**
+ * Mock process.stdin so that we can pipe in text for non-interactive mode tests.
+ */
+export function useMockStdin({ isTTY }: { isTTY: boolean }) {
+  const mockStdin = new MockStdIn(isTTY);
+
+  beforeEach(() => {
+    mockStdin.reset();
+    Object.defineProperty(process, "stdin", {
+      value: mockStdin,
+      configurable: true,
+      writable: false,
+    });
+  });
+
+  afterEach(() => {
+    Object.defineProperty(process, "stdin", {
+      value: ORIGINAL_STDIN,
+      configurable: true,
+      writable: false,
+    });
+  });
+
+  return mockStdin;
+}
+
+const failCallback: (value: unknown) => void = () => {
+  throw new Error(
+    "TEST FAILURE: stdin callback called before being initialized."
+  );
+};
+
+/**
+ * A mock version of `process.std`, which can be used to simulate piping data
+ * into the wrangler process in non-interactive mode.
+ */
+class MockStdIn {
+  private endCallback = failCallback;
+  private errorCallback = failCallback;
+  private chunks: string[] = [];
+  private error: Error | undefined;
+
+  /**
+   * Set this to true if you want the stdin stream to error.
+   */
+  throwError(error: Error) {
+    this.error = error;
+  }
+
+  /**
+   * Call this to clean out the chunks that are queued for sending.
+   */
+  reset() {
+    this.chunks.length = 0;
+    this.error = undefined;
+  }
+
+  /**
+   * Queue up some chunks to be sent.
+   */
+  send(...chunks: string[]) {
+    this.chunks.push(...chunks);
+  }
+
+  constructor(
+    /**
+     * Used by wrangler to check whether stdin is interactive.
+     */
+    readonly isTTY: boolean
+  ) {}
+
+  /**
+   * Used by wrangler to add event listeners.
+   */
+  on(eventName: string, callback: () => void) {
+    switch (eventName) {
+      case "readable":
+        setImmediate(callback);
+        break;
+      case "end":
+        this.endCallback = callback;
+        break;
+      case "error":
+        this.errorCallback = callback;
+        break;
+    }
+  }
+
+  /**
+   * Used by wrangler to get the next chunk of data in the stream.
+   */
+  read() {
+    if (this.error) {
+      setImmediate(() => this.errorCallback(this.error));
+    }
+    if (this.chunks.length === 0) {
+      setImmediate(this.endCallback);
+    }
+    return this.chunks.shift() ?? null;
+  }
+}

package/src/__tests__/helpers/mock-web-socket.ts

@@ -0,0 +1,29 @@
+import { WebSocket } from "mock-socket";
+
+/**
+ * A version of the mock WebSocket that supports the methods that we use.
+ */
+export class MockWebSocket extends WebSocket {
+  on(event: string | symbol, listener: (...args: unknown[]) => void): this {
+    switch (event) {
+      case "message":
+        this.onmessage = ({ data }) => {
+          listener(data);
+        };
+        break;
+      case "open":
+        this.onopen = listener;
+        break;
+      case "close":
+        this.onclose = listener;
+        break;
+      default:
+        throw new Error("Unknown event type: " + event.toString());
+    }
+    return this;
+  }
+
+  terminate() {
+    this.close();
+  }
+}