wrangler 0.0.0-e928f94 → 0.0.0-e93063e9

package/src/__tests__/helpers/msw/handlers/r2.ts

@@ -0,0 +1,80 @@
+import { rest } from "msw";
+
+export const mswSuccessR2handlers = [
+	// List endpoint r2Buckets
+	rest.get("*/accounts/:accountId/r2/buckets", (_, response, context) =>
+		response.once(
+			context.status(200),
+			context.json({
+				success: true,
+				errors: [],
+				messages: [],
+				result: {
+					buckets: [
+						{ name: "bucket-1", creation_date: "01-01-2001" },
+						{ name: "bucket-2", creation_date: "01-01-2001" },
+					],
+				},
+			})
+		)
+	),
+	rest.post("*/accounts/:accountId/r2/buckets", (_, response, context) =>
+		response.once(
+			context.status(200),
+			context.json({ success: true, errors: [], messages: [], result: {} })
+		)
+	),
+	rest.put(
+		"*/accounts/:accountId/r2/buckets/:bucketName",
+		(_, response, context) =>
+			response.once(
+				context.status(200),
+				context.json({ success: true, errors: [], messages: [], result: {} })
+			)
+	),
+	rest.delete(
+		"*/accounts/:accountId/r2/buckets/:bucketName",
+		(_, response, context) =>
+			response.once(
+				context.status(200),
+				context.json({ success: true, errors: [], messages: [], result: null })
+			)
+	),
+	rest.get(
+		"*/accounts/:accountId/r2/buckets/:bucketName/objects/:objectName",
+		(_, response, context) => {
+			const imageBuffer = Buffer.from("wormhole-img.png");
+			return response.once(
+				context.set("Content-Length", imageBuffer.byteLength.toString()),
+				context.set("Content-Type", "image/png"),
+				context.status(200),
+				context.body(imageBuffer)
+			);
+		}
+	),
+	rest.put(
+		"*/accounts/:accountId/r2/buckets/:bucketName/objects/:objectName",
+		(_, response, context) =>
+			response.once(
+				context.status(200),
+				context.json({
+					success: true,
+					errors: [],
+					messages: [],
+					result: {
+						accountId: "some-account-id",
+						bucketName: "bucketName-object-test",
+						objectName: "wormhole-img.png",
+					},
+				})
+			)
+	),
+	rest.delete(
+		"*/accounts/:accountId/r2/buckets/:bucketName/objects/:objectName",
+		(_, response, context) =>
+			response.once(
+				context.status(200),
+				context.json({ success: true, errors: [], messages: [], result: null })
+			)
+	),
+];

package/src/__tests__/helpers/msw/handlers/script.ts

@@ -0,0 +1,75 @@
+import { rest } from "msw";
+import type { WorkerMetadata } from "../../../../create-worker-upload-form";
+
+const bindings: Record<string, WorkerMetadata["bindings"]> = {
+	"durable-object": [
+		{
+			type: "durable_object_namespace",
+			name: "TestDO",
+			class_name: "TestDO",
+		},
+	],
+};
+const scripts: Record<string, string> = {
+	websocket: `new WebSocket("ws://dummy")`,
+	response: `return new Response("ok")`,
+};
+function getBindings(scriptName: string) {
+	return scriptName.split("--").flatMap((part) => bindings[part] ?? []);
+}
+function getScript(scriptName: string) {
+	return `export default {fetch(request){
+    ${scriptName
+			.split("--")
+			.map((part) => scripts[part] ?? "")
+			.join(";\n")}
+  }}`;
+}
+export default [
+	rest.get(
+		"*/accounts/:accountId/workers/services/:scriptName/environments/:env/content",
+		({ params: { scriptName } }, res, context) => {
+			return res(
+				context.status(200),
+				context.text(getScript(scriptName as string))
+			);
+		}
+	),
+	rest.get(
+		"*/accounts/:accountId/workers/scripts/:scriptName",
+		({ params: { scriptName } }, res, context) => {
+			return res(
+				context.status(200),
+				context.text(getScript(scriptName as string))
+			);
+		}
+	),
+	rest.get(
+		"*/accounts/:accountId/workers/services/:scriptName/environments/:env/bindings",
+		({ params: { scriptName } }, res, context) => {
+			return res(
+				context.status(200),
+				context.json({
+					success: true,
+					errors: [],
+					messages: [],
+					result: getBindings(scriptName as string),
+				})
+			);
+		}
+	),
+	rest.get(
+		"*/accounts/:accountId/workers/scripts/:scriptName/bindings",
+		({ params: { scriptName } }, res, context) => {
+			return res(
+				context.status(200),
+				context.json({
+					success: true,
+					errors: [],
+					messages: [],
+					result: getBindings(scriptName as string),
+				})
+			);
+		}
+	),
+];

