meocord 4.1.0 → 4.1.2

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

@@ -1,9 +1,11 @@
 import 'reflect-metadata';
 import { createMockFn } from './mock-fn.js';
-import { InteractionType, ComponentType, ApplicationCommandType, CommandInteractionOptionResolver, ApplicationCommandOptionType, GuildMessageManager, GuildTextThreadManager, GuildForumThreadManager, DMMessageManager, ThreadMemberManager, Client, ApplicationCommandManager, UserManager, ChannelManager, GuildManager, ClientUser, Guild, GuildMemberManager, GuildChannelManager, GuildBanManager, AuthorizingIntegrationOwners, BaseInteraction, Locale, StringSelectMenuInteraction, UserSelectMenuInteraction, RoleSelectMenuInteraction, ChannelSelectMenuInteraction, MentionableSelectMenuInteraction, Collection, Message, ThreadChannel, MessageFlagsBitField, User, RoleManager, SnowflakeUtil, BaseChannel, DMChannel, GuildMember, GuildMemberRoleManager, MessageMentions, Component, Embed, Role, Attachment, BaseManager, Base, TextChannel, GuildBan, ThreadMember, ApplicationCommand, NewsChannel, ForumChannel, MediaChannel, BaseGuildVoiceChannel, DiscordjsErrorCodes, DiscordjsTypeError } from 'discord.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 { 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 { embedsAsDiscordStores, asDiscordStores } from './discord-shape.js';
 import { nextSnowflake, MOCK_BOT_ID } from './snowflake.js';
 
@@ -58,11 +60,14 @@ 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);
                     break;
                 }
                 proto = Object.getPrototypeOf(proto);
             }
-            const stub = typeof protoValue === 'function' ? methodStub(target, key, protoValue, ()=>proxy) : stubDeep({});
+            // A client the mock's structures share: its guild's, or one of its own
+            if (key === 'client' && target instanceof Base) return clientOf(target);
+            const stub = typeof protoValue === 'function' ? isRealMethod(target, key) ? createMockFn((...args)=>protoValue.apply(proxy, args)) : methodStub(target, key, protoValue, ()=>proxy) : stubDeep({});
             stubs.set(key, stub);
             return stub;
         },
@@ -83,6 +88,164 @@ function stubDeep(instance, externalStubs, onSet) {
     });
     return proxy;
 }
+// discord.js methods that read only what the mock holds, so they run for real: looking items up in a manager's cache,
+// ranking roles, a member's or role's permissions in a channel, and whom a message mentions
+const REAL_METHODS = new Map([
+    [
+        DataManager.prototype,
+        new Set([
+            'resolve',
+            'resolveId'
+        ])
+    ],
+    [
+        RoleManager.prototype,
+        new Set([
+            'comparePositions'
+        ])
+    ],
+    [
+        Role.prototype,
+        new Set([
+            'comparePositionTo',
+            'permissionsIn'
+        ])
+    ],
+    [
+        GuildChannel.prototype,
+        new Set([
+            'permissionsFor',
+            'overwritesFor',
+            'memberPermissions',
+            'rolePermissions'
+        ])
+    ],
+    [
+        GuildMember.prototype,
+        new Set([
+            'permissionsIn',
+            'isCommunicationDisabled'
+        ])
+    ],
+    [
+        User.prototype,
+        new Set([
+            'avatarURL',
+            'displayAvatarURL',
+            'bannerURL'
+        ])
+    ],
+    [
+        BaseGuild.prototype,
+        new Set([
+            'iconURL',
+            'bannerURL',
+            'splashURL'
+        ])
+    ],
+    [
+        MessageMentions.prototype,
+        new Set([
+            'has'
+        ])
+    ]
+]);
+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;
+    }
+    return false;
+}
+// discord.js's computed booleans a mock reads as a placeholder, which is truthy: 5.0 computes them, and until then a
+// test that reads one is told so once
+const PLACEHOLDER_BOOLEANS = new Map([
+    [
+        Message.prototype,
+        new Set([
+            'editable',
+            'deletable',
+            'pinnable',
+            'crosspostable',
+            'bulkDeletable',
+            'hasThread',
+            'partial'
+        ])
+    ],
+    [
+        GuildMember.prototype,
+        new Set([
+            'manageable',
+            'kickable',
+            'bannable',
+            'moderatable'
+        ])
+    ],
+    [
+        Role.prototype,
+        new Set([
+            'editable'
+        ])
+    ],
+    [
+        GuildChannel.prototype,
+        new Set([
+            'viewable',
+            'manageable',
+            'deletable'
+        ])
+    ],
+    [
+        ThreadChannel.prototype,
+        new Set([
+            'joinable',
+            'joined',
+            'sendable',
+            'unarchivable',
+            'editable',
+            'manageable',
+            'viewable'
+        ])
+    ],
+    [
+        BaseGuildVoiceChannel.prototype,
+        new Set([
+            'joinable'
+        ])
+    ],
+    [
+        User.prototype,
+        new Set([
+            'partial'
+        ])
+    ],
+    [
+        BaseChannel.prototype,
+        new Set([
+            'partial'
+        ])
+    ],
+    [
+        MessageReaction.prototype,
+        new Set([
+            'partial'
+        ])
+    ]
+]);
+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 client of a structure made without one: the one its guild has, else one of its own, made once
+const ownClients = new WeakMap();
+function clientOf(target) {
+    const guild = Object.getOwnPropertyDescriptor(target, 'guild')?.value;
+    if (guild instanceof Guild) return guild.client;
+    let client = ownClients.get(target);
+    if (client === undefined) ownClients.set(target, client = createMockClient());
+    return client;
+}
 // ---------------------------------------------------------------------------
 // methodStub — what an auto-stubbed discord.js method returns
 // ---------------------------------------------------------------------------
