meocord 2.0.0 → 2.1.1

package/README.md

@@ -513,6 +513,29 @@ edited.delete  // → a mock fn
 expect(msg.delete).toHaveBeenCalledTimes(1)
 ```
 
+### `createMock`
+
+Mocks any type without a runtime class — use it for the services a controller depends on. `createMockInteraction` needs a class to build a prototype chain from, which is what makes `instanceof` and the real type guards work; a service double needs none of that, and an injected dependency may be an interface that does not exist at runtime at all.
+
+Every property is a mock fn, created on first access, so a double only declares what the test cares about. The result is assignable to `T`, so it goes straight into `useValue` with no cast — which matters because a class holding a `private` member (a logger, say) can never be satisfied by an object literal.
+
+```typescript
+import { createMock, MeoCordTestingModule } from 'meocord/testing'
+import { GreetingService } from '@src/services/greeting.service.js'
+
+const greetingService = createMock<GreetingService>()
+greetingService.buildGreeting.mockResolvedValue('Hello, Alice!')
+
+const module = MeoCordTestingModule.create({
+  controllers: [GreetingSlashController],
+  providers: [{ provide: GreetingService, useValue: greetingService }],
+}).compile()
+
+expect(greetingService.buildGreeting).toHaveBeenCalledWith('Alice')
+```
+
+Nested access works without declaring the shape first — `cache.store.flush()` is a mock fn on a mock fn. Properties passed as `createMock<T>({ ... })` are used exactly as given rather than wrapped, so call assertions do not apply to those.
+
 ### `overrideGuard`
 
 Replaces a guard class in the DI container with a stub. No guard dependencies need to be provided.

package/dist/cjs/testing/index.cjs

@@ -152,23 +152,16 @@ function isValueProvider(p) {
  * fn(2)                    // → 99
  * fn.mock.calls             // → [[2], [2]]
  */ function createMockFn(impl) {
+    // One persistent implementation and one queue of single-use ones, which is how
+    // jest and vitest model this. mockReturnValue, mockResolvedValue,
+    // mockRejectedValue and mockImplementation all write the same slot, so the last
+    // call wins; the four `*Once` variants all push onto the same queue, so they are
+    // consumed in the order they were declared regardless of which kind they are.
+    // Keeping a slot per kind instead gave a fixed precedence, where a stored
+    // resolved value beat a later mockRejectedValue and the override was silently
+    // dropped.
     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 onceQueue = [];
     let name = 'vi.fn';
     const calls = [];
     const results = [];
@@ -179,20 +172,8 @@ function isValueProvider(p) {
         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);
+            if (onceQueue.length > 0) {
+                value = onceQueue.shift().apply(this, args);
             } else if (currentImpl !== undefined) {
                 value = currentImpl.apply(this, args);
             } else {
@@ -234,36 +215,27 @@ function isValueProvider(p) {
         enumerable: false
     });
     mockFn.mockReturnValue = (v)=>{
-        returnValue = {
-            set: true,
-            value: v
-        };
+        currentImpl = ()=>v;
         return mockFn;
     };
     mockFn.mockReturnValueOnce = (v)=>{
-        returnOnce.push(v);
+        onceQueue.push(()=>v);
         return mockFn;
     };
     mockFn.mockResolvedValue = (v)=>{
-        resolvedValue = {
-            set: true,
-            value: v
-        };
+        currentImpl = ()=>Promise.resolve(v);
         return mockFn;
     };
     mockFn.mockResolvedValueOnce = (v)=>{
-        resolvedOnce.push(v);
+        onceQueue.push(()=>Promise.resolve(v));
         return mockFn;
     };
     mockFn.mockRejectedValue = (v)=>{
-        rejectedValue = {
-            set: true,
-            value: v
-        };
+        currentImpl = ()=>Promise.reject(v);
         return mockFn;
     };
     mockFn.mockRejectedValueOnce = (v)=>{
-        rejectedOnce.push(v);
+        onceQueue.push(()=>Promise.reject(v));
         return mockFn;
     };
     mockFn.mockImplementation = (fn)=>{
@@ -271,7 +243,7 @@ function isValueProvider(p) {
         return mockFn;
     };
     mockFn.mockImplementationOnce = (fn)=>{
-        implOnce.push(fn);
+        onceQueue.push(fn);
         return mockFn;
     };
     mockFn.mockClear = ()=>{
@@ -284,22 +256,7 @@ function isValueProvider(p) {
         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;
+        onceQueue = [];
         currentImpl = impl;
         return mockFn;
     };
@@ -582,6 +539,104 @@ function findPrototypeMethod(instance, name) {
     return stubDeep(instance, stubs);
 }
 // ---------------------------------------------------------------------------
+// createMock — class-free mock for services and interfaces
+// ---------------------------------------------------------------------------
+/**
+ * A mock fn that also answers property access with another one, so a nested call
+ * like `cache.store.flush()` works without declaring `store` up front.
+ *
+ * stubDeep cannot serve this: it decides between a mock fn and a nested object by
+ * looking up the prototype chain, and a service double has no prototype to read.
+ * Everything here is callable instead, which is the right default when the shape
+ * being mocked is an interface that erases at runtime.
+ */ function stubCallable() {
+    const fn = createMockFn();
+    const nested = new Map();
+    return new Proxy(fn, {
+        get (target, prop) {
+            if (typeof prop === 'symbol') return Reflect.get(target, prop, target);
+            const key = prop;
+            // Never thenable — otherwise awaiting a mock hangs on itself
+            if (key === 'then') return undefined;
+            // The mock's own API (`mock`, `mockReturnValue`, `_isMockFunction`, …) and
+            // the function intrinsics pass straight through.
+            if (key in target) return Reflect.get(target, prop, target);
+            if (!nested.has(key)) nested.set(key, stubCallable());
+            return nested.get(key);
+        },
+        set (target, prop, value) {
+            Object.defineProperty(target, prop, {
+                value,
+                writable: true,
+                enumerable: true,
+                configurable: true
+            });
+            return true;
+        }
+    });
+}
+/**
+ * Creates a mock of any type, with no runtime class required.
+ *
+ * `createMockInteraction` needs a class to build a prototype chain from, which is
+ * what makes `instanceof` and the real type guards work. A service double needs
+ * none of that, and frequently has no class to pass at all — an injected
+ * dependency may be an interface, which does not exist at runtime.
+ *
+ * Every property is a mock fn, created on first access and cached, so a double
+ * only has to declare what the test actually cares about. The result is assignable
+ * to `T`, so it can be handed to `useValue` or a constructor without a cast.
+ *
+ * Properties supplied through {@link MockProps} are used as given rather than
+ * wrapped, so call assertions do not apply to them.
+ *
+ * @example
+ * ```ts
+ * const notifications = createMock<NotificationService>()
+ * notifications.notify.mockResolvedValue('sent')
+ *
+ * const module = MeoCordTestingModule.create({
+ *   controllers: [AlertController],
+ *   providers: [{ provide: NotificationService, useValue: notifications }],
+ * }).compile()
+ *
+ * expect(notifications.notify).toHaveBeenCalledWith('hello')
+ * ```
+ */ function createMock(props) {
+    const target = {};
+    if (props !== undefined) {
+        for (const [key, value] of Object.entries(props)){
+            Object.defineProperty(target, key, {
+                value,
+                writable: true,
+                enumerable: true,
+                configurable: true
+            });
+        }
+    }
+    const stubs = new Map();
+    return new Proxy(target, {
+        get (instance, prop) {
+            if (typeof prop === 'symbol') return Reflect.get(instance, prop, instance);
+            const key = prop;
+            if (key === 'then') return undefined;
+            // An explicitly supplied prop wins over the auto-stub.
+            if (Object.prototype.hasOwnProperty.call(instance, key)) return Reflect.get(instance, prop, instance);
+            if (!stubs.has(key)) stubs.set(key, stubCallable());
+            return stubs.get(key);
+        },
+        set (instance, prop, value) {
+            Object.defineProperty(instance, prop, {
+                value,
+                writable: true,
+                enumerable: true,
+                configurable: true
+            });
+            return true;
+        }
+    });
+}
+// ---------------------------------------------------------------------------
 // Convenience wrappers for common discord.js classes
 // ---------------------------------------------------------------------------
 /** Creates a mock {@link User}. All methods are auto-stubbed as a mock fn. */ const createMockUser = ()=>createMockInteraction(discord_js.User);
@@ -793,6 +848,7 @@ exports.MeoCordTestingModule = MeoCordTestingModule;
 exports.TestingModule = TestingModule;
 exports.TestingModuleBuilder = TestingModuleBuilder;
 exports.createChatInputOptions = createChatInputOptions;
+exports.createMock = createMock;
 exports.createMockChannel = createMockChannel;
 exports.createMockClient = createMockClient;
 exports.createMockFn = createMockFn;

package/dist/esm/testing/index.js

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

package/dist/esm/testing/mock-fn.js

@@ -30,23 +30,16 @@
  * fn(2)                    // → 99
  * fn.mock.calls             // → [[2], [2]]
  */ function createMockFn(impl) {
+    // One persistent implementation and one queue of single-use ones, which is how
+    // jest and vitest model this. mockReturnValue, mockResolvedValue,
+    // mockRejectedValue and mockImplementation all write the same slot, so the last
+    // call wins; the four `*Once` variants all push onto the same queue, so they are
+    // consumed in the order they were declared regardless of which kind they are.
+    // Keeping a slot per kind instead gave a fixed precedence, where a stored
+    // resolved value beat a later mockRejectedValue and the override was silently
+    // dropped.
     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 onceQueue = [];
     let name = 'vi.fn';
     const calls = [];
     const results = [];
@@ -57,20 +50,8 @@
         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);
+            if (onceQueue.length > 0) {
+                value = onceQueue.shift().apply(this, args);
             } else if (currentImpl !== undefined) {
                 value = currentImpl.apply(this, args);
             } else {
@@ -112,36 +93,27 @@
         enumerable: false
     });
     mockFn.mockReturnValue = (v)=>{
-        returnValue = {
-            set: true,
-            value: v
-        };
+        currentImpl = ()=>v;
         return mockFn;
     };
     mockFn.mockReturnValueOnce = (v)=>{
-        returnOnce.push(v);
+        onceQueue.push(()=>v);
         return mockFn;
     };
     mockFn.mockResolvedValue = (v)=>{
-        resolvedValue = {
-            set: true,
-            value: v
-        };
+        currentImpl = ()=>Promise.resolve(v);
         return mockFn;
     };
     mockFn.mockResolvedValueOnce = (v)=>{
-        resolvedOnce.push(v);
+        onceQueue.push(()=>Promise.resolve(v));
         return mockFn;
     };
     mockFn.mockRejectedValue = (v)=>{
-        rejectedValue = {
-            set: true,
-            value: v
-        };
+        currentImpl = ()=>Promise.reject(v);
         return mockFn;
     };
     mockFn.mockRejectedValueOnce = (v)=>{
-        rejectedOnce.push(v);
+        onceQueue.push(()=>Promise.reject(v));
         return mockFn;
     };
     mockFn.mockImplementation = (fn)=>{
@@ -149,7 +121,7 @@
         return mockFn;
     };
     mockFn.mockImplementationOnce = (fn)=>{
-        implOnce.push(fn);
+        onceQueue.push(fn);
         return mockFn;
     };
     mockFn.mockClear = ()=>{
@@ -162,22 +134,7 @@
         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;
+        onceQueue = [];
         currentImpl = impl;
         return mockFn;
     };

package/dist/esm/testing/mock-interaction.js

@@ -269,6 +269,104 @@ function findPrototypeMethod(instance, name) {
     return stubDeep(instance, stubs);
 }
 // ---------------------------------------------------------------------------
+// createMock — class-free mock for services and interfaces
+// ---------------------------------------------------------------------------
+/**
+ * A mock fn that also answers property access with another one, so a nested call
+ * like `cache.store.flush()` works without declaring `store` up front.
+ *
+ * stubDeep cannot serve this: it decides between a mock fn and a nested object by
+ * looking up the prototype chain, and a service double has no prototype to read.
+ * Everything here is callable instead, which is the right default when the shape
+ * being mocked is an interface that erases at runtime.
+ */ function stubCallable() {
+    const fn = createMockFn();
+    const nested = new Map();
+    return new Proxy(fn, {
+        get (target, prop) {
+            if (typeof prop === 'symbol') return Reflect.get(target, prop, target);
+            const key = prop;
+            // Never thenable — otherwise awaiting a mock hangs on itself
+            if (key === 'then') return undefined;
+            // The mock's own API (`mock`, `mockReturnValue`, `_isMockFunction`, …) and
+            // the function intrinsics pass straight through.
+            if (key in target) return Reflect.get(target, prop, target);
+            if (!nested.has(key)) nested.set(key, stubCallable());
+            return nested.get(key);
+        },
+        set (target, prop, value) {
+            Object.defineProperty(target, prop, {
+                value,
+                writable: true,
+                enumerable: true,
+                configurable: true
+            });
+            return true;
+        }
+    });
+}
+/**
+ * Creates a mock of any type, with no runtime class required.
+ *
+ * `createMockInteraction` needs a class to build a prototype chain from, which is
+ * what makes `instanceof` and the real type guards work. A service double needs
+ * none of that, and frequently has no class to pass at all — an injected
+ * dependency may be an interface, which does not exist at runtime.
+ *
+ * Every property is a mock fn, created on first access and cached, so a double
+ * only has to declare what the test actually cares about. The result is assignable
+ * to `T`, so it can be handed to `useValue` or a constructor without a cast.
+ *
+ * Properties supplied through {@link MockProps} are used as given rather than
+ * wrapped, so call assertions do not apply to them.
+ *
+ * @example
+ * ```ts
+ * const notifications = createMock<NotificationService>()
+ * notifications.notify.mockResolvedValue('sent')
+ *
+ * const module = MeoCordTestingModule.create({
+ *   controllers: [AlertController],
+ *   providers: [{ provide: NotificationService, useValue: notifications }],
+ * }).compile()
+ *
+ * expect(notifications.notify).toHaveBeenCalledWith('hello')
+ * ```
+ */ function createMock(props) {
+    const target = {};
+    if (props !== undefined) {
+        for (const [key, value] of Object.entries(props)){
+            Object.defineProperty(target, key, {
+                value,
+                writable: true,
+                enumerable: true,
+                configurable: true
+            });
+        }
+    }
+    const stubs = new Map();
+    return new Proxy(target, {
+        get (instance, prop) {
+            if (typeof prop === 'symbol') return Reflect.get(instance, prop, instance);
+            const key = prop;
+            if (key === 'then') return undefined;
+            // An explicitly supplied prop wins over the auto-stub.
+            if (Object.prototype.hasOwnProperty.call(instance, key)) return Reflect.get(instance, prop, instance);
+            if (!stubs.has(key)) stubs.set(key, stubCallable());
+            return stubs.get(key);
+        },
+        set (instance, prop, value) {
+            Object.defineProperty(instance, prop, {
+                value,
+                writable: true,
+                enumerable: true,
+                configurable: true
+            });
+            return true;
+        }
+    });
+}
+// ---------------------------------------------------------------------------
 // Convenience wrappers for common discord.js classes
 // ---------------------------------------------------------------------------
 /** Creates a mock {@link User}. All methods are auto-stubbed as a mock fn. */ const createMockUser = ()=>createMockInteraction(User);
@@ -476,4 +574,4 @@ function createChatInputOptions(opts = {}) {
     return stubDeep(base);
 }
 
-export { createChatInputOptions, createMockChannel, createMockClient, createMockGuild, createMockInteraction, createMockMessage, createMockUser };
+export { createChatInputOptions, createMock, createMockChannel, createMockClient, createMockGuild, createMockInteraction, createMockMessage, createMockUser };

package/dist/types/testing/index.d.ts

@@ -212,6 +212,35 @@ interface InteractionClass<T> {
  * ```
  */
 declare function createMockInteraction<T extends object>(Class: InteractionClass<T>, props?: MockProps<T>): DeepMocked<T>;
