wrangler 0.0.0-e7a0cd5b → 0.0.0-e87ad068

package/src/__tests__/helpers/mock-auth-domain.ts

@@ -0,0 +1,20 @@
+const ORIGINAL_WRANGLER_AUTH_DOMAIN = process.env.WRANGLER_AUTH_DOMAIN;
+
+/**
+ * Mock the Auth URL domain so that we can control where we attempt to login.
+ *
+ * Note that you can remove any API token from the environment by setting the value to `null`.
+ * This is useful if a higher `describe()` block has already called `mockAuthDomain()`.
+ */
+export function mockAuthDomain({ domain }: { domain: string | null }) {
+	beforeEach(() => {
+		if (domain === null) {
+			delete process.env.WRANGLER_AUTH_DOMAIN;
+		} else {
+			process.env.WRANGLER_AUTH_DOMAIN = domain;
+		}
+	});
+	afterEach(() => {
+		process.env.WRANGLER_AUTH_DOMAIN = ORIGINAL_WRANGLER_AUTH_DOMAIN;
+	});
+}

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

@@ -8,6 +8,7 @@ import { logger } from "../../logger";
 
 let debugSpy: jest.SpyInstance,
 	logSpy: jest.SpyInstance,
+	infoSpy: jest.SpyInstance,
 	errorSpy: jest.SpyInstance,
 	warnSpy: jest.SpyInstance;
 
@@ -18,6 +19,9 @@ const std = {
 	get out() {
 		return normalizeOutput(logSpy);
 	},
+	get info() {
+		return normalizeOutput(infoSpy);
+	},
 	get err() {
 		return normalizeOutput(errorSpy);
 	},
@@ -47,12 +51,14 @@ export function mockConsoleMethods() {
 		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();
 	});

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

@@ -1,5 +1,4 @@
-import { confirm, prompt, select } from "../../dialogs";
-import { normalizeSlashes } from "./mock-console";
+import prompts from "prompts";
 
 /**
  * The expected values for a confirmation request.
@@ -7,6 +6,8 @@ import { normalizeSlashes } from "./mock-console";
 export interface ConfirmExpectation {
 	/** 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,35 +20,22 @@ export interface ConfirmExpectation {
  * then an error is thrown.
  */
 export function mockConfirm(...expectations: ConfirmExpectation[]) {
-	(confirm as jest.Mock).mockImplementation((text: string) => {
-		for (const expectation of expectations) {
-			if (normalizeSlashes(text) === normalizeSlashes(expectation.text)) {
-				expectations = expectations.filter((e) => e !== expectation);
-				return Promise.resolve(expectation.result);
-			}
-		}
-		throw new Error(`Unexpected confirmation message: ${text}`);
-	});
-	return () => {
-		if (expectations.length > 0) {
-			throw new Error(
-				"The following expected confirmation dialogs were not used:\n" +
-					expectations.map((e) => `- "${e.text}"`).join("\n")
-			);
-		}
-	};
-}
+	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 });
+			}
 		);
-	});
+	}
 }
 
 /**
@@ -57,7 +45,10 @@ export interface PromptExpectation {
 	/** The text expected to be seen in the prompt dialog. */
 	text: string;
 	/** The type of the prompt. */
-	type: "text" | "password";
+	options?: {
+		defaultValue?: string;
+		isSecret?: boolean;
+	};
 	/** The mock response send back from the prompt dialog. */
 	result: string;
 }
@@ -70,45 +61,44 @@ 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 expectation of expectations) {
-				if (text === expectation.text && type == expectation.type) {
-					expectations = expectations.filter((e) => e !== expectation);
-					return Promise.resolve(expectation.result);
+	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 });
 			}
-			throw new Error(`Unexpected confirmation message: ${text}`);
-		}
-	);
-	return () => {
-		if (expectations.length > 0) {
-			throw new Error(
-				"The following expected prompt dialogs were not used:\n" +
-					expectations.map((e) => `- "${e.text}"`).join("\n")
-			);
-		}
-	};
+		);
+	}
 }
 
-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 {
+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;
 }
@@ -120,34 +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 expectation of expectations) {
-			if (normalizeSlashes(text) === normalizeSlashes(expectation.text)) {
-				expectations = expectations.filter((e) => e !== expectation);
-				return Promise.resolve(expectation.result);
+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 });
 			}
