meocord 1.8.3 → 1.8.4

package/README.md

@@ -124,7 +124,7 @@ export class App {}
 .
 ├── meocord.config.ts
 ├── eslint.config.ts
-├── jest.config.ts
+├── vitest.config.ts
 ├── tsconfig.json
 ├── tsconfig.eslint.json
 ├── tsconfig.test.json
@@ -337,7 +337,21 @@ async ban(interaction: ChatInputCommandInteraction) { ... }
 
 ## Testing
 
-MeoCord ships a `meocord/testing` entry point with utilities for testing controllers in isolation — no real Discord connection required.
+MeoCord ships a `meocord/testing` entry point with utilities for testing controllers in isolation — no real Discord connection required. The framework repo runs tests with [Vitest](https://vitest.dev/); the mocks themselves are **framework-agnostic** and work with Vitest or Jest assertions (see below).
+
+### Running tests
+
+From the MeoCord repo root:
+
+```shell
+bun run test              # run once
+bun run test:watch        # watch mode
+bun run test:coverage     # coverage report
+bun run test:typecheck    # tsc -p tsconfig.test.json
+bun run lint              # eslint --fix + tsc
+```
+
+In your own bot project, add Vitest (or keep Jest) plus a `vitest.config.ts` with SWC if you use decorator metadata — see this repo's config for reference. Generated apps include `*.spec.ts` stubs but not a test runner config yet.
 
 ### `MeoCordTestingModule`
 
@@ -360,9 +374,11 @@ const controller = module.get(GreetingSlashController)
 
 Creates a smart mock instance of any discord.js class. The full prototype chain is preserved so `instanceof` checks pass at every level.
 
-**Type guards run real logic** — `isButton()`, `isRepliable()`, `isChatInputCommand()`, etc. are backed by the actual discord.js prototype methods. The right fields (`type`, `componentType`, `commandType`) are set based on the class you pass in, so no manual `.mockReturnValue(true)` setup is needed. All type guard methods are still `jest.fn()` and can be overridden per test.
+**Type guards run real logic** — `isButton()`, `isRepliable()`, `isChatInputCommand()`, etc. are backed by the actual discord.js prototype methods. The right fields (`type`, `componentType`, `commandType`) are set based on the class you pass in, so no manual `.mockReturnValue(true)` setup is needed. All type guard methods are still mock functions and can be overridden per test.
+
+**Reply state machine** — for repliable interactions, `replied` and `deferred` start as `false`. Calling `reply()` or `deferReply()` twice throws, just like a real interaction. `followUp()`, `editReply()`, and `deleteReply()` throw if called before any reply. The ephemeral flag is tracked on `interaction.ephemeral`. All reply methods are still mock functions so call assertions work normally.
 
-**Reply state machine** — for repliable interactions, `replied` and `deferred` start as `false`. Calling `reply()` or `deferReply()` twice throws, just like a real interaction. `followUp()`, `editReply()`, and `deleteReply()` throw if called before any reply. The ephemeral flag is tracked on `interaction.ephemeral`. All reply methods are still `jest.fn()` so call assertions work normally.
+> **Framework-agnostic** — the mocks returned here are plain mock functions that stamp `_isMockFunction` and expose `.mock.calls`, the exact contract both `jest` and `vitest` check. Use them with either framework's `expect(...).toHaveBeenCalledWith(...)` / `toHaveBeenCalledTimes(...)` — no jest or vitest import is required to produce them. For typed stubs in your own code, import `MockedFunction`, `createMockFn`, and `DeepMocked` from `meocord/testing`.
 
 ```typescript
 import { createMockInteraction } from 'meocord/testing'
@@ -385,7 +401,7 @@ await interaction.reply({ content: 'hi' })
 interaction.replied   // → true
 await interaction.reply({ content: 'again' }) // → throws (already replied)
 
-// still jest.fn() — call assertions work normally
+// still a mock fn — call assertions work normally
 expect(interaction.reply).toHaveBeenCalledWith({ content: 'hi' })
 
 // direct property writes work normally
@@ -420,14 +436,20 @@ interaction.options.getString('duration')      // → null (wrong type)
 interaction.options.getNumber('x', true)       // → throws (absent + required)
 ```
 
-All methods are `jest.fn()` — override any per test with `.mockReturnValue()`.
+All methods are mock functions — override any per test with `.mockReturnValue()`.
 
 ### `createMockUser` / `createMockClient` / `createMockGuild` / `createMockChannel`
 
-Convenience wrappers for common discord.js classes. All methods are auto-stubbed as `jest.fn()`. Nested managers (`client.users`, `guild.members`, etc.) are independent nested stubs.
+Convenience wrappers for common discord.js classes. All methods are auto-stubbed as mock functions. Nested managers (`client.users`, `guild.members`, etc.) are independent nested stubs.
 
 ```typescript
-import { createMockUser, createMockClient, createMockGuild, createMockChannel } from 'meocord/testing'
+import {
+  createMockFn,
+  createMockUser,
+  createMockClient,
+  createMockGuild,
+  createMockChannel,
+} from 'meocord/testing'
 import { TextChannel } from 'discord.js'
 
 const user    = createMockUser()
@@ -435,15 +457,15 @@ const client  = createMockClient()
 const guild   = createMockGuild()
 const channel = createMockChannel(TextChannel)
 
-// override nested manager methods per test
-;(client.users as any).fetch = jest.fn(() => Promise.resolve(user))
+// override nested manager methods per test (createMockFn works with vitest and jest matchers)
+;(client.users as any).fetch = createMockFn(() => Promise.resolve(user))
 await (client.users as any).fetch('user-123')
 expect((client.users as any).fetch).toHaveBeenCalledWith('user-123')
 ```
 
 ### `createMockMessage`
 
-Creates a smart mock `Message`. Tracks a `deleted` boolean — `delete()`, `edit()`, `reply()`, `react()`, `pin()`, and `unpin()` throw if the message has already been deleted. `edit()` and `reply()` resolve to a new mock `Message` instance. All methods are `jest.fn()`.
+Creates a smart mock `Message`. Tracks a `deleted` boolean — `delete()`, `edit()`, `reply()`, `react()`, `pin()`, and `unpin()` throw if the message has already been deleted. `edit()` and `reply()` resolve to a new mock `Message` instance. All methods are mock functions.
 
 ```typescript
 import { createMockMessage } from 'meocord/testing'
@@ -458,9 +480,9 @@ await msg.edit({ content: 'x' }) // → throws (already deleted)
 
 // edit() and reply() resolve to a new Message mock
 const edited = await createMockMessage().edit({ content: 'updated' })
-edited.delete  // → jest.fn()
+edited.delete  // → a mock fn
 
-// still jest.fn() — assertions work
+// still a mock fn — assertions work
 expect(msg.delete).toHaveBeenCalledTimes(1)
 ```
 
@@ -483,8 +505,13 @@ const module = MeoCordTestingModule.create({
 ### Full example
 
 ```typescript
-import { jest } from '@jest/globals'
-import { MeoCordTestingModule, createMockInteraction, createChatInputOptions } from 'meocord/testing'
+import {
+  MeoCordTestingModule,
+  createMockFn,
+  createMockInteraction,
+  createChatInputOptions,
+  type MockedFunction,
+} from 'meocord/testing'
 import { ChatInputCommandInteraction } from 'discord.js'
 import { GreetingSlashController } from '@src/controllers/slash/greeting.slash.controller.js'
 import { GreetingService } from '@src/services/greeting.service.js'
@@ -492,10 +519,10 @@ import { RateLimiterGuard } from '@src/guards/rate-limiter.guard.js'
 
 describe('GreetingSlashController', () => {
   let controller: GreetingSlashController
-  let greetingService: { buildGreeting: jest.MockedFunction<GreetingService['buildGreeting']> }
+  let greetingService: { buildGreeting: MockedFunction<GreetingService['buildGreeting']> }
 
   beforeEach(() => {
-    greetingService = { buildGreeting: jest.fn() }
+    greetingService = { buildGreeting: createMockFn() }
 
     const module = MeoCordTestingModule.create({
       controllers: [GreetingSlashController],
@@ -508,7 +535,7 @@ describe('GreetingSlashController', () => {
   })
 
   it('replies with a greeting for the provided name', async () => {
-    jest.mocked(greetingService.buildGreeting).mockResolvedValue('Hello, Alice!')
+    greetingService.buildGreeting.mockResolvedValue('Hello, Alice!')
 
     const interaction = createMockInteraction(ChatInputCommandInteraction)
     interaction.options = createChatInputOptions({ name: 'Alice' })
@@ -563,9 +590,10 @@ npx meocord start --prod
 1. Fork the repository
 2. Create a feature branch: `git checkout -b feat/your-feature`
 3. Commit with conventional commits: `git commit -m "feat: add X"`
-4. Push and open a pull request against `main`
+4. Run `bun run lint` and `bun run test` before pushing
+5. Push and open a pull request against `main`
 
-Include a description of what changed and why, and add tests for any new behaviour.
+Include a description of what changed and why, and add tests for any new behaviour. Use `fix:` / `feat:` / `docs:` prefixes so [semantic-release](https://semantic-release.gitbook.io/) can version correctly — `test:` commits do not trigger a release.
 
 ---
 

package/dist/cjs/testing/index.cjs

@@ -3,7 +3,6 @@
 require('reflect-metadata');
 var inversify = require('inversify');
 var metadataKey_enum = require('../_shared/metadata-key.enum-BzzvGUId.cjs');
-var globals = require('@jest/globals');
 var discord_js = require('discord.js');
 
 function isValueProvider(p) {
@@ -98,10 +97,12 @@ function isValueProvider(p) {
  *
  * @example
  * ```typescript
+ * import { MeoCordTestingModule, createMockFn } from 'meocord/testing'
+ *
  * const module = MeoCordTestingModule.create({
  *   controllers: [PingController],
  *   providers: [
- *     { provide: PingService, useValue: { handlePing: jest.fn().mockResolvedValue('pong') } },
+ *     { provide: PingService, useValue: { handlePing: createMockFn().mockResolvedValue('pong') } },
  *   ],
  * }).compile()
  *
@@ -113,8 +114,203 @@ function isValueProvider(p) {
     }
 }
 
+/**
+ * MeoCord Framework
+ * Copyright (c) 2025 Ukasyah Rahmatullah Zada
+ * SPDX-License-Identifier: MIT
+ */ // ---------------------------------------------------------------------------
+// Framework-agnostic mock function
+//
+// A minimal mock-fn implementation used internally by the testing utilities so
+// that `meocord/testing` does not depend on jest OR vitest. Both jest and
+// vitest detect a mock via the `_isMockFunction` flag, and both
+// `expect(fn).toHaveBeenCalledWith(...)` / `toHaveBeenCalledTimes(...)` read
+// `fn.mock.calls` — so a mock produced here is recognized by assertions in
+// either framework.
+// ---------------------------------------------------------------------------
+/**
+ * Type guard that recognises mocks produced by `createMockFn` as well as
+ * native `jest.fn()` / `vi.fn()` mocks — all stamp `_isMockFunction = true`.
+ */ function isMockFunction(fn) {
+    return typeof fn === 'function' && '_isMockFunction' in fn && fn._isMockFunction === true;
+}
+/**
+ * Creates a framework-agnostic mock function. Callable; records calls on
+ * `.mock.calls`; supports the mock-return/resolved/rejected/implementation
+ * API used by the testing utilities and by user assertions.
+ *
+ * @example
+ * const fn = createMockFn<(x: number) => number>((x) => x + 1)
+ * fn(2)                    // → 3
+ * fn.mockReturnValue(99)
+ * fn(2)                    // → 99
+ * fn.mock.calls             // → [[2], [2]]
+ */ function createMockFn(impl) {
+    let currentImpl = impl;
+    let returnOnce = [];
+    let returnValue = {
+        set: false,
+        value: undefined
+    };
+    let resolvedOnce = [];
+    let resolvedValue = {
+        set: false,
+        value: undefined
+    };
+    let rejectedOnce = [];
+    let rejectedValue = {
+        set: false,
+        value: undefined
+    };
+    const implOnce = [];
+    let name = 'vi.fn';
+    const calls = [];
+    const results = [];
+    const instances = [];
+    const mockFn = function(...args) {
+        calls.push(args);
+        instances.push(this);
+        let type = 'return';
+        let value;
+        try {
+            if (implOnce.length > 0) {
+                value = implOnce.shift().apply(this, args);
+            } else if (returnOnce.length > 0) {
+                value = returnOnce.shift();
+            } else if (returnValue.set) {
+                value = returnValue.value;
+            } else if (resolvedOnce.length > 0) {
+                value = Promise.resolve(resolvedOnce.shift());
+            } else if (resolvedValue.set) {
+                value = Promise.resolve(resolvedValue.value);
+            } else if (rejectedOnce.length > 0) {
+                value = Promise.reject(rejectedOnce.shift());
+            } else if (rejectedValue.set) {
+                value = Promise.reject(rejectedValue.value);
+            } else if (currentImpl !== undefined) {
+                value = currentImpl.apply(this, args);
+            } else {
+                value = undefined;
+            }
+            return value;
+        } catch (err) {
+            type = 'throw';
+            value = err;
+            throw err;
+        } finally{
+            results.push({
+                type,
+                value
+            });
+        }
+    };
+    // Stamp the marker both jest and vitest check via isMockFunction.
+    Object.defineProperty(mockFn, '_isMockFunction', {
+        value: true,
+        enumerable: false
+    });
+    const mock = {
+        get calls () {
+            return calls;
+        },
+        get results () {
+            return results;
+        },
+        get instances () {
+            return instances;
+        },
+        get lastCall () {
+            return calls.length > 0 ? calls[calls.length - 1] : undefined;
+        }
+    };
+    Object.defineProperty(mockFn, 'mock', {
+        value: mock,
+        enumerable: false
+    });
+    mockFn.mockReturnValue = (v)=>{
+        returnValue = {
+            set: true,
+            value: v
+        };
+        return mockFn;
+    };
+    mockFn.mockReturnValueOnce = (v)=>{
+        returnOnce.push(v);
+        return mockFn;
+    };
+    mockFn.mockResolvedValue = (v)=>{
+        resolvedValue = {
+            set: true,
+            value: v
+        };
+        return mockFn;
+    };
+    mockFn.mockResolvedValueOnce = (v)=>{
+        resolvedOnce.push(v);
+        return mockFn;
+    };
+    mockFn.mockRejectedValue = (v)=>{
+        rejectedValue = {
+            set: true,
+            value: v
+        };
+        return mockFn;
+    };
+    mockFn.mockRejectedValueOnce = (v)=>{
+        rejectedOnce.push(v);
+        return mockFn;
+    };
+    mockFn.mockImplementation = (fn)=>{
+        currentImpl = fn;
+        return mockFn;
+    };
+    mockFn.mockImplementationOnce = (fn)=>{
+        implOnce.push(fn);
+        return mockFn;
+    };
+    mockFn.mockClear = ()=>{
+        calls.length = 0;
+        results.length = 0;
+        instances.length = 0;
+        return mockFn;
+    };
+    mockFn.mockReset = ()=>{
+        calls.length = 0;
+        results.length = 0;
+        instances.length = 0;
+        returnOnce = [];
+        returnValue = {
+            set: false,
+            value: undefined
+        };
+        resolvedOnce = [];
+        resolvedValue = {
+            set: false,
+            value: undefined
+        };
+        rejectedOnce = [];
+        rejectedValue = {
+            set: false,
+            value: undefined
+        };
+        implOnce.length = 0;
+        currentImpl = impl;
+        return mockFn;
+    };
+    mockFn.mockRestore = ()=>{
+        mockFn.mockReset();
+        return mockFn;
+    };
+    mockFn.getMockName = ()=>name;
+    mockFn.mockName = (n)=>{
+        name = n;
+        return mockFn;
+    };
+    return mockFn;
+}
+
 // ---------------------------------------------------------------------------
-// stubDeep — Proxy that auto-creates jest.fn() on any property access
+// stubDeep — Proxy that auto-creates a mock fn on any property access
 // ---------------------------------------------------------------------------
 const SKIP = new Set([
     'constructor',
@@ -132,7 +328,7 @@ function stubDeep(instance, externalStubs) {
                 return Reflect.get(target, prop, target);
             }
             const key = prop;
-            // 'then' must be undefined — prevents jest treating the mock as a Promise
+            // 'then' must be undefined — prevents frameworks treating the mock as a Promise
             if (key === 'then') return undefined;
             // Own property writes take precedence (e.g. interaction.guildId = 'abc')
             if (Object.prototype.hasOwnProperty.call(target, key)) {
@@ -155,7 +351,7 @@ function stubDeep(instance, externalStubs) {
                 }
                 proto = Object.getPrototypeOf(proto);
             }
-            const stub = typeof protoValue === 'function' ? globals.jest.fn() : stubDeep({});
+            const stub = typeof protoValue === 'function' ? createMockFn() : stubDeep({});
             stubs.set(key, stub);
             return stub;
         },
@@ -225,7 +421,7 @@ const CLASS_TYPE_FIELDS = {
     }
 };
 // All known pure type-guard methods on BaseInteraction and its subclasses.
-// These are wired as jest.fn() wrapping the real prototype logic so they return
+// These are wired as a mock fn wrapping the real prototype logic so they return
 // correct values by default and can still be overridden per test.
 const TYPE_GUARD_METHODS = [
     'isCommand',
@@ -265,14 +461,14 @@ function findPrototypeMethod(instance, name) {
  *
  * **Type guards** (`isButton()`, `isRepliable()`, etc.) run the real discord.js
  * prototype logic — no manual `.mockReturnValue(true)` setup needed. They are
- * still `jest.fn()` so you can override them per test.
+ * still mock functions so you can override them per test.
  *
  * **Reply state machine** — `replied` and `deferred` start as `false`. Calling
  * `reply()` or `deferReply()` twice throws, just like a real interaction would.
  * `followUp()`, `editReply()`, and `deleteReply()` throw if called before any
- * reply. These are still `jest.fn()` so call assertions work normally.
+ * reply. These are still mock functions so call assertions work normally.
  *
- * All other methods are auto-stubbed as `jest.fn()` via Proxy.
+ * All other methods are auto-stubbed as a mock fn via Proxy.
  *
  * @example
  * ```ts
@@ -295,12 +491,12 @@ function findPrototypeMethod(instance, name) {
             instance[key] = value;
         }
     }
-    // Wire each type guard as jest.fn() calling the real prototype implementation.
+    // Wire each type guard as a mock fn calling the real prototype implementation.
     // Correct by default; overridable per test via .mockReturnValue().
     for (const name of TYPE_GUARD_METHODS){
         const method = findPrototypeMethod(instance, name);
         if (method !== null) {
-            stubs.set(name, globals.jest.fn().mockImplementation(()=>method.call(instance)));
+            stubs.set(name, createMockFn().mockImplementation(()=>method.call(instance)));
         }
     }
     // Set up reply state machine for repliable interactions
@@ -320,36 +516,36 @@ function findPrototypeMethod(instance, name) {
             if (typeof flags === 'bigint') return (flags & 64n) !== 0n;
             return false;
         };
-        stubs.set('reply', globals.jest.fn(async (...args)=>{
+        stubs.set('reply', createMockFn(async (...args)=>{
             if (instance.deferred || instance.replied) throw alreadyReplied();
             instance.replied = true;
             if (hasEphemeralFlag(args[0])) instance.ephemeral = true;
         }));
-        stubs.set('deferReply', globals.jest.fn(async (...args)=>{
+        stubs.set('deferReply', createMockFn(async (...args)=>{
             if (instance.deferred || instance.replied) throw alreadyReplied();
             instance.deferred = true;
             if (hasEphemeralFlag(args[0])) instance.ephemeral = true;
         }));
-        stubs.set('followUp', globals.jest.fn(async ()=>{
+        stubs.set('followUp', createMockFn(async ()=>{
             if (!instance.deferred && !instance.replied) throw notYetReplied('followUp');
             instance.replied = true;
             return createMockMessage();
         }));
-        stubs.set('editReply', globals.jest.fn(async ()=>{
+        stubs.set('editReply', createMockFn(async ()=>{
             if (!instance.deferred && !instance.replied) throw notYetReplied('editReply');
             instance.replied = true;
             return createMockMessage();
         }));
-        stubs.set('deleteReply', globals.jest.fn(async ()=>{
+        stubs.set('deleteReply', createMockFn(async ()=>{
             if (!instance.deferred && !instance.replied) throw notYetReplied('deleteReply');
         }));
         // deferUpdate / update — MessageComponentInteraction only (type === MessageComponent)
         if (instance.type === discord_js.InteractionType.MessageComponent) {
-            stubs.set('update', globals.jest.fn(async ()=>{
+            stubs.set('update', createMockFn(async ()=>{
                 if (instance.deferred || instance.replied) throw alreadyReplied();
                 instance.replied = true;
             }));
-            stubs.set('deferUpdate', globals.jest.fn(async ()=>{
+            stubs.set('deferUpdate', createMockFn(async ()=>{
                 if (instance.deferred || instance.replied) throw alreadyReplied();
                 instance.deferred = true;
             }));
@@ -360,18 +556,18 @@ function findPrototypeMethod(instance, name) {
 // ---------------------------------------------------------------------------
 // Convenience wrappers for common discord.js classes
 // ---------------------------------------------------------------------------
-/** Creates a mock {@link User}. All methods are auto-stubbed as `jest.fn()`. */ const createMockUser = ()=>createMockInteraction(discord_js.User);
+/** Creates a mock {@link User}. All methods are auto-stubbed as a mock fn. */ const createMockUser = ()=>createMockInteraction(discord_js.User);
 /**
  * Creates a mock {@link Client}.
  *
  * Manager methods that are constructor-assigned (not on the prototype) are
- * pre-initialized as `jest.fn()` so they work out of the box without manual
+ * pre-initialized as a mock fn so they work out of the box without manual
  * setup: `users.fetch`, `channels.fetch`, `guilds.fetch`, and
  * `application.commands.fetch`.
  */ function createMockClient() {
     const instance = Object.create(discord_js.Client.prototype);
     // Manager properties are constructor-assigned — pre-initialize as prototype-based
-    // stubs so ALL manager methods (not just fetch) are auto-stubbed as jest.fn().
+    // stubs so ALL manager methods (not just fetch) are auto-stubbed as a mock fn.
     const appInstance = Object.create(null);
     appInstance.commands = stubDeep(Object.create(discord_js.ApplicationCommandManager.prototype));
     instance.users = stubDeep(Object.create(discord_js.UserManager.prototype));
@@ -386,7 +582,7 @@ function findPrototypeMethod(instance, name) {
  *
  * Manager properties are constructor-assigned in discord.js. This factory
  * pre-initializes each as a prototype-based stub so all methods are
- * auto-stubbed as `jest.fn()`.
+ * auto-stubbed as a mock fn.
  *
  * Pre-initialized: `members`, `channels`, `roles`, `bans`.
  */ function createMockGuild() {
@@ -402,7 +598,7 @@ function findPrototypeMethod(instance, name) {
  *
  * Manager properties that are constructor-assigned in discord.js are
  * pre-initialized as prototype-based stubs so all methods are auto-stubbed
- * as `jest.fn()`:
+ * as a mock fn:
  * - Guild text channels (`TextChannel`, `NewsChannel`): `messages`, `threads`
  * - `DMChannel`: `messages`
  * - `ThreadChannel`: `messages`, `members`
@@ -437,7 +633,7 @@ function findPrototypeMethod(instance, name) {
  * `msg.channel.send`, `msg.guild.members.fetch`, `msg.thread.fetch`,
  * and `msg.mentions.has` all work out of the box.
  *
- * All methods remain `jest.fn()` — overridable per test.
+ * All methods remain mock functions — overridable per test.
  *
  * Note: `createMockInteraction`'s `followUp()` and `editReply()` stubs return
  * a `createMockMessage()` by default, matching the official return types.
@@ -460,7 +656,7 @@ function createMockMessage() {
     // Constructor-assigned — set as prototype-based stubs
     instance.author = stubDeep(Object.create(discord_js.User.prototype));
     // Getters on the prototype — the proxy sees them as functions and returns
-    // jest.fn(), which is wrong. Pre-initialize as own properties to shadow
+    // a mock fn, which is wrong. Pre-initialize as own properties to shadow
     // the prototype getters.
     Object.defineProperty(instance, 'member', {
         value: stubDeep(Object.create(discord_js.GuildMember.prototype)),
@@ -481,25 +677,25 @@ function createMockMessage() {
     // MessageMentions — constructor-assigned, has methods like .has(), .members
     instance.mentions = stubDeep(Object.create(discord_js.MessageMentions.prototype));
     const alreadyDeleted = ()=>new Error('This message has already been deleted.');
-    stubs.set('delete', globals.jest.fn(async ()=>{
+    stubs.set('delete', createMockFn(async ()=>{
         if (instance.deleted) throw alreadyDeleted();
         instance.deleted = true;
     }));
-    stubs.set('edit', globals.jest.fn(async ()=>{
+    stubs.set('edit', createMockFn(async ()=>{
         if (instance.deleted) throw alreadyDeleted();
         return createMockMessage();
     }));
-    stubs.set('reply', globals.jest.fn(async ()=>{
+    stubs.set('reply', createMockFn(async ()=>{
         if (instance.deleted) throw alreadyDeleted();
         return createMockMessage();
     }));
-    stubs.set('react', globals.jest.fn(async ()=>{
+    stubs.set('react', createMockFn(async ()=>{
         if (instance.deleted) throw alreadyDeleted();
     }));
-    stubs.set('pin', globals.jest.fn(async ()=>{
+    stubs.set('pin', createMockFn(async ()=>{
         if (instance.deleted) throw alreadyDeleted();
     }));
-    stubs.set('unpin', globals.jest.fn(async ()=>{
+    stubs.set('unpin', createMockFn(async ()=>{
         if (instance.deleted) throw alreadyDeleted();
     }));
     return stubDeep(instance, stubs);
@@ -509,7 +705,7 @@ function createMockMessage() {
  * `CommandInteractionOptionResolver` works: declare what options the command
  * was invoked with, and the resolver finds them by name.
  *
- * All explicit methods are `jest.fn()` — override per test with `.mockReturnValue()`.
+ * All explicit methods are mock functions — override per test with `.mockReturnValue()`.
  * Methods not listed (e.g. `getAttachment`) are auto-stubbed by the Proxy.
  *
  * @example
@@ -541,20 +737,20 @@ function createMockMessage() {
     }
     const isObjectOption = (v)=>typeof v === 'object' && v !== null && 'id' in v;
     // Use a real prototype instance so unlisted methods (e.g. getAttachment)
-    // are found on the prototype chain and auto-stubbed as jest.fn()
+    // are found on the prototype chain and auto-stubbed as a mock fn
     const base = Object.create(discord_js.CommandInteractionOptionResolver.prototype);
-    base.getSubcommandGroup = globals.jest.fn((required)=>resolveSubEntry(subcommandGroup, 'subcommand group', required));
-    base.getSubcommand = globals.jest.fn((required)=>resolveSubEntry(subcommand, 'subcommand', required));
-    base.getString = globals.jest.fn((name, required)=>resolveOrThrow(name, typeof values[name] === 'string' ? values[name] : null, required));
-    base.getNumber = globals.jest.fn((name, required)=>resolveOrThrow(name, typeof values[name] === 'number' ? values[name] : null, required));
-    base.getInteger = globals.jest.fn((name, required)=>resolveOrThrow(name, typeof values[name] === 'number' ? values[name] : null, required));
-    base.getBoolean = globals.jest.fn((name, required)=>resolveOrThrow(name, typeof values[name] === 'boolean' ? values[name] : null, required));
+    base.getSubcommandGroup = createMockFn((required)=>resolveSubEntry(subcommandGroup, 'subcommand group', required));
+    base.getSubcommand = createMockFn((required)=>resolveSubEntry(subcommand, 'subcommand', required));
+    base.getString = createMockFn((name, required)=>resolveOrThrow(name, typeof values[name] === 'string' ? values[name] : null, required));
+    base.getNumber = createMockFn((name, required)=>resolveOrThrow(name, typeof values[name] === 'number' ? values[name] : null, required));
+    base.getInteger = createMockFn((name, required)=>resolveOrThrow(name, typeof values[name] === 'number' ? values[name] : null, required));
+    base.getBoolean = createMockFn((name, required)=>resolveOrThrow(name, typeof values[name] === 'boolean' ? values[name] : null, required));
     const getObjectOption = (name, required)=>resolveOrThrow(name, isObjectOption(values[name]) ? values[name] : null, required);
-    base.getUser = globals.jest.fn(getObjectOption);
-    base.getRole = globals.jest.fn(getObjectOption);
-    base.getChannel = globals.jest.fn(getObjectOption);
-    base.getMember = globals.jest.fn(getObjectOption);
-    base.getMentionable = globals.jest.fn(getObjectOption);
+    base.getUser = createMockFn(getObjectOption);
+    base.getRole = createMockFn(getObjectOption);
+    base.getChannel = createMockFn(getObjectOption);
+    base.getMember = createMockFn(getObjectOption);
+    base.getMentionable = createMockFn(getObjectOption);
     return stubDeep(base);
 }
 
@@ -564,7 +760,9 @@ exports.TestingModuleBuilder = TestingModuleBuilder;
 exports.createChatInputOptions = createChatInputOptions;
 exports.createMockChannel = createMockChannel;
 exports.createMockClient = createMockClient;
+exports.createMockFn = createMockFn;
 exports.createMockGuild = createMockGuild;
 exports.createMockInteraction = createMockInteraction;
 exports.createMockMessage = createMockMessage;
 exports.createMockUser = createMockUser;
+exports.isMockFunction = isMockFunction;

package/dist/esm/testing/index.js

@@ -1,2 +1,3 @@
 export { MeoCordTestingModule, TestingModule, TestingModuleBuilder } from './meocord-testing-module.js';
 export { createChatInputOptions, createMockChannel, createMockClient, createMockGuild, createMockInteraction, createMockMessage, createMockUser } from './mock-interaction.js';
+export { createMockFn, isMockFunction } from './mock-fn.js';

package/dist/esm/testing/meocord-testing-module.js

@@ -94,10 +94,12 @@ function isValueProvider(p) {
  *
  * @example
  * ```typescript
+ * import { MeoCordTestingModule, createMockFn } from 'meocord/testing'
+ *
  * const module = MeoCordTestingModule.create({
  *   controllers: [PingController],
  *   providers: [
- *     { provide: PingService, useValue: { handlePing: jest.fn().mockResolvedValue('pong') } },
+ *     { provide: PingService, useValue: { handlePing: createMockFn().mockResolvedValue('pong') } },
  *   ],
  * }).compile()
  *