wrangler 0.0.0-e9ab55a → 0.0.0-e9e9872

package/src/__tests__/user.test.ts

@@ -0,0 +1,143 @@
+import fs from "node:fs";
+import path from "node:path";
+import fetchMock from "jest-fetch-mock";
+import { getGlobalWranglerConfigPath } from "../global-wrangler-config-path";
+import {
+	loginOrRefreshIfRequired,
+	readAuthConfigFile,
+	requireAuth,
+	USER_AUTH_CONFIG_FILE,
+	writeAuthConfigFile,
+} from "../user";
+import { mockConsoleMethods } from "./helpers/mock-console";
+import { useMockIsTTY } from "./helpers/mock-istty";
+import { mockOAuthFlow } from "./helpers/mock-oauth-flow";
+import { runInTempDir } from "./helpers/run-in-tmp";
+import { runWrangler } from "./helpers/run-wrangler";
+import type { Config } from "../config";
+import type { UserAuthConfig } from "../user";
+
+describe("User", () => {
+	runInTempDir();
+	const std = mockConsoleMethods();
+	const {
+		mockOAuthServerCallback,
+		mockGrantAccessToken,
+		mockGrantAuthorization,
+		mockRevokeAuthorization,
+		mockExchangeRefreshTokenForAccessToken,
+	} = mockOAuthFlow();
+
+	const { setIsTTY } = useMockIsTTY();
+
+	describe("login", () => {
+		it("should login a user when `wrangler login` is run", async () => {
+			mockOAuthServerCallback();
+			const accessTokenRequest = mockGrantAccessToken({ respondWith: "ok" });
+			mockGrantAuthorization({ respondWith: "success" });
+
+			await runWrangler("login");
+
+			expect(accessTokenRequest.actual.url).toEqual(
+				accessTokenRequest.expected.url
+			);
+			expect(accessTokenRequest.actual.method).toEqual(
+				accessTokenRequest.expected.method
+			);
+
+			expect(std.out).toMatchInlineSnapshot(`
+        "Attempting to login via OAuth...
+        Opening a link in your default browser: https://dash.cloudflare.com/oauth2/auth?response_type=code&client_id=54d11594-84e4-41aa-b438-e81b8fa78ee7&redirect_uri=http%3A%2F%2Flocalhost%3A8976%2Foauth%2Fcallback&scope=account%3Aread%20user%3Aread%20workers%3Awrite%20workers_kv%3Awrite%20workers_routes%3Awrite%20workers_scripts%3Awrite%20workers_tail%3Aread%20pages%3Awrite%20zone%3Aread%20offline_access&state=MOCK_STATE_PARAM&code_challenge=MOCK_CODE_CHALLENGE&code_challenge_method=S256
+        Successfully logged in."
+      `);
+
+			expect(readAuthConfigFile()).toEqual<UserAuthConfig>({
+				api_token: undefined,
+				oauth_token: "test-access-token",
+				refresh_token: "test-refresh-token",
+				expiration_time: expect.any(String),
+			});
+		});
+	});
+
+	describe("logout", () => {
+		it("should exit with a message stating the user is not logged in", async () => {
+			await runWrangler("logout");
+			expect(std.out).toMatchInlineSnapshot(`"Not logged in, exiting..."`);
+		});
+
+		it("should logout user that has been properly logged in", async () => {
+			writeAuthConfigFile({
+				oauth_token: "some-oauth-tok",
+				refresh_token: "some-refresh-tok",
+			});
+			const outcome = mockRevokeAuthorization();
+
+			await runWrangler("logout");
+
+			expect(outcome.actual.url).toEqual(
+				"https://dash.cloudflare.com/oauth2/revoke"
+			);
+			expect(outcome.actual.method).toEqual("POST");
+
+			expect(std.out).toMatchInlineSnapshot(`"Successfully logged out."`);
+
+			// Make sure that we made the request to logout.
+			expect(fetchMock).toHaveBeenCalledTimes(1);
+
+			// Make sure that logout removed the config file containing the auth tokens.
+			const config = path.join(
+				getGlobalWranglerConfigPath(),
+				USER_AUTH_CONFIG_FILE
+			);
+			expect(fs.existsSync(config)).toBeFalsy();
+		});
+	});
+
+	// TODO: Improve OAuth mocking to handle `/token` endpoints from different calls
+	it("should handle errors for failed token refresh", async () => {
+		setIsTTY(false);
+		writeAuthConfigFile({
+			oauth_token: "hunter2",
+			refresh_token: "Order 66",
+		});
+		mockExchangeRefreshTokenForAccessToken({
+			respondWith: "badResponse",
+		});
+
+		// Handles the requireAuth error throw from failed login that is unhandled due to directly calling it here
+		await expect(
+			requireAuth({} as Config)
+		).rejects.toThrowErrorMatchingInlineSnapshot(
+			`"In a non-interactive environment, it's necessary to set a CLOUDFLARE_API_TOKEN environment variable for wrangler to work. Please go to https://developers.cloudflare.com/api/tokens/create/ for instructions on how to create an api token, and assign its value to CLOUDFLARE_API_TOKEN."`
+		);
+	});
+
+	it("should confirm no error message when refresh is successful", async () => {
+		setIsTTY(false);
+		mockOAuthServerCallback();
+		writeAuthConfigFile({
+			oauth_token: "hunter2",
+			refresh_token: "Order 66",
+		});
+		mockGrantAuthorization({ respondWith: "success" });
+
+		mockExchangeRefreshTokenForAccessToken({
+			respondWith: "refreshSuccess",
+		});
+
+		// Handles the requireAuth error throw from failed login that is unhandled due to directly calling it here
+		await expect(requireAuth({} as Config)).rejects.toThrowError();
+		expect(std.err).toContain("");
+	});
+
+	it("should revert to non-interactive mode if isTTY throws an error", async () => {
+		setIsTTY({
+			stdin() {
+				throw new Error("stdin is not tty");
+			},
+			stdout: true,
+		});
+		await expect(loginOrRefreshIfRequired()).resolves.toEqual(false);
+	});
+});

