@acmekit/acmekit 2.13.83 → 2.13.85

package/dist/templates/plugin/.claude/rules/testing.md

@@ -10,874 +10,885 @@ paths:
 
 ## Critical — Read Before Writing Any Test
 
+**Single unified runner.** Use `integrationTestRunner` from `@acmekit/test-utils` with a `mode` parameter. The old names (`pluginIntegrationTestRunner`, `moduleIntegrationTestRunner`) are deprecated aliases — NEVER use them.
+
 **Service resolution key = module constant.** `container.resolve(MY_MODULE)` where `MY_MODULE = "my-module"` (the string passed to `Module()`). NEVER guess `"myModuleService"` — it won't resolve.
 
 **Workflow errors are plain objects, not Error instances.** The distributed transaction engine serializes them. NEVER use `.rejects.toThrow()` on workflows — it always fails with "Received function did not throw". Use `throwOnError: false` + `errors` array, or `.rejects.toEqual(expect.objectContaining({ message }))`.
 
 **Error path is `errors[0].error.message`** — NOT `errors[0].message`. Each item in the `errors` array wraps the actual error under `.error`.
 
-**Schema sync vs migrations.** `pluginIntegrationTestRunner` and `moduleIntegrationTestRunner` sync DB schema from entities — no migration files needed. `acmekitIntegrationTestRunner` (host app) runs real migrations — modules MUST have migration files or you get `TableNotFoundException`.
+**Schema sync vs migrations.** `mode: "plugin"` (without `http: true`) and `mode: "module"` sync DB schema from entities — no migration files needed. `mode: "plugin"` with `http: true` runs full migrations like app mode.
 
 **`.rejects.toThrow()` DOES work for service errors** (e.g., `service.retrievePost("bad-id")`). Services throw real `Error` instances. Only workflow errors are serialized.
 
+**jest.mock factories are hoisted.** `jest.mock()` runs BEFORE `const`/`let` declarations. Never reference file-level variables inside a `jest.mock()` factory — see "Unit Tests" section below.
+
+**Always add `jest.clearAllMocks()` in `beforeEach`.** Mock state leaks between test blocks. Without explicit cleanup, assertions on mock call counts fail from prior-test contamination.
+
 ---
 
 ## Test Runner Selection
 
-| What to test | Runner | Fixtures provided | DB setup |
-|---|---|---|---|
-| Full plugin (modules + workflows + subscribers + jobs) | `pluginIntegrationTestRunner` | `container`, `acmekitApp`, `MikroOrmWrapper`, `dbConfig` | Schema sync (no migrations) |
-| Module service CRUD in isolation | `moduleIntegrationTestRunner` | `service`, `MikroOrmWrapper`, `acmekitApp`, `dbConfig` | Schema sync (no migrations) |
-| Pure functions (no DB) | Plain Jest `describe/it` | none | N/A |
+| What to test | Mode | HTTP? | Fixtures | DB setup |
+|---|---|---|---|---|
+| Full plugin (modules + workflows + subscribers + jobs) | `mode: "plugin"` | no | `container`, `acmekitApp`, `MikroOrmWrapper`, `dbConfig` | Schema sync |
+| Plugin HTTP routes end-to-end | `mode: "plugin"` + `http: true` | yes | `api`, `container`, `dbConfig` | Runs migrations |
+| Module service CRUD in isolation | `mode: "module"` | no | `service`, `MikroOrmWrapper`, `acmekitApp`, `dbConfig` | Schema sync |
+| Pure functions (no DB) | Plain Jest `describe/it` | — | none | N/A |
 
-**No HTTP server:** `pluginIntegrationTestRunner` does NOT start an Express server. There is no `api` fixture. To test HTTP routes, mount the plugin in a host application and use `acmekitIntegrationTestRunner` there.
+---
 
 ## File Locations (must match `jest.config.js` buckets)
 
 ```
-integration-tests/plugin/<feature>.spec.ts   → TEST_TYPE=integration:plugin
-src/modules/<mod>/__tests__/<name>.spec.ts   → TEST_TYPE=integration:modules
-src/**/__tests__/<name>.unit.spec.ts         → TEST_TYPE=unit
+integration-tests/plugin/<feature>.spec.ts  → TEST_TYPE=integration:plugin
+integration-tests/http/<feature>.spec.ts    → TEST_TYPE=integration:http
+src/modules/<mod>/__tests__/<name>.spec.ts  → TEST_TYPE=integration:modules
+src/**/__tests__/<name>.unit.spec.ts        → TEST_TYPE=unit
 ```
 
+**`integration-tests/plugin/`** — container-only tests (module CRUD, workflows, subscribers, jobs, event spying). No HTTP server.
+
+**`integration-tests/http/`** — full HTTP tests with Express. Boots the entire framework with the plugin installed. Requires auth setup (JWT + client API key).
+
+---
+
 ## Commands
 
 ```bash
 pnpm test:unit                      # Unit tests
 pnpm test:integration:modules       # Module integration tests
-pnpm test:integration:plugin        # Full plugin integration tests
+pnpm test:integration:plugin        # Plugin integration tests (container-only)
+pnpm test:integration:http          # Plugin HTTP integration tests
 ```
 
 All integration tests require `NODE_OPTIONS=--experimental-vm-modules` (set in package.json scripts).
 
 ---
 
-## Plugin Integration Tests
+## Plugin Integration Tests (`integration-tests/plugin/`)
+
+No HTTP server — test services, workflows, subscribers, and jobs directly through the container.
 
 ```typescript
-import { pluginIntegrationTestRunner } from "@acmekit/test-utils"
-import { plugin } from "../../src/plugin"
-import { BLOG_MODULE } from "../../src/modules/blog"  // BLOG_MODULE = "blog" — must match Module() key
+import { integrationTestRunner, MockEventBusService } from "@acmekit/test-utils"
+import { Modules } from "@acmekit/framework/utils"
+import { GREETING_MODULE } from "../../src/modules/greeting"
 
 jest.setTimeout(60 * 1000)
 
-pluginIntegrationTestRunner({
+integrationTestRunner({
+  mode: "plugin",
   pluginPath: process.cwd(),
   pluginOptions: {
     apiKey: "test-api-key",
   },
-  // additionalModules: { myOtherModule: OtherModule },
-  // injectedDependencies: { externalApi: mockExternalApi },
-  testSuite: ({ container, acmekitApp, MikroOrmWrapper }) => {
+  testSuite: ({ container, acmekitApp }) => {
     describe("Plugin loading", () => {
-      it("should load plugin modules", () => {
+      it("should load plugin resources", () => {
         expect(acmekitApp.modules).toBeDefined()
       })
 
-      it("should resolve typed plugin options", () => {
-        const options = plugin.resolveOptions(container)
-        expect(options.apiKey).toBe("test-api-key")
+      it("should resolve EVENT_BUS as MockEventBusService", () => {
+        const eventBus = container.resolve(Modules.EVENT_BUS)
+        expect(eventBus).toBeInstanceOf(MockEventBusService)
       })
     })
 
-    describe("BlogModule CRUD", () => {
-      let service: any
-
-      beforeEach(() => {
-        service = container.resolve(BLOG_MODULE)
-      })
-
-      it("should create a blog post", async () => {
-        const result = await service.createBlogPosts([
-          { title: "Launch Announcement" },
+    describe("GreetingModule CRUD", () => {
+      it("should create a greeting", async () => {
+        const service: any = container.resolve(GREETING_MODULE)
+        const result = await service.createGreetings([
+          { message: "Hello World" },
         ])
         expect(result).toHaveLength(1)
         expect(result[0]).toEqual(
           expect.objectContaining({
             id: expect.any(String),
-            title: "Launch Announcement",
+            message: "Hello World",
           })
         )
       })
 
-      it("should list and count", async () => {
-        await service.createBlogPosts([
-          { title: "Post A" },
-          { title: "Post B" },
-        ])
-        const [posts, count] = await service.listAndCountBlogPosts()
-        expect(count).toBe(2)
-      })
-
-      it("should soft delete and restore", async () => {
-        const [created] = await service.createBlogPosts([
-          { title: "To Delete" },
-        ])
-        await service.softDeleteBlogPosts([created.id])
-        await expect(
-          service.retrieveBlogPost(created.id)
-        ).rejects.toThrow()
-
-        await service.restoreBlogPosts([created.id])
-        const restored = await service.retrieveBlogPost(created.id)
-        expect(restored.title).toBe("To Delete")
-      })
-
       it("should throw on missing required field", async () => {
-        await expect(service.createBlogPosts([{}])).rejects.toThrow()
+        const service: any = container.resolve(GREETING_MODULE)
+        await expect(service.createGreetings([{}])).rejects.toThrow()
       })
     })
   },
 })
 ```
 
