meocord 2.0.0-beta.2 → 2.1.0

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

@@ -582,6 +582,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 +891,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-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-beta.2",
+  "version": "2.1.0",
   "type": "module",
   "engines": {
     "node": ">=22"