framework/pagination/Pagination.test.ts

import Pagination from "@framework/pagination/Pagination";
import { describe, expect, it, vi } from "vitest";
import { createApplication } from "../../mocks/application.mock";

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

    it("should initialize with default values", () => {
        const pagination = new Pagination();

        expect(pagination.state).toEqual({ page: 1 });
        expect(pagination.limit).toBe(10);
    });

    it("should set fetcher correctly", () => {
        const fetcher = vi.fn();
        const pagination = new Pagination().setFetcher(fetcher);

        expect(pagination["_fetcher"]).toBe(fetcher);
    });

    it("should set count getter correctly", () => {
        const getCount = vi.fn();
        const pagination = new Pagination().setCountGetter(getCount);

        expect(pagination["_getCount"]).toBe(getCount);
    });

    it("should set initial message correctly", () => {
        const message = {} as any;
        const pagination = new Pagination().setInitialMessage(message);

        expect(pagination["_initialMessage"]).toBe(message);
    });

    it("should set data correctly", () => {
        const data = [1, 2, 3];
        const pagination = new Pagination().setData(data);

        expect(pagination["_cachedData"]).toBe(data);
    });

    it("should set limit correctly", () => {
        const limit = 20;
        const pagination = new Pagination().setLimit(limit);

        expect(pagination["_limit"]).toBe(limit);
    });

    it("should set message options builder correctly", () => {
        const builder = vi.fn();
        const pagination = new Pagination().setMessageOptionsBuilder(builder);

        expect(pagination["_builder"]).toBe(builder);
    });

    it("should set action row builder correctly", () => {
        const builder = vi.fn();
        const pagination = new Pagination().setActionRowBuilder(builder);

        expect(pagination["_actionRowBuilder"]).toBe(builder);
    });

    it("should calculate offset correctly", () => {
        const pagination = new Pagination().setLimit(10);

        expect(pagination["calculateOffset"].call(pagination, 1)).toBe(0);
        expect(pagination["calculateOffset"].call(pagination, 2)).toBe(10);
        expect(pagination["calculateOffset"].call(pagination, 3)).toBe(20);
    });

    it("should get slice correctly", async () => {
        const data = [1, 2, 3, 4, 5];
        const pagination = new Pagination().setData(data).setLimit(2);

        expect(await pagination["getSlice"].call(pagination, 1)).toEqual([1, 2]);
        expect(await pagination["getSlice"].call(pagination, 2)).toEqual([3, 4]);
        expect(await pagination["getSlice"].call(pagination, 3)).toEqual([5]);
    });

    it("should get message options correctly", async () => {
        const data = [1, 2, 3];
        const builder = vi.fn().mockResolvedValue({});
        const pagination = new Pagination().setData(data).setMessageOptionsBuilder(builder);

        await pagination["getMessageOptions"].call(pagination);

        expect(builder).toHaveBeenCalledWith({
            data,
            pagination,
            state: pagination.state,
            maxPages: await pagination["calculateMaxPages"].call(pagination),
            page: pagination.state.page
        });
    });

    it("should destroy pagination correctly", async () => {
        const message = {
            edit: vi.fn()
        } as any;
        const pagination = new Pagination().setInitialMessage(message);
        pagination["getMessageOptions"] = vi.fn().mockResolvedValue({});

        await pagination.destroy();

        expect(pagination["_destroyed"]).toBe(true);
        expect(pagination["_timeout"]).toBeUndefined();
        expect(pagination["_initialMessage"]?.edit).toHaveBeenCalledWith({});
    });

    it("should calculate max pages correctly", async () => {
        const getCount = vi.fn().mockResolvedValue(15);
        const pagination = new Pagination().setCountGetter(getCount).setLimit(5);

        expect(await pagination["calculateMaxPages"].call(pagination)).toBe(3);
    });

    it("should get action row correctly", async () => {
        const pagination = new Pagination().setLimit(10);
        pagination["calculateMaxPages"] = vi.fn().mockResolvedValue(3);

        const actionRow = await pagination["getActionRow"].call(pagination);

        expect(actionRow).toBeDefined();
        expect(actionRow.components.length).toBe(4);
    });

    it("should create pagination with fetcher", () => {
        const fetcher = vi.fn();
        const pagination = Pagination.withFetcher(fetcher);

        expect(pagination["_fetcher"]).toBe(fetcher);
    });

    it("should create pagination with data", () => {
        const data = [1, 2, 3];
        const pagination = Pagination.withData(data);

        expect(pagination["_cachedData"]).toBe(data);
    });

    it("should create pagination with data using 'of' method", () => {
        const data = [1, 2, 3];
        const pagination = Pagination.of(data);

        expect(pagination["_cachedData"]).toBe(data);
    });
});
1	rakinar2	575	import Pagination from "@framework/pagination/Pagination";
2			import { describe, expect, it, vi } from "vitest";
3			import { createApplication } from "../../mocks/application.mock";
4
5			describe("Pagination", () => {
6			createApplication();
7
8			it("should initialize with default values", () => {
9			const pagination = new Pagination();
10
11			expect(pagination.state).toEqual({ page: 1 });
12			expect(pagination.limit).toBe(10);
13			});
14
15			it("should set fetcher correctly", () => {
16			const fetcher = vi.fn();
17			const pagination = new Pagination().setFetcher(fetcher);
18
19			expect(pagination["_fetcher"]).toBe(fetcher);
20			});
21
22			it("should set count getter correctly", () => {
23			const getCount = vi.fn();
24			const pagination = new Pagination().setCountGetter(getCount);
25
26			expect(pagination["_getCount"]).toBe(getCount);
27			});
28
29			it("should set initial message correctly", () => {
30			const message = {} as any;
31			const pagination = new Pagination().setInitialMessage(message);
32
33			expect(pagination["_initialMessage"]).toBe(message);
34			});
35
36			it("should set data correctly", () => {
37			const data = [1, 2, 3];
38			const pagination = new Pagination().setData(data);
39
40			expect(pagination["_cachedData"]).toBe(data);
41			});
42
43			it("should set limit correctly", () => {
44			const limit = 20;
45			const pagination = new Pagination().setLimit(limit);
46
47			expect(pagination["_limit"]).toBe(limit);
48			});
49
50			it("should set message options builder correctly", () => {
51			const builder = vi.fn();
52			const pagination = new Pagination().setMessageOptionsBuilder(builder);
53
54			expect(pagination["_builder"]).toBe(builder);
55			});
56
57			it("should set action row builder correctly", () => {
58			const builder = vi.fn();
59			const pagination = new Pagination().setActionRowBuilder(builder);
60
61			expect(pagination["_actionRowBuilder"]).toBe(builder);
62			});
63
64			it("should calculate offset correctly", () => {
65			const pagination = new Pagination().setLimit(10);
66
67			expect(pagination["calculateOffset"].call(pagination, 1)).toBe(0);
68			expect(pagination["calculateOffset"].call(pagination, 2)).toBe(10);
69			expect(pagination["calculateOffset"].call(pagination, 3)).toBe(20);
70			});
71
72			it("should get slice correctly", async () => {
73			const data = [1, 2, 3, 4, 5];
74			const pagination = new Pagination().setData(data).setLimit(2);
75
76			expect(await pagination["getSlice"].call(pagination, 1)).toEqual([1, 2]);
77			expect(await pagination["getSlice"].call(pagination, 2)).toEqual([3, 4]);
78			expect(await pagination["getSlice"].call(pagination, 3)).toEqual([5]);
79			});
80
81			it("should get message options correctly", async () => {
82			const data = [1, 2, 3];
83			const builder = vi.fn().mockResolvedValue({});
84			const pagination = new Pagination().setData(data).setMessageOptionsBuilder(builder);
85
86			await pagination["getMessageOptions"].call(pagination);
87
88			expect(builder).toHaveBeenCalledWith({
89			data,
90			pagination,
91			state: pagination.state,
92			maxPages: await pagination["calculateMaxPages"].call(pagination),
93			page: pagination.state.page
94			});
95			});
96
97			it("should destroy pagination correctly", async () => {
98			const message = {
99			edit: vi.fn()
100			} as any;
101			const pagination = new Pagination().setInitialMessage(message);
102			pagination["getMessageOptions"] = vi.fn().mockResolvedValue({});
103
104			await pagination.destroy();
105
106			expect(pagination["_destroyed"]).toBe(true);
107			expect(pagination["_timeout"]).toBeUndefined();
108			expect(pagination["_initialMessage"]?.edit).toHaveBeenCalledWith({});
109			});
110
111			it("should calculate max pages correctly", async () => {
112			const getCount = vi.fn().mockResolvedValue(15);
113			const pagination = new Pagination().setCountGetter(getCount).setLimit(5);
114
115			expect(await pagination["calculateMaxPages"].call(pagination)).toBe(3);
116			});
117
118			it("should get action row correctly", async () => {
119			const pagination = new Pagination().setLimit(10);
120			pagination["calculateMaxPages"] = vi.fn().mockResolvedValue(3);
121
122			const actionRow = await pagination["getActionRow"].call(pagination);
123
124			expect(actionRow).toBeDefined();
125			expect(actionRow.components.length).toBe(4);
126			});
127
128			it("should create pagination with fetcher", () => {
129			const fetcher = vi.fn();
130			const pagination = Pagination.withFetcher(fetcher);
131
132			expect(pagination["_fetcher"]).toBe(fetcher);
133			});
134
135			it("should create pagination with data", () => {
136			const data = [1, 2, 3];
137			const pagination = Pagination.withData(data);
138
139			expect(pagination["_cachedData"]).toBe(data);
140			});
141
142			it("should create pagination with data using 'of' method", () => {
143			const data = [1, 2, 3];
144			const pagination = Pagination.of(data);
145
146			expect(pagination["_cachedData"]).toBe(data);
147			});
148			});