meocord 4.2.0 → 4.2.1

package/dist/esm/testing/discord-defaults.js

@@ -1,10 +1,66 @@
-import { Message, Guild, TextChannel, ThreadChannel, GuildChannel, BaseGuildVoiceChannel, MessageReaction, GuildPremiumTier, GuildVerificationLevel, GuildNSFWLevel, Locale, ClientUser, User, GuildMember, Role, Collection, MessageType, CommandInteraction, AutocompleteInteraction, PermissionsBitField, BaseInteraction, ChannelType, NewsChannel, VoiceChannel, ForumChannel, MediaChannel, DMChannel, BaseChannel, Client, BaseGuild, SnowflakeUtil } from 'discord.js';
-import { createMockChannel, createMockGuild, memberRoles, createMockUser, isRawMember } from './mock-interaction.js';
+import { GuildChannel, MessageReaction, MessageMentions, Message, GuildMember, BaseGuild, Guild, ModalSubmitInteraction, TextChannel, ThreadChannel, BaseGuildVoiceChannel, GuildPremiumTier, GuildVerificationLevel, GuildNSFWLevel, Locale, PresenceManager, ClientUser, UserFlagsBitField, User, GuildMemberFlagsBitField, Role, Collection, MessageType, ReactionManager, ChatInputCommandInteraction, CommandInteraction, AutocompleteInteraction, ReactionUserManager, BaseInteraction, ChannelType, NewsChannel, VoiceChannel, ForumChannel, MediaChannel, DMChannel, BaseChannel, Client, PermissionsBitField, PermissionFlagsBits } from 'discord.js';
+import { createMockChannel, createMockGuild, createMockMessage, ownedManager, memberRoles, createMockUser, createChatInputOptions, readPlaceAs, botMemberOf, heldChannelOf, isRawMember, isUnsetEveryone, NEW_SERVER_EVERYONE_PERMISSIONS } from './mock-interaction.js';
+import { nextSnowflake } from './snowflake.js';
 import { strictMocks } from './strict-mocks.js';
+import { Logger } from '../common/logger.js';
+import { warnOnce } from '../common/deprecation.js';
 