+/**
+ * Creates a mock of any type, with no runtime class required.
+ *
+ * `createMockInteraction` needs a class to build a prototype chain from, which is
+ * what makes `instanceof` and the real type guards work. A service double needs
+ * none of that, and frequently has no class to pass at all — an injected
+ * dependency may be an interface, which does not exist at runtime.
+ *
+ * Every property is a mock fn, created on first access and cached, so a double
+ * only has to declare what the test actually cares about. The result is assignable
+ * to `T`, so it can be handed to `useValue` or a constructor without a cast.
+ *
+ * Properties supplied through {@link MockProps} are used as given rather than
+ * wrapped, so call assertions do not apply to them.
+ *
+ * @example
+ * ```ts
+ * const notifications = createMock<NotificationService>()
+ * notifications.notify.mockResolvedValue('sent')
+ *
+ * const module = MeoCordTestingModule.create({
+ *   controllers: [AlertController],
+ *   providers: [{ provide: NotificationService, useValue: notifications }],
+ * }).compile()
+ *
+ * expect(notifications.notify).toHaveBeenCalledWith('hello')
+ * ```
+ */
+declare function createMock<T extends object>(props?: MockProps<T>): DeepMocked<T>;
 /** Creates a mock {@link User}. All methods are auto-stubbed as a mock fn. */
 declare const createMockUser: () => DeepMocked<User>;
 /**
@@ -274,5 +303,5 @@ interface ChatInputOptions {
  */
 declare function createChatInputOptions<Cached extends CacheType = any>(opts?: ChatInputOptions): DeepMocked<CommandInteractionOptionResolver<Cached>>;
 
-export { MeoCordTestingModule, TestingModule, TestingModuleBuilder, createChatInputOptions, createMockChannel, createMockClient, createMockFn, createMockGuild, createMockInteraction, createMockMessage, createMockUser, isMockFunction };
+export { MeoCordTestingModule, TestingModule, TestingModuleBuilder, createChatInputOptions, createMock, createMockChannel, createMockClient, createMockFn, createMockGuild, createMockInteraction, createMockMessage, createMockUser, isMockFunction };
 export type { ChatInputOptions, ClassProvider, DeepMocked, Mock, MockInstance, MockProps, MockResult, MockState, MockedFunction, Provider, TestingModuleOptions, ValueProvider };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "meocord",
   "description": "Decorator-based Discord bot framework built on discord.js. Brings NestJS-style controllers, dependency injection, guards, and testing utilities to bot development — with a full CLI and TypeScript-first design.",
-  "version": "2.0.0",
+  "version": "2.1.1",
   "type": "module",
   "engines": {
     "node": ">=22"