cf-bun-mocks 0.2.0 → 0.3.0

package/README.md

@@ -109,77 +109,52 @@ const response = await worker.fetch(request, env);
 
 ## Workers Environment
 
-For testing Cloudflare Workers, use the `useWorkersEnv` helper to create test environments:
+For testing code that imports from `cloudflare:workers`, use `useWorkersMock()` to mock the module and set up test environments:
 
 ```typescript
 import { describe, test, expect } from "bun:test";
-import { useWorkersEnv, D1Mock } from "cf-bun-mocks";
-import type { Env } from "./worker";
+import { useWorkersMock, D1Mock } from "cf-bun-mocks";
 
-describe("my worker", () => {
-  const { env } = useWorkersEnv<Env>(() => ({
-    DB: new D1Mock(":memory:"),
-    MY_SECRET: "test-secret",
+describe("worker with module imports", () => {
+  const { env } = useWorkersMock(() => ({
+    env: {
+      DB: new D1Mock(":memory:"),
+      API_KEY: "test-key",
+    },
   }));
 
-  test("uses test environment", async () => {
-    // Pass the env to your worker handler
-    const response = await worker.fetch(request, env);
-    expect(response.status).toBe(200);
+  test("uses mocked environment", async () => {
+    const { env } = await import("cloudflare:workers");
+    expect(env.DB).toBeDefined();
+    expect(env.API_KEY).toBe("test-key");
   });
 });
 ```
 
-### Module Mocking (Advanced)
+The mock environment is reset before each test with the values from your factory function.
 
-For mocking `cloudflare:workers` module imports, use `setupWorkersMock` in a preload script and combine it with `useWorkersEnv`:
+### Manual Injection (Alternative)
 
-Create a `test-setup.ts` file:
-
-```typescript
-// test-setup.ts
-import { setupWorkersMock } from "cf-bun-mocks";
-
-// Set up module mocks before any test files load
-await setupWorkersMock();
-```
-
-Then run tests with preload:
-
-```bash
-bun test --preload ./test-setup.ts
-```
-
-Or configure it in `bunfig.toml`:
-
-```toml
-[test]
-preload = ["./test-setup.ts"]
-```
-
-Then use in your tests:
+If you're not using `cloudflare:workers` imports, you can pass the environment directly to your worker:
 
 ```typescript
 import { describe, test, expect } from "bun:test";
-import { useWorkersEnv, D1Mock } from "cf-bun-mocks";
+import { D1Mock } from "cf-bun-mocks";
+import type { Env } from "./worker";
 
-describe("worker with module imports", () => {
-  useWorkersEnv(() => ({
-    DB: new D1Mock(":memory:"),
-    API_KEY: "test-key",
-  }));
+describe("my worker", () => {
+  test("uses test environment", async () => {
+    const env: Env = {
+      DB: new D1Mock(":memory:"),
+      MY_SECRET: "test-secret",
+    };
 
-  test("uses mocked module", async () => {
-    // The env object reference stays the same, only properties change
-    const { env } = await import("cloudflare:workers");
-    expect(env.DB).toBeDefined();
-    expect(env.API_KEY).toBe("test-key");
+    const response = await worker.fetch(request, env);
+    expect(response.status).toBe(200);
   });
 });
 ```
 
