wrangler 2.1.3 → 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.3",
+	"version": "2.1.5",
 	"description": "Command-line interface for all things Cloudflare Workers",
 	"keywords": [
 		"wrangler",

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

@@ -1,11 +1,14 @@
+import * as fs from "node:fs";
+import { Request } from "undici";
 import { unstable_dev } from "../api";
+import { runInTempDir } from "./helpers/run-in-tmp";
 
 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 }
 		);
@@ -17,3 +20,170 @@ describe("unstable_dev", () => {
 		await worker.stop();
 	});
 });
+
+describe("unstable dev fetch input protocol", () => {
+	it("should use http localProtocol", async () => {
+		const worker = await unstable_dev(
+			"src/__tests__/helpers/worker-scripts/hello-world-worker.js",
+			{ localProtocol: "http" },
+			{ disableExperimentalWarning: true }
+		);
+		const res = await worker.fetch();
+		if (res) {
+			const text = await res.text();
+			expect(text).toMatchInlineSnapshot(`"Hello World!"`);
+		}
+		await worker.stop();
+	});
+
+	it("should use undefined localProtocol", async () => {
+		const worker = await unstable_dev(
+			"src/__tests__/helpers/worker-scripts/hello-world-worker.js",
+			{ localProtocol: undefined },
+			{ disableExperimentalWarning: true }
+		);
+		const res = await worker.fetch();
+		if (res) {
+			const text = await res.text();
+			expect(text).toMatchInlineSnapshot(`"Hello World!"`);
+		}
+		await worker.stop();
+	});
+});
+
+describe("unstable dev fetch input parsing", () => {
+	runInTempDir();
+
+	it("should pass in a request object unchanged", async () => {
+		const scriptContent = `
+	export default {
+		fetch(request, env, ctx) {
+			const url = new URL(request.url);
+			if (url.pathname === "/test") {
+				if (request.method === "POST") {
+					return new Response("requestPOST");
+				}
+				return new Response("requestGET");
+			}
+			return new Response('Hello world');
+		}
+	};
+	`;
+		fs.writeFileSync("index.js", scriptContent);
+		const port = 21213;
+		const worker = await unstable_dev(
+			"index.js",
+			{ port },
+			{ disableExperimentalWarning: true }
+		);
+		const req = new Request("http://0.0.0.0:21213/test", {
+			method: "POST",
+		});
+		const resp = await worker.fetch(req);
+		let text;
+		if (resp) text = await resp.text();
+		expect(text).toMatchInlineSnapshot(`"requestPOST"`);
+		await worker.stop();
+	});
+
+	it("should strip back to pathname for URL objects", async () => {
+		const scriptContent = `
+	export default {
+		fetch(request, env, ctx) {
+			const url = new URL(request.url);
+			if (url.pathname === "/test") {
+				return new Response("request");
+			}
+			return new Response('Hello world');
+		}
+	};
+	`;
+		fs.writeFileSync("index.js", scriptContent);
+		const worker = await unstable_dev(
+			"index.js",
+			{},
+			{ disableExperimentalWarning: true }
+		);
+		const url = new URL("http://localhost:80/test");
+		const resp = await worker.fetch(url);
+		let text;
+		if (resp) text = await resp.text();
+		expect(text).toMatchInlineSnapshot(`"request"`);
+		await worker.stop();
+	});
+
+	it("should allow full url passed in string, and stripped back to pathname", async () => {
+		const scriptContent = `
+	export default {
+		fetch(request, env, ctx) {
+			const url = new URL(request.url);
+			if (url.pathname === "/test") {
+				return new Response("request");
+			}
+			return new Response('Hello world');
+		}
+	};
+	`;
+		fs.writeFileSync("index.js", scriptContent);
+		const worker = await unstable_dev(
+			"index.js",
+			{},
+			{ disableExperimentalWarning: true }
+		);
+		const resp = await worker.fetch("http://example.com/test");
+		let text;
+		if (resp) text = await resp.text();
+		expect(text).toMatchInlineSnapshot(`"request"`);
+		await worker.stop();
+	});
+
+	it("should allow pathname to be passed in", async () => {
+		const scriptContent = `
+	export default {
+		fetch(request, env, ctx) {
+			const url = new URL(request.url);
+			if (url.pathname === "/test") {
+				return new Response("request");
+			}
+			return new Response('Hello world');
+		}
+	};
+	`;
+		fs.writeFileSync("index.js", scriptContent);
+		const worker = await unstable_dev(
+			"index.js",
+			{},
+			{ disableExperimentalWarning: true }
+		);
+		const resp = await worker.fetch("/test");
+		let text;
+		if (resp) text = await resp.text();
+		expect(text).toMatchInlineSnapshot(`"request"`);
+		await worker.stop();
+	});
+
+	it("should allow no input be passed in", async () => {
+		const scriptContent = `
+	export default {
+		fetch(request, env, ctx) {
+			const url = new URL(request.url);
+			if (url.pathname === "/test") {
+				return new Response("request");
+			}
+			return new Response('Hello world');
+		}
+	};
+	`;
+		fs.writeFileSync("index.js", scriptContent);
+		const worker = await unstable_dev(
+			"index.js",
+			{},
+			{ disableExperimentalWarning: true }
+		);
+		const resp = await worker.fetch("");
+		let text;
+		if (resp) text = await resp.text();
+		expect(text).toMatchInlineSnapshot(`"Hello world"`);
+		await worker.stop();
+	});
+});

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__/api.test.ts

