wrangler 2.6.2 → 2.7.0

package/src/__tests__/delete.test.ts

@@ -2,17 +2,20 @@ import { rest } from "msw";
 import { mockAccountId, mockApiToken } from "./helpers/mock-account-id";
 import { mockConsoleMethods } from "./helpers/mock-console";
 import { mockConfirm } from "./helpers/mock-dialogs";
+import { useMockIsTTY } from "./helpers/mock-istty";
 import { msw } from "./helpers/msw";
 import { runInTempDir } from "./helpers/run-in-tmp";
 import { runWrangler } from "./helpers/run-wrangler";
 import writeWranglerToml from "./helpers/write-wrangler-toml";
 import type { KVNamespaceInfo } from "../kv/helpers";
-
 describe("delete", () => {
 	mockAccountId();
 	mockApiToken();
 	runInTempDir();
-
+	const { setIsTTY } = useMockIsTTY();
+	beforeEach(() => {
+		setIsTTY(true);
+	});
 	const std = mockConsoleMethods();
 
 	it("should delete an entire service by name", async () => {

package/src/__tests__/deployments.test.ts

@@ -1,5 +1,7 @@
 // import * as fs from "fs";
 // import * as TOML from "@iarna/toml";
+import * as fs from "node:fs";
+import * as TOML from "@iarna/toml";
 import { rest } from "msw";
 import { mockAccountId, mockApiToken } from "./helpers/mock-account-id";
 import { mockConsoleMethods } from "./helpers/mock-console";
@@ -26,11 +28,7 @@ describe("deployments", () => {
 			...mswSuccessUserHandlers,
 			rest.get(
 				"*/accounts/:accountId/workers/services/:scriptName",
-				(request, response, context) => {
-					expect(["undefined", "somethingElse"]).toContain(
-						request.params.scriptName
-					);
-
+				(_, response, context) => {
 					return response.once(
 						context.status(200),
 						context.json({
@@ -52,6 +50,16 @@ describe("deployments", () => {
 	});
 
 	it("should log deployments", async () => {
+		fs.writeFileSync(
+			"./wrangler.toml",
+			TOML.stringify({
+				compatibility_date: "2022-01-12",
+				name: "test-script-name",
+				first_party_worker: true,
+			}),
+			"utf-8"
+		);
+
 		await runWrangler("deployments");
 		expect(std.out).toMatchInlineSnapshot(`
 		"🚧\`wrangler deployments\` is a beta command. Please report any issues to https://github.com/cloudflare/wrangler2/issues/new/choose
@@ -71,7 +79,7 @@ describe("deployments", () => {
 	});
 
 	it("should log deployments for script with passed in name option", async () => {
-		await runWrangler("deployments --name somethingElse");
+		await runWrangler("deployments --name something-else");
 		expect(std.out).toMatchInlineSnapshot(`
 		"🚧\`wrangler deployments\` is a beta command. Please report any issues to https://github.com/cloudflare/wrangler2/issues/new/choose
 
@@ -88,4 +96,10 @@ describe("deployments", () => {
 		🟩 Active"
 	`);
 	});
+
+	it("should error on missing script name", async () => {
+		await expect(runWrangler("deployments")).rejects.toMatchInlineSnapshot(
+			`[Error: Required Worker name missing. Please specify the Worker name in wrangler.toml, or pass it as an argument with \`--name\`]`
+		);
+	});
 });

package/src/__tests__/dev.test.tsx

@@ -1,11 +1,11 @@
 import * as fs from "node:fs";
 import getPort from "get-port";
+import { rest } from "msw";
 import patchConsole from "patch-console";
 import dedent from "ts-dedent";
 import Dev from "../dev/dev";
 import { CI } from "../is-ci";
 import { mockAccountId, mockApiToken } from "./helpers/mock-account-id";
-import { setMockResponse, unsetAllMocks } from "./helpers/mock-cfetch";
 import { mockConsoleMethods } from "./helpers/mock-console";
 import {
 	msw,
@@ -33,7 +33,7 @@ describe("wrangler dev", () => {
 	afterEach(() => {
 		(Dev as jest.Mock).mockClear();
 		patchConsole(() => {});
-		unsetAllMocks();
+		msw.resetHandlers();
 	});
 
 	describe("authorization", () => {
@@ -439,16 +439,44 @@ describe("wrangler dev", () => {
 				main: "index.js",
 			});
 			fs.writeFileSync("index.js", `export default {};`);
-			mockGetZones("111.222.333.some-host.com", []);
-			mockGetZones("222.333.some-host.com", []);
-			mockGetZones("333.some-host.com", [{ id: "some-zone-id" }]);
-			await runWrangler("dev --host 111.222.333.some-host.com");
-			expect((Dev as jest.Mock).mock.calls[0][0]).toEqual(
-				expect.objectContaining({
-					host: "111.222.333.some-host.com",
-					zone: "some-zone-id",
+
+			msw.use(
+				rest.get("*/zones", (req, res, ctx) => {
+					let zone: [] | [{ id: "some-zone-id" }] = [];
+					if (
+						req.url.searchParams.get("name") === "111.222.333.some-host.com"
+					) {
+						zone = [];
+					} else if (
+						req.url.searchParams.get("name") === "222.333.some-host.com"
+					) {
+						zone = [];
+					} else if (req.url.searchParams.get("name") === "333.some-host.com") {
+						zone = [{ id: "some-zone-id" }];
+					}
+
+					return res(
+						ctx.status(200),
+						ctx.json({
+							success: true,
+							errors: [],
+							messages: [],
+							result: zone,
+						})
+					);
 				})
 			);
+
+			await runWrangler("dev --host 111.222.333.some-host.com");
+
+			const devMockCall = (Dev as jest.Mock).mock.calls[0][0];
+
+			expect(devMockCall).toHaveProperty("host", "111.222.333.some-host.com");
+			expect(devMockCall).toHaveProperty(
+				"localUpstream",
+				"111.222.333.some-host.com"
+			);
+			expect(devMockCall).toHaveProperty("zone", "some-zone-id");
 		});
 
 		it("should, in order, use args.host/config.dev.host/args.routes/(config.route|config.routes)", async () => {
@@ -1540,14 +1568,19 @@ describe("wrangler dev", () => {
 });
 
 function mockGetZones(domain: string, zones: { id: string }[] = []) {
-	const removeMock = setMockResponse(
-		"/zones",
-		"GET",
-		(_urlPieces, _init, queryParams) => {
-			expect([...queryParams.entries()]).toEqual([["name", domain]]);
-			// Because the API URL `/zones` is the same for each request, we can get into a situation where earlier mocks get triggered for later requests. So, we simply clear the mock on every trigger.
-			removeMock();
-			return zones;
-		}
+	msw.use(
+		rest.get("*/zones", (req, res, ctx) => {
+			expect([...req.url.searchParams.entries()]).toEqual([["name", domain]]);
+
+			return res(
+				ctx.status(200),
+				ctx.json({
+					success: true,
+					errors: [],
+					messages: [],
+					result: zones,
+				})
+			);
+		})
 	);
 }

package/src/__tests__/generate.test.ts

@@ -1,18 +1,21 @@
 import fs from "node:fs";
 import path from "node:path";
 import { mockConsoleMethods } from "./helpers/mock-console";
-import { mockConfirm, clearConfirmMocks } from "./helpers/mock-dialogs";
+import { mockConfirm } from "./helpers/mock-dialogs";
+import { useMockIsTTY } from "./helpers/mock-istty";
 import { runInTempDir } from "./helpers/run-in-tmp";
 import { runWrangler } from "./helpers/run-wrangler";
 
 describe("generate", () => {
 	runInTempDir();
+	const { setIsTTY } = useMockIsTTY();
 	const std = mockConsoleMethods();
+	beforeEach(() => {
+		setIsTTY(true);
+	});
 
 	describe("cli functionality", () => {
-		afterEach(() => {
-			clearConfirmMocks();
-		});
+		afterEach(() => {});
 
 		it("defers to `wrangler init` when no template is given", async () => {
 			mockConfirm(

package/src/__tests__/helpers/mock-auth-domain.ts

@@ -0,0 +1,20 @@
+const ORIGINAL_WRANGLER_AUTH_DOMAIN = process.env.WRANGLER_AUTH_DOMAIN;
+
+/**
+ * Mock the Auth URL domain so that we can control where we attempt to login.
+ *
+ * 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 `mockAuthDomain()`.
+ */
+export function mockAuthDomain({ domain }: { domain: string | null }) {
+	beforeEach(() => {
+		if (domain === null) {
+			delete process.env.WRANGLER_AUTH_DOMAIN;
+		} else {
+			process.env.WRANGLER_AUTH_DOMAIN = domain;
+		}
+	});
+	afterEach(() => {
+		process.env.WRANGLER_AUTH_DOMAIN = ORIGINAL_WRANGLER_AUTH_DOMAIN;
+	});
+}

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

@@ -2,7 +2,7 @@ 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 { getCloudflareApiBaseUrl } from "../../environment-variables/misc-variables";
 import type { FetchResult, FetchError } from "../../cfetch";
 import type {
 	fetchInternal,
@@ -175,6 +175,7 @@ export function setMockResponse<ResponseType>(
 
 /**
  * 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>,
@@ -219,31 +220,6 @@ 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
  */
@@ -300,34 +276,3 @@ export function unsetSpecialMockFns() {
 	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-dialogs.ts

@@ -1,12 +1,12 @@
-import { confirm, prompt, select } from "../../dialogs";
-import { normalizeSlashes } from "./mock-console";
-
+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;
 }
@@ -19,35 +19,21 @@ export interface ConfirmExpectation {
  * 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);
+	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 });
 			}
-		}
-		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.`
 		);
-	});
+	}
 }
 
 /**
@@ -57,7 +43,10 @@ export interface PromptExpectation {
 	/** The text expected to be seen in the prompt dialog. */
 	text: string;
 	/** The type of the prompt. */
-	type: "text" | "password";
+	options?: {
+		defaultValue?: string;
+		isSecret?: boolean;
+	};
 	/** The mock response send back from the prompt dialog. */
 	result: string;
 }
@@ -70,45 +59,44 @@ export interface PromptExpectation {
  * 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);
+	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 });
 			}
-			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.`
-		);
-	});
+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 {
+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;
 }
@@ -120,34 +108,30 @@ export interface SelectExpectation {
  * 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);
+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 });
 			}
-		}
-		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.`
-		);
-	});
+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 "
+	);
 }