wrangler 0.0.0-e3a458e → 0.0.0-e3c036d7

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

@@ -0,0 +1,263 @@
+import { rest } from "msw";
+import { Request } from "undici";
+import openInBrowser from "../../open-in-browser";
+import { mockHttpServer } from "./mock-http-server";
+import { createFetchResult, msw } from "./msw";
+
+export function mockGetMemberships(
+	accounts: { id: string; account: { id: string; name: string } }[]
+) {
+	msw.use(
+		rest.get("*/memberships", (_, res, ctx) => {
+			return res.once(ctx.json(createFetchResult(accounts)));
+		})
+	);
+}
+export function mockGetMembershipsFail() {
+	msw.use(
+		rest.get("*/memberships", (_, res, ctx) => {
+			return res.once(ctx.json(createFetchResult([], false)));
+		})
+	);
+}
+
+/**
+ * Functions to help with mocking various parts of the OAuth Flow
+ */
+export const mockOAuthFlow = () => {
+	// the response to send when wrangler wants an oauth grant
+	let oauthGrantResponse: GrantResponseOptions | "timeout" = {};
+	const fetchHttp = mockHttpServer();
+
+	/**
+	 * 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
+				);
+			});
+		});
+	};
+
+	// 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 mockGrantAccessToken = ({
+		respondWith,
+		domain = "dash.cloudflare.com",
+	}: {
+		respondWith: MockTokenResponse;
+		domain?: string;
+	}) => {
+		const outcome = {
+			actual: "https://example.org",
+			expected: `https://${domain}/oauth2/token`,
+		};
+		msw.use(
+			rest.post(outcome.expected, async (req, res, ctx) => {
+				// TODO: update Miniflare typings to match full undici Request
+				outcome.actual = req.url.toString();
+				return res.once(ctx.json(makeTokenResponse(respondWith)));
+			})
+		);
+
+		return outcome;
+	};
+
+	function 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.
+		msw.use(
+			rest.get(`https://${domain}/`, (_, res, ctx) => {
+				let status = 200;
+				let headers: Record<string, string> = {
+					"Content-Type": "application/json",
+				};
+				if (usesAccess) {
+					status = 302;
+					headers = { location: "cloudflareaccess.com" };
+				}
+				return res.once(ctx.status(status), ctx.set(headers));
+			})
+		);
+	}
+
+	return {
+		mockHttpServer,
+		mockDomainUsesAccess,
+		mockGrantAccessToken,
+		mockOAuthServerCallback,
+		mockExchangeRefreshTokenForAccessToken,
+	};
+};
+
+export function mockExchangeRefreshTokenForAccessToken({
+	respondWith,
+	domain = "dash.cloudflare.com",
+}: {
+	respondWith: "refreshSuccess" | "refreshError" | "badResponse";
+	domain?: string;
+}) {
+	msw.use(
+		rest.post(`https://${domain}/oauth2/token`, async (_, res, ctx) => {
+			switch (respondWith) {
+				case "refreshSuccess":
+					return res.once(
+						ctx.status(200),
+						ctx.json({
+							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 res.once(
+						ctx.status(400),
+						ctx.json({
+							error: "invalid_request",
+							error_description: "error_description_mock",
+							error_hint: "error_hint_mock",
+							error_verbose: "error_verbose_mock",
+							status_code: 400,
+						})
+					);
+				case "badResponse":
+					return res.once(
+						ctx.status(400),
+						ctx.text(
+							`<html> <body> This shouldn't be sent, but should be handled </body> </html>`
+						)
+					);
+
+				default:
+					throw new Error(
+						"Not a respondWith option for `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) => {
+	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 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-set-timeout.ts

@@ -0,0 +1,16 @@
+let setTimeoutSpy: jest.SpyInstance;
+
+export function mockSetTimeout() {
+	beforeEach(() => {
+		setTimeoutSpy = jest
+			.spyOn(global, "setTimeout")
+			// @ts-expect-error we're using a very simple setTimeout mock here
+			.mockImplementation((fn, _period) => {
+				setImmediate(fn);
+			});
+	});
+
+	afterEach(() => {
+		setTimeoutSpy.mockRestore();
+	});
+}

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

@@ -4,32 +4,32 @@ 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);
+	const mockStdin = new MockStdIn(isTTY);
 
-  beforeEach(() => {
-    mockStdin.reset();
-    Object.defineProperty(process, "stdin", {
-      value: mockStdin,
-      configurable: true,
-      writable: false,
-    });
-  });
+	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,
-    });
-  });
+	afterEach(() => {
+		Object.defineProperty(process, "stdin", {
+			value: ORIGINAL_STDIN,
+			configurable: true,
+			writable: false,
+		});
+	});
 
-  return mockStdin;
+	return mockStdin;
 }
 
 const failCallback: (value: unknown) => void = () => {
-  throw new Error(
-    "TEST FAILURE: stdin callback called before being initialized."
-  );
+	throw new Error(
+		"TEST FAILURE: stdin callback called before being initialized."
+	);
 };
 
 /**
@@ -37,67 +37,72 @@ const failCallback: (value: unknown) => void = () => {
  * into the wrangler process in non-interactive mode.
  */
 class MockStdIn {
-  private endCallback = failCallback;
-  private errorCallback = failCallback;
-  private chunks: string[] = [];
-  private error: Error | undefined;
+	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;
-  }
+	/**
+	 * 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;
-  }
+	/**
+	 * 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);
-  }
+	/**
+	 * 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
-  ) {}
+	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 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 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

@@ -4,26 +4,26 @@ 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;
-  }
+	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();
-  }
+	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,93 @@
+import { rest } from "msw";
+import { createFetchResult } from "../index";
+
+const latestDeployment = {
+	id: "Galaxy-Class",
+	number: "1701-E",
+	annotations: {
+		"workers/triggered_by": "rollback",
+		"workers/rollback_from": "MOCK-DEPLOYMENT-ID-2222",
+	},
+	metadata: {
+		author_id: "Picard-Gamma-6-0-7-3",
+		author_email: "Jean-Luc-Picard@federation.org",
+		source: "wrangler",
+		created_on: "2021-01-04T00:00:00.000000Z",
+		modified_on: "2021-01-04T00:00:00.000000Z",
+	},
+	resources: {
+		script: "MOCK-TAG",
+		bindings: [],
+	},
+};
+export const mswSuccessDeployments = [
+	rest.get(
+		"*/accounts/:accountId/workers/deployments/by-script/:scriptTag",
+		(_, response, context) =>
+			response.once(
+				context.json(
+					createFetchResult({
+						latest: latestDeployment,
+						items: [
+							{
+								id: "Constitution-Class",
+								number: "1701-E",
+								annotations: {
+									"workers/triggered_by": "upload",
+								},
+								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",
+								annotations: {
+									"workers/triggered_by": "rollback",
+									"workers/rollback_from": "MOCK-DEPLOYMENT-ID-1111",
+								},
+								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",
+								},
+							},
+							{
+								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-03T00:00:00.000000Z",
+									modified_on: "2021-02-03T00:00:00.000000Z",
+								},
+							},
+							latestDeployment,
+						],
+					})
+				)
+			)
+	),
+];
+
+export const mswSuccessLastDeployment = [
+	rest.get(
+		"*/accounts/:accountId/workers/services/:scriptName",
+		(_, res, ctx) => {
+			return res.once(
+				ctx.json(
+					createFetchResult({
+						default_environment: { script: { last_deployed_from: "wrangler" } },
+					})
+				)
+			);
+		}
+	),
+];