wrangler 0.0.0-e464fcdb → 0.0.0-e4abed3e

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

@@ -1,139 +0,0 @@
-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;
-
-	options?: { defaultValue: boolean };
-	/** 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[]) {
-	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);
-				}
-
-				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. */
-	options?: {
-		defaultValue?: string;
-		isSecret?: boolean;
-	};
-	/** 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[]) {
-	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 });
-			}
-		);
-	}
-}
-
-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<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;
-}
-
-/**
- * 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<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 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

@@ -1,25 +0,0 @@
-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,11 +0,0 @@
-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

@@ -1,46 +0,0 @@
-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

@@ -1,74 +0,0 @@
-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-known-routes.ts

@@ -1,12 +0,0 @@
-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,46 +0,0 @@
-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
-) {
-	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;
-				}
-
-				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;
-}

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

@@ -1,263 +0,0 @@
-import { rest } from "msw";
-import { Request } from "undici";
-import openInBrowser from "../../open-in-browser";
-import { mockHttpServer } from "./mock-http-server";
-import { createFetchResult, msw } from "./msw";
-
-export function mockGetMemberships(
-	accounts: { id: string; account: { id: string; name: string } }[]
-) {
-	msw.use(
-		rest.get("*/memberships", (_, res, ctx) => {
-			return res.once(ctx.json(createFetchResult(accounts)));
-		})
-	);
-}
-export function mockGetMembershipsFail() {
-	msw.use(
-		rest.get("*/memberships", (_, res, ctx) => {
-			return res.once(ctx.json(createFetchResult([], false)));
-		})
-	);
-}
-
-/**
- * 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();
-
-	/**
-	 * 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 = (
-		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";
-			}
-
-			// 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
-				);
-			});
-		});
-	};
-
-	// Handled in `mockOAuthServerCallback`
-	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 mockGrantAccessToken = ({
-		respondWith,
-		domain = "dash.cloudflare.com",
-	}: {
-		respondWith: MockTokenResponse;
-		domain?: string;
-	}) => {
-		const outcome = {
-			actual: "https://example.org",
-			expected: `https://${domain}/oauth2/token`,
-		};
-		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;
-	};
-
-	function mockDomainUsesAccess({
-		usesAccess,
-		domain = "dash.cloudflare.com",
-	}: {
-		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,
-		mockOAuthServerCallback,
-		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[];
-};
-
-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) => {
-	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 fullResponse;
-};

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

@@ -1,34 +0,0 @@
-/**
- * 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 | undefined {
-	const calls = spy.mock.calls;
-
-	// Loop through and find the buffer in calls
-	// (we don't know the index of the buffer in the calls array)
-	const buffer = calls
-		.map((call) => call[0])
-		.find((call) => call instanceof Buffer);
-
-	if (buffer instanceof Buffer) {
-		return 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-set-timeout.ts

@@ -1,16 +0,0 @@
-let setTimeoutSpy: jest.SpyInstance;
-
-export function mockSetTimeout() {
-	beforeEach(() => {
-		setTimeoutSpy = jest
-			.spyOn(global, "setTimeout")
-			// @ts-expect-error we're using a very simple setTimeout mock here
-			.mockImplementation((fn, _period) => {
-				setImmediate(fn);
-			});
-	});
-
-	afterEach(() => {
-		setTimeoutSpy.mockRestore();
-	});
-}