wrangler 0.0.0-e95e5a0 → 0.0.0-e981d0be5

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

@@ -1,255 +0,0 @@
-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

@@ -1,103 +0,0 @@
-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

@@ -1,29 +0,0 @@
-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

@@ -1,39 +0,0 @@
-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

@@ -1,16 +0,0 @@
-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

@@ -1,31 +0,0 @@
-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

@@ -1,17 +0,0 @@
-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

@@ -1,130 +0,0 @@
-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);
-      }
-    });
-}