wrangler 0.0.0-e64812e → 0.0.0-e6c71262

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

@@ -1,255 +1,263 @@
-import fetchMock from "jest-fetch-mock";
+import { rest } from "msw";
 import { Request } from "undici";
-import { getCloudflareApiBaseUrl } from "../../cfetch";
 import openInBrowser from "../../open-in-browser";
 import { mockHttpServer } from "./mock-http-server";
+import { createFetchResult, msw } from "./msw";
 
-// the response to send when wrangler wants an oauth grant
-let oauthGrantResponse: GrantResponseOptions | "timeout" = {};
+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 = () => {
-  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 = () => {
-    (
-      openInBrowser as jest.MockedFunction<typeof openInBrowser>
-    ).mockImplementation(async (url: string) => {
-      // 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
-        );
-      });
-    });
-  };
-
-  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 = () => {
-    const outcome = {
-      actual: new Request("https://example.org"),
-      expected: new Request("https://dash.cloudflare.com/oauth2/revoke", {
-        method: "POST",
-      }),
-    };
-
-    fetchMock.mockIf(outcome.expected.url, async (req) => {
-      outcome.actual = req;
-      return "";
-    });
-
-    return outcome;
-  };
-
-  const mockGetMemberships = (args: {
-    success: boolean;
-    result: { id: string; account: { id: string; name: string } }[];
-  }) => {
-    const outcome = {
-      actual: new Request("https://example.org"),
-      expected: new Request(`${getCloudflareApiBaseUrl()}/memberships`, {
-        method: "GET",
-      }),
-    };
-
-    fetchMock.mockIf(outcome.expected.url, async (req) => {
-      outcome.actual = req;
-      return {
-        status: 200,
-        body: JSON.stringify(args),
-      };
-    });
-
-    return outcome;
-  };
-
-  const mockGrantAccessToken = ({
-    respondWith,
-  }: {
-    respondWith: MockTokenResponse;
-  }) => {
-    const outcome = {
-      actual: new Request("https://example.org"),
-      expected: new Request("https://dash.cloudflare.com/oauth2/token", {
-        method: "POST",
-      }),
-    };
-
-    fetchMock.mockOnceIf(outcome.expected.url, async (req) => {
-      outcome.actual = req;
-      return makeTokenResponse(respondWith);
-    });
-
-    return outcome;
-  };
-
-  const mockExchangeRefreshTokenForAccessToken = ({
-    respondWith,
-  }: {
-    respondWith: "refreshSuccess" | "refreshError" | "badResponse";
-  }) => {
-    fetchMock.mockOnceIf(
-      "https://dash.cloudflare.com/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_sucess_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`";
-        }
-      }
-    );
-  };
-
-  return {
-    mockGetMemberships,
-    mockGrantAccessToken,
-    mockGrantAuthorization,
-    mockOAuthServerCallback,
-    mockRevokeAuthorization,
-    mockExchangeRefreshTokenForAccessToken,
-  };
+	// 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[];
+	code?: string;
+	error?: ErrorType | ErrorType[];
 };
 
 const toQueryParams = (
-  { code, error }: GrantResponseOptions,
-  wranglerRequestParams: URLSearchParams
+	{ 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("&");
+	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";
+	| "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);
+	| "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();
+	});
+}