wrangler 2.0.22 → 2.0.25

package/src/__tests__/r2.test.ts

@@ -1,5 +1,10 @@
+import * as fs from "node:fs";
 import { mockAccountId, mockApiToken } from "./helpers/mock-account-id";
-import { setMockResponse, unsetAllMocks } from "./helpers/mock-cfetch";
+import {
+	setMockFetchR2Objects,
+	setMockResponse,
+	unsetAllMocks,
+} from "./helpers/mock-cfetch";
 import { mockConsoleMethods } from "./helpers/mock-console";
 import { runInTempDir } from "./helpers/run-in-tmp";
 import { runWrangler } from "./helpers/run-wrangler";
@@ -22,26 +27,26 @@ describe("wrangler", () => {
 					runWrangler("r2 bucket foo")
 				).rejects.toThrowErrorMatchingInlineSnapshot(`"Unknown argument: foo"`);
 				expect(std.err).toMatchInlineSnapshot(`
-          "X [ERROR] Unknown argument: foo
+			          "X [ERROR] Unknown argument: foo
 
-          "
-        `);
+			          "
+		        `);
 				expect(std.out).toMatchInlineSnapshot(`
-          "
-          wrangler r2 bucket
+			          "
+			          wrangler r2 bucket
 
-          Manage R2 buckets
+			          Manage R2 buckets
 
-          Commands:
-            wrangler r2 bucket create <name>  Create a new R2 bucket
-            wrangler r2 bucket list           List R2 buckets
-            wrangler r2 bucket delete <name>  Delete an R2 bucket
+			          Commands:
+			            wrangler r2 bucket create <name>  Create a new R2 bucket
+			            wrangler r2 bucket list           List R2 buckets
+			            wrangler r2 bucket delete <name>  Delete an R2 bucket
 
-          Flags:
-            -c, --config   Path to .toml configuration file  [string]
-            -h, --help     Show help  [boolean]
-            -v, --version  Show version number  [boolean]"
-        `);
+			          Flags:
+			            -c, --config   Path to .toml configuration file  [string]
+			            -h, --help     Show help  [boolean]
+			            -v, --version  Show version number  [boolean]"
+		        `);
 			});
 
 			describe("list", () => {
@@ -95,24 +100,24 @@ describe("wrangler", () => {
 						`"Not enough non-option arguments: got 0, need at least 1"`
 					);
 					expect(std.out).toMatchInlineSnapshot(`
-            "
-            wrangler r2 bucket create <name>
+				            "
+				            wrangler r2 bucket create <name>
 
-            Create a new R2 bucket
+				            Create a new R2 bucket
 
-            Positionals:
-              name  The name of the new bucket  [string] [required]
+				            Positionals:
+				              name  The name of the new bucket  [string] [required]
 
-            Flags:
-              -c, --config   Path to .toml configuration file  [string]
-              -h, --help     Show help  [boolean]
-              -v, --version  Show version number  [boolean]"
-          `);
+				            Flags:
+				              -c, --config   Path to .toml configuration file  [string]
+				              -h, --help     Show help  [boolean]
+				              -v, --version  Show version number  [boolean]"
+			          `);
 					expect(std.err).toMatchInlineSnapshot(`
-            "X [ERROR] Not enough non-option arguments: got 0, need at least 1
+				            "X [ERROR] Not enough non-option arguments: got 0, need at least 1
 
-            "
-          `);
+				            "
+			          `);
 				});
 
 				it("should error if the bucket to create contains spaces", async () => {
@@ -122,33 +127,33 @@ describe("wrangler", () => {
 						`"Unknown arguments: def, ghi"`
 					);
 					expect(std.out).toMatchInlineSnapshot(`
-            "
-            wrangler r2 bucket create <name>
+				            "
+				            wrangler r2 bucket create <name>
 
-            Create a new R2 bucket
+				            Create a new R2 bucket
 
-            Positionals:
-              name  The name of the new bucket  [string] [required]
+				            Positionals:
+				              name  The name of the new bucket  [string] [required]
 
-            Flags:
-              -c, --config   Path to .toml configuration file  [string]
-              -h, --help     Show help  [boolean]
-              -v, --version  Show version number  [boolean]"
-          `);
+				            Flags:
+				              -c, --config   Path to .toml configuration file  [string]
+				              -h, --help     Show help  [boolean]
+				              -v, --version  Show version number  [boolean]"
+			          `);
 					expect(std.err).toMatchInlineSnapshot(`
-            "X [ERROR] Unknown arguments: def, ghi
+				            "X [ERROR] Unknown arguments: def, ghi
 
-            "
-          `);
+				            "
+			          `);
 				});
 
 				it("should create a bucket", async () => {
 					const requests = mockCreateRequest("testBucket");
 					await runWrangler("r2 bucket create testBucket");
 					expect(std.out).toMatchInlineSnapshot(`
-            "Creating bucket testBucket.
-            Created bucket testBucket."
-          `);
+				            "Creating bucket testBucket.
+				            Created bucket testBucket."
+			          `);
 					expect(requests.count).toEqual(1);
 				});
 			});
@@ -175,24 +180,24 @@ describe("wrangler", () => {
 						`"Not enough non-option arguments: got 0, need at least 1"`
 					);
 					expect(std.out).toMatchInlineSnapshot(`
-            "
-            wrangler r2 bucket delete <name>
+				            "
+				            wrangler r2 bucket delete <name>
 
-            Delete an R2 bucket
+				            Delete an R2 bucket
 
-            Positionals:
-              name  The name of the bucket to delete  [string] [required]
+				            Positionals:
+				              name  The name of the bucket to delete  [string] [required]
 
-            Flags:
-              -c, --config   Path to .toml configuration file  [string]
-              -h, --help     Show help  [boolean]
-              -v, --version  Show version number  [boolean]"
-          `);
+				            Flags:
+				              -c, --config   Path to .toml configuration file  [string]
+				              -h, --help     Show help  [boolean]
+				              -v, --version  Show version number  [boolean]"
+			          `);
 					expect(std.err).toMatchInlineSnapshot(`
-            "X [ERROR] Not enough non-option arguments: got 0, need at least 1
+				            "X [ERROR] Not enough non-option arguments: got 0, need at least 1
 
-            "
-          `);
+				            "
+			          `);
 				});
 
 				it("should error if the bucket name to delete contains spaces", async () => {
@@ -202,24 +207,24 @@ describe("wrangler", () => {
 						`"Unknown arguments: def, ghi"`
 					);
 					expect(std.out).toMatchInlineSnapshot(`
-            "
-            wrangler r2 bucket delete <name>
+				            "
+				            wrangler r2 bucket delete <name>
 
-            Delete an R2 bucket
+				            Delete an R2 bucket
 
-            Positionals:
-              name  The name of the bucket to delete  [string] [required]
+				            Positionals:
+				              name  The name of the bucket to delete  [string] [required]
 
-            Flags:
-              -c, --config   Path to .toml configuration file  [string]
-              -h, --help     Show help  [boolean]
-              -v, --version  Show version number  [boolean]"
-          `);
+				            Flags:
+				              -c, --config   Path to .toml configuration file  [string]
+				              -h, --help     Show help  [boolean]
+				              -v, --version  Show version number  [boolean]"
+			          `);
 					expect(std.err).toMatchInlineSnapshot(`
-            "X [ERROR] Unknown arguments: def, ghi
+				            "X [ERROR] Unknown arguments: def, ghi
 
-            "
-          `);
+				            "
+			          `);
 				});
 
 				it("should delete a bucket specified by name", async () => {
@@ -229,5 +234,102 @@ describe("wrangler", () => {
 				});
 			});
 		});
+
+		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`
+				);
+
+				expect(std.out).toMatchInlineSnapshot(`
+			"Downloading \\"wormhole-img.png\\" from \\"bucketName-object-test\\".
+			Download complete."
+		`);
+			});
+
+			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`
+				);
+
+				expect(std.out).toMatchInlineSnapshot(`
+			"Creating object \\"wormhole-img.png\\" in bucket \\"bucketName-object-test\\".
+			Upload complete."
+		`);
+			});
+
+			it("should pass all fetch option flags into requestInit", async () => {
+				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";
+
+				await runWrangler(
+					`r2 object put bucketName-object-test/wormhole-img.png ${flags} --file wormhole-img.png`
+				);
+
+				expect(std.out).toMatchInlineSnapshot(`
+			"Creating object \\"wormhole-img.png\\" in bucket \\"bucketName-object-test\\".
+			Upload complete."
+		`);
+			});
+
+			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`
+				);
+
+				expect(std.out).toMatchInlineSnapshot(`
+			"Deleting object \\"wormhole-img.png\\" from bucket \\"bucketName-object-test\\".
+			Delete complete."
+		`);
+			});
+
+			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`
+					)
+				).rejects.toThrowErrorMatchingInlineSnapshot(
+					`"Arguments pipe and file are mutually exclusive"`
+				);
+
+				expect(std.err).toMatchInlineSnapshot(`
+			"X [ERROR] Arguments pipe and file are mutually exclusive
+
+			"
+		`);
+			});
+		});
 	});
 });

package/src/__tests__/tail.test.ts

@@ -6,7 +6,12 @@ import { mockConsoleMethods } from "./helpers/mock-console";
 import { useMockIsTTY } from "./helpers/mock-istty";
 import { runInTempDir } from "./helpers/run-in-tmp";
 import { runWrangler } from "./helpers/run-wrangler";
-import type { TailEventMessage, RequestEvent, ScheduledEvent } from "../tail";
+import type {
+	TailEventMessage,
+	RequestEvent,
+	ScheduledEvent,
+	AlarmEvent,
+} from "../tail";
 import type WebSocket from "ws";
 
 describe("tail", () => {
@@ -251,6 +256,18 @@ describe("tail", () => {
 			expect(std.out).toMatch(deserializeToJson(serializedMessage));
 		});
 
+		it("logs alarm messages in json format", async () => {
+			const api = mockWebsocketAPIs();
+			await runWrangler("tail test-worker --format json");
+
+			const event = generateMockAlarmEvent();
+			const message = generateMockEventMessage({ event });
+			const serializedMessage = serialize(message);
+
+			api.ws.send(serializedMessage);
+			expect(std.out).toMatch(deserializeToJson(serializedMessage));
+		});
+
 		it("logs request messages in pretty format", async () => {
 			const api = mockWebsocketAPIs();
 			await runWrangler("tail test-worker --format pretty");
@@ -271,10 +288,10 @@ describe("tail", () => {
 						"[mock expiration date]"
 					)
 			).toMatchInlineSnapshot(`