-		}
-		throw new Error(`Unexpected select message: ${text}`);
-	});
-	return () => {
-		if (expectations.length > 0) {
-			throw new Error(
-				"The following expected select dialogs were not used:\n" +
-					expectations.map((e) => `- "${e.text}"`).join("\n")
-			);
-		}
-	};
+		);
+	}
 }
 
-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

@@ -1,8 +1,11 @@
-import { setMockResponse } from "./mock-cfetch";
+import { rest } from "msw";
+import { msw, createFetchResult } from "./msw";
 
 export function mockGetZoneFromHostRequest(host: string, zone?: string) {
-	setMockResponse("/zones", (_uri, _init, queryParams) => {
-		expect(queryParams.get("name")).toEqual(host);
-		return zone ? [{ id: zone }] : [];
-	});
+	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-known-routes.ts

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

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

@@ -1,4 +1,5 @@
-import { createFetchResult, setMockRawResponse } from "./mock-cfetch";
+import { rest } from "msw";
+import { createFetchResult, msw } from "./msw";
 import type { NamespaceKeyInfo } from "../../kv/helpers";
 
 export function mockKeyListRequest(
@@ -9,25 +10,37 @@ export function mockKeyListRequest(
 ) {
 	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 start = parseInt(req.url.searchParams.get("cursor") ?? "0") || 0;
 				const end = start + keysPerRequest;
 				const cursor = end < expectedKeys.length ? end : blankCursorValue;
-				return createFetchResult(expectedKeys.slice(start, end), true, [], [], {
-					cursor,
-				});
+
+				return res(
+					ctx.json(
+						createFetchResult(
+							response ? response : expectedKeys.slice(start, end),
+							true,
+							[],
+							[],
+							{
+								cursor,
+							}
+						)
+					)
+				);
 			}
-		}
+		)
 	);
 	return requests;
 }

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

@@ -1,40 +1,34 @@
-import fetchMock from "jest-fetch-mock";
+import { rest } from "msw";
 import { Request } from "undici";
 import openInBrowser from "../../open-in-browser";
-import {
-	createFetchResult,
-	setMockRawResponse,
-	setMockResponse,
-} from "./mock-cfetch";
 import { mockHttpServer } from "./mock-http-server";
+import { createFetchResult, msw } from "./msw";
 
 export function mockGetMemberships(
 	accounts: { id: string; account: { id: string; name: string } }[]
 ) {
-	setMockResponse("/memberships", "GET", () => {
-		return accounts;
-	});
+	msw.use(
+		rest.get("*/memberships", (_, res, ctx) => {
+			return res.once(ctx.json(createFetchResult(accounts)));
+		})
+	);
 }
-
 export function mockGetMembershipsFail() {
-	setMockRawResponse("/memberships", () => {
-		return createFetchResult([], false);
-	});
+	msw.use(
+		rest.get("*/memberships", (_, res, ctx) => {
+			return res.once(ctx.json(createFetchResult([], false)));
+		})
+	);
 }
 
-// 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 = () => {
+	// the response to send when wrangler wants an oauth grant
+	let oauthGrantResponse: GrantResponseOptions | "timeout" = {};
 	const fetchHttp = mockHttpServer();
 
