wrangler 0.0.0-e151223 → 0.0.0-e1b8ac4

package/src/__tests__/guess-worker-format.test.ts

@@ -0,0 +1,85 @@
+import { writeFile } from "fs/promises";
+import path from "path";
+import guessWorkerFormat from "../entry";
+import { mockConsoleMethods } from "./helpers/mock-console";
+import { runInTempDir } from "./helpers/run-in-tmp";
+
+describe("guess worker format", () => {
+  runInTempDir();
+  const std = mockConsoleMethods();
+  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 a `default` export like a module worker. 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."
+    );
+  });
+
+  it("should not error if a .js entry point has jsx", async () => {
+    await writeFile("./index.js", "console.log(<div/>)");
+    const guess = await guessWorkerFormat(
+      path.join(process.cwd(), "./index.js"),
+      process.cwd(),
+      undefined
+    );
+    expect(guess).toBe("service-worker");
+  });
+
+  it("logs a warning when a worker has exports, but not a default one", async () => {
+    await writeFile("./index.ts", "export const foo = 1;");
+    const guess = await guessWorkerFormat(
+      path.join(process.cwd(), "./index.ts"),
+      process.cwd(),
+      undefined
+    );
+    expect(guess).toBe("service-worker");
+    expect(std.warn).toMatchInlineSnapshot(`
+      "▲ [WARNING] The entrypoint index.ts has exports like an ES Module, but hasn't defined a default export like a module worker normally would. Building the worker using \\"service-worker\\" format...
+
+      "
+    `);
+  });
+});

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