-### `pluginIntegrationTestRunner` Options
+### Plugin mode options
 
 | Option | Type | Default | Description |
 |---|---|---|---|
-| `pluginPath` | `string` | **(required)** | Path to plugin root (where `package.json` lives), usually `process.cwd()` |
-| `pluginOptions` | `Record<string, unknown>` | `{}` | Simulates host app plugin config from `acmekit-config.ts` |
+| `mode` | `"plugin"` | **(required)** | Selects plugin mode |
+| `pluginPath` | `string` | **(required)** | Path to plugin root — always use `process.cwd()` |
+| `pluginOptions` | `Record<string, unknown>` | `{}` | Simulates host app plugin config |
+| `http` | `boolean` | `false` | Set `true` to boot full Express server for HTTP tests |
 | `additionalModules` | `Record<string, any>` | `{}` | Extra modules to load alongside the plugin |
 | `injectedDependencies` | `Record<string, any>` | `{}` | Mock services to register in the container |
-| `schema` | `string` | `"public"` | Postgres schema |
+| `skipDependencyValidation` | `boolean` | `false` | Skip `definePlugin({ dependencies })` validation — use when peer plugins aren't installed |
+| `pluginModuleOptions` | `Record<string, Record<string, any>>` | `{}` | Per-module options keyed by module name (e.g., provider config) |
 | `dbName` | `string` | auto-generated | Override the computed DB name |
+| `schema` | `string` | `"public"` | Postgres schema |
 | `debug` | `boolean` | `false` | Enables DB query logging |
-| `cwd` | `string` | `process.cwd()` | Working directory |
-| `hooks` | `{ beforePluginInit?, afterPluginInit? }` | `{}` | Lifecycle hooks |
-| `testSuite` | `(options: PluginSuiteOptions) => void` | **(required)** | Test callback |
+| `hooks` | `RunnerHooks` | `{}` | Lifecycle hooks |
+| `testSuite` | `(options) => void` | **(required)** | Test callback |
 
-### `PluginSuiteOptions` fields
+### Plugin mode fixtures (container-only)
 
 - `container` — proxy to the shared `AcmeKitContainer` (auto-refreshed each `beforeEach`)
 - `acmekitApp` — proxy to the `AcmeKitApp` instance (has `.modules`, `.sharedContainer`)
 - `MikroOrmWrapper` — raw DB access: `.getManager()`, `.forkManager()`, `.getOrm()`
-- `dbConfig` — `{ schema, clientUrl }`
+- `dbConfig` — `{ schema, clientUrl, dbName }`
+
+### Plugin test lifecycle (container-only)
+
+Each `it` block gets: schema drop + recreate → fresh plugin boot (all modules, subscribers, workflows, jobs loaded) → test runs → schema clear → module shutdown. No manual cleanup needed.
 
-### Plugin test lifecycle
+---
 
-Each `it` block gets: schema drop + recreate → fresh plugin boot (all modules, subscribers, workflows, jobs loaded via SubscriberLoader, WorkflowLoader, JobLoader) → test runs → schema clear → module shutdown. No manual cleanup needed.
+## Plugin HTTP Integration Tests (`integration-tests/http/`)
 
-### Testing plugin options
+Full Express server with the plugin installed. Boots the entire framework including all core modules (user, auth, api-key, etc.), runs migrations, and serves plugin routes.
 
 ```typescript
-import { plugin } from "../../src/plugin"
+import { integrationTestRunner } from "@acmekit/test-utils"
+import {
+  ApiKeyType,
+  CLIENT_API_KEY_HEADER,
+  ContainerRegistrationKeys,
+  generateJwtToken,
+  Modules,
+} from "@acmekit/framework/utils"
+import { GREETING_MODULE } from "../../src/modules/greeting"
 
-pluginIntegrationTestRunner({
+jest.setTimeout(120 * 1000)
+
+integrationTestRunner({
+  mode: "plugin",
+  http: true,
   pluginPath: process.cwd(),
-  pluginOptions: { apiKey: "test-key", debug: true },
-  testSuite: ({ container }) => {
-    it("should resolve typed plugin options", () => {
-      const options = plugin.resolveOptions(container)
-      expect(options.apiKey).toBe("test-key")
-      expect(options.debug).toBe(true)
+  pluginOptions: { apiKey: "test-api-key" },
+  testSuite: ({ api, container }) => {
+    let adminHeaders: Record<string, any>
+    let clientHeaders: Record<string, any>
+
+    beforeEach(async () => {
+      const userModule = container.resolve(Modules.USER)
+      const authModule = container.resolve(Modules.AUTH)
+      const apiKeyModule = container.resolve(Modules.API_KEY)
+
+      const user = await userModule.createUsers({
+        email: "admin@test.js",
+      })
+
+      const authIdentity = await authModule.createAuthIdentities({
+        provider_identities: [
+          { provider: "emailpass", entity_id: "admin@test.js" },
+        ],
+        app_metadata: { user_id: user.id },
+      })
+
+      const config = container.resolve(
+        ContainerRegistrationKeys.CONFIG_MODULE
+      )
+      const { jwtSecret, jwtOptions } = config.projectConfig.http
+
+      const token = generateJwtToken(
+        {
+          actor_id: user.id,
+          actor_type: "user",
+          auth_identity_id: authIdentity.id,
+          app_metadata: { user_id: user.id },
+        },
+        { secret: jwtSecret, expiresIn: "1d", jwtOptions }
+      )
+
+      adminHeaders = {
+        headers: { authorization: `Bearer ${token}` },
+      }
+
+      const apiKey = await apiKeyModule.createApiKeys({
+        title: "Test Client Key",
+        type: ApiKeyType.CLIENT,
+        created_by: "test",
+      })
+
+      clientHeaders = {
+        headers: { [CLIENT_API_KEY_HEADER]: apiKey.token },
+      }
+    })
+
+    describe("Admin plugin routes", () => {
+      it("POST /admin/plugin/greetings creates a greeting", async () => {
+        const response = await api.post(
+          "/admin/plugin/greetings",
+          { message: "Hello from HTTP" },
+          adminHeaders
+        )
+        expect(response.status).toEqual(200)
+        expect(response.data.greeting).toEqual(
+          expect.objectContaining({
+            id: expect.any(String),
+            message: "Hello from HTTP",
+          })
+        )
+      })
+
+      it("DELETE /admin/plugin/greetings/:id soft-deletes", async () => {
+        const created = await api.post(
+          "/admin/plugin/greetings",
+          { message: "Delete me" },
+          adminHeaders
+        )
+        const response = await api.delete(
+          `/admin/plugin/greetings/${created.data.greeting.id}`,
+          adminHeaders
+        )
+        expect(response.data).toEqual({
+          id: created.data.greeting.id,
+          object: "greeting",
+          deleted: true,
+        })
+      })
+    })
+
+    describe("Client plugin routes", () => {
+      it("GET /client/plugin/greetings with API key", async () => {
+        await api.post(
+          "/admin/plugin/greetings",
+          { message: "Public" },
+          adminHeaders
+        )
+        const response = await api.get(
+          "/client/plugin/greetings",
+          clientHeaders
+        )
+        expect(response.status).toEqual(200)
+        expect(response.data.greetings).toHaveLength(1)
+      })
+    })
+
+    describe("Auth enforcement", () => {
+      it("admin route rejects without JWT", async () => {
+        const error = await api
+          .get("/admin/plugin")
+          .catch((e: any) => e)
+        expect(error.response.status).toEqual(401)
+      })
     })
   },
 })
 ```
 
