wrangler 0.0.0-e2f9bb2 → 0.0.0-e30d1013

package/src/__tests__/r2.test.ts

@@ -1,214 +1,393 @@
+import * as fs from "node:fs";
+import { rest } from "msw";
+import prettyBytes from "pretty-bytes";
+import { MAX_UPLOAD_SIZE } from "../r2/constants";
 import { mockAccountId, mockApiToken } from "./helpers/mock-account-id";
-import { setMockResponse, unsetAllMocks } from "./helpers/mock-cfetch";
 import { mockConsoleMethods } from "./helpers/mock-console";
+import { msw, mswSuccessR2handlers } from "./helpers/msw";
 import { runInTempDir } from "./helpers/run-in-tmp";
 import { runWrangler } from "./helpers/run-wrangler";
-import type { R2BucketInfo } from "../r2";
-
-describe("wrangler", () => {
-  mockAccountId();
-  mockApiToken();
-  runInTempDir();
-  const std = mockConsoleMethods();
-
-  afterEach(() => {
-    unsetAllMocks();
-  });
-
-  describe("r2", () => {
-    describe("bucket", () => {
-      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 () => {
-          const expectedBuckets: R2BucketInfo[] = [
-            { name: "bucket-1", creation_date: "01-01-2001" },
-            { name: "bucket-2", creation_date: "01-01-2001" },
-          ];
-          mockListRequest(expectedBuckets);
-          await runWrangler("r2 bucket list");
-
-          expect(std.err).toMatchInlineSnapshot(`""`);
-          const buckets = JSON.parse(std.out);
-          expect(buckets).toEqual(expectedBuckets);
-        });
-      });
-
-      describe("create", () => {
-        function mockCreateRequest(expectedBucketName: string) {
-          const requests = { count: 0 };
-          setMockResponse(
-            "/accounts/:accountId/r2/buckets/:bucketName",
-            "PUT",
-            ([_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 create")
-          ).rejects.toThrowErrorMatchingInlineSnapshot(
-            `"Not enough non-option arguments: got 0, need at least 1"`
-          );
-          expect(std.out).toMatchInlineSnapshot(`
-            "
-            "
-          `);
-          expect(std.err).toMatchInlineSnapshot(`
-            "wrangler r2 bucket create <name>
-
-            Create a new R2 bucket
-
-            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]
-                  --legacy-env  Use legacy environments  [boolean]
-            X [ERROR] Not enough non-option arguments: got 0, need at least 1
-
-            "
-          `);
-        });
-
-        it("should error if the bucket to create contains spaces", async () => {
-          await expect(
-            runWrangler("r2 bucket create abc def ghi")
-          ).rejects.toThrowErrorMatchingInlineSnapshot(
-            `"Unknown arguments: def, ghi"`
-          );
-          expect(std.out).toMatchInlineSnapshot(`
-            "
-            "
-          `);
-          expect(std.err).toMatchInlineSnapshot(`
-            "wrangler r2 bucket create <name>
-
-            Create a new R2 bucket
-
-            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]
-                  --legacy-env  Use legacy environments  [boolean]
-            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."
-          `);
-          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")
-          ).rejects.toThrowErrorMatchingInlineSnapshot(
-            `"Not enough non-option arguments: got 0, need at least 1"`
-          );
-          expect(std.out).toMatchInlineSnapshot(`
-            "
-            "
-          `);
-          expect(std.err).toMatchInlineSnapshot(`
-            "wrangler r2 bucket delete <name>
-
-            Delete an R2 bucket
-
-            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]
-                  --legacy-env  Use legacy environments  [boolean]
-            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 () => {
-          await expect(
-            runWrangler("r2 bucket delete abc def ghi")
-          ).rejects.toThrowErrorMatchingInlineSnapshot(
-            `"Unknown arguments: def, ghi"`
-          );
-          expect(std.out).toMatchInlineSnapshot(`
-            "
-            "
-          `);
-          expect(std.err).toMatchInlineSnapshot(`
-            "wrangler r2 bucket delete <name>
-
-            Delete an R2 bucket
-
-            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]
-                  --legacy-env  Use legacy environments  [boolean]
-            X [ERROR] Unknown arguments: def, ghi
-
-            "
-          `);
-        });
-
-        it("should delete a bucket specified by name", async () => {
-          const requests = mockDeleteRequest("some-bucket");
-          await runWrangler(`r2 bucket delete some-bucket`);
-          expect(requests.count).toEqual(1);
-        });
-      });
-    });
-  });
+import type { R2BucketInfo } from "../r2/helpers";
+
+describe("r2", () => {
+	const std = mockConsoleMethods();
+	beforeEach(() => msw.use(...mswSuccessR2handlers));
+
+	mockAccountId();
+	mockApiToken();
+	runInTempDir();
+
+	describe("bucket", () => {
+		it("should show the correct help when an invalid command is passed", async () => {
+			await expect(() =>
+				runWrangler("r2 bucket foo")
+			).rejects.toThrowErrorMatchingInlineSnapshot(`"Unknown argument: foo"`);
+			expect(std.err).toMatchInlineSnapshot(`
+			          "X [ERROR] Unknown argument: foo
+
+			          "
+		        `);
+			expect(std.out).toMatchInlineSnapshot(`
+			"
+			wrangler r2 bucket
+
+			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
+
+			Flags:
+			  -c, --config   Path to .toml configuration file  [string]
+			  -e, --env      Environment to use for operations and .env files  [string]
+			  -h, --help     Show help  [boolean]
+			  -v, --version  Show version number  [boolean]"
+		`);
+		});
+
+		describe("list", () => {
+			it("should list buckets & check request inputs", async () => {
+				const expectedBuckets: R2BucketInfo[] = [
+					{ name: "bucket-1-local-once", creation_date: "01-01-2001" },
+					{ name: "bucket-2-local-once", creation_date: "01-01-2001" },
+				];
+				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(`""`);
+				const buckets = JSON.parse(std.out);
+				expect(buckets).toEqual(expectedBuckets);
+			});
+		});
+
+		describe("create", () => {
+			it("should error if no bucket name is given", async () => {
+				await expect(
+					runWrangler("r2 bucket create")
+				).rejects.toThrowErrorMatchingInlineSnapshot(
+					`"Not enough non-option arguments: got 0, need at least 1"`
+				);
+				expect(std.out).toMatchInlineSnapshot(`
+			"
+			wrangler r2 bucket create <name>
+
+			Create a new R2 bucket
+
+			Positionals:
+			  name  The name of the new bucket  [string] [required]
+
+			Flags:
+			  -c, --config   Path to .toml configuration file  [string]
+			  -e, --env      Environment to use for operations and .env files  [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
+
+				            "
+			          `);
+			});
+
+			it("should error if the bucket to create contains spaces", async () => {
+				await expect(
+					runWrangler("r2 bucket create abc def ghi")
+				).rejects.toThrowErrorMatchingInlineSnapshot(
+					`"Unknown arguments: def, ghi"`
+				);
+				expect(std.out).toMatchInlineSnapshot(`
+			"
+			wrangler r2 bucket create <name>
+
+			Create a new R2 bucket
+
+			Positionals:
+			  name  The name of the new bucket  [string] [required]
+
+			Flags:
+			  -c, --config   Path to .toml configuration file  [string]
+			  -e, --env      Environment to use for operations and .env files  [string]
+			  -h, --help     Show help  [boolean]
+			  -v, --version  Show version number  [boolean]"
+		`);
+				expect(std.err).toMatchInlineSnapshot(`
+				            "X [ERROR] Unknown arguments: def, ghi
+
+				            "
+			          `);
+			});
+
+			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."
+			          `);
+			});
+		});
+
+		describe("delete", () => {
+			it("should error if no bucket name is given", async () => {
+				await expect(
+					runWrangler("r2 bucket delete")
+				).rejects.toThrowErrorMatchingInlineSnapshot(
+					`"Not enough non-option arguments: got 0, need at least 1"`
+				);
+				expect(std.out).toMatchInlineSnapshot(`
+			"
+			wrangler r2 bucket delete <name>
+
+			Delete an R2 bucket
+
+			Positionals:
+			  name  The name of the bucket to delete  [string] [required]
+
+			Flags:
+			  -c, --config   Path to .toml configuration file  [string]
+			  -e, --env      Environment to use for operations and .env files  [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
+
+				            "
+			          `);
+			});
+
+			it("should error if the bucket name to delete contains spaces", async () => {
+				await expect(
+					runWrangler("r2 bucket delete abc def ghi")
+				).rejects.toThrowErrorMatchingInlineSnapshot(
+					`"Unknown arguments: def, ghi"`
+				);
+				expect(std.out).toMatchInlineSnapshot(`
+			"
+			wrangler r2 bucket delete <name>
+
+			Delete an R2 bucket
+
+			Positionals:
+			  name  The name of the bucket to delete  [string] [required]
+
+			Flags:
+			  -c, --config   Path to .toml configuration file  [string]
+			  -e, --env      Environment to use for operations and .env files  [string]
+			  -h, --help     Show help  [boolean]
+			  -v, --version  Show version number  [boolean]"
+		`);
+				expect(std.err).toMatchInlineSnapshot(`
+				            "X [ERROR] Unknown arguments: def, ghi
+
+				            "
+			          `);
+			});
+
+			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(std.out).toMatchInlineSnapshot(`
+				"Deleting bucket some-bucket.
+				Deleted bucket some-bucket."
+			`);
+			});
+		});
+	});
+
+	describe("r2 object", () => {
+		it("should download R2 object from bucket", async () => {
+			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 to bucket", async () => {
+			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 fail to upload R2 object to bucket if too large", async () => {
+			const TOO_BIG_FILE_SIZE = MAX_UPLOAD_SIZE + 1024 * 1024;
+			fs.writeFileSync("wormhole-img.png", Buffer.alloc(TOO_BIG_FILE_SIZE));
+			await expect(
+				runWrangler(
+					`r2 object put bucketName-object-test/wormhole-img.png --file ./wormhole-img.png`
+				)
+			).rejects.toThrowErrorMatchingInlineSnapshot(`
+			"Error: Wrangler only supports uploading files up to ${prettyBytes(
+				MAX_UPLOAD_SIZE
+			)} in size
+			wormhole-img.png is ${prettyBytes(TOO_BIG_FILE_SIZE)} in size"
+		`);
+		});
+
+		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");
+			const flags =
+				"--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`
+			);
+
+			expect(std.out).toMatchInlineSnapshot(`
+			"Creating object \\"wormhole-img.png\\" in bucket \\"bucketName-object-test\\".
+			Upload complete."
+		`);
+		});
+
+		it("should delete R2 object from bucket", async () => {
+			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");
+			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__/route.test.ts

@@ -3,43 +3,43 @@ import { runInTempDir } from "./helpers/run-in-tmp";
 import { runWrangler } from "./helpers/run-wrangler";
 
 describe("wrangler route", () => {
-  mockConsoleMethods();
-  runInTempDir();
+	mockConsoleMethods();
+	runInTempDir();
 
-  it("shows a deprecation notice when `wrangler route` is run", async () => {
-    await expect(runWrangler("route")).rejects
-      .toThrowErrorMatchingInlineSnapshot(`
+	it("shows a deprecation notice when `wrangler route` is run", async () => {
+		await expect(runWrangler("route")).rejects
+			.toThrowErrorMatchingInlineSnapshot(`
             "Deprecation:
             \`wrangler route\` has been deprecated.
             Please use wrangler.toml and/or \`wrangler publish --routes\` to modify routes"
           `);
-  });
+	});
 
-  it("shows a deprecation notice when `wrangler route delete` is run", async () => {
-    await expect(runWrangler("route delete")).rejects
-      .toThrowErrorMatchingInlineSnapshot(`
+	it("shows a deprecation notice when `wrangler route delete` is run", async () => {
+		await expect(runWrangler("route delete")).rejects
+			.toThrowErrorMatchingInlineSnapshot(`
             "Deprecation:
             \`wrangler route delete\` has been deprecated.
             Remove the unwanted route(s) from wrangler.toml and run \`wrangler publish\` to remove your worker from those routes."
           `);
-  });
+	});
 
