wrangler 2.1.4 → 2.1.5

package/miniflare-dist/index.mjs

@@ -6099,7 +6099,10 @@ async function generateAssetsFetch(directory, log) {
           );
         }
         const body = readFileSync5(filepath);
-        const contentType = (0, import_mime.getType)(filepath) || "application/octet-stream";
+        let contentType = (0, import_mime.getType)(filepath) || "application/octet-stream";
+        if (contentType.startsWith("text/") && !contentType.includes("charset")) {
+          contentType = `${contentType}; charset=utf-8`;
+        }
         return { body, contentType };
       }
     });

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "wrangler",
-	"version": "2.1.4",
+	"version": "2.1.5",
 	"description": "Command-line interface for all things Cloudflare Workers",
 	"keywords": [
 		"wrangler",

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

@@ -8,7 +8,7 @@ jest.unmock("undici");
 describe("unstable_dev", () => {
 	it("should return Hello World", async () => {
 		const worker = await unstable_dev(
-			"src/__tests__/helpers/hello-world-worker.js",
+			"src/__tests__/helpers/worker-scripts/hello-world-worker.js",
 			{},
 			{ disableExperimentalWarning: true }
 		);
@@ -24,7 +24,7 @@ describe("unstable_dev", () => {
 describe("unstable dev fetch input protocol", () => {
 	it("should use http localProtocol", async () => {
 		const worker = await unstable_dev(
-			"src/__tests__/helpers/hello-world-worker.js",
+			"src/__tests__/helpers/worker-scripts/hello-world-worker.js",
 			{ localProtocol: "http" },
 			{ disableExperimentalWarning: true }
 		);
@@ -38,7 +38,7 @@ describe("unstable dev fetch input protocol", () => {
 
 	it("should use undefined localProtocol", async () => {
 		const worker = await unstable_dev(
-			"src/__tests__/helpers/hello-world-worker.js",
+			"src/__tests__/helpers/worker-scripts/hello-world-worker.js",
 			{ localProtocol: undefined },
 			{ disableExperimentalWarning: true }
 		);

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

@@ -0,0 +1,56 @@
+import { unstable_dev } from "../api";
+import { fetch } from "undici";
+
+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", () => {
+	let childWorker;
+	let parentWorker;
+
+	beforeAll(async () => {
+		childWorker = await unstable_dev(
+			"src/__tests__/helpers/worker-scripts/hello-world-worker.js",
+			{ config: "src/__tests__/helpers/worker-scripts/child-wrangler.toml" },
+			{ disableExperimentalWarning: true }
+		);
+		parentWorker = await unstable_dev(
+			"src/__tests__/helpers/worker-scripts/parent-worker.js",
+			{ config: "src/__tests__/helpers/worker-scripts/parent-wrangler.toml" },
+			{ 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();
+			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!");
+		}
+	});
+});

package/src/__tests__/dev.test.tsx

@@ -1027,7 +1027,9 @@ describe("wrangler dev", () => {
 			      --node-compat                                Enable node.js compatibility  [boolean]
 			      --persist                                    Enable persistence for local mode, using default path: .wrangler/state  [boolean]
 			      --persist-to                                 Specify directory to use for local persistence (implies --persist)  [string]
-			      --inspect                                    Enable dev tools  [deprecated] [boolean]",
+			      --inspect                                    Enable dev tools  [deprecated] [boolean]
+			      --test-scheduled                             Test scheduled events by visiting /__scheduled in browser  [boolean] [default: false]
+			      --log-level                                  Specify logging level  [choices: \\"debug\\", \\"info\\", \\"log\\", \\"warn\\", \\"error\\", \\"none\\"] [default: \\"log\\"]",
 			  "warn": "",
 			}
 		`);
@@ -1211,6 +1213,42 @@ describe("wrangler dev", () => {
 		});
 	});
 
+	describe("--log-level", () => {
+		it("should not output warnings with log-level 'none'", async () => {
+			fs.writeFileSync("index.js", `export default {};`);
+			await runWrangler("dev index.js --inspect --log-level none");
+			expect(std).toMatchInlineSnapshot(`
+			Object {
+			  "debug": "",
+			  "err": "",
+			  "out": "",
+			  "warn": "",
+			}
+		`);
+		});
+
+		it("should output warnings with log-level 'warn'", async () => {
+			fs.writeFileSync("index.js", `export default {};`);
+			await runWrangler("dev index.js --inspect --log-level warn");
+			expect(std).toMatchInlineSnapshot(`
+			Object {
+			  "debug": "",
+			  "err": "",
+			  "out": "",
+			  "warn": "▲ [WARNING] Passing --inspect is unnecessary, now you can always connect to devtools.
+
+			",
+			}
+		`);
+		});
+
+		it("should not output Errors with log-level error", async () => {
+			fs.writeFileSync("index.js", `export default {};`);
+			await runWrangler("dev index.js --inspect --log-level debug");
+			expect(std.debug.length > 1).toBe(true);
+		});
+	});
+
 	describe("service bindings", () => {
 		it("should warn when using service bindings", async () => {
 			writeWranglerToml({

package/src/__tests__/helpers/worker-scripts/child-wrangler.toml

@@ -0,0 +1 @@
+name = 'child'

package/src/__tests__/helpers/worker-scripts/hello-world-wrangler.toml

@@ -0,0 +1 @@
+name = 'hello-world'

package/src/__tests__/helpers/worker-scripts/parent-worker.js

@@ -0,0 +1,8 @@
+export default {
+	async fetch(req, env) {
+		const resp = await env.CHILD.fetch(req);
+		const text = await resp.text();
+		console.log("text: ", text);
+		return new Response(`Parent worker sees: ${text}`);
+	},
+};

package/src/__tests__/helpers/worker-scripts/parent-wrangler.toml

@@ -0,0 +1,5 @@
+name = 'parent'
+
+[[services]]
+binding = "CHILD"
+service = 'child'

package/src/__tests__/middleware.scheduled.test.ts

@@ -0,0 +1,135 @@
+import * as fs from "node:fs";
+import { unstable_dev } from "../api";
+import { runInTempDir } from "./helpers/run-in-tmp";
+
+jest.unmock("undici");
+
+describe("run scheduled events with middleware", () => {
+	describe("module workers", () => {
+		runInTempDir();
+
+		beforeEach(() => {
+			const scriptContent = `
+			export default {
+				fetch(request, env, ctx) {
+					const url = new URL(request.url);
+					if (url.pathname === "/__scheduled") {
+						return new Response("Fetch triggered at /__scheduled");
+					}
+					return new Response("Hello world!");
+				},
+				scheduled(controller, env, ctx) {
+					console.log("Doing something scheduled in modules...");
+				},
+			};
+			`;
+			fs.writeFileSync("index.js", scriptContent);
+		});
+
+		it("should not intercept when middleware is not enabled", async () => {
+			const worker = await unstable_dev(
+				"index.js",
+				{},
+				{ disableExperimentalWarning: true }
+			);
+
+			const resp = await worker.fetch("/__scheduled");
+			let text;
+			if (resp) text = await resp.text();
+			expect(text).toMatchInlineSnapshot(`"Fetch triggered at /__scheduled"`);
+			await worker.stop();
+		});
+
+		it("should intercept when middleware is enabled", async () => {
+			const worker = await unstable_dev(
+				"index.js",
+				{ testScheduled: true },
+				{ disableExperimentalWarning: true }
+			);
+
+			const resp = await worker.fetch("/__scheduled");
+			let text;
+			if (resp) text = await resp.text();
+			expect(text).toMatchInlineSnapshot(`"Ran scheduled event"`);
+			await worker.stop();
+		});
+
+		it("should not trigger scheduled event on wrong route", async () => {
+			const worker = await unstable_dev(
+				"index.js",
+				{ testScheduled: true },
+				{ disableExperimentalWarning: true }
+			);
+
+			const resp = await worker.fetch("/test");
+			let text;
+			if (resp) text = await resp.text();
+			expect(text).toMatchInlineSnapshot(`"Hello world!"`);
+			await worker.stop();
+		});
+	});
+
+	describe("service workers", () => {
+		runInTempDir();
+
+		beforeEach(() => {
+			const scriptContent = `
+			addEventListener("scheduled", (event) => {
+				console.log("Doing something scheduled in service worker...");
+			});
+
+			addEventListener("fetch", (event) => {
+				const url = new URL(event.request.url);
+				if (url.pathname === "/__scheduled") {
+					event.respondWith(new Response("Fetch triggered at /__scheduled"));
+				} else {
+					event.respondWith(new Response("Hello world!"));
+				}
+			});
+			`;
+			fs.writeFileSync("index.js", scriptContent);
+		});
+
+		it("should not intercept when middleware is not enabled", async () => {
+			const worker = await unstable_dev(
+				"index.js",
+				{},
+				{ disableExperimentalWarning: true }
+			);
+
+			const resp = await worker.fetch("/__scheduled");
+			let text;
+			if (resp) text = await resp.text();
+			expect(text).toMatchInlineSnapshot(`"Fetch triggered at /__scheduled"`);
+			await worker.stop();
+		});
+
+		it("should intercept when middleware is enabled", async () => {
+			const worker = await unstable_dev(
+				"index.js",
+				{ testScheduled: true },
+				{ disableExperimentalWarning: true }
+			);
+
+			const resp = await worker.fetch("/__scheduled");
+			let text;
+			if (resp) text = await resp.text();
+			expect(text).toMatchInlineSnapshot(`"Ran scheduled event"`);
+			await worker.stop();
+		});
+
+		it("should not trigger scheduled event on wrong route", async () => {
+			const worker = await unstable_dev(
+				"index.js",
+				{ testScheduled: true },
+				{ disableExperimentalWarning: true }
+			);
+
+			const resp = await worker.fetch("/test");
+			let text;
+			if (resp) text = await resp.text();
+			expect(text).toMatchInlineSnapshot(`"Hello world!"`);
+			await worker.stop();
+		});
+	});
+});