wrangler 0.0.0-e95bea2 → 0.0.0-e95e5a0

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

@@ -1,15 +1,20 @@
 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 normalizeOutput(logSpy);
   },
@@ -22,8 +27,8 @@ const std = {
 };
 
 function normalizeOutput(spy: jest.SpyInstance): string {
-  return stripTrailingWhitespace(
-    normalizeSlashes(stripTimings(captureCalls(spy)))
+  return normalizeErrorMarkers(
+    stripTrailingWhitespace(normalizeSlashes(stripTimings(captureCalls(spy))))
   );
 }
 
@@ -35,11 +40,14 @@ function captureCalls(spy: jest.SpyInstance): string {
 
 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();
@@ -47,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.
  *

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

@@ -1,4 +1,5 @@
 import { confirm, prompt } from "../../dialogs";
+import { normalizeSlashes } from "./mock-console";
 
 /**
  * The expected values for a confirmation request.
@@ -20,7 +21,7 @@ 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) {
+      if (normalizeSlashes(text) === normalizeSlashes(expectedText)) {
         return Promise.resolve(result);
       }
     }
@@ -28,6 +29,18 @@ export function mockConfirm(...expectations: ConfirmExpectation[]) {
   });
 }
 
+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.`
+    );
+  });
+}
+
 /**
  * The expected values for a prompt request.
  */
@@ -63,3 +76,15 @@ export function mockPrompt(...expectations: PromptExpectation[]) {
     }
   );
 }
+
+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.`
+    );
+  });
+}

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

package/src/__tests__/helpers/mock-oauth-flow.ts

@@ -0,0 +1,255 @@
+import fetchMock from "jest-fetch-mock";
+import { Request } from "undici";
+import { getCloudflareApiBaseUrl } from "../../cfetch";
+import openInBrowser from "../../open-in-browser";
+import { mockHttpServer } from "./mock-http-server";
+
+// the response to send when wrangler wants an oauth grant
+let oauthGrantResponse: GrantResponseOptions | "timeout" = {};
+
+/**
+ * Functions to help with mocking various parts of the OAuth Flow
+ */
+export const mockOAuthFlow = () => {
+  const fetchHttp = mockHttpServer();
+
+  afterEach(() => {
+    fetchMock.resetMocks();
+  });
+
+  /**
+   * Mock out the callback from a browser to our HttpServer.
+   *
+   * This function will override `openInBrowser()` so that instead of opening a browser window
+   * at the OAuth URL, it will automatically trigger the callback URL on the mock HttpServer that
+   * we have created as part of the call to `mockOAuthFlow()`.
+   */
+  const mockOAuthServerCallback = () => {
+    (
+      openInBrowser as jest.MockedFunction<typeof openInBrowser>
+    ).mockImplementation(async (url: string) => {
+      // We don't support the grant response timing out.
+      if (oauthGrantResponse === "timeout") {
+        throw "unimplemented";
+      }
+
+      // Create a fake callback request that would be created by the OAuth server
+      const { searchParams } = new URL(url);
+      const queryParams = toQueryParams(oauthGrantResponse, searchParams);
+      const request = new Request(
+        `${searchParams.get("redirect_uri")}?${queryParams}`
+      );
+
+      // Trigger the mock HttpServer to handle this fake request to continue the OAuth flow.
+      fetchHttp(request).catch((e) => {
+        throw new Error(
+          "Failed to send OAuth Grant to wrangler, maybe the server was closed?",
+          e as Error
+        );
+      });
+    });
+  };
+
+  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 mockGetMemberships = (args: {
+    success: boolean;
+    result: { id: string; account: { id: string; name: string } }[];
+  }) => {
+    const outcome = {
+      actual: new Request("https://example.org"),
+      expected: new Request(`${getCloudflareApiBaseUrl()}/memberships`, {
+        method: "GET",
+      }),
+    };
+
+    fetchMock.mockIf(outcome.expected.url, async (req) => {
+      outcome.actual = req;
+      return {
+        status: 200,
+        body: JSON.stringify(args),
+      };
+    });
+
+    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;
+  };
+
+  const mockExchangeRefreshTokenForAccessToken = ({
+    respondWith,
+  }: {
+    respondWith: "refreshSuccess" | "refreshError" | "badResponse";
+  }) => {
+    fetchMock.mockOnceIf(
+      "https://dash.cloudflare.com/oauth2/token",
+      async () => {
+        switch (respondWith) {
+          case "refreshSuccess":
+            return {
+              status: 200,
+              body: JSON.stringify({
+                access_token: "access_token_success_mock",
+                expires_in: 1701,
+                refresh_token: "refresh_token_sucess_mock",
+                scope: "scope_success_mock",
+                token_type: "bearer",
+              }),
+            };
+          case "refreshError":
+            return {
+              status: 400,
+              body: JSON.stringify({
+                error: "invalid_request",
+                error_description: "error_description_mock",
+                error_hint: "error_hint_mock",
+                error_verbose: "error_verbose_mock",
+                status_code: 400,
+              }),
+            };
+          case "badResponse":
+            return {
+              status: 400,
+              body: `<html> <body> This shouldn't be sent, but should be handled </body> </html>`,
+            };
+
+          default:
+            return "Not a respondWith option for `mockExchangeRefreshTokenForAccessToken`";
+        }
+      }
+    );
+  };
+
+  return {
+    mockGetMemberships,
+    mockGrantAccessToken,
+    mockGrantAuthorization,
+    mockOAuthServerCallback,
+    mockRevokeAuthorization,
+    mockExchangeRefreshTokenForAccessToken,
+  };
+};
+
+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);
+};

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

