wrangler 0.0.0-ece06ea → 0.0.0-ecfbb0c

package/src/__tests__/pubsub.test.ts

@@ -0,0 +1,276 @@
+import { mockAccountId, mockApiToken } from "./helpers/mock-account-id";
+import { 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";
+import type {
+	PubSubNamespace,
+	PubSubBroker,
+	PubSubBrokerUpdate,
+	PubSubBrokerOnPublish,
+} from "../pubsub";
+
+describe("wrangler", () => {
+	mockAccountId();
+	mockApiToken();
+	runInTempDir();
+	const std = mockConsoleMethods();
+
+	afterEach(() => {
+		unsetAllMocks();
+	});
+
+	describe("pubsub", () => {
+		describe("namespaces", () => {
+			describe("create", () => {
+				function mockCreateRequest(expectedNamespaceName: string) {
+					const requests = { count: 0 };
+					setMockResponse(
+						"/accounts/:accountId/pubsub/namespaces",
+						"POST",
+						([_url, accountId], { body }) => {
+							expect(accountId).toEqual("some-account-id");
+							const namespaceName = JSON.parse(body as string).name;
+							expect(namespaceName).toEqual(expectedNamespaceName);
+							requests.count += 1;
+						}
+					);
+					return requests;
+				}
+
+				it("should create a namespace", async () => {
+					const requests = mockCreateRequest("my-namespace");
+					await runWrangler("pubsub namespace create my-namespace");
+					// TODO: check returned object
+					expect(requests.count).toEqual(1);
+				});
+			});
+
+			describe("list", () => {
+				function mockListRequest(namespaces: PubSubNamespace[]) {
+					const requests = { count: 0 };
+					setMockResponse(
+						"/accounts/:accountId/pubsub/namespaces",
+						([_url, accountId], init) => {
+							requests.count++;
+							expect(accountId).toEqual("some-account-id");
+							expect(init).toEqual({});
+							return { namespaces };
+						}
+					);
+					return requests;
+				}
+
+				it("should list namespaces", async () => {
+					const expectedNamespaces: PubSubNamespace[] = [
+						{ name: "namespace-1", created_on: "01-01-2001" },
+						{ name: "namespace-2", created_on: "01-01-2001" },
+					];
+					const requests = mockListRequest(expectedNamespaces);
+					await runWrangler("pubsub namespace list");
+
+					expect(std.err).toMatchInlineSnapshot(`""`);
+					// TODO(elithrar): check returned object
+					expect(requests.count).toEqual(1);
+				});
+			});
+		});
+
+		describe("brokers", () => {
+			describe("create", () => {
+				function mockCreateRequest(expectedBrokerName: string) {
+					const requests = { count: 0 };
+					setMockResponse(
+						"/accounts/:accountId/pubsub/namespaces/:namespaceName/brokers",
+						"POST",
+						([_url, accountId, namespaceName], { body }) => {
+							expect(accountId).toEqual("some-account-id");
+							expect(namespaceName).toEqual("some-namespace");
+							const brokerName = JSON.parse(body as string).name;
+							expect(brokerName).toEqual(expectedBrokerName);
+							requests.count += 1;
+						}
+					);
+					return requests;
+				}
+
+				it("should create a broker", async () => {
+					const requests = mockCreateRequest("my-broker");
+					await runWrangler(
+						"pubsub broker create my-broker --namespace=some-namespace"
+					);
+
+					// TODO: check returned object
+					expect(requests.count).toEqual(1);
+				});
+
+				it("fail to create broker when no namespace is set", async () => {
+					await expect(
+						runWrangler("pubsub broker create my-broker")
+					).rejects.toThrowErrorMatchingInlineSnapshot(
+						`"Missing required argument: namespace"`
+					);
+				});
+			});
+
+			describe("update", () => {
+				function mockUpdateRequest(
+					expectedBrokerName: string,
+					expectedExpiration: number,
+					expectedDescription: string,
+					expectedOnPublishConfig: PubSubBrokerOnPublish
+				) {
+					const requests = { count: 0 };
+					setMockResponse(
+						"/accounts/:accountId/pubsub/namespaces/:namespaceName/brokers/:brokerName",
+						"PATCH",
+						([_url, accountId, namespaceName, brokerName], { body }) => {
+							expect(accountId).toEqual("some-account-id");
+							expect(namespaceName).toEqual("some-namespace");
+							expect(brokerName).toEqual(expectedBrokerName);
+
+							const patchBody: PubSubBrokerUpdate = JSON.parse(body as string);
+							expect(patchBody.expiration).toEqual(expectedExpiration);
+							expect(patchBody.description).toEqual(expectedDescription);
+							expect(patchBody.on_publish).toEqual(expectedOnPublishConfig);
+
+							requests.count += 1;
+						}
+					);
+					return requests;
+				}
+
+				it("should update a broker's properties", async () => {
+					const expectedOnPublish: PubSubBrokerOnPublish = {
+						url: "https://foo.bar.example.com",
+					};
+					const requests = mockUpdateRequest(
+						"my-broker",
+						86400,
+						"hello",
+						expectedOnPublish
+					);
+					await runWrangler(
+						"pubsub broker update my-broker --namespace=some-namespace --expiration=24h --description='hello' --on-publish-url='https://foo.bar.example.com'"
+					);
+
+					expect(std.err).toMatchInlineSnapshot(`""`);
+					// TODO(elithrar): check returned object
+					expect(requests.count).toEqual(1);
+				});
+			});
+
+			describe("list", () => {
+				function mockListRequest(brokers: PubSubBroker[]) {
+					const requests = { count: 0 };
+					setMockResponse(
+						"/accounts/:accountId/pubsub/namespaces/:namespaceName/brokers",
+						([_url, accountId, namespaceName], init) => {
+							requests.count++;
+							expect(accountId).toEqual("some-account-id");
+							expect(namespaceName).toEqual("some-namespace");
+							expect(init).toEqual({});
+							return { brokers };
+						}
+					);
+					return requests;
+				}
+
+				it("should list brokers", async () => {
+					const expectedBrokers: PubSubBroker[] = [
+						{ name: "broker-1", created_on: "01-01-2001" },
+						{ name: "broker-2", created_on: "01-01-2001" },
+					];
+					const requests = mockListRequest(expectedBrokers);
+					await runWrangler("pubsub broker list --namespace=some-namespace");
+
+					expect(std.err).toMatchInlineSnapshot(`""`);
+					// TODO(elithrar): check returned object
+					expect(requests.count).toEqual(1);
+				});
+			});
+
+			describe("describe", () => {
+				function mockGetRequest(broker: PubSubBroker) {
+					const requests = { count: 0 };
+					setMockResponse(
+						"/accounts/:accountId/pubsub/namespaces/:namespaceName/brokers/:brokerName",
+						([_url, accountId, namespaceName, brokerName]) => {
+							requests.count++;
+							expect(accountId).toEqual("some-account-id");
+							expect(namespaceName).toEqual("some-namespace");
+							expect(brokerName).toEqual(broker.name);
+							return { result: broker };
+						}
+					);
+					return requests;
+				}
+
+				it("should describe a single broker", async () => {
+					const requests = mockGetRequest({ id: "1234", name: "my-broker" });
+					await runWrangler(
+						"pubsub broker describe my-broker --namespace=some-namespace"
+					);
+
+					expect(std.err).toMatchInlineSnapshot(`""`);
+					// TODO(elithrar): check returned object
+					expect(requests.count).toEqual(1);
+				});
+			});
+
+			describe("issue", () => {
+				function mockIssueRequest(expectedBrokerName: string) {
+					const requests = { count: 0 };
+					setMockResponse(
+						"/accounts/:accountId/pubsub/namespaces/:namespaceName/brokers/:brokerName/credentials",
+						([_url, accountId, namespaceName, brokerName]) => {
+							expect(accountId).toEqual("some-account-id");
+							expect(namespaceName).toEqual("some-namespace");
+							expect(brokerName).toEqual(expectedBrokerName);
+							requests.count += 1;
+						}
+					);
+					return requests;
+				}
+
+				it("should issue a token for the broker", async () => {
+					const requests = mockIssueRequest("my-broker");
+					await runWrangler(
+						"pubsub broker issue my-broker --namespace=some-namespace"
+					);
+
+					expect(std.err).toMatchInlineSnapshot(`""`);
+					// TODO(elithrar): check returned object
+					expect(requests.count).toEqual(1);
+				});
+			});
+
+			describe("public-keys", () => {
+				function mockIssueRequest(expectedBrokerName: string) {
+					const requests = { count: 0 };
+					setMockResponse(
+						"/accounts/:accountId/pubsub/namespaces/:namespaceName/brokers/:brokerName/publickeys",
+						([_url, accountId, namespaceName, brokerName]) => {
+							expect(accountId).toEqual("some-account-id");
+							expect(namespaceName).toEqual("some-namespace");
+							expect(brokerName).toEqual(expectedBrokerName);
+							requests.count += 1;
+						}
+					);
+					return requests;
+				}
+
+				it("should return the public keys for a broker", async () => {
+					const requests = mockIssueRequest("my-broker");
+					await runWrangler(
+						"pubsub broker public-keys my-broker --namespace=some-namespace"
+					);
+
+					expect(std.err).toMatchInlineSnapshot(`""`);
+					// TODO(elithrar): check returned object
+					expect(requests.count).toEqual(1);
+				});
+			});
+		});
+	});
+});

package/src/__tests__/r2.test.ts

@@ -0,0 +1,233 @@
+import { mockAccountId, mockApiToken } from "./helpers/mock-account-id";
+import { 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";
+import type { R2BucketInfo } from "../r2";
+
+describe("wrangler", () => {
+	mockAccountId();
+	mockApiToken();
+	runInTempDir();
+	const std = mockConsoleMethods();
+
+	afterEach(() => {
+		unsetAllMocks();
+	});
+
+	describe("r2", () => {
+		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]
+            -h, --help     Show help  [boolean]
+            -v, --version  Show version number  [boolean]"
+        `);
+			});
+
+			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(`
+            "
+            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]"
+          `);
+					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]
+              -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", 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(`
+            "
+            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]"
+          `);
+					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]
+              -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", async () => {
+					const requests = mockDeleteRequest("some-bucket");
+					await runWrangler(`r2 bucket delete some-bucket`);
+					expect(requests.count).toEqual(1);
+				});
+			});
+		});
+	});
+});

package/src/__tests__/route.test.ts

@@ -0,0 +1,45 @@
+import { mockConsoleMethods } from "./helpers/mock-console";
+import { runInTempDir } from "./helpers/run-in-tmp";
+import { runWrangler } from "./helpers/run-wrangler";
+
+describe("wrangler route", () => {
+	mockConsoleMethods();
+	runInTempDir();
+
+	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(`
+            "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(`
+            "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(`
+            "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."
+          `);
+	});
+});