@@ -241,9 +404,9 @@ const MANAGER_ITEMS = [
     ]
 ];
 const returnsPromise = (key, method)=>method.constructor.name === 'AsyncFunction' || PROMISE_METHODS.has(key) || /^set[A-Z]/.test(key) && !SYNC_SETTERS.has(key);
-// The id of the one item a fetch asks for: an id, a discord.js object, or options naming one, such as `{ user: id }`;
-// undefined for a fetch of a list
-function fetchedId(args) {
+// The ids a fetch asks for: an id, a discord.js object, or options naming one or several, such as `{ user: id }` or
+// `{ user: [ids] }`; undefined for a fetch of a list
+function fetchedIds(args) {
     const idOf = (value)=>typeof value === 'string' ? value : value instanceof Base ? value.id : undefined;
     const [first] = args;
     if (typeof first !== 'object' || first === null || first instanceof Base) return idOf(first);
@@ -255,7 +418,9 @@ function fetchedId(args) {
         'thread',
         'id'
     ]){
-        const id = idOf(first[key]);
+        const value = first[key];
+        if (Array.isArray(value)) return value.map(idOf).filter((id)=>id !== undefined);
+        const id = idOf(value);
         if (id !== undefined) return id;
     }
     return undefined;
@@ -263,9 +428,9 @@ function fetchedId(args) {
 /**
  * The mock function for a method found on a discord.js prototype. One that returns a promise in discord.js resolves:
  * `createDM` to the user's DM channel, `send` and its kin to a message, a manager's `fetch`, `create` and `edit` to its
- * item (an empty collection for a list fetch), a structure's own `edit`, `fetch`, `delete`, `ban`, `pin`, `unpin`,
- * `timeout`, `disableCommunicationUntil` and setters to the structure, and the rest to `undefined`. Any other method
- * returns `undefined`.
+ * item (a collection of each for a fetch of several, an empty one for a list fetch), a structure's own `edit`, `fetch`,
+ * `delete`, `ban`, `pin`, `unpin`, `timeout`, `disableCommunicationUntil` and setters to the structure, and the rest to
+ * `undefined`. Any other method returns `undefined`.
  */ function methodStub(target, key, method, receiver) {
     if (!returnsPromise(key, method)) return createMockFn();
     // A member's DMs go through its user, and a user's through its one DM channel, as discord.js sends them
@@ -279,12 +444,17 @@ function fetchedId(args) {
     if (MESSAGE_METHODS.has(key)) return createMockFn(async ()=>createMockMessage());
     if (target instanceof BaseManager) {
         const item = MANAGER_ITEMS.find(([Manager])=>Manager.prototype.isPrototypeOf(target))?.[1];
-        // A fetch of one item finds it in the cache first, as discord.js does, and caches one it makes
+        // A fetch of one item finds it in the cache first, as discord.js does, and caches one it makes; a fetch of
+        // several does so for each
         if (item && key === 'fetch') {
             return createMockFn(async (...args)=>{
-                const id = fetchedId(args);
-                if (id === undefined) return new Collection();
-                return cached(cacheOf(receiver()), id, ()=>item(id, receiver()));
+                const ids = fetchedIds(args);
+                const one = (id)=>cached(cacheOf(receiver()), id, ()=>item(id, receiver()));
+                if (Array.isArray(ids)) return new Collection(ids.map((id)=>[
+                        id,
+                        one(id)
+                    ]));
+                return ids === undefined ? new Collection() : one(ids);
             });
         }
         if (item && (key === 'create' || key === 'edit')) return createMockFn(async ()=>item(undefined, receiver()));
@@ -500,54 +670,7 @@ const INVALID_CHANNEL_TYPE = 'CommandInteractionOptionInvalidChannelType';
         id,
         bot: false
     }));
-// ---------------------------------------------------------------------------
-// createMockInteraction
-// ---------------------------------------------------------------------------
-/**
- * Creates a mock instance of a discord.js class, such as an interaction, keeping its prototype so `instanceof` holds.
- *
- * Use it for the interaction a test hands to `invoke` or `dispatch`. For a user, a message, a guild, a channel or a
- * client, the dedicated factories fill in what discord.js would; for a type with no class, use {@link createMock}.
- *
- * @remarks
- * Type guards such as `isButton()` run the real discord.js logic. An interaction gets an `id`, a `channelId` and a
- * `user` of its own unless given, and its `locale` is `'en-US'`; without a `guildId` it is a DM, and with one its
- * `member` is its user: for a `user` given, when the test gives the `guild`, the guild's cached member for that user,
- * so a message and an interaction from one user in that server share it, and `memberPermissions` are that member's
- * permissions (`null` in a DM). A user is a person, `bot: false`, and a member has the server's @everyone role and the
- * roles {@link createMockMember} gave it; with a `guildId` but no `guild`, a server the bot isn't in, that @everyone role
- * has the `guildId`. A DM sent to a member goes through its user's `send()` and the user's one DM channel. Its
- * `channel` is a text channel of its server, the one its guild caches under `channelId`, or the user's DM channel. A
- * `channel` given sets what the test leaves out of `channelId`, `guildId` and `guild`, as discord.js reads them from
- * it: a DM channel is no server, and a server's channel its server; one in another server than the `guildId` given is
- * refused, naming both. A select menu has picked nothing unless given: its
- * `values` are the ids of the `users` and `members`, `roles` or `channels` given, the collections of what it picks,
- * each empty unless given. Other data Discord always sends reads as
- * Discord sends it, such as `false` for a flag and `null` for what may be absent; what picks the handler, `commandName`
- * or `customId`, is the test's to give. Replies follow Discord's order, so a second `reply()` rejects, and
- * {@link getResponse} reports every answer the interaction got. Every method is a mock function, and one that returns a
- * promise in discord.js resolves.
- *
- * @param Class - The discord.js class to mock.
- * @param props - Values for properties the class declares `readonly`; see {@link MockProps}.
- *
- * @example
- * ```ts
- * import { expect } from 'vitest'
- *
- * const interaction = createMockInteraction(ButtonInteraction, { customId: 'ticket/42/close' })
- * expect(interaction.isButton()).toBe(true)
- * await interaction.reply({ content: 'Closed.' })
- * expect(interaction.replied).toBe(true)
- * await expect(interaction.reply({ content: 'Again.' })).rejects.toThrow()
- * ```
- *
- * @group Testing
- * @category Mocks
- * @see {@link MockProps}
- * @see {@link createChatInputOptions}
- * @see {@link https://meocord.dev/docs/4.1/mocks | Mocks}
- */ function createMockInteraction(Class, props) {
+function createMockInteraction(Class, props) {
     const instance = Object.create(Class.prototype);
     const stubs = new Map();
     // Set type fields so all prototype type-guard methods compute the right value
@@ -557,13 +680,10 @@ const INVALID_CHANNEL_TYPE = 'CommandInteractionOptionInvalidChannelType';
             instance[key] = value;
         }
     }
-    // Wire each type guard as a mock fn calling the real prototype implementation.
-    // Correct by default; overridable per test via .mockReturnValue().
+    // Each type guard runs the real prototype implementation, as the mock's own, so a reset keeps it; a test may override it
     for (const name of TYPE_GUARD_METHODS){
         const method = findPrototypeMethod(instance, name);
-        if (method !== null) {
-            stubs.set(name, createMockFn().mockImplementation(()=>method.call(instance)));
-        }
+        if (method !== null) stubs.set(name, createMockFn(()=>method.call(instance)));
     }
     // Guild checks read the mock's own data, since discord.js resolves `guild` through a client the
     // mock lacks: a guildId is a guild, a guild object with it a cached one, neither a DM. A member
@@ -576,7 +696,7 @@ const INVALID_CHANNEL_TYPE = 'CommandInteractionOptionInvalidChannelType';
         inRawGuild: ()=>Boolean(own('guildId') && !own('guild') && hasMember())
     };
     for (const [name, check] of Object.entries(guildChecks)){
-        if (findPrototypeMethod(instance, name) !== null) stubs.set(name, createMockFn().mockImplementation(check));
+        if (findPrototypeMethod(instance, name) !== null) stubs.set(name, createMockFn(check));
     }
     // Set up reply state machine for repliable interactions
     const isRepliableMethod = findPrototypeMethod(instance, 'isRepliable');
@@ -711,6 +831,9 @@ const INVALID_CHANNEL_TYPE = 'CommandInteractionOptionInvalidChannelType';
             writable: true,
             configurable: true
         });