@@ -1,12 +1,20 @@
 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;
 
+  beforeAll(() => {
+    if (tmpDir !== undefined) {
+      process.chdir(originalCwd);
+      fs.rmSync(tmpDir, { recursive: true });
+    }
+  });
+
   beforeEach(() => {
     tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "wrangler-tests"));
     process.chdir(tmpDir);
@@ -19,6 +27,8 @@ export function runInTempDir({ homedir }: { homedir?: string } = {}) {
       // 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();
     }
   });
 

package/src/__tests__/helpers/write-worker-source.ts

@@ -0,0 +1,31 @@
+import fs from "node:fs";
+
+/** Write a mock Worker script to disk. */
+export function writeWorkerSource({
+  basePath = ".",
+  format = "js",
+  type = "esm",
+}: {
+  basePath?: string;
+  format?: "js" | "ts" | "jsx" | "tsx" | "mjs";
+  type?: "esm" | "sw";
+} = {}) {
+  if (basePath !== ".") {
+    fs.mkdirSync(basePath, { recursive: true });
+  }
+  fs.writeFileSync(
+    `${basePath}/index.${format}`,
+    type === "esm"
+      ? `import { foo } from "./another";
+      export default {
+        async fetch(request) {
+          return new Response('Hello' + foo);
+        },
+      };`
+      : `import { foo } from "./another";
+      addEventListener('fetch', event => {
+        event.respondWith(new Response('Hello' + foo));
+      })`
+  );
+  fs.writeFileSync(`${basePath}/another.${format}`, `export const foo = 100;`);
+}

package/src/__tests__/https-options.test.ts

@@ -97,8 +97,11 @@ describe("getHttpsOptions()", () => {
       `"Generating new self-signed certificate..."`
     );
     expect(std.warn).toMatchInlineSnapshot(`
-      "Unable to cache generated self-signed certificate in home/.wrangler/local-cert.
-      ERROR: Cannot write file"
+      "▲ [WARNING] Unable to cache generated self-signed certificate in home/.wrangler/local-cert.
+
+        ERROR: Cannot write file
+
+      "
     `);
     expect(std.err).toMatchInlineSnapshot(`""`);
   });