wrangler 0.0.0-e64812e → 0.0.0-e665ccc3

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

@@ -7,52 +7,62 @@ import { logger } from "../../logger";
  */
 
 let debugSpy: jest.SpyInstance,
-  logSpy: jest.SpyInstance,
-  errorSpy: jest.SpyInstance,
-  warnSpy: jest.SpyInstance;
+	logSpy: jest.SpyInstance,
+	infoSpy: jest.SpyInstance,
+	errorSpy: jest.SpyInstance,
+	warnSpy: jest.SpyInstance;
 
 const std = {
-  get debug() {
-    return normalizeOutput(debugSpy);
-  },
-  get out() {
-    return normalizeOutput(logSpy);
-  },
-  get err() {
-    return normalizeOutput(errorSpy);
-  },
-  get warn() {
-    return normalizeOutput(warnSpy);
-  },
+	get debug() {
+		return normalizeOutput(debugSpy);
+	},
+	get out() {
+		return normalizeOutput(logSpy);
+	},
+	get info() {
+		return normalizeOutput(infoSpy);
+	},
+	get err() {
+		return normalizeOutput(errorSpy);
+	},
+	get warn() {
+		return normalizeOutput(warnSpy);
+	},
 };
 
 function normalizeOutput(spy: jest.SpyInstance): string {
-  return normalizeErrorMarkers(
-    stripTrailingWhitespace(normalizeSlashes(stripTimings(captureCalls(spy))))
-  );
+	return normalizeErrorMarkers(
+		replaceByte(
+			stripTrailingWhitespace(
+				normalizeSlashes(normalizeTempDirs(stripTimings(captureCalls(spy))))
+			)
+		)
+	);
 }
 
 function captureCalls(spy: jest.SpyInstance): string {
-  return spy.mock.calls
-    .map((args: unknown[]) => util.format("%s", ...args))
-    .join("\n");
+	return spy.mock.calls
+		.map((args: unknown[]) => util.format("%s", ...args))
+		.join("\n");
 }
 
 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();
-  });
-  return std;
+	beforeEach(() => {
+		logger.columns = 100;
+		debugSpy = jest.spyOn(console, "debug").mockImplementation();
+		logSpy = jest.spyOn(console, "log").mockImplementation();
+		infoSpy = jest.spyOn(console, "info").mockImplementation();
+		errorSpy = jest.spyOn(console, "error").mockImplementation();
+		warnSpy = jest.spyOn(console, "warn").mockImplementation();
+	});
+	afterEach(() => {
+		debugSpy.mockRestore();
+		logSpy.mockRestore();
+		infoSpy.mockRestore();
+		errorSpy.mockRestore();
+		warnSpy.mockRestore();
+	});
+	return std;
 }
 
 /**
@@ -61,7 +71,7 @@ export function mockConsoleMethods() {
  * Windows gets a different character.
  */
 function normalizeErrorMarkers(str: string): string {
-  return str.replaceAll("✘", "X");
+	return str.replaceAll("✘", "X");
 }
 
 /**
@@ -70,7 +80,7 @@ function normalizeErrorMarkers(str: string): string {
  * Use this in snapshot tests to be resilient to file-system differences.
  */
 export function normalizeSlashes(str: string): string {
-  return str.replace(/\\/g, "/");
+	return str.replace(/\\/g, "/");
 }
 
 /**
@@ -79,9 +89,24 @@ export function normalizeSlashes(str: string): string {
  * 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)");
+	return stdout.replace(/\(\d+\.\d+ sec\)/g, "(TIMINGS)");
 }
 
 export function stripTrailingWhitespace(str: string): string {
-  return str.replace(/[^\S\n]+\n/g, "\n");
+	return str.replace(/[^\S\n]+\n/g, "\n");
+}
+
+/**
+ * Removing leading kilobit (tenth of a byte) from test output due to
+ * variation causing every few tests the value to change by ± .01
+ */
+function replaceByte(stdout: string): string {
+	return stdout.replaceAll(/\d+\.\d+ KiB/g, "xx KiB");
+}
+
+/**
+ * Temp directories are created with random names, so we replace all comments temp dirs in them
+ */
+export function normalizeTempDirs(stdout: string): string {
+	return stdout.replaceAll(/\/\/.+\/tmp.+/g, "//tmpdir");
 }

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