@@ -0,0 +1,80 @@
+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 full url to be passed in as string and stripped", () => {
+		const [input, _] = parseRequestInput(
+			"0.0.0.0",
+			8080,
+			"http://cloudflare.com/test"
+		);
+
+		expect(input).toMatchInlineSnapshot(`"http://0.0.0.0:8080/test"`);
+	});
+
+	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 request object to be passed in", () => {
+		const [input, init] = parseRequestInput(
+			"0.0.0.0",
+			8080,
+			new Request("http://cloudflare.com/test", { 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"`
+		);
+		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__/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__/init.test.ts

@@ -982,7 +982,8 @@ describe("init", () => {
 				{
 					text: "Would you like to use TypeScript?",
 					result: false,
-				}
+				},
+				{ text: "Would you like us to write your first test?", result: false }
 			);
 			mockSelect({
 				text: "Would you like to create a Worker at src/index.js?",
@@ -1562,7 +1563,8 @@ describe("init", () => {
 				{
 					text: "Would you like to use TypeScript?",
 					result: false,
-				}
+				},
+				{ text: "Would you like us to write your first test?", result: false }
 			);
 			mockSelect({
 				text: "Would you like to create a Worker at src/index.js?",
@@ -1596,6 +1598,127 @@ describe("init", () => {
 			        To publish your Worker to the Internet, run \`npm run deploy\`"
 		      `);
 		});
+		it("should add a jest test for a non-ts project with .js extension", 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: true,
+				},
+				{
+					text: "Would you like to install wrangler into package.json?",
+					result: false,
+				},
+				{
+					text: "Would you like to use TypeScript?",
+					result: false,
+				},
+				{ text: "Would you like us to write your first test?", result: true }
+			);
+			mockSelect(
+				{
+					text: "Would you like to create a Worker at src/index.js?",
+					result: "fetch",
+				},
+				{ text: "Which test runner would you like to use?", result: "jest" }
+			);
+
+			await runWrangler("init");
+
+			checkFiles({
+				items: {
+					"src/index.js": true,
+					"src/index.test.js": true,
+					"src/index.ts": false,
+					"package.json": {
+						contents: expect.objectContaining({
+							name: expect.stringContaining("wrangler-tests"),
+							version: "0.0.0",
+							scripts: {
+								start: "wrangler dev",
+								deploy: "wrangler publish",
+								test: "jest",
+							},
+						}),
+					},
+				},
+			});
+			expect(std.out).toMatchInlineSnapshot(`
+			"✨ Created wrangler.toml
+			✨ Created package.json
+			✨ Created src/index.js
+			✨ Created src/index.test.js
+			✨ Installed jest into devDependencies
+
+			To start developing your Worker, run \`npm start\`
+			To start testing your Worker, run \`npm test\`
+			To publish your Worker to the Internet, run \`npm run deploy\`"
+		`);
+		});
+
+		it("should add a vitest test for a non-ts project with .js extension", 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: true,
+				},
+				{
+					text: "Would you like to install wrangler into package.json?",
+					result: false,
+				},
+				{
+					text: "Would you like to use TypeScript?",
+					result: false,
+				},
+				{ text: "Would you like us to write your first test?", result: true }
+			);
+			mockSelect(
+				{
+					text: "Would you like to create a Worker at src/index.js?",
+					result: "fetch",
+				},
+				{ text: "Which test runner would you like to use?", result: "vitest" }
+			);
+
+			await runWrangler("init");
+
+			checkFiles({
+				items: {
+					"src/index.js": true,
+					"src/index.test.js": true,
+					"src/index.ts": false,
+					"package.json": {
+						contents: expect.objectContaining({
+							name: expect.stringContaining("wrangler-tests"),
+							version: "0.0.0",
+							scripts: {
+								start: "wrangler dev",
+								deploy: "wrangler publish",
+								test: "vitest",
+							},
+						}),
+					},
+				},
+			});
+			expect(std.out).toMatchInlineSnapshot(`
+			"✨ Created wrangler.toml
+			✨ Created package.json
+			✨ Created src/index.js
+			✨ Created src/index.test.js
+			✨ Installed vitest into devDependencies
+
+			To start developing your Worker, run \`npm start\`
+			To start testing your Worker, run \`npm test\`
+			To publish your Worker to the Internet, run \`npm run deploy\`"
+		`);
+		});
 
 		it("should not overwrite package.json scripts for a non-ts project with .js extension", async () => {
 			mockConfirm(
@@ -1610,7 +1733,8 @@ describe("init", () => {
 				{
 					text: "Would you like to use TypeScript?",
 					result: false,
-				}
+				},
+				{ text: "Would you like us to write your first test?", result: false }
 			);
 			mockSelect({
 				text: "Would you like to create a Worker at src/index.js?",