wrangler 0.0.0-ece06ea → 0.0.0-ecfbb0c

package/src/__tests__/guess-worker-format.test.ts

@@ -0,0 +1,85 @@
+import { writeFile } from "fs/promises";
+import path from "path";
+import guessWorkerFormat from "../entry";
+import { mockConsoleMethods } from "./helpers/mock-console";
+import { runInTempDir } from "./helpers/run-in-tmp";
+
+describe("guess worker format", () => {
+	runInTempDir();
+	const std = mockConsoleMethods();
+	it('should detect a "modules" worker', async () => {
+		await writeFile("./index.ts", "export default {};");
+		// Note that this isn't actually a valid worker, because it's missing
+		// a fetch handler. Regardless, our heuristic is simply to check for exports.
+		const guess = await guessWorkerFormat(
+			path.join(process.cwd(), "./index.ts"),
+			process.cwd(),
+			undefined
+		);
+		expect(guess).toBe("modules");
+	});
+
+	it('should detect a "service-worker" worker', async () => {
+		await writeFile("./index.ts", "");
+		// Note that this isn't actually a valid worker, because it's missing
+		// a fetch listener. Regardless, our heuristic is simply to check for
+		// the lack of exports.
+		const guess = await guessWorkerFormat(
+			path.join(process.cwd(), "./index.ts"),
+			process.cwd(),
+			undefined
+		);
+		expect(guess).toBe("service-worker");
+	});
+
+	it("should throw an error when the hint doesn't match the guess (modules - service-worker)", async () => {
+		await writeFile("./index.ts", "export default {};");
+		await expect(
+			guessWorkerFormat(
+				path.join(process.cwd(), "./index.ts"),
+				process.cwd(),
+				"service-worker"
+			)
+		).rejects.toThrow(
+			"You configured this worker to be a 'service-worker', but the file you are trying to build appears to have a `default` export like a module worker. Please pass `--format modules`, or simply remove the configuration."
+		);
+	});
+
+	it("should throw an error when the hint doesn't match the guess (service-worker - modules)", async () => {
+		await writeFile("./index.ts", "");
+		await expect(
+			guessWorkerFormat(
+				path.join(process.cwd(), "./index.ts"),
+				process.cwd(),
+				"modules"
+			)
+		).rejects.toThrow(
+			"You configured this worker to be 'modules', but the file you are trying to build doesn't export a handler. Please pass `--format service-worker`, or simply remove the configuration."
+		);
+	});
+
+	it("should not error if a .js entry point has jsx", async () => {
+		await writeFile("./index.js", "console.log(<div/>)");
+		const guess = await guessWorkerFormat(
+			path.join(process.cwd(), "./index.js"),
+			process.cwd(),
+			undefined
+		);
+		expect(guess).toBe("service-worker");
+	});
+
+	it("logs a warning when a worker has exports, but not a default one", async () => {
+		await writeFile("./index.ts", "export const foo = 1;");
+		const guess = await guessWorkerFormat(
+			path.join(process.cwd(), "./index.ts"),
+			process.cwd(),
+			undefined
+		);
+		expect(guess).toBe("service-worker");
+		expect(std.warn).toMatchInlineSnapshot(`
+      "▲ [WARNING] The entrypoint index.ts has exports like an ES Module, but hasn't defined a default export like a module worker normally would. Building the worker using \\"service-worker\\" format...
+
+      "
+    `);
+	});
+});

package/src/__tests__/helpers/cmd-shim.d.ts

@@ -0,0 +1,11 @@
+/**
+ * The typings file available at `@types/cmd-shim` are out of date.
+ */
+module "cmd-shim" {
+	/**
+	 *
+	 * Create a cmd shim at `to` for the command line program at `from`.
+	 *
+	 */
+	export default function cmdShim(from: string, to: string): Promise<void>;
+}

package/src/__tests__/helpers/faye-websocket.d.ts

@@ -0,0 +1,6 @@
+module "faye-websocket" {
+	/**
+	 * Standards-compliant WebSocket client and server.
+	 */
+	export default WebSocket;
+}

package/src/__tests__/helpers/mock-account-id.ts