@@ -1,30 +1,48 @@
-const ORIGINAL_CF_API_TOKEN = process.env.CF_API_TOKEN;
-const ORIGINAL_CF_ACCOUNT_ID = process.env.CF_ACCOUNT_ID;
+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 } = {}) {
+}: { apiToken?: string | null } = {}) {
   beforeEach(() => {
-    process.env.CF_API_TOKEN = apiToken;
+    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.CF_API_TOKEN = ORIGINAL_CF_API_TOKEN;
+    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 } = {}) {
+}: { accountId?: string | null } = {}) {
   beforeEach(() => {
-    process.env.CF_ACCOUNT_ID = accountId;
+    if (accountId === null) {
+      delete process.env.CLOUDFLARE_ACCOUNT_ID;
+    } else {
+      process.env.CLOUDFLARE_ACCOUNT_ID = accountId;
+    }
   });
   afterEach(() => {
-    process.env.CF_ACCOUNT_ID = ORIGINAL_CF_ACCOUNT_ID;
+    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__/helpers/mock-cfetch.ts

@@ -1,7 +1,7 @@
 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";
 
 /**
@@ -35,7 +35,7 @@ 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"))) {
@@ -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,41 @@ 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 | Buffer>();
+
+/**
+ * @mocked typeof fetchKVGetValue
+ */
+export function mockFetchKVGetValue(
+  accountId: string,
+  namespaceId: string,
+  key: string
+) {
+  const mapKey = `${accountId}/${namespaceId}/${key}`;
+  if (kvGetMocks.has(mapKey)) {
+    const value = kvGetMocks.get(mapKey);
+    if (value !== undefined) return Promise.resolve(value);
+  }
+  throw new Error(`no mock value found for \`kv:key get\` - ${mapKey}`);
+}
+
+export function setMockFetchKVGetValue(
+  accountId: string,
+  namespaceId: string,
+  key: string,
+  value: string | Buffer
+) {
+  kvGetMocks.set(`${accountId}/${namespaceId}/${key}`, value);
+}
+
+export function unsetMockFetchKVGetValues() {
+  kvGetMocks.clear();
+}

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

@@ -1,35 +1,53 @@
+import * as util from "node:util";
+import { logger } from "../../logger";
+
 /**
  * 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,
+let debugSpy: jest.SpyInstance,
+  logSpy: jest.SpyInstance,
   errorSpy: jest.SpyInstance,
   warnSpy: jest.SpyInstance;
 
 const std = {
+  get debug() {
+    return normalizeOutput(debugSpy);
+  },
   get out() {
-    return normalizeSlashes(stripTimings(logSpy.mock.calls.flat(2).join("\n")));
+    return normalizeOutput(logSpy);
   },
   get err() {
-    return normalizeSlashes(
-      stripTimings(errorSpy.mock.calls.flat(2).join("\n"))
-    );
+    return normalizeOutput(errorSpy);
   },
   get warn() {
-    return normalizeSlashes(
-      stripTimings(warnSpy.mock.calls.flat(2).join("\n"))
-    );
+    return normalizeOutput(warnSpy);
   },
 };
 
+function normalizeOutput(spy: jest.SpyInstance): string {
+  return normalizeErrorMarkers(
+    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(() => {
+    logger.columns = 100;
+    debugSpy = jest.spyOn(console, "debug").mockImplementation();
     logSpy = jest.spyOn(console, "log").mockImplementation();
     errorSpy = jest.spyOn(console, "error").mockImplementation();
     warnSpy = jest.spyOn(console, "warn").mockImplementation();
   });
   afterEach(() => {
+    debugSpy.mockRestore();
     logSpy.mockRestore();
     errorSpy.mockRestore();
     warnSpy.mockRestore();
@@ -37,6 +55,15 @@ export function mockConsoleMethods() {
   return std;
 }
 
+/**
+ * Normalize error `X` markers.
+ *
+ * Windows gets a different character.
+ */
+function normalizeErrorMarkers(str: string): string {
+  return str.replaceAll("✘", "X");
+}
+
 /**
  * Ensure slashes in the `str` are OS file-system agnostic.
  *
@@ -54,3 +81,7 @@ export function normalizeSlashes(str: string): string {
 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__/helpers/mock-dialogs.ts

@@ -1,4 +1,5 @@
-import { confirm, prompt } from "../../dialogs";
+import { confirm, prompt, select } from "../../dialogs";
+import { normalizeSlashes } from "./mock-console";
 
 /**
  * The expected values for a confirmation request.
@@ -19,13 +20,34 @@ export interface ConfirmExpectation {
  */
 export function mockConfirm(...expectations: ConfirmExpectation[]) {
   (confirm as jest.Mock).mockImplementation((text: string) => {
-    for (const { text: expectedText, result } of expectations) {
-      if (text === expectedText) {
-        return Promise.resolve(result);
+    for (const expectation of expectations) {
+      if (normalizeSlashes(text) === normalizeSlashes(expectation.text)) {
+        expectations = expectations.filter((e) => e !== expectation);
+        return Promise.resolve(expectation.result);
       }
     }
     throw new Error(`Unexpected confirmation message: ${text}`);
   });
+  return () => {
+    if (expectations.length > 0) {
+      throw new Error(
+        "The following expected confirmation dialogs were not used:\n" +
+          expectations.map((e) => `- "${e.text}"`).join("\n")
+      );
+    }
+  };
+}
+
+export function clearConfirmMocks() {
+  (confirm as jest.Mock).mockReset();
+  // Because confirm was originally a spy, calling mockReset will simply reset
+  // it as a function with no return value (!), so we need to accitionally reset
+  // the mock implementation to the one that throws (from jest.setup.js).
+  (confirm as jest.Mock).mockImplementation((text: string) => {
+    throw new Error(
+      `Unexpected call to \`confirm("${text}")\`.\nYou should use \`mockConfirm()\` to mock calls to \`confirm()\` with expectations. Search the codebase for \`mockConfirm\` to learn more.`
+    );
+  });
 }
 
 /**
@@ -50,16 +72,82 @@ export interface PromptExpectation {
 export function mockPrompt(...expectations: PromptExpectation[]) {
   (prompt as jest.Mock).mockImplementation(
     (text: string, type: "text" | "password") => {
-      for (const {
-        text: expectedText,
-        type: expectedType,
-        result,
-      } of expectations) {
-        if (text === expectedText && type == expectedType) {
-          return Promise.resolve(result);
+      for (const expectation of expectations) {
+        if (text === expectation.text && type == expectation.type) {
+          expectations = expectations.filter((e) => e !== expectation);
+          return Promise.resolve(expectation.result);
         }
       }
       throw new Error(`Unexpected confirmation message: ${text}`);
     }
   );
+  return () => {
+    if (expectations.length > 0) {
+      throw new Error(
+        "The following expected prompt dialogs were not used:\n" +
+          expectations.map((e) => `- "${e.text}"`).join("\n")
+      );
+    }
+  };
+}
+
+export function clearPromptMocks() {
+  (prompt as jest.Mock).mockReset();
+  // Because prompt was originally a spy, calling mockReset will simply reset
+  // it as a function with no return value (!), so we need to accitionally reset
+  // the mock implementation to the one that throws (from jest.setup.js).
+  (prompt as jest.Mock).mockImplementation((text: string) => {
+    throw new Error(
+      `Unexpected call to \`prompt(${text}, ...)\`.\nYou should use \`mockPrompt()\` to mock calls to \`prompt()\` with expectations. Search the codebase for \`mockPrompt\` to learn more.`
+    );
+  });
+}
+
+/**
+ * The expected values for a select request.
+ */
+export interface SelectExpectation {
+  /** The text expected to be seen in the select dialog. */
+  text: string;
+  /** The mock response send back from the select dialog. */
+  result: string;
+}
+
+/**
+ * Mock the implementation of `select()` that will respond with configured results
+ * for configured select text messages.
+ *
+ * If there is a call to `select()` that does not match any of the expectations
+ * then an error is thrown.
+ */
+export function mockSelect(...expectations: SelectExpectation[]) {
+  (select as jest.Mock).mockImplementation((text: string) => {
+    for (const expectation of expectations) {
+      if (normalizeSlashes(text) === normalizeSlashes(expectation.text)) {
+        expectations = expectations.filter((e) => e !== expectation);
+        return Promise.resolve(expectation.result);
+      }
+    }
+    throw new Error(`Unexpected select message: ${text}`);
+  });
+  return () => {
+    if (expectations.length > 0) {
+      throw new Error(
+        "The following expected select dialogs were not used:\n" +
+          expectations.map((e) => `- "${e.text}"`).join("\n")
+      );
+    }
+  };
+}
+
+export function clearSelectMocks() {
+  (select as jest.Mock).mockReset();
+  // Because select was originally a spy, calling mockReset will simply reset
+  // it as a function with no return value (!), so we need to additionally reset
+  // the mock implementation to the one that throws (from jest.setup.js).
+  (select as jest.Mock).mockImplementation((text: string) => {
+    throw new Error(
+      `Unexpected call to \`select("${text}")\`.\nYou should use \`mockSelect()\` to mock calls to \`select()\` with expectations. Search the codebase for \`mockSelect\` to learn more.`
+    );
+  });
 }

package/src/__tests__/helpers/mock-http-server.ts

@@ -0,0 +1,46 @@
+import http from "node:http";
+import type { Request } from "undici";
+
+/**
+ * Setup a mock HTTP server that can be triggered directly without interacting with any network.
+ *
+ * @returns a `fetch`-like function that will trigger the mock server to handle the request.
+ */
+export function mockHttpServer() {
+  let listener: http.RequestListener;
+
+  beforeEach(() => {
+    jest
+      .spyOn(http, "createServer")
+      .mockImplementation((...args: unknown[]) => {
+        listener = args.pop() as http.RequestListener;
+        return {
+          listen: jest.fn(),
+          close(callback?: (err?: Error) => void) {
+            callback?.();
+            return this;
+          },
+        } as unknown as http.Server;
+      });
+  });
+
+  return async (req: Request) => {
+    const resp = new http.ServerResponse(
+      // If you squint you can just about see that an `IncomingMessages` is like a `Request`!
+      req as unknown as http.IncomingMessage
+    );
+
+    // The listener will attache a callback to the response by calling `resp.end(callback)`.
+    // We want to capture that so that we can trigger it after the listener has completed its work.
+    const endSpy = jest.spyOn(resp, "end");
+
+    // The `await` here is important to allow the listener to complete its async work before we end the response.
+    await listener(req as unknown as http.IncomingMessage, resp);
+
+    // Now trigger the end callback.
+    const endCallback = endSpy.mock.calls[0].pop();
+    endCallback?.();
+
+    return resp;
+  };
+}

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

@@ -0,0 +1,27 @@
+const ORIGINAL_STDOUT_ISTTY = process.stdout.isTTY;
+const ORIGINAL_STDIN_ISTTY = process.stdin.isTTY;
+
+/**
+ * Mock `process.stdout.isTTY`
+ */
+export function useMockIsTTY() {
+  /**
+   * Explicitly set `process.stdout.isTTY` to a given value
+   */
+  const setIsTTY = (isTTY: boolean) => {
+    process.stdout.isTTY = isTTY;
+    process.stdin.isTTY = isTTY;
+  };
+
+  beforeEach(() => {
+    process.stdout.isTTY = ORIGINAL_STDOUT_ISTTY;
+    process.stdin.isTTY = ORIGINAL_STDIN_ISTTY;
+  });
+
+  afterEach(() => {
+    process.stdout.isTTY = ORIGINAL_STDOUT_ISTTY;
+    process.stdin.isTTY = ORIGINAL_STDIN_ISTTY;
+  });
+
+  return { setIsTTY };
+}

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

@@ -1,18 +1,15 @@
 import { createFetchResult, setMockRawResponse } from "./mock-cfetch";
+import type { NamespaceKeyInfo } from "../../kv";
 
 export function mockKeyListRequest(
   expectedNamespaceId: string,
-  expectedKeys: 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
-  const expectedKeyObjects = expectedKeys.map((name) => ({
-    name,
-    expiration: 123456789,
-    metadata: {},
-  }));
+
   setMockRawResponse(
     "/accounts/:accountId/storage/kv/namespaces/:namespaceId/keys",
     "GET",
@@ -20,19 +17,15 @@ export function mockKeyListRequest(
       requests.count++;
       expect(accountId).toEqual("some-account-id");
       expect(namespaceId).toEqual(expectedNamespaceId);
-      if (expectedKeyObjects.length <= keysPerRequest) {
-        return createFetchResult(expectedKeyObjects);
+      if (expectedKeys.length <= keysPerRequest) {
+        return createFetchResult(expectedKeys);
       } else {
         const start = parseInt(query.get("cursor") ?? "0") || 0;
         const end = start + keysPerRequest;
-        const cursor = end < expectedKeyObjects.length ? end : blankCursorValue;
-        return createFetchResult(
-          expectedKeyObjects.slice(start, end),
-          true,
-          [],
-          [],
-          { cursor }
-        );
+        const cursor = end < expectedKeys.length ? end : blankCursorValue;
+        return createFetchResult(expectedKeys.slice(start, end), true, [], [], {
+          cursor,
+        });
       }
     }
   );