A bit of renaming.

Author: digitalBush

README.md

@@ -43,7 +43,7 @@ The default export is a function that sets up a mock environment, imports the ta
 
 ## Hard Mode
 
-If you need more control over the mock lifecycle (like dynamic imports), then you'll need to use the `Mocker` class directly.
+If you need more control over the mock lifecycle (like dynamic imports), then you'll need to use the `Pod` class directly.
 
 Let's consider a few files:
 
@@ -68,18 +68,18 @@ Now we can write a test that handles the dynamic import.
 import assert from "node:assert";
 import {test, mock} from "node:test";
 
-import {Mocker} from "modpod";
+import {Pod} from "modpod";
 
 test("hard mode", async (t) => {
-	const m = new Mocker({strict: true});
-	t.after(() => m.dispose()); // Clean up
+	const p = new Pod({strict: true});
+	t.after(() => p.dispose()); // Clean up
 
 	const dep = mock.fn(() => "mocked");
-	m.mock("./dep.js", {
+	p.mock("./dep.js", {
 		default: dep
 	});
 
-	const instance = await m.import("./target.js");
+	const instance = await p.import("./target.js");
 	assert.strictEqual(dep.mock.calls.length, 0);
 
 	const result = await instance.doSomething();

index.js

@@ -1,17 +1,17 @@
 import "./src/register.js";
 import internal from "./src/internal.js";
-import Mocker from "./src/mocker.js";
+import Pod from "./src/pod.js";
 
 async function _mock(module, mocks, opts) {
-	const m = new Mocker(opts, {[internal]: 3});
+	const p = new Pod(opts, {[internal]: 3});
 	try {
 		for (const [k, v] of Object.entries(mocks)) {
-			m.mock(k, v);
+			p.mock(k, v);
 		}
-		const instance = await m.import(module);
+		const instance = await p.import(module);
 		return instance;
 	} finally {
-		m.dispose();
+		p.dispose();
 	}
 }
 
@@ -21,4 +21,4 @@ mock.strict = (module, mocks) => _mock(module, mocks, {strict: true});
 
 export default mock;
 
-export {Mocker};
+export {Pod};

src/getModuleUrl.test.js

@@ -2,14 +2,14 @@ import {describe, it} from "node:test";
 import assert from "node:assert/strict";
 import path from "node:path";
 
-import {Mocker} from "../index.js"; // We're gonna test with our own mocker. 😍
+import {Pod} from "../index.js"; // We're gonna test using our own mocker. 😍
 
 describe("getModuleUrl", () => {
 	it("should error if no package.json is found", async (t) => {
-		const m = new Mocker();
-		t.after(() => m.dispose());
+		const p = new Pod();
+		t.after(() => p.dispose());
 
-		m.mock("node:fs/promises", {
+		p.mock("node:fs/promises", {
 			default: {
 				stat: () =>
 					Promise.resolve({
@@ -18,24 +18,24 @@ describe("getModuleUrl", () => {
 			}
 		});
 
-		const {default: getModuleUrl} = await m.import("./getModuleUrl.js");
+		const {default: getModuleUrl} = await p.import("./getModuleUrl.js");
 
 		await assert.rejects(() => getModuleUrl("#/lol.js", import.meta.url), {
 			message: `Can't locate package.json from ${path.dirname(import.meta.url)}`
 		});
 	});
 
 	it("should error if error is not ENOENT", async (t) => {
-		const m = new Mocker();
-		t.after(() => m.dispose());
+		const p = new Pod();
+		t.after(() => p.dispose());
 
-		m.mock("node:fs/promises", {
+		p.mock("node:fs/promises", {
 			default: {
 				stat: () => Promise.reject(new Error("boom"))
 			}
 		});
 
-		const {default: getModuleUrl} = await m.import("./getModuleUrl.js");
+		const {default: getModuleUrl} = await p.import("./getModuleUrl.js");
 
 		await assert.rejects(() => getModuleUrl("#/lol.js", import.meta.url), {
 			message: "boom"

src/hooks.js

@@ -38,7 +38,7 @@ export async function resolve(module, context, nextResolve) {
 				throw new Error(`Strict mode missing mock: "${module}"`);
 			} else if (isMissing) {
 				throw new Error(
-					`Late dynamic import: "${module}". Use the Mocker directly and call dispose after your test is done.`
+					`Late dynamic import: "${module}". Use the Pod class directly and call dispose after your test is done.`
 				);
 			}
 			if (deep && canRewrite(module)) {

src/mocker.js src/pod.jssrc/mocker.js renamed to src/pod.js

@@ -5,7 +5,7 @@ import internal from "./internal.js";
 import Cache from "./cache.js";
 import getModuleUrl from "./getModuleUrl.js";
 
-export default class Mocker {
+export default class Pod {
 	#cache;
 	#caller;
 	#options;

tests/mocker.test.js

@@ -1,25 +1,25 @@
 import {describe, it} from "node:test";
 import assert from "node:assert/strict";
 import {fileURLToPath} from "node:url";
-import {Mocker} from "../index.js";
+import {Pod} from "../index.js";
 
-describe("Mocker", () => {
+describe("Pod", () => {
 	[
 		["file://", import.meta.resolve("./scenarios/linear/a.js")],
 		["absolute", fileURLToPath(import.meta.resolve("./scenarios/linear/a.js"))],
 		["relative", "./scenarios/linear/a.js"],
 		["package imports", "#root/tests/scenarios/linear/a.js"]
 	].forEach(([desc, file]) => {
 		it(`should import from ${desc} path`, async (t) => {
-			const m = new Mocker();
-			t.after(() => m.dispose());
+			const p = new Pod();
+			t.after(() => p.dispose());
 
-			m.mock("./b.js", {
+			p.mock("./b.js", {
 				default: {mocked: "default"},
 				named: {mocked: "named"}
 			});
 
-			const a = await m.import(file);
+			const a = await p.import(file);
 
 			assert.deepEqual(a.default, {
 				a: true,
@@ -34,38 +34,38 @@ describe("Mocker", () => {
 	});
 
 	it("should mock late dynamic imports", async (t) => {
-		const m = new Mocker();
-		t.after(() => m.dispose());
-		m.mock("./b.js", {
+		const p = new Pod();
+		t.after(() => p.dispose());
+		p.mock("./b.js", {
 			default: () => "mocked"
 		});
-		const a = await m.import("./scenarios/dynamic/a.js");
+		const a = await p.import("./scenarios/dynamic/a.js");
 		assert.deepEqual(await a.default(), "mocked");
 	});
 
 	it("should error when trying to deep strict mocks", async () => {
-		assert.throws(() => new Mocker({deep: true, strict: true}), {
+		assert.throws(() => new Pod({deep: true, strict: true}), {
 			message: "Can't have a deep and strict mock"
 		});
 	});
 
 	it("should error with unknown options", async () => {
-		assert.throws(() => new Mocker({foo: "bar"}), {
+		assert.throws(() => new Pod({foo: "bar"}), {
 			message: 'Unknown options: {"foo":"bar"}'
 		});
 	});
 
 	it("should error with unused mocks", async () => {
-		const m = new Mocker();
+		const p = new Pod();
 
-		m.mock("./lol.js", {
+		p.mock("./lol.js", {
 			default: {mocked: "default"},
 			named: {mocked: "named"}
 		});
 
-		await m.import(import.meta.resolve("./scenarios/linear/a.js"));
+		await p.import(import.meta.resolve("./scenarios/linear/a.js"));
 
-		assert.throws(() => m.dispose(), {
+		assert.throws(() => p.dispose(), {
 			message: 'Unused mocks: "./lol.js"'
 		});
 	});

tests/shallow.test.js

@@ -46,6 +46,8 @@ describe("shallow (default)", () => {
 
 	it("should fail with late dynamic import", async () => {
 		const a = await mock("./scenarios/dynamic/a.js", {});
-		await assert.rejects(() => a.default());
+		await assert.rejects(() => a.default(), {
+			message: 'Late dynamic import: "./b.js". Use the Pod class directly and call dispose after your test is done.'
+		});
 	});
 });