meocord 4.1.2 → 4.2.0

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

@@ -1,13 +1,14 @@
 import 'reflect-metadata';
 import { createMockFn } from './mock-fn.js';
-import { DataManager, RoleManager, Role, GuildChannel, GuildMember, User, BaseGuild, MessageMentions, Message, ThreadChannel, BaseGuildVoiceChannel, BaseChannel, MessageReaction, InteractionType, ComponentType, ApplicationCommandType, GuildMemberManager, GuildChannelManager, UserManager, ChannelManager, GuildManager, Guild, GuildBanManager, GuildBan, ThreadMemberManager, ThreadMember, GuildMessageManager, DMMessageManager, GuildTextThreadManager, GuildForumThreadManager, PermissionOverwriteManager, PermissionOverwrites, CommandInteractionOptionResolver, ApplicationCommandOptionType, Client, ApplicationCommandManager, ClientUser, CDN, AuthorizingIntegrationOwners, BaseInteraction, UserContextMenuCommandInteraction, Locale, StringSelectMenuInteraction, UserSelectMenuInteraction, RoleSelectMenuInteraction, ChannelSelectMenuInteraction, MentionableSelectMenuInteraction, Collection, MessageFlagsBitField, Base, SnowflakeUtil, DMChannel, GuildMemberRoleManager, TextChannel, Component, Embed, Attachment, BaseManager, ApplicationCommand, NewsChannel, ForumChannel, MediaChannel, DiscordjsErrorCodes, DiscordjsTypeError } from 'discord.js';
+import { DataManager, RoleManager, Role, GuildChannel, GuildMember, User, BaseGuild, MessageMentions, ThreadChannel, Message, BaseGuildVoiceChannel, VoiceChannel, BaseChannel, MessageReaction, InteractionType, ComponentType, ApplicationCommandType, GuildMemberManager, GuildChannelManager, UserManager, ChannelManager, GuildManager, Guild, GuildBanManager, GuildBan, ThreadMemberManager, ThreadMember, GuildMessageManager, DMMessageManager, GuildTextThreadManager, GuildForumThreadManager, PermissionOverwriteManager, PermissionOverwrites, CommandInteractionOptionResolver, ApplicationCommandOptionType, Client, ApplicationCommandManager, ClientUser, CDN, AuthorizingIntegrationOwners, BaseInteraction, UserContextMenuCommandInteraction, Locale, StringSelectMenuInteraction, UserSelectMenuInteraction, RoleSelectMenuInteraction, ChannelSelectMenuInteraction, MentionableSelectMenuInteraction, Collection, MessageFlagsBitField, PermissionsBitField, Base, SnowflakeUtil, DMChannel, GuildMemberRoleManager, TextChannel, Component, Embed, Attachment, BaseManager, ApplicationCommand, NewsChannel, ForumChannel, MediaChannel, DiscordjsErrorCodes, DiscordjsTypeError } from 'discord.js';
 import { createDiscordError } from './response.js';
 import { stampCall } from '../common/response/call-order.js';
 import { discordDefault, REAL_GETTER } from './discord-defaults.js';
 import { Logger } from '../common/logger.js';
-import { warnPlaceholder } from '../common/deprecation.js';
+import { warnOnce, warnPlaceholder } from '../common/deprecation.js';
 import { embedsAsDiscordStores, asDiscordStores } from './discord-shape.js';
 import { nextSnowflake, MOCK_BOT_ID } from './snowflake.js';
+import { noteMockMade, strictMocks } from './strict-mocks.js';
 
 // ---------------------------------------------------------------------------
 // stubDeep — Proxy that answers each property it lacks: a mock fn for a method, a default, or a nested stub
