wrangler 0.0.0-e60dc909 → 0.0.0-e61444cb

package/src/__tests__/type-generation.test.ts

@@ -1,233 +0,0 @@
-import * as fs from "fs";
-import * as TOML from "@iarna/toml";
-import { mockConsoleMethods } from "./helpers/mock-console";
-import { runInTempDir } from "./helpers/run-in-tmp";
-import { runWrangler } from "./helpers/run-wrangler";
-import type { Config } from "../config";
-
-const bindingsConfigMock: Partial<Config> = {
-	kv_namespaces: [{ binding: "TEST_KV_NAMESPACE", id: "1234" }],
-	vars: {
-		SOMETHING: "asdasdfasdf",
-		ANOTHER: "thing",
-		OBJECT_VAR: {
-			enterprise: "1701-D",
-			activeDuty: true,
-			captian: "Picard",
-		}, // We can assume the objects will be stringified
-	},
-	queues: {
-		producers: [
-			{
-				binding: "TEST_QUEUE_BINDING",
-				queue: "TEST_QUEUE",
-			},
-		],
-		consumers: [
-			{
-				queue: "my-queue",
-				max_batch_size: 10,
-				max_batch_timeout: 1,
-				max_retries: 3,
-			},
-		],
-	},
-	durable_objects: {
-		bindings: [
-			{ name: "DURABLE_TEST1", class_name: "Durability1" },
-			{ name: "DURABLE_TEST2", class_name: "Durability2" },
-		],
-	},
-	r2_buckets: [
-		{
-			binding: "R2_BUCKET_BINDING",
-			bucket_name: "R2BUCKET_NAME_TEST",
-		},
-	],
-	d1_databases: [
-		{
-			binding: "D1_TESTING_SOMETHING",
-			database_name: "D1_BINDING",
-			database_id: "1234",
-		},
-	],
-	services: [{ binding: "SERVICE_BINDING", service: "SERVICE_NAME" }],
-	analytics_engine_datasets: [
-		{
-			binding: "AE_DATASET_BINDING",
-			dataset: "AE_DATASET_TEST",
-		},
-	],
-	dispatch_namespaces: [
-		{ binding: "NAMESPACE_BINDING", namespace: "NAMESPACE_ID" },
-	],
-	logfwdr: {
-		schema: "LOGFWDER_SCHEMA",
-		bindings: [{ name: "LOGFWDR_BINDING", destination: "LOGFWDR_DESTINATION" }],
-	},
-	data_blobs: {
-		SOME_DATA_BLOB1: "SOME_DATA_BLOB1.bin",
-		SOME_DATA_BLOB2: "SOME_DATA_BLOB2.bin",
-	},
-	text_blobs: {
-		SOME_TEXT_BLOB1: "SOME_TEXT_BLOB1.txt",
-		SOME_TEXT_BLOB2: "SOME_TEXT_BLOB2.txt",
-	},
-	wasm_modules: { MODULE1: "module1.wasm", MODULE2: "module2.wasm" },
-	unsafe: {
-		bindings: [{ name: "testing_unsafe", type: "plain_text" }],
-	},
-	rules: [
-		{
-			type: "Text",
-			globs: ["**/*.txt"],
-			fallthrough: true,
-		},
-		{
-			type: "Data",
-			globs: ["**/*.webp"],
-			fallthrough: true,
-		},
-		{ type: "CompiledWasm", globs: ["**/*.wasm"], fallthrough: true },
-	],
-};
-
-describe("generateTypes()", () => {
-	const std = mockConsoleMethods();
-	runInTempDir();
-
-	it("should log the interface type generated and declare modules", async () => {
-		fs.writeFileSync("./index.ts", "export default { async fetch () {} };");
-		fs.writeFileSync(
-			"./wrangler.toml",
-			TOML.stringify({
-				compatibility_date: "2022-01-12",
-				name: "test-name",
-				main: "./index.ts",
-				...bindingsConfigMock,
-				unsafe: bindingsConfigMock.unsafe ?? {},
-			} as unknown as TOML.JsonMap),
-			"utf-8"
-		);
-
-		await runWrangler("types");
-		expect(std.out).toMatchInlineSnapshot(`
-		"interface Env {
-			TEST_KV_NAMESPACE: KVNamespace;
-			SOMETHING: \\"asdasdfasdf\\";
-			ANOTHER: \\"thing\\";
-			OBJECT_VAR: {\\"enterprise\\":\\"1701-D\\",\\"activeDuty\\":true,\\"captian\\":\\"Picard\\"};
-			DURABLE_TEST1: DurableObjectNamespace;
-			DURABLE_TEST2: DurableObjectNamespace;
-			R2_BUCKET_BINDING: R2Bucket;
-			D1_TESTING_SOMETHING: D1Database;
-			SERVICE_BINDING: Fetcher;
-			AE_DATASET_BINDING: AnalyticsEngineDataset;
-			NAMESPACE_BINDING: any;
-			LOGFWDR_SCHEMA: any;
-			SOME_DATA_BLOB1: ArrayBuffer;
-			SOME_DATA_BLOB2: ArrayBuffer;
-			SOME_TEXT_BLOB1: string;
-			SOME_TEXT_BLOB2: string;
-			testing_unsafe: any;
-			TEST_QUEUE_BINDING: Queue;
-		}
-		declare module \\"*.txt\\" {
-			const value: string;
-			export default value;
-		}
-		declare module \\"*.webp\\" {
-			const value: ArrayBuffer;
-			export default value;
-		}
-		declare module \\"*.wasm\\" {
-			const value: WebAssembly.Module;
-			export default value;
-		}"
-	`);
-	});
-
-	it("should create a DTS file at the location that the command is executed from", async () => {
-		fs.writeFileSync("./index.ts", "export default { async fetch () {} };");
-		fs.writeFileSync(
-			"./wrangler.toml",
-			TOML.stringify({
-				compatibility_date: "2022-01-12",
-				name: "test-name",
-				main: "./index.ts",
-				vars: bindingsConfigMock.vars,
-				// eslint-disable-next-line @typescript-eslint/no-explicit-any
-			} as any),
-			"utf-8"
-		);
-		await runWrangler("types");
-		expect(fs.existsSync("./worker-configuration.d.ts")).toBe(true);
-	});
-
-	it("should not create DTS file if there is nothing in the config to generate types from", async () => {
-		fs.writeFileSync("./index.ts", "export default { async fetch () {} };");
-		fs.writeFileSync(
-			"./wrangler.toml",
-			TOML.stringify({
-				compatibility_date: "2022-01-12",
-				name: "test-name",
-				main: "./index.ts",
-			}),
-			"utf-8"
-		);
-
-		await runWrangler("types");
-		expect(fs.existsSync("./worker-configuration.d.ts")).toBe(false);
-		expect(std.out).toMatchInlineSnapshot(`""`);
-	});
-
-	it("should create a DTS file at the location that the command is executed from", async () => {
-		fs.writeFileSync(
-			"./worker-configuration.d.ts",
-			"NOT THE CONTENTS OF THE GENERATED FILE"
-		);
-		fs.writeFileSync("./index.ts", "export default { async fetch () {} };");
-		fs.writeFileSync(
-			"./wrangler.toml",
-			TOML.stringify({
-				compatibility_date: "2022-01-12",
-				name: "test-name",
-				main: "./index.ts",
-				vars: bindingsConfigMock.vars,
-			} as TOML.JsonMap),
-			"utf-8"
-		);
-
-		await expect(runWrangler("types")).rejects.toMatchInlineSnapshot(
-			`[Error: A non-wrangler worker-configuration.d.ts already exists, please rename and try again.]`
-		);
-		expect(fs.existsSync("./worker-configuration.d.ts")).toBe(true);
-	});
-
-	it("should log the declare global type generated and declare modules", async () => {
-		fs.writeFileSync(
-			"./index.ts",
-			`addEventListener('fetch', event => {  event.respondWith(handleRequest(event.request));
-		}); async function handleRequest(request) {  return new Response('Hello worker!', {headers: { 'content-type': 'text/plain' },});}`
-		);
-		fs.writeFileSync(
-			"./wrangler.toml",
-			TOML.stringify({
-				compatibility_date: "2022-01-12",
-				name: "test-name",
-				main: "./index.ts",
-				unsafe: bindingsConfigMock.unsafe ?? {},
-			} as TOML.JsonMap),
-			"utf-8"
-		);
-
-		await runWrangler("types");
-		expect(std.out).toMatchInlineSnapshot(`
-		"export {};
-		declare global {
-			const testing_unsafe: any;
-		}
-		"
-	`);
-	});
-});

