wrangler 0.0.0-e464fcdb → 0.0.0-e4aff81a

package/src/__tests__/generate.test.ts

@@ -1,237 +0,0 @@
-import fs from "node:fs";
-import path from "node:path";
-import { mockConsoleMethods } from "./helpers/mock-console";
-import { mockConfirm } from "./helpers/mock-dialogs";
-import { useMockIsTTY } from "./helpers/mock-istty";
-import { runInTempDir } from "./helpers/run-in-tmp";
-import { runWrangler } from "./helpers/run-wrangler";
-
-describe("generate", () => {
-	runInTempDir();
-	const { setIsTTY } = useMockIsTTY();
-	const std = mockConsoleMethods();
-	beforeEach(() => {
-		setIsTTY(true);
-	});
-
-	describe("cli functionality", () => {
-		afterEach(() => {});
-
-		it("defers to `wrangler init` when no template is given", async () => {
-			mockConfirm(
-				{
-					text: "Would you like to use git to manage this Worker?",
-					result: false,
-				},
-				{
-					text: "No package.json found. Would you like to create one?",
-					result: false,
-				}
-			);
-			await runWrangler("generate no-template");
-			expect(std.out).toMatchInlineSnapshot(
-				`"✨ Created no-template/wrangler.toml"`
-			);
-		});
-
-		it("complains when given the --type argument", async () => {
-			await expect(
-				runWrangler("generate worker-name worker-template --type rust")
-			).rejects.toThrowErrorMatchingInlineSnapshot(
-				`"The --type option is no longer supported."`
-			);
-		});
-
-		it("complains when given the --site argument", async () => {
-			await expect(runWrangler("generate worker-name worker-template --site"))
-				.rejects.toThrowErrorMatchingInlineSnapshot(`
-					"The --site option is no longer supported.
-					If you wish to create a brand new Worker Sites project then clone the \`worker-sites-template\` starter repository:
-
-					\`\`\`
-					git clone --depth=1 --branch=wrangler2 https://github.com/cloudflare/worker-sites-template worker-name
-					cd worker-name
-					\`\`\`
-
-					Find out more about how to create and maintain Sites projects at https://developers.cloudflare.com/workers/platform/sites.
-					Have you considered using Cloudflare Pages instead? See https://pages.cloudflare.com/."
-				`);
-		});
-
-		it.skip("auto-increments the worker directory name", async () => {
-			fs.mkdirSync("my-worker");
-
-			expect(fs.existsSync("my-worker-1")).toBe(false);
-
-			await expect(
-				runWrangler("generate my-worker worker-typescript")
-			).resolves.toBeUndefined();
-
-			expect(std.out).toStrictEqual(expect.stringContaining("my-worker-1"));
-
-			expect(readDirectory("my-worker-1")).toMatchObject<Directory>({
-				".git": expect.any(Object),
-				".gitignore": expect.any(String),
-				"README.md": expect.stringContaining("Template: worker-typescript"),
-				"jest.config.json": expect.any(String),
-				"package.json": expect.stringContaining("@cloudflare/workers-types"),
-				src: expect.objectContaining({ "index.ts": expect.any(String) }),
-				test: expect.objectContaining({
-					"index.test.ts": expect.any(String),
-				}),
-				"tsconfig.json": expect.any(String),
-				"wrangler.toml": expect.any(String),
-			});
-			expect(fs.existsSync("my-worker-2")).toBe(false);
-
-			await expect(
-				runWrangler("generate my-worker worker-typescript")
-			).resolves.toBeUndefined();
-
-			expect(std.out).toStrictEqual(expect.stringContaining("my-worker-2"));
-
-			expect(readDirectory("my-worker-2")).toMatchObject<Directory>({
-				".git": expect.any(Object),
-				".gitignore": expect.any(String),
-				"README.md": expect.stringContaining("Template: worker-typescript"),
-				"jest.config.json": expect.any(String),
-				"package.json": expect.stringContaining("@cloudflare/workers-types"),
-				src: expect.objectContaining({ "index.ts": expect.any(String) }),
-				test: expect.objectContaining({
-					"index.test.ts": expect.any(String),
-				}),
-				"tsconfig.json": expect.any(String),
-				"wrangler.toml": expect.any(String),
-			});
-		});
-	});
-
-	describe("cloning", () => {
-		it("clones a cloudflare template with sparse checkouts", async () => {
-			await expect(
-				runWrangler("generate my-worker worker-typescript")
-			).resolves.toBeUndefined();
-
-			expect(readDirectory("my-worker")).toMatchObject<Directory>({
-				".git": expect.any(Object),
-				".gitignore": expect.any(String),
-				"README.md": expect.stringContaining("Template: worker-typescript"),
-				"package.json": expect.stringContaining("@cloudflare/workers-types"),
-				src: expect.objectContaining({
-					"index.ts": expect.any(String),
-					"index.test.ts": expect.any(String),
-				}),
-				"tsconfig.json": expect.any(String),
-				"wrangler.toml": expect.any(String),
-			});
-		});
-
-		// mocking out calls to either `isGitInstalled` or `execa("git", ["--version"])`
-		// was harder than i thought, leaving this for now.
-		it.todo("clones a cloudflare template with full checkouts");
-
-		it.skip("clones a user/repo template", async () => {
-			await expect(
-				runWrangler("generate my-worker caass/wrangler-generate-test-template")
-			).resolves.toBeUndefined();
-
-			expect(readDirectory("my-worker")).toMatchObject<Directory>({
-				".git": expect.any(Object),
-				".gitignore": expect.any(String),
-				"package.json": expect.stringContaining("@cloudflare/workers-types"),
-				src: expect.objectContaining({ "index.ts": expect.any(String) }),
-				"tsconfig.json": expect.any(String),
-				"wrangler.toml": expect.any(String),
-			});
-		});
-
-		it.skip("clones a user/repo/path/to/subdirectory template", async () => {
-			await expect(
-				runWrangler("generate my-worker cloudflare/templates/worker-typescript")
-			).resolves.toBeUndefined();
-
-			expect(readDirectory("my-worker")).toMatchObject<Directory>({
-				".git": expect.any(Object),
-				".gitignore": expect.any(String),
-				"README.md": expect.stringContaining("Template: worker-typescript"),
-				"jest.config.json": expect.any(String),
-				"package.json": expect.stringContaining("@cloudflare/workers-types"),
-				src: expect.objectContaining({ "index.ts": expect.any(String) }),
-				test: expect.objectContaining({
-					"index.test.ts": expect.any(String),
-				}),
-				"tsconfig.json": expect.any(String),
-				"wrangler.toml": expect.any(String),
-			});
-		});
-
-		it.skip("clones a git@github.com/user/repo template", async () => {
-			await expect(
-				runWrangler(
-					"generate my-worker git@github.com:caass/wrangler-generate-test-template"
-				)
-			).resolves.toBeUndefined();
-
-			expect(readDirectory("my-worker")).toMatchObject<Directory>({
-				".git": expect.any(Object),
-				".gitignore": expect.any(String),
-				"package.json": expect.stringContaining("@cloudflare/workers-types"),
-				src: expect.objectContaining({ "index.ts": expect.any(String) }),
-				"tsconfig.json": expect.any(String),
-				"wrangler.toml": expect.any(String),
-			});
-		});
-
-		it.skip("clones a git@github.com/user/repo/path/to/subdirectory template", async () => {
-			await expect(
-				runWrangler(
-					"generate my-worker git@github.com:cloudflare/templates/worker-typescript"
-				)
-			).resolves.toBeUndefined();
-
-			expect(readDirectory("my-worker")).toMatchObject<Directory>({
-				".git": expect.any(Object),
-				".gitignore": expect.any(String),
-				"README.md": expect.stringContaining("Template: worker-typescript"),
-				"jest.config.json": expect.any(String),
-				"package.json": expect.stringContaining("@cloudflare/workers-types"),
-				src: expect.objectContaining({ "index.ts": expect.any(String) }),
-				test: expect.objectContaining({
-					"index.test.ts": expect.any(String),
-				}),
-				"tsconfig.json": expect.any(String),
-				"wrangler.toml": expect.any(String),
-			});
-		});
-	});
-});
-
-type FileName = string;
-type FileContents = string;
-type Directory = { [key: FileName]: FileContents | Directory };
-
-function readDirectory(directoryPath: string): Directory {
-	if (!fs.existsSync(directoryPath)) {
-		throw new Error(`${directoryPath} does not exist!`);
-	}
-
-	if (!fs.lstatSync(directoryPath).isDirectory()) {
-		throw new Error(`${directoryPath} is not a directory!`);
-	}
-
-	return fs
-		.readdirSync(directoryPath, { withFileTypes: true })
-		.reduce((output, child) => {
-			const childPath = path.join(directoryPath, child.name);
-
-			if (child.isDirectory()) {
-				output[child.name] = readDirectory(childPath);
-			} else if (child.isFile()) {
-				output[child.name] = fs.readFileSync(childPath, { encoding: "utf-8" });
-			} else {
-				throw new Error(`${childPath} was not a file or directory!`);
-			}
-
-			return output;
-		}, {} as Directory);
-}

