wrangler 0.0.0-e41c7e41 → 0.0.0-e42f3207

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

@@ -1,333 +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 "../../cfetch";
-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.
- */
-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 fetchKVGetValue
- */
-export function mockFetchKVGetValue(
-	accountId: string,
-	namespaceId: string,
-	key: string
-) {
-	const mapKey = `${accountId}/${namespaceId}/${key}`;
-	if (kvGetMocks.has(mapKey)) {
-		const value = kvGetMocks.get(mapKey);
-		if (value !== undefined) return Promise.resolve(value);
-	}
-	throw new Error(`no mock value found for \`kv:key get\` - ${mapKey}`);
-}
-
-export function setMockFetchKVGetValue(
-	accountId: string,
-	namespaceId: string,
-	key: string,
-	value: string | Buffer
-) {
-	kvGetMocks.set(`${accountId}/${namespaceId}/${key}`, value);
-}
-
-/**
- * @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();
-}
-
-/**
- * @mocked typeof fetchDashScript
- * multipart/form-data is the response for modules and raw text for the Script endpoint.
- */
-export async function mockFetchDashScript(resource: string): Promise<string> {
-	if (dashScriptMocks.has(resource)) {
-		return dashScriptMocks.get(resource) ?? "";
-	}
-	throw new Error(`no mock found for \`init from-dash\` - ${resource}`);
-}
-
-/**
- * Mock setter for usage within test blocks, companion helper to `mockFetchDashScript`
- */
-export function setMockFetchDashScript({
-	accountId,
-	fromDashScriptName,
-	environment,
-	mockResponse,
-}: {
-	accountId: string;
-	fromDashScriptName: string;
-	environment: string;
-	mockResponse?: string;
-}) {
-	dashScriptMocks.set(
-		`/accounts/${accountId}/workers/services/${fromDashScriptName}/environments/${environment}/content`,
-		mockResponse
-	);
-}

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,153 +0,0 @@
-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-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;
-	};
-}