wrangler 0.0.0-e928f94 → 0.0.0-e93063e9

package/src/__tests__/helpers/mock-oauth-flow.ts

@@ -0,0 +1,271 @@
+import fetchMock from "jest-fetch-mock";
+import { Request } from "undici";
+import openInBrowser from "../../open-in-browser";
+import { setMockResponse } from "./mock-cfetch";
+import { mockHttpServer } from "./mock-http-server";
+
+export function mockGetMemberships(
+	accounts: { id: string; account: { id: string; name: string } }[]
+) {
+	setMockResponse("/memberships", "GET", () => {
+		return accounts;
+	});
+}
+
+// the response to send when wrangler wants an oauth grant
+let oauthGrantResponse: GrantResponseOptions | "timeout" = {};
+
+/**
+ * Functions to help with mocking various parts of the OAuth Flow
+ */
+export const mockOAuthFlow = () => {
+	const fetchHttp = mockHttpServer();
+
+	afterEach(() => {
+		fetchMock.resetMocks();
+	});
+
+	/**
+	 * Mock out the callback from a browser to our HttpServer.
+	 *
+	 * This function will override `openInBrowser()` so that instead of opening a browser window
+	 * at the OAuth URL, it will automatically trigger the callback URL on the mock HttpServer that
+	 * we have created as part of the call to `mockOAuthFlow()`.
+	 */
+	const mockOAuthServerCallback = (
+		respondWith?: "timeout" | "success" | "failure" | GrantResponseOptions
+	) => {
+		(
+			openInBrowser as jest.MockedFunction<typeof openInBrowser>
+		).mockImplementation(async (url: string) => {
+			if (respondWith) mockGrantAuthorization({ respondWith });
+			// We don't support the grant response timing out.
+			if (oauthGrantResponse === "timeout") {
+				throw "unimplemented";
+			}
+
+			// Create a fake callback request that would be created by the OAuth server
+			const { searchParams } = new URL(url);
+			const queryParams = toQueryParams(oauthGrantResponse, searchParams);
+			const request = new Request(
+				`${searchParams.get("redirect_uri")}?${queryParams}`
+			);
+
+			// Trigger the mock HttpServer to handle this fake request to continue the OAuth flow.
+			fetchHttp(request).catch((e) => {
+				throw new Error(
+					"Failed to send OAuth Grant to wrangler, maybe the server was closed?",
+					e as Error
+				);
+			});
+		});
+	};
+
+	//TODO: this can just handled in `mockOAuthServerCallback`
+	const mockGrantAuthorization = ({
+		respondWith,
+	}: {
+		respondWith: "timeout" | "success" | "failure" | GrantResponseOptions;
+	}) => {
+		if (respondWith === "failure") {
+			oauthGrantResponse = {
+				error: "access_denied",
+			};
+		} else if (respondWith === "success") {
+			oauthGrantResponse = {
+				code: "test-oauth-code",
+			};
+		} else if (respondWith === "timeout") {
+			oauthGrantResponse = "timeout";
+		} else {
+			oauthGrantResponse = respondWith;
+		}
+	};
+
+	const mockRevokeAuthorization = ({
+		domain = "dash.cloudflare.com",
+	}: { domain?: string } = {}) => {
+		const outcome = {
+			actual: new Request("https://example.org"),
+			expected: new Request(`https://${domain}/oauth2/revoke`, {
+				method: "POST",
+			}),
+		};
+
+		fetchMock.mockIf(outcome.expected.url, async (req) => {
+			// TODO: update Miniflare typings to match full undici Request
+			outcome.actual = req as unknown as Request;
+			return "";
+		});
+
+		return outcome;
+	};
+
+	const mockGrantAccessToken = ({
+		respondWith,
+		domain = "dash.cloudflare.com",
+	}: {
+		respondWith: MockTokenResponse;
+		domain?: string;
+	}) => {
+		const outcome = {
+			actual: new Request("https://example.org"),
+			expected: new Request(`https://${domain}/oauth2/token`, {
+				method: "POST",
+			}),
+		};
+
+		fetchMock.mockOnceIf(outcome.expected.url, async (req) => {
+			// TODO: update Miniflare typings to match full undici Request
+			outcome.actual = req as unknown as Request;
+			return makeTokenResponse(respondWith);
+		});
+
+		return outcome;
+	};
+
+	const mockExchangeRefreshTokenForAccessToken = ({
+		respondWith,
+		domain = "dash.cloudlfare.com",
+	}: {
+		respondWith: "refreshSuccess" | "refreshError" | "badResponse";
+		domain?: string;
+	}) => {
+		fetchMock.mockOnceIf(`https://${domain}/oauth2/token`, async () => {
+			switch (respondWith) {
+				case "refreshSuccess":
+					return {
+						status: 200,
+						body: JSON.stringify({
+							access_token: "access_token_success_mock",
+							expires_in: 1701,
+							refresh_token: "refresh_token_success_mock",
+							scope: "scope_success_mock",
+							token_type: "bearer",
+						}),
+					};
+				case "refreshError":
+					return {
+						status: 400,
+						body: JSON.stringify({
+							error: "invalid_request",
+							error_description: "error_description_mock",
+							error_hint: "error_hint_mock",
+							error_verbose: "error_verbose_mock",
+							status_code: 400,
+						}),
+					};
+				case "badResponse":
+					return {
+						status: 400,
+						body: `<html> <body> This shouldn't be sent, but should be handled </body> </html>`,
+					};
+
+				default:
+					return "Not a respondWith option for `mockExchangeRefreshTokenForAccessToken`";
+			}
+		});
+	};
+
+	const mockDomainUsesAccess = ({
+		usesAccess,
+		domain = "dash.cloudflare.com",
+	}: {
+		usesAccess: boolean;
+		domain?: string;
+	}) => {
+		// If the domain relies upon Cloudflare Access, then a request to the domain
+		// will result in a redirect to the `cloudflareaccess.com` domain.
+		fetchMock.mockOnceIf(`https://${domain}/`, async () => {
+			if (usesAccess) {
+				return {
+					status: 302,
+					headers: { location: "cloudflareaccess.com" },
+				};
+			} else {
+				return { status: 200 };
+			}
+		});
+	};
+
+	return {
+		mockDomainUsesAccess,
+		mockGrantAccessToken,
+		mockGrantAuthorization,
+		mockOAuthServerCallback,
+		mockRevokeAuthorization,
+		mockExchangeRefreshTokenForAccessToken,
+	};
+};
+
+type GrantResponseOptions = {
+	code?: string;
+	error?: ErrorType | ErrorType[];
+};
+
+const toQueryParams = (
+	{ code, error }: GrantResponseOptions,
+	wranglerRequestParams: URLSearchParams
+): string => {
+	const queryParams = [];
+	if (code) {
+		queryParams.push(`code=${code}`);
+	}
+	if (error) {
+		const stringifiedErr = Array.isArray(error) ? error.join(",") : error;
+		queryParams.push(`error=${stringifiedErr}`);
+	}
+
+	queryParams.push(`state=${wranglerRequestParams.get("state")}`);
+
+	return queryParams.join("&");
+};
+
+type ErrorType =
+	| "invalid_request"
+	| "invalid_grant"
+	| "unauthorized_client"
+	| "access_denied"
+	| "unsupported_response_type"
+	| "invalid_scope"
+	| "server_error"
+	| "temporarily_unavailable"
+	| "invalid_client"
+	| "unsupported_grant_type"
+	| "invalid_json"
+	| "invalid_token"
+	| "test-token-grant-error";
+
+type MockTokenResponse =
+	| "ok"
+	| "error"
+	| {
+			access_token: string;
+			expires_in: number;
+			refresh_token: string;
+			scope: string;
+	  }
+	| {
+			error: ErrorType;
+	  };
+
+const makeTokenResponse = (partialResponse: MockTokenResponse): string => {
+	let fullResponse: MockTokenResponse;
+
+	if (partialResponse === "ok") {
+		fullResponse = {
+			access_token: "test-access-token",
+			expires_in: 100000,
+			refresh_token: "test-refresh-token",
+			scope: "account:read",
+		};
+	} else if (partialResponse === "error") {
+		fullResponse = {
+			error: "test-token-grant-error",
+		};
+	} else {
+		fullResponse = partialResponse;
+	}
+
+	return JSON.stringify(fullResponse);
+};