+### Plugin HTTP fixtures
+
+- `api` — axios instance pointed at `http://localhost:<port>`
+- `container` — proxy to the live container (includes all framework modules)
+- `dbConfig` — `{ schema, clientUrl, dbName }`
+
 ---
 
 ## Module Integration Tests
 
 ```typescript
-import { moduleIntegrationTestRunner } from "@acmekit/test-utils"
-import { MY_MODULE } from "../../src/modules/my-module"  // MY_MODULE = "my-module" — must match Module() key
+import { integrationTestRunner } from "@acmekit/test-utils"
 
 jest.setTimeout(30000)
 
-moduleIntegrationTestRunner<IMyModuleService>({
-  moduleName: MY_MODULE,  // must match the string passed to Module(), e.g., "my-module"
-  resolve: "./src/modules/my-module",  // path from CWD to module root (for model auto-discovery)
-  // moduleModels: [Post, Comment],  // OR pass models explicitly
-  // moduleOptions: { jwt_secret: "test" },
+integrationTestRunner<IGreetingModuleService>({
+  mode: "module",
+  moduleName: "greeting",
+  resolve: process.cwd() + "/src/modules/greeting",
   testSuite: ({ service }) => {
-    afterEach(() => {
-      jest.restoreAllMocks()
-    })
-
-    describe("createPosts", () => {
-      it("should create a post", async () => {
-        const result = await service.createPosts([
-          { title: "Quarterly Report" },
+    describe("createGreetings", () => {
+      it("should create a greeting", async () => {
+        const result = await service.createGreetings([
+          { message: "Hello" },
         ])
         expect(result).toHaveLength(1)
         expect(result[0]).toEqual(
           expect.objectContaining({
             id: expect.any(String),
-            title: "Quarterly Report",
+            message: "Hello",
           })
         )
       })
-
-      it("should throw on missing required field", async () => {
-        await expect(service.createPosts([{}])).rejects.toThrow()
-      })
     })
   },
 })
 ```
 
-### `SuiteOptions<TService>` fields
+### Module mode fixtures
 
 - `service` — proxy to the module service (auto-refreshed each `beforeEach`)
-- `MikroOrmWrapper` — raw DB access: `.getManager()`, `.forkManager()`, `.getOrm()`
+- `MikroOrmWrapper` — raw DB access
 - `acmekitApp` — proxy to the `AcmeKitApp` instance
 - `dbConfig` — `{ schema, clientUrl }`
 
-### CRUD test patterns
-
-```typescript
-// --- Create ---
-const [post] = await service.createPosts([{ title: "Test" }])
-
-// --- List with filters ---
-const filtered = await service.listPosts({ status: "published" })
-const withRelations = await service.listPosts({}, { relations: ["comments"] })
-
-// --- List and count ---
-const [posts, count] = await service.listAndCountPosts()
-expect(count).toEqual(2)
-
-// --- Retrieve ---
-const post = await service.retrievePost(id)
-
-// --- Retrieve with select (verify no extra fields) ---
-const withSelect = await service.retrievePost(id, { select: ["id"] })
-const serialized = JSON.parse(JSON.stringify(withSelect))
-expect(serialized).toEqual({ id })
-
-// --- Update ---
-const updated = await service.updatePosts(id, { title: "New Title" })
-
-// --- Soft delete / restore ---
-await service.softDeletePosts([id])
-const listed = await service.listPosts({ id })
-expect(listed).toHaveLength(0)
-await service.restorePosts([id])
-const restored = await service.listPosts({ id })
-expect(restored).toHaveLength(1)
-
-// --- Hard delete ---
-await service.deletePosts([id])
-```
-
-### Error handling in module tests
-
-```typescript
-// Style 1: .catch((e) => e) — preferred when checking message
-const error = await service.retrievePost("nonexistent").catch((e) => e)
-expect(error.message).toEqual("Post with id: nonexistent was not found")
-
-// Style 2: rejects.toThrow() — when only checking it throws
-await expect(service.createPosts([{}])).rejects.toThrow()
-
-// Style 3: check error.type
-let error
-try {
-  await service.deleteApiKeys([unrevokedKey.id])
-} catch (e) {
-  error = e
-}
-expect(error.type).toEqual("not_allowed")
-```
-
-### Related entity testing
+### Module test lifecycle
 
-```typescript
-const [category] = await service.createCategories([{ name: "Tech" }])
-const [post] = await service.createPosts([
-  { title: "Test", category_id: category.id },
-])
-
-const withRelation = await service.retrievePost(post.id, {
-  relations: ["category"],
-})
-expect(withRelation.category.name).toBe("Tech")
-```
+Each `it` block gets: schema drop + recreate → fresh module boot → test runs → schema clear → module shutdown. No manual cleanup needed.
 
 ---
 
-## Testing Workflows Through Container
+## Testing Workflows
 
-Workflows are tested by running them via `container` — NOT via HTTP:
+Workflows are called via `workflowFn(container).run({ input })`:
 
 ```typescript
-import { createOrderWorkflow } from "../../src/workflows"
+import { createGreetingsWorkflow } from "../../src/workflows"
 
-pluginIntegrationTestRunner({
+integrationTestRunner({
+  mode: "plugin",
   pluginPath: process.cwd(),
   testSuite: ({ container }) => {
-    it("should execute the create order workflow", async () => {
-      const { result } = await createOrderWorkflow(container).run({
-        input: {
-          customerId: "cus_123",
-          items: [{ sku: "SKU-001", qty: 2 }],
-        },
+    it("should create a greeting via workflow", async () => {
+      const { result } = await createGreetingsWorkflow(container).run({
+        input: { greetings: [{ message: "Workflow Hello" }] },
       })
-      expect(result.order).toEqual(
-        expect.objectContaining({ customerId: "cus_123" })
-      )
+      expect(result).toHaveLength(1)
+      expect(result[0].message).toBe("Workflow Hello")
     })
 
-    it("should reject invalid workflow input", async () => {
-      const { errors } = await createOrderWorkflow(container).run({
-        input: {},
+    it("should reject invalid input", async () => {
+      const { errors } = await createGreetingsWorkflow(container).run({
+        input: { greetings: [{ message: "", status: "invalid" }] },
         throwOnError: false,
       })
       expect(errors).toHaveLength(1)
+      expect(errors[0].error.message).toContain("Invalid")
     })
   },
 })
 ```
 
