wrangler 0.0.0-e043479 → 0.0.0-e0621809

package/src/__tests__/whoami.test.tsx

@@ -1,86 +1,172 @@
-import { render } from "ink-testing-library";
-import React from "react";
-import { initialise } from "../user";
-import { getUserInfo, WhoAmI } from "../whoami";
-import { setMockResponse } from "./helpers/mock-cfetch";
-import { writeUserConfig } from "./helpers/mock-user";
+import { rest } from "msw";
+import { writeAuthConfigFile } from "../user";
+import { getUserInfo } from "../whoami";
+import { mockConsoleMethods } from "./helpers/mock-console";
+import { useMockIsTTY } from "./helpers/mock-istty";
+import {
+	createFetchResult,
+	msw,
+	mswSuccessOauthHandlers,
+	mswSuccessUserHandlers,
+} from "./helpers/msw";
 import { runInTempDir } from "./helpers/run-in-tmp";
-import type { UserInfo } from "../whoami";
 
 describe("getUserInfo()", () => {
-  runInTempDir({ homedir: "./home" });
-
-  it("should return undefined if there is no config file", async () => {
-    await initialise();
-    const userInfo = await getUserInfo();
-    expect(userInfo).toBeUndefined();
-  });
-
-  it("should return undefined if there is an empty config file", async () => {
-    writeUserConfig();
-    await initialise();
-    const userInfo = await getUserInfo();
-    expect(userInfo).toBeUndefined();
-  });
-
-  it("should return the user's email and accounts if authenticated via config token", async () => {
-    writeUserConfig("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" },
-      ];
-    });
-
-    await initialise();
-    const userInfo = await getUserInfo();
-
-    expect(userInfo).toEqual({
-      authType: "OAuth",
-      apiToken: "some-oauth-token",
-      email: "user@example.com",
-      accounts: [
-        { name: "Account One", id: "account-1" },
-        { name: "Account Two", id: "account-2" },
-        { name: "Account Three", id: "account-3" },
-      ],
-    });
-  });
-});
+	const ENV_COPY = process.env;
+
+	runInTempDir();
+	const std = mockConsoleMethods();
+	const { setIsTTY } = useMockIsTTY();
+
+	beforeEach(() => {
+		msw.use(...mswSuccessOauthHandlers, ...mswSuccessUserHandlers);
+		setIsTTY(true);
+	});
+
+	afterEach(() => {
+		process.env = ENV_COPY;
+	});
+
+	it("should return undefined if there is no config file", async () => {
+		const userInfo = await getUserInfo();
+		expect(userInfo).toBeUndefined();
+	});
+
+	it("should return undefined if there is an empty config file", async () => {
+		writeAuthConfigFile({});
+		const userInfo = await getUserInfo();
+		expect(userInfo).toBeUndefined();
+	});
+
+	it("should return undefined for email if the user settings API request fails with 9109", async () => {
+		process.env = {
+			CLOUDFLARE_API_TOKEN: "123456789",
+		};
+		msw.use(
+			rest.get("*/user", (_, res, ctx) => {
+				return res.once(
+					ctx.json(
+						createFetchResult({}, false, [
+							{
+								code: 9109,
+								message: "Uauthorized to access requested resource",
+							},
+						])
+					)
+				);
+			}),
+			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.json(createFetchResult([])));
+			})
+		);
+		const userInfo = await getUserInfo();
+		expect(userInfo?.email).toBeUndefined();
+	});
+	it("should say it's using an API token when one is set", async () => {
+		process.env = {
+			CLOUDFLARE_API_TOKEN: "123456789",
+		};
+
+		const userInfo = await getUserInfo();
+		expect(userInfo).toEqual({
+			authType: "API Token",
+			apiToken: "123456789",
+			email: "user@example.com",
+			accounts: [
+				{ name: "Account One", id: "account-1" },
+				{ name: "Account Two", id: "account-2" },
+				{ name: "Account Three", id: "account-3" },
+			],
+		});
+	});
+
+	it("should say it's using a Global API Key when one is set", async () => {
+		process.env = {
+			CLOUDFLARE_API_KEY: "123456789",
+			CLOUDFLARE_EMAIL: "user@example.com",
+		};
+
+		const userInfo = await getUserInfo();
+		expect(userInfo).toEqual({
+			authType: "Global API Key",
+			apiToken: "123456789",
+			email: "user@example.com",
+			accounts: [
+				{ name: "Account One", id: "account-1" },
+				{ name: "Account Two", id: "account-2" },
+				{ name: "Account Three", id: "account-3" },
+			],
+		});
+	});
+
+	it("should use a Global API Key in preference to an API token", async () => {
+		process.env = {
+			CLOUDFLARE_API_KEY: "123456789",
+			CLOUDFLARE_EMAIL: "user@example.com",
+			CLOUDFLARE_API_TOKEN: "123456789",
+		};
+
+		const userInfo = await getUserInfo();
+		expect(userInfo).toEqual({
+			authType: "Global API Key",
+			apiToken: "123456789",
+			email: "user@example.com",
+			accounts: [
+				{ name: "Account One", id: "account-1" },
+				{ name: "Account Two", id: "account-2" },
+				{ name: "Account Three", id: "account-3" },
+			],
+		});
+	});
+
+	it("should return undefined only a Global API Key, but not Email, is set", async () => {
+		process.env = {
+			CLOUDFLARE_API_KEY: "123456789",
+		};
+		const userInfo = await getUserInfo();
+		expect(userInfo).toEqual(undefined);
+	});
+
+	it("should return the user's email and accounts if authenticated via config token", async () => {
+		writeAuthConfigFile({ oauth_token: "some-oauth-token" });
+		const userInfo = await getUserInfo();
+
+		expect(userInfo).toEqual({
+			authType: "OAuth Token",
+			apiToken: "some-oauth-token",
+			email: "user@example.com",
+			accounts: [
+				{ name: "Account One", id: "account-1" },
+				{ name: "Account Two", id: "account-2" },
+				{ name: "Account Three", id: "account-3" },
+			],
+		});
+	});
+
+	it("should display a warning message if the config file contains a legacy api_token field", async () => {
+		writeAuthConfigFile({ api_token: "API_TOKEN" });
+		await getUserInfo();
+
+		expect(std.warn).toMatchInlineSnapshot(`
+		      "▲ [WARNING] It looks like you have used Wrangler v1'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.
 
-describe("WhoAmI component", () => {
-  it("should return undefined if there is no user", async () => {
-    const { lastFrame } = render(<WhoAmI user={undefined}></WhoAmI>);
-
-    expect(lastFrame()).toMatchInlineSnapshot(
-      `"You are not authenticated. Please run \`wrangler login\`."`
-    );
-  });
-
-  it("should display the user's email and accounts", async () => {
-    const user: UserInfo = {
-      authType: "OAuth",
-      apiToken: "some-oauth-token",
-      email: "user@example.com",
-      accounts: [
-        { name: "Account One", id: "account-1" },
-        { name: "Account Two", id: "account-2" },
-        { name: "Account Three", id: "account-3" },
-      ],
-    };
-
-    const { lastFrame } = render(<WhoAmI user={user}></WhoAmI>);
-
-    expect(lastFrame()).toContain(
-      "You are logged in with an OAuth Token, associated with the email 'user@example.com'!"
-    );
-    expect(lastFrame()).toMatch(/Account Name .+ Account ID/);
-    expect(lastFrame()).toMatch(/Account One .+ account-1/);
-    expect(lastFrame()).toMatch(/Account Two .+ account-2/);
-    expect(lastFrame()).toMatch(/Account Three .+ account-3/);
-  });
+		      "
+	    `);
+	});
 });

