wrangler 0.0.0-ece06ea → 0.0.0-ef13735

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

@@ -0,0 +1,56 @@
+/**
+ * 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 normalizeSlashes(stripTimings(logSpy.mock.calls.flat(2).join("\n")));
+  },
+  get err() {
+    return normalizeSlashes(
+      stripTimings(errorSpy.mock.calls.flat(2).join("\n"))
+    );
+  },
+  get warn() {
+    return normalizeSlashes(
+      stripTimings(warnSpy.mock.calls.flat(2).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)");
+}

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,40 @@
+import { createFetchResult, setMockRawResponse } from "./mock-cfetch";
+
+export function mockKeyListRequest(
+  expectedNamespaceId: string,
+  expectedKeys: string[],
+  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",
+    ([_url, accountId, namespaceId], _init, query) => {
+      requests.count++;
+      expect(accountId).toEqual("some-account-id");
+      expect(namespaceId).toEqual(expectedNamespaceId);
+      if (expectedKeyObjects.length <= keysPerRequest) {
+        return createFetchResult(expectedKeyObjects);
+      } 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 }
+        );
+      }
+    }
+  );
+  return requests;
+}

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

@@ -0,0 +1,27 @@
+import { mkdirSync, writeFileSync } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+
+export function writeUserConfig(
+  oauth_token?: string,
+  refresh_token?: string,
+  expiration_time?: string
+) {
+  const lines: string[] = [];
+  if (oauth_token) {
+    lines.push(`oauth_token = "${oauth_token}"`);
+  }
+  if (refresh_token) {
+    lines.push(`refresh_token = "${refresh_token}"`);
+  }
+  if (expiration_time) {
+    lines.push(`expiration_time = "${expiration_time}"`);
+  }
+  const configPath = path.join(os.homedir(), ".wrangler/config");
+  mkdirSync(configPath, { recursive: true });
+  writeFileSync(
+    path.join(configPath, "default.toml"),
+    lines.join("\n"),
+    "utf-8"
+  );
+}

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

@@ -0,0 +1,29 @@
+import * as fs from "node:fs";
+import os from "node:os";
+import * as path from "node:path";
+
+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);
+    }
+  });
+
+  afterEach(() => {
+    process.chdir(originalCwd);
+    fs.rmSync(tmpDir, { recursive: true });
+  });
+}

package/src/__tests__/helpers/run-wrangler.ts

@@ -0,0 +1,14 @@
+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 (e) {
+    e.message = normalizeSlashes(stripTimings(e.message));
+    throw e;
+  }
+}