wrangler 0.0.0-e492c10 → 0.0.0-e4ca780f

package/src/__tests__/api-devregistry.test.ts

@@ -0,0 +1,121 @@
+import { fetch } from "undici";
+import { unstable_dev } from "../api";
+
+jest.unmock("undici");
+
+/**
+ * a huge caveat to how testing multi-worker scripts works:
+ * you can't shutdown the first worker you spun up, or it'll kill the devRegistry
+ */
+describe("multi-worker testing", () => {
+	// eslint-disable-next-line @typescript-eslint/no-explicit-any
+	let childWorker: any;
+	// eslint-disable-next-line @typescript-eslint/no-explicit-any
+	let parentWorker: any;
+
+	beforeAll(async () => {
+		childWorker = await unstable_dev(
+			"src/__tests__/helpers/worker-scripts/hello-world-worker.js",
+			{
+				config: "src/__tests__/helpers/worker-scripts/child-wrangler.toml",
+				experimental: {
+					disableExperimentalWarning: true,
+				},
+			}
+		);
+		parentWorker = await unstable_dev(
+			"src/__tests__/helpers/worker-scripts/parent-worker.js",
+			{
+				config: "src/__tests__/helpers/worker-scripts/parent-wrangler.toml",
+				experimental: {
+					disableExperimentalWarning: true,
+				},
+			}
+		);
+	});
+
+	afterAll(async () => {
+		await childWorker.stop();
+		await parentWorker.stop();
+	});
+
+	it("parentWorker and childWorker should be added devRegistry", async () => {
+		const resp = await fetch("http://localhost:6284/workers");
+		if (resp) {
+			const parsedResp = (await resp.json()) as {
+				parent: unknown;
+				child: unknown;
+			};
+			expect(parsedResp.parent).toBeTruthy();
+			expect(parsedResp.child).toBeTruthy();
+		}
+	});
+
+	it("childWorker should return Hello World itself", async () => {
+		const resp = await childWorker.fetch();
+		if (resp) {
+			const text = await resp.text();
+			expect(text).toMatchInlineSnapshot(`"Hello World!"`);
+		}
+	});
+
+	it("parentWorker should return Hello World by invoking the child worker", async () => {
+		const resp = await parentWorker.fetch();
+		if (resp) {
+			const parsedResp = await resp.text();
+			expect(parsedResp).toEqual("Parent worker sees: Hello World!");
+		}
+	});
+
+	it("should be able to stop and start the server with no warning logs", async () => {
+		// Spy on all the console methods
+		let logs = "";
+		(["debug", "info", "log", "warn", "error"] as const).forEach((method) =>
+			jest
+				.spyOn(console, method)
+				.mockImplementation((...args: unknown[]) => (logs += `\n${args}`))
+		);
+
+		// Spy on the std out that is written to by Miniflare 2
+		jest
+			.spyOn(process.stdout, "write")
+			.mockImplementation((chunk: unknown) => ((logs += `\n${chunk}`), true));
+
+		async function startWorker() {
+			return await unstable_dev(
+				"src/__tests__/helpers/worker-scripts/hello-world-worker.js",
+				{
+					// We need the wrangler.toml config to specify a Worker name
+					// otherwise unstable_dev will not register the worker with the DevRegistry
+					config: "src/__tests__/helpers/worker-scripts/child-wrangler.toml",
+					// We need debug logs because this is where the message is written if registering the worker fails.
+					logLevel: "debug",
+					experimental: {
+						disableExperimentalWarning: true,
+					},
+				}
+			);
+		}
+
+		// eslint-disable-next-line @typescript-eslint/no-explicit-any
+		let worker: any;
+		try {
+			worker = await startWorker();
+
+			// Stop the worker and start it again
+			await worker.stop();
+			await new Promise((r) => setTimeout(r, 2000));
+
+			worker = await startWorker();
+
+			const resp = await worker.fetch();
+			expect(resp).not.toBe(undefined);
+
+			expect(logs).not.toMatch(
+				/Failed to register worker in local service registry/
+			);
+		} finally {
+			await worker?.stop();
+		}
+	}, 10000);
+});

