wrangler 2.0.29 → 2.1.2

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__/tail.test.ts

@@ -14,6 +14,7 @@ import type {
 	ScheduledEvent,
 	AlarmEvent,
 } from "../tail";
+import type { RequestInit } from "undici";
 import type WebSocket from "ws";
 
 describe("tail", () => {
@@ -44,12 +45,12 @@ describe("tail", () => {
 
 		it("creates and then delete tails", async () => {
 			const api = mockWebsocketAPIs();
-			expect(api.requests.creation.count).toStrictEqual(0);
+			expect(api.requests.creation.length).toStrictEqual(0);
 
 			await runWrangler("tail test-worker");
 
 			await expect(api.ws.connected).resolves.toBeTruthy();
-			expect(api.requests.creation.count).toStrictEqual(1);
+			expect(api.requests.creation.length).toStrictEqual(1);
 			expect(api.requests.deletion.count).toStrictEqual(0);
 
 			api.ws.close();
@@ -57,7 +58,7 @@ describe("tail", () => {
 		});
 		it("should connect to the worker assigned to a given route", async () => {
 			const api = mockWebsocketAPIs();
-			expect(api.requests.creation.count).toStrictEqual(0);
+			expect(api.requests.creation.length).toStrictEqual(0);
 
 			mockGetZoneFromHostRequest("example.com", "test-zone");
 			mockCollectKnownRoutesRequest([
@@ -69,7 +70,7 @@ describe("tail", () => {
 			await runWrangler("tail example.com/*");
 
 			await expect(api.ws.connected).resolves.toBeTruthy();
-			expect(api.requests.creation.count).toStrictEqual(1);
+			expect(api.requests.creation.length).toStrictEqual(1);
 			expect(api.requests.deletion.count).toStrictEqual(0);
 
 			api.ws.close();
@@ -90,12 +91,12 @@ describe("tail", () => {
 
 		it("creates and then delete tails: legacy envs", async () => {
 			const api = mockWebsocketAPIs("some-env", true);
-			expect(api.requests.creation.count).toStrictEqual(0);
+			expect(api.requests.creation.length).toStrictEqual(0);
 
 			await runWrangler("tail test-worker --env some-env --legacy-env true");
 
 			await expect(api.ws.connected).resolves.toBeTruthy();
-			expect(api.requests.creation.count).toStrictEqual(1);
+			expect(api.requests.creation.length).toStrictEqual(1);
 			expect(api.requests.deletion.count).toStrictEqual(0);
 
 			api.ws.close();
@@ -104,12 +105,12 @@ describe("tail", () => {
 
 		it("creates and then delete tails: service envs", async () => {
 			const api = mockWebsocketAPIs("some-env");
-			expect(api.requests.creation.count).toStrictEqual(0);
+			expect(api.requests.creation.length).toStrictEqual(0);
 
 			await runWrangler("tail test-worker --env some-env --legacy-env false");
 
 			await expect(api.ws.connected).resolves.toBeTruthy();
-			expect(api.requests.creation.count).toStrictEqual(1);
+			expect(api.requests.creation.length).toStrictEqual(1);
 			expect(api.requests.deletion.count).toStrictEqual(0);
 
 			api.ws.close();
@@ -143,65 +144,57 @@ describe("tail", () => {
 			await expect(tooLow).rejects.toThrow();
 
 			await runWrangler("tail test-worker --sampling-rate 0.25");
-			await expect(api.nextMessageJson()).resolves.toHaveProperty("filters", [
-				{ sampling_rate: 0.25 },
-			]);
+			expect(api.requests.creation[0].body).toEqual(
+				`{"filters":[{"sampling_rate":0.25}]}`
+			);
 		});
 
 		it("sends single status filters", async () => {
 			const api = mockWebsocketAPIs();
 			await runWrangler("tail test-worker --status error");
-			await expect(api.nextMessageJson()).resolves.toHaveProperty("filters", [
-				{ outcome: ["exception", "exceededCpu", "exceededMemory", "unknown"] },
-			]);
+			expect(api.requests.creation[0].body).toEqual(
+				`{"filters":[{"outcome":["exception","exceededCpu","exceededMemory","unknown"]}]}`
+			);
 		});
 
 		it("sends multiple status filters", async () => {
 			const api = mockWebsocketAPIs();
 			await runWrangler("tail test-worker --status error --status canceled");
-			await expect(api.nextMessageJson()).resolves.toHaveProperty("filters", [
-				{
-					outcome: [
-						"exception",
-						"exceededCpu",
-						"exceededMemory",
-						"unknown",
-						"canceled",
-					],
-				},
-			]);
+			expect(api.requests.creation[0].body).toEqual(
+				`{"filters":[{"outcome":["exception","exceededCpu","exceededMemory","unknown","canceled"]}]}`
+			);
 		});
 
 		it("sends single HTTP method filters", async () => {
 			const api = mockWebsocketAPIs();
 			await runWrangler("tail test-worker --method POST");
-			await expect(api.nextMessageJson()).resolves.toHaveProperty("filters", [
-				{ method: ["POST"] },
-			]);
+			expect(api.requests.creation[0].body).toEqual(
+				`{"filters":[{"method":["POST"]}]}`
+			);
 		});
 
 		it("sends multiple HTTP method filters", async () => {
 			const api = mockWebsocketAPIs();
 			await runWrangler("tail test-worker --method POST --method GET");
-			await expect(api.nextMessageJson()).resolves.toHaveProperty("filters", [
-				{ method: ["POST", "GET"] },
-			]);
+			expect(api.requests.creation[0].body).toEqual(
+				`{"filters":[{"method":["POST","GET"]}]}`
+			);
 		});
 
 		it("sends header filters without a query", async () => {
 			const api = mockWebsocketAPIs();
 			await runWrangler("tail test-worker --header X-CUSTOM-HEADER");
-			await expect(api.nextMessageJson()).resolves.toHaveProperty("filters", [
-				{ header: { key: "X-CUSTOM-HEADER" } },
-			]);
+			expect(api.requests.creation[0].body).toEqual(
+				`{"filters":[{"header":{"key":"X-CUSTOM-HEADER"}}]}`
+			);
 		});
 
 		it("sends header filters with a query", async () => {
 			const api = mockWebsocketAPIs();
 			await runWrangler("tail test-worker --header X-CUSTOM-HEADER:some-value");
-			await expect(api.nextMessageJson()).resolves.toHaveProperty("filters", [
-				{ header: { key: "X-CUSTOM-HEADER", query: "some-value" } },
-			]);
+			expect(api.requests.creation[0].body).toEqual(
+				`{"filters":[{"header":{"key":"X-CUSTOM-HEADER","query":"some-value"}}]}`
+			);
 		});
 
 		it("sends single IP filters", async () => {
@@ -209,9 +202,9 @@ describe("tail", () => {
 			const fakeIp = "192.0.2.1";
 
 			await runWrangler(`tail test-worker --ip ${fakeIp}`);
-			await expect(api.nextMessageJson()).resolves.toHaveProperty("filters", [
-				{ client_ip: [fakeIp] },
-			]);
+			expect(api.requests.creation[0].body).toEqual(
+				`{"filters":[{"client_ip":["${fakeIp}"]}]}`
+			);
 		});
 
 		it("sends multiple IP filters", async () => {
@@ -219,9 +212,9 @@ describe("tail", () => {
 			const fakeIp = "192.0.2.1";
 
 			await runWrangler(`tail test-worker --ip ${fakeIp} --ip self`);
-			await expect(api.nextMessageJson()).resolves.toHaveProperty("filters", [
-				{ client_ip: [fakeIp, "self"] },
-			]);
+			expect(api.requests.creation[0].body).toEqual(
+				`{"filters":[{"client_ip":["${fakeIp}","self"]}]}`
+			);
 		});
 
 		it("sends search filters", async () => {
@@ -229,9 +222,9 @@ describe("tail", () => {
 			const search = "filterMe";
 
 			await runWrangler(`tail test-worker --search ${search}`);
-			await expect(api.nextMessageJson()).resolves.toHaveProperty("filters", [
-				{ query: search },
-			]);
+			expect(api.requests.creation[0].body).toEqual(
+				`{"filters":[{"query":"${search}"}]}`
+			);
 		});
 
 		it("sends everything but the kitchen sink", async () => {
@@ -252,30 +245,10 @@ describe("tail", () => {
 				`--search ${query} ` +
 				`--debug`;
 
-			const expectedWebsocketMessage = {
-				filters: [
-					{ sampling_rate },
-					{
-						outcome: [
-							"ok",
-							"exception",
-							"exceededCpu",
-							"exceededMemory",
-							"unknown",
-						],
-					},
-					{ method },
-					{ header: { key: "X-HELLO", query: "world" } },
-					{ client_ip },
-					{ query },
-				],
-				debug: true,
-			};
+			const expectedWebsocketMessage = `{"filters":[{"sampling_rate":0.69},{"outcome":["ok","exception","exceededCpu","exceededMemory","unknown"]},{"method":["GET","POST","PUT"]},{"header":{"key":"X-HELLO","query":"world"}},{"client_ip":["192.0.2.1","self"]},{"query":"onlyTheseMessagesPlease"}]}`;
 
 			await runWrangler(`tail test-worker ${cliFilters}`);
-			await expect(api.nextMessageJson()).resolves.toEqual(
-				expectedWebsocketMessage
-			);
+			expect(api.requests.creation[0].body).toEqual(expectedWebsocketMessage);
 		});
 	});
 
@@ -589,7 +562,7 @@ function deserializeToJson(message: WebSocket.RawData): string {
  */
 type MockAPI = {
 	requests: {
-		creation: RequestCounter;
+		creation: RequestInit[];
 		deletion: RequestCounter;
 	};
 	ws: MockWebSocket;
@@ -615,15 +588,15 @@ function mockCreateTailRequest(
 	websocketURL: string,
 	env?: string,
 	legacyEnv = false
-): RequestCounter {
-	const requests = { count: 0 };
+): RequestInit[] {
+	const requests: RequestInit[] = [];
 	const servicesOrScripts = env && !legacyEnv ? "services" : "scripts";
 	const environment = env && !legacyEnv ? "/environments/:envName" : "";
 	setMockResponse(
 		`/accounts/:accountId/workers/${servicesOrScripts}/:scriptName${environment}/tails`,
 		"POST",
-		([_url, accountId, scriptName, envName]) => {
-			requests.count++;
+		([_url, accountId, scriptName, envName], req) => {
+			requests.push(req);
 			expect(accountId).toEqual("some-account-id");
 			expect(scriptName).toEqual(
 				legacyEnv && env ? `test-worker-${env}` : "test-worker"
@@ -710,7 +683,7 @@ function mockWebsocketAPIs(env?: string, legacyEnv = false): MockAPI {
 	const api: MockAPI = {
 		requests: {
 			deletion: { count: 0 },
-			creation: { count: 0 },
+			creation: [],
 		},
 		// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
 		ws: null!, // will be set in the `beforeEach()` below.