@@ -0,0 +1,48 @@
+import { reinitialiseAuthTokens } from "../../user";
+
+const ORIGINAL_CLOUDFLARE_API_TOKEN = process.env.CLOUDFLARE_API_TOKEN;
+const ORIGINAL_CLOUDFLARE_ACCOUNT_ID = process.env.CLOUDFLARE_ACCOUNT_ID;
+
+/**
+ * Mock the API token so that we don't need to read it from user configuration files.
+ *
+ * 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 `mockApiToken()`.
+ */
+export function mockApiToken({
+	apiToken = "some-api-token",
+}: { apiToken?: string | null } = {}) {
+	beforeEach(() => {
+		if (apiToken === null) {
+			delete process.env.CLOUDFLARE_API_TOKEN;
+		} else {
+			process.env.CLOUDFLARE_API_TOKEN = apiToken;
+		}
+		// Now we have updated the environment, we must reinitialize the user auth state.
+		reinitialiseAuthTokens();
+	});
+	afterEach(() => {
+		process.env.CLOUDFLARE_API_TOKEN = ORIGINAL_CLOUDFLARE_API_TOKEN;
+	});
+}
+
+/**
+ * Mock the current account ID so that we don't need to read it from configuration files.
+ *
+ * Note that you can remove any account ID from the environment by setting the value to `null`.
+ * This is useful if a higher `describe()` block has already called `mockAccountId()`.
+ */
+export function mockAccountId({
+	accountId = "some-account-id",
+}: { accountId?: string | null } = {}) {
+	beforeEach(() => {
+		if (accountId === null) {
+			delete process.env.CLOUDFLARE_ACCOUNT_ID;
+		} else {
+			process.env.CLOUDFLARE_ACCOUNT_ID = accountId;
+		}
+	});
+	afterEach(() => {
+		process.env.CLOUDFLARE_ACCOUNT_ID = ORIGINAL_CLOUDFLARE_ACCOUNT_ID;
+	});
+}

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

@@ -0,0 +1,36 @@
+import { chmodSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { basename, resolve } from "node:path";
+import cmdShim from "cmd-shim";
+
+const nodeShebang = "#!/usr/bin/env node";
+
+/**
+ * Create a binary file in a temp directory and make it available on the PATH.
+ */
+export async function mockBinary(
+	binaryName: string,
+	code: string
+): Promise<() => void> {
+	// Ensure there is a directory to put the mock binary in.
+	const tmpDir = resolve(mkdtempSync(".mock-binary-"));
+
+	// Use a fake extension on Windows because we will create a cmd-shim to run the binary.
+	const extension = process.platform === "win32" ? ".x-mock-bin" : "";
+	const filePath = resolve(tmpDir, `${binaryName}${extension}`);
+	writeFileSync(filePath, nodeShebang + "\n" + code);
+	chmodSync(filePath, 0o777);
+
+	if (process.platform === "win32") {
+		await cmdShim(filePath, basename(filePath, ".x-mock-bin"));
+	}
+
+	// Update PATH using the appropriate separator for the platform.
+	const oldPath = process.env.PATH;
+	const sep = process.platform === "win32" ? ";" : ":";
+	process.env.PATH = tmpDir + sep + oldPath;
+
+	return function unMock() {
+		rmSync(tmpDir, { recursive: true });
+		process.env.PATH = process.env.PATH?.replace(tmpDir + sep, "");
+	};
+}

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

@@ -0,0 +1,211 @@
+import { URL, URLSearchParams } from "node:url";
+import { pathToRegexp } from "path-to-regexp";
+import { getCloudflareApiBaseUrl } from "../../cfetch";
+import type { FetchResult, FetchError } from "../../cfetch";
+import type { RequestInit } from "undici";
+
+/**
+ * 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 = new URLSearchParams()
+) {
+	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); // TODO: should we have some kind of fallthrough system? we'll see.
+		}
+	}
+	throw new Error(
+		`no mocks found for ${init.method ?? "any HTTP"} request to ${resource}`
+	);
+}
+
+/**
+ * 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>();
+
+/**
+ * @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);
+}
+
+export function unsetMockFetchKVGetValues() {
+	kvGetMocks.clear();
+}

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

@@ -0,0 +1,97 @@
+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(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(/.[0-9][0-9] KiB/g, "xx KiB");
+}

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.`
+		);
+	});
+}