package/src/__tests__/helpers/mock-process.ts

@@ -0,0 +1,34 @@
+/**
+ * We use this module to mock process methods (write only for now),
+ * and optionally assert on the values they're called with in our tests.
+ */
+
+let writeSpy: jest.SpyInstance;
+
+function captureLastWriteCall(spy: jest.SpyInstance): Buffer | undefined {
+	const calls = spy.mock.calls;
+
+	// Loop through and find the buffer in calls
+	// (we don't know the index of the buffer in the calls array)
+	const buffer = calls
+		.map((call) => call[0])
+		.find((call) => call instanceof Buffer);
+
+	if (buffer instanceof Buffer) {
+		return buffer;
+	}
+}
+
+export function mockProcess() {
+	beforeEach(() => {
+		writeSpy = jest.spyOn(process.stdout, "write").mockImplementation();
+	});
+	afterEach(() => {
+		writeSpy.mockRestore();
+	});
+	return {
+		get write() {
+			return captureLastWriteCall(writeSpy);
+		},
+	};
+}

package/src/__tests__/helpers/mock-stdin.ts

@@ -0,0 +1,108 @@
+const ORIGINAL_STDIN = process.stdin;
+
+/**
+ * Mock process.stdin so that we can pipe in text for non-interactive mode tests.
+ */
+export function useMockStdin({ isTTY }: { isTTY: boolean }) {
+	const mockStdin = new MockStdIn(isTTY);
+
+	beforeEach(() => {
+		mockStdin.reset();
+		Object.defineProperty(process, "stdin", {
+			value: mockStdin,
+			configurable: true,
+			writable: false,
+		});
+	});
+
+	afterEach(() => {
+		Object.defineProperty(process, "stdin", {
+			value: ORIGINAL_STDIN,
+			configurable: true,
+			writable: false,
+		});
+	});
+
+	return mockStdin;
+}
+
+const failCallback: (value: unknown) => void = () => {
+	throw new Error(
+		"TEST FAILURE: stdin callback called before being initialized."
+	);
+};
+
+/**
+ * A mock version of `process.std`, which can be used to simulate piping data
+ * into the wrangler process in non-interactive mode.
+ */
+class MockStdIn {
+	private endCallback = failCallback;
+	private errorCallback = failCallback;
+	private chunks: string[] = [];
+	private error: Error | undefined;
+
+	/**
+	 * Set this to true if you want the stdin stream to error.
+	 */
+	throwError(error: Error) {
+		this.error = error;
+	}
+
+	/**
+	 * Call this to clean out the chunks that are queued for sending.
+	 */
+	reset() {
+		this.chunks.length = 0;
+		this.error = undefined;
+	}
+
+	/**
+	 * Queue up some chunks to be sent.
+	 */
+	send(...chunks: string[]) {
+		this.chunks.push(...chunks);
+	}
+
+	constructor(
+		/**
+		 * Used by wrangler to check whether stdin is interactive.
+		 */
+		readonly isTTY: boolean
+	) {}
+
+	/**
+	 * Used by wrangler to add event listeners.
+	 */
+	on(eventName: string, callback: () => void) {
+		switch (eventName) {
+			case "readable":
+				setImmediate(callback);
+				break;
+			case "end":
+				this.endCallback = callback;
+				break;
+			case "error":
+				this.errorCallback = callback;
+				break;
+		}
+	}
+
+	/**
+	 * Used by wrangler to get the next chunk of data in the stream.
+	 */
+	read() {
+		if (this.error) {
+			setImmediate(() => this.errorCallback(this.error));
+		}
+		if (this.chunks.length === 0) {
+			setImmediate(this.endCallback);
+		}
+		return this.chunks.shift() ?? null;
+	}
+
+	/**
+	 * Used by Ink.js to set the encoding of the stdout.
+	 */
+	setEncoding() {}
+}