+const mockLogger = new Logger('Mocks');
+/**
+ * A member's permissions where an interaction was made, as Discord computes them: under strict mocks, every permission
+ * for an Administrator or the owner, else the channel's overwrites on top of `member.permissions`, so a test that sets
+ * those keeps the base; otherwise `member.permissions`, with a warning once where strict mocks would read otherwise.
+ */ function inChannel(interaction, member) {
+    const base = member.permissions;
+    // Only a server the mock caches has the overwrites to apply
+    const { guild } = interaction;
+    if (!(guild instanceof Guild)) return base;
+    const computed = base.has(PermissionFlagsBits.Administrator) || member.id === guild.ownerId ? new PermissionsBitField(PermissionsBitField.All).freeze() : withOverwrites(base, overwritingChannel(interaction, guild), member);
+    if (strictMocks()) return computed;
+    if (!computed.equals(base)) {
+        const lost = new PermissionsBitField(base).remove(computed).toArray();
+        const gained = new PermissionsBitField(computed).remove(base).toArray();
+        const change = lost.length > 0 ? [
+            `without ${lost.join(', ')}`
+        ] : [];
+        if (gained.length > 0) change.push(`with ${gained.join(', ')}`);
+        warnOnce(mockLogger, `${interaction.constructor.name}.memberPermissions reads the member's own permissions here, without the ` + "channel's overwrites or every permission an Administrator or the owner has; in the next major version (5.0) " + `it reads them as Discord computes them in the channel, ${change.join(' and ')}. Set memberPermissions on the ` + 'mock, or call useStrictMocks() to compute them now.');
+    }
+    // Unless the test set them, a member's permissions come from its roles, @everyone's included
+    if (!Object.prototype.hasOwnProperty.call(member, 'permissions')) warnOnUnsetEveryone(interaction, guild, 'memberPermissions', base);
+    return base;
+}
+/**
+ * Warns once, as `key`, where `permissions` read a server's @everyone role default mode made with none, and lack what
+ * strict mocks give @everyone in a new server.
+ */ function warnOnUnsetEveryone(interaction, guild, key, permissions) {
+    const everyone = guild.roles.everyone;
+    if (!everyone || !isUnsetEveryone(everyone) || permissions.has(NEW_SERVER_EVERYONE_PERMISSIONS)) return;
+    warnOnce(mockLogger, `${interaction.constructor.name}.${key} reads the server's @everyone role here with no permissions; in the next major ` + 'version (5.0) it has the permissions Discord gives @everyone in a new server, as strict mocks read it. Set ' + 'guild.roles.everyone.permissions, or call useStrictMocks() to read it so now.');
+}
+/**
+ * The channel whose overwrites apply where an interaction was made, read without making or caching one: a thread's
+ * parent, or undefined where the channel, or a thread's parent, is one the mock would make, which has none.
+ */ function overwritingChannel(interaction, guild) {
+    const channel = heldChannelOf(interaction, guild);
+    // A thread's parent by the id the test gave it or one already read, so strict mocks' parent isn't made for this read
+    const parentId = (thread)=>Object.prototype.hasOwnProperty.call(thread, 'parentId') ? thread.parentId : madeParentIds.get(thread);
+    const at = channel instanceof ThreadChannel ? guild.channels.cache.get(parentId(channel) ?? '') : channel;
+    return at instanceof GuildChannel ? at : undefined;
+}
+// The parent id strict mocks made for each thread made without one, once read
+const madeParentIds = new WeakMap();
+// Private in discord.js's typings, though they are what its own permissionsFor computes with; called on the prototype
+// so a test's stub on the channel stays for its caller
+const channelPermissions = GuildChannel.prototype;
+/** `base` with `channel`'s overwrites for `member` applied, in discord.js's order: @everyone's, the roles', the member's. */ function withOverwrites(base, channel, member) {
+    if (!channel) return base;
+    // Given the member and its roles as verified, as discord.js's memberPermissions does, so it resolves nothing again
+    const overwrites = channelPermissions.overwritesFor.call(channel, member, true, member.roles.cache);
+    return new PermissionsBitField(base).remove(overwrites.everyone?.deny ?? 0n).add(overwrites.everyone?.allow ?? 0n).remove(overwrites.roles.length > 0 ? overwrites.roles.map((role)=>role.deny) : 0n).add(overwrites.roles.length > 0 ? overwrites.roles.map((role)=>role.allow) : 0n).remove(overwrites.member?.deny ?? 0n).add(overwrites.member?.allow ?? 0n).freeze();
+}
 /** A permission set with none, frozen as discord.js freezes the ones it gives. */ const noPermissions = ()=>new PermissionsBitField().freeze();
 /** A property discord.js computes from the others: its own getter runs, reading the mock's values. */ const REAL_GETTER = Symbol('real getter');