+        // The client caches the guild the interaction came from
+        const guildGiven = own('guild');
+        if (guildGiven instanceof Guild) cached(cacheOf(instance.client.guilds), guildGiven.id, ()=>guildGiven);
         cacheOf(instance.client?.users)?.set(instance.user.id, instance.user);
         // A channel given says where the interaction was made, for what the test leaves unset, as discord.js reads it
         const given = own('channel');
@@ -781,6 +904,30 @@ const INVALID_CHANNEL_TYPE = 'CommandInteractionOptionInvalidChannelType';
                 configurable: true
             });
         }
+        // A user context menu's target: the user with its targetId, the client's cached one or one made and cached there,
+        // and in a server that user's member; each read live, so a targetId set later picks its user, and assignable
+        if (UserContextMenuCommandInteraction.prototype.isPrototypeOf(instance)) {
+            if (unset('targetId')) instance.targetId = own('targetUser')?.id ?? nextSnowflake();
+            const targetUser = ()=>{
+                const id = own('targetId');
+                return cached(cacheOf(instance.client.users), id, ()=>mockUser(id));
+            };
+            const live = (key, read)=>Object.defineProperty(instance, key, {
+                    get: read,
+                    set: (value)=>Object.defineProperty(instance, key, {
+                            value,
+                            writable: true,
+                            enumerable: true,
+                            configurable: true
+                        }),
+                    enumerable: true,
+                    configurable: true
+                });
+            if (unset('targetUser')) live('targetUser', targetUser);
+            if (unset('targetMember')) {
+                live('targetMember', ()=>own('guildId') ? memberFor(own('guild'), targetUser(), true, own('guildId')) : null);
+            }
+        }
     }
     // Discord sends the user's locale with every interaction, and the server's preferred one with one made in a server
     if (BaseInteraction.prototype.isPrototypeOf(instance)) {
@@ -957,7 +1104,7 @@ const INVALID_CHANNEL_TYPE = 'CommandInteractionOptionInvalidChannelType';
  * import { expect } from 'vitest'
  *
  * const client = createMockClient()
- * const botId = client.user!.id
+ * const botId = client.user.id
  * const message = createMockMessage({ content: `<@${botId}> help`, client })
  * expect(message.mentions.users.has(botId)).toBe(true)
  * ```
@@ -974,15 +1121,90 @@ const INVALID_CHANNEL_TYPE = 'CommandInteractionOptionInvalidChannelType';
     // Real caches, empty until something is put in them, as a client that has just logged in
     instance.users = managerWith(UserManager.prototype, undefined);
     instance.channels = managerWith(ChannelManager.prototype, undefined);
-    instance.guilds = stubDeep(Object.create(GuildManager.prototype));
+    instance.guilds = managerWith(GuildManager.prototype, undefined);
     instance.user = stubDeep(Object.assign(Object.create(ClientUser.prototype), {
         id: MOCK_BOT_ID,
         bot: true
     }));
     instance.application = stubDeep(appInstance);
-    return stubDeep(instance);
+    // Discord's CDN routes, which avatar and icon URLs are built from; nothing is requested
+    instance.rest = stubDeep(Object.assign(Object.create(null), {
+        cdn: new CDN()
+    }));
+    // A client a test is given is a logged-in one
+    instance.isReady = createMockFn(()=>true);
+    const client = stubDeep(instance);
+    for (const key of [
+        'users',
+        'channels',
+        'guilds'
+    ])instance[key].client = client;
+    Object.defineProperty(instance.user, 'client', {
+        value: client,
+        writable: true,
+        configurable: true
+    });
+    return client;
 }
-/** A manager whose `cache` is a real collection of `items`, by id, empty without them, and whose methods are stubs. */ function managerWith(prototype, items) {
+// What each manager holds, which discord.js's resolve() checks an item against
+const HOLDS = [
+    [
+        GuildMemberManager.prototype,
+        GuildMember
+    ],
+    [
+        RoleManager.prototype,
+        Role
+    ],
+    [
+        GuildChannelManager.prototype,
+        GuildChannel
+    ],
+    [
+        UserManager.prototype,
+        User
+    ],
+    [
+        ChannelManager.prototype,
+        BaseChannel
+    ],
+    [
+        GuildManager.prototype,
+        Guild
+    ],
+    [
+        GuildBanManager.prototype,
+        GuildBan
+    ],
+    [
+        ThreadMemberManager.prototype,
+        ThreadMember
+    ],
+    [
+        GuildMessageManager.prototype,
+        Message
+    ],
+    [
+        DMMessageManager.prototype,
+        Message
+    ],
+    [
+        GuildTextThreadManager.prototype,
+        ThreadChannel
+    ],
+    [
+        GuildForumThreadManager.prototype,
+        ThreadChannel
+    ],
+    [
+        PermissionOverwriteManager.prototype,
+        PermissionOverwrites
+    ]
+];
+/**
+ * A manager whose `cache` is a real collection of `items`, by id, empty without them, and whose methods are stubs but
+ * for `resolve` and `resolveId`, which read the cache. Its `client` is the one its guild or channel has.
+ */ function managerWith(prototype, items) {
     const manager = Object.create(prototype);
     const cache = new Collection((items ?? []).map((item)=>[
             String(item.id ?? item.user?.id),
@@ -992,6 +1214,19 @@ const INVALID_CHANNEL_TYPE = 'CommandInteractionOptionInvalidChannelType';
         value: cache,
         writable: true
     });
+    const holds = HOLDS.find(([Manager])=>Manager === prototype || Object.prototype.isPrototypeOf.call(Manager, prototype))?.[1];
+    if (holds) Object.defineProperty(manager, 'holds', {
+        value: holds
+    });
+    let own;
+    Object.defineProperty(manager, 'client', {
+        get: ()=>{
+            const owner = manager.guild ?? manager.channel ?? manager.thread;
+            return owner instanceof Base ? owner.client : own ?? (own = createMockClient());
+        },
+        set: (value)=>own = value,
+        configurable: true
+    });
     return stubDeep(manager);
 }
 /**
@@ -1005,14 +1240,18 @@ const INVALID_CHANNEL_TYPE = 'CommandInteractionOptionInvalidChannelType';
  *
  * @remarks
  * A manager's `fetch(id)` resolves to its cached item with that id, as discord.js looks there first, or to a new one it
- * caches under that id: a member or channel in this guild, a role with that id, or a ban; `create()` and `edit()`
- * resolve to a mock of its item, and a list fetch to an empty collection. Members, roles and channels given are put in
+ * caches under that id: a member or channel in this guild, a role with that id, or a ban. `members.fetch({ user: ids })`
+ * resolves to a collection of each of those members, found or made the same way; `create()` and `edit()` resolve to a
+ * mock of its item, and a list fetch to an empty collection. Members, roles and channels given are put in
  * their managers' caches, where dispatch looks first when it resolves a message's typed params; a member
  * {@link createMockMember} made without a server is in this one. Its `roles.everyone` is the role given with the
  * guild's id, or else an @everyone role of its own at position 0 with no permissions, in `roles.cache` as Discord has
  * it. The guild is named `'Guild'` and its `preferredLocale` is `'en-US'` unless given, so `t.forGuild(guild)`
  * translates as for a new English server.
  *
+ * The mock makes a member for any id it's asked for, so a test of an id that isn't a member rejects the fetch, as
+ * `guild.members.fetch.mockRejectedValue(createDiscordError(10007))`, or resolves a collection without that member.
+ *
  * @example
  * ```ts
  * const target = createMock<GuildMember>({ id: '111111111111111111' })
@@ -1035,7 +1274,7 @@ const INVALID_CHANNEL_TYPE = 'CommandInteractionOptionInvalidChannelType';
     instance.roles = guildRoleManager(instance.id, overrides.roles);
     instance.bans = managerWith(GuildBanManager.prototype, undefined);
     const guild = stubDeep(instance);
-    homeManagers(instance, guild);
+    settleGuild(instance, guild);
     // A member made without a server of its own is in this one
     for (const member of overrides.members ?? []){
         if (!unhomedMembers.delete(member)) continue;
@@ -1052,7 +1291,8 @@ const INVALID_CHANNEL_TYPE = 'CommandInteractionOptionInvalidChannelType';
  * The managers the class has are ready to stub: `messages`, `threads` on text, announcement, forum and media channels,
  * and `members` on threads, each with a real, empty `cache` and the channel as its `channel`, or `thread`. A subclass gets the managers of the class it extends.
  * Type guards such as `isTextBased()`, `isDMBased()` and `isThread()` run discord.js's own logic, so each answers what
- * the channel is.
+ * the channel is. A thread is typed as discord.js types every thread it gives, a public or a private one, so it fits
+ * an interaction's `channel`, a guild's channels and the `threadCreate` event.
  *
  * @param Class - The discord.js channel class to mock.
  * @param props - Values for the channel's properties, such as its `id`, `name` or `topic`; see {@link MockProps}.
@@ -1096,13 +1336,16 @@ const INVALID_CHANNEL_TYPE = 'CommandInteractionOptionInvalidChannelType';
         instance.messages = managerWith(GuildMessageManager.prototype, undefined);
         instance.members = managerWith(ThreadMemberManager.prototype, undefined);
     }
+    // A server's channel has its overwrites, none until a test puts some in the cache, which its permissions read
+    if (is(GuildChannel) && !is(ThreadChannel)) instance.permissionOverwrites = managerWith(PermissionOverwriteManager.prototype, undefined);
     Object.assign(instance, props);
     const stubs = new Map();
     const channel = stubDeep(instance, stubs);
     // Each manager knows its channel, as discord.js's do, and a thread's members their thread
     for (const key of [
         'messages',
-        'threads'
+        'threads',
+        'permissionOverwrites'
     ])if (instance[key]) instance[key].channel = channel;
     if (is(ThreadChannel) && instance.members) instance.members.thread = channel;
     // Type guards run discord.js's own logic, which reads the channel's type and the managers it has
@@ -1362,7 +1605,7 @@ const CHANNEL_TYPE_GUARDS = [
     guild.roles = guildRoleManager(guild.id, undefined);
     guild.bans = managerWith(GuildBanManager.prototype, undefined);
     const proxy = stubDeep(guild);
-    homeManagers(guild, proxy);
+    settleGuild(guild, proxy);
     return proxy;
 }
 /** Gives a guild's managers the guild, as discord.js's do, so what they fetch or make is in it. */ function homeManagers(instance, guild) {
@@ -1373,6 +1616,35 @@ const CHANNEL_TYPE_GUARDS = [
         'bans'
     ])instance[key].guild = guild;
 }