@@ -20,6 +21,7 @@ const SKIP = new Set([
     'then'
 ]);
 function stubDeep(instance, externalStubs, onSet) {
+    noteMockMade();
     const stubs = externalStubs ?? new Map();
     const proxy = new Proxy(instance, {
         get (target, prop) {
@@ -60,7 +62,11 @@ function stubDeep(instance, externalStubs, onSet) {
                 const desc = Object.getOwnPropertyDescriptor(proto, key);
                 if (desc !== undefined) {
                     protoValue = desc.value;
-                    if (desc.get && PLACEHOLDER_BOOLEANS.get(proto)?.has(key)) warnBooleanPlaceholder(target, key);
+                    if (desc.get && isPlaceholder(proto, key)) {
+                        // Strict mocks run discord.js's getter, read live; otherwise the placeholder, with a warning once
+                        if (strictMocks()) return Reflect.get(target, prop, proxy);
+                        warnBooleanPlaceholder(target, key);
+                    }
                     break;
                 }
                 proto = Object.getPrototypeOf(proto);
@@ -150,9 +156,18 @@ const REAL_METHODS = new Map([
         ])
     ]
 ]);
+// What strict mocks also run for real: a thread's permissions are its parent channel's, as discord.js reads them
+const STRICT_REAL_METHODS = new Map([
+    [
+        ThreadChannel.prototype,
+        new Set([
+            'permissionsFor'
+        ])
+    ]
+]);
 function isRealMethod(target, key) {
     for(let proto = Object.getPrototypeOf(target); proto !== null; proto = Object.getPrototypeOf(proto)){
-        if (REAL_METHODS.get(proto)?.has(key)) return true;
+        if (REAL_METHODS.get(proto)?.has(key) || strictMocks() && STRICT_REAL_METHODS.get(proto)?.has(key)) return true;
     }
     return false;
 }
@@ -212,6 +227,12 @@ const PLACEHOLDER_BOOLEANS = new Map([
             'joinable'
         ])
     ],
+    [
+        VoiceChannel.prototype,
+        new Set([
+            'speakable'
+        ])
+    ],
     [
         User.prototype,
         new Set([
@@ -231,11 +252,18 @@ const PLACEHOLDER_BOOLEANS = new Map([
         ])
     ]
 ]);
+/** Whether `proto`'s getter for `key` is one of those, or a subclass's override of one, such as a voice channel's `joinable`. */ function isPlaceholder(proto, key) {
+    for(; proto !== null; proto = Object.getPrototypeOf(proto)){
+        if (PLACEHOLDER_BOOLEANS.get(proto)?.has(key)) return true;
+    }
+    return false;
+}
 const mockLogger = new Logger('Mocks');
 function warnBooleanPlaceholder(target, key) {
     const name = Object.getPrototypeOf(target).constructor.name;
-    const variable = name.charAt(0).toLowerCase() + name.slice(1);
-    warnPlaceholder(mockLogger, `${name}.${key}`, 'the mock computes it as discord.js does', `Set it on the mock, such as ${variable}.${key} = false, to test either way.`);
+    // The class name in camel case, a leading acronym included: dmChannel, guildMember
+    const variable = name.replace(/^[A-Z]+(?=[A-Z][a-z])|^[A-Z]/, (start)=>start.toLowerCase());
+    warnPlaceholder(mockLogger, `${name}.${key}`, 'the mock computes it as discord.js does', `Set it on the mock, such as ${variable}.${key} = false, to test either way, or call useStrictMocks() to have the mock compute it now.`);
 }
 // The client of a structure made without one: the one its guild has, else one of its own, made once
 const ownClients = new WeakMap();
@@ -618,22 +646,13 @@ const isSnowflake = (id)=>typeof id === 'string' && /^\d{1,20}$/.test(id);
     }
 }
 /** Where a mock interaction keeps every answer it got, through respond() or discord.js directly, in order. */ const RESPONSE_LOG = Symbol('response log');
