wrangler 0.0.0-e93063e9 → 0.0.0-e93d240f

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

@@ -1,278 +0,0 @@
-import { Readable } from "node:stream";
-import { URL, URLSearchParams } from "node:url";
-import { pathToRegexp } from "path-to-regexp";
-import { Response } from "undici";
-import { getCloudflareApiBaseUrl } from "../../environment-variables/misc-variables";
-import type { FetchResult, FetchError } from "../../cfetch";
-import type {
-	fetchInternal,
-	fetchR2Objects,
-	performApiFetch,
-} from "../../cfetch/internal";
-import type { RequestInit, BodyInit, HeadersInit } from "undici";
-
-/**
- * When the custom mocks fallthrough in tests because they aren't set, instead of throwing an error,
- * we use real fetch to make the request which will use Mock Service Workers.
- */
-const {
-	fetchInternal: realFetchInternal,
-}: { fetchInternal: typeof fetchInternal } = jest.requireActual(
-	"../../cfetch/internal"
-);
-const {
-	fetchR2Objects: realFetchR2Objects,
-}: { fetchR2Objects: typeof fetchR2Objects } = jest.requireActual(
-	"../../cfetch/internal"
-);
-
-const {
-	performApiFetch: realPerformApiFetch,
-}: { performApiFetch: typeof performApiFetch } = jest.requireActual(
-	"../../cfetch/internal"
-);
-
-/**
- * The signature of the function that will handle a mock request.
- */
-export type MockHandler<ResponseType> = (
-	uri: RegExpExecArray,
-	init: RequestInit,
-	queryParams: URLSearchParams
-) => ResponseType | Promise<ResponseType>;
-
-type RemoveMockFn = () => void;
-
-interface MockFetch<ResponseType> {
-	regexp: RegExp;
-	method: string | undefined;
-	handler: MockHandler<ResponseType>;
-}
-const mocks: MockFetch<unknown>[] = [];
-
-/**
- * The mock implementation of `cfApi.fetch()`.
- *
- * This function will attempt to match the given request to one of the mock handlers configured by calls to `setMock`.
- *
- * Once found the handler will be used to generate a mock response.
- */
-export async function mockFetchInternal(
-	resource: string,
-	init: RequestInit = {},
-	queryParams: URLSearchParams | undefined
-) {
-	for (const { regexp, method, handler } of mocks) {
-		const resourcePath = new URL(resource, getCloudflareApiBaseUrl()).pathname;
-		const uri = regexp.exec(resourcePath);
-		// Do the resource path and (if specified) the HTTP method match?
-		if (uri !== null && (!method || method === (init.method ?? "GET"))) {
-			// The `resource` regular expression will extract the labelled groups from the URL.
-			// These are passed through to the `handler` call, to allow it to do additional checks or behaviour.
-			return await handler(uri, init, queryParams ?? new URLSearchParams()); // TODO: should we have some kind of fallthrough system? we'll see.
-		}
-	}
-
-	// let it fall through to mock-service-worker
-	// (do a real, unmocked fetch)
-	return await realFetchInternal(resource, init, queryParams);
-}
-
-/**
- * We don't have loads of infrastructure around performApiFetch
- * the same way we do for cfetch, so we'll just pass off the real
- * deal to avoid getting it auto-mocked, so that msw can catch it.
- */
-export const mockPerformApiFetch = realPerformApiFetch;
-
-/**
- * Specify an expected resource path that is to be handled, resulting in a raw JSON response.
- *
- * @param resource The path of the resource to be matched.
- * This can include wildcards whose value will be passed to the `handler`.
- * @param handler The function that will generate the mock response for this request.
- */
-export function setMockRawResponse<ResponseType>(
-	resource: string,
-	handler: MockHandler<ResponseType>
-): RemoveMockFn;
-/**
- * Specify an expected resource path that is to be handled, resulting in a raw JSON response.
- *
- * @param resource The path of the resource to be matched.
- * This can include wildcards whose value will be passed to the `handler`.
- * @param method The HTTP method (e.g. GET, POST, etc) that the request must have to match this mock handler.
- * @param handler The function that will generate the mock response for this request.
- */
-export function setMockRawResponse<ResponseType>(
-	resource: string,
-	method: string,
-	handler: MockHandler<ResponseType>
-): RemoveMockFn;
-/**
- * Specify an expected resource path that is to be handled, resulting in a raw JSON response.
- */
-export function setMockRawResponse<ResponseType>(
-	resource: string,
-	...args: [string, MockHandler<ResponseType>] | [MockHandler<ResponseType>]
-): RemoveMockFn {
-	const handler = args.pop() as MockHandler<ResponseType>;
-	const method = args.pop() as string;
-	const mock = {
-		resource,
-		method,
-		handler,
-		regexp: pathToRegexp(resource),
-	};
-	mocks.push(mock);
-	return () => {
-		const mockIndex = mocks.indexOf(mock);
-		if (mockIndex !== -1) {
-			mocks.splice(mockIndex, 1);
-		}
-	};
-}
-
-/**
- * Specify an expected resource path that is to be handled, resulting in a `FetchRequest`.
- *
- * The mock `handler` should return the `result`, which will then be wrapped in a `FetchRequest` object.
- *
- * @param resource The path of the resource to be matched.
- * This can include wildcards whose value will be passed to the `handler`.
- * @param handler The function that will generate the mock response for this request.
- */
-export function setMockResponse<ResponseType>(
-	resource: string,
-	handler: MockHandler<ResponseType>
-): RemoveMockFn;
-/**
- * Specify an expected resource path that is to be handled, resulting in a FetchRequest..
- *
- * @param resource The path of the resource to be matched.
- * This can include wildcards whose value will be passed to the `handler`.
- * @param method The HTTP method (e.g. GET, POST, etc) that the request must have to match this mock handler.
- * @param handler The function that will generate the mock response for this request.
- */
-export function setMockResponse<ResponseType>(
-	resource: string,
-	method: string,
-	handler: MockHandler<ResponseType>
-): RemoveMockFn;
-/**
- * Specify an expected resource path that is to be handled, resulting in a FetchRequest.
- */
-export function setMockResponse<ResponseType>(
-	resource: string,
-	...args: [string, MockHandler<ResponseType>] | [MockHandler<ResponseType>]
-): RemoveMockFn {
-	const handler = args.pop() as MockHandler<ResponseType>;
-	const method = args.pop() as string;
-	return setMockRawResponse(resource, method, (...handlerArgs) =>
-		createFetchResult(handler(...handlerArgs))
-	);
-}
-
-/**
- * A helper to make it easier to create `FetchResult` objects in tests.
- * TODO: Hijack this for MSW response objects. - JACOB
- */
-export async function createFetchResult<ResponseType>(
-	result: ResponseType | Promise<ResponseType>,
-	success = true,
-	errors: FetchError[] = [],
-	messages: string[] = [],
-	result_info?: unknown
-): Promise<FetchResult<ResponseType>> {
-	return result_info
-		? {
-				result: await result,
-				success,
-				errors,
-				messages,
-				result_info,
-		  }
-		: {
-				result: await result,
-				success,
-				errors,
-				messages,
-		  };
-}
-
-/**
- * Remove all the configured mock handlers.
- *
- * This should be called in an `afterEach()` block to ensure that mock handlers do not leak between tests.
- */
-export function unsetAllMocks() {
-	mocks.length = 0;
-}
-
-/**
- * We special-case fetching the request for `kv:key get`, because it's
- * the only cloudflare API endpoint that returns a plain string as the
- * value, and not as the "standard" FetchResult-style json. Hence, we also
- * special-case mocking it here.
- */
-
-const kvGetMocks = new Map<string, string | Buffer>();
-const r2GetMocks = new Map<string, string | undefined>();
-const dashScriptMocks = new Map<string, string | undefined>();
-
-/**
- * @mocked typeof fetchR2Objects
- */
-export async function mockFetchR2Objects(
-	resource: string,
-	bodyInit: {
-		body: BodyInit | Readable;
-		headers: HeadersInit | undefined;
-		method: "PUT" | "GET" | "DELETE";
-	}
-): Promise<Response> {
-	if (r2GetMocks.has(resource)) {
-		/**
-		 * Here we destroy & removeListeners to "drain" the stream, for testing purposes
-		 * mimicking the fetch request taking in the stream and draining it.
-		 */
-		if (bodyInit.body instanceof Readable) {
-			bodyInit.body.destroy();
-			bodyInit.body.removeAllListeners();
-		}
-
-		const value = r2GetMocks.get(resource);
-
-		return new Response(value);
-	}
-
-	// No mocks found for ${init.method ?? "any HTTP"} request to ${resource}
-	// let it fall through to Mock Service Worker with a real fetch.
-	return await realFetchR2Objects(resource, bodyInit);
-}
-
-/**
- * Mock setter for usage within test blocks, companion helper to `mockFetchR2Objects`
- */
-export function setMockFetchR2Objects({
-	accountId,
-	bucketName,
-	objectName,
-	mockResponse,
-}: {
-	accountId: string;
-	bucketName: string;
-	objectName: string;
-	mockResponse?: string;
-}) {
-	r2GetMocks.set(
-		`/accounts/${accountId}/r2/buckets/${bucketName}/objects/${objectName}`,
-		mockResponse
-	);
-}
-
-export function unsetSpecialMockFns() {
-	kvGetMocks.clear();
-	r2GetMocks.clear();
-	dashScriptMocks.clear();
-}

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

