wrangler 0.0.0-e95e5a0 → 0.0.0-e98613f8

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/run-in-tmp.ts

@@ -5,35 +5,34 @@ import { reinitialiseAuthTokens } from "../../user";
 
 const originalCwd = process.cwd();
 
-export function runInTempDir({ homedir }: { homedir?: string } = {}) {
-  let tmpDir: string;
+export function runInTempDir({ homedir } = { homedir: "./home" }) {
+	let tmpDir: string;
 
-  beforeAll(() => {
-    if (tmpDir !== undefined) {
-      process.chdir(originalCwd);
-      fs.rmSync(tmpDir, { recursive: true });
-    }
-  });
+	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"))
+		);
 
-  beforeEach(() => {
-    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "wrangler-tests"));
-    process.chdir(tmpDir);
-    if (homedir !== undefined) {
-      // Override where the home directory is so that we can write our own user config,
-      // without destroying the real thing.
-      fs.mkdirSync(homedir);
-      // 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(homedir);
-      // Now that we have changed the home directory location, we must reinitialize the user auth state
-      reinitialiseAuthTokens();
-    }
-  });
+		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(() => {
-    process.chdir(originalCwd);
-    fs.rmSync(tmpDir, { recursive: true });
-  });
+	afterEach(() => {
+		if (fs.existsSync(tmpDir)) {
+			process.chdir(originalCwd);
+			fs.rmSync(tmpDir, { recursive: true });
+		}
+	});
 }

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

@@ -5,12 +5,12 @@ 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;
-  }
+	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

@@ -2,30 +2,30 @@ import fs from "node:fs";
 
 /** Write a mock Worker script to disk. */
 export function writeWorkerSource({
-  basePath = ".",
-  format = "js",
-  type = "esm",
+	basePath = ".",
+	format = "js",
+	type = "esm",
 }: {
-  basePath?: string;
-  format?: "js" | "ts" | "jsx" | "tsx" | "mjs";
-  type?: "esm" | "sw";
+	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";
+	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";
+			: `import { foo } from "./another";
       addEventListener('fetch', event => {
         event.respondWith(new Response('Hello' + foo));
       })`
-  );
-  fs.writeFileSync(`${basePath}/another.${format}`, `export const foo = 100;`);
+	);
+	fs.writeFileSync(`${basePath}/another.${format}`, `export const foo = 100;`);
 }

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

@@ -4,14 +4,14 @@ 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),
-    }),
+	fs.writeFileSync(
+		"./wrangler.toml",
+		TOML.stringify({
+			compatibility_date: "2022-01-12",
+			name: "test-name",
+			...(config as TOML.JsonMap),
+		}),
 
-    "utf-8"
-  );
+		"utf-8"
+	);
 }

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

@@ -1,130 +1,163 @@
 import fs from "node:fs";
 import os from "node:os";
-import { resolve } from "node:path";
+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({ homedir: "./home" });
-  const std = mockConsoleMethods();
+	runInTempDir();
+	const std = mockConsoleMethods();
 
-  it("should use cached values if they have not expired", async () => {
-    fs.mkdirSync(resolve(os.homedir(), ".wrangler/local-cert"), {
-      recursive: true,
-    });
-    fs.writeFileSync(
-      resolve(os.homedir(), ".wrangler/local-cert/key.pem"),
-      "PRIVATE KEY"
-    );
-    fs.writeFileSync(
-      resolve(os.homedir(), ".wrangler/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 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(
-      resolve(os.homedir(), ".wrangler/local-cert/key.pem"),
-      "utf8"
-    );
-    const cert = fs.readFileSync(
-      resolve(os.homedir(), ".wrangler/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 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(resolve(os.homedir(), ".wrangler/local-cert"), {
-      recursive: true,
-    });
-    const ORIGINAL_KEY = "EXPIRED PRIVATE KEY";
-    const ORIGINAL_CERT = "EXPIRED PUBLIC KEY";
-    fs.writeFileSync(
-      resolve(os.homedir(), ".wrangler/local-cert/key.pem"),
-      ORIGINAL_KEY
-    );
-    fs.writeFileSync(
-      resolve(os.homedir(), ".wrangler/local-cert/cert.pem"),
-      ORIGINAL_CERT
-    );
-    mockStatSync(/\.pem$/, { mtimeMs: new Date(2000).valueOf() });
+	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(
-      resolve(os.homedir(), ".wrangler/local-cert/key.pem"),
-      "utf8"
-    );
-    const cert = fs.readFileSync(
-      resolve(os.homedir(), ".wrangler/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(`""`);
-  });
+		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", async () => {
-    mockWriteFileSyncThrow(/\.pem$/);
-    await getHttpsOptions();
-    expect(
-      fs.existsSync(resolve(os.homedir(), ".wrangler/local-cert/key.pem"))
-    ).toBe(false);
-    expect(
-      fs.existsSync(resolve(os.homedir(), ".wrangler/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.
+	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
+		        ERROR: Cannot write file
 
-      "
-    `);
-    expect(std.err).toMatchInlineSnapshot(`""`);
-  });
+		      "
+	    `);
+		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);
-  });
+	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);
-      }
-    });
+	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);
+			}
+		});
 }