@@ -1,14 +1,15 @@
-import { confirm, prompt, select } from "../../dialogs";
-import { normalizeSlashes } from "./mock-console";
+import prompts from "prompts";
 
 /**
  * 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;
+	/** The text expected to be seen in the confirmation dialog. */
+	text: string;
+
+	options?: { defaultValue: boolean };
+	/** The mock response send back from the confirmation dialog. */
+	result: boolean;
 }
 
 /**
@@ -19,38 +20,37 @@ export interface ConfirmExpectation {
  * 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 (normalizeSlashes(text) === normalizeSlashes(expectedText)) {
-        return Promise.resolve(result);
-      }
-    }
-    throw new Error(`Unexpected confirmation message: ${text}`);
-  });
-}
+	for (const expectation of expectations) {
+		(prompts as unknown as jest.Mock).mockImplementationOnce(
+			({ type, name, message, initial }) => {
+				expect({ type, name, message }).toStrictEqual({
+					type: "confirm",
+					name: "value",
+					message: expectation.text,
+				});
+				if (expectation.options) {
+					expect(initial).toStrictEqual(expectation.options?.defaultValue);
+				}
 
-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.`
-    );
-  });
+				return Promise.resolve({ value: expectation.result });
+			}
+		);
+	}
 }
 
 /**
  * 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;
+	/** The text expected to be seen in the prompt dialog. */
+	text: string;
+	/** The type of the prompt. */
+	options?: {
+		defaultValue?: string;
+		isSecret?: boolean;
+	};
+	/** The mock response send back from the prompt dialog. */
+	result: string;
 }
 
 /**
@@ -61,42 +61,46 @@ export interface PromptExpectation {
  * 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}`);
-    }
-  );
+	for (const expectation of expectations) {
+		(prompts as unknown as jest.Mock).mockImplementationOnce(
+			({ type, name, message, initial, style }) => {
+				expect({ type, name, message }).toStrictEqual({
+					type: "text",
+					name: "value",
+					message: expectation.text,
+				});
+				if (expectation.options) {
+					expect(initial).toStrictEqual(expectation.options?.defaultValue);
+					expect(style).toStrictEqual(
+						expectation.options?.isSecret ? "password" : "default"
+					);
+				}
+				return Promise.resolve({ value: expectation.result });
+			}
+		);
+	}
 }
 
-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.`
-    );
-  });
+interface SelectOptions<Values> {
+	choices: SelectOption<Values>[];
+	defaultOption?: number;
 }
 
+interface SelectOption<Values> {
+	title: string;
+	description?: string;
+	value: Values;
+}
 /**
  * The expected values for a select request.
  */
