tests/utils/cache.test.ts

import { cache, resetCache } from "@/utils/cache";
import { beforeEach, describe, expect, it, vi } from "vitest";

describe("caching utilities", () => {
    beforeEach(() => {
        resetCache();
    });

    it("should cache a value", () => {
        const callback = vi.fn(() => Math.random());
        const cached = cache("callback", callback);
        expect(cached()).toBe(cached());
        expect(callback.mock.calls.length).toBe(1);
    });

    it("should cache a value with a TTL", { repeats: 10 }, async () => {
        const callback = vi.fn(() => Math.random());
        const cached = cache("callback", callback, { ttl: 100 });
        expect(cached()).toBe(cached());
        expect(callback.mock.calls.length).toBe(1);
        await new Promise(resolve => setTimeout(resolve, 110));
        expect(cached()).toBe(cached());
        expect(callback.mock.calls.length).toBe(2);
    });

    it("should cache a value with an onHit callback", () => {
        const callback = vi.fn(() => Math.random());
        const onHit = vi.fn();
        const cached = cache("callback", callback, { onHit });
        expect(cached()).toBe(cached());
        expect(onHit.mock.calls.length).toBe(1);
    });

    it("should cache a value with an onHit callback and a TTL", { repeats: 10 }, async () => {
        const callback = vi.fn(() => Math.random());
        const onHit = vi.fn();
        const cached = cache("callback", callback, { ttl: 100, onHit });
        expect(cached()).toBe(cached());
        expect(onHit.mock.calls.length).toBe(1);
        await new Promise(resolve => setTimeout(resolve, 110));
        expect(cached()).toBe(cached());
        expect(onHit.mock.calls.length).toBe(2);
    });

    it("it should cache a value with an invoke option", () => {
        const callback = vi.fn(() => Math.random());
        const cached = cache("callback", callback, { invoke: true });
        expect(cached).toBe(cached);
        expect(callback.mock.calls.length).toBe(1);
    });

    it("it can clear the cache", () => {
        const callback = vi.fn(() => Math.random());
        const cached = cache("callback", callback);
        expect(cached()).toBe(cached());
        resetCache();
        expect(cached()).toBe(cached());
        expect(callback.mock.calls.length).toBe(2);
    });
});
1	import { cache, resetCache } from "@/utils/cache";
2	import { beforeEach, describe, expect, it, vi } from "vitest";
3
4	describe("caching utilities", () => {
5	beforeEach(() => {
6	resetCache();
7	});
8
9	it("should cache a value", () => {
10	const callback = vi.fn(() => Math.random());
11	const cached = cache("callback", callback);
12	expect(cached()).toBe(cached());
13	expect(callback.mock.calls.length).toBe(1);
14	});
15
16	it("should cache a value with a TTL", { repeats: 10 }, async () => {
17	const callback = vi.fn(() => Math.random());
18	const cached = cache("callback", callback, { ttl: 100 });
19	expect(cached()).toBe(cached());
20	expect(callback.mock.calls.length).toBe(1);
21	await new Promise(resolve => setTimeout(resolve, 110));
22	expect(cached()).toBe(cached());
23	expect(callback.mock.calls.length).toBe(2);
24	});
25
26	it("should cache a value with an onHit callback", () => {
27	const callback = vi.fn(() => Math.random());
28	const onHit = vi.fn();
29	const cached = cache("callback", callback, { onHit });
30	expect(cached()).toBe(cached());
31	expect(onHit.mock.calls.length).toBe(1);
32	});
33
34	it("should cache a value with an onHit callback and a TTL", { repeats: 10 }, async () => {
35	const callback = vi.fn(() => Math.random());
36	const onHit = vi.fn();
37	const cached = cache("callback", callback, { ttl: 100, onHit });
38	expect(cached()).toBe(cached());
39	expect(onHit.mock.calls.length).toBe(1);
40	await new Promise(resolve => setTimeout(resolve, 110));
41	expect(cached()).toBe(cached());
42	expect(onHit.mock.calls.length).toBe(2);
43	});
44
45	it("it should cache a value with an invoke option", () => {
46	const callback = vi.fn(() => Math.random());
47	const cached = cache("callback", callback, { invoke: true });
48	expect(cached).toBe(cached);
49	expect(callback.mock.calls.length).toBe(1);
50	});
51
52	it("it can clear the cache", () => {
53	const callback = vi.fn(() => Math.random());
54	const cached = cache("callback", callback);
55	expect(cached()).toBe(cached());
56	resetCache();
57	expect(cached()).toBe(cached());
58	expect(callback.mock.calls.length).toBe(2);
59	});
60	});