tests/utils/embed.test.ts

import { faker } from "@faker-js/faker";
import { ColorResolvable, Colors, EmbedBuilder, User } from "discord.js";
import { beforeEach, describe, expect, it } from "vitest";
import { ChatInputCommandContext } from "../../src/services/CommandManager";
import { generateEmbed, guildInfo, userInfo } from "../../src/utils/embed";
import { createClient } from "../mocks/client.mock";
import { createGuild, createInvite } from "../mocks/guild.mock";
import { randomSnowflake } from "../mocks/snowflakes";

describe("generateEmbed", () => {
    let authorIconURL: string;
    let footerIconURL: string;
    let thumbnailURL: string;
    let imageURL: string;
    let videoURL: string;
    let timestamp: Date;

    let options: ChatInputCommandContext["options"];

    beforeEach(() => {
        authorIconURL = faker.image.avatar();
        footerIconURL = faker.image.avatar();
        thumbnailURL = faker.image.avatar();
        imageURL = faker.image.avatar();
        videoURL = faker.internet.url() + "1.mp4";
        timestamp = new Date();

        options = {
            getString: (field: string) => {
                switch (field) {
                    case "author_name":
                        return "author";
                    case "author_iconurl":
                        return authorIconURL;
                    case "footer_text":
                        return "footer";
                    case "footer_iconurl":
                        return footerIconURL;
                    case "color":
                        return Colors.Red satisfies ColorResolvable;
                    case "title":
                        return "title";
                    case "description":
                        return "description";
                    case "thumbnail":
                        return thumbnailURL;
                    case "image":
                        return imageURL;
                    case "video":
                        return videoURL;
                    case "timestamp":
                        return timestamp.toISOString();
                    case "fields":
                        return "name: value";
                    default:
                        return undefined;
                }
            }
        } as ChatInputCommandContext["options"];
    });

    it("should generate an embed", () => {
        const embed = generateEmbed(options);

        expect(embed).toEqual({
            embed: new EmbedBuilder({
                video: {
                    url: videoURL
                }
            })
                .setAuthor({
                    name: "author",
                    iconURL: authorIconURL
                })
                .setTitle("title")
                .setDescription("description")
                .setThumbnail(thumbnailURL)
                .setImage(imageURL)

                .setFooter({
                    text: "footer",
                    iconURL: footerIconURL
                })
                .setTimestamp(timestamp)
                .addFields({
                    name: "name",
                    value: "value"
                })
                .setColor(Colors.Red)
        });
    });

    it("should return an error if the color is invalid", () => {
        const original = options.getString;

        options.getString = ((field: string) => {
            if (field === "color") {
                return "invalid";
            }

            return original(field);
        }) as typeof options.getString;

        const embed = generateEmbed(options);

        expect(embed).toEqual({
            error: "Invalid color given."
        });
    });

    it("should set the timestamp to the current date if the timestamp is 'current'", () => {
        const original = options.getString;

        options.getString = ((field: string) => {
            if (field === "timestamp") {
                return "current";
            }

            return original(field);
        }) as typeof options.getString;

        const startTime = Date.now();
        const embed = generateEmbed(options);
        const endTime = Date.now();

        expect(new Date(embed.embed?.toJSON().timestamp ?? "").getTime()).greaterThanOrEqual(
            startTime
        );
        expect(new Date(embed.embed?.toJSON().timestamp ?? "").getTime()).lessThanOrEqual(endTime);
    });
});

describe("userInfo", () => {
    it("should return the user info", () => {
        const user = {
            id: randomSnowflake(),
            username: faker.internet.userName(),
            client: createClient(),
            toString() {
                return `<@${this.id}>`;
            }
        } as unknown as User;

        const info = userInfo(user);
        expect(info).toBe(
            `ID: ${user.id}\nUsername: ${user.username}\nMention: ${user.toString()}`
        );
    });

    it("should return the system user info if the user is the bot", () => {
        const user = createClient().user;

        const info1 = userInfo(user, true);
        const info2 = userInfo(user, false);

        expect(info1).toBe("System");
        expect(info2).toBe(`Type: __System__\nMention: ${user.toString()}`);
    });
});