package/src/__tests__/helpers/msw/handlers/user.ts

@@ -0,0 +1,63 @@
+import { rest } from "msw";
+
+export const mswSuccessUserHandlers = [
+	rest.get("*/user", (_, response, cxt) => {
+		return response.once(
+			cxt.status(200),
+			cxt.json({
+				success: true,
+				errors: [],
+				messages: [],
+				result: {
+					id: "7c5dae5552338874e5053f2534d2767a",
+					email: "user@example.com",
+					first_name: "John",
+					last_name: "Appleseed",
+					username: "cfuser12345",
+					telephone: "+1 123-123-1234",
+					country: "US",
+					zipcode: "12345",
+					created_on: "2014-01-01T05:20:00Z",
+					modified_on: "2014-01-01T05:20:00Z",
+					two_factor_authentication_enabled: false,
+					suspended: false,
+				},
+			})
+		);
+	}),
+	rest.get("*/accounts", (_, response, cxt) => {
+		return response.once(
+			cxt.status(200),
+			cxt.json({
+				success: true,
+				errors: [],
+				messages: [],
+				result: [
+					{ name: "Account One", id: "account-1" },
+					{ name: "Account Two", id: "account-2" },
+					{ name: "Account Three", id: "account-3" },
+				],
+			})
+		);
+	}),
+	rest.get("*/memberships", (_, response, context) => {
+		return response.once(
+			context.status(200),
+			context.json({
+				success: true,
+				errors: [],
+				messages: [],
+				result: [
+					{
+						id: "membership-id-1",
+						account: { id: "account-id-1", name: "My Personal Account" },
+					},
+					{
+						id: "membership-id-2",
+						account: { id: "account-id-2", name: "Enterprise Account" },
+					},
+				],
+			})
+		);
+	}),
+];

package/src/__tests__/helpers/msw/handlers/zones.ts

@@ -0,0 +1,22 @@
+import { rest } from "msw";
+
+export default [
+	rest.get("*/zones", ({ url: { searchParams } }, res, context) => {
+		return res(
+			context.status(200),
+			context.json({
+				success: true,
+				errors: [],
+				messages: [],
+				result:
+					searchParams.get("name") === "exists.com"
+						? [
+								{
+									id: "exists-com",
+								},
+						  ]
+						: [],
+			})
+		);
+	}),
+];

package/src/__tests__/helpers/msw/index.ts

@@ -0,0 +1,21 @@
+import { setupServer } from "msw/node";
+import { default as mswAccessHandlers } from "./handlers/access";
+import { mswSuccessDeployments } from "./handlers/deployments";
+import { mswSuccessNamespacesHandlers } from "./handlers/namespaces";
+import { mswSuccessOauthHandlers } from "./handlers/oauth";
+import { mswSuccessR2handlers } from "./handlers/r2";
+import { default as mswSucessScriptHandlers } from "./handlers/script";
+import { mswSuccessUserHandlers } from "./handlers/user";
+import { default as mswZoneHandlers } from "./handlers/zones";
+export const msw = setupServer();
+
+export {
+	mswSuccessUserHandlers,
+	mswSuccessR2handlers,
+	mswSuccessOauthHandlers,
+	mswSuccessNamespacesHandlers,
+	mswSucessScriptHandlers,
+	mswZoneHandlers,
+	mswSuccessDeployments,
+	mswAccessHandlers,
+};

package/src/__tests__/helpers/msw/read-file-sync.js

