wrangler 0.0.0-e928f94 → 0.0.0-e9307365

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

@@ -0,0 +1,153 @@
+import { confirm, prompt, select } from "../../dialogs";
+import { normalizeSlashes } from "./mock-console";
+
+/**
+ * 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 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")
+			);
+		}
+	};
+}
+
+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.`
+		);
+	});
+}
+
+/**
+ * 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 expectation of expectations) {
+				if (text === expectation.text && type == expectation.type) {
+					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 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.`
+		);
+	});
+}
+
+/**
+ * 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;
+}
+
+/**
+ * Mock the implementation of `select()` that will respond with configured results
+ * for configured select text messages.
+ *
+ * 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);
+			}
+		}
+		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.`
+		);
+	});
+}

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

@@ -0,0 +1,46 @@
+import http from "node:http";
+import type { Request } from "undici";
+
+/**
+ * Setup a mock HTTP server that can be triggered directly without interacting with any network.
+ *
+ * @returns a `fetch`-like function that will trigger the mock server to handle the request.
+ */
+export function mockHttpServer() {
+	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;
+			});
+	});
+
+	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 `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?.();
+
+		return resp;
+	};
+}

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

@@ -0,0 +1,74 @@
+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 (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(() => {
+		Object.defineProperty(process, "stdout", { value: ORIGINAL_STDOUT });
+		Object.defineProperty(process, "stdin", { value: ORIGINAL_STDIN });
+	});
+
+	afterEach(() => {
+		Object.defineProperty(process, "stdout", { value: ORIGINAL_STDOUT });
+		Object.defineProperty(process, "stdin", { value: ORIGINAL_STDIN });
+	});
+
+	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-kv.ts

@@ -0,0 +1,33 @@
+import { createFetchResult, setMockRawResponse } from "./mock-cfetch";
+import type { NamespaceKeyInfo } from "../../kv";
+
+export function mockKeyListRequest(
+	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
+
+	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;
+}

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

@@ -0,0 +1,250 @@
+import fetchMock from "jest-fetch-mock";
+import { Request } from "undici";
+import openInBrowser from "../../open-in-browser";
+import {
+	createFetchResult,
+	setMockRawResponse,
+	setMockResponse,
+} from "./mock-cfetch";
+import { mockHttpServer } from "./mock-http-server";
+
+export function mockGetMemberships(
+	accounts: { id: string; account: { id: string; name: string } }[]
+) {
+	setMockResponse("/memberships", "GET", () => {
+		return accounts;
+	});
+}
+
+export function mockGetMembershipsFail() {
+	setMockRawResponse("/memberships", () => {
+		return 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 = () => {
+	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 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 {
+		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-process.ts

@@ -0,0 +1,39 @@
+/**
+ * We use this module to mock process methods (write only for now),
+ * and optionally assert on the values they're called with in our tests.
+ */
+
+let writeSpy: jest.SpyInstance;
+
+function captureLastWriteCall(spy: jest.SpyInstance): Buffer {
+	const calls = spy.mock.calls;
+	if (calls.length > 1) {
+		throw new Error(
+			"Unexpected calls to `stdout.write()`: " + JSON.stringify(calls)
+		);
+	}
+	const buffer = calls[0]?.[0] ?? Buffer.alloc(0);
+	if (buffer instanceof Buffer) {
+		return buffer;
+	} else {
+		throw new Error(
+			`Unexpected non-Buffer passed to \`stdout.write()\`: "${JSON.stringify(
+				buffer
+			)}"`
+		);
+	}
+}
+
+export function mockProcess() {
+	beforeEach(() => {
+		writeSpy = jest.spyOn(process.stdout, "write").mockImplementation();
+	});
+	afterEach(() => {
+		writeSpy.mockRestore();
+	});
+	return {
+		get write() {
+			return captureLastWriteCall(writeSpy);
+		},
+	};
+}

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

@@ -0,0 +1,108 @@
+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;
+	}
+
+	/**
+	 * Used by Ink.js to set the encoding of the stdout.
+	 */
+	setEncoding() {}
+}