-        "Successfully created tail, expires at [mock expiration date]
-        Connected to test-worker, waiting for logs...
-        GET https://example.org/ - Ok @ [mock event timestamp]"
-      `);
+			        "Successfully created tail, expires at [mock expiration date]
+			        Connected to test-worker, waiting for logs...
+			        GET https://example.org/ - Ok @ [mock event timestamp]"
+		      `);
 		});
 
 		it("logs scheduled messages in pretty format", async () => {
@@ -297,35 +314,61 @@ describe("tail", () => {
 						"[mock expiration date]"
 					)
 			).toMatchInlineSnapshot(`
-        "Successfully created tail, expires at [mock expiration date]
-        Connected to test-worker, waiting for logs...
-        \\"* * * * *\\" @ [mock timestamp string] - Ok"
-      `);
+			        "Successfully created tail, expires at [mock expiration date]
+			        Connected to test-worker, waiting for logs...
+			        \\"* * * * *\\" @ [mock timestamp string] - Ok"
+		      `);
 		});
 
-		it("should not crash when the tail message has a void event", async () => {
+		it("logs alarm messages in pretty format", async () => {
 			const api = mockWebsocketAPIs();
 			await runWrangler("tail test-worker --format pretty");
 
-			const message = generateMockEventMessage({ event: null });
+			const event = generateMockAlarmEvent();
+			const message = generateMockEventMessage({ event });
 			const serializedMessage = serialize(message);
 
 			api.ws.send(serializedMessage);
 			expect(
 				std.out
 					.replace(
-						new Date(mockEventTimestamp).toLocaleString(),
-						"[mock timestamp string]"
+						new Date(mockEventScheduledTime).toLocaleString(),
+						"[mock scheduled time]"
 					)
 					.replace(
 						mockTailExpiration.toLocaleString(),
 						"[mock expiration date]"
 					)
 			).toMatchInlineSnapshot(`
-        "Successfully created tail, expires at [mock expiration date]
-        Connected to test-worker, waiting for logs...
-        [missing request] - Ok @ [mock timestamp string]"
-      `);
+			        "Successfully created tail, expires at [mock expiration date]
+			        Connected to test-worker, waiting for logs...
+			        Alarm @ [mock scheduled time] - Ok"
+		      `);
+		});
+
+		it("should not crash when the tail message has a void event", async () => {
+			const api = mockWebsocketAPIs();
+			await runWrangler("tail test-worker --format pretty");
+
+			const message = generateMockEventMessage({ event: null });
+			const serializedMessage = serialize(message);
+
+			api.ws.send(serializedMessage);
+			expect(
+				std.out
+					.replace(
+						mockTailExpiration.toLocaleString(),
+						"[mock expiration date]"
+					)
+					.replace(
+						new Date(mockEventTimestamp).toLocaleString(),
+						"[mock timestamp string]"
+					)
+			).toMatchInlineSnapshot(`
+			"Successfully created tail, expires at [mock expiration date]
+			Connected to test-worker, waiting for logs...
+			Unknown Event - Ok @ [mock timestamp string]"
+		`);
 		});
 
 		it("defaults to logging in pretty format when the output is a TTY", async () => {
@@ -349,10 +392,10 @@ describe("tail", () => {
 						"[mock expiration date]"
 					)
 			).toMatchInlineSnapshot(`
-        "Successfully created tail, expires at [mock expiration date]
-        Connected to test-worker, waiting for logs...
-        GET https://example.org/ - Ok @ [mock event timestamp]"
-      `);
+			        "Successfully created tail, expires at [mock expiration date]
+			        Connected to test-worker, waiting for logs...
+			        GET https://example.org/ - Ok @ [mock event timestamp]"
+		      `);
 		});
 
 		it("defaults to logging in json format when the output is not a TTY", async () => {
@@ -405,21 +448,21 @@ describe("tail", () => {
 						"[mock expiration date]"
 					)
 			).toMatchInlineSnapshot(`
-        "Successfully created tail, expires at [mock expiration date]
-        Connected to test-worker, waiting for logs...
-        GET https://example.org/ - Ok @ [mock event timestamp]
-          (log) some string
-          (log) { complex: 'object' }
-          (error) 1234"
-      `);
+			        "Successfully created tail, expires at [mock expiration date]
+			        Connected to test-worker, waiting for logs...
+			        GET https://example.org/ - Ok @ [mock event timestamp]
+			          (log) some string
+			          (log) { complex: 'object' }
+			          (error) 1234"
+		      `);
 			expect(std.err).toMatchInlineSnapshot(`
-        "X [ERROR]   Error: some error
+			        "X [ERROR]   Error: some error
 
 
-        X [ERROR]   Error: { complex: 'error' }
+			        X [ERROR]   Error: { complex: 'error' }
 
-        "
-      `);
+			        "
+		      `);
 			expect(std.warn).toMatchInlineSnapshot(`""`);
 		});
 	});
@@ -437,8 +480,8 @@ describe("tail", () => {
  * @returns the same type we expect when deserializing in wrangler
  */
 function serialize(message: TailEventMessage): WebSocket.RawData {
-	if (isScheduled(message.event)) {
-		// `ScheduledEvent`s work just fine
+	if (!isRequest(message.event)) {
+		// `ScheduledEvent`s and `TailEvent`s work just fine
 		const stringified = JSON.stringify(message);
 		return Buffer.from(stringified, "utf-8");
 	} else {
@@ -470,12 +513,12 @@ function serialize(message: TailEventMessage): WebSocket.RawData {
  * Small helper to disambiguate the event types possible in a `TailEventMessage`
  *
  * @param event A TailEvent
- * @returns whether event is a ScheduledEvent (true) or a RequestEvent
+ * @returns true if `event` is a RequestEvent
  */
-function isScheduled(
-	event: ScheduledEvent | RequestEvent | undefined | null
-): event is ScheduledEvent {
-	return Boolean(event && "cron" in event);
+function isRequest(
+	event: ScheduledEvent | RequestEvent | AlarmEvent | undefined | null
+): event is RequestEvent {
+	return Boolean(event && "request" in event);
 }
 
 /**
@@ -559,6 +602,11 @@ const mockTailExpiration = new Date(3005, 1);
  */
 const mockEventTimestamp = 1645454470467;
 
+/**
+ * Default value for event time ISO strings
+ */
+const mockEventScheduledTime = new Date(mockEventTimestamp).toISOString();
+
 /**
  * Mock out the API hit during Tail deletion
  *
@@ -696,3 +744,9 @@ function generateMockScheduledEvent(
 		scheduledTime: opts?.scheduledTime || mockEventTimestamp,
 	};
 }
+
+function generateMockAlarmEvent(opts?: Partial<AlarmEvent>): AlarmEvent {
+	return {
+		scheduledTime: opts?.scheduledTime || mockEventScheduledTime,
+	};
+}

package/src/__tests__/user.test.ts

@@ -56,6 +56,7 @@ describe("User", () => {
 				oauth_token: "test-access-token",
 				refresh_token: "test-refresh-token",
 				expiration_time: expect.any(String),
+				scopes: ["account:read"],
 			});
 		});
 	});

package/src/__tests__/validate-dev-props.test.ts

@@ -0,0 +1,56 @@
+import { validateDevProps } from "../dev/validate-dev-props";
+import type { DevProps } from "../dev/dev";
+
+describe("validateDevProps", () => {
+	it("should throw if the user tries to use the service-worker format with an `assets` directory", () => {
+		const props = {
+			isWorkersSite: false,
+			assetPaths: ["assets"],
+			entry: { format: "service-worker" },
+			bindings: {},
+		};
+
+		expect(() => validateDevProps(props as unknown as DevProps)).toThrowError(
+			"You cannot use the service-worker format with an `assets` directory yet. For information on how to migrate to the module-worker format, see: https://developers.cloudflare.com/workers/learning/migrating-to-module-workers/"
+		);
+	});
+
+	it("should throw if the user tries to configure [wasm_modules] with an ES module worker", () => {
+		const props = {
+			isWorkersSite: false,
+			assetPaths: [],
+			entry: { format: "modules" },
+			bindings: { wasm_modules: true },
+		};
+
+		expect(() => validateDevProps(props as unknown as DevProps)).toThrowError(
+			"You cannot configure [wasm_modules] with an ES module worker. Instead, import the .wasm module directly in your code"
+		);
+	});
+
+	it("should throw if the user tries to configure [text_blobs] with an ES module worker", () => {
+		const props = {
+			isWorkersSite: false,
+			assetPaths: [],
+			entry: { format: "modules" },
+			bindings: { text_blobs: true },
+		};
+
+		expect(() => validateDevProps(props as unknown as DevProps)).toThrowError(
+			"You cannot configure [text_blobs] with an ES module worker. Instead, import the file directly in your code, and optionally configure `[rules]` in your wrangler.toml"
+		);
+	});
+
+	it("should throw if the user tries to configure [data_blobs] with an ES module worker", () => {
+		const props = {
+			isWorkersSite: false,
+			assetPaths: [],
+			entry: { format: "modules" },
+			bindings: { data_blobs: true },
+		};
+
+		expect(() => validateDevProps(props as unknown as DevProps)).toThrowError(
+			"You cannot configure [data_blobs] with an ES module worker. Instead, import the file directly in your code, and optionally configure `[rules]` in your wrangler.toml"
+		);
+	});
+});

package/src/__tests__/version.test.ts

@@ -0,0 +1,35 @@
+import { version } from "./../../package.json";
+import { mockConsoleMethods } from "./helpers/mock-console";
+import { useMockIsTTY } from "./helpers/mock-istty";
+import { runWrangler } from "./helpers/run-wrangler";
+
+describe("version", () => {
+	const std = mockConsoleMethods();
+	const { setIsTTY } = useMockIsTTY();
+
+	// We cannot test output of version banner,
+	// as it is disabled in jest environments
+
+	// it("should output version banner", async () => {
+	// 	await runWrangler("-v");
+	// 	expect(std.out).toMatchInlineSnapshot(`
+	// 	" ⛅️ wrangler 2.0.22
+	// 	--------------------"
+	// `);
+	// });
+
+	it("should output current version if !isTTY calling -v", async () => {
+		setIsTTY(false);
+
+		await runWrangler("-v");
+		expect(std.out).toMatch(version);
+	});
+
+	// This run separately as command handling is different
+	it("should output current version if !isTTY calling --version", async () => {
+		setIsTTY(false);
+
+		await runWrangler("--version");
+		expect(std.out).toMatch(version);
+	});
+});