@@ -0,0 +1,61 @@
+/*! Read blob sync in NodeJS. MIT License. Jimmy Wärting <https://jimmy.warting.se/opensource>
+ * Special Thanks to Jimmy Wärting helping in https://github.com/nodejs/undici/issues/1830
+ */
+const { join } = require("path");
+const {
+	Worker,
+	receiveMessageOnPort,
+	MessageChannel,
+} = require("worker_threads");
+
+/**
+ * blob-worker & read-file-sync are part of a polyfill to synchronously read a blob in NodeJS
+ * this is needed for MSW FormData patching to work and support Blobs, serializing them to a string before recreating the FormData.
+ */
+function read(blob) {
+	const subChannel = new MessageChannel();
+	const signal = new Int32Array(new SharedArrayBuffer(4));
+	signal[0] = 0;
+
+	const path = join(__dirname, "blob-worker.cjs");
+
+	const worker = new Worker(path, {
+		transferList: [subChannel.port1],
+		workerData: {
+			signal,
+			port: subChannel.port1,
+			blob,
+		},
+	});
+
+	// Sleep until the other thread sets signal[0] to 1
+	Atomics.wait(signal, 0, 0);
+
+	// Close the worker thread
+	worker.terminate();
+
+	return receiveMessageOnPort(subChannel.port2)?.message;
+}
+
+class FileReaderSync {
+	readAsArrayBuffer(blob) {
+		this.result = read(blob);
+	}
+
+	readAsDataURL(blob) {
+		const ab = read(blob);
+		this.result = `data:${blob.type};base64,${Buffer.from(ab).toString(
+			"base64"
+		)}`;
+	}
+
+	readAsText(blob) {
+		const ab = read(blob);
+		this.result = new TextDecoder().decode(ab);
+	}
+
+	// Should not be used, use readAsArrayBuffer instead
+	// readAsBinaryString(blob) { ... }
+}
+
+exports.FileReaderSync = FileReaderSync;

package/src/__tests__/helpers/run-in-tmp.ts

@@ -0,0 +1,38 @@
+import * as fs from "node:fs";
+import os from "node:os";
+import * as path from "node:path";
+import { reinitialiseAuthTokens } from "../../user";
+
+const originalCwd = process.cwd();
+
+export function runInTempDir({ homedir } = { homedir: "./home" }) {
+	let tmpDir: string;
+
+	beforeEach(() => {
+		// Use realpath because the temporary path can point to a symlink rather than the actual path.
+		tmpDir = fs.realpathSync(
+			fs.mkdtempSync(path.join(os.tmpdir(), "wrangler-tests"))
+		);
+
+		process.chdir(tmpDir);
+		// The path that is returned from `homedir()` should be absolute.
+		const absHomedir = path.resolve(tmpDir, homedir);
+		// Override where the home directory is so that we can write our own user config,
+		// without destroying the real thing.
+		fs.mkdirSync(absHomedir, { recursive: true });
+		// Note it is very important that we use the "default" value from "node:os" (e.g. `import os from "node:os";`)
+		// rather than an alias to the module (e.g. `import * as os from "node:os";`).
+		// This is because the module gets transpiled so that the "method" `homedir()` gets converted to a
+		// getter that is not configurable (and so cannot be spied upon).
+		jest.spyOn(os, "homedir")?.mockReturnValue(absHomedir);
+		// Now that we have changed the home directory location, we must reinitialize the user auth state
+		reinitialiseAuthTokens();
+	});
+
+	afterEach(() => {
+		if (fs.existsSync(tmpDir)) {
+			process.chdir(originalCwd);
+			fs.rmSync(tmpDir, { recursive: true });
+		}
+	});
+}

package/src/__tests__/helpers/run-wrangler.ts

@@ -0,0 +1,16 @@
+import { main } from "../../index";
+import { normalizeSlashes, stripTimings } from "./mock-console";
+
+/**
+ * A helper to 'run' wrangler commands for tests.
+ */
+export async function runWrangler(cmd?: string) {
+	try {
+		await main(cmd?.split(" ") ?? []);
+	} catch (err) {
+		if (err instanceof Error) {
+			err.message = normalizeSlashes(stripTimings(err.message));
+		}
+		throw err;
+	}
+}

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

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

package/src/__tests__/helpers/worker-scripts/hello-world-worker.js

@@ -0,0 +1,5 @@
+export default {
+	async fetch() {
+		return new Response("Hello World!");
+	},
+};

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__/helpers/write-worker-source.ts