----
-
-## Asserting Domain Events
-
-Both runners inject `MockEventBusService` under `Modules.EVENT_BUS`. Spy on the **prototype**, not an instance.
+### Step compensation
 
 ```typescript
-import { MockEventBusService } from "@acmekit/test-utils"
-
-let eventBusSpy: jest.SpyInstance
-
-beforeEach(() => {
-  eventBusSpy = jest.spyOn(MockEventBusService.prototype, "emit")
-})
-
-afterEach(() => {
-  eventBusSpy.mockClear()
-})
-
-it("should emit blog-post.created event", async () => {
-  const service = container.resolve(BLOG_MODULE)  // "blog" — from Module() key
-  await service.createBlogPosts([{ title: "Event Test" }])
+it("should compensate on failure", async () => {
+  const service: any = container.resolve(GREETING_MODULE)
 
-  // Direct access to mock.calls for precise assertions
-  const events = eventBusSpy.mock.calls[0][0]  // first call, first arg = events array
-  expect(events).toHaveLength(1)
-  expect(events).toEqual(
-    expect.arrayContaining([
-      expect.objectContaining({
-        name: "blog-post.created",
-        data: expect.objectContaining({ id: expect.any(String) }),
-      }),
-    ])
-  )
+  const { errors } = await createGreetingsWorkflow(container).run({
+    input: { greetings: [{ message: "Will Fail", trigger_error: true }] },
+    throwOnError: false,
+  })
+  expect(errors).toHaveLength(1)
 
-  // Second argument is always { internal: true }
-  expect(eventBusSpy.mock.calls[0][1]).toEqual({ internal: true })
+  // Verify compensation ran — greeting rolled back
+  const greetings = await service.listGreetings()
+  expect(greetings).toHaveLength(0)
 })
 ```
 
 ---
 
-## Waiting for Subscribers
+## Testing Subscribers
+
+### Direct handler invocation (plugin mode — container-only)
 
-Use `waitSubscribersExecution` when testing subscriber side-effects. **CRITICAL: create the promise BEFORE triggering the event.**
+Import the handler and call it manually with `{ event, container }`:
 
 ```typescript
-import { TestEventUtils } from "@acmekit/test-utils"
-import { Modules } from "@acmekit/framework/utils"
+import { integrationTestRunner } from "@acmekit/test-utils"
+import greetingCreatedHandler from "../../src/subscribers/greeting-created"
+import { GREETING_MODULE } from "../../src/modules/greeting"
 
-it("should execute subscriber side-effect", async () => {
-  const eventBus = container.resolve(Modules.EVENT_BUS)
+jest.setTimeout(60 * 1000)
 
-  // Create promise BEFORE triggering event
-  const subscriberExecution = TestEventUtils.waitSubscribersExecution(
-    "blog-post.created",
-    eventBus
-  )
-  const service = container.resolve(BLOG_MODULE)  // "blog" — from Module() key
-  await service.createBlogPosts([{ title: "Trigger Event" }])
-  await subscriberExecution
-  // now assert subscriber side-effect
+integrationTestRunner({
+  mode: "plugin",
+  pluginPath: process.cwd(),
+  testSuite: ({ container }) => {
+    it("should append ' [notified]' to greeting message", async () => {
+      const service: any = container.resolve(GREETING_MODULE)
+      const [greeting] = await service.createGreetings([
+        { message: "Hello World" },
+      ])
+
+      await greetingCreatedHandler({
+        event: {
+          data: { id: greeting.id },
+          name: "greeting.created",
+        },
+        container,
+      })
+
+      const updated = await service.retrieveGreeting(greeting.id)
+      expect(updated.message).toBe("Hello World [notified]")
+    })
+  },
 })
 ```
 
----
+### Event bus driven (plugin HTTP mode or app mode)
 
-## Resolving Services in Tests
+Use `TestEventUtils.waitSubscribersExecution` with the real event bus:
 
 ```typescript
-// In pluginIntegrationTestRunner — use module constant (matches Module() key)
-import { BLOG_MODULE } from "../../src/modules/blog"  // BLOG_MODULE = "blog"
-const service = container.resolve(BLOG_MODULE)
-const query = container.resolve(ContainerRegistrationKeys.QUERY)
+import { integrationTestRunner, TestEventUtils } from "@acmekit/test-utils"
 
-// In moduleIntegrationTestRunner — use the service fixture directly
-const result = await service.listBlogPosts()
-
-// NEVER guess the key — "blogModuleService", "blog-module", "BlogModule" are all WRONG
-// The key is EXACTLY the string passed to Module() in your module definition
+// CRITICAL: create the promise BEFORE emitting the event
+const subscriberDone = TestEventUtils.waitSubscribersExecution(
+  "greeting.created",
+  eventBus
+)
+await eventBus.emit({ name: "greeting.created", data: { id } })
+await subscriberDone
 ```
 
 ---
 
-## JWT Token Generation
+## Testing Jobs
 
