wrangler 0.0.0-e7a0cd5b → 0.0.0-e81b1611

package/src/__tests__/test-old-node-version.js

@@ -1,31 +0,0 @@
-// this test has to be run with a version of node.js older than 16.13 to pass
-
-const { spawn } = require("child_process");
-const path = require("path");
-
-const assert = require("assert");
-
-const wranglerProcess = spawn(
-	"node",
-	[path.join(__dirname, "../../bin/wrangler.js")],
-	{ stdio: "pipe" }
-);
-
-const messageToMatch = "Wrangler requires at least node.js v16.13.0";
-
-wranglerProcess.once("exit", (code) => {
-	try {
-		const errorMessage = wranglerProcess.stderr.read().toString();
-
-		assert(code === 1, "Expected exit code 1");
-		assert(
-			errorMessage.includes(messageToMatch),
-			`Expected error message to include "${messageToMatch}"`
-		);
-	} catch (err) {
-		console.error("Error:", err);
-		throw new Error(
-			"This test has to be run with a version of node.js under 16.13 to pass"
-		);
-	}
-});

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

@@ -1,217 +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";
-import type { CfWorkerInit } from "../worker";
-
-const bindingsConfigMock: CfWorkerInit["bindings"] & {
-	rules: Config["rules"];
-} = {
-	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
-	},
-	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: [
-		{
-			// @ts-expect-error This type is resolved in the function that handles creating BETA string
-			binding: "D1_TESTING_SOMETHING",
-			database_name: "D1_BINDING",
-			database_id: "1234",
-		},
-	],
-	services: [{ binding: "SERVICE_BINDING", service: "SERVICE_NAME" }],
-	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: [
-		{
-			// @ts-expect-error Unsafe bindings type is somewhat different in different places
-			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",
-				// eslint-disable-next-line @typescript-eslint/no-explicit-any
-				...(bindingsConfigMock as any),
-				unsafe: bindingsConfigMock.unsafe?.at(0) ?? {},
-			}),
-			"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;
-			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;
-		}
-		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",
-				// @ts-expect-error This type is out of sync with the actual bindingsConfig type
-				vars: bindingsConfigMock.vars,
-			}),
-			"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",
-				// @ts-expect-error This type is out of sync with the actual bindingsConfig type
-				vars: bindingsConfigMock.vars,
-			}),
-			"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",
-				// @ts-expect-error This type is out of sync with the actual bindingsConfig type
-				unsafe: bindingsConfigMock.unsafe?.at(0) ?? {},
-			}),
-			"utf-8"
-		);
-
-		await runWrangler("types");
-		expect(std.out).toMatchInlineSnapshot(`
-		"declare global {
-			testing_unsafe: any;
-		}
-		"
-	`);
-	});
-});

package/src/__tests__/user.test.ts

@@ -1,155 +0,0 @@
-import fs from "node:fs";
-import path from "node:path";
-import fetchMock from "jest-fetch-mock";
-import { getGlobalWranglerConfigPath } from "../global-wrangler-config-path";
-import { CI } from "../is-ci";
-import {
-	loginOrRefreshIfRequired,
-	readAuthConfigFile,
-	requireAuth,
-	USER_AUTH_CONFIG_FILE,
-	writeAuthConfigFile,
-} from "../user";
-import { mockConsoleMethods } from "./helpers/mock-console";
-import { useMockIsTTY } from "./helpers/mock-istty";
-import { mockOAuthFlow } from "./helpers/mock-oauth-flow";
-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();
-	const {
-		mockOAuthServerCallback,
-		mockGrantAccessToken,
-		mockGrantAuthorization,
-		mockRevokeAuthorization,
-		mockExchangeRefreshTokenForAccessToken,
-	} = mockOAuthFlow();
-
-	const { setIsTTY } = useMockIsTTY();
-
-	beforeEach(() => {
-		isCISpy = jest.spyOn(CI, "isCI").mockReturnValue(false);
-	});
-
-	describe("login", () => {
-		it("should login a user when `wrangler login` is run", async () => {
-			mockOAuthServerCallback();
-			const accessTokenRequest = mockGrantAccessToken({ respondWith: "ok" });
-			mockGrantAuthorization({ respondWith: "success" });
-
-			await runWrangler("login");
-
-			expect(accessTokenRequest.actual.url).toEqual(
-				accessTokenRequest.expected.url
-			);
-			expect(accessTokenRequest.actual.method).toEqual(
-				accessTokenRequest.expected.method
-			);
-
-			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"],
-			});
-		});
-	});
-
-	describe("logout", () => {
-		it("should exit with a message stating the user is not logged in", async () => {
-			await runWrangler("logout");
-			expect(std.out).toMatchInlineSnapshot(`"Not logged in, exiting..."`);
-		});
-
-		it("should logout user that has been properly logged in", async () => {
-			writeAuthConfigFile({
-				oauth_token: "some-oauth-tok",
-				refresh_token: "some-refresh-tok",
-			});
-			const outcome = mockRevokeAuthorization();
-
-			await runWrangler("logout");
-
-			expect(outcome.actual.url).toEqual(
-				"https://dash.cloudflare.com/oauth2/revoke"
-			);
-			expect(outcome.actual.method).toEqual("POST");
-
-			expect(std.out).toMatchInlineSnapshot(`"Successfully logged out."`);
-
-			// Make sure that we made the request to logout.
-			expect(fetchMock).toHaveBeenCalledTimes(1);
-
-			// Make sure that logout removed the config file containing the auth tokens.
-			const config = path.join(
-				getGlobalWranglerConfigPath(),
-				USER_AUTH_CONFIG_FILE
-			);
-			expect(fs.existsSync(config)).toBeFalsy();
-		});
-	});
-
-	// TODO: Improve OAuth mocking to handle `/token` endpoints from different calls
-	it("should handle errors for failed token refresh", async () => {
-		setIsTTY(false);
-		writeAuthConfigFile({
-			oauth_token: "hunter2",
-			refresh_token: "Order 66",
-		});
-		mockExchangeRefreshTokenForAccessToken({
-			respondWith: "badResponse",
-		});
-
-		// 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."`
-		);
-	});
-
-	it("should confirm no error message when refresh is successful", async () => {
-		setIsTTY(false);
-		mockOAuthServerCallback();
-		writeAuthConfigFile({
-			oauth_token: "hunter2",
-			refresh_token: "Order 66",
-		});
-		mockGrantAuthorization({ respondWith: "success" });
-
-		mockExchangeRefreshTokenForAccessToken({
-			respondWith: "refreshSuccess",
-		});
-
-		// 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);
-	});
-});