-export interface SelectExpectation {
-  /** The text expected to be seen in the select dialog. */
-  text: string;
-  /** The mock response send back from the select dialog. */
-  result: string;
+export interface SelectExpectation<Values> {
+	/** The text expected to be seen in the select dialog. */
+	text: string;
+
+	options?: SelectOptions<Values>;
+	/** The mock response send back from the select dialog. */
+	result: string;
 }
 
 /**
@@ -106,25 +110,30 @@ export interface SelectExpectation {
  * If there is a call to `select()` that does not match any of the expectations
  * then an error is thrown.
  */
-export function mockSelect(...expectations: SelectExpectation[]) {
-  (select as jest.Mock).mockImplementation((text: string) => {
-    for (const { text: expectedText, result } of expectations) {
-      if (normalizeSlashes(text) === normalizeSlashes(expectedText)) {
-        return Promise.resolve(result);
-      }
-    }
-    throw new Error(`Unexpected select message: ${text}`);
-  });
+export function mockSelect<Values>(
+	...expectations: SelectExpectation<Values>[]
+) {
+	for (const expectation of expectations) {
+		(prompts as unknown as jest.Mock).mockImplementationOnce(
+			({ type, name, message, choices, initial }) => {
+				expect({ type, name, message }).toStrictEqual({
+					type: "select",
+					name: "value",
+					message: expectation.text,
+				});
+				if (expectation.options) {
+					expect(choices).toStrictEqual(expectation.options?.choices);
+					expect(initial).toStrictEqual(expectation.options?.defaultOption);
+				}
+				return Promise.resolve({ value: expectation.result });
+			}
+		);
+	}
 }
 
-export function clearSelectMocks() {
-  (select as jest.Mock).mockReset();
-  // Because select was originally a spy, calling mockReset will simply reset
-  // it as a function with no return value (!), so we need to additionally reset
-  // the mock implementation to the one that throws (from jest.setup.js).
-  (select as jest.Mock).mockImplementation((text: string) => {
-    throw new Error(
-      `Unexpected call to \`select("${text}")\`.\nYou should use \`mockSelect()\` to mock calls to \`select()\` with expectations. Search the codebase for \`mockSelect\` to learn more.`
-    );
-  });
+export function clearDialogs() {
+	// No dialog mocks should be left after each test, and so calling the dialog methods should throw
+	expect(() => prompts({ type: "select", name: "unknown" })).toThrow(
+		"Unexpected call to "
+	);
 }

package/src/__tests__/helpers/mock-get-pages-upload-token.ts

@@ -0,0 +1,25 @@
+import { rest } from "msw";
+import { msw } from "./msw";
+
+/**
+ * Mocks the `/accounts/:accountId/pages/projects/:projectName/upload-token` GET request
+ */
+export function mockGetUploadTokenRequest(
+	jwt: string,
+	accountId: string,
+	projectName: string
+) {
+	msw.use(
+		rest.get(
+			`*/accounts/:accountId/pages/projects/${projectName}/upload-token`,
+			(req, res, ctx) => {
+				expect(req.params.accountId).toEqual(accountId);
+
+				return res(
+					ctx.status(200),
+					ctx.json({ success: true, errors: [], messages: [], result: { jwt } })
+				);
+			}
+		)
+	);
+}

package/src/__tests__/helpers/mock-get-zone-from-host.ts

@@ -0,0 +1,11 @@
+import { rest } from "msw";
+import { msw, createFetchResult } from "./msw";
+
+export function mockGetZoneFromHostRequest(host: string, zone?: string) {
+	msw.use(
+		rest.get("*/zones", (req, res, ctx) => {
+			expect(req.url.searchParams.get("name")).toEqual(host);
+			return res(ctx.json(createFetchResult(zone ? [{ id: zone }] : [])));
+		})
+	);
+}

package/src/__tests__/helpers/mock-http-server.ts

@@ -7,40 +7,40 @@ import type { Request } from "undici";
  * @returns a `fetch`-like function that will trigger the mock server to handle the request.
  */
 export function mockHttpServer() {
-  let listener: http.RequestListener;
+	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;
-      });
-  });
+	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
-    );
+	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 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);
+		// 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?.();
+		// Now trigger the end callback.
+		const endCallback = endSpy.mock.calls[0].pop();
+		endCallback?.();
 
-    return resp;
-  };
+		return resp;
+	};
 }

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

@@ -1,27 +1,74 @@
-const ORIGINAL_STDOUT_ISTTY = process.stdout.isTTY;
-const ORIGINAL_STDIN_ISTTY = process.stdin.isTTY;
+const ORIGINAL_STDOUT = process.stdout;
+const ORIGINAL_STDIN = process.stdin;
 
 /**
  * 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;
-  };
+	/**
+	 * Explicitly set `process.stdout.isTTY` to a given value (or to a getter function).
+	 */
+	const setIsTTY = (
+		isTTY:
+			| boolean
+			| { stdin: boolean | (() => boolean); stdout: boolean | (() => boolean) }
+	) => {
+		mockStdStream("stdout", ORIGINAL_STDOUT, isTTY);
+		mockStdStream("stdin", ORIGINAL_STDIN, isTTY);
+	};
 
-  beforeEach(() => {
-    process.stdout.isTTY = ORIGINAL_STDOUT_ISTTY;
-    process.stdin.isTTY = ORIGINAL_STDIN_ISTTY;
-  });
+	beforeEach(() => {
+		Object.defineProperty(process, "stdout", { value: ORIGINAL_STDOUT });
+		Object.defineProperty(process, "stdin", { value: ORIGINAL_STDIN });
+	});
 
-  afterEach(() => {
-    process.stdout.isTTY = ORIGINAL_STDOUT_ISTTY;
-    process.stdin.isTTY = ORIGINAL_STDIN_ISTTY;
-  });
+	afterEach(() => {
+		Object.defineProperty(process, "stdout", { value: ORIGINAL_STDOUT });
+		Object.defineProperty(process, "stdin", { value: ORIGINAL_STDIN });
+	});
 
