wrangler 0.0.0-fb43821 → 0.0.0-fb53fda

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

@@ -0,0 +1,207 @@
+import { URL, URLSearchParams } from "node:url";
+import { pathToRegexp } from "path-to-regexp";
+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.
+ */
+export type MockHandler<ResponseType> = (
+  uri: RegExpExecArray,
+  init: RequestInit,
+  queryParams: URLSearchParams
+) => ResponseType | Promise<ResponseType>;
+
+type RemoveMockFn = () => void;
+
+interface MockFetch<ResponseType> {
+  regexp: RegExp;
+  method: string | undefined;
+  handler: MockHandler<ResponseType>;
+}
+const mocks: MockFetch<unknown>[] = [];
+
+/**
+ * The mock implementation of `cfApi.fetch()`.
+ *
+ * This function will attempt to match the given request to one of the mock handlers configured by calls to `setMock`.
+ *
+ * Once found the handler will be used to generate a mock response.
+ */
+export async function mockFetchInternal(
+  resource: string,
+  init: RequestInit = {},
+  queryParams: URLSearchParams = new URLSearchParams()
+) {
+  for (const { regexp, method, handler } of mocks) {
+    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 await handler(uri, init, queryParams); // TODO: should we have some kind of fallthrough system? we'll see.
+    }
+  }
+  throw new Error(
+    `no mocks found for ${init.method ?? "any HTTP"} request to ${resource}`
+  );
+}
+
+/**
+ * Specify an expected resource path that is to be handled, resulting in a raw JSON response.
+ *
+ * @param resource The path of the resource to be matched.
+ * This can include wildcards whose value will be passed to the `handler`.
+ * @param handler The function that will generate the mock response for this request.
+ */
+export function setMockRawResponse<ResponseType>(
+  resource: string,
+  handler: MockHandler<ResponseType>
+): RemoveMockFn;
+/**
+ * Specify an expected resource path that is to be handled, resulting in a raw JSON response.
+ *
+ * @param resource The path of the resource to be matched.
+ * This can include wildcards whose value will be passed to the `handler`.
+ * @param method The HTTP method (e.g. GET, POST, etc) that the request must have to match this mock handler.
+ * @param handler The function that will generate the mock response for this request.
+ */
+export function setMockRawResponse<ResponseType>(
+  resource: string,
+  method: string,
+  handler: MockHandler<ResponseType>
+): RemoveMockFn;
+/**
+ * Specify an expected resource path that is to be handled, resulting in a raw JSON response.
+ */
+export function setMockRawResponse<ResponseType>(
+  resource: string,
+  ...args: [string, MockHandler<ResponseType>] | [MockHandler<ResponseType>]
+): RemoveMockFn {
+  const handler = args.pop() as MockHandler<ResponseType>;
+  const method = args.pop() as string;
+  const mock = {
+    resource,
+    method,
+    handler,
+    regexp: pathToRegexp(resource),
+  };
+  mocks.push(mock);
+  return () => {
+    const mockIndex = mocks.indexOf(mock);
+    if (mockIndex !== -1) {
+      mocks.splice(mockIndex, 1);
+    }
+  };
+}
+
+/**
+ * Specify an expected resource path that is to be handled, resulting in a `FetchRequest`.
+ *
+ * The mock `handler` should return the `result`, which will then be wrapped in a `FetchRequest` object.
+ *
+ * @param resource The path of the resource to be matched.
+ * This can include wildcards whose value will be passed to the `handler`.
+ * @param handler The function that will generate the mock response for this request.
+ */
+export function setMockResponse<ResponseType>(
+  resource: string,
+  handler: MockHandler<ResponseType>
+): RemoveMockFn;
+/**
+ * Specify an expected resource path that is to be handled, resulting in a FetchRequest..
+ *
+ * @param resource The path of the resource to be matched.
+ * This can include wildcards whose value will be passed to the `handler`.
+ * @param method The HTTP method (e.g. GET, POST, etc) that the request must have to match this mock handler.
+ * @param handler The function that will generate the mock response for this request.
+ */
+export function setMockResponse<ResponseType>(
+  resource: string,
+  method: string,
+  handler: MockHandler<ResponseType>
+): RemoveMockFn;
+/**
+ * Specify an expected resource path that is to be handled, resulting in a FetchRequest.
+ */
+export function setMockResponse<ResponseType>(
+  resource: string,
+  ...args: [string, MockHandler<ResponseType>] | [MockHandler<ResponseType>]
+): RemoveMockFn {
+  const handler = args.pop() as MockHandler<ResponseType>;
+  const method = args.pop() as string;
+  return setMockRawResponse(resource, method, (...handlerArgs) =>
+    createFetchResult(handler(...handlerArgs))
+  );
+}
+
+/**
+ * A helper to make it easier to create `FetchResult` objects in tests.
+ */
+export async function createFetchResult<ResponseType>(
+  result: ResponseType | Promise<ResponseType>,
+  success = true,
+  errors: FetchError[] = [],
+  messages: string[] = [],
+  result_info?: unknown
+): Promise<FetchResult<ResponseType>> {
+  return result_info
+    ? {
+        result: await result,
+        success,
+        errors,
+        messages,
+        result_info,
+      }
+    : {
+        result: await result,
+        success,
+        errors,
+        messages,
+      };
+}
+
+/**
+ * Remove all the configured mock handlers.
+ *
+ * This should be called in an `afterEach()` block to ensure that mock handlers do not leak between tests.
+ */
+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__/helpers/mock-dialogs.ts