@@ -0,0 +1,31 @@
+import fs from "node:fs";
+
+/** Write a mock Worker script to disk. */
+export function writeWorkerSource({
+	basePath = ".",
+	format = "js",
+	type = "esm",
+}: {
+	basePath?: string;
+	format?: "js" | "ts" | "jsx" | "tsx" | "mjs";
+	type?: "esm" | "sw";
+} = {}) {
+	if (basePath !== ".") {
+		fs.mkdirSync(basePath, { recursive: true });
+	}
+	fs.writeFileSync(
+		`${basePath}/index.${format}`,
+		type === "esm"
+			? `import { foo } from "./another";
+      export default {
+        async fetch(request) {
+          return new Response('Hello' + foo);
+        },
+      };`
+			: `import { foo } from "./another";
+      addEventListener('fetch', event => {
+        event.respondWith(new Response('Hello' + foo));
+      })`
+	);
+	fs.writeFileSync(`${basePath}/another.${format}`, `export const foo = 100;`);
+}

package/src/__tests__/helpers/write-wrangler-toml.ts

@@ -0,0 +1,17 @@
+import * as fs from "fs";
+import TOML from "@iarna/toml";
+import type { RawConfig } from "../../config";
+
+/** Write a mock wrangler.toml file to disk. */
+export default function writeWranglerToml(config: RawConfig = {}) {
+	fs.writeFileSync(
+		"./wrangler.toml",
+		TOML.stringify({
+			compatibility_date: "2022-01-12",
+			name: "test-name",
+			...(config as TOML.JsonMap),
+		}),
+
+		"utf-8"
+	);
+}

package/src/__tests__/https-options.test.ts