package/src/__tests__/helpers/mock-web-socket.ts

@@ -0,0 +1,29 @@
+import { WebSocket } from "mock-socket";
+
+/**
+ * A version of the mock WebSocket that supports the methods that we use.
+ */
+export class MockWebSocket extends WebSocket {
+	on(event: string | symbol, listener: (...args: unknown[]) => void): this {
+		switch (event) {
+			case "message":
+				this.onmessage = ({ data }) => {
+					listener(data);
+				};
+				break;
+			case "open":
+				this.onopen = listener;
+				break;
+			case "close":
+				this.onclose = listener;
+				break;
+			default:
+				throw new Error("Unknown event type: " + event.toString());
+		}
+		return this;
+	}
+
+	terminate() {
+		this.close();
+	}
+}

package/src/__tests__/helpers/msw/blob-worker.cjs

@@ -0,0 +1,19 @@
+/*! Read blob sync in NodeJS. MIT License. Jimmy Wärting <https://jimmy.warting.se/opensource>
+ * Special Thanks to Jimmy Wärting helping in https://github.com/nodejs/undici/issues/1830
+ */
+
+const { workerData } = require("worker_threads");
+
+const { signal, port, blob } = workerData;
+
+blob.arrayBuffer().then((ab) => {
+	// Post the result back to the main thread before unlocking 'signal'
+	port.postMessage(ab, [ab]);
+	port.close();
+
+	// Change the value of signal[0] to 1
+	Atomics.store(signal, 0, 1);
+
+	// This will unlock the main thread when we notify it
+	Atomics.notify(signal, 0);
+});

package/src/__tests__/helpers/msw/handlers/access.ts

@@ -0,0 +1,13 @@
+import { rest } from "msw";
+
+export default [
+	rest.get("*access-protected.com*", (_, response, cxt) => {
+		return response.once(
+			cxt.status(302),
+			cxt.set("location", "access-protected-com.cloudflareaccess.com")
+		);
+	}),
+	rest.get("*not-access-protected.com*", (_, response, cxt) => {
+		return response.once(cxt.status(200), cxt.body("OK"));
+	}),
+];

