wrangler 2.1.0 → 2.1.3

package/src/__tests__/r2.test.ts

@@ -1,11 +1,8 @@
 import * as fs from "node:fs";
+import { rest } from "msw";
 import { mockAccountId, mockApiToken } from "./helpers/mock-account-id";
-import {
-	setMockFetchR2Objects,
-	setMockResponse,
-	unsetAllMocks,
-} from "./helpers/mock-cfetch";
 import { mockConsoleMethods } from "./helpers/mock-console";
+import { msw } from "./helpers/msw";
 import { runInTempDir } from "./helpers/run-in-tmp";
 import { runWrangler } from "./helpers/run-wrangler";
 import type { R2BucketInfo } from "../r2";
@@ -16,10 +13,6 @@ describe("wrangler", () => {
 	runInTempDir();
 	const std = mockConsoleMethods();
 
-	afterEach(() => {
-		unsetAllMocks();
-	});
-
 	describe("r2", () => {
 		describe("bucket", () => {
 			it("should show the correct help when an invalid command is passed", async () => {
@@ -50,26 +43,41 @@ describe("wrangler", () => {
 			});
 
 			describe("list", () => {
-				function mockListRequest(buckets: R2BucketInfo[]) {
-					const requests = { count: 0 };
-					setMockResponse(
-						"/accounts/:accountId/r2/buckets",
-						([_url, accountId], init) => {
-							requests.count++;
-							expect(accountId).toEqual("some-account-id");
-							expect(init).toEqual({});
-							return { buckets };
-						}
-					);
-					return requests;
-				}
-
-				it("should list buckets", async () => {
+				it("should list buckets & check request inputs", async () => {
 					const expectedBuckets: R2BucketInfo[] = [
-						{ name: "bucket-1", creation_date: "01-01-2001" },
-						{ name: "bucket-2", creation_date: "01-01-2001" },
+						{ name: "bucket-1-local-once", creation_date: "01-01-2001" },
+						{ name: "bucket-2-local-once", creation_date: "01-01-2001" },
 					];
-					mockListRequest(expectedBuckets);
+					msw.use(
+						rest.get(
+							"*/accounts/:accountId/r2/buckets",
+							async (request, response, context) => {
+								const { accountId } = request.params;
+								expect(accountId).toEqual("some-account-id");
+								expect(await request.text()).toEqual("");
+								return response.once(
+									context.status(200),
+									context.json({
+										success: true,
+										errors: [],
+										messages: [],
+										result: {
+											buckets: [
+												{
+													name: "bucket-1-local-once",
+													creation_date: "01-01-2001",
+												},
+												{
+													name: "bucket-2-local-once",
+													creation_date: "01-01-2001",
+												},
+											],
+										},
+									})
+								);
+							}
+						)
+					);
 					await runWrangler("r2 bucket list");
 
 					expect(std.err).toMatchInlineSnapshot(`""`);
@@ -79,21 +87,6 @@ describe("wrangler", () => {
 			});
 
 			describe("create", () => {
-				function mockCreateRequest(expectedBucketName: string) {
-					const requests = { count: 0 };
-					setMockResponse(
-						"/accounts/:accountId/r2/buckets",
-						"POST",
-						([_url, accountId], { body }) => {
-							expect(accountId).toEqual("some-account-id");
-							const bucketName = JSON.parse(body as string).name;
-							expect(bucketName).toEqual(expectedBucketName);
-							requests.count += 1;
-						}
-					);
-					return requests;
-				}
-
 				it("should error if no bucket name is given", async () => {
 					await expect(
 						runWrangler("r2 bucket create")
@@ -148,32 +141,35 @@ describe("wrangler", () => {
 			          `);
 				});
 
-				it("should create a bucket", async () => {
-					const requests = mockCreateRequest("testBucket");
+				it("should create a bucket & check request inputs", async () => {
+					msw.use(
+						rest.post(
+							"*/accounts/:accountId/r2/buckets",
+							async (request, response, context) => {
+								const { accountId } = request.params;
+								expect(accountId).toEqual("some-account-id");
+								expect(await request.json()).toEqual({ name: "testBucket" });
+								response.once(
+									context.status(200),
+									context.json({
+										success: true,
+										errors: [],
+										messages: [],
+										result: {},
+									})
+								);
+							}
+						)
+					);
 					await runWrangler("r2 bucket create testBucket");
 					expect(std.out).toMatchInlineSnapshot(`
 				            "Creating bucket testBucket.
 				            Created bucket testBucket."
 			          `);
-					expect(requests.count).toEqual(1);
 				});
 			});
 
 			describe("delete", () => {
-				function mockDeleteRequest(expectedBucketName: string) {
-					const requests = { count: 0 };
-					setMockResponse(
-						"/accounts/:accountId/r2/buckets/:bucketName",
-						"DELETE",
-						([_url, accountId, bucketName]) => {
-							expect(accountId).toEqual("some-account-id");
-							expect(bucketName).toEqual(expectedBucketName);
-							requests.count += 1;
-						}
-					);
-					return requests;
-				}
-
 				it("should error if no bucket name is given", async () => {
 					await expect(
 						runWrangler("r2 bucket delete")
@@ -228,23 +224,42 @@ describe("wrangler", () => {
 			          `);
 				});
 
-				it("should delete a bucket specified by name", async () => {
-					const requests = mockDeleteRequest("some-bucket");
+				it("should delete a bucket specified by name & check requests inputs", async () => {
+					msw.use(
+						rest.delete(
+							"*/accounts/:accountId/r2/buckets/:bucketName",
+							async (request, response, context) => {
+								const { accountId, bucketName } = request.params;
+								expect(accountId).toEqual("some-account-id");
+								expect(bucketName).toEqual("some-bucket");
+								expect(await request.text()).toEqual("");
+								expect(request.headers.get("authorization")).toEqual(
+									"Bearer some-api-token"
+								);
+
+								return response.once(
+									context.status(200),
+									context.json({
+										success: true,
+										errors: [],
+										messages: [],
+										result: null,
+									})
+								);
+							}
+						)
+					);
 					await runWrangler(`r2 bucket delete some-bucket`);
-					expect(requests.count).toEqual(1);
+					expect(std.out).toMatchInlineSnapshot(`
+				"Deleting bucket some-bucket.
+				Deleted bucket some-bucket."
+			`);
 				});
 			});
 		});
 
 		describe("r2 object", () => {
 			it("should download R2 object from bucket", async () => {
-				setMockFetchR2Objects({
-					accountId: "some-account-id",
-					bucketName: "bucketName-object-test",
-					objectName: "wormhole-img.png",
-					mockResponse: "R2-objects-test-data",
-				});
-
 				await runWrangler(
 					`r2 object get bucketName-object-test/wormhole-img.png --file ./wormhole-img.png`
 				);
@@ -256,11 +271,6 @@ describe("wrangler", () => {
 			});
 
 			it("should upload R2 object from bucket", async () => {
-				setMockFetchR2Objects({
-					accountId: "some-account-id",
-					bucketName: "bucketName-object-test",
-					objectName: "wormhole-img.png",
-				});
 				fs.writeFileSync("wormhole-img.png", "passageway");
 				await runWrangler(
 					`r2 object put bucketName-object-test/wormhole-img.png --file ./wormhole-img.png`
@@ -272,15 +282,52 @@ describe("wrangler", () => {
 		`);
 			});
 
-			it("should pass all fetch option flags into requestInit", async () => {
+			it("should pass all fetch option flags into requestInit & check request inputs", async () => {
+				msw.use(
+					rest.put(
+						"*/accounts/:accountId/r2/buckets/:bucketName/objects/:objectName",
+						(request, response, context) => {
+							const { accountId, bucketName, objectName } = request.params;
+							expect(accountId).toEqual("some-account-id");
+							expect(bucketName).toEqual("bucketName-object-test");
+							expect(objectName).toEqual("wormhole-img.png");
+							const headersObject = request.headers.all();
+							delete headersObject["user-agent"];
+							expect(headersObject).toMatchInlineSnapshot(`
+					Object {
+					  "accept": "*/*",
+					  "accept-encoding": "gzip,deflate",
+					  "authorization": "Bearer some-api-token",
+					  "cache-control": "cache-control-mock",
+					  "connection": "close",
+					  "content-disposition": "content-disposition-mock",
+					  "content-encoding": "content-encoding-mock",
+					  "content-language": "content-lang-mock",
+					  "content-length": "10",
+					  "content-type": "content-type-mock",
+					  "expires": "expire-time-mock",
+					  "host": "api.cloudflare.com",
+					}
+				`);
+							response.once(
+								context.status(200),
+								context.json({
+									success: true,
+									errors: [],
+									messages: [],
+									result: {
+										accountId: "some-account-id",
+										bucketName: "bucketName-object-test",
+										objectName: "wormhole-img.png",
+									},
+								})
+							);
+						}
+					)
+				);
 				fs.writeFileSync("wormhole-img.png", "passageway");
-				setMockFetchR2Objects({
-					accountId: "some-account-id",
-					bucketName: "bucketName-object-test",
-					objectName: "wormhole-img.png",
-				});
 				const flags =
-					"--ct content-type --cd content-disposition --ce content-encoding --cl content-lang --cc cache-control --e expire-time";
+					"--ct content-type-mock --cd content-disposition-mock --ce content-encoding-mock --cl content-lang-mock --cc cache-control-mock --e expire-time-mock";
 
 				await runWrangler(
 					`r2 object put bucketName-object-test/wormhole-img.png ${flags} --file wormhole-img.png`
@@ -293,12 +340,6 @@ describe("wrangler", () => {
 			});
 
 			it("should delete R2 object from bucket", async () => {
-				setMockFetchR2Objects({
-					accountId: "some-account-id",
-					bucketName: "bucketName-object-test",
-					objectName: "wormhole-img.png",
-				});
-
 				await runWrangler(
 					`r2 object delete bucketName-object-test/wormhole-img.png`
 				);
@@ -311,12 +352,6 @@ describe("wrangler", () => {
 
 			it("should not allow `--pipe` & `--file` to run together", async () => {
 				fs.writeFileSync("wormhole-img.png", "passageway");
-				setMockFetchR2Objects({
-					accountId: "some-account-id",
-					bucketName: "bucketName-object-test",
-					objectName: "wormhole-img.png",
-				});
-
 				await expect(
 					runWrangler(
 						`r2 object put bucketName-object-test/wormhole-img.png --pipe --file wormhole-img.png`

package/src/__tests__/secret.test.ts

@@ -1,4 +1,5 @@
 import * as fs from "node:fs";
+import { writeFileSync } from "node:fs";
 import * as TOML from "@iarna/toml";
 import { mockAccountId, mockApiToken } from "./helpers/mock-account-id";
 import { setMockResponse, unsetAllMocks } from "./helpers/mock-cfetch";
@@ -95,6 +96,83 @@ describe("wrangler secret", () => {
 				expect(std.err).toMatchInlineSnapshot(`""`);
 			});
 
+			it("should create secret:bulk", async () => {
+				writeFileSync(
+					"secret.json",
+					JSON.stringify({
+						"secret-name-1": "secret_text",
+						"secret-name-2": "secret_text",
+					})
+				);
+
+				// User counter to pass different secrets to the request mock
+				let counter = 0;
+				setMockResponse(
+					`/accounts/:accountId/workers/scripts/:scriptName/secrets`,
+					"PUT",
+					([_url, accountId]) => {
+						expect(accountId).toEqual("some-account-id");
+						counter++;
+
+						return { name: `secret-name-${counter}`, type: "secret_text" };
+					}
+				);
+
+				await runWrangler("secret:bulk ./secret.json --name script-name");
+
+				expect(std.out).toMatchInlineSnapshot(`
+			"🌀 Creating the secrets for the Worker \\"script-name\\"
+			✨ Successfully created secret for key: secret-name-1
+			✨ Successfully created secret for key: secret-name-2
+			✨ Finished processing secrets JSON file"
+		`);
+				expect(std.err).toMatchInlineSnapshot(`""`);
+			});
+
+			it("should handle failed secret:bulk", async () => {
+				writeFileSync(
+					"secret.json",
+					JSON.stringify({
+						"secret-name-1": "secret_text",
+						"secret-name-2": "secret_text",
+					})
+				);
+
+				// User counter to pass different secrets to the request mock
+				let counter = 0;
+				setMockResponse(
+					`/accounts/:accountId/workers/scripts/:scriptName/secrets`,
+					"PUT",
+					([_url, accountId]) => {
+						expect(accountId).toEqual("some-account-id");
+						counter++;
+
+						return Promise.reject(
+							new Error(`Failed to create secret ${counter}`)
+						);
+					}
+				);
+
+				await runWrangler("secret:bulk ./secret.json --name script-name");
+
+				expect(std.out).toMatchInlineSnapshot(`
+			"🌀 Creating the secrets for the Worker \\"script-name\\"
+			✨ Finished processing secrets JSON file"
+		`);
+				expect(std.err).toMatchInlineSnapshot(`
+			"X [ERROR] 🚨 Error uploading secret for key: secret-name-1:
+
+			  										Failed to create secret 1
+
+
+			X [ERROR] 🚨 Error uploading secret for key: secret-name-2:
+
+			  										Failed to create secret 2
+
+			"
+		`);
+			});
+
 			it("should create a secret: legacy envs", async () => {
 				mockPrompt({
 					text: "Enter a secret value:",

package/src/__tests__/whoami.test.tsx

@@ -1,15 +1,11 @@
 import { render } from "ink-testing-library";
+import { rest } from "msw";
 import React from "react";
 import { writeAuthConfigFile } from "../user";
 import { getUserInfo, WhoAmI } from "../whoami";
-import {
-	createFetchResult,
-	setMockRawResponse,
-	setMockResponse,
-	unsetAllMocks,
-} from "./helpers/mock-cfetch";
 import { mockConsoleMethods } from "./helpers/mock-console";
 import { useMockIsTTY } from "./helpers/mock-istty";
+import { msw } from "./helpers/msw";
 import { runInTempDir } from "./helpers/run-in-tmp";
 import type { UserInfo } from "../whoami";
 
@@ -26,7 +22,6 @@ describe("getUserInfo()", () => {
 
 	afterEach(() => {
 		process.env = ENV_COPY;
-		unsetAllMocks();
 	});
 
 	it("should return undefined if there is no config file", async () => {
@@ -44,12 +39,47 @@ describe("getUserInfo()", () => {
 		process.env = {
 			CLOUDFLARE_API_TOKEN: "123456789",
 		};
-		setMockRawResponse("/user", () =>
-			createFetchResult(undefined, false, [
-				{ code: 9109, message: "Uauthorized to access requested resource" },
-			])
+		msw.use(
+			rest.get("*/user", (_, res, ctx) => {
+				return res.once(
+					ctx.status(200),
+					ctx.json({
+						success: false,
+						errors: [
+							{
+								code: 9109,
+								message: "Uauthorized to access requested resource",
+							},
+						],
+						messages: [],
+						result: {},
+					})
+				);
+			}),
+			rest.get("*/accounts", (request, res, ctx) => {
+				const headersObject = request.headers.all();
+				delete headersObject["user-agent"];
+
+				expect(headersObject).toMatchInlineSnapshot(`
+			Object {
+			  "accept": "*/*",
+			  "accept-encoding": "gzip,deflate",
+			  "authorization": "Bearer 123456789",
+			  "connection": "close",
+			  "host": "api.cloudflare.com",
+			}
+		`);
+				return res.once(
+					ctx.status(200),
+					ctx.json({
+						success: true,
+						errors: [],
+						messages: [],
+						result: [],
+					})
+				);
+			})
 		);
-		setMockResponse("/accounts", () => []);
 		const userInfo = await getUserInfo();
 		expect(userInfo?.email).toBeUndefined();
 	});
@@ -58,16 +88,6 @@ describe("getUserInfo()", () => {
 		process.env = {
 			CLOUDFLARE_API_TOKEN: "123456789",
 		};
-		setMockResponse("/user", () => {
-			return { email: "user@example.com" };
-		});
-		setMockResponse("/accounts", () => {
-			return [
-				{ name: "Account One", id: "account-1" },
-				{ name: "Account Two", id: "account-2" },
-				{ name: "Account Three", id: "account-3" },
-			];
-		});
 
 		const userInfo = await getUserInfo();
 		expect(userInfo).toEqual({
@@ -87,13 +107,6 @@ describe("getUserInfo()", () => {
 			CLOUDFLARE_API_KEY: "123456789",
 			CLOUDFLARE_EMAIL: "user@example.com",
 		};
-		setMockResponse("/accounts", () => {
-			return [
-				{ name: "Account One", id: "account-1" },
-				{ name: "Account Two", id: "account-2" },
-				{ name: "Account Three", id: "account-3" },
-			];
-		});
 
 		const userInfo = await getUserInfo();
 		expect(userInfo).toEqual({
@@ -114,13 +127,6 @@ describe("getUserInfo()", () => {
 			CLOUDFLARE_EMAIL: "user@example.com",
 			CLOUDFLARE_API_TOKEN: "123456789",
 		};
-		setMockResponse("/accounts", () => {
-			return [
-				{ name: "Account One", id: "account-1" },
-				{ name: "Account Two", id: "account-2" },
-				{ name: "Account Three", id: "account-3" },
-			];
-		});
 
 		const userInfo = await getUserInfo();
 		expect(userInfo).toEqual({
@@ -145,18 +151,6 @@ describe("getUserInfo()", () => {
 
 	it("should return the user's email and accounts if authenticated via config token", async () => {
 		writeAuthConfigFile({ oauth_token: "some-oauth-token" });
-
-		setMockResponse("/user", () => {
-			return { email: "user@example.com" };
-		});
-		setMockResponse("/accounts", () => {
-			return [
-				{ name: "Account One", id: "account-1" },
-				{ name: "Account Two", id: "account-2" },
-				{ name: "Account Three", id: "account-3" },
-			];
-		});
-
 		const userInfo = await getUserInfo();
 
 		expect(userInfo).toEqual({
@@ -173,26 +167,17 @@ describe("getUserInfo()", () => {
 
 	it("should display a warning message if the config file contains a legacy api_token field", async () => {
 		writeAuthConfigFile({ api_token: "API_TOKEN" });
-		setMockResponse("/user", () => {
-			return { email: "user@example.com" };
-		});
-		setMockResponse("/accounts", () => {
-			return [
-				{ name: "Account One", id: "account-1" },
-				{ name: "Account Two", id: "account-2" },
-				{ name: "Account Three", id: "account-3" },
-			];
-		});
 		await getUserInfo();
+
 		expect(std.warn).toMatchInlineSnapshot(`
-      "▲ [WARNING] It looks like you have used Wrangler 1's \`config\` command to login with an API token.
+		      "▲ [WARNING] It looks like you have used Wrangler 1's \`config\` command to login with an API token.
 
-        This is no longer supported in the current version of Wrangler.
-        If you wish to authenticate via an API token then please set the \`CLOUDFLARE_API_TOKEN\`
-        environment variable.
+		        This is no longer supported in the current version of Wrangler.
+		        If you wish to authenticate via an API token then please set the \`CLOUDFLARE_API_TOKEN\`
+		        environment variable.
 
-      "
-    `);
+		      "
+	    `);
 	});
 });
 

package/src/api/dev.ts

@@ -19,7 +19,8 @@ interface DevOptions {
 	nodeCompat?: boolean;
 	compatibilityDate?: string;
 	compatibilityFlags?: string[];
-	experimentalEnableLocalPersistence?: boolean;
+	persist?: boolean;
+	persistTo?: string;
 	liveReload?: boolean;
 	watch?: boolean;
 	vars?: {

package/src/dev/dev.tsx

@@ -136,7 +136,7 @@ export type DevProps = {
 	upstreamProtocol: "https" | "http";
 	localProtocol: "https" | "http";
 	localUpstream: string | undefined;
-	enableLocalPersistence: boolean;
+	localPersistencePath: string | null;
 	liveReload: boolean;
 	bindings: CfWorkerInit["bindings"];
 	define: Config["define"];
@@ -276,7 +276,7 @@ function DevSession(props: DevSessionProps) {
 			ip={props.ip}
 			rules={props.rules}
 			inspectorPort={props.inspectorPort}
-			enableLocalPersistence={props.enableLocalPersistence}
+			localPersistencePath={props.localPersistencePath}
 			liveReload={props.liveReload}
 			crons={props.crons}
 			localProtocol={props.localProtocol}

package/src/dev/local.tsx

@@ -42,7 +42,7 @@ export interface LocalProps {
 	ip: string;
 	rules: Config["rules"];
 	inspectorPort: number;
-	enableLocalPersistence: boolean;
+	localPersistencePath: string | null;
 	liveReload: boolean;
 	crons: Config["triggers"]["crons"];
 	localProtocol: "http" | "https";
@@ -77,7 +77,7 @@ function useLocalWorker({
 	port,
 	inspectorPort,
 	rules,
-	enableLocalPersistence,
+	localPersistencePath,
 	liveReload,
 	ip,
 	crons,
@@ -93,16 +93,6 @@ function useLocalWorker({
 	const local = useRef<ChildProcess>();
 	const removeSignalExitListener = useRef<() => void>();
 	const [inspectorUrl, setInspectorUrl] = useState<string | undefined>();
-	// if we're using local persistence for data, we should use the cwd
-	// as an explicit path, or else it'll use the temp dir
-	// which disappears when dev ends
-	const localPersistencePath = enableLocalPersistence
-		? // Maybe we could make the path configurable as well?
-		  path.join(process.cwd(), "wrangler-local-state")
-		: // We otherwise choose null, but choose true later
-		  // so that it's persisted in the temp dir across a dev session
-		  // even when we change source and reload
-		  null;
 
 	useEffect(() => {
 		if (bindings.services && bindings.services.length > 0) {

package/src/dev/start-server.ts

@@ -80,7 +80,7 @@ export async function startDevServer(
 			ip: props.ip,
 			rules: props.rules,
 			inspectorPort: props.inspectorPort,
-			enableLocalPersistence: props.enableLocalPersistence,
+			localPersistencePath: props.localPersistencePath,
 			liveReload: props.liveReload,
 			crons: props.crons,
 			localProtocol: props.localProtocol,
@@ -203,7 +203,7 @@ export async function startLocalServer({
 	port,
 	inspectorPort,
 	rules,
-	enableLocalPersistence,
+	localPersistencePath,
 	liveReload,
 	ip,
 	crons,
@@ -222,17 +222,6 @@ export async function startLocalServer({
 		inspectorUrl = url;
 	};
 
-	// if we're using local persistence for data, we should use the cwd
-	// as an explicit path, or else it'll use the temp dir
-	// which disappears when dev ends
-	const localPersistencePath = enableLocalPersistence
-		? // Maybe we could make the path configurable as well?
-		  path.join(process.cwd(), "wrangler-local-state")
-		: // We otherwise choose null, but choose true later
-		  // so that it's persisted in the temp dir across a dev session
-		  // even when we change source and reload
-		  null;
-
 	const abortController = new AbortController();
 	async function startLocalWorker() {
 		if (!bundle || !format) return;