wrangler 0.0.0-ece06ea → 0.0.0-ed4f2ef

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__/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-oauth-flow.ts

@@ -0,0 +1,178 @@
+import { ChildProcess } from "child_process";
+import fetchMock from "jest-fetch-mock";
+import { Request } from "undici";
+const { fetch } = jest.requireActual("undici") as {
+  fetch: (input: string) => Promise<unknown>;
+};
+
+// the response to send when wrangler wants an oauth grant
+let oauthGrantResponse: GrantResponseOptions | "timeout" = {};
+
+/**
+ * A mock implementation for `openInBrowser` that sends an oauth grant response
+ * to wrangler. Use it like this:
+ *
+ * ```js
+ * jest.mock("../open-in-browser");
+ * (openInBrowser as jest.Mock).mockImplementation(mockOpenInBrowser);
+ * ```
+ */
+export const mockOpenInBrowser = async (url: string, ..._args: unknown[]) => {
+  const { searchParams } = new URL(url);
+  if (oauthGrantResponse === "timeout") {
+    throw "unimplemented";
+  } else {
+    const queryParams = toQueryParams(oauthGrantResponse, searchParams);
+    // don't await this -- it will block the rest of the login flow
+    fetch(`${searchParams.get("redirect_uri")}?${queryParams}`).catch((e) => {
+      throw new Error(
+        "Failed to send OAuth Grant to wrangler, maybe the server was closed?",
+        e as Error
+      );
+    });
+    return new ChildProcess();
+  }
+};
+
+/**
+ * Functions to help with mocking various parts of the OAuth Flow
+ */
+export const mockOAuthFlow = () => {
+  afterEach(() => {
+    fetchMock.resetMocks();
+  });
+
+  const mockGrantAuthorization = ({
+    respondWith,
+  }: {
+    respondWith: "timeout" | "success" | "failure" | GrantResponseOptions;
+  }) => {
+    if (respondWith === "failure") {
+      oauthGrantResponse = {
+        error: "access_denied",
+      };
+    } else if (respondWith === "success") {
+      oauthGrantResponse = {
+        code: "test-oauth-code",
+      };
+    } else if (respondWith === "timeout") {
+      oauthGrantResponse = "timeout";
+    } else {
+      oauthGrantResponse = respondWith;
+    }
+  };
+
+  const mockRevokeAuthorization = () => {
+    const outcome = {
+      actual: new Request("https://example.org"),
+      expected: new Request("https://dash.cloudflare.com/oauth2/revoke", {
+        method: "POST",
+      }),
+    };
+
+    fetchMock.mockIf(outcome.expected.url, async (req) => {
+      outcome.actual = req;
+      return "";
+    });
+
+    return outcome;
+  };
+
+  const mockGrantAccessToken = ({
+    respondWith,
+  }: {
+    respondWith: MockTokenResponse;
+  }) => {
+    const outcome = {
+      actual: new Request("https://example.org"),
+      expected: new Request("https://dash.cloudflare.com/oauth2/token", {
+        method: "POST",
+      }),
+    };
+
+    fetchMock.mockOnceIf(outcome.expected.url, async (req) => {
+      outcome.actual = req;
+      return makeTokenResponse(respondWith);
+    });
+
+    return outcome;
+  };
+
+  return {
+    mockGrantAuthorization,
+    mockRevokeAuthorization,
+    mockGrantAccessToken,
+  };
+};
+
+type GrantResponseOptions = {
+  code?: string;
+  error?: ErrorType | ErrorType[];
+};
+
+const toQueryParams = (
+  { code, error }: GrantResponseOptions,
+  wranglerRequestParams: URLSearchParams
+): string => {
+  const queryParams = [];
+  if (code) {
+    queryParams.push(`code=${code}`);
+  }
+  if (error) {
+    const stringifiedErr = Array.isArray(error) ? error.join(",") : error;
+    queryParams.push(`error=${stringifiedErr}`);
+  }
+
+  queryParams.push(`state=${wranglerRequestParams.get("state")}`);
+
+  return queryParams.join("&");
+};
+
+type ErrorType =
+  | "invalid_request"
+  | "invalid_grant"
+  | "unauthorized_client"
+  | "access_denied"
+  | "unsupported_response_type"
+  | "invalid_scope"
+  | "server_error"
+  | "temporarily_unavailable"
+  | "invalid_client"
+  | "unsupported_grant_type"
+  | "invalid_json"
+  | "invalid_token"
+  | "test-token-grant-error";
+
+type MockTokenResponse =
+  | "ok"
+  | "error"
+  | {
+      access_token: string;
+      expires_in: number;
+      refresh_token: string;
+      scope: string;
+    }
+  | {
+      error: ErrorType;
+    };
+
+const makeTokenResponse = (partialResponse: MockTokenResponse): string => {
+  let fullResponse: MockTokenResponse;
+
+  if (partialResponse === "ok") {
+    fullResponse = {
+      access_token: "test-access-token",
+      expires_in: 100000,
+      refresh_token: "test-refresh-token",
+      scope: "account:read",
+    };
+  } else if (partialResponse === "error") {
+    fullResponse = {
+      error: "test-token-grant-error",
+    };
+  } else {
+    fullResponse = partialResponse;
+  }
+
+  return JSON.stringify(fullResponse);
+};