wrangler 0.0.0-ecc8b172 → 0.0.0-ecded1af1

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

@@ -1,74 +0,0 @@
-const ORIGINAL_STDOUT = process.stdout;
-const ORIGINAL_STDIN = process.stdin;
-
-/**
- * Mock `process.stdout.isTTY`
- */
-export function useMockIsTTY() {
-	/**
-	 * Explicitly set `process.stdout.isTTY` to a given value (or to a getter function).
-	 */
-	const setIsTTY = (
-		isTTY:
-			| boolean
-			| { stdin: boolean | (() => boolean); stdout: boolean | (() => boolean) }
-	) => {
-		mockStdStream("stdout", ORIGINAL_STDOUT, isTTY);
-		mockStdStream("stdin", ORIGINAL_STDIN, isTTY);
-	};
-
-	beforeEach(() => {
-		Object.defineProperty(process, "stdout", { value: ORIGINAL_STDOUT });
-		Object.defineProperty(process, "stdin", { value: ORIGINAL_STDIN });
-	});
-
-	afterEach(() => {
-		Object.defineProperty(process, "stdout", { value: ORIGINAL_STDOUT });
-		Object.defineProperty(process, "stdin", { value: ORIGINAL_STDIN });
-	});
-
-	return { setIsTTY };
-}
-
-/**
- * Create a mock version of the specified stream which overrides `isTTY`
- * with the given mock responses.
- *
- * @param streamName the property name on `process` for the stream to be mocked.
- * @param originalStream the original stream object from the `process` object to be overridden.
- * @param isTTY the mock behaviour for the `isTTY` property:
- *  - boolean or `{ [streamName]: boolean } - use this value for isTTY;
- *  - { [streamName]: () => boolean } - use this function as a getter for isTTY.
- */
-function mockStdStream<T extends object>(
-	streamName: "stdout" | "stdin",
-	originalStream: T,
-	isTTY:
-		| boolean
-		| { stdin: boolean | (() => boolean); stdout: boolean | (() => boolean) }
-) {
-	Object.defineProperty(process, streamName, {
-		value: createStdProxy(
-			originalStream,
-			typeof isTTY === "boolean" ? isTTY : isTTY[streamName]
-		),
-	});
-}
-
-/**
- * Create a proxy wrapper around the given `stream` object that overrides the `isTTY` property.
- */
-function createStdProxy<T extends object>(
-	stream: T,
-	isTTY: boolean | (() => boolean)
-): T {
-	return new Proxy(stream, {
-		get(target, prop) {
-			return prop === "isTTY"
-				? typeof isTTY === "boolean"
-					? isTTY
-					: isTTY()
-				: target[prop as keyof typeof target];
-		},
-	});
-}

package/src/__tests__/helpers/mock-known-routes.ts

@@ -1,7 +0,0 @@
-import { setMockResponse } from "./mock-cfetch";
-
-export function mockCollectKnownRoutesRequest(
-	routes: { pattern: string; script: string }[]
-) {
-	setMockResponse(`/zones/:zoneId/workers/routes`, "GET", () => routes);
-}

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

@@ -1,33 +0,0 @@
-import { createFetchResult, setMockRawResponse } from "./mock-cfetch";
-import type { NamespaceKeyInfo } from "../../kv/helpers";
-
-export function mockKeyListRequest(
-	expectedNamespaceId: string,
-	expectedKeys: NamespaceKeyInfo[],
-	keysPerRequest = 1000,
-	blankCursorValue: "" | undefined | null = undefined
-) {
-	const requests = { count: 0 };
-	// See https://api.cloudflare.com/#workers-kv-namespace-list-a-namespace-s-keys
-
-	setMockRawResponse(
-		"/accounts/:accountId/storage/kv/namespaces/:namespaceId/keys",
-		"GET",
-		([_url, accountId, namespaceId], _init, query) => {
-			requests.count++;
-			expect(accountId).toEqual("some-account-id");
-			expect(namespaceId).toEqual(expectedNamespaceId);
-			if (expectedKeys.length <= keysPerRequest) {
-				return createFetchResult(expectedKeys);
-			} else {
-				const start = parseInt(query.get("cursor") ?? "0") || 0;
-				const end = start + keysPerRequest;
-				const cursor = end < expectedKeys.length ? end : blankCursorValue;
-				return createFetchResult(expectedKeys.slice(start, end), true, [], [], {
-					cursor,
-				});
-			}
-		}
-	);
-	return requests;
-}

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

@@ -1,252 +0,0 @@
-import fetchMock from "jest-fetch-mock";
-import { Request } from "undici";
-import openInBrowser from "../../open-in-browser";
-import {
-	createFetchResult,
-	setMockRawResponse,
-	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;
-	});
-}
-
-export function mockGetMembershipsFail() {
-	setMockRawResponse("/memberships", () => {
-		return createFetchResult([], false);
-	});
-}
-
-// 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 = () => {
-		(
-			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) => {
-			// TODO: update Miniflare typings to match full undici Request
-			outcome.actual = req as unknown as Request;
-			return "";
-		});
-
-		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) => {
-			// TODO: update Miniflare typings to match full undici Request
-			outcome.actual = req as unknown as Request;
-			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 {
-		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

@@ -1,39 +0,0 @@
-/**
- * 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 {
-	const calls = spy.mock.calls;
-	if (calls.length > 1) {
-		throw new Error(
-			"Unexpected calls to `stdout.write()`: " + JSON.stringify(calls)
-		);
-	}
-	const buffer = calls[0]?.[0] ?? Buffer.alloc(0);
-	if (buffer instanceof Buffer) {
-		return buffer;
-	} else {
-		throw new Error(
-			`Unexpected non-Buffer passed to \`stdout.write()\`: "${JSON.stringify(
-				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

@@ -1,108 +0,0 @@
-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

@@ -1,29 +0,0 @@
-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/handlers/namespaces.ts

@@ -1,104 +0,0 @@
-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

@@ -1,36 +0,0 @@
-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(
-		"https://dash.cloudflare.com/oauth2/revoke",
-		(_, response, context) =>
-			response.once(context.status(200), context.text(""))
-	),
-	// exchange (auth code | refresh token) for access token
-	rest.post(
-		"https://dash.cloudflare.com/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",
-				})
-			);
-		}
-	),
-];