tests/services/PermissionManager.test.ts

import "../setup";

import assert from "assert";
import {
    APIGuild,
    APIRole,
    Guild,
    GuildDefaultMessageNotifications,
    GuildMember,
    PermissionsBitField,
    PermissionsString
} from "discord.js";
import { RawGuildMemberData } from "discord.js/typings/rawDataTypes";
import { after, before, beforeEach, describe, it, test } from "node:test";
import Client from "../../src/core/Client";
import { GUILD_ID, registerFileHandler, unregisterFileHandler } from "../clientsetup";
import { randomSnowflake } from "../utils";

const client = new Client(
    {
        intents: []
    },
    {
        services: ["@services/ConfigManager", "@services/PermissionManager"]
    }
);

describe("Permission Manager", () => {
    let owner_id: string, user_id: string, mod_role: string, admin_role: string;
    let roles: APIRole[];
    let guild: Guild;
    let normalMember: GuildMember, moderatorMember: GuildMember, adminMember: GuildMember, adminOnlyMember: GuildMember;

    before(() => {
        registerFileHandler();
        return client.boot();
    });

    after(() => {
        unregisterFileHandler();
    });

    test("Initialization", () => {
        assert.strictEqual(Object.keys(client.permissionManager.levels).length, 100);
        assert.deepEqual(client.permissionManager.guildPermissionLevels, {});
    });

    beforeEach(() => {
        owner_id = randomSnowflake();
        user_id = randomSnowflake();
        mod_role = randomSnowflake();
        admin_role = randomSnowflake();
        roles = (
            [
                {
                    id: mod_role,
                    name: "Moderator",
                    permissions: new PermissionsBitField(["BanMembers", "KickMembers"]).bitfield.toString()
                },
                {
                    id: admin_role,
                    name: "Admin",
                    permissions: new PermissionsBitField("Administrator").bitfield.toString()
                },
                {
                    id: GUILD_ID,
                    name: "@everyone",
                    permissions: new PermissionsBitField("SendMessages").bitfield.toString()
                }
            ] as APIRole[]
        ).map((role, index) => ({
            ...role,
            color: 0xf14a69,
            hoist: false,
            managed: true,
            mentionable: true,
            position: index
        }));

        guild = new (Guild as any)(client, {
            id: GUILD_ID,
            afk_channel_id: null,
            application_id: null,
            default_message_notifications: GuildDefaultMessageNotifications.OnlyMentions,
            description: null,
            owner_id,
            discovery_splash: null,
            name: "Test Guild",
            roles,
            banner: null
        } as Partial<APIGuild>);

        normalMember = new (GuildMember as any)(
            client,
            {
                user: {
                    discriminator: "2084",
                    global_name: "ABC",
                    id: user_id,
                    username: "root"
                },
                roles: [GUILD_ID],
                guild_id: GUILD_ID,
                joined_at: new Date().toISOString()
            } as RawGuildMemberData,
            guild
        );

        moderatorMember = new (GuildMember as any)(
            client,
            {
                user: {
                    discriminator: "2084",
                    global_name: "ABC",
                    id: user_id,
                    username: "root"
                },
                roles: [mod_role, GUILD_ID],
                guild_id: GUILD_ID,
                joined_at: new Date().toISOString()
            } as RawGuildMemberData,
            guild
        );

        adminMember = new (GuildMember as any)(
            client,
            {
                user: {
                    discriminator: "2084",
                    global_name: "ABC",
                    id: user_id,
                    username: "root"
                },
                roles: [admin_role, mod_role, GUILD_ID],
                guild_id: GUILD_ID,
                joined_at: new Date().toISOString()
            } as RawGuildMemberData,
            guild
        );

        adminOnlyMember = new (GuildMember as any)(
            client,
            {
                user: {
                    discriminator: "2084",
                    global_name: "ABC",
                    id: user_id,
                    username: "root"
                },
                roles: [admin_role, GUILD_ID],
                guild_id: GUILD_ID,
                joined_at: new Date().toISOString()
            } as RawGuildMemberData,
            guild
        );
    });

    it("Can determine member permissions", () => {
        const normalResult = [...client.permissionManager.getMemberPermissions(normalMember, true).values()];
        const moderatorResult = [...client.permissionManager.getMemberPermissions(moderatorMember, true).values()];
        const adminResult = [...client.permissionManager.getMemberPermissions(adminMember, true).values()];
        const adminOnlyResult = [...client.permissionManager.getMemberPermissions(adminOnlyMember, true).values()];

        normalResult.sort();
        moderatorResult.sort();
        adminResult.sort();
        adminOnlyResult.sort();

        assert.deepEqual(normalResult, ["SendMessages"] as PermissionsString[]);
        assert.deepEqual(moderatorResult, ["BanMembers", "KickMembers", "SendMessages"] as PermissionsString[]);
        assert.deepEqual(adminResult, ["Administrator", "BanMembers", "KickMembers", "SendMessages"] as PermissionsString[]);
        assert.deepEqual(adminOnlyResult, ["Administrator", "SendMessages"] as PermissionsString[]);
    });

    it("Can determine if a member is able to bypass AutoMod", () => {
        assert.strictEqual(client.permissionManager.isImmuneToAutoMod(normalMember), false);
        assert.strictEqual(client.permissionManager.isImmuneToAutoMod(moderatorMember), false);
        assert.strictEqual(
            client.permissionManager.isImmuneToAutoMod(moderatorMember, [PermissionsBitField.Flags.BanMembers]),
            true
        );
        assert.strictEqual(client.permissionManager.isImmuneToAutoMod(adminMember), true);
        assert.strictEqual(client.permissionManager.isImmuneToAutoMod(adminMember, [PermissionsBitField.Flags.BanMembers]), true);
        assert.strictEqual(client.permissionManager.isImmuneToAutoMod(adminOnlyMember), true);
        assert.strictEqual(
            client.permissionManager.isImmuneToAutoMod(adminOnlyMember, [PermissionsBitField.Flags.BanMembers]),
            true
        );
    });
});
1	import "../setup";
2
3	import assert from "assert";
4	import {
5	APIGuild,
6	APIRole,
7	Guild,
8	GuildDefaultMessageNotifications,
9	GuildMember,
10	PermissionsBitField,
11	PermissionsString
12	} from "discord.js";
13	import { RawGuildMemberData } from "discord.js/typings/rawDataTypes";
14	import { after, before, beforeEach, describe, it, test } from "node:test";
15	import Client from "../../src/core/Client";
16	import { GUILD_ID, registerFileHandler, unregisterFileHandler } from "../clientsetup";
17	import { randomSnowflake } from "../utils";
18
19	const client = new Client(
20	{
21	intents: []
22	},
23	{
24	services: ["@services/ConfigManager", "@services/PermissionManager"]
25	}
26	);
27
28	describe("Permission Manager", () => {
29	let owner_id: string, user_id: string, mod_role: string, admin_role: string;
30	let roles: APIRole[];
31	let guild: Guild;
32	let normalMember: GuildMember, moderatorMember: GuildMember, adminMember: GuildMember, adminOnlyMember: GuildMember;
33
34	before(() => {
35	registerFileHandler();
36	return client.boot();
37	});
38
39	after(() => {
40	unregisterFileHandler();
41	});
42
43	test("Initialization", () => {
44	assert.strictEqual(Object.keys(client.permissionManager.levels).length, 100);
45	assert.deepEqual(client.permissionManager.guildPermissionLevels, {});
46	});
47
48	beforeEach(() => {
49	owner_id = randomSnowflake();
50	user_id = randomSnowflake();
51	mod_role = randomSnowflake();
52	admin_role = randomSnowflake();
53	roles = (
54	[
55	{
56	id: mod_role,
57	name: "Moderator",
58	permissions: new PermissionsBitField(["BanMembers", "KickMembers"]).bitfield.toString()
59	},
60	{
61	id: admin_role,
62	name: "Admin",
63	permissions: new PermissionsBitField("Administrator").bitfield.toString()
64	},
65	{
66	id: GUILD_ID,
67	name: "@everyone",
68	permissions: new PermissionsBitField("SendMessages").bitfield.toString()
69	}
70	] as APIRole[]
71	).map((role, index) => ({
72	...role,
73	color: 0xf14a69,
74	hoist: false,
75	managed: true,
76	mentionable: true,
77	position: index
78	}));
79
80	guild = new (Guild as any)(client, {
81	id: GUILD_ID,
82	afk_channel_id: null,
83	application_id: null,
84	default_message_notifications: GuildDefaultMessageNotifications.OnlyMentions,
85	description: null,
86	owner_id,
87	discovery_splash: null,
88	name: "Test Guild",
89	roles,
90	banner: null
91	} as Partial<APIGuild>);
92
93	normalMember = new (GuildMember as any)(
94	client,
95	{
96	user: {
97	discriminator: "2084",
98	global_name: "ABC",
99	id: user_id,
100	username: "root"
101	},
102	roles: [GUILD_ID],
103	guild_id: GUILD_ID,
104	joined_at: new Date().toISOString()
105	} as RawGuildMemberData,
106	guild
107	);
108
109	moderatorMember = new (GuildMember as any)(
110	client,
111	{
112	user: {
113	discriminator: "2084",
114	global_name: "ABC",
115	id: user_id,
116	username: "root"
117	},
118	roles: [mod_role, GUILD_ID],
119	guild_id: GUILD_ID,
120	joined_at: new Date().toISOString()
121	} as RawGuildMemberData,
122	guild
123	);
124
125	adminMember = new (GuildMember as any)(
126	client,
127	{
128	user: {
129	discriminator: "2084",
130	global_name: "ABC",
131	id: user_id,
132	username: "root"
133	},
134	roles: [admin_role, mod_role, GUILD_ID],
135	guild_id: GUILD_ID,
136	joined_at: new Date().toISOString()
137	} as RawGuildMemberData,
138	guild
139	);
140
141	adminOnlyMember = new (GuildMember as any)(
142	client,
143	{
144	user: {
145	discriminator: "2084",
146	global_name: "ABC",
147	id: user_id,
148	username: "root"
149	},
150	roles: [admin_role, GUILD_ID],
151	guild_id: GUILD_ID,
152	joined_at: new Date().toISOString()
153	} as RawGuildMemberData,
154	guild
155	);
156	});
157
158	it("Can determine member permissions", () => {
159	const normalResult = [...client.permissionManager.getMemberPermissions(normalMember, true).values()];
160	const moderatorResult = [...client.permissionManager.getMemberPermissions(moderatorMember, true).values()];
161	const adminResult = [...client.permissionManager.getMemberPermissions(adminMember, true).values()];
162	const adminOnlyResult = [...client.permissionManager.getMemberPermissions(adminOnlyMember, true).values()];
163
164	normalResult.sort();
165	moderatorResult.sort();
166	adminResult.sort();
167	adminOnlyResult.sort();
168
169	assert.deepEqual(normalResult, ["SendMessages"] as PermissionsString[]);
170	assert.deepEqual(moderatorResult, ["BanMembers", "KickMembers", "SendMessages"] as PermissionsString[]);
171	assert.deepEqual(adminResult, ["Administrator", "BanMembers", "KickMembers", "SendMessages"] as PermissionsString[]);
172	assert.deepEqual(adminOnlyResult, ["Administrator", "SendMessages"] as PermissionsString[]);
173	});
174
175	it("Can determine if a member is able to bypass AutoMod", () => {
176	assert.strictEqual(client.permissionManager.isImmuneToAutoMod(normalMember), false);
177	assert.strictEqual(client.permissionManager.isImmuneToAutoMod(moderatorMember), false);
178	assert.strictEqual(
179	client.permissionManager.isImmuneToAutoMod(moderatorMember, [PermissionsBitField.Flags.BanMembers]),
180	true
181	);
182	assert.strictEqual(client.permissionManager.isImmuneToAutoMod(adminMember), true);
183	assert.strictEqual(client.permissionManager.isImmuneToAutoMod(adminMember, [PermissionsBitField.Flags.BanMembers]), true);
184	assert.strictEqual(client.permissionManager.isImmuneToAutoMod(adminOnlyMember), true);
185	assert.strictEqual(
186	client.permissionManager.isImmuneToAutoMod(adminOnlyMember, [PermissionsBitField.Flags.BanMembers]),
187	true
188	);
189	});
190	});