package/src/__tests__/whoami.test.tsx

@@ -0,0 +1,230 @@
+import { render } from "ink-testing-library";
+import React from "react";
+import { writeAuthConfigFile } from "../user";
+import { getUserInfo, WhoAmI } from "../whoami";
+import {
+	createFetchResult,
+	setMockRawResponse,
+	setMockResponse,
+	unsetAllMocks,
+} from "./helpers/mock-cfetch";
+import { mockConsoleMethods } from "./helpers/mock-console";
+import { useMockIsTTY } from "./helpers/mock-istty";
+import { runInTempDir } from "./helpers/run-in-tmp";
+import type { UserInfo } from "../whoami";
+
+describe("getUserInfo()", () => {
+	const ENV_COPY = process.env;
+
+	runInTempDir();
+	const std = mockConsoleMethods();
+	const { setIsTTY } = useMockIsTTY();
+
+	beforeEach(() => {
+		setIsTTY(true);
+	});
+
+	afterEach(() => {
+		process.env = ENV_COPY;
+		unsetAllMocks();
+	});
+
+	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",
+		};
+		setMockRawResponse("/user", () =>
+			createFetchResult(undefined, false, [
+				{ code: 9109, message: "Uauthorized to access requested resource" },
+			])
+		);
+		setMockResponse("/accounts", () => []);
+		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",
+		};
+		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" },
+			];
+		});
+
+		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",
+		};
+		setMockResponse("/accounts", () => {
+			return [
+				{ name: "Account One", id: "account-1" },
+				{ name: "Account Two", id: "account-2" },
+				{ name: "Account Three", id: "account-3" },
+			];
+		});
+
+		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",
+		};
+		setMockResponse("/accounts", () => {
+			return [
+				{ name: "Account One", id: "account-1" },
+				{ name: "Account Two", id: "account-2" },
+				{ name: "Account Three", id: "account-3" },
+			];
+		});
+
+		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" });
+
+		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" },
+			];
+		});
+
+		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" });
+		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 getUserInfo();
+		expect(std.warn).toMatchInlineSnapshot(`
+      "▲ [WARNING] It looks like you have used Wrangler 1'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 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" },
+			],
+		};
+
+		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,327 @@
+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";
+
+describe("worker-namespace", () => {
+	runInTempDir();
+	const std = mockConsoleMethods();
+	mockAccountId();
+	mockApiToken();
+
+	afterEach(() => {
+		unsetAllMocks();
+	});
+
+	it("should should display a list of available subcommands, for worker-namespace with no subcommand", async () => {
+		await runWrangler("worker-namespace");
+
+		// wait a tick for the help menu to be printed
+		await new Promise((resolve) => setImmediate(resolve));
+
+		expect(std).toMatchInlineSnapshot(`
+		Object {
+		  "debug": "",
+		  "err": "",
+		  "out": "wrangler worker-namespace
+
+		📦 Interact with a worker namespace
+
+		Commands:
+		  wrangler worker-namespace list                          List all Worker namespaces
+		  wrangler worker-namespace get <name>                    Get information about a Worker namespace
+		  wrangler worker-namespace create <name>                 Create a Worker namespace
+		  wrangler worker-namespace delete <name>                 Delete a Worker namespace
+		  wrangler worker-namespace rename <old-name> <new-name>  Rename a Worker namespace
+
+		Flags:
+		  -c, --config   Path to .toml configuration file  [string]
+		  -h, --help     Show help  [boolean]
+		  -v, --version  Show version number  [boolean]",
+		  "warn": "",
+		}
+	`);
+	});
+
+	describe("create namespace", () => {
+		function mockCreateRequest(expectedName: string) {
+			const requests = { count: 0 };
+			setMockResponse(
+				"/accounts/:accountId/workers/dispatch/namespaces",
+				([_url], init) => {
+					requests.count += 1;
+
+					const incomingText = init.body?.toString() || "";
+					const { name: namespace_name } = JSON.parse(incomingText);
+
+					expect(init.method).toBe("POST");
+					expect(namespace_name).toEqual(expectedName);
+
+					return {
+						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",
+					};
+				}
+			);
+			return requests;
+		}
+
+		it("should display help for create", async () => {
+			await expect(
+				runWrangler("worker-namespace create")
+			).rejects.toThrowErrorMatchingInlineSnapshot(
+				`"Not enough non-option arguments: got 0, need at least 1"`
+			);
+
+			expect(std.out).toMatchInlineSnapshot(`
+			"
+			wrangler worker-namespace create <name>
+
+			Create a Worker namespace
+
+			Positionals:
+			  name  Name of the Worker namespace  [string] [required]
+
+			Flags:
+			  -c, --config   Path to .toml configuration file  [string]
+			  -h, --help     Show help  [boolean]
+			  -v, --version  Show version number  [boolean]"
+		`);
+		});
+
+		it("should attempt to create the given namespace", async () => {
+			const namespaceName = "my-namespace";
+			const requests = mockCreateRequest(namespaceName);
+			await runWrangler(`worker-namespace create ${namespaceName}`);
+			expect(requests.count).toEqual(1);
+
+			expect(std.out).toMatchInlineSnapshot(
+				`"Created Worker namespace \\"my-namespace\\" with ID \\"some-namespace-id\\""`
+			);
+		});
+	});
+
+	describe("delete namespace", () => {
+		function mockDeleteRequest(expectedName: string) {
+			const requests = { count: 0 };
+			setMockResponse(
+				"/accounts/:accountId/workers/dispatch/namespaces/:namespaceName",
+				([_url, _, namespaceName], init) => {
+					requests.count += 1;
+
+					expect(init.method).toBe("DELETE");
+					expect(namespaceName).toEqual(expectedName);
+
+					return null;
+				}
+			);
+			return requests;
+		}
+
+		it("should display help for delete", async () => {
+			await expect(
+				runWrangler("worker-namespace create")
+			).rejects.toThrowErrorMatchingInlineSnapshot(
+				`"Not enough non-option arguments: got 0, need at least 1"`
+			);
+
+			expect(std.out).toMatchInlineSnapshot(`
+			"
+			wrangler worker-namespace create <name>
+
+			Create a Worker namespace
+
+			Positionals:
+			  name  Name of the Worker namespace  [string] [required]
+
+			Flags:
+			  -c, --config   Path to .toml configuration file  [string]
+			  -h, --help     Show help  [boolean]
+			  -v, --version  Show version number  [boolean]"
+		`);
+		});
+
+		it("should try to delete the given namespace", async () => {
+			const namespaceName = "my-namespace";
+			const requests = mockDeleteRequest(namespaceName);
+			await runWrangler(`worker-namespace delete ${namespaceName}`);
+			expect(requests.count).toBe(1);
+
+			expect(std.out).toMatchInlineSnapshot(
+				`"Deleted Worker namespace \\"my-namespace\\""`
+			);
+		});
+	});
+
+	describe("get namespace", () => {
+		function mockInfoRequest(expectedName: string) {
+			const requests = { count: 0 };
+			setMockResponse(
+				"/accounts/:accountId/workers/dispatch/namespaces/:namespaceName",
+				([_url, _, namespaceName], _init) => {
+					requests.count += 1;
+
+					expect(namespaceName).toEqual(expectedName);
+
+					return {
+						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",
+					};
+				}
+			);
+			return requests;
+		}
+
+		it("should display help for get", async () => {
+			await expect(
+				runWrangler("worker-namespace get")
+			).rejects.toThrowErrorMatchingInlineSnapshot(
+				`"Not enough non-option arguments: got 0, need at least 1"`
+			);
+
+			expect(std.out).toMatchInlineSnapshot(`
+			        "
+			        wrangler worker-namespace get <name>
+
+			        Get information about a Worker namespace
+
+			        Positionals:
+			          name  Name of the Worker namespace  [string] [required]
+
+			        Flags:
+			          -c, --config   Path to .toml configuration file  [string]
+			          -h, --help     Show help  [boolean]
+			          -v, --version  Show version number  [boolean]"
+		      `);
+		});
+
+		it("should attempt to get info for the given namespace", async () => {
+			const namespaceName = "my-namespace";
+			const requests = mockInfoRequest(namespaceName);
+			await runWrangler(`worker-namespace get ${namespaceName}`);
+			expect(requests.count).toBe(1);
+
+			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", () => {
+		function mockListRequest() {
+			const requests = { count: 0 };
+			setMockResponse(
+				"/accounts/:accountId/workers/dispatch/namespaces",
+				([_url, _, _page, _perPage], _init) => {
+					requests.count += 1;
+
+					return [
+						{
+							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",
+						},
+					];
+				}
+			);
+			return requests;
+		}
+
+		it("should list all namespaces", async () => {
+			const requests = mockListRequest();
+			await runWrangler("worker-namespace list");
+			expect(requests.count).toBe(1);
+			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", () => {
+		function mockRenameRequest(expectedName: string) {
+			const requests = { count: 0 };
+			setMockResponse(
+				"/accounts/:accountId/workers/dispatch/namespaces/:namespaceName",
+				([_url, _, namespaceName], init) => {
+					requests.count += 1;
+
+					expect(init.method).toEqual("PUT");
+					expect(namespaceName).toEqual(expectedName);
+
+					return {
+						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",
+					};
+				}
+			);
+			return requests;
+		}
+
+		it("should display help for rename", async () => {
+			await expect(
+				runWrangler("worker-namespace rename")
+			).rejects.toThrowErrorMatchingInlineSnapshot(
+				`"Not enough non-option arguments: got 0, need at least 2"`
+			);
+
+			expect(std.out).toMatchInlineSnapshot(`
+			"
+			wrangler worker-namespace rename <old-name> <new-name>
+
+			Rename a Worker namespace
+
+			Positionals:
+			  old-name  Name of the Worker namespace  [string] [required]
+			  new-name  New name of the Worker namespace  [string] [required]
+
+			Flags:
+			  -c, --config   Path to .toml configuration file  [string]
+			  -h, --help     Show help  [boolean]
+			  -v, --version  Show version number  [boolean]"
+		`);
+		});
+
+		it("should attempt to rename the given namespace", async () => {
+			const namespaceName = "my-namespace";
+			const newName = "new-namespace";
+			const requests = mockRenameRequest(namespaceName);
+			await runWrangler(`worker-namespace rename ${namespaceName} ${newName}`);
+			expect(requests.count).toBe(1);
+			expect(std.out).toMatchInlineSnapshot(
+				`"Renamed Worker namespace \\"my-namespace\\" to \\"new-namespace\\""`
+			);
+		});
+	});
+});

package/src/abort.d.ts

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