@@ -0,0 +1,163 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { getGlobalWranglerConfigPath } from "../global-wrangler-config-path";
+import { getHttpsOptions } from "../https-options";
+import { mockConsoleMethods } from "./helpers/mock-console";
+import { runInTempDir } from "./helpers/run-in-tmp";
+
+describe("getHttpsOptions()", () => {
+	runInTempDir();
+	const std = mockConsoleMethods();
+
+	it("should use cached values if they have not expired", async () => {
+		fs.mkdirSync(path.resolve(getGlobalWranglerConfigPath(), "local-cert"), {
+			recursive: true,
+		});
+		fs.writeFileSync(
+			path.resolve(getGlobalWranglerConfigPath(), "local-cert/key.pem"),
+			"PRIVATE KEY"
+		);
+		fs.writeFileSync(
+			path.resolve(getGlobalWranglerConfigPath(), "local-cert/cert.pem"),
+			"PUBLIC KEY"
+		);
+		const result = await getHttpsOptions();
+		expect(result.key).toEqual("PRIVATE KEY");
+		expect(result.cert).toEqual("PUBLIC KEY");
+		expect(std.out).toMatchInlineSnapshot(`""`);
+		expect(std.warn).toMatchInlineSnapshot(`""`);
+		expect(std.err).toMatchInlineSnapshot(`""`);
+	});
+
+	it("should generate and cache new keys if none are cached", async () => {
+		const result = await getHttpsOptions();
+		const key = fs.readFileSync(
+			path.resolve(getGlobalWranglerConfigPath(), "local-cert/key.pem"),
+			"utf8"
+		);
+		const cert = fs.readFileSync(
+			path.resolve(getGlobalWranglerConfigPath(), "local-cert/cert.pem"),
+			"utf8"
+		);
+		expect(result.key).toEqual(key);
+		expect(result.cert).toEqual(cert);
+		expect(std.out).toMatchInlineSnapshot(
+			`"Generating new self-signed certificate..."`
+		);
+		expect(std.warn).toMatchInlineSnapshot(`""`);
+		expect(std.err).toMatchInlineSnapshot(`""`);
+	});
+
+	it("should generate and cache new keys if cached files have expired", async () => {
+		fs.mkdirSync(path.resolve(getGlobalWranglerConfigPath(), "local-cert"), {
+			recursive: true,
+		});
+		const ORIGINAL_KEY = "EXPIRED PRIVATE KEY";
+		const ORIGINAL_CERT = "EXPIRED PUBLIC KEY";
+		fs.writeFileSync(
+			path.resolve(getGlobalWranglerConfigPath(), "local-cert/key.pem"),
+			ORIGINAL_KEY
+		);
+		fs.writeFileSync(
+			path.resolve(getGlobalWranglerConfigPath(), "local-cert/cert.pem"),
+			ORIGINAL_CERT
+		);
+		mockStatSync(/\.pem$/, { mtimeMs: new Date(2000).valueOf() });
+
+		const result = await getHttpsOptions();
+		const key = fs.readFileSync(
+			path.resolve(getGlobalWranglerConfigPath(), "local-cert/key.pem"),
+			"utf8"
+		);
+		const cert = fs.readFileSync(
+			path.resolve(getGlobalWranglerConfigPath(), "local-cert/cert.pem"),
+			"utf8"
+		);
+		expect(key).not.toEqual(ORIGINAL_KEY);
+		expect(cert).not.toEqual(ORIGINAL_CERT);
+		expect(result.key).toEqual(key);
+		expect(result.cert).toEqual(cert);
+		expect(std.out).toMatchInlineSnapshot(
+			`"Generating new self-signed certificate..."`
+		);
+		expect(std.warn).toMatchInlineSnapshot(`""`);
+		expect(std.err).toMatchInlineSnapshot(`""`);
+	});
+
+	it("should warn if not able to write to the cache (legacy config path)", async () => {
+		fs.mkdirSync(path.join(os.homedir(), ".wrangler"));
+		mockWriteFileSyncThrow(/\.pem$/);
+		await getHttpsOptions();
+		expect(
+			fs.existsSync(
+				path.resolve(getGlobalWranglerConfigPath(), "local-cert/key.pem")
+			)
+		).toBe(false);
+		expect(
+			fs.existsSync(
+				path.resolve(getGlobalWranglerConfigPath(), "local-cert/cert.pem")
+			)
+		).toBe(false);
+		expect(std.out).toMatchInlineSnapshot(
+			`"Generating new self-signed certificate..."`
+		);
+		expect(std.warn).toMatchInlineSnapshot(`
+		      "▲ [WARNING] Unable to cache generated self-signed certificate in home/.wrangler/local-cert.
+
+		        ERROR: Cannot write file
+
+		      "
+	    `);
+		expect(std.err).toMatchInlineSnapshot(`""`);
+		fs.rmSync(path.join(os.homedir(), ".wrangler"), { recursive: true });
+	});
+
+	it("should warn if not able to write to the cache", async () => {
+		mockWriteFileSyncThrow(/\.pem$/);
+		await getHttpsOptions();
+		expect(
+			fs.existsSync(
+				path.resolve(getGlobalWranglerConfigPath(), "local-cert/key.pem")
+			)
+		).toBe(false);
+		expect(
+			fs.existsSync(
+				path.resolve(getGlobalWranglerConfigPath(), "local-cert/cert.pem")
+			)
+		).toBe(false);
+		expect(std.out).toMatchInlineSnapshot(
+			`"Generating new self-signed certificate..."`
+		);
+		expect(std.warn).toMatchInlineSnapshot(`
+		"▲ [WARNING] Unable to cache generated self-signed certificate in test-xdg-config/local-cert.
+
+		  ERROR: Cannot write file
+
+		"
+	`);
+		expect(std.err).toMatchInlineSnapshot(`""`);
+	});
+});
+
+function mockStatSync(matcher: RegExp, stats: Partial<fs.Stats>) {
+	const originalStatSync = jest.requireActual("node:fs").statSync;
+	jest.spyOn(fs, "statSync").mockImplementation((statPath, options) => {
+		return matcher.test(statPath.toString())
+			? (stats as fs.Stats)
+			: originalStatSync(statPath, options);
+	});
+}
+
+function mockWriteFileSyncThrow(matcher: RegExp) {
+	const originalWriteFileSync = jest.requireActual("node:fs").writeFileSync;
+	jest
+		.spyOn(fs, "writeFileSync")
+		.mockImplementation((filePath, data, options) => {
+			if (matcher.test(filePath.toString())) {
+				throw new Error("ERROR: Cannot write file");
+			} else {
+				return originalWriteFileSync(filePath, data, options);
+			}
+		});
+}