-  return { setIsTTY };
+	return { setIsTTY };
+}
+
+/**
+ * Create a mock version of the specified stream which overrides `isTTY`
+ * with the given mock responses.
+ *
+ * @param streamName the property name on `process` for the stream to be mocked.
+ * @param originalStream the original stream object from the `process` object to be overridden.
+ * @param isTTY the mock behaviour for the `isTTY` property:
+ *  - boolean or `{ [streamName]: boolean } - use this value for isTTY;
+ *  - { [streamName]: () => boolean } - use this function as a getter for isTTY.
+ */
+function mockStdStream<T extends object>(
+	streamName: "stdout" | "stdin",
+	originalStream: T,
+	isTTY:
+		| boolean
+		| { stdin: boolean | (() => boolean); stdout: boolean | (() => boolean) }
+) {
+	Object.defineProperty(process, streamName, {
+		value: createStdProxy(
+			originalStream,
+			typeof isTTY === "boolean" ? isTTY : isTTY[streamName]
+		),
+	});
+}
+
+/**
+ * Create a proxy wrapper around the given `stream` object that overrides the `isTTY` property.
+ */
+function createStdProxy<T extends object>(
+	stream: T,
+	isTTY: boolean | (() => boolean)
+): T {
+	return new Proxy(stream, {
+		get(target, prop) {
+			return prop === "isTTY"
+				? typeof isTTY === "boolean"
+					? isTTY
+					: isTTY()
+				: target[prop as keyof typeof target];
+		},
+	});
 }

package/src/__tests__/helpers/mock-known-routes.ts

@@ -0,0 +1,12 @@
+import { rest } from "msw";
+import { createFetchResult, msw } from "./msw";
+
+export function mockCollectKnownRoutesRequest(
+	routes: { pattern: string; script: string }[]
+) {
+	msw.use(
+		rest.get(`*/zones/:zoneId/workers/routes`, (_, res, ctx) =>
+			res.once(ctx.json(createFetchResult(routes)))
+		)
+	);
+}

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

@@ -1,33 +1,46 @@
-import { createFetchResult, setMockRawResponse } from "./mock-cfetch";
-import type { NamespaceKeyInfo } from "../../kv";
+import { rest } from "msw";
+import { createFetchResult, msw } from "./msw";
+import type { NamespaceKeyInfo } from "../../kv/helpers";
 
 export function mockKeyListRequest(
-  expectedNamespaceId: string,
-  expectedKeys: NamespaceKeyInfo[],
-  keysPerRequest = 1000,
-  blankCursorValue: "" | undefined | null = undefined
+	expectedNamespaceId: 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 requests = { count: 0 };
+	// See https://api.cloudflare.com/#workers-kv-namespace-list-a-namespace-s-keys
+	msw.use(
+		rest.get(
+			"*/accounts/:accountId/storage/kv/namespaces/:namespaceId/keys",
+			(req, res, ctx) => {
+				requests.count++;
+				expect(req.params.accountId).toEqual("some-account-id");
+				expect(req.params.namespaceId).toEqual(expectedNamespaceId);
+				let response: undefined | NamespaceKeyInfo[];
+				if (expectedKeys.length <= keysPerRequest) {
+					response = expectedKeys;
+				}
 
-  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 (expectedKeys.length <= keysPerRequest) {
-        return createFetchResult(expectedKeys);
-      } else {
-        const start = parseInt(query.get("cursor") ?? "0") || 0;
-        const end = start + keysPerRequest;
-        const cursor = end < expectedKeys.length ? end : blankCursorValue;
-        return createFetchResult(expectedKeys.slice(start, end), true, [], [], {
-          cursor,
-        });
-      }
-    }
-  );
-  return requests;
+				const start = parseInt(req.url.searchParams.get("cursor") ?? "0") || 0;
+				const end = start + keysPerRequest;
+				const cursor = end < expectedKeys.length ? end : blankCursorValue;
+
+				return res(
+					ctx.json(
+						createFetchResult(
+							response ? response : expectedKeys.slice(start, end),
+							true,
+							[],
+							[],
+							{
+								cursor,
+							}
+						)
+					)
+				);
+			}
+		)
+	);
+	return requests;
 }