package/src/__tests__/api.test.ts

@@ -0,0 +1,102 @@
+import { Request } from "undici";
+import { parseRequestInput } from "../api/dev";
+
+describe("parseRequestInput for fetch on unstable dev", () => {
+	it("should allow no input to be passed in", () => {
+		const [input, _] = parseRequestInput("0.0.0.0", 8080);
+
+		expect(input).toMatchInlineSnapshot(`"http://0.0.0.0:8080/"`);
+	});
+
+	it("should allow string of pathname to be passed in", () => {
+		const [input, _] = parseRequestInput("0.0.0.0", 8080, "/test");
+
+		expect(input).toMatchInlineSnapshot(`"http://0.0.0.0:8080/test"`);
+	});
+
+	it("should allow string of pathname and querystring to be passed in", () => {
+		const [input, _] = parseRequestInput("0.0.0.0", 8080, "/test?q=testparam");
+
+		expect(input).toMatchInlineSnapshot(
+			`"http://0.0.0.0:8080/test?q=testparam"`
+		);
+	});
+
+	it("should allow full url to be passed in as string and stripped", () => {
+		const [input, _] = parseRequestInput(
+			"0.0.0.0",
+			8080,
+			"http://cloudflare.com/test?q=testparam"
+		);
+
+		expect(input).toMatchInlineSnapshot(
+			`"http://0.0.0.0:8080/test?q=testparam"`
+		);
+	});
+
+	it("should allow URL object without pathname to be passed in and stripped", () => {
+		const [input, _] = parseRequestInput(
+			"0.0.0.0",
+			8080,
+			new URL("http://cloudflare.com")
+		);
+
+		expect(input).toMatchInlineSnapshot(`"http://0.0.0.0:8080/"`);
+	});
+
+	it("should allow URL object with pathname to be passed in and stripped", () => {
+		const [input, _] = parseRequestInput(
+			"0.0.0.0",
+			8080,
+			new URL("http://cloudflare.com/test")
+		);
+
+		expect(input).toMatchInlineSnapshot(`"http://0.0.0.0:8080/test"`);
+	});
+
+	it("should allow URL object with pathname and querystring to be passed in and stripped", () => {
+		const [input, _] = parseRequestInput(
+			"0.0.0.0",
+			8080,
+			new URL("http://cloudflare.com/test?q=testparam")
+		);
+
+		expect(input).toMatchInlineSnapshot(
+			`"http://0.0.0.0:8080/test?q=testparam"`
+		);
+	});
+
+	it("should allow request object to be passed in", () => {
+		const [input, init] = parseRequestInput(
+			"0.0.0.0",
+			8080,
+			new Request("http://cloudflare.com/test?q=testparam", { method: "POST" })
+		);
+
+		expect(init).toBeUndefined();
+		expect(input).toBeInstanceOf(Request);
+		// We don't expect the request to be modified
+		expect((input as Request).url).toMatchInlineSnapshot(
+			`"http://cloudflare.com/test?q=testparam"`
+		);
+		expect((input as Request).method).toMatchInlineSnapshot(`"POST"`);
+	});
+
+	it("should parse to give https url with localProtocol = https", () => {
+		const [input, _] = parseRequestInput("0.0.0.0", 8080, "/test", {}, "https");
+
+		expect(input).toMatchInlineSnapshot(`"https://0.0.0.0:8080/test"`);
+	});
+
+	it("should parse to give http url with localProtocol = http", () => {
+		const [input, _] = parseRequestInput("0.0.0.0", 8080, "/test", {}, "http");
+
+		expect(input).toMatchInlineSnapshot(`"http://0.0.0.0:8080/test"`);
+	});
+
+	it("should parse to give http url with localProtocol not set", () => {
+		const [input, _] = parseRequestInput("0.0.0.0", 8080, "/test", {});
+
+		expect(input).toMatchInlineSnapshot(`"http://0.0.0.0:8080/test"`);
+	});
+});

package/src/__tests__/config-cache-without-cache-dir.test.ts

