framework/arguments/GuildMemberArgument.test.ts

import { Casted } from "@framework/arguments/Argument";
import GuildMemberArgument from "@framework/arguments/GuildMemberArgument";
import * as entityUtils from "@framework/utils/entities";
import { Guild, GuildMember, Snowflake, User } from "discord.js";
import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
import { createApplication } from "../../mocks/application.mock";
import { randomSnowflake } from "../../mocks/snowflakes";
import { initialize } from "./ArgumentTestUtils";

const fetchMember = vi
    .spyOn(entityUtils, "fetchMember")
    .mockImplementation(async (guild: Guild, memberId: Snowflake) => {
        if (memberId === "11111111111111111") {
            return null;
        }

        return {
            [Symbol.hasInstance]: (obj: unknown) => obj === GuildMember,
            id: memberId,
            guild,
            user: {
                id: memberId
            }
        } as unknown as GuildMember;
    });

describe("GuildMemberArgument", () => {
    createApplication();

    let userId: Snowflake, guildId: Snowflake;
    let data: ReturnType<typeof initialize>;

    beforeEach(() => {
        userId = randomSnowflake();
        guildId = randomSnowflake();
    });

    afterEach(() => {
        fetchMember.mockClear();
    });

    it("should parse a guild member argument with mentions", async () => {
        data = initialize({
            content: `test <@${userId}>`,
            userId,
            guildId,
            prefix: "!"
        });

        const result = (await GuildMemberArgument.performCast(
            data.context,
            data.content,
            data.argv,
            data.argv[1],
            0,
            "testarg",
            undefined,
            true
        )) as Casted<User>;

        expect(result.value?.getRawValue()).toBe(`<@${userId}>`);
        expect(result.value?.getValue().id).toBe(userId);
        expect(result.error).toBeUndefined();
        expect(fetchMember).toBeCalledWith(data.message.guild, userId);
        expect(fetchMember).toBeCalledTimes(1);
    });

    it("should parse a guild member argument with snowflake IDs", async () => {
        data = initialize({
            content: `test ${userId}`,
            userId,
            guildId,
            prefix: "!"
        });

        const result = (await GuildMemberArgument.performCast(
            data.context,
            data.content,
            data.argv,
            data.argv[1],
            0,
            "testarg",
            undefined,
            true
        )) as Casted<User>;

        expect(result.value?.getRawValue()).toBe(`${userId}`);
        expect(result.value?.getValue().id).toBe(userId);
        expect(result.error).toBeUndefined();
        expect(fetchMember).toBeCalledWith(data.message.guild, userId);
        expect(fetchMember).toBeCalledTimes(1);
    });
});
1	rakinar2	575	import { Casted } from "@framework/arguments/Argument";
2			import GuildMemberArgument from "@framework/arguments/GuildMemberArgument";
3			import * as entityUtils from "@framework/utils/entities";
4			import { Guild, GuildMember, Snowflake, User } from "discord.js";
5			import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
6			import { createApplication } from "../../mocks/application.mock";
7			import { randomSnowflake } from "../../mocks/snowflakes";
8			import { initialize } from "./ArgumentTestUtils";
9
10			const fetchMember = vi
11			.spyOn(entityUtils, "fetchMember")
12			.mockImplementation(async (guild: Guild, memberId: Snowflake) => {
13			if (memberId === "11111111111111111") {
14			return null;
15			}
16
17			return {
18			[Symbol.hasInstance]: (obj: unknown) => obj === GuildMember,
19			id: memberId,
20			guild,
21			user: {
22			id: memberId
23			}
24			} as unknown as GuildMember;
25			});
26
27			describe("GuildMemberArgument", () => {
28			createApplication();
29
30			let userId: Snowflake, guildId: Snowflake;
31			let data: ReturnType<typeof initialize>;
32
33			beforeEach(() => {
34			userId = randomSnowflake();
35			guildId = randomSnowflake();
36			});
37
38			afterEach(() => {
39			fetchMember.mockClear();
40			});
41
42			it("should parse a guild member argument with mentions", async () => {
43			data = initialize({
44			content: `test <@${userId}>`,
45			userId,
46			guildId,
47			prefix: "!"
48			});
49
50			const result = (await GuildMemberArgument.performCast(
51			data.context,
52			data.content,
53			data.argv,
54			data.argv[1],
55			0,
56			"testarg",
57			undefined,
58			true
59			)) as Casted<User>;
60
61			expect(result.value?.getRawValue()).toBe(`<@${userId}>`);
62			expect(result.value?.getValue().id).toBe(userId);
63			expect(result.error).toBeUndefined();
64			expect(fetchMember).toBeCalledWith(data.message.guild, userId);
65			expect(fetchMember).toBeCalledTimes(1);
66			});
67
68			it("should parse a guild member argument with snowflake IDs", async () => {
69			data = initialize({
70			content: `test ${userId}`,
71			userId,
72			guildId,
73			prefix: "!"
74			});
75
76			const result = (await GuildMemberArgument.performCast(
77			data.context,
78			data.content,
79			data.argv,
80			data.argv[1],
81			0,
82			"testarg",
83			undefined,
84			true
85			)) as Casted<User>;
86
87			expect(result.value?.getRawValue()).toBe(`${userId}`);
88			expect(result.value?.getValue().id).toBe(userId);
89			expect(result.error).toBeUndefined();
90			expect(fetchMember).toBeCalledWith(data.message.guild, userId);
91			expect(fetchMember).toBeCalledTimes(1);
92			});
93			});