wrangler 0.0.0-e1e2ee5c → 0.0.0-e1f2576e

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-kv.ts

@@ -1,33 +0,0 @@
-import { createFetchResult, setMockRawResponse } from "./mock-cfetch";
-import type { NamespaceKeyInfo } from "../../kv";
-
-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,250 +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) => {
-			outcome.actual = req;
-			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) => {
-			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 {
-		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/run-in-tmp.ts

@@ -1,38 +0,0 @@
-import * as fs from "node:fs";
-import os from "node:os";
-import * as path from "node:path";
-import { reinitialiseAuthTokens } from "../../user";
-
-const originalCwd = process.cwd();
-
-export function runInTempDir({ homedir } = { homedir: "./home" }) {
-	let tmpDir: string;
-
-	beforeEach(() => {
-		// Use realpath because the temporary path can point to a symlink rather than the actual path.
-		tmpDir = fs.realpathSync(
-			fs.mkdtempSync(path.join(os.tmpdir(), "wrangler-tests"))
-		);
-
-		process.chdir(tmpDir);
-		// The path that is returned from `homedir()` should be absolute.
-		const absHomedir = path.resolve(tmpDir, homedir);
-		// Override where the home directory is so that we can write our own user config,
-		// without destroying the real thing.
-		fs.mkdirSync(absHomedir, { recursive: true });
-		// Note it is very important that we use the "default" value from "node:os" (e.g. `import os from "node:os";`)
-		// rather than an alias to the module (e.g. `import * as os from "node:os";`).
-		// This is because the module gets transpiled so that the "method" `homedir()` gets converted to a
-		// getter that is not configurable (and so cannot be spied upon).
-		jest.spyOn(os, "homedir")?.mockReturnValue(absHomedir);
-		// Now that we have changed the home directory location, we must reinitialize the user auth state
-		reinitialiseAuthTokens();
-	});
-
-	afterEach(() => {
-		if (fs.existsSync(tmpDir)) {
-			process.chdir(originalCwd);
-			fs.rmSync(tmpDir, { recursive: true });
-		}
-	});
-}

package/src/__tests__/helpers/run-wrangler.ts

@@ -1,16 +0,0 @@
-import { main } from "../../index";
-import { normalizeSlashes, stripTimings } from "./mock-console";
-
-/**
- * A helper to 'run' wrangler commands for tests.
- */
-export async function runWrangler(cmd?: string) {
-	try {
-		await main(cmd?.split(" ") ?? []);
-	} catch (err) {
-		if (err instanceof Error) {
-			err.message = normalizeSlashes(stripTimings(err.message));
-		}
-		throw err;
-	}
-}

package/src/__tests__/helpers/write-worker-source.ts

@@ -1,31 +0,0 @@
-import fs from "node:fs";
-
-/** Write a mock Worker script to disk. */
-export function writeWorkerSource({
-	basePath = ".",
-	format = "js",
-	type = "esm",
-}: {
-	basePath?: string;
-	format?: "js" | "ts" | "jsx" | "tsx" | "mjs";
-	type?: "esm" | "sw";
-} = {}) {
-	if (basePath !== ".") {
-		fs.mkdirSync(basePath, { recursive: true });
-	}
-	fs.writeFileSync(
-		`${basePath}/index.${format}`,
-		type === "esm"
-			? `import { foo } from "./another";
-      export default {
-        async fetch(request) {
-          return new Response('Hello' + foo);
-        },
-      };`
-			: `import { foo } from "./another";
-      addEventListener('fetch', event => {
-        event.respondWith(new Response('Hello' + foo));
-      })`
-	);
-	fs.writeFileSync(`${basePath}/another.${format}`, `export const foo = 100;`);
-}

package/src/__tests__/helpers/write-wrangler-toml.ts

@@ -1,17 +0,0 @@
-import * as fs from "fs";
-import TOML from "@iarna/toml";
-import type { RawConfig } from "../../config";
-
-/** Write a mock wrangler.toml file to disk. */
-export default function writeWranglerToml(config: RawConfig = {}) {
-	fs.writeFileSync(
-		"./wrangler.toml",
-		TOML.stringify({
-			compatibility_date: "2022-01-12",
-			name: "test-name",
-			...(config as TOML.JsonMap),
-		}),
-
-		"utf-8"
-	);
-}