@@ -1,106 +0,0 @@
-import * as util from "node:util";
-import { logger } from "../../logger";
-
-/**
- * We use this module to mock console methods, and optionally
- * assert on the values they're called with in our tests.
- */
-
-let debugSpy: jest.SpyInstance,
-	logSpy: 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);
-	},
-};
-
-function normalizeOutput(spy: jest.SpyInstance): string {
-	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");
-}
-
-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;
-}
-
-/**
- * Normalize error `X` markers.
- *
- * Windows gets a different character.
- */
-function normalizeErrorMarkers(str: string): string {
-	return str.replaceAll("✘", "X");
-}
-
-/**
- * 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)");
-}
-
-export function stripTrailingWhitespace(str: string): string {
-	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,137 +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-zone-from-host.ts

@@ -1,8 +0,0 @@
-import { setMockResponse } from "./mock-cfetch";
-
-export function mockGetZoneFromHostRequest(host: string, zone?: string) {
-	setMockResponse("/zones", (_uri, _init, queryParams) => {
-		expect(queryParams.get("name")).toEqual(host);
-		return 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,7 +0,0 @@
-import { setMockResponse } from "./mock-cfetch";
-
-export function mockCollectKnownRoutesRequest(
-	routes: { pattern: string; script: string }[]
-) {
-	setMockResponse(`/zones/:zoneId/workers/routes`, "GET", () => routes);
-}

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

@@ -1,33 +0,0 @@
-import { createFetchResult, setMockRawResponse } from "./mock-cfetch";
-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
-
-	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;
-}