-  it("shows a deprecation notice when `wrangler route delete <id>` is run", async () => {
-    await expect(runWrangler("route delete some-zone-id")).rejects
-      .toThrowErrorMatchingInlineSnapshot(`
+	it("shows a deprecation notice when `wrangler route delete <id>` is run", async () => {
+		await expect(runWrangler("route delete some-zone-id")).rejects
+			.toThrowErrorMatchingInlineSnapshot(`
             "Deprecation:
             \`wrangler route delete\` has been deprecated.
             Remove the unwanted route(s) from wrangler.toml and run \`wrangler publish\` to remove your worker from those routes."
           `);
-  });
+	});
 
-  it("shows a deprecation notice when `wrangler route list` is run", async () => {
-    await expect(runWrangler("route list")).rejects
-      .toThrowErrorMatchingInlineSnapshot(`
+	it("shows a deprecation notice when `wrangler route list` is run", async () => {
+		await expect(runWrangler("route list")).rejects
+			.toThrowErrorMatchingInlineSnapshot(`
             "Deprecation:
             \`wrangler route list\` has been deprecated.
             Refer to wrangler.toml for a list of routes the worker will be deployed to upon publishing.
             Refer to the Cloudflare Dashboard to see the routes this worker is currently running on."
           `);
-  });
+	});
 });