-const ANSWER_METHODS = [
-    'reply',
-    'deferReply',
-    'editReply',
-    'followUp',
-    'deleteReply',
-    'update',
-    'deferUpdate',
-    'showModal'
-];
 /**
- * `mock`, recording each call in `log` as it is made, with what it sent and, once it settles, what it rejected with.
- * `withResponse` is how a call asks discord.js for the message back, not part of what it sends, so it is left out.
- */ function recorded(method, mock, log) {
-    return new Proxy(mock, {
-        apply (target, self, args) {
+ * A mock of an answer method, `impl` its behaviour, that records each call in `log` as it is made, with what it sent
+ * and, once it settles, what it rejected with. The record wraps every behaviour the mock is given, its own and any a
+ * test sets, so the mock stays the plain mock function a runner's matchers read, bun's included. `withResponse` is how
+ * a call asks discord.js for the message back, not part of what it sends, so it is left out.
+ */ function recordedMock(method, impl, log) {
+    const record = (behaviour)=>function(...args) {
             const [payload] = args;
             const sent = payload && typeof payload === 'object' && 'withResponse' in payload ? Object.fromEntries(Object.entries(payload).filter(([key])=>key !== 'withResponse')) : payload;
             const call = {
@@ -643,7 +662,7 @@ const ANSWER_METHODS = [
             stampCall(call);
             log.push(call);
             try {
-                const result = Reflect.apply(target, self, args);
+                const result = Reflect.apply(behaviour, this, args);
                 // Recorded and passed on, so a rejection nobody awaits is unhandled in the test, as it is on a bot
                 if (result instanceof Promise) {
                     return result.then(undefined, (error)=>{
@@ -656,8 +675,38 @@ const ANSWER_METHODS = [
                 call.error = error;
                 throw error;
             }
-        }
-    });
+        };
+    const mock = createMockFn(record(impl));
+    const always = mock.mockImplementation.bind(mock);
+    const once = mock.mockImplementationOnce.bind(mock);
+    // Each way a test sets a behaviour goes through the record, a runner's own extras included where it has them
+    const setters = {
+        mockImplementation: (fn)=>fn,
+        mockReturnValue: (value)=>()=>value,
+        mockResolvedValue: (value)=>()=>Promise.resolve(value),
+        mockRejectedValue: (value)=>()=>Promise.reject(value)
+    };
+    // In place of the mock's own, keeping whether each is among its keys
+    const define = (name, value)=>Object.defineProperty(mock, name, {
+            value,
+            writable: true,
+            enumerable: Object.getOwnPropertyDescriptor(mock, name)?.enumerable ?? false,
+            configurable: true
+        });
+    for (const [name, behaviourOf] of Object.entries(setters)){
+        define(name, (value)=>(always(record(behaviourOf(value))), mock));
+        define(`${name}Once`, (value)=>(once(record(behaviourOf(value))), mock));
+    }
+    if (typeof mock.mockReturnThis === 'function') {
+        define('mockReturnThis', ()=>(always(record(function() {
+                return this;
+            })), mock));
+    }
+    const withImplementation = mock.withImplementation;
+    if (typeof withImplementation === 'function') {
+        define('withImplementation', (fn, callback)=>withImplementation.call(mock, record(fn), callback));
+    }
+    return mock;
 }
 /** The interaction a mock options resolver was given to, for the server a user option's member is in. */ const optionOwners = new WeakMap();
 /** An error as discord.js's options resolver throws it: a `TypeError` with discord.js's code and message. */ const optionError = (code, ...args)=>new DiscordjsTypeError(code, ...args);
@@ -716,21 +765,27 @@ function createMockInteraction(Class, props) {
             if (typeof flags === 'bigint') return (flags & 64n) !== 0n;
             return false;
         };
-        stubs.set('reply', createMockFn(async (...args)=>{
+        // Every answer the interaction gets, through respond() or discord.js directly, in order, for getResponse
+        const log = [];
+        Object.defineProperty(instance, RESPONSE_LOG, {
+            value: log
+        });
+        const answer = (method, impl)=>stubs.set(method, recordedMock(method, impl, log));
+        answer('reply', async (...args)=>{
             if (instance.deferred || instance.replied) throw alreadyReplied();
             instance.replied = true;
             if (hasEphemeralFlag(args[0])) instance.ephemeral = true;
-        }));
-        stubs.set('deferReply', createMockFn(async (...args)=>{
+        });
+        answer('deferReply', async (...args)=>{
             if (instance.deferred || instance.replied) throw alreadyReplied();
             instance.deferred = true;
             if (hasEphemeralFlag(args[0])) instance.ephemeral = true;
-        }));
-        stubs.set('followUp', createMockFn(async ()=>{
+        });
+        answer('followUp', async ()=>{
             if (!instance.deferred && !instance.replied) throw notYetReplied('followUp');
             instance.replied = true;
             return createMockMessage();
-        }));
+        });
         // The interaction's own message as Discord holds it: the message a component is on, or the original response.
         // An edit replaces it in the shape Discord stores, with ids and resolved media, stamped with when it was edited,
         // and fetchReply() reads that back, so code comparing the two sees what it would against Discord.
@@ -739,7 +794,7 @@ function createMockInteraction(Class, props) {
         // A command answered with a modal has no original response, and Discord refuses one asked for
         let modalAnswered = false;
         const unknownMessage = ()=>createDiscordError(10008, 'Unknown Message');
-        stubs.set('editReply', createMockFn(async (options)=>{
+        answer('editReply', async (options)=>{
             if (!instance.deferred && !instance.replied) throw notYetReplied('editReply');
             if (modalAnswered) throw unknownMessage();
             instance.replied = true;
@@ -749,42 +804,33 @@ function createMockInteraction(Class, props) {
                 ...held,
                 components: held.returned ?? held.components
             });
-        }));
+        });
         stubs.set('fetchReply', createMockFn(async ()=>{
             if (modalAnswered) throw unknownMessage();
             return messageFrom(current());
         }));
-        stubs.set('deleteReply', createMockFn(async ()=>{
+        answer('deleteReply', async ()=>{
             if (!instance.deferred && !instance.replied) throw notYetReplied('deleteReply');
             if (modalAnswered) throw unknownMessage();
-        }));
+        });
         // showModal — the first response of a command or a component, like reply()
         if (instance.type === InteractionType.ApplicationCommand || instance.type === InteractionType.MessageComponent) {
-            stubs.set('showModal', createMockFn(async ()=>{
+            answer('showModal', async ()=>{
                 if (instance.deferred || instance.replied) throw alreadyReplied();
                 instance.replied = true;
                 modalAnswered = instance.type === InteractionType.ApplicationCommand;
-            }));
+            });
         }
         // deferUpdate / update — components, and modals submitted from a message's component
         if (instance.type === InteractionType.MessageComponent || instance.type === InteractionType.ModalSubmit) {
-            stubs.set('update', createMockFn(async ()=>{
+            answer('update', async ()=>{
                 if (instance.deferred || instance.replied) throw alreadyReplied();
                 instance.replied = true;
-            }));
-            stubs.set('deferUpdate', createMockFn(async ()=>{
+            });
+            answer('deferUpdate', async ()=>{
                 if (instance.deferred || instance.replied) throw alreadyReplied();
                 instance.deferred = true;
-            }));
-        }
-        // Every answer the interaction gets, through respond() or discord.js directly, in order, for getResponse
-        const log = [];
-        Object.defineProperty(instance, RESPONSE_LOG, {
-            value: log
-        });
-        for (const method of ANSWER_METHODS){
-            const stub = stubs.get(method);
-            if (stub) stubs.set(method, recorded(method, stub, log));
+            });
         }
     }
     // Autocomplete is not repliable, but it has a response of its own: Discord accepts
@@ -823,6 +869,43 @@ function createMockInteraction(Class, props) {
         const unset = (key)=>!Object.prototype.hasOwnProperty.call(instance, key);
         const generatedId = unset('id') ? instance.id = nextSnowflake() : undefined;
         defineCreatedTime(instance, generatedId);
+        // A raw member is from a server the bot isn't in: no cached guild, and its user the interaction's, as discord.js reads it
+        const raw = own('member');
+        // Given with a guild, a raw-shaped member is kept as the cached server's member it was before raw members
+        if (isRawMember(raw) && own('guild')) {
+            warnOnce(mockLogger, "The member given is a raw member, from a server the bot isn't in, but the mock was given a guild, so it reads as a " + 'cached server: leave the guild out for a raw member, or give a GuildMember.');
+        } else if (isRawMember(raw)) {
+            const rawOnly = "The member given is a raw member, from a server the bot isn't in";
+            if (!own('guildId')) throw new Error(`${rawOnly}, so the mock needs that server's guildId.`);
+            if (own('channel') !== undefined) throw new Error(`${rawOnly}, where discord.js caches no channel, but the mock was given a channel: leave the channel out.`);
+            const givenUser = own('user');
+            if (givenUser && givenUser.id !== raw.user.id) {
+                throw new Error(`The member given is user ${raw.user.id}'s, but the mock's user is ${givenUser.id}: give the same user, or leave one of them out.`);
+            }
+            if (!givenUser) {
+                const { id, username, global_name: globalName, discriminator, avatar } = raw.user;
+                instance.user = createMockUser({
+                    id,
+                    username,
+                    globalName: globalName ?? null,
+                    discriminator,
+                    avatar: avatar ?? null
+                });
+            }
+            Object.defineProperty(instance, 'guild', {
+                value: null,
+                writable: true,
+                enumerable: true,
+                configurable: true
+            });
+            // Only its channelId: discord.js caches no channel from a server the bot isn't in
+            Object.defineProperty(instance, 'channel', {
+                value: null,
+                writable: true,
+                enumerable: true,
+                configurable: true
+            });
+        }
         const userGiven = !unset('user');
         if (!userGiven) instance.user = mockUser();
         // Assigned once by discord.js's Base constructor, as on a message, and the gateway caches the user on it
@@ -965,29 +1048,25 @@ function createMockInteraction(Class, props) {
  * on a double whose shape is an interface with nothing at runtime to read it from.
  */ 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;
+    // Any property beyond the mock's own API is a nested mock, made on first read and kept on the function, out of its
+    // keys. Its prototype makes them rather than a Proxy around it, so it stays the plain mock function matchers read
+    const inherited = Object.getPrototypeOf(fn);
+    Object.setPrototypeOf(fn, new Proxy(inherited, {
+        get (proto, prop, receiver) {
+            if (typeof prop === 'symbol' || prop in proto) return Reflect.get(proto, prop, receiver);
             // 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,
+            if (prop === 'then') return undefined;
+            const nested = stubCallable();
+            Object.defineProperty(receiver, prop, {
+                value: nested,
                 writable: true,
-                enumerable: true,
+                enumerable: false,
                 configurable: true
             });
-            return true;
+            return nested;
         }
-    });
+    }));
+    return fn;
 }
 /**
  * Creates a mock of any type, with no class needed, for service doubles and interfaces.
@@ -1463,10 +1542,16 @@ const CHANNEL_TYPE_GUARDS = [
     });
     return stubDeep(manager);
 }
-/** A server's @everyone role, which has the server's id and ranks lowest, at position 0. */ const everyoneRole = (guildId)=>createMockInteraction(Role, {
+/** The permissions Discord gives a server's @everyone role in a server made today. */ const NEW_SERVER_EVERYONE_PERMISSIONS = 2248473465835073n;
+// A server's @everyone role, which has the server's id and ranks lowest, at position 0; with strict mocks, the
+// permissions Discord gives it in a new server
+const everyoneRole = (guildId)=>createMockInteraction(Role, {
         id: guildId,
         name: '@everyone',
-        position: 0
+        position: 0,
+        ...strictMocks() ? {
+            permissions: new PermissionsBitField(NEW_SERVER_EVERYONE_PERMISSIONS).freeze()
+        } : {}
     });
 /**
  * A guild's role manager with `roles` in its cache, and the guild's @everyone role: the one given with the guild's id,
@@ -1494,6 +1579,68 @@ const CHANNEL_TYPE_GUARDS = [
     });
     return manager;
 }
+/**
+ * Creates the member Discord sends with an interaction from a server the bot isn't in, as discord.js keeps it.
+ *
+ * Give it as an interaction's `member`, with the server's `guildId` and no `guild`, to test a user-installed command
+ * run there: the interaction reads `inRawGuild()` true, `guild` and `channel` null, `user` the member's user and
+ * `memberPermissions` the member's, and a user option's member is the plain member Discord resolves too.
+ *
+ * @remarks
+ * It is plain data, not a `GuildMember`: `roles` are role ids, `permissions` is the permission bitfield as a string,
+ * and the rest are as Discord sends them, `null` for what may be absent and `false` for a flag. Code that reads
+ * `member.roles.cache` throws on it, as it does in Discord.
+ *
+ * @param overrides - Fields for the member; see {@link MockRawMemberOverrides}.
+ * @returns The member, as an `APIInteractionGuildMember`.
+ *
+ * @example
+ * ```ts
+ * import { expect } from 'vitest'
+ *
+ * const member = createMockRawMember({ roles: ['300000000000000001'], permissions: [PermissionFlagsBits.SendMessages] })
+ * const command = createMockInteraction(ChatInputCommandInteraction, { guildId: '100000000000000001', member })
+ * expect(command.inRawGuild()).toBe(true)
+ * ```
+ *
+ * @group Testing
+ * @category Mocks
+ * @see {@link createMockMember}
+ */ function createMockRawMember(overrides = {}) {
+    const { permissions, user, ...given } = overrides;
+    return {
+        user: {
+            id: nextSnowflake(),
+            username: 'user',
+            discriminator: '0',
+            global_name: null,
+            avatar: null,
+            ...user
+        },
+        roles: [],
+        nick: null,
+        avatar: null,
+        banner: null,
+        premium_since: null,
+        communication_disabled_until: null,
+        joined_at: new Date().toISOString(),
+        deaf: false,
+        mute: false,
+        pending: false,
+        flags: 0,
+        ...given,
+        permissions: String(new PermissionsBitField(permissions ?? NEW_SERVER_EVERYONE_PERMISSIONS).bitfield)
+    };
+}
+/** Whether `value` is a member Discord sends from a server the bot isn't in: plain data, not a `GuildMember`. */ function isRawMember(value) {
+    if (typeof value !== 'object' || value === null || value instanceof GuildMember) return false;
+    const { roles, permissions, user } = value;
+    return Array.isArray(roles) && typeof permissions === 'string' && typeof user === 'object' && user !== null;
+}
+/** A user option's member as Discord resolves it with an interaction from a server the bot isn't in. */ function rawResolvedMember() {
+    const { user: _user, deaf: _deaf, mute: _mute, ...resolved } = createMockRawMember();
+    return resolved;
+}
 /**
  * Creates a mock {@link GuildMember}: a user in a server, with the roles given.
  *
@@ -1644,6 +1791,8 @@ const CHANNEL_TYPE_GUARDS = [
             if (!Object.prototype.hasOwnProperty.call(item, 'guild')) item.guild = guild;
         }
     }
+    // Strict mocks cache the bot's member from the start, as the gateway does when the bot joins, so lookups find it
+    if (strictMocks()) void members.me;
 }
 /** The ids each kind of mention in `content` names, in order and once each. */ function mentionedIds(content) {
     const ids = (pattern)=>[
@@ -1866,7 +2015,8 @@ const CHANNEL_TYPE_GUARDS = [
         get: ()=>{
             const found = cacheOf(instance.channel.threads)?.get(instance.id);
             if (found) return found;
-            warnPlaceholder(mockLogger, 'Message.thread', 'it is null unless the channel caches a thread under the message id, as discord.js reads it', 'Cache one with message.channel.threads.cache.set(message.id, thread).');
+            if (strictMocks()) return null;
+            warnPlaceholder(mockLogger, 'Message.thread', 'it is null unless the channel caches a thread under the message id, as discord.js reads it', 'Cache one with message.channel.threads.cache.set(message.id, thread), or call useStrictMocks() to have it read null now.');
             return placeholderThread ?? (placeholderThread = stubDeep(Object.create(ThreadChannel.prototype)));
         },
         set: (value)=>Object.defineProperty(instance, 'thread', {
@@ -2135,7 +2285,8 @@ const CHANNEL_TYPE_GUARDS = [
             if (!unowned.has(name)) unowned.set(name, memberIn(undefined, user.id, user));
             return unowned.get(name);
         }
-        if (!members.has(name)) members.set(name, owner.guildId ? memberFor(owner.guild, user, true) : null);
+        const rawOwner = !owner.guild && isRawMember(Object.getOwnPropertyDescriptor(owner, 'member')?.value);
+        if (!members.has(name)) members.set(name, owner.guildId ? rawOwner ? rawResolvedMember() : memberFor(owner.guild, user, true) : null);
         return members.get(name) ?? null;
     };
     base.getUser = createMockFn((name, required)=>{
@@ -2194,4 +2345,4 @@ const CHANNEL_TYPE_GUARDS = [
     return resolver;
 }
 
-export { RESPONSE_LOG, createChatInputOptions, createMock, createMockChannel, createMockClient, createMockGuild, createMockInteraction, createMockMember, createMockMessage, createMockUser, memberRoles };
+export { RESPONSE_LOG, createChatInputOptions, createMock, createMockChannel, createMockClient, createMockGuild, createMockInteraction, createMockMember, createMockMessage, createMockRawMember, createMockUser, isRawMember, memberRoles };

package/dist/esm/testing/response.js

@@ -42,7 +42,7 @@ const VISIBLE = new Set([
  * @group Testing
  * @category Inspection
  * @see {@link TestingModule}
- * @see {@link https://meocord.dev/docs/4.1/invoke-and-dispatch | Invoke and dispatch}
+ * @see {@link https://meocord.dev/docs/4.2/invoke-and-dispatch | Invoke and dispatch}
  */ function getResponse(interaction) {
     const state = existingResponse(interaction);
     // A mock records every answer it gets; respond()'s edits through the channel are its own, so they are merged in

package/dist/esm/testing/routing.js

@@ -1,4 +1,4 @@
-import { findComponentRouteConflicts, buildComponentRoutes, matchComponentRoute } from '../core/component-routes.js';
+import { findComponentRouteConflicts, buildComponentRoutes, matchComponentRoute, readCustomId } from '../core/component-routes.js';
 import { isCustomIdRouted } from '../util/interaction.util.js';
 import { staticMessageStarts, matchMessageRoute, buildMessageRoutes, fitsScope } from '../core/message-routes.js';
 import { needsGuild } from '../core/message-params.js';
@@ -47,7 +47,7 @@ import { META } from '../util/metadata-keys.js';
  * @group Testing
  * @category Inspection
  * @see {@link findRouteConflicts}
- * @see {@link https://meocord.dev/docs/4.1/components | Buttons, selects and modals}
+ * @see {@link https://meocord.dev/docs/4.2/components | Buttons, selects and modals}
  */ function resolveRoute(app, input) {
     if ('content' in input) {
         const { messages = {} } = appOptionsOf(app);
@@ -73,7 +73,10 @@ import { META } from '../util/metadata-keys.js';
     const { route, params, text } = matched;
     const method = route.meta.methodName;
     const typed = Object.keys(route.types).length > 0;
-    return {
+    // The routes ranked behind it that the customId matches too, which dispatch never reaches for it
+    const behind = routes.slice(routes.indexOf(route) + 1);
+    const alsoMatches = behind.filter((other)=>other.meta.type === input.type && readCustomId(other.pattern, other.meta.regex, input.customId)).map((other)=>other.pattern);
+    const resolved = {
         controller: route.controllerClass,
         method,
         handler: route.controllerClass.prototype[method],
@@ -82,28 +85,34 @@ import { META } from '../util/metadata-keys.js';
             values: params
         }
     };
+    return alsoMatches.length > 0 ? readableOnly(resolved, {
+        alsoMatches
+    }) : resolved;
 }
 /**
- * Finds component patterns that can match the same `customId`, which MeoCord otherwise only warns about at startup.
+ * Finds component patterns that rank equally and can match the same `customId`, which MeoCord otherwise only warns
+ * about at startup.
  *
- * Use it in a test to keep the warning from reaching production: two patterns that trade a literal for a parameter
- * in opposite places both take one id, and neither is more specific. Patterns are compared within a component type.
+ * Use it in a test to keep the warning from reaching production. Patterns rank segment by segment, a literal before a
+ * param and then the narrower type, so two collide only with the same literals and equally narrow params at each
+ * position, such as `{action:close|reopen}` and `{step:close|confirm}`, which both take `close`; the one listed
+ * first runs. Patterns are compared within a component type.
  *
  * @param app - The application class decorated with `@MeoCord`.
- * @returns Each pair of patterns that can match the same `customId`, with its component type.
+ * @returns Each pair of patterns that rank equally and can match the same `customId`, with its component type.
  *
  * @example
  * ```ts
  * import { expect } from 'vitest'
  *
  * @Controller()
- * class CardController {
- *   @Command('card/{id}/open', CommandType.BUTTON)
- *   async open(interaction: ButtonInteraction) { await respond(interaction).send('Opened.') }
- *   @Command('card/new/{kind}', CommandType.BUTTON)
- *   async create(interaction: ButtonInteraction) { await respond(interaction).send('Created.') }
+ * class TicketController {
+ *   @Command('ticket/{action:close|reopen}', CommandType.BUTTON)
+ *   async act(interaction: ButtonInteraction) { await respond(interaction).send('Done.') }
+ *   @Command('ticket/{step:close|confirm}', CommandType.BUTTON)
+ *   async step(interaction: ButtonInteraction) { await respond(interaction).send('Next.') }
  * }
- * @MeoCord({ controllers: [CardController], clientOptions: { intents: [] } })
+ * @MeoCord({ controllers: [TicketController], clientOptions: { intents: [] } })
  * class App {}
  * expect(findRouteConflicts(App)).toHaveLength(1)
  * ```
@@ -112,7 +121,23 @@ import { META } from '../util/metadata-keys.js';
  * @category Inspection
  * @see {@link resolveRoute}
  */ function findRouteConflicts(app) {
-    return findComponentRouteConflicts(buildComponentRoutes(controllersOf(app)));
+    return findComponentRouteConflicts(buildComponentRoutes(controllersOf(app))).map(({ type, patterns, runs })=>readableOnly({
+            type: type,
+            patterns
+        }, {
+            runs
+        }));
+}
+/**
+ * `target` with `fields` added as properties a test reads but `toEqual` and its kin, which compare enumerable keys,
+ * don't see, so an assertion written for the fields it had before still holds.
+ */ function readableOnly(target, fields) {
+    for (const [key, value] of Object.entries(fields))Object.defineProperty(target, key, {
+        value,
+        enumerable: false,
+        configurable: true
+    });
+    return target;
 }
 
 export { findRouteConflicts, resolveRoute };

package/dist/esm/testing/startup-errors.js

@@ -0,0 +1,26 @@
+import { setStartupErrorsMode } from '../util/refusal.util.js';
+
+/**
+ * Has decorators keep the startup errors they find, as a bot built with `startupErrors: 'all'` does, so a testing
+ * module reports every one at once.
+ *
+ * Call it once in the test runner's setup file, before any test imports a controller: a decorator runs when its class
+ * is defined, as its file is imported. A decorator given what it cannot use then throws nothing as the file loads, and
+ * `MeoCordTestingModule.create(...).compile()` logs every startup error of the classes it runs, each with its handler
+ * and file, then throws the first. Without it, a decorator throws its error as its class is defined.
+ *
+ * @example
+ * ```ts
+ * // vitest.setup.ts
+ * reportAllStartupErrors()
+ * ```
+ *
+ * @group Testing
+ * @category Module
+ * @see {@link MeoCordTestingModule}
+ * @see {@link https://meocord.dev/docs/4.2/configuration | Configuration}
+ */ function reportAllStartupErrors() {
+    setStartupErrorsMode('all');
+}
+
+export { reportAllStartupErrors };

package/dist/esm/testing/strict-mocks.js

@@ -0,0 +1,45 @@
+// Whether useStrictMocks() is on, and whether a mock was made before it could be
+let strict = false;
+let mockMade = false;
+/** Whether mocks compute discord.js's state, as {@link useStrictMocks} turns on. */ const strictMocks = ()=>strict;
+/** Notes that a mock was made, which useStrictMocks() must come before. */ function noteMockMade() {
+    mockMade = true;
+}
+/**
+ * Has every mock from `meocord/testing` compute the values discord.js computes, where it reads a placeholder otherwise.
+ *
+ * Call it once in the test runner's setup file. A message's `editable`, `deletable`, `pinnable`, `crosspostable`,
+ * `bulkDeletable`, `hasThread` and `partial`, a member's `manageable`, `kickable`, `bannable` and `moderatable`, a
+ * role's `editable`, a channel's and a thread's `viewable`, `manageable`, `deletable`, `joinable` and the rest, and
+ * `partial` on users, channels and reactions then run discord.js's own getters against the mock, and `message.thread`
+ * is `null` when the channel caches no thread under the message's id. No placeholder warning is logged.
+ *
+ * @remarks
+ * Those getters read what a server holds, so strict mocks also have it as Discord sends it: the bot's member is in
+ * the server's member cache from the start, @everyone has the permissions Discord gives it in a new server, and a
+ * channel or thread made without a server has one of its own, a thread with a text channel as its parent. A message
+ * has empty `content`, a thread is neither archived nor locked, and a reaction's `count` is 1. Give the bot's member
+ * a role to let it do more, such as kick a member its role ranks above. A value the test sets on a mock wins over the
+ * computed one. The next major version (5.0) computes these values without the call.
+ *
+ * @throws Error when a mock already exists, which was made without it.
+ *
+ * @example
+ * ```ts
+ * // vitest.setup.ts
+ * useStrictMocks()
+ * ```
+ *
+ * @group Testing
+ * @category Mocks
+ * @see {@link useMockFn}
+ * @see {@link https://meocord.dev/docs/4.2/mocks | Mocks}
+ */ function useStrictMocks() {
+    if (strict) return;
+    if (mockMade) {
+        throw new Error('useStrictMocks() goes before any mock is made: a mock made before it reads placeholders, and the two kinds would ' + "mix. Call it once, in the test runner's setup file.");
+    }
+    strict = true;
+}
+
+export { noteMockMade, strictMocks, useStrictMocks };