package/src/__tests__/helpers/msw/handlers/deployments.ts

@@ -0,0 +1,59 @@
+import { rest } from "msw";
+
+import type { DeploymentListRes } from "../../../../deployments";
+
+export const mswSuccessDeployments = [
+	rest.get(
+		"*/accounts/:accountId/workers/deployments/by-script/:scriptTag",
+		(_, response, context) =>
+			response.once(
+				context.status(200),
+				context.json({
+					success: true,
+					errors: [],
+					messages: [],
+					result: {
+						latest: {
+							id: "Galaxy-Class",
+							number: "1701-E",
+							metadata: {
+								author_id: "Picard-Gamma-6-0-7-3",
+								author_email: "Jean-Luc-Picard@federation.org",
+								source: "wrangler",
+								created_on: "2021-01-01T00:00:00.000000Z",
+								modified_on: "2021-01-01T00:00:00.000000Z",
+							},
+							resources: {
+								script: "MOCK-TAG",
+								bindings: [],
+							},
+						},
+						items: [
+							{
+								id: "Galaxy-Class",
+								number: "1701-E",
+								metadata: {
+									author_id: "Picard-Gamma-6-0-7-3",
+									author_email: "Jean-Luc-Picard@federation.org",
+									source: "wrangler",
+									created_on: "2021-01-01T00:00:00.000000Z",
+									modified_on: "2021-01-01T00:00:00.000000Z",
+								},
+							},
+							{
+								id: "Intrepid-Class",
+								number: "NCC-74656",
+								metadata: {
+									author_id: "Kathryn-Jane-Gamma-6-0-7-3",
+									author_email: "Kathryn-Janeway@federation.org",
+									source: "wrangler",
+									created_on: "2021-02-02T00:00:00.000000Z",
+									modified_on: "2021-02-02T00:00:00.000000Z",
+								},
+							},
+						],
+					} as DeploymentListRes,
+				})
+			)
+	),
+];

package/src/__tests__/helpers/msw/handlers/namespaces.ts

@@ -0,0 +1,104 @@
+import { rest } from "msw";
+
+export const mswSuccessNamespacesHandlers = [
+	rest.post(
+		"*/accounts/:accountId/workers/dispatch/namespaces",
+		(_, response, context) => {
+			return response.once(
+				context.status(200),
+				context.json({
+					success: true,
+					errors: [],
+					messages: [],
+					result: {
+						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",
+					},
+				})
+			);
+		}
+	),
+	rest.delete(
+		"*/accounts/:accountId/workers/dispatch/namespaces/:namespaceName",
+		(_, response, context) => {
+			return response.once(
+				context.status(200),
+				context.json({
+					success: true,
+					errors: [],
+					messages: [],
+					result: null,
+				})
+			);
+		}
+	),
+	rest.put(
+		"*/accounts/:accountId/workers/dispatch/namespaces/:namespaceName",
+		(_, response, context) => {
+			return response.once(
+				context.status(200),
+				context.json({
+					success: true,
+					errors: [],
+					messages: [],
+					result: {
+						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",
+					},
+				})
+			);
+		}
+	),
+	rest.get(
+		"*/accounts/:accountId/workers/dispatch/namespaces/:namespaceName",
+		(_, response, context) => {
+			return response.once(
+				context.status(200),
+				context.json({
+					success: true,
+					errors: [],
+					messages: [],
+					result: {
+						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",
+					},
+				})
+			);
+		}
+	),
+	rest.get(
+		"*/accounts/:accountId/workers/dispatch/namespaces",
+		(_, response, context) => {
+			return response.once(
+				context.status(200),
+				context.json({
+					success: true,
+					errors: [],
+					messages: [],
+					result: [
+						{
+							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",
+						},
+					],
+				})
+			);
+		}
+	),
+];

package/src/__tests__/helpers/msw/handlers/oauth.ts

@@ -0,0 +1,31 @@
+import { rest } from "msw";
+
+export const mswSuccessOauthHandlers = [
+	rest.all("*/oauth/callback", (_, response, context) => {
+		return response.once(
+			context.status(200),
+			context.json({
+				success: true,
+				errors: [],
+				messages: [],
+				code: "test-oauth-code",
+			})
+		);
+	}),
+	// revoke access token
+	rest.post("*/oauth2/revoke", (_, response, context) =>
+		response.once(context.status(200), context.text(""))
+	),
+	// exchange (auth code | refresh token) for access token
+	rest.post("*/oauth2/token", (_, response, context) => {
+		return response.once(
+			context.status(200),
+			context.json({
+				access_token: "test-access-token",
+				expires_in: 100000,
+				refresh_token: "test-refresh-token",
+				scope: "account:read",
+			})
+		);
+	}),
+];