@@ -0,0 +1,38 @@
+import { getConfigCache, saveToConfigCache } from "../config-cache";
+import { mockConsoleMethods } from "./helpers/mock-console";
+import { runInTempDir } from "./helpers/run-in-tmp";
+
+interface PagesConfigCache {
+	account_id: string;
+	pages_project_name: string;
+}
+
+describe("config cache", () => {
+	runInTempDir();
+	mockConsoleMethods();
+	// In this set of tests, we don't create a node_modules folder
+	const pagesConfigCacheFilename = "pages-config-cache.json";
+
+	it("should return an empty config if no file exists", () => {
+		expect(
+			getConfigCache<PagesConfigCache>(pagesConfigCacheFilename)
+		).toMatchInlineSnapshot(`Object {}`);
+	});
+
+	it("should ignore attempts to cache values ", () => {
+		saveToConfigCache<PagesConfigCache>(pagesConfigCacheFilename, {
+			account_id: "some-account-id",
+			pages_project_name: "foo",
+		});
+		expect(getConfigCache<PagesConfigCache>(pagesConfigCacheFilename)).toEqual(
+			{}
+		);
+
+		saveToConfigCache<PagesConfigCache>(pagesConfigCacheFilename, {
+			pages_project_name: "bar",
+		});
+		expect(getConfigCache<PagesConfigCache>(pagesConfigCacheFilename)).toEqual(
+			{}
+		);
+	});
+});

package/src/__tests__/config-cache.test.ts

@@ -1,36 +1,42 @@
+import { mkdirSync } from "node:fs";
 import { getConfigCache, saveToConfigCache } from "../config-cache";
+import { mockConsoleMethods } from "./helpers/mock-console";
 import { runInTempDir } from "./helpers/run-in-tmp";
 
 interface PagesConfigCache {
-  account_id: string;
-  pages_project_name: string;
+	account_id: string;
+	pages_project_name: string;
 }
 
 describe("config cache", () => {
-  runInTempDir();
+	runInTempDir();
+	mockConsoleMethods();
+	beforeEach(() => {
+		mkdirSync("node_modules");
+	});
 
-  const pagesConfigCacheFilename = "pages-config-cache.json";
+	const pagesConfigCacheFilename = "pages-config-cache.json";
 
-  it("should return an empty config if no file exists", () => {
-    expect(
-      getConfigCache<PagesConfigCache>(pagesConfigCacheFilename)
-    ).toMatchInlineSnapshot(`Object {}`);
-  });
+	it("should return an empty config if no file exists", () => {
+		expect(
+			getConfigCache<PagesConfigCache>(pagesConfigCacheFilename)
+		).toMatchInlineSnapshot(`Object {}`);
+	});
 
-  it("should read and write values without overriding old ones", () => {
-    saveToConfigCache<PagesConfigCache>(pagesConfigCacheFilename, {
-      account_id: "some-account-id",
-      pages_project_name: "foo",
-    });
-    expect(
-      getConfigCache<PagesConfigCache>(pagesConfigCacheFilename).account_id
-    ).toEqual("some-account-id");
+	it("should read and write values without overriding old ones", () => {
+		saveToConfigCache<PagesConfigCache>(pagesConfigCacheFilename, {
+			account_id: "some-account-id",
+			pages_project_name: "foo",
+		});
+		expect(
+			getConfigCache<PagesConfigCache>(pagesConfigCacheFilename).account_id
+		).toEqual("some-account-id");
 
-    saveToConfigCache<PagesConfigCache>(pagesConfigCacheFilename, {
-      pages_project_name: "bar",
-    });
-    expect(
-      getConfigCache<PagesConfigCache>(pagesConfigCacheFilename).account_id
-    ).toEqual("some-account-id");
-  });
+		saveToConfigCache<PagesConfigCache>(pagesConfigCacheFilename, {
+			pages_project_name: "bar",
+		});
+		expect(
+			getConfigCache<PagesConfigCache>(pagesConfigCacheFilename).account_id
+		).toEqual("some-account-id");
+	});
 });