tests/utils/embed.test.ts

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