🧪 [testing improvement] Add tests for useYearInReview hook

src/hooks/__tests__/useDashboardData.test.ts

@@ -1,7 +1,7 @@
 // @vitest-environment jsdom
 import { describe, it, expect, vi, beforeEach } from "vitest";
 import { renderHook } from "@testing-library/react";
-import { useDashboardData } from "../useDashboardData";
+import { useDashboardData, useYearInReview } from "../useDashboardData";
 import { useSession } from "next-auth/react";
 import useSWR from "swr";
 
@@ -154,3 +154,184 @@ describe("useDashboardData", () => {
         expect(result.current.isLoading).toBe(true);
     });
 });
+
+
+describe("useYearInReview", () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+
+    it("handles loading state", () => {
+        vi.mocked(useSession).mockReturnValue({
+            data: null,
+            status: "loading",
+            update: vi.fn(),
+        } satisfies MockSessionReturn as unknown as MockSessionReturn);
+
+        vi.mocked(useSWR).mockReturnValue({
+            data: undefined,
+            error: undefined,
+            isLoading: false,
+            isValidating: false,
+            mutate: vi.fn(),
+        } satisfies MockSWRReturn as unknown as MockSWRReturn);
+
+        const { result } = renderHook(() => useYearInReview(2023));
+
+        expect(useSWR).toHaveBeenCalledWith(null, expect.any(Function));
+        expect(result.current.isLoading).toBe(true);
+    });
+
+    it("handles unauthenticated state", () => {
+        vi.mocked(useSession).mockReturnValue({
+            data: null,
+            status: "unauthenticated",
+            update: vi.fn(),
+        } satisfies MockSessionReturn as unknown as MockSessionReturn);
+
+        vi.mocked(useSWR).mockReturnValue({
+            data: undefined,
+            error: undefined,
+            isLoading: false,
+            isValidating: false,
+            mutate: vi.fn(),
+        } satisfies MockSWRReturn as unknown as MockSWRReturn);
+
+        const { result } = renderHook(() => useYearInReview(2023));
+
+        expect(useSWR).toHaveBeenCalledWith(null, expect.any(Function));
+        expect(result.current.isLoading).toBe(false);
+    });
+
+    it("handles authenticated state but without token", () => {
+        vi.mocked(useSession).mockReturnValue({
+            data: { user: { name: "test" }, expires: "2030-01-01T00:00:00.000Z" },
+            status: "authenticated",
+            update: vi.fn(),
+        } satisfies MockSessionReturn as unknown as MockSessionReturn);
+
+        vi.mocked(useSWR).mockReturnValue({
+            data: undefined,
+            error: undefined,
+            isLoading: false,
+            isValidating: false,
+            mutate: vi.fn(),
+        } satisfies MockSWRReturn as unknown as MockSWRReturn);
+
+        const { result } = renderHook(() => useYearInReview(2023));
+
+        expect(useSWR).toHaveBeenCalledWith(null, expect.any(Function));
+        expect(result.current.isLoading).toBe(false);
+    });
+
+    it("handles invalid year", () => {
+        vi.mocked(useSession).mockReturnValue({
+            data: { accessToken: "token123", user: { name: "test" }, expires: "2030-01-01T00:00:00.000Z" },
+            status: "authenticated",
+            update: vi.fn(),
+        } satisfies MockSessionReturn as unknown as MockSessionReturn);
+
+        vi.mocked(useSWR).mockReturnValue({
+            data: undefined,
+            error: undefined,
+            isLoading: false,
+            isValidating: false,
+            mutate: vi.fn(),
+        } satisfies MockSWRReturn as unknown as MockSWRReturn);
+
+        const { result } = renderHook(() => useYearInReview(NaN));
+
+        expect(useSWR).toHaveBeenCalledWith(null, expect.any(Function));
+        expect(result.current.isLoading).toBe(false);
+    });
+
+    it("handles null year", () => {
+        vi.mocked(useSession).mockReturnValue({
+            data: { accessToken: "token123", user: { name: "test" }, expires: "2030-01-01T00:00:00.000Z" },
+            status: "authenticated",
+            update: vi.fn(),
+        } satisfies MockSessionReturn as unknown as MockSessionReturn);
+
+        vi.mocked(useSWR).mockReturnValue({
+            data: undefined,
+            error: undefined,
+            isLoading: false,
+            isValidating: false,
+            mutate: vi.fn(),
+        } satisfies MockSWRReturn as unknown as MockSWRReturn);
+
+        const { result } = renderHook(() => useYearInReview(null));
+
+        expect(useSWR).toHaveBeenCalledWith(null, expect.any(Function));
+        expect(result.current.isLoading).toBe(false);
+    });
+
+    it("fetches data when authenticated with token and valid year", () => {
+        const mockMutate = vi.fn();
+        const mockSession = {
+            data: { accessToken: "token123", user: { name: "test" }, expires: "2030-01-01T00:00:00.000Z" },
+            status: "authenticated" as const,
+            update: vi.fn(),
+        };
+        vi.mocked(useSession).mockReturnValue(mockSession satisfies MockSessionReturn as unknown as MockSessionReturn);
+
+        vi.mocked(useSWR).mockReturnValue({
+            data: {
+                totalContributions: 100,
+            },
+            error: null,
+            isLoading: false,
+            isValidating: false,
+            mutate: mockMutate,
+        } satisfies MockSWRReturn as unknown as MockSWRReturn);
+
+        const { result } = renderHook(() => useYearInReview(2023));
+
+        expect(useSWR).toHaveBeenCalledWith("/api/dashboard/year?year=2023", expect.any(Function));
+        expect(result.current.isLoading).toBe(false);
+        expect(result.current.data).toEqual({ totalContributions: 100 });
+        expect(result.current.error).toBeNull();
+        expect(result.current.mutate).toBe(mockMutate);
+    });
+
+    it("handles SWR error", () => {
+        const mockError = new Error("SWR failed");
+        vi.mocked(useSession).mockReturnValue({
+            data: { accessToken: "token123", expires: "2030-01-01T00:00:00.000Z" },
+            status: "authenticated",
+            update: vi.fn(),
+        } satisfies MockSessionReturn as unknown as MockSessionReturn);
+
+        vi.mocked(useSWR).mockReturnValue({
+            data: undefined,
+            error: mockError,
+            isLoading: false,
+            isValidating: false,
+            mutate: vi.fn(),
+        } satisfies MockSWRReturn as unknown as MockSWRReturn);
+
+        const { result } = renderHook(() => useYearInReview(2023));
+
+        expect(result.current.error).toBe(mockError);
+    });
+
+    it("handles SWR loading", () => {
+        vi.mocked(useSession).mockReturnValue({
+            data: { accessToken: "token123", expires: "2030-01-01T00:00:00.000Z" },
+            status: "authenticated",
+            update: vi.fn(),
+        } satisfies MockSessionReturn as unknown as MockSessionReturn);
+
+        vi.mocked(useSWR).mockReturnValue({
+            data: undefined,
+            error: undefined,
+            isLoading: true,
+            isValidating: false,
+            mutate: vi.fn(),
+        } satisfies MockSWRReturn as unknown as MockSWRReturn);
+
+        const { result } = renderHook(() => useYearInReview(2023));
+
+        expect(result.current.isLoading).toBe(true);
+    });
+});