+/**
+ * Makes `guild` whole, as discord.js's guilds are: its managers and the roles and channels in its caches belong to it,
+ * it has a client of its own until one is given, and `members.me` is the bot's member, the cached one or one with
+ * @everyone, made and cached once on first read.
+ */ function settleGuild(instance, guild) {
+    homeManagers(instance, guild);
+    let client;
+    Object.defineProperty(instance, 'client', {
+        get: ()=>client ?? (client = createMockClient()),
+        set: (value)=>client = value,
+        configurable: true
+    });
+    const members = instance.members;
+    Object.defineProperty(members, 'me', {
+        get: ()=>{
+            const { user } = guild.client;
+            return cached(cacheOf(members), user.id, ()=>memberIn(guild, user.id, user));
+        },
+        configurable: true
+    });
+    for (const key of [
+        'roles',
+        'channels'
+    ]){
+        for (const item of cacheOf(instance[key])?.values() ?? []){
+            if (!Object.prototype.hasOwnProperty.call(item, 'guild')) item.guild = guild;
+        }
+    }
+}
 /** The ids each kind of mention in `content` names, in order and once each. */ function mentionedIds(content) {
     const ids = (pattern)=>[
             ...new Set([
@@ -1435,11 +1707,15 @@ const CHANNEL_TYPE_GUARDS = [
     const instance = Object.create(MessageMentions.prototype);
     for (const [key, value] of Object.entries({
         ...mentioned,
-        everyone: false
-    }))Object.defineProperty(instance, key, {
-        value,
-        writable: true
-    });
+        everyone: false,
+        client,
+        guild: guild ?? null
+    })){
+        Object.defineProperty(instance, key, {
+            value,
+            writable: true
+        });
+    }
     return stubDeep(instance);
 }
 /** A value as its API JSON: a builder or discord.js structure through `toJSON()`, anything else as it is. */ const jsonOf = (value)=>value && typeof value.toJSON === 'function' ? value.toJSON() : value;
@@ -1518,7 +1794,8 @@ const CHANNEL_TYPE_GUARDS = [
  * and `reply()` resolve to a new mock message. Without overrides the message is empty, in a server, from a new
  * person who is its `member`; with `guild: null` it is a direct message. Give `author` to send several messages as
  * one user, such as to reach a per-user cooldown. An author given, and the users, roles and channels the content
- * mentions, are cached as the gateway delivers them.
+ * mentions, are cached as the gateway delivers them. It is typed as discord.js emits a message, never in a group DM,
+ * so it fits `messageCreate` and the other message events.
  *
  * @param overrides - The message's content, components and the rest; see {@link MockMessageOverrides}.
  *
@@ -1567,33 +1844,55 @@ const CHANNEL_TYPE_GUARDS = [
     });
     // The author as a member of the message's server; a direct message has none. A given author's member is the one
     // the server caches, as the gateway resolves it, so every message from that author has the same member
-    const author = overrides.author;
-    const member = guild ? memberFor(guild, instance.author, author !== undefined) : null;
+    // The author's member, cached as the gateway caches it with the message; `member` reads the cache, as discord.js does
+    if (guild) memberFor(guild, instance.author, true);
     Object.defineProperty(instance, 'member', {
-        value: member,
-        writable: true
+        get: ()=>guild ? guild.members.resolve(instance.author) : null,
+        set: (value)=>Object.defineProperty(instance, 'member', {
+                value,
+                writable: true,
+                enumerable: true,
+                configurable: true
+            }),
+        enumerable: true,
+        configurable: true
     });
     // In a server's text channel, the ids matching the objects; with no guild, a DM
     instance.channelId = channel.id;
     instance.guildId = guild?.id ?? null;
+    // The thread its channel caches under its id, as discord.js reads it; until 5.0, a placeholder thread otherwise
+    let placeholderThread;
     Object.defineProperty(instance, 'thread', {
-        value: stubDeep(Object.create(ThreadChannel.prototype)),
-        writable: true
+        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).');
+            return placeholderThread ?? (placeholderThread = stubDeep(Object.create(ThreadChannel.prototype)));
+        },
+        set: (value)=>Object.defineProperty(instance, 'thread', {
+                value,
+                writable: true,
+                enumerable: true,
+                configurable: true
+            }),
+        enumerable: true,
+        configurable: true
     });
-    // Assigned once by discord.js's Base constructor, so an own value, as it is on a real message
+    // Assigned once by discord.js's Base constructor, so an own value, as it is on a real message; a guild the message
+    // made for itself has the same client, which caches the guild
     const client = overrides.client ?? createMockClient();
+    if (guild && overrides.guild === undefined) guild.client = client;
     Object.defineProperty(instance, 'client', {
         value: client,
         writable: true,
         configurable: true
     });
+    if (guild instanceof Guild) cached(cacheOf(client.guilds), guild.id, ()=>guild);
     cacheChannel(channel, guild, client);
     const userCache = cacheOf(client.users);
     for (const user of [
         ...overrides.users ?? [],
-        ...author ? [
-            author
-        ] : []
+        instance.author
     ])userCache?.set(user.id, user);
     // MessageMentions — constructor-assigned; what the content mentions, cached as the gateway delivers it
     instance.mentions = mentionsOf(overrides.content, client, guild);