describe("guildInfo", () => {
    it("should return the guild info", () => {
        const guild = createGuild();
        const invite = createInvite();

        guild.id = "123456789";
        guild.name = "Test Guild";
        guild.invites.cache.set("inviteCode", invite);

        const info = guildInfo(guild);

        expect(info).toBe(`ID: 123456789\nName: Test Guild\nInvite: ${invite.url}`);
    });

    it("should return 'Unavailable' if the guild invite is not available", () => {
        const guild = createGuild();

        guild.id = "987654321";
        guild.name = "Another Guild";

        const info = guildInfo(guild);

        expect(info).toBe("ID: 987654321\nName: Another Guild\nInvite: *Unavailable*");
    });
});
1	import { faker } from "@faker-js/faker";
2	import { ColorResolvable, Colors, EmbedBuilder, User } from "discord.js";
3	import { beforeEach, describe, expect, it } from "vitest";
4	import { ChatInputCommandContext } from "../../src/services/CommandManager";
5	import { generateEmbed, guildInfo, userInfo } from "../../src/utils/embed";
6	import { createClient } from "../mocks/client.mock";
7	import { createGuild, createInvite } from "../mocks/guild.mock";
8	import { randomSnowflake } from "../mocks/snowflakes";
9
10	describe("generateEmbed", () => {
11	let authorIconURL: string;
12	let footerIconURL: string;
13	let thumbnailURL: string;
14	let imageURL: string;
15	let videoURL: string;
16	let timestamp: Date;
17
18	let options: ChatInputCommandContext["options"];
19
20	beforeEach(() => {
21	authorIconURL = faker.image.avatar();
22	footerIconURL = faker.image.avatar();
23	thumbnailURL = faker.image.avatar();
24	imageURL = faker.image.avatar();
25	videoURL = faker.internet.url() + "1.mp4";
26	timestamp = new Date();
27
28	options = {
29	getString: (field: string) => {
30	switch (field) {
31	case "author_name":
32	return "author";
33	case "author_iconurl":
34	return authorIconURL;
35	case "footer_text":
36	return "footer";
37	case "footer_iconurl":
38	return footerIconURL;
39	case "color":
40	return Colors.Red satisfies ColorResolvable;
41	case "title":
42	return "title";
43	case "description":
44	return "description";
45	case "thumbnail":
46	return thumbnailURL;
47	case "image":
48	return imageURL;
49	case "video":
50	return videoURL;
51	case "timestamp":
52	return timestamp.toISOString();
53	case "fields":
54	return "name: value";
55	default:
56	return undefined;
57	}
58	}
59	} as ChatInputCommandContext["options"];
60	});
61
62	it("should generate an embed", () => {
63	const embed = generateEmbed(options);
64
65	expect(embed).toEqual({
66	embed: new EmbedBuilder({
67	video: {
68	url: videoURL
69	}
70	})
71	.setAuthor({
72	name: "author",
73	iconURL: authorIconURL
74	})
75	.setTitle("title")
76	.setDescription("description")
77	.setThumbnail(thumbnailURL)
78	.setImage(imageURL)
79
80	.setFooter({
81	text: "footer",
82	iconURL: footerIconURL
83	})
84	.setTimestamp(timestamp)
85	.addFields({
86	name: "name",
87	value: "value"
88	})
89	.setColor(Colors.Red)
90	});
91	});
92
93	it("should return an error if the color is invalid", () => {
94	const original = options.getString;
95
96	options.getString = ((field: string) => {
97	if (field === "color") {
98	return "invalid";
99	}
100
101	return original(field);
102	}) as typeof options.getString;
103
104	const embed = generateEmbed(options);
105
106	expect(embed).toEqual({
107	error: "Invalid color given."
108	});
109	});
110
111	it("should set the timestamp to the current date if the timestamp is 'current'", () => {
112	const original = options.getString;
113
114	options.getString = ((field: string) => {
115	if (field === "timestamp") {
116	return "current";
117	}
118
119	return original(field);
120	}) as typeof options.getString;
121
122	const startTime = Date.now();
123	const embed = generateEmbed(options);
124	const endTime = Date.now();
125
126	expect(new Date(embed.embed?.toJSON().timestamp ?? "").getTime()).greaterThanOrEqual(
127	startTime
128	);
129	expect(new Date(embed.embed?.toJSON().timestamp ?? "").getTime()).lessThanOrEqual(endTime);
130	});
131	});
132
133	describe("userInfo", () => {
134	it("should return the user info", () => {
135	const user = {
136	id: randomSnowflake(),
137	username: faker.internet.userName(),
138	client: createClient(),
139	toString() {
140	return `<@${this.id}>`;
141	}
142	} as unknown as User;
143
144	const info = userInfo(user);
145	expect(info).toBe(
146	`ID: ${user.id}\nUsername: ${user.username}\nMention: ${user.toString()}`
147	);
148	});
149
150	it("should return the system user info if the user is the bot", () => {
151	const user = createClient().user;
152
153	const info1 = userInfo(user, true);
154	const info2 = userInfo(user, false);
155
156	expect(info1).toBe("System");
157	expect(info2).toBe(`Type: __System__\nMention: ${user.toString()}`);
158	});
159	});
160
161	describe("guildInfo", () => {
162	it("should return the guild info", () => {
163	const guild = createGuild();
164	const invite = createInvite();
165
166	guild.id = "123456789";
167	guild.name = "Test Guild";
168	guild.invites.cache.set("inviteCode", invite);
169
170	const info = guildInfo(guild);
171
172	expect(info).toBe(`ID: 123456789\nName: Test Guild\nInvite: ${invite.url}`);
173	});
174
175	it("should return 'Unavailable' if the guild invite is not available", () => {
176	const guild = createGuild();
177
178	guild.id = "987654321";
179	guild.name = "Another Guild";
180
181	const info = guildInfo(guild);
182
183	expect(info).toBe("ID: 987654321\nName: Another Guild\nInvite: Unavailable");
184	});
185	});