wrangler 0.0.0-e41c7e41 → 0.0.0-e44afaf79

package/src/__tests__/dialogs.test.tsx

@@ -1,40 +0,0 @@
-jest.unmock("../dialogs");
-import { fromDashMessagePrompt } from "../dialogs";
-import { CI } from "../is-ci";
-
-describe("fromDashMessagePrompt", () => {
-	it("should return undefined in CI when last deployed from api", async () => {
-		//in CI
-		jest.spyOn(CI, "isCI").mockReturnValue(true);
-		const result = await fromDashMessagePrompt("api");
-		expect(result).toBe(undefined);
-	});
-
-	it("should return undefined in CI when last deployed from wrangler", async () => {
-		//in CI
-		jest.spyOn(CI, "isCI").mockReturnValue(true);
-		const result = await fromDashMessagePrompt("wrangler");
-		expect(result).toBe(undefined);
-	});
-
-	it("should return true in CI when last deployed from dash", async () => {
-		//in CI
-		jest.spyOn(CI, "isCI").mockReturnValue(true);
-		const result = await fromDashMessagePrompt("dash");
-		expect(result).toBe(true);
-	});
-
-	it("should return undefined when last deployed from api", async () => {
-		//not in CI
-		jest.spyOn(CI, "isCI").mockReturnValue(false);
-		const result = await fromDashMessagePrompt("api");
-		expect(result).toBe(undefined);
-	});
-
-	it("should return undefined when last deployed from wrangler", async () => {
-		//not in CI
-		jest.spyOn(CI, "isCI").mockReturnValue(false);
-		const result = await fromDashMessagePrompt("wrangler");
-		expect(result).toBe(undefined);
-	});
-});

package/src/__tests__/generate.test.ts

@@ -1,235 +0,0 @@
-import fs from "node:fs";
-import path from "node:path";
-import { mockConsoleMethods } from "./helpers/mock-console";
-import { mockConfirm, clearConfirmMocks } from "./helpers/mock-dialogs";
-import { runInTempDir } from "./helpers/run-in-tmp";
-import { runWrangler } from "./helpers/run-wrangler";
-
-describe("generate", () => {
-	runInTempDir();
-	const std = mockConsoleMethods();
-
-	describe("cli functionality", () => {
-		afterEach(() => {
-			clearConfirmMocks();
-		});
-
-		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.skip("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"),
-				"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),
-			});
-		});
-
-		// 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("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,85 +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 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/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-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, "");
-	};
-}