wrangler 0.0.0-e6733a3 → 0.0.0-e6c71262

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

@@ -0,0 +1,234 @@
+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" }],
+		metadata: { some_key: "some_value" },
+	},
+	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__/unstableDev.test.ts

@@ -0,0 +1,61 @@
+import { fetch } from "undici";
+import {
+	stopWorkerRegistry,
+	registerWorker,
+	startWorkerRegistry,
+} from "../dev-registry";
+
+jest.unmock("undici");
+
+/**
+ * Sometimes the devRegistry killed by some reason, the register worker will to restart it.
+ */
+describe("unstable devRegistry testing", () => {
+	afterAll(async () => {
+		await stopWorkerRegistry();
+	});
+
+	it("should start the devRegistry if the devRegistry not start", async () => {
+		await registerWorker("test", {
+			port: 6789,
+			protocol: "http",
+			host: "localhost",
+			mode: "local",
+			durableObjects: [{ name: "testing", className: "testing" }],
+		});
+		const resp = await fetch("http://localhost:6284/workers");
+		if (resp) {
+			const parsedResp = (await resp.json()) as {
+				test: unknown;
+			};
+			expect(parsedResp.test).toBeTruthy();
+		}
+	});
+
+	it("should not restart the devRegistry if the devRegistry already start", async () => {
+		await startWorkerRegistry();
+
+		await fetch("http://localhost:6284/workers/init", {
+			method: "POST",
+			body: JSON.stringify({}),
+		});
+
+		await registerWorker("test", {
+			port: 6789,
+			protocol: "http",
+			host: "localhost",
+			mode: "local",
+			durableObjects: [{ name: "testing", className: "testing" }],
+		});
+
+		const resp = await fetch("http://localhost:6284/workers");
+		if (resp) {
+			const parsedResp = (await resp.json()) as {
+				test: unknown;
+				init: unknown;
+			};
+			expect(parsedResp.init).toBeTruthy();
+			expect(parsedResp.test).toBeTruthy();
+		}
+	});
+});

package/src/__tests__/user.test.ts

@@ -0,0 +1,118 @@
+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 {
+	mockExchangeRefreshTokenForAccessToken,
+	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.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%20ssl_certs%3Awrite%20constellation%3Awrite%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",
+		});
+		mockExchangeRefreshTokenForAccessToken({ respondWith: "refreshError" });
+
+		// 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/fundamentals/api/get-started/create-token/ for instructions on how to create an api token, and assign its value to CLOUDFLARE_API_TOKEN."`
+		);
+	});
+
+	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

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

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

@@ -0,0 +1,35 @@
+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);
+	});
+});