-	afterEach(() => {
-		fetchMock.resetMocks();
-	});
-
 	/**
 	 * Mock out the callback from a browser to our HttpServer.
 	 *
@@ -42,10 +36,13 @@ export const mockOAuthFlow = () => {
 	 * 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 = () => {
+	const mockOAuthServerCallback = (
+		respondWith?: "timeout" | "success" | "failure" | GrantResponseOptions
+	) => {
 		(
 			openInBrowser as jest.MockedFunction<typeof openInBrowser>
 		).mockImplementation(async (url: string) => {
+			if (respondWith) mockGrantAuthorization({ respondWith });
 			// We don't support the grant response timing out.
 			if (oauthGrantResponse === "timeout") {
 				throw "unimplemented";
@@ -68,6 +65,7 @@ export const mockOAuthFlow = () => {
 		});
 	};
 
+	// Handled in `mockOAuthServerCallback`
 	const mockGrantAuthorization = ({
 		respondWith,
 	}: {
@@ -88,97 +86,110 @@ export const mockOAuthFlow = () => {
 		}
 	};
 
-	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) => {
-			// TODO: update Miniflare typings to match full undici Request
-			outcome.actual = req as unknown as Request;
-			return "";
-		});
-
-		return outcome;
-	};
-
 	const mockGrantAccessToken = ({
 		respondWith,
+		domain = "dash.cloudflare.com",
 	}: {
 		respondWith: MockTokenResponse;
+		domain?: string;
 	}) => {
 		const outcome = {
-			actual: new Request("https://example.org"),
-			expected: new Request("https://dash.cloudflare.com/oauth2/token", {
-				method: "POST",
-			}),
+			actual: "https://example.org",
+			expected: `https://${domain}/oauth2/token`,
 		};
-
-		fetchMock.mockOnceIf(outcome.expected.url, async (req) => {
-			// TODO: update Miniflare typings to match full undici Request
-			outcome.actual = req as unknown as Request;
-			return makeTokenResponse(respondWith);
-		});
+		msw.use(
+			rest.post(outcome.expected, async (req, res, ctx) => {
+				// TODO: update Miniflare typings to match full undici Request
+				outcome.actual = req.url.toString();
+				return res.once(ctx.json(makeTokenResponse(respondWith)));
+			})
+		);
 
 		return outcome;
 	};
 
-	const mockExchangeRefreshTokenForAccessToken = ({
-		respondWith,
+	function mockDomainUsesAccess({
+		usesAccess,
+		domain = "dash.cloudflare.com",
 	}: {
-		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`";
+		usesAccess: boolean;
+		domain?: string;
+	}) {
+		// If the domain relies upon Cloudflare Access, then a request to the domain
+		// will result in a redirect to the `cloudflareaccess.com` domain.
+		msw.use(
+			rest.get(`https://${domain}/`, (_, res, ctx) => {
+				let status = 200;
+				let headers: Record<string, string> = {
+					"Content-Type": "application/json",
+				};
+				if (usesAccess) {
+					status = 302;
+					headers = { location: "cloudflareaccess.com" };
 				}
-			}
+				return res.once(ctx.status(status), ctx.set(headers));
+			})
 		);
-	};
+	}
 
 	return {
+		mockHttpServer,
+		mockDomainUsesAccess,
 		mockGrantAccessToken,
-		mockGrantAuthorization,
 		mockOAuthServerCallback,
-		mockRevokeAuthorization,
 		mockExchangeRefreshTokenForAccessToken,
 	};
 };
 
+export function mockExchangeRefreshTokenForAccessToken({
+	respondWith,
+	domain = "dash.cloudflare.com",
+}: {
+	respondWith: "refreshSuccess" | "refreshError" | "badResponse";
+	domain?: string;
+}) {
+	msw.use(
+		rest.post(`https://${domain}/oauth2/token`, async (_, res, ctx) => {
+			switch (respondWith) {
+				case "refreshSuccess":
+					return res.once(
+						ctx.status(200),
+						ctx.json({
+							access_token: "access_token_success_mock",
+							expires_in: 1701,
+							refresh_token: "refresh_token_success_mock",
+							scope: "scope_success_mock",
+							token_type: "bearer",
+						})
+					);
+				case "refreshError":
+					return res.once(
+						ctx.status(400),
+						ctx.json({
+							error: "invalid_request",
+							error_description: "error_description_mock",
+							error_hint: "error_hint_mock",
+							error_verbose: "error_verbose_mock",
+							status_code: 400,
+						})
+					);
+				case "badResponse":
+					return res.once(
+						ctx.status(400),
+						ctx.text(
+							`<html> <body> This shouldn't be sent, but should be handled </body> </html>`
+						)
+					);
+
+				default:
+					throw new Error(
+						"Not a respondWith option for `mockExchangeRefreshTokenForAccessToken`"
+					);
+			}
+		})
+	);
+}
+
 type GrantResponseOptions = {
 	code?: string;
 	error?: ErrorType | ErrorType[];
@@ -230,7 +241,7 @@ type MockTokenResponse =
 			error: ErrorType;
 	  };
 
-const makeTokenResponse = (partialResponse: MockTokenResponse): string => {
+const makeTokenResponse = (partialResponse: MockTokenResponse) => {
 	let fullResponse: MockTokenResponse;
 
 	if (partialResponse === "ok") {
@@ -248,5 +259,5 @@ const makeTokenResponse = (partialResponse: MockTokenResponse): string => {
 		fullResponse = partialResponse;
 	}
 
-	return JSON.stringify(fullResponse);
+	return fullResponse;
 };