@@ -0,0 +1,65 @@
+import { confirm, prompt } from "../../dialogs";
+
+/**
+ * The expected values for a confirmation request.
+ */
+export interface ConfirmExpectation {
+  /** The text expected to be seen in the confirmation dialog. */
+  text: string;
+  /** The mock response send back from the confirmation dialog. */
+  result: boolean;
+}
+
+/**
+ * Mock the implementation of `confirm()` that will respond with configured results
+ * for configured confirmation text messages.
+ *
+ * If there is a call to `confirm()` that does not match any of the expectations
+ * then an error is thrown.
+ */
+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);
+      }
+    }
+    throw new Error(`Unexpected confirmation message: ${text}`);
+  });
+}
+
+/**
+ * The expected values for a prompt request.
+ */
+export interface PromptExpectation {
+  /** The text expected to be seen in the prompt dialog. */
+  text: string;
+  /** The type of the prompt. */
+  type: "text" | "password";
+  /** The mock response send back from the prompt dialog. */
+  result: string;
+}
+
+/**
+ * Mock the implementation of `prompt()` that will respond with configured results
+ * for configured prompt text messages.
+ *
+ * If there is a call to `prompt()` that does not match any of the expectations
+ * then an error is thrown.
+ */
+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);
+        }
+      }
+      throw new Error(`Unexpected confirmation message: ${text}`);
+    }
+  );
+}

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();
+  }
+}

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

@@ -0,0 +1,32 @@
+import * as fs from "node:fs";
+import os from "node:os";
+import * as path from "node:path";
+import { reinitialiseAuthTokens } from "../../user";
+
+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);
+      // Now that we have changed the home directory location, we must reinitialize the user auth state
+      reinitialiseAuthTokens();
+    }
+  });
+
+  afterEach(() => {
+    process.chdir(originalCwd);
+    fs.rmSync(tmpDir, { recursive: true });
+  });
+}

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

@@ -0,0 +1,16 @@
+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 (err) {
+    if (err instanceof Error) {
+      err.message = normalizeSlashes(stripTimings(err.message));
+    }
+    throw err;
+  }
+}

package/src/__tests__/helpers/write-wrangler-toml.ts

@@ -0,0 +1,17 @@
+import * as fs from "fs";
+import TOML from "@iarna/toml";
+import type { RawConfig } from "../../config";
+
+/** Write a mock wrangler.toml file to disk. */
+export default function writeWranglerToml(config: RawConfig = {}) {
+  fs.writeFileSync(
+    "./wrangler.toml",
+    TOML.stringify({
+      compatibility_date: "2022-01-12",
+      name: "test-name",
+      ...(config as TOML.JsonMap),
+    }),
+
+    "utf-8"
+  );
+}