wrangler 0.0.0-ece06ea → 0.0.0-ed08df4

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/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,39 @@
+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);
+    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-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__/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"
+  );
+}

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

@@ -0,0 +1,130 @@
+import fs from "node:fs";
+import os from "node:os";
+import { resolve } from "node:path";
+import { getHttpsOptions } from "../https-options";
+import { mockConsoleMethods } from "./helpers/mock-console";
+import { runInTempDir } from "./helpers/run-in-tmp";
+
+describe("getHttpsOptions()", () => {
+  runInTempDir({ homedir: "./home" });
+  const std = mockConsoleMethods();
+
+  it("should use cached values if they have not expired", async () => {
+    fs.mkdirSync(resolve(os.homedir(), ".wrangler/local-cert"), {
+      recursive: true,
+    });
+    fs.writeFileSync(
+      resolve(os.homedir(), ".wrangler/local-cert/key.pem"),
+      "PRIVATE KEY"
+    );
+    fs.writeFileSync(
+      resolve(os.homedir(), ".wrangler/local-cert/cert.pem"),
+      "PUBLIC KEY"
+    );
+    const result = await getHttpsOptions();
+    expect(result.key).toEqual("PRIVATE KEY");
+    expect(result.cert).toEqual("PUBLIC KEY");
+    expect(std.out).toMatchInlineSnapshot(`""`);
+    expect(std.warn).toMatchInlineSnapshot(`""`);
+    expect(std.err).toMatchInlineSnapshot(`""`);
+  });
+
+  it("should generate and cache new keys if none are cached", async () => {
+    const result = await getHttpsOptions();
+    const key = fs.readFileSync(
+      resolve(os.homedir(), ".wrangler/local-cert/key.pem"),
+      "utf8"
+    );
+    const cert = fs.readFileSync(
+      resolve(os.homedir(), ".wrangler/local-cert/cert.pem"),
+      "utf8"
+    );
+    expect(result.key).toEqual(key);
+    expect(result.cert).toEqual(cert);
+    expect(std.out).toMatchInlineSnapshot(
+      `"Generating new self-signed certificate..."`
+    );
+    expect(std.warn).toMatchInlineSnapshot(`""`);
+    expect(std.err).toMatchInlineSnapshot(`""`);
+  });
+
+  it("should generate and cache new keys if cached files have expired", async () => {
+    fs.mkdirSync(resolve(os.homedir(), ".wrangler/local-cert"), {
+      recursive: true,
+    });
+    const ORIGINAL_KEY = "EXPIRED PRIVATE KEY";
+    const ORIGINAL_CERT = "EXPIRED PUBLIC KEY";
+    fs.writeFileSync(
+      resolve(os.homedir(), ".wrangler/local-cert/key.pem"),
+      ORIGINAL_KEY
+    );
+    fs.writeFileSync(
+      resolve(os.homedir(), ".wrangler/local-cert/cert.pem"),
+      ORIGINAL_CERT
+    );
+    mockStatSync(/\.pem$/, { mtimeMs: new Date(2000).valueOf() });
+
+    const result = await getHttpsOptions();
+    const key = fs.readFileSync(
+      resolve(os.homedir(), ".wrangler/local-cert/key.pem"),
+      "utf8"
+    );
+    const cert = fs.readFileSync(
+      resolve(os.homedir(), ".wrangler/local-cert/cert.pem"),
+      "utf8"
+    );
+    expect(key).not.toEqual(ORIGINAL_KEY);
+    expect(cert).not.toEqual(ORIGINAL_CERT);
+    expect(result.key).toEqual(key);
+    expect(result.cert).toEqual(cert);
+    expect(std.out).toMatchInlineSnapshot(
+      `"Generating new self-signed certificate..."`
+    );
+    expect(std.warn).toMatchInlineSnapshot(`""`);
+    expect(std.err).toMatchInlineSnapshot(`""`);
+  });
+
+  it("should warn if not able to write to the cache", async () => {
+    mockWriteFileSyncThrow(/\.pem$/);
+    await getHttpsOptions();
+    expect(
+      fs.existsSync(resolve(os.homedir(), ".wrangler/local-cert/key.pem"))
+    ).toBe(false);
+    expect(
+      fs.existsSync(resolve(os.homedir(), ".wrangler/local-cert/cert.pem"))
+    ).toBe(false);
+    expect(std.out).toMatchInlineSnapshot(
+      `"Generating new self-signed certificate..."`
+    );
+    expect(std.warn).toMatchInlineSnapshot(`
+      "▲ [WARNING] Unable to cache generated self-signed certificate in home/.wrangler/local-cert.
+
+        ERROR: Cannot write file
+
+      "
+    `);
+    expect(std.err).toMatchInlineSnapshot(`""`);
+  });
+});
+
+function mockStatSync(matcher: RegExp, stats: Partial<fs.Stats>) {
+  const originalStatSync = jest.requireActual("node:fs").statSync;
+  jest.spyOn(fs, "statSync").mockImplementation((statPath, options) => {
+    return matcher.test(statPath.toString())
+      ? (stats as fs.Stats)
+      : originalStatSync(statPath, options);
+  });
+}
+
+function mockWriteFileSyncThrow(matcher: RegExp) {
+  const originalWriteFileSync = jest.requireActual("node:fs").writeFileSync;
+  jest
+    .spyOn(fs, "writeFileSync")
+    .mockImplementation((filePath, data, options) => {
+      if (matcher.test(filePath.toString())) {
+        throw new Error("ERROR: Cannot write file");
+      } else {
+        return originalWriteFileSync(filePath, data, options);
+      }
+    });
+}