-> **Note**: `setupWorkersMock` uses Bun's `mock.module()` function. Module mocks must be set up before any imports happen. See [Bun's test lifecycle docs](https://bun.com/docs/test/lifecycle#global-setup-and-teardown) for preload details and [Bun's mocking docs](https://bun.sh/docs/test/mocking) for more on module mocking.
-
 ## API
 
 ### `D1Mock`
@@ -196,13 +171,9 @@ Implements the full `D1Database` interface from `@cloudflare/workers-types`:
 
 Creates an in-memory D1Mock and runs all `.sql` migration files from the specified directory in sorted order.
 
-### `useWorkersEnv<TEnv>(createEnv: () => Partial<TEnv> | Promise<Partial<TEnv>>)`
-
-Updates the global workers mock environment for each test. Must be used with `setupWorkersMock()`.
-
-### `setupWorkersMock<TEnv>(createMock?: () => WorkersModuleMock<TEnv> | Promise<WorkersModuleMock<TEnv>>)`
+### `useWorkersMock<TEnv>(createMock: () => Partial<{ env: TEnv }> | Promise<Partial<{ env: TEnv }>>)`
 
-Sets up the `cloudflare:workers` module mock using Bun's `mock.module()`. **Must be called in a preload script before any test files load.** Use Bun's `--preload` flag or configure it in `bunfig.toml`. Call once at the start of your test suite, then use `useWorkersEnv()` to update the environment per test.
+Mocks the `cloudflare:workers` module and sets up test environments. Returns a mock object with an `env` property that gets updated before each test with values from the factory function. Uses Bun's `mock.module()` internally.
 
 ## Requirements
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cf-bun-mocks",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "Cloudflare Workers mocks and helpers for Bun testing",
   "type": "module",
   "main": "src/index.ts",

package/src/d1.ts

@@ -110,7 +110,7 @@ class D1DatabaseSessionMock implements D1DatabaseSession {
 }
 
 export class D1Mock implements D1Database {
-  #db: Database;
+  db: Database;
 
   constructor(
     filename?: string,
@@ -124,11 +124,11 @@ export class D1Mock implements D1Database {
           strict?: boolean;
         }
   ) {
-    this.#db = new Database(filename, options);
+    this.db = new Database(filename, options);
   }
 
   prepare(query: string): D1PreparedStatement {
-    const stmt = this.#db.prepare(query);
+    const stmt = this.db.prepare(query);
     return new D1PreparedStatementMock(stmt);
   }
 
@@ -148,7 +148,7 @@ export class D1Mock implements D1Database {
   async exec(query: string): Promise<D1ExecResult> {
     const start = performance.now();
     try {
-      const { changes: count } = this.#db.run(query);
+      const { changes: count } = this.db.run(query);
       const duration = performance.now() - start;
       return {
         count,
@@ -170,7 +170,7 @@ export class D1Mock implements D1Database {
   }
 
   async dump(): Promise<ArrayBuffer> {
-    const serialized = this.#db.serialize();
+    const serialized = this.db.serialize();
     const buffer = serialized.buffer;
     if (buffer instanceof SharedArrayBuffer) {
       const newBuffer = new ArrayBuffer(buffer.byteLength);

package/src/workers.ts

@@ -1,33 +1,28 @@
 /// <reference types="@cloudflare/workers-types" />
-import { beforeEach, mock, afterAll } from "bun:test";
+import { beforeEach, mock, afterAll, beforeAll } from "bun:test";
 
-type WorkersModuleMock<TEnv extends Cloudflare.Env = Cloudflare.Env> = {
-  env: Partial<TEnv>;
-};
+type WorkersModuleMock<TEnv extends Partial<Cloudflare.Env> = Cloudflare.Env> =
+  {
+    env: TEnv;
+  };
 
-let moduleMock: WorkersModuleMock = { env: {} };
+export function useWorkersMock<
+  TEnv extends Partial<Cloudflare.Env> = Cloudflare.Env
+>(createMock: () => Bun.MaybePromise<Partial<WorkersModuleMock<TEnv>>>) {
+  const moduleMock: WorkersModuleMock<TEnv> = { env: {} as TEnv };
 
-export async function setupWorkersMock<
-  TEnv extends Cloudflare.Env = Cloudflare.Env
->(createMock?: () => Bun.MaybePromise<WorkersModuleMock<TEnv>>) {
-  if (createMock) {
-    moduleMock = await createMock();
-  }
-  mock.module("cloudflare:workers", () => moduleMock);
-}
+  beforeAll(() => {
+    mock.module("cloudflare:workers", () => moduleMock);
+  });
 
-export function useWorkersEnv<TEnv extends Cloudflare.Env = Cloudflare.Env>(
-  createEnv: () => Bun.MaybePromise<Partial<TEnv>>
-) {
   beforeEach(async () => {
-    const env = await createEnv();
-    for (const key in moduleMock.env) {
-      delete (moduleMock.env as any)[key];
-    }
-    Object.assign(moduleMock.env, env);
+    const mock = await createMock();
+    Object.assign(moduleMock.env, mock.env);
   });
 
   afterAll(() => {
-    moduleMock.env = {};
+    mock.restore();
   });
+
+  return moduleMock;
 }