-const snowflake = ()=>SnowflakeUtil.generate().toString();
 /** A class and its defaults, typed together so a default that stops fitting its property fails to compile. */ const defaultsOf = (Class, defaults)=>[
         Class.prototype,
         defaults
@@ -17,7 +73,7 @@ const snowflake = ()=>SnowflakeUtil.generate().toString();
     defaultsOf(Guild, {
         name: ()=>'Guild',
         preferredLocale: ()=>Locale.EnglishUS,
-        ownerId: snowflake,
+        ownerId: nextSnowflake,
         memberCount: ()=>1,
         available: ()=>true,
         large: ()=>false,
@@ -30,6 +86,9 @@ const snowflake = ()=>SnowflakeUtil.generate().toString();
         shardId: ()=>0,
         nsfwLevel: ()=>GuildNSFWLevel.Default,
         verificationLevel: ()=>GuildVerificationLevel.None,
+        presences: (guild)=>ownedManager(PresenceManager.prototype, {
+                guild
+            }),
         premiumTier: ()=>GuildPremiumTier.None,
         createdTimestamp: REAL_GETTER,
         createdAt: REAL_GETTER
@@ -44,6 +103,7 @@ const snowflake = ()=>SnowflakeUtil.generate().toString();
         discriminator: ()=>'0',
         avatar: ()=>null,
         system: ()=>false,
+        flags: ()=>new UserFlagsBitField(),
         tag: REAL_GETTER,
         displayName: REAL_GETTER,
         defaultAvatarURL: REAL_GETTER,
@@ -64,12 +124,12 @@ const snowflake = ()=>SnowflakeUtil.generate().toString();
         premiumSinceTimestamp: ()=>null,
         communicationDisabledUntilTimestamp: ()=>null,
         pending: ()=>false,
+        flags: ()=>new GuildMemberFlagsBitField().freeze(),
         displayName: REAL_GETTER,
         roles: (member)=>memberRoles(member, []),
         permissions: REAL_GETTER
     }),
     defaultsOf(Role, {
-        id: snowflake,
         name: ()=>'role',
         // Above @everyone, which a server's role manager makes at position 0
         position: ()=>1,
@@ -107,37 +167,71 @@ const snowflake = ()=>SnowflakeUtil.generate().toString();
         poll: ()=>null,
         interactionMetadata: ()=>null,
         stickers: ()=>new Collection(),
+        messageSnapshots: ()=>new Collection(),
+        reactions: (message)=>ownedManager(ReactionManager.prototype, {
+                message
+            }),
         url: REAL_GETTER
     }),
     // A command's name and a component's customId say which handler a call is for, so they stay the test's to give
+    defaultsOf(ChatInputCommandInteraction, {
+        options: ()=>createChatInputOptions()
+    }),
     defaultsOf(CommandInteraction, {
-        commandId: snowflake,
+        commandId: nextSnowflake,
         commandGuildId: ()=>null
     }),
     defaultsOf(AutocompleteInteraction, {
-        commandId: snowflake,
-        commandGuildId: ()=>null
+        commandId: nextSnowflake,
+        commandGuildId: ()=>null,
+        options: ()=>createChatInputOptions()
+    }),
+    defaultsOf(MessageReaction, {
+        users: (reaction)=>ownedManager(ReactionUserManager.prototype, {
+                reaction
+            })
     }),
     defaultsOf(BaseInteraction, {
-        applicationId: snowflake,
+        applicationId: nextSnowflake,
         token: ()=>'mock-interaction-token',
         version: ()=>1,
         context: ()=>null,
+        entitlements: ()=>new Collection(),
         // What Discord sends with an interaction in a server, the member's permissions there; typed for a cached one
-        memberPermissions: (interaction)=>{
-            const { guildId } = interaction;
-            const member = interaction.member;
-            if (!guildId) return null;
-            if (member instanceof GuildMember) return member.permissions;
-            // A raw member's permissions are the string Discord sends, read as discord.js reads them
-            return isRawMember(member) && !interaction.guild ? new PermissionsBitField(BigInt(member.permissions)).freeze() : null;
-        },
-        // The bot's permissions where the interaction was made: its member's in the channel, or none outside a server
-        appPermissions: (interaction)=>{
-            const { guild, channel } = interaction;
-            const me = guild instanceof Guild ? guild.members.me : null;
-            return (me && channel instanceof GuildChannel ? channel.permissionsFor(me) : null) ?? noPermissions();
-        }
+        // Each reads where the interaction is as its own, and warns by its own name where strict mocks place it otherwise
+        memberPermissions: (interaction)=>readPlaceAs(interaction, 'memberPermissions', ()=>{
+                const { guildId } = interaction;
+                const member = interaction.member;
+                if (!guildId) return null;
+                if (member instanceof GuildMember) return inChannel(interaction, member);
+                // A raw member's permissions are the string Discord sends, read as discord.js reads them
+                return isRawMember(member) && !interaction.guild ? new PermissionsBitField(BigInt(member.permissions)).freeze() : null;
+            }),
+        // The bot's permissions where the interaction was made: its member's in the channel, or in a thread its parent, as
+        // discord.js computes them; none outside a server
+        appPermissions: (interaction)=>readPlaceAs(interaction, 'appPermissions', ()=>{
+                const { guild } = interaction;
+                const me = guild instanceof Guild ? botMemberOf(guild) : null;
+                if (!(me instanceof GuildMember) || heldChannelOf(interaction, guild) === null) return noPermissions();
+                // discord.js's own computation, given its own overwritesFor over a test's stub on the channel; a channel the
+                // mock would make has no overwrites
+                const at = overwritingChannel(interaction, guild) ?? {
+                    guild,
+                    permissionOverwrites: {
+                        cache: new Collection()
+                    }
+                };
+                const channel = Object.create(at, {
+                    overwritesFor: {
+                        value: channelPermissions.overwritesFor
+                    }
+                });
+                const permissions = channelPermissions.memberPermissions.call(channel, me, true);
+                // The bot's member has @everyone's too
+                warnOnUnsetEveryone(interaction, guild, 'appPermissions', permissions);
+                return permissions;
+            }, // A server the bot isn't in has no guild in either mode, so no permissions in both
+            (place)=>!place.raw)
     }),
     defaultsOf(TextChannel, {
         type: ()=>ChannelType.GuildText,
@@ -173,7 +267,7 @@ const snowflake = ()=>SnowflakeUtil.generate().toString();
     }),
     defaultsOf(GuildChannel, {
         name: ()=>'channel',
-        guildId: (channel)=>typeof channel.guild?.id === 'string' ? channel.guild.id : snowflake(),
+        guildId: (channel)=>typeof channel.guild?.id === 'string' ? channel.guild.id : nextSnowflake(),
         position: ()=>0,
         rawPosition: ()=>0,
         parentId: ()=>null
@@ -197,11 +291,26 @@ const snowflake = ()=>SnowflakeUtil.generate().toString();
  * thread made without one, a thread's parent text channel in it, and data that is otherwise a placeholder.
  */ const STRICT_DEFAULTS = new Map([
     defaultsOf(Message, {
-        content: ()=>''
+        content: ()=>'',
+        editedTimestamp: ()=>null,
+        editedAt: REAL_GETTER
+    }),
+    defaultsOf(MessageMentions, {
+        repliedUser: ()=>null
     }),
     defaultsOf(Guild, {
         rulesChannelId: ()=>null,
-        publicUpdatesChannelId: ()=>null
+        publicUpdatesChannelId: ()=>null,
+        systemChannel: REAL_GETTER
+    }),
+    defaultsOf(BaseGuild, {
+        verified: REAL_GETTER
+    }),
+    defaultsOf(GuildMember, {
+        presence: REAL_GETTER
+    }),
+    defaultsOf(ModalSubmitInteraction, {
+        message: ()=>null
     }),
     defaultsOf(ThreadChannel, {
         guild: ()=>createMockGuild(),
@@ -211,25 +320,91 @@ const snowflake = ()=>SnowflakeUtil.generate().toString();
                 guild: thread.guild
             });
             thread.guild.channels.cache.set(parent.id, parent);
+            madeParentIds.set(thread, parent.id);
             return parent.id;
         },
         parent: REAL_GETTER,
-        ownerId: snowflake,
+        ownerId: nextSnowflake,
         archived: ()=>false,
         locked: ()=>false
     }),
     defaultsOf(GuildChannel, {
-        guild: ()=>createMockGuild()
+        guild: ()=>createMockGuild(),
+        parent: REAL_GETTER
     }),
     // Full once its members reach a user limit, which a voice channel has none of unless given one
     defaultsOf(BaseGuildVoiceChannel, {
         userLimit: ()=>0,
         full: REAL_GETTER
     }),
+    // A reaction's message, as discord.js always has one, is a whole one
     defaultsOf(MessageReaction, {
-        count: ()=>1
+        count: ()=>1,
+        me: ()=>false,
+        message: ()=>createMockMessage()
     })
 ]);