-**ALWAYS use `generateJwtToken` from `@acmekit/framework/utils`.** NEVER use `jsonwebtoken` directly or hardcode the JWT secret.
-
-This applies when testing your plugin mounted in a host application with `acmekitIntegrationTestRunner`.
+Import the job function directly and call with container:
 
 ```typescript
-import {
-  ContainerRegistrationKeys,
-  generateJwtToken,
-  Modules,
-} from "@acmekit/framework/utils"
+import { integrationTestRunner } from "@acmekit/test-utils"
+import cleanupGreetingsJob from "../../src/jobs/cleanup-greetings"
+import { GREETING_MODULE } from "../../src/modules/greeting"
 
-// Resolve the JWT secret from the project config — NEVER hardcode "supersecret"
-const config = container.resolve(ContainerRegistrationKeys.CONFIG_MODULE)
-const { jwtSecret, jwtOptions } = config.projectConfig.http
+jest.setTimeout(60 * 1000)
 
-const token = generateJwtToken(
-  {
-    actor_id: user.id,
-    actor_type: "user",           // or "customer" for customer auth
-    auth_identity_id: authIdentity.id,
-    app_metadata: { user_id: user.id },
-  },
-  { secret: jwtSecret, expiresIn: "1d", jwtOptions }
-)
-```
+integrationTestRunner({
+  mode: "plugin",
+  pluginPath: process.cwd(),
+  testSuite: ({ container }) => {
+    it("should soft-delete greetings with lang='old'", async () => {
+      const service: any = container.resolve(GREETING_MODULE)
 
----
+      await service.createGreetings([
+        { message: "Old 1", lang: "old" },
+        { message: "Old 2", lang: "old" },
+        { message: "Current", lang: "en" },
+      ])
 
-## Client API Key Generation
+      await cleanupGreetingsJob(container)
 
-**ALWAYS use `ApiKeyType.CLIENT` and `CLIENT_API_KEY_HEADER`.** NEVER use `type: "publishable"` or `"x-publishable-api-key"`.
+      const remaining = await service.listGreetings()
+      expect(remaining).toHaveLength(1)
+      expect(remaining[0].lang).toBe("en")
+    })
 
-```typescript
-import {
-  ApiKeyType,
-  CLIENT_API_KEY_HEADER,
-  Modules,
-} from "@acmekit/framework/utils"
+    it("should do nothing when no old greetings exist", async () => {
+      const service: any = container.resolve(GREETING_MODULE)
+      await service.createGreetings([{ message: "Hello", lang: "en" }])
 
-const apiKeyModule = container.resolve(Modules.API_KEY)
-const apiKey = await apiKeyModule.createApiKeys({
-  title: "Test Client Key",
-  type: ApiKeyType.CLIENT,
-  created_by: "system",
-})
+      await cleanupGreetingsJob(container)
 
-const clientHeaders = {
-  headers: { [CLIENT_API_KEY_HEADER]: apiKey.token },
-}
+      const remaining = await service.listGreetings()
+      expect(remaining).toHaveLength(1)
+    })
+  },
+})
 ```
 
 ---
 
-## Service Resolution
+## Asserting Domain Events
 
-**ALWAYS use `Modules.*` constants** to resolve core services. NEVER use string literals like `"auth"`, `"user"`, `"customer"`.
+Plugin mode (without HTTP) injects `MockEventBusService`. Spy on the **prototype**, not an instance.
 
 ```typescript
-// RIGHT
-const authModule = container.resolve(Modules.AUTH)
-const userModule = container.resolve(Modules.USER)
-const apiKeyModule = container.resolve(Modules.API_KEY)
+import { MockEventBusService } from "@acmekit/test-utils"
 
-// WRONG — string literals are fragile and may not match container keys
-const authModule = container.resolve("auth")        // ❌
-const userModule = container.resolve("user")        // ❌
-```
+it("should capture events", async () => {
+  const spy = jest.spyOn(MockEventBusService.prototype, "emit")
+  const eventBus = container.resolve(Modules.EVENT_BUS)
 
----
+  await eventBus.emit([
+    { name: "greeting.created", data: { id: "g1", message: "Hello" } },
+  ])
+
+  expect(spy).toHaveBeenCalledTimes(1)
+  expect(spy.mock.calls[0][0]).toEqual(
+    expect.arrayContaining([
+      expect.objectContaining({
+        name: "greeting.created",
+        data: expect.objectContaining({ id: "g1" }),
+      }),
+    ])
+  )
 
-## Environment
+  spy.mockRestore()
+})
+```
 
-- `jest.config.js` loads `.env.test` via `@acmekit/utils` `loadEnv("test", process.cwd())`
-- `integration-tests/setup.js` clears `MetadataStorage` between test files (prevents MikroORM entity bleed)
-- DB defaults: `DB_HOST=localhost`, `DB_USERNAME=postgres`, `DB_PASSWORD=""`, `DB_PORT=5432`
-- Each test run creates a unique DB: `acmekit-<module>-integration-<JEST_WORKER_ID>`
+**Note:** MockEventBusService `emit` takes an **array** of events. Real event bus `emit` takes a single `{ name, data }` object.
 
 ---
 
-## Anti-Patterns — NEVER Do These
+## Service Resolution
 
 ```typescript
-// WRONG — using acmekitIntegrationTestRunner in a plugin
-import { acmekitIntegrationTestRunner } from "@acmekit/test-utils"  // ❌
-// RIGHT — use pluginIntegrationTestRunner for plugin tests
-import { pluginIntegrationTestRunner } from "@acmekit/test-utils"
-
-// WRONG — trying to use `api` in plugin tests (no HTTP server!)
-testSuite: ({ api }) => { ... }  // ❌ api is not available
-// RIGHT — resolve services from container and call methods directly
-testSuite: ({ container }) => {
-  const service = container.resolve(BLOG_MODULE)
-  await service.createBlogPosts([{ title: "Test" }])
-}
-
-// WRONG — silently passes without asserting
-const result = await createWorkflow(container).run({ input: body })
-if (!result.result) return  // ❌ test passes with zero assertions!
-// RIGHT
-const { result } = await createWorkflow(container).run({ input: body })
-expect(result).toBeDefined()
+// Custom modules — use module constant
+import { GREETING_MODULE } from "../../src/modules/greeting"
+const service = container.resolve(GREETING_MODULE)
 
-// WRONG — using non-standard Jest matchers (not available without jest-extended)
-expect(value).toBeOneOf([expect.any(String), null])  // ❌
-expect(value).toSatisfy(fn)  // ❌
-// RIGHT
-expect(value === null || typeof value === "string").toBe(true)
+// Core modules — use Modules.* constants
+container.resolve(Modules.AUTH)
+container.resolve(Modules.USER)
 
-// WRONG — typeof checks on result fields
-expect(typeof result.id).toBe("string")  // ❌
-// RIGHT
-expect(result.id).toEqual(expect.any(String))
+// WRONG
+container.resolve("greetingModuleService")  // ❌
+container.resolve("auth")  // ❌
+```
 
-// WRONG — JSDoc comment block at file top (test files never have these)
-/** BlogModule — tests CRUD, validation, events */  // ❌
+---
 
-// WRONG — type casts in tests
-const filtered = (operations as Array<{ status: string }>).filter(...)  // ❌
+## Unit Tests (No Framework Bootstrap)
 
-// WRONG — vague range assertions
-expect(someStatus).toBeGreaterThanOrEqual(400)  // ❌
-// RIGHT
-expect(someStatus).toEqual("voided")
+For providers, utility functions, and standalone classes that don't need the database or AcmeKit container. Uses plain Jest — no `integrationTestRunner`.
 
-// WRONG — asserting exact objects (timestamps/IDs change)
-expect(result).toEqual({ id: "123", title: "Test", created_at: "..." })  // ❌
-// RIGHT
-expect(result).toEqual(expect.objectContaining({
-  id: expect.any(String),
-  title: "Test",
-}))
+**File naming:** `src/**/__tests__/<name>.unit.spec.ts` — matches `TEST_TYPE=unit` in `jest.config.js`.
 
-// WRONG — calling waitSubscribersExecution AFTER triggering event
-await service.createBlogPosts([{ title: "Test" }])
-await TestEventUtils.waitSubscribersExecution("blog-post.created", eventBus)  // ❌ may miss it
-// RIGHT — capture promise BEFORE triggering
-const execution = TestEventUtils.waitSubscribersExecution("blog-post.created", eventBus)
-await service.createBlogPosts([{ title: "Test" }])
-await execution
-
-// WRONG — putting test files in non-standard locations
-// integration-tests/tests/plugin.test.ts  ← won't be picked up
-// RIGHT
-// integration-tests/plugin/plugin.spec.ts
+### jest.mock Hoisting (Temporal Dead Zone)
 
-// WRONG — hardcoding pluginPath
-pluginIntegrationTestRunner({ pluginPath: "/absolute/path/to/plugin" })  // ❌
-// RIGHT
-pluginIntegrationTestRunner({ pluginPath: process.cwd() })
+`jest.mock()` factories are **hoisted above all `const`/`let` declarations** by SWC/Babel. Referencing a file-level `const` inside a `jest.mock()` factory causes `ReferenceError: Cannot access before initialization`.
 
-// WRONG — passing module object to resolve (type error: expects string)
-import MyModule from "../index"
-moduleIntegrationTestRunner({ resolve: MyModule, ... })  // ❌
+```typescript
+// WRONG — TDZ error: mockSign is not yet initialized when factory runs
+const mockSign = jest.fn()
+jest.mock("tronweb", () => ({
+  TronWeb: jest.fn().mockImplementation(() => ({ trx: { sign: mockSign } })),
+}))
 
-// WRONG — relative path from test file (model discovery uses CWD, not test file dir!)
-moduleIntegrationTestRunner({ resolve: "../index", ... })  // ❌ hangs — models not found
-// RIGHT — path from project root (CWD)
-moduleIntegrationTestRunner({ resolve: "./src/modules/my-module", ... })
+// RIGHT — create mocks INSIDE the factory, expose via module return
+jest.mock("tronweb", () => {
+  const mocks = {
+    sign: jest.fn(),
+    isAddress: jest.fn().mockReturnValue(true),
+  }
+  const MockTronWeb = jest.fn().mockImplementation(() => ({
+    trx: { sign: mocks.sign },
+  }))
+  MockTronWeb.isAddress = mocks.isAddress
+  return { TronWeb: MockTronWeb, __mocks: mocks }
+})
 
-// WRONG — unused imports
-import { ContainerRegistrationKeys } from "@acmekit/framework/utils"  // ❌ if never used
-// RIGHT — only import what you use
+// Access mocks after jest.mock via require()
+const { __mocks: tronMocks } = require("tronweb")
+```
 
-// WRONG — calling plugin.resolveOptions(container) in module loaders
-// Module container is scoped, not root — resolveOptions needs root container
-// RIGHT — only use plugin.resolveOptions(container) in tests, subscribers, and workflows
+**Rule:** All mock state must live INSIDE the `jest.mock()` factory or be accessed via `require()` after the mock is set up. Never reference file-level `const`/`let` from inside a `jest.mock()` factory.
 
-// WRONG — calling workflow without passing container
-await createOrderWorkflow.run({ input: { ... } })  // ❌
-// RIGHT
-await createOrderWorkflow(container).run({ input: { ... } })
-
-// WRONG — using jsonwebtoken directly or hardcoding JWT secrets
-import jwt from "jsonwebtoken"
-const token = jwt.sign({ user_id: user.id }, "supersecret")  // ❌
-// RIGHT — use generateJwtToken with config-resolved secret
-import { generateJwtToken, ContainerRegistrationKeys } from "@acmekit/framework/utils"
-const config = container.resolve(ContainerRegistrationKeys.CONFIG_MODULE)
-const token = generateJwtToken(payload, { secret: config.projectConfig.http.jwtSecret })
-
-// WRONG — using string "publishable" for API key type
-await apiKeyModule.createApiKeys({ type: "publishable" })  // ❌
-// RIGHT — use ApiKeyType.CLIENT enum
-import { ApiKeyType } from "@acmekit/framework/utils"
-await apiKeyModule.createApiKeys({ type: ApiKeyType.CLIENT })
-
-// WRONG — using old publishable header name
-headers: { "x-publishable-api-key": token }  // ❌
-// RIGHT — use CLIENT_API_KEY_HEADER constant
-import { CLIENT_API_KEY_HEADER } from "@acmekit/framework/utils"
-headers: { [CLIENT_API_KEY_HEADER]: token }
-
-// WRONG — resolving core services with string literals
-container.resolve("auth")  // ❌
-container.resolve("user")  // ❌
-// RIGHT — use Modules.* constants
-container.resolve(Modules.AUTH)
-container.resolve(Modules.USER)
+### Provider Unit Test Pattern
 
-// WRONG — using .rejects.toThrow() on workflow errors
-// The distributed transaction engine serializes errors into plain objects
-// (not Error instances), so .toThrow() never matches.
-await expect(
-  createOrderWorkflow(container).run({ input: {} })
-).rejects.toThrow()  // ❌ always fails — "Received function did not throw"
+Providers have a specific structure: constructor receives `(container, options)`, static `identifier`, optional static `validateOptions`. Test each part:
 
-// RIGHT — Option 1: use throwOnError: false + errors array (recommended)
-const { errors } = await createOrderWorkflow(container).run({
-  input: {},
-  throwOnError: false,
+```typescript
+jest.mock("external-sdk", () => {
+  const mocks = {
+    doThing: jest.fn(),
+  }
+  const MockClient = jest.fn().mockImplementation(() => ({
+    doThing: mocks.doThing,
+  }))
+  return { Client: MockClient, __mocks: mocks }
 })
-expect(errors).toHaveLength(1)
-expect(errors[0].error.message).toContain("customerId")
 
-// RIGHT — Option 2: use .rejects.toEqual() for plain object matching
-await expect(
-  createOrderWorkflow(container).run({ input: {} })
-).rejects.toEqual(
-  expect.objectContaining({
-    message: expect.stringContaining("customerId"),
-  })
-)
+const { __mocks: sdkMocks } = require("external-sdk")
 
-// NOTE: .rejects.toThrow() DOES work for service-level errors (e.g.,
-// service.retrievePost("bad-id")) because services throw real Error
-// instances. The serialization only happens in the workflow engine.
-```
+import MyProvider from "../my-provider"
 
----
+describe("MyProvider", () => {
+  let provider: MyProvider
 
-## Workflow Composition Testing
+  const mockContainer = {} as any
+  const defaultOptions = { apiKey: "test-key" }
 
-### Happy path + error inspection
+  beforeEach(() => {
+    jest.clearAllMocks()
+    provider = new MyProvider(mockContainer, defaultOptions)
+  })
 
-```typescript
-import { createOrderWorkflow } from "../../src/workflows"
+  describe("static identifier", () => {
+    it("should have correct identifier", () => {
+      expect(MyProvider.identifier).toBe("my-provider")
+    })
+  })
 
-pluginIntegrationTestRunner({
-  pluginPath: process.cwd(),
-  testSuite: ({ container }) => {
-    it("should execute the workflow", async () => {
-      const { result } = await createOrderWorkflow(container).run({
-        input: {
-          customerId: "cus_123",
-          items: [{ sku: "SKU-001", qty: 2 }],
-        },
-      })
-      expect(result.order).toEqual(
-        expect.objectContaining({ customerId: "cus_123" })
-      )
+  describe("validateOptions", () => {
+    it("should accept valid options", () => {
+      expect(() =>
+        MyProvider.validateOptions({ apiKey: "key" })
+      ).not.toThrow()
     })
 
-    it("should reject invalid input via inputSchema", async () => {
-      const { errors } = await createOrderWorkflow(container).run({
-        input: {},
-        throwOnError: false,
-      })
-      expect(errors).toHaveLength(1)
-      expect(errors[0].error.message).toContain("customerId")
+    it("should reject missing required option", () => {
+      expect(() => MyProvider.validateOptions({})).toThrow()
     })
-  },
+  })
+
+  describe("doSomething", () => {
+    it("should delegate to SDK", async () => {
+      sdkMocks.doThing.mockResolvedValue({ success: true })
+      const result = await provider.doSomething({ input: "test" })
+      expect(result.success).toBe(true)
+      expect(sdkMocks.doThing).toHaveBeenCalledWith(
+        expect.objectContaining({ input: "test" })
+      )
+    })
+  })
 })
 ```
 
-### Step compensation
+### Mock Cleanup Between Tests
 
-Test that compensation reverses side-effects when a later step fails:
+Mock state leaks between `describe` and `it` blocks. **Always add cleanup:**
 
 ```typescript
-it("should compensate on failure", async () => {
-  const service = container.resolve("orderModuleService")
-
-  // Run workflow that will fail at payment step
-  const { errors } = await createOrderWorkflow(container).run({
-    input: {
-      customerId: "cus_123",
-      items: [{ sku: "SKU-001", qty: 2 }],
-      paymentMethod: "invalid-method",  // triggers payment step failure
-    },
-    throwOnError: false,
+// Recommended: file-level cleanup
+beforeEach(() => {
+  jest.clearAllMocks()
+})
+
+// Alternative: per-describe when different describes need different setups
+describe("feature A", () => {
+  beforeEach(() => {
+    jest.clearAllMocks()
+    mockFn.mockResolvedValue("A result")
   })
+})
+```
 
-  expect(errors).toHaveLength(1)
+Without `jest.clearAllMocks()`, a mock called in one test still shows those calls in the next test:
 
-  // Verify compensation ran — order should not exist
-  const orders = await service.listOrders({ customerId: "cus_123" })
-  expect(orders).toHaveLength(0)
-})
+```typescript
+expect(mockSign).not.toHaveBeenCalled()  // FAILS — called by prior test
 ```
 
-### `when()` branches
+### Testing Code with Timers
+
+When code under test calls `setTimeout`, `setInterval`, or a `sleep()` function, tests time out or run slowly.
 
 ```typescript
-it("should skip notification when flag is false", async () => {
-  const eventBusSpy = jest.spyOn(MockEventBusService.prototype, "emit")
-
-  await createOrderWorkflow(container).run({
-    input: {
-      customerId: "cus_123",
-      items: [{ sku: "SKU-001", qty: 1 }],
-      sendNotification: false,
-    },
-  })
+// Option 1: Fake timers (for setTimeout/setInterval)
+beforeEach(() => {
+  jest.useFakeTimers()
+})
+afterEach(() => {
+  jest.useRealTimers()
+})
+it("should retry after delay", async () => {
+  const promise = provider.retryOperation()
+  await jest.advanceTimersByTimeAsync(3000)
+  const result = await promise
+  expect(result).toBeDefined()
+})
 
-  // No notification event emitted
-  const allEvents = eventBusSpy.mock.calls.flatMap((call) => call[0])
-  expect(allEvents).toEqual(
-    expect.not.arrayContaining([
-      expect.objectContaining({ name: "order.notification.sent" }),
-    ])
-  )
-  eventBusSpy.mockRestore()
+// Option 2: Mock the sleep method (for custom sleep/delay functions)
+it("should complete without waiting", async () => {
+  jest.spyOn(provider as any, "sleep_").mockResolvedValue(undefined)
+  const result = await provider.longRunningOperation()
+  expect(result).toBeDefined()
 })
 ```
 
-### `parallelize()` results
+### SWC Regex Limitation
+
+SWC's regex parser fails on certain complex regex literals. If you get a `Syntax Error` from SWC on a line with a regex:
 
 ```typescript
-it("should run parallel steps", async () => {
-  const { result } = await enrichOrderWorkflow(container).run({
-    input: { orderId: order.id },
-  })
+// WRONG — SWC may fail to parse this
+const pattern = /^(\*|[0-9]+)(\/[0-9]+)?$|^\*\/[0-9]+$/
 
-  // Both parallel branches produce results
-  expect(result.customerDetails).toBeDefined()
-  expect(result.inventoryCheck).toBeDefined()
-  expect(result.customerDetails.name).toBe("Jane Doe")
-  expect(result.inventoryCheck.available).toBe(true)
-})
+// RIGHT — use RegExp constructor
+const pattern = new RegExp("^(\\*|[0-9]+)(\\/[0-9]+)?$|^\\*\\/[0-9]+$")
 ```
 
-### `StepResponse.permanentFailure()` and `StepResponse.skip()`
+### Verifying Error Paths
 
-```typescript
-it("should permanently fail without compensation", async () => {
-  const { errors } = await validatePaymentWorkflow(container).run({
-    input: { paymentId: "fraudulent-id" },
-    throwOnError: false,
-  })
+When testing error cases, **read the implementation** to determine whether the method throws or returns an error object. Don't assume from the return type alone.
 
-  expect(errors).toHaveLength(1)
-  expect(errors[0].error.message).toContain("Fraudulent payment detected")
-  // permanentFailure skips compensation — verify no rollback happened
-})
+```typescript
+// If the method catches errors and returns { success: false }:
+const result = await provider.process(badInput)
+expect(result.success).toBe(false)
 
-it("should skip optional step", async () => {
-  const { result } = await processOrderWorkflow(container).run({
-    input: { orderId: order.id, skipLoyaltyPoints: true },
-  })
+// If the method throws (no internal try/catch on that path):
+await expect(provider.process(badInput)).rejects.toThrow("invalid")
 
-  // Workflow completes successfully, loyalty step was skipped
-  expect(result.order.status).toBe("processed")
-  expect(result.loyaltyPoints).toBeUndefined()
-})
+// If validation runs BEFORE a try/catch block:
+// validateInput() throws → not caught by the try/catch in process()
+await expect(provider.process(badInput)).rejects.toThrow("validation")
 ```
 
-### Workflow hooks
+**Tip:** Look for `try/catch` blocks in the implementation. Code that runs BEFORE or OUTSIDE a `try/catch` throws directly. Code INSIDE a `try/catch` may return an error result instead.
 
-```typescript
-it("should execute hook handler", async () => {
-  const hookResult: any[] = []
+---
 
-  const workflow = createOrderWorkflow(container)
-  workflow.hooks.orderCreated((input) => {
-    hookResult.push(input)
-  })
+## Testing Plugins with Dependencies
 
-  await workflow.run({
-    input: { customerId: "cus_123", items: [{ sku: "SKU-001", qty: 1 }] },
-  })
+When your plugin depends on other plugins (declared in `definePlugin({ dependencies })`), the test runner validates that all dependencies are installed. For workspace plugins that depend on other workspace plugins, use `skipDependencyValidation`:
 
-  expect(hookResult).toHaveLength(1)
-  expect(hookResult[0]).toEqual(
-    expect.objectContaining({ orderId: expect.any(String) })
-  )
+```typescript
+integrationTestRunner({
+  mode: "plugin",
+  pluginPath: process.cwd(),
+  skipDependencyValidation: true,
+  injectedDependencies: {
+    // Mock services your plugin expects from peer plugins
+    peerModuleService: { list: jest.fn().mockResolvedValue([]) },
+  },
+  testSuite: ({ container }) => { ... },
 })
 ```
 
----
-
-## Cross-Module Testing with additionalModules
+## Configuring Providers in Plugin Tests
 
-When a plugin workflow depends on another module (e.g., a payment module):
+Use `pluginModuleOptions` to pass per-module options (e.g., provider configuration) keyed by module name:
 
 ```typescript
-import { PaymentModule } from "@acmekit/payment"
-
-pluginIntegrationTestRunner({
+integrationTestRunner({
+  mode: "plugin",
   pluginPath: process.cwd(),
-  additionalModules: {
-    paymentModuleService: PaymentModule,
-  },
-  testSuite: ({ container }) => {
-    it("should process order with payment", async () => {
-      const { result } = await createOrderWorkflow(container).run({
-        input: {
-          customerId: "cus_123",
-          items: [{ sku: "SKU-001", qty: 2 }],
-          paymentMethod: "card",
+  pluginModuleOptions: {
+    tron: {
+      providers: [
+        {
+          resolve: "./src/providers/energy/own-pool",
+          id: "own-pool",
+          options: { apiKey: "test-key" },
         },
-      })
-      expect(result.payment).toEqual(
-        expect.objectContaining({ status: "captured" })
-      )
-    })
+      ],
+    },
   },
+  testSuite: ({ container }) => { ... },
 })
 ```
 
----
+`pluginModuleOptions` is merged into the discovered module config AFTER `pluginOptions`, so module-specific options override plugin-level ones.
 
-## Link / Relation Testing in Plugin Context
+---
 
-Test cross-module links via `container.resolve`:
+## Anti-Patterns — NEVER Do These
 
 ```typescript
-import { ContainerRegistrationKeys } from "@acmekit/framework/utils"
+// WRONG — using deprecated runner names
+import { pluginIntegrationTestRunner } from "@acmekit/test-utils"  // ❌
+import { moduleIntegrationTestRunner } from "@acmekit/test-utils"  // ❌
+// RIGHT — use unified runner with mode
+import { integrationTestRunner } from "@acmekit/test-utils"
+integrationTestRunner({ mode: "plugin", pluginPath: process.cwd(), ... })
+
+// WRONG — trying to use `api` in container-only plugin tests
+integrationTestRunner({
+  mode: "plugin",
+  pluginPath: process.cwd(),
+  testSuite: ({ api }) => {  // ❌ api is not available without http: true
+    await api.get("/admin/plugin")
+  },
+})
 
-it("should create and query a link", async () => {
-  const remoteLink = container.resolve(ContainerRegistrationKeys.LINK)
-  const query = container.resolve(ContainerRegistrationKeys.QUERY)
+// WRONG — hardcoding pluginPath
+integrationTestRunner({ mode: "plugin", pluginPath: "/absolute/path" })  // ❌
+// RIGHT
+integrationTestRunner({ mode: "plugin", pluginPath: process.cwd() })
 
-  const blogService = container.resolve(BLOG_MODULE)  // "blog" — from Module() key
-  const [post] = await blogService.createBlogPosts([{ title: "Linked Post" }])
-  const [category] = await blogService.createBlogCategories([{ name: "Tech" }])
+// WRONG — no auth in HTTP tests
+it("should list", async () => {
+  await api.get("/admin/plugin")  // ❌ 401
+})
 
-  await remoteLink.create([{
-    blogModuleService: { blog_post_id: post.id },
-    blogCategoryModuleService: { blog_category_id: category.id },
-  }])
+// WRONG — asserting error responses without catching (axios throws!)
+const response = await api.post("/admin/plugin/greetings", {}, adminHeaders)
+expect(response.status).toEqual(400)  // ❌ never reached
+// RIGHT
+const { response } = await api.post("/admin/plugin/greetings", {}, adminHeaders).catch((e: any) => e)
+expect(response.status).toEqual(400)
 
-  const { data: [linkedPost] } = await query.graph({
-    entity: "blog_post",
-    fields: ["id", "title", "category.*"],
-    filters: { id: post.id },
-  })
+// WRONG — calling workflow without passing container
+await createGreetingsWorkflow.run({ input: {} })  // ❌
+// RIGHT
+await createGreetingsWorkflow(container).run({ input: {} })
 
-  expect(linkedPost.category.name).toBe("Tech")
+// WRONG — using .rejects.toThrow() on workflow errors
+await expect(
+  createGreetingsWorkflow(container).run({ input: {} })
+).rejects.toThrow()  // ❌ plain object, not Error instance
+// RIGHT
+const { errors } = await createGreetingsWorkflow(container).run({
+  input: {},
+  throwOnError: false,
 })
-```
-
----
+expect(errors[0].error.message).toContain("message")
 
-## What to Test
+// WRONG — calling waitSubscribersExecution AFTER triggering event
+await eventBus.emit({ name: "greeting.created", data: { id } })
+await TestEventUtils.waitSubscribersExecution("greeting.created", eventBus)  // ❌
+// RIGHT — capture promise BEFORE
+const done = TestEventUtils.waitSubscribersExecution("greeting.created", eventBus)
+await eventBus.emit({ name: "greeting.created", data: { id } })
+await done
+
+// WRONG — exact object assertions (timestamps/IDs change)
+expect(result).toEqual({ id: "123", message: "Test" })  // ❌
+// RIGHT
+expect(result).toEqual(expect.objectContaining({
+  id: expect.any(String),
+  message: "Test",
+}))
 
-**Plugin loading:** Modules resolve from container, plugin options accessible via `plugin.resolveOptions(container)`, auto-discovered resources (subscribers, workflows, jobs) are loaded.
+// WRONG — non-standard Jest matchers
+expect(value).toBeOneOf([expect.any(String), null])  // ❌
+// RIGHT
+expect(value === null || typeof value === "string").toBe(true)
 
-**Module services:** CRUD operations (create, retrieve, list, update, softDelete, restore), custom methods, validation (required fields → `rejects.toThrow()`, not found → check error.message), related entities with `{ relations: [...] }`.
+// WRONG — resolve path as relative from test file
+integrationTestRunner({ mode: "module", moduleName: "greeting", resolve: "../index" })  // ❌
+// RIGHT
+integrationTestRunner({ mode: "module", moduleName: "greeting", resolve: process.cwd() + "/src/modules/greeting" })
 
-**Workflows:**
-- Happy path + correct result
-- `throwOnError: false` + `errors` array inspection
-- `inputSchema` rejection with specific error messages
-- Compensation on failure (verify side-effects rolled back)
-- `when()` branches (verify skipped/executed paths)
-- `parallelize()` results (verify both branches complete)
-- `StepResponse.permanentFailure()` (no compensation)
-- `StepResponse.skip()` (optional steps)
-- Hook handlers (`workflow.hooks.hookName(handler)`)
+// WRONG — using jsonwebtoken directly
+import jwt from "jsonwebtoken"  // ❌
+// RIGHT — use generateJwtToken from @acmekit/framework/utils
 
-**Subscribers/Events:** Spy on `MockEventBusService.prototype.emit`, access events via `mock.calls[0][0]`, use `TestEventUtils.waitSubscribersExecution` for async subscriber side-effects.
+// WRONG — using old publishable API key names
+{ type: "publishable" }  // ❌
+{ "x-publishable-api-key": token }  // ❌
+// RIGHT
+{ type: ApiKeyType.CLIENT }
+{ [CLIENT_API_KEY_HEADER]: token }
+
+// WRONG — unused imports, JSDoc blocks, type casts in tests
+
+// WRONG — referencing file-level const/let inside jest.mock factory (TDZ)
+const mockFn = jest.fn()
+jest.mock("lib", () => ({ thing: mockFn }))  // ❌ ReferenceError
+// RIGHT — create mocks inside factory, access via require()
+jest.mock("lib", () => {
+  const mocks = { thing: jest.fn() }
+  return { ...mocks, __mocks: mocks }
+})
+const { __mocks } = require("lib")
+
+// WRONG — no mock cleanup between tests
+describe("A", () => { it("calls mock", () => { mockFn() }) })
+describe("B", () => { it("mock is clean", () => {
+  expect(mockFn).not.toHaveBeenCalled()  // ❌ fails — leaked from A
+}) })
+// RIGHT — add beforeEach(() => jest.clearAllMocks())
+
+// WRONG — real timers in unit tests cause timeouts
+it("should process", async () => {
+  await relay.process(data)  // ❌ hangs — code calls sleep(3000) internally
+})
+// RIGHT — mock timers or sleep method
+jest.useFakeTimers()
+// or: jest.spyOn(relay as any, "sleep_").mockResolvedValue(undefined)
 
-**Links:** `remoteLink.create()` + `query.graph()` with related fields.
+// WRONG — complex regex literal that SWC can't parse
+const re = /^(\*|[0-9]+)(\/[0-9]+)?$/  // ❌ SWC Syntax Error
+// RIGHT
+const re = new RegExp("^(\\*|[0-9]+)(\\/[0-9]+)?$")
 
-**HTTP routes:** Cannot be tested with `pluginIntegrationTestRunner`. Mount the plugin in a host app and use `acmekitIntegrationTestRunner` there.
+// WRONG — assuming method returns error without reading implementation
+const result = await provider.process(bad)
+expect(result.success).toBe(false)  // ❌ actually throws
+// RIGHT — read implementation first to check if it throws or returns
+```