package/src/__tests__/worker-namespace.test.ts

@@ -0,0 +1,340 @@
+import { rest } from "msw";
+import { mockAccountId, mockApiToken } from "./helpers/mock-account-id";
+import { mockConsoleMethods } from "./helpers/mock-console";
+import {
+	createFetchResult,
+	msw,
+	mswSuccessNamespacesHandlers,
+} from "./helpers/msw";
+import { runInTempDir } from "./helpers/run-in-tmp";
+import { runWrangler } from "./helpers/run-wrangler";
+
+describe("dispatch-namespace", () => {
+	const std = mockConsoleMethods();
+	beforeEach(() => msw.use(...mswSuccessNamespacesHandlers));
+
+	runInTempDir();
+	mockAccountId();
+	mockApiToken();
+
+	it("should display a list of available subcommands, for dispatch-namespace with no subcommand", async () => {
+		await runWrangler("dispatch-namespace");
+
+		// wait a tick for the help menu to be printed
+		await new Promise((resolve) => setImmediate(resolve));
+
+		expect(std).toMatchInlineSnapshot(`
+		Object {
+		  "debug": "",
+		  "err": "",
+		  "info": "",
+		  "out": "wrangler dispatch-namespace
+
+		📦 Interact with a dispatch namespace
+
+		Commands:
+		  wrangler dispatch-namespace list                          List all dispatch namespaces
+		  wrangler dispatch-namespace get <name>                    Get information about a dispatch namespace
+		  wrangler dispatch-namespace create <name>                 Create a dispatch namespace
+		  wrangler dispatch-namespace delete <name>                 Delete a dispatch namespace
+		  wrangler dispatch-namespace rename <old-name> <new-name>  Rename a dispatch namespace
+
+		Flags:
+		  -j, --experimental-json-config  Experimental: Support wrangler.json  [boolean]
+		  -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]",
+		  "warn": "",
+		}
+	`);
+	});
+
+	describe("create namespace", () => {
+		const namespaceName = "my-namespace";
+		let counter = 0;
+		msw.use(
+			rest.post(
+				"*/accounts/:accountId/workers/dispatch/namespaces/:namespaceNameParam",
+				(req, res, ctx) => {
+					counter++;
+					const { namespaceNameParam } = req.params;
+					expect(counter).toBe(1);
+					expect(namespaceNameParam).toBe(namespaceName);
+					return res.once(
+						ctx.json(
+							createFetchResult({
+								namespace_id: "some-namespace-id",
+								namespace_name: "namespace-name",
+								created_on: "2022-06-29T14:30:08.16152Z",
+								created_by: "1fc1df98cc4420fe00367c3ab68c1639",
+								modified_on: "2022-06-29T14:30:08.16152Z",
+								modified_by: "1fc1df98cc4420fe00367c3ab68c1639",
+							})
+						)
+					);
+				}
+			)
+		);
+
+		it("should display help for create", async () => {
+			await expect(
+				runWrangler("dispatch-namespace create")
+			).rejects.toThrowErrorMatchingInlineSnapshot(
+				`"Not enough non-option arguments: got 0, need at least 1"`
+			);
+
+			expect(std.out).toMatchInlineSnapshot(`
+			"
+			wrangler dispatch-namespace create <name>
+
+			Create a dispatch namespace
+
+			Positionals:
+			  name  Name of the dispatch namespace  [string] [required]
+
+			Flags:
+			  -j, --experimental-json-config  Experimental: Support wrangler.json  [boolean]
+			  -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]"
+		`);
+		});
+
+		it("should attempt to create the given namespace", async () => {
+			await runWrangler(`dispatch-namespace create ${namespaceName}`);
+
+			expect(std.out).toMatchInlineSnapshot(
+				`"Created dispatch namespace \\"my-namespace\\" with ID \\"some-namespace-id\\""`
+			);
+		});
+	});
+
+	describe("delete namespace", () => {
+		const namespaceName = "my-namespace";
+		let counter = 0;
+		msw.use(
+			rest.delete(
+				"*/accounts/:accountId/workers/dispatch/namespaces/:namespaceNameParam",
+				(req, res, ctx) => {
+					counter++;
+					const { namespaceNameParam } = req.params;
+					expect(counter).toBe(1);
+					expect(namespaceNameParam).toBe(namespaceName);
+					return res.once(ctx.json(null));
+				}
+			)
+		);
+
+		it("should display help for delete", async () => {
+			await expect(
+				runWrangler("dispatch-namespace create")
+			).rejects.toThrowErrorMatchingInlineSnapshot(
+				`"Not enough non-option arguments: got 0, need at least 1"`
+			);
+
+			expect(std.out).toMatchInlineSnapshot(`
+			"
+			wrangler dispatch-namespace create <name>
+
+			Create a dispatch namespace
+
+			Positionals:
+			  name  Name of the dispatch namespace  [string] [required]
+
+			Flags:
+			  -j, --experimental-json-config  Experimental: Support wrangler.json  [boolean]
+			  -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]"
+		`);
+		});
+
+		it("should try to delete the given namespace", async () => {
+			await runWrangler(`dispatch-namespace delete ${namespaceName}`);
+
+			expect(std.out).toMatchInlineSnapshot(
+				`"Deleted dispatch namespace \\"my-namespace\\""`
+			);
+		});
+	});
+
+	describe("get namespace", () => {
+		const namespaceName = "my-namespace";
+		let counter = 0;
+		msw.use(
+			rest.get(
+				"*/accounts/:accountId/workers/dispatch/namespaces/:namespaceNameParam",
+				(req, res, ctx) => {
+					counter++;
+					const { namespaceNameParam } = req.params;
+					expect(counter).toBe(1);
+					expect(namespaceNameParam).toBe(namespaceName);
+					return res.once(
+						ctx.json(
+							createFetchResult({
+								namespace_id: "some-namespace-id",
+								namespace_name: "namespace-name",
+								created_on: "2022-06-29T14:30:08.16152Z",
+								created_by: "1fc1df98cc4420fe00367c3ab68c1639",
+								modified_on: "2022-06-29T14:30:08.16152Z",
+								modified_by: "1fc1df98cc4420fe00367c3ab68c1639",
+							})
+						)
+					);
+				}
+			)
+		);
+
+		it("should display help for get", async () => {
+			await expect(
+				runWrangler("dispatch-namespace get")
+			).rejects.toThrowErrorMatchingInlineSnapshot(
+				`"Not enough non-option arguments: got 0, need at least 1"`
+			);
+
+			expect(std.out).toMatchInlineSnapshot(`
+			"
+			wrangler dispatch-namespace get <name>
+
+			Get information about a dispatch namespace
+
+			Positionals:
+			  name  Name of the dispatch namespace  [string] [required]
+
+			Flags:
+			  -j, --experimental-json-config  Experimental: Support wrangler.json  [boolean]
+			  -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]"
+		`);
+		});
+
+		it("should attempt to get info for the given namespace", async () => {
+			await runWrangler(`dispatch-namespace get ${namespaceName}`);
+
+			expect(std.out).toMatchInlineSnapshot(`
+			"{
+			  namespace_id: 'some-namespace-id',
+			  namespace_name: 'namespace-name',
+			  created_on: '2022-06-29T14:30:08.16152Z',
+			  created_by: '1fc1df98cc4420fe00367c3ab68c1639',
+			  modified_on: '2022-06-29T14:30:08.16152Z',
+			  modified_by: '1fc1df98cc4420fe00367c3ab68c1639'
+			}"
+		`);
+		});
+	});
+
+	describe("list namespaces", () => {
+		const namespaceName = "my-namespace";
+		let counter = 0;
+		msw.use(
+			rest.get(
+				"*/accounts/:accountId/workers/dispatch/namespaces/:namespaceNameParam",
+				(req, res, ctx) => {
+					counter++;
+					const { namespaceNameParam } = req.params;
+					expect(counter).toBe(1);
+					expect(namespaceNameParam).toBe(namespaceName);
+					return res.once(
+						ctx.json(
+							createFetchResult({
+								namespace_id: "some-namespace-id",
+								namespace_name: "namespace-name",
+								created_on: "2022-06-29T14:30:08.16152Z",
+								created_by: "1fc1df98cc4420fe00367c3ab68c1639",
+								modified_on: "2022-06-29T14:30:08.16152Z",
+								modified_by: "1fc1df98cc4420fe00367c3ab68c1639",
+							})
+						)
+					);
+				}
+			)
+		);
+
+		it("should list all namespaces", async () => {
+			await runWrangler("dispatch-namespace list");
+			expect(std.out).toMatchInlineSnapshot(`
+			"[
+			  {
+			    namespace_id: 'some-namespace-id',
+			    namespace_name: 'namespace-name',
+			    created_on: '2022-06-29T14:30:08.16152Z',
+			    created_by: '1fc1df98cc4420fe00367c3ab68c1639',
+			    modified_on: '2022-06-29T14:30:08.16152Z',
+			    modified_by: '1fc1df98cc4420fe00367c3ab68c1639'
+			  }
+			]"
+		`);
+		});
+	});
+
+	describe("rename namespace", () => {
+		const namespaceName = "my-namespace";
+		let counter = 0;
+		msw.use(
+			rest.put(
+				"*/accounts/:accountId/workers/dispatch/namespaces/:namespaceNameParam",
+				(req, res, ctx) => {
+					counter++;
+					const { namespaceNameParam } = req.params;
+					expect(counter).toBe(1);
+					expect(namespaceNameParam).toBe(namespaceName);
+					return res.once(
+						ctx.json(
+							createFetchResult({
+								namespace_id: "some-namespace-id",
+								namespace_name: "namespace-name",
+								created_on: "2022-06-29T14:30:08.16152Z",
+								created_by: "1fc1df98cc4420fe00367c3ab68c1639",
+								modified_on: "2022-06-29T14:30:08.16152Z",
+								modified_by: "1fc1df98cc4420fe00367c3ab68c1639",
+							})
+						)
+					);
+				}
+			)
+		);
+
+		it("should display help for rename", async () => {
+			await expect(
+				runWrangler("dispatch-namespace rename")
+			).rejects.toThrowErrorMatchingInlineSnapshot(
+				`"Not enough non-option arguments: got 0, need at least 2"`
+			);
+
+			expect(std.out).toMatchInlineSnapshot(`
+			"
+			wrangler dispatch-namespace rename <old-name> <new-name>
+
+			Rename a dispatch namespace
+
+			Positionals:
+			  old-name  Name of the dispatch namespace  [string] [required]
+			  new-name  New name of the dispatch namespace  [string] [required]
+
+			Flags:
+			  -j, --experimental-json-config  Experimental: Support wrangler.json  [boolean]
+			  -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]"
+		`);
+		});
+
+		it("should attempt to rename the given namespace", async () => {
+			const newName = "new-namespace";
+			await runWrangler(
+				`dispatch-namespace rename ${namespaceName} ${newName}`
+			);
+
+			expect(std.out).toMatchInlineSnapshot(
+				`"Renamed dispatch namespace \\"my-namespace\\" to \\"new-namespace\\""`
+			);
+		});
+	});
+});

package/src/abort.d.ts

@@ -0,0 +1,3 @@
+declare interface AbortSignal {
+	addEventListener(event: "abort", handler: () => void);
+}