+/**
+ * What a mock reads as a placeholder unless strict mocks read it as discord.js gives it, by the value a test sets for
+ * that, which the warning on reading one names.
+ */ const PLACEHOLDER_VALUES = new Map([
+    [
+        MessageReaction.prototype,
+        {
+            me: 'false',
+            message: 'createMockMessage()'
+        }
+    ],
+    [
+        MessageMentions.prototype,
+        {
+            repliedUser: 'null'
+        }
+    ],
+    [
+        Message.prototype,
+        {
+            editedAt: 'null'
+        }
+    ],
+    [
+        GuildMember.prototype,
+        {
+            presence: 'null'
+        }
+    ],
+    [
+        BaseGuild.prototype,
+        {
+            verified: 'false'
+        }
+    ],
+    [
+        Guild.prototype,
+        {
+            systemChannel: 'null'
+        }
+    ],
+    [
+        GuildChannel.prototype,
+        {
+            parent: 'null'
+        }
+    ],
+    [
+        ModalSubmitInteraction.prototype,
+        {
+            message: 'null'
+        }
+    ]
+]);
+/** The value a test sets for `key` on a mock of `target`'s class, when a mock reads it as a placeholder. */ function placeholderValue(target, key) {
+    for(let proto = Object.getPrototypeOf(target); proto !== null; proto = Object.getPrototypeOf(proto)){
+        const value = PLACEHOLDER_VALUES.get(proto)?.[key];
+        if (value !== undefined) return value;
+    }
+    return undefined;
+}
 /** The default a mock of `target`'s class has for `key`, read from the nearest class that has one, strict ones first. */ function discordDefault(target, key) {
     for (const defaults of strictMocks() ? [
         STRICT_DEFAULTS,
@@ -245,4 +420,4 @@ const snowflake = ()=>SnowflakeUtil.generate().toString();
     return undefined;
 }
 
-export { REAL_GETTER, discordDefault };
+export { REAL_GETTER, discordDefault, placeholderValue };