wrangler 0.0.0-ece06ea → 0.0.0-ed4f2ef

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

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

@@ -0,0 +1,127 @@
+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(`
+      "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);
+      }
+    });
+}