package/src/__tests__/user.test.ts

@@ -1,129 +0,0 @@
-import { rest } from "msw";
-import { CI } from "../is-ci";
-import {
-	loginOrRefreshIfRequired,
-	readAuthConfigFile,
-	requireAuth,
-	writeAuthConfigFile,
-} from "../user";
-import { mockConsoleMethods } from "./helpers/mock-console";
-import { useMockIsTTY } from "./helpers/mock-istty";
-import { mockOAuthFlow } from "./helpers/mock-oauth-flow";
-import {
-	msw,
-	mswSuccessOauthHandlers,
-	mswSuccessUserHandlers,
-} from "./helpers/msw";
-import { runInTempDir } from "./helpers/run-in-tmp";
-import { runWrangler } from "./helpers/run-wrangler";
-import type { Config } from "../config";
-import type { UserAuthConfig } from "../user";
-
-describe("User", () => {
-	let isCISpy: jest.SpyInstance;
-	runInTempDir();
-	const std = mockConsoleMethods();
-	// TODO: Implement these two mocks with MSW
-	const { mockOAuthServerCallback } = mockOAuthFlow();
-	const { setIsTTY } = useMockIsTTY();
-
-	beforeEach(() => {
-		msw.use(...mswSuccessOauthHandlers, ...mswSuccessUserHandlers);
-		isCISpy = jest.spyOn(CI, "isCI").mockReturnValue(false);
-	});
-
-	describe("login", () => {
-		it("should login a user when `wrangler login` is run", async () => {
-			mockOAuthServerCallback("success");
-
-			let counter = 0;
-			msw.use(
-				rest.post("*/oauth2/token", async (_, response, context) => {
-					counter += 1;
-
-					return response.once(
-						context.status(200),
-						context.json({
-							access_token: "test-access-token",
-							expires_in: 100000,
-							refresh_token: "test-refresh-token",
-							scope: "account:read",
-						})
-					);
-				})
-			);
-
-			await runWrangler("login");
-
-			expect(counter).toBe(1);
-			expect(std.out).toMatchInlineSnapshot(`
-			"Attempting to login via OAuth...
-			Opening a link in your default browser: https://dash.cloudflare.com/oauth2/auth?response_type=code&client_id=54d11594-84e4-41aa-b438-e81b8fa78ee7&redirect_uri=http%3A%2F%2Flocalhost%3A8976%2Foauth%2Fcallback&scope=account%3Aread%20user%3Aread%20workers%3Awrite%20workers_kv%3Awrite%20workers_routes%3Awrite%20workers_scripts%3Awrite%20workers_tail%3Aread%20d1%3Awrite%20pages%3Awrite%20zone%3Aread%20offline_access&state=MOCK_STATE_PARAM&code_challenge=MOCK_CODE_CHALLENGE&code_challenge_method=S256
-			Successfully logged in."
-		`);
-			expect(readAuthConfigFile()).toEqual<UserAuthConfig>({
-				api_token: undefined,
-				oauth_token: "test-access-token",
-				refresh_token: "test-refresh-token",
-				expiration_time: expect.any(String),
-				scopes: ["account:read"],
-			});
-		});
-	});
-
-	it("should handle errors for failed token refresh in a non-interactive environment", async () => {
-		setIsTTY(false);
-		writeAuthConfigFile({
-			oauth_token: "hunter2",
-			refresh_token: "Order 66",
-		});
-		// TODO: Use MSW to handle `/token` endpoints from different calls
-		let counter = 0;
-		msw.use(
-			rest.post("*/oauth2/token", async (request, response, context) => {
-				counter += 1;
-				return response.once(
-					context.status(400),
-					context.body(
-						`<html> <body> This shouldn't be sent, but should be handled </body> </html>`
-					)
-				);
-			})
-		);
-
-		// Handles the requireAuth error throw from failed login that is unhandled due to directly calling it here
-		await expect(
-			requireAuth({} as Config)
-		).rejects.toThrowErrorMatchingInlineSnapshot(
-			`"In a non-interactive environment, it's necessary to set a CLOUDFLARE_API_TOKEN environment variable for wrangler to work. Please go to https://developers.cloudflare.com/api/tokens/create/ for instructions on how to create an api token, and assign its value to CLOUDFLARE_API_TOKEN."`
-		);
-		expect(counter).toBe(0);
-	});
-
-	it("should confirm no error message when refresh is successful", async () => {
-		setIsTTY(false);
-		writeAuthConfigFile({
-			oauth_token: "hunter2",
-			refresh_token: "Order 66",
-		});
-
-		// Handles the requireAuth error throw from failed login that is unhandled due to directly calling it here
-		await expect(requireAuth({} as Config)).rejects.toThrowError();
-		expect(std.err).toContain("");
-	});
-
-	it("should revert to non-interactive mode if in CI", async () => {
-		isCISpy.mockReturnValue(true);
-		await expect(loginOrRefreshIfRequired()).resolves.toEqual(false);
-	});
-
-	it("should revert to non-interactive mode if isTTY throws an error", async () => {
-		setIsTTY({
-			stdin() {
-				throw new Error("stdin is not tty");
-			},
-			stdout: true,
-		});
-		await expect(loginOrRefreshIfRequired()).resolves.toEqual(false);
-	});
-});

package/src/__tests__/utils-collectKeyValues.test.ts

@@ -1,47 +0,0 @@
-import { collectKeyValues } from "../utils/collectKeyValues";
-
-describe("collectKeyValues()", () => {
-	it("should return an empty object when passed undefined", () => {
-		expect(collectKeyValues(undefined)).toEqual({});
-	});
-
-	it("should return an empty object when passed an empty array", () => {
-		expect(collectKeyValues([])).toEqual({});
-	});
-
-	it("should parse a key:value string with no value by returning an empty string for the value", () => {
-		expect(collectKeyValues(["some-string-with-no-colon"])).toEqual({
-			"some-string-with-no-colon": "",
-		});
-	});
-
-	it("should return an object with a single key/value pair when passed an array with a single string", () => {
-		expect(collectKeyValues(["some-key:some-value"])).toEqual({
-			"some-key": "some-value",
-		});
-	});
-
-	it("should return an object with multiple key/value pairs when passed an array with multiple strings", () => {
-		expect(
-			collectKeyValues([
-				"some-key:some-value",
-				"some-other-key:some-other-value",
-			])
-		).toEqual({
-			"some-key": "some-value",
-			"some-other-key": "some-other-value",
-		});
-	});
-
-	it("should return an object with multiple key/value pairs when passed an array with multiple strings with multiple colons", () => {
-		expect(
-			collectKeyValues([
-				"some-key:https://some-value.com",
-				"some-other-key:https://some-other-value.com",
-			])
-		).toEqual({
-			"some-key": "https://some-value.com",
-			"some-other-key": "https://some-other-value.com",
-		});
-	});
-});

package/src/__tests__/validate-dev-props.test.ts

@@ -1,56 +0,0 @@
-import { validateDevProps } from "../dev/validate-dev-props";
-import type { DevProps } from "../dev/dev";
-
-describe("validateDevProps", () => {
-	it("should throw if the user tries to use the service-worker format with an `assets` directory", () => {
-		const props = {
-			isWorkersSite: false,
-			assetPaths: ["assets"],
-			entry: { format: "service-worker" },
-			bindings: {},
-		};
-
-		expect(() => validateDevProps(props as unknown as DevProps)).toThrowError(
-			"You cannot use the service-worker format with an `assets` directory yet. For information on how to migrate to the module-worker format, see: https://developers.cloudflare.com/workers/learning/migrating-to-module-workers/"
-		);
-	});
-
-	it("should throw if the user tries to configure [wasm_modules] with an ES module worker", () => {
-		const props = {
-			isWorkersSite: false,
-			assetPaths: [],
-			entry: { format: "modules" },
-			bindings: { wasm_modules: true },
-		};
-
-		expect(() => validateDevProps(props as unknown as DevProps)).toThrowError(
-			"You cannot configure [wasm_modules] with an ES module worker. Instead, import the .wasm module directly in your code"
-		);
-	});
-
-	it("should throw if the user tries to configure [text_blobs] with an ES module worker", () => {
-		const props = {
-			isWorkersSite: false,
-			assetPaths: [],
-			entry: { format: "modules" },
-			bindings: { text_blobs: true },
-		};
-
-		expect(() => validateDevProps(props as unknown as DevProps)).toThrowError(
-			"You cannot configure [text_blobs] with an ES module worker. Instead, import the file directly in your code, and optionally configure `[rules]` in your wrangler.toml"
-		);
-	});
-
-	it("should throw if the user tries to configure [data_blobs] with an ES module worker", () => {
-		const props = {
-			isWorkersSite: false,
-			assetPaths: [],
-			entry: { format: "modules" },
-			bindings: { data_blobs: true },
-		};
-
-		expect(() => validateDevProps(props as unknown as DevProps)).toThrowError(
-			"You cannot configure [data_blobs] with an ES module worker. Instead, import the file directly in your code, and optionally configure `[rules]` in your wrangler.toml"
-		);
-	});
-});

package/src/__tests__/version.test.ts

@@ -1,35 +0,0 @@
-import { version } from "./../../package.json";
-import { mockConsoleMethods } from "./helpers/mock-console";
-import { useMockIsTTY } from "./helpers/mock-istty";
-import { runWrangler } from "./helpers/run-wrangler";
-
-describe("version", () => {
-	const std = mockConsoleMethods();
-	const { setIsTTY } = useMockIsTTY();
-
-	// We cannot test output of version banner,
-	// as it is disabled in jest environments
-
-	// it("should output version banner", async () => {
-	// 	await runWrangler("-v");
-	// 	expect(std.out).toMatchInlineSnapshot(`
-	// 	" ⛅️ wrangler 2.0.22
-	// 	--------------------"
-	// `);
-	// });
-
-	it("should output current version if !isTTY calling -v", async () => {
-		setIsTTY(false);
-
-		await runWrangler("-v");
-		expect(std.out).toMatch(version);
-	});
-
-	// This run separately as command handling is different
-	it("should output current version if !isTTY calling --version", async () => {
-		setIsTTY(false);
-
-		await runWrangler("--version");
-		expect(std.out).toMatch(version);
-	});
-});

package/src/__tests__/whoami.test.tsx

@@ -1,183 +0,0 @@
-import { rest } from "msw";
-import { writeAuthConfigFile } from "../user";
-import { getUserInfo } from "../whoami";
-import { mockConsoleMethods } from "./helpers/mock-console";
-import { useMockIsTTY } from "./helpers/mock-istty";
-import {
-	msw,
-	mswSuccessOauthHandlers,
-	mswSuccessUserHandlers,
-} from "./helpers/msw";
-import { runInTempDir } from "./helpers/run-in-tmp";
-
-describe("getUserInfo()", () => {
-	const ENV_COPY = process.env;
-
-	runInTempDir();
-	const std = mockConsoleMethods();
-	const { setIsTTY } = useMockIsTTY();
-
-	beforeEach(() => {
-		msw.use(...mswSuccessOauthHandlers, ...mswSuccessUserHandlers);
-		setIsTTY(true);
-	});
-
-	afterEach(() => {
-		process.env = ENV_COPY;
-	});
-
-	it("should return undefined if there is no config file", async () => {
-		const userInfo = await getUserInfo();
-		expect(userInfo).toBeUndefined();
-	});
-
-	it("should return undefined if there is an empty config file", async () => {
-		writeAuthConfigFile({});
-		const userInfo = await getUserInfo();
-		expect(userInfo).toBeUndefined();
-	});
-
-	it("should return undefined for email if the user settings API request fails with 9109", async () => {
-		process.env = {
-			CLOUDFLARE_API_TOKEN: "123456789",
-		};
-		msw.use(
-			rest.get("*/user", (_, res, ctx) => {
-				return res.once(
-					ctx.status(200),
-					ctx.json({
-						success: false,
-						errors: [
-							{
-								code: 9109,
-								message: "Uauthorized to access requested resource",
-							},
-						],
-						messages: [],
-						result: {},
-					})
-				);
-			}),
-			rest.get("*/accounts", (request, res, ctx) => {
-				const headersObject = request.headers.all();
-				delete headersObject["user-agent"];
-
-				expect(headersObject).toMatchInlineSnapshot(`
-			Object {
-			  "accept": "*/*",
-			  "accept-encoding": "gzip,deflate",
-			  "authorization": "Bearer 123456789",
-			  "connection": "close",
-			  "host": "api.cloudflare.com",
-			}
-		`);
-				return res.once(
-					ctx.status(200),
-					ctx.json({
-						success: true,
-						errors: [],
-						messages: [],
-						result: [],
-					})
-				);
-			})
-		);
-		const userInfo = await getUserInfo();
-		expect(userInfo?.email).toBeUndefined();
-	});
-	it("should say it's using an API token when one is set", async () => {
-		process.env = {
-			CLOUDFLARE_API_TOKEN: "123456789",
-		};
-
-		const userInfo = await getUserInfo();
-		expect(userInfo).toEqual({
-			authType: "API Token",
-			apiToken: "123456789",
-			email: "user@example.com",
-			accounts: [
-				{ name: "Account One", id: "account-1" },
-				{ name: "Account Two", id: "account-2" },
-				{ name: "Account Three", id: "account-3" },
-			],
-		});
-	});
-
-	it("should say it's using a Global API Key when one is set", async () => {
-		process.env = {
-			CLOUDFLARE_API_KEY: "123456789",
-			CLOUDFLARE_EMAIL: "user@example.com",
-		};
-
-		const userInfo = await getUserInfo();
-		expect(userInfo).toEqual({
-			authType: "Global API Key",
-			apiToken: "123456789",
-			email: "user@example.com",
-			accounts: [
-				{ name: "Account One", id: "account-1" },
-				{ name: "Account Two", id: "account-2" },
-				{ name: "Account Three", id: "account-3" },
-			],
-		});
-	});
-
-	it("should use a Global API Key in preference to an API token", async () => {
-		process.env = {
-			CLOUDFLARE_API_KEY: "123456789",
-			CLOUDFLARE_EMAIL: "user@example.com",
-			CLOUDFLARE_API_TOKEN: "123456789",
-		};
-
-		const userInfo = await getUserInfo();
-		expect(userInfo).toEqual({
-			authType: "Global API Key",
-			apiToken: "123456789",
-			email: "user@example.com",
-			accounts: [
-				{ name: "Account One", id: "account-1" },
-				{ name: "Account Two", id: "account-2" },
-				{ name: "Account Three", id: "account-3" },
-			],
-		});
-	});
-
-	it("should return undefined only a Global API Key, but not Email, is set", async () => {
-		process.env = {
-			CLOUDFLARE_API_KEY: "123456789",
-		};
-		const userInfo = await getUserInfo();
-		expect(userInfo).toEqual(undefined);
-	});
-
-	it("should return the user's email and accounts if authenticated via config token", async () => {
-		writeAuthConfigFile({ oauth_token: "some-oauth-token" });
-		const userInfo = await getUserInfo();
-
-		expect(userInfo).toEqual({
-			authType: "OAuth Token",
-			apiToken: "some-oauth-token",
-			email: "user@example.com",
-			accounts: [
-				{ name: "Account One", id: "account-1" },
-				{ name: "Account Two", id: "account-2" },
-				{ name: "Account Three", id: "account-3" },
-			],
-		});
-	});
-
-	it("should display a warning message if the config file contains a legacy api_token field", async () => {
-		writeAuthConfigFile({ api_token: "API_TOKEN" });
-		await getUserInfo();
-
-		expect(std.warn).toMatchInlineSnapshot(`
-		      "▲ [WARNING] It looks like you have used Wrangler 1's \`config\` command to login with an API token.
-
-		        This is no longer supported in the current version of Wrangler.
-		        If you wish to authenticate via an API token then please set the \`CLOUDFLARE_API_TOKEN\`
-		        environment variable.
-
-		      "
-	    `);
-	});
-});