package/src/__tests__/get-host-from-url.test.ts

@@ -1,16 +0,0 @@
-import { getHostFromUrl } from "../zones";
-
-//return the host given a url-like string
-describe("getHostFromUrl", () => {
-	it("should return the host from a url", () => {
-		expect(getHostFromUrl("https://www.example.com")).toBe("www.example.com");
-	});
-
-	it("should return the host from a url using wildcard *.", () => {
-		expect(getHostFromUrl("*.example.com")).toBe("example.com");
-	});
-
-	it("should return the host from a url using wildcard *", () => {
-		expect(getHostFromUrl("*example.com")).toBe("example.com");
-	});
-});

package/src/__tests__/guess-worker-format.test.ts

@@ -1,120 +0,0 @@
-import { writeFile } from "fs/promises";
-import path from "path";
-import guessWorkerFormat from "../entry";
-import { mockConsoleMethods } from "./helpers/mock-console";
-import { runInTempDir } from "./helpers/run-in-tmp";
-
-describe("guess worker format", () => {
-	runInTempDir();
-	const std = mockConsoleMethods();
-	it('should detect a "modules" worker', async () => {
-		await writeFile("./index.ts", "export default {};");
-		// Note that this isn't actually a valid worker, because it's missing
-		// a fetch handler. Regardless, our heuristic is simply to check for exports.
-		const guess = await guessWorkerFormat(
-			path.join(process.cwd(), "./index.ts"),
-			process.cwd(),
-			undefined
-		);
-		expect(guess).toBe("modules");
-	});
-
-	it('should detect a "service-worker" worker', async () => {
-		await writeFile("./index.ts", "");
-		// Note that this isn't actually a valid worker, because it's missing
-		// a fetch listener. Regardless, our heuristic is simply to check for
-		// the lack of exports.
-		const guess = await guessWorkerFormat(
-			path.join(process.cwd(), "./index.ts"),
-			process.cwd(),
-			undefined
-		);
-		expect(guess).toBe("service-worker");
-	});
-
-	it('should detect a "service-worker" worker using `typeof module`', async () => {
-		await writeFile("./index.ts", "typeof module");
-		const guess = await guessWorkerFormat(
-			path.join(process.cwd(), "./index.ts"),
-			process.cwd(),
-			undefined
-		);
-		expect(guess).toBe("service-worker");
-	});
-
-	it('should detect a "service-worker" worker using imports', async () => {
-		await writeFile(
-			"./dep.ts",
-			`
-			const value = 'thing';
-			export default value;
-			`
-		);
-		await writeFile(
-			"./index.ts",
-			`
-			import value from './dep.ts';
-			addEventListener('fetch', (event) => {
-				event.respondWith(new Response(value));
-			});
-			`
-		);
-		const guess = await guessWorkerFormat(
-			path.join(process.cwd(), "./index.ts"),
-			process.cwd(),
-			undefined
-		);
-		expect(guess).toBe("service-worker");
-	});
-
-	it("should throw an error when the hint doesn't match the guess (modules - service-worker)", async () => {
-		await writeFile("./index.ts", "export default {};");
-		await expect(
-			guessWorkerFormat(
-				path.join(process.cwd(), "./index.ts"),
-				process.cwd(),
-				"service-worker"
-			)
-		).rejects.toThrow(
-			"You configured this worker to be a 'service-worker', but the file you are trying to build appears to have a `default` export like a module worker. Please pass `--format modules`, or simply remove the configuration."
-		);
-	});
-
-	it("should throw an error when the hint doesn't match the guess (service-worker - modules)", async () => {
-		await writeFile("./index.ts", "");
-		await expect(
-			guessWorkerFormat(
-				path.join(process.cwd(), "./index.ts"),
-				process.cwd(),
-				"modules"
-			)
-		).rejects.toThrow(
-			"You configured this worker to be 'modules', but the file you are trying to build doesn't export a handler. Please pass `--format service-worker`, or simply remove the configuration."
-		);
-	});
-
-	it("should not error if a .js entry point has jsx", async () => {
-		await writeFile("./index.js", "console.log(<div/>)");
-		const guess = await guessWorkerFormat(
-			path.join(process.cwd(), "./index.js"),
-			process.cwd(),
-			undefined
-		);
-		expect(guess).toBe("service-worker");
-	});
-
-	it("logs a warning when a worker has exports, but not a default one", async () => {
-		await writeFile("./index.ts", "export const foo = 1;");
-		const guess = await guessWorkerFormat(
-			path.join(process.cwd(), "./index.ts"),
-			process.cwd(),
-			undefined
-		);
-		expect(guess).toBe("service-worker");
-		expect(std.warn).toMatchInlineSnapshot(`
-      "▲ [WARNING] The entrypoint index.ts has exports like an ES Module, but hasn't defined a default export like a module worker normally would. Building the worker using \\"service-worker\\" format...
-
-      "
-    `);
-	});
-});

package/src/__tests__/helpers/clipboardy-mock.js

@@ -1,4 +0,0 @@
-// We use this mock during tests because we're having trouble
-// properly compiling clipboardy for jest
-// We can revisit this if and when we write tests that test
-// the copying part of `dev`

package/src/__tests__/helpers/cmd-shim.d.ts

@@ -1,11 +0,0 @@
-/**
- * The typings file available at `@types/cmd-shim` are out of date.
- */
-module "cmd-shim" {
-	/**
-	 *
-	 * Create a cmd shim at `to` for the command line program at `from`.
-	 *
-	 */
-	export default function cmdShim(from: string, to: string): Promise<void>;
-}

package/src/__tests__/helpers/end-event-loop.ts

@@ -1,6 +0,0 @@
-/**
- * Forces a tick and ensures that all pending promises resolve
- */
-export function endEventLoop() {
-	return new Promise((resolve) => setImmediate(resolve));
-}

package/src/__tests__/helpers/mock-account-id.ts

@@ -1,48 +0,0 @@
-import { reinitialiseAuthTokens } from "../../user";
-
-const ORIGINAL_CLOUDFLARE_API_TOKEN = process.env.CLOUDFLARE_API_TOKEN;
-const ORIGINAL_CLOUDFLARE_ACCOUNT_ID = process.env.CLOUDFLARE_ACCOUNT_ID;
-
-/**
- * Mock the API token so that we don't need to read it from user configuration files.
- *
- * Note that you can remove any API token from the environment by setting the value to `null`.
- * This is useful if a higher `describe()` block has already called `mockApiToken()`.
- */
-export function mockApiToken({
-	apiToken = "some-api-token",
-}: { apiToken?: string | null } = {}) {
-	beforeEach(() => {
-		if (apiToken === null) {
-			delete process.env.CLOUDFLARE_API_TOKEN;
-		} else {
-			process.env.CLOUDFLARE_API_TOKEN = apiToken;
-		}
-		// Now we have updated the environment, we must reinitialize the user auth state.
-		reinitialiseAuthTokens();
-	});
-	afterEach(() => {
-		process.env.CLOUDFLARE_API_TOKEN = ORIGINAL_CLOUDFLARE_API_TOKEN;
-	});
-}
-
-/**
- * Mock the current account ID so that we don't need to read it from configuration files.
- *
- * Note that you can remove any account ID from the environment by setting the value to `null`.
- * This is useful if a higher `describe()` block has already called `mockAccountId()`.
- */
-export function mockAccountId({
-	accountId = "some-account-id",
-}: { accountId?: string | null } = {}) {
-	beforeEach(() => {
-		if (accountId === null) {
-			delete process.env.CLOUDFLARE_ACCOUNT_ID;
-		} else {
-			process.env.CLOUDFLARE_ACCOUNT_ID = accountId;
-		}
-	});
-	afterEach(() => {
-		process.env.CLOUDFLARE_ACCOUNT_ID = ORIGINAL_CLOUDFLARE_ACCOUNT_ID;
-	});
-}

package/src/__tests__/helpers/mock-auth-domain.ts

@@ -1,20 +0,0 @@
-const ORIGINAL_WRANGLER_AUTH_DOMAIN = process.env.WRANGLER_AUTH_DOMAIN;
-
-/**
- * Mock the Auth URL domain so that we can control where we attempt to login.
- *
- * Note that you can remove any API token from the environment by setting the value to `null`.
- * This is useful if a higher `describe()` block has already called `mockAuthDomain()`.
- */
-export function mockAuthDomain({ domain }: { domain: string | null }) {
-	beforeEach(() => {
-		if (domain === null) {
-			delete process.env.WRANGLER_AUTH_DOMAIN;
-		} else {
-			process.env.WRANGLER_AUTH_DOMAIN = domain;
-		}
-	});
-	afterEach(() => {
-		process.env.WRANGLER_AUTH_DOMAIN = ORIGINAL_WRANGLER_AUTH_DOMAIN;
-	});
-}

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

@@ -1,36 +0,0 @@
-import { chmodSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
-import { basename, resolve } from "node:path";
-import cmdShim from "cmd-shim";
-
-const nodeShebang = "#!/usr/bin/env node";
-
-/**
- * Create a binary file in a temp directory and make it available on the PATH.
- */
-export async function mockBinary(
-	binaryName: string,
-	code: string
-): Promise<() => void> {
-	// Ensure there is a directory to put the mock binary in.
-	const tmpDir = resolve(mkdtempSync(".mock-binary-"));
-
-	// Use a fake extension on Windows because we will create a cmd-shim to run the binary.
-	const extension = process.platform === "win32" ? ".x-mock-bin" : "";
-	const filePath = resolve(tmpDir, `${binaryName}${extension}`);
-	writeFileSync(filePath, nodeShebang + "\n" + code);
-	chmodSync(filePath, 0o777);
-
-	if (process.platform === "win32") {
-		await cmdShim(filePath, basename(filePath, ".x-mock-bin"));
-	}
-
-	// Update PATH using the appropriate separator for the platform.
-	const oldPath = process.env.PATH;
-	const sep = process.platform === "win32" ? ";" : ":";
-	process.env.PATH = tmpDir + sep + oldPath;
-
-	return function unMock() {
-		rmSync(tmpDir, { recursive: true });
-		process.env.PATH = process.env.PATH?.replace(tmpDir + sep, "");
-	};
-}

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

@@ -1,112 +0,0 @@
-import * as util from "node:util";
-import { logger } from "../../logger";
-
-/**
- * We use this module to mock console methods, and optionally
- * assert on the values they're called with in our tests.
- */
-
-let debugSpy: jest.SpyInstance,
-	logSpy: jest.SpyInstance,
-	infoSpy: jest.SpyInstance,
-	errorSpy: jest.SpyInstance,
-	warnSpy: jest.SpyInstance;
-
-const std = {
-	get debug() {
-		return normalizeOutput(debugSpy);
-	},
-	get out() {
-		return normalizeOutput(logSpy);
-	},
-	get info() {
-		return normalizeOutput(infoSpy);
-	},
-	get err() {
-		return normalizeOutput(errorSpy);
-	},
-	get warn() {
-		return normalizeOutput(warnSpy);
-	},
-};
-
-function normalizeOutput(spy: jest.SpyInstance): string {
-	return normalizeErrorMarkers(
-		replaceByte(
-			stripTrailingWhitespace(
-				normalizeSlashes(normalizeTempDirs(stripTimings(captureCalls(spy))))
-			)
-		)
-	);
-}
-
-function captureCalls(spy: jest.SpyInstance): string {
-	return spy.mock.calls
-		.map((args: unknown[]) => util.format("%s", ...args))
-		.join("\n");
-}
-
-export function mockConsoleMethods() {
-	beforeEach(() => {
-		logger.columns = 100;
-		debugSpy = jest.spyOn(console, "debug").mockImplementation();
-		logSpy = jest.spyOn(console, "log").mockImplementation();
-		infoSpy = jest.spyOn(console, "info").mockImplementation();
-		errorSpy = jest.spyOn(console, "error").mockImplementation();
-		warnSpy = jest.spyOn(console, "warn").mockImplementation();
-	});
-	afterEach(() => {
-		debugSpy.mockRestore();
-		logSpy.mockRestore();
-		infoSpy.mockRestore();
-		errorSpy.mockRestore();
-		warnSpy.mockRestore();
-	});
-	return std;
-}
-
-/**
- * Normalize error `X` markers.
- *
- * Windows gets a different character.
- */
-function normalizeErrorMarkers(str: string): string {
-	return str.replaceAll("✘", "X");
-}
-
-/**
- * Ensure slashes in the `str` are OS file-system agnostic.
- *
- * Use this in snapshot tests to be resilient to file-system differences.
- */
-export function normalizeSlashes(str: string): string {
-	return str.replace(/\\/g, "/");
-}
-
-/**
- * Strip "timing data" out of the `stdout` string, since this is not always deterministic.
- *
- * Use this in snapshot tests to be resilient to slight changes in timing of processing.
- */
-export function stripTimings(stdout: string): string {
-	return stdout.replace(/\(\d+\.\d+ sec\)/g, "(TIMINGS)");
-}
-
-export function stripTrailingWhitespace(str: string): string {
-	return str.replace(/[^\S\n]+\n/g, "\n");
-}
-
-/**
- * Removing leading kilobit (tenth of a byte) from test output due to
- * variation causing every few tests the value to change by ± .01
- */
-function replaceByte(stdout: string): string {
-	return stdout.replaceAll(/\d+\.\d+ KiB/g, "xx KiB");
-}
-
-/**
- * Temp directories are created with random names, so we replace all comments temp dirs in them
- */
-export function normalizeTempDirs(stdout: string): string {
-	return stdout.replaceAll(/\/\/.+\/tmp.+/g, "//tmpdir");
-}