From d65621a556e960b5faa67d089a6475c0b1b6c79b Mon Sep 17 00:00:00 2001 From: Jason Date: Sat, 25 Oct 2025 22:51:51 +0800 Subject: [PATCH] test: add error handling and edge case tests for hooks useSettings Tests: - Add test for null settings state protection - Returns null immediately without calling APIs - Prevents null pointer errors in save flow - Add test for save mutation failure - Verifies error propagates to caller - Ensures restart flag remains untouched on failure - Validates no side effects when save fails useProviderActions Tests: - Add error propagation tests for CRUD operations - updateProvider: propagates errors to caller - addProvider: propagates errors to caller - deleteProvider: propagates errors to caller - Add switch mutation error handling tests - Claude switch: handles errors silently (no throw) - Codex switch: skips plugin sync when mutation fails - Verifies plugin sync APIs not called on failure - Add loading state verification - Test all mutations pending scenario (existing) - Test all mutations idle scenario (new) - Ensures isLoading flag accuracy useImportExport Edge Case Tests (new file): - Add test for user cancelling file dialog - File dialog returns null (user cancelled) - State remains unchanged (selectedFile: "", status: "idle") - No error toast shown - Add test for resetStatus behavior - Clears error message and status - Preserves selected file path for retry - Resets backupId to null All tests passing: 79/79 (10 new tests) --- tests/hooks/useImportExport.extra.test.tsx | 76 ++++++++++++++++++ tests/hooks/useProviderActions.test.tsx | 92 ++++++++++++++++++++++ tests/hooks/useSettings.test.tsx | 38 +++++++++ 3 files changed, 206 insertions(+) create mode 100644 tests/hooks/useImportExport.extra.test.tsx diff --git a/tests/hooks/useImportExport.extra.test.tsx b/tests/hooks/useImportExport.extra.test.tsx new file mode 100644 index 0000000..014097e --- /dev/null +++ b/tests/hooks/useImportExport.extra.test.tsx @@ -0,0 +1,76 @@ +import { renderHook, act } from "@testing-library/react"; +import { describe, it, expect, vi, beforeEach, afterEach } from "vitest"; +import { useImportExport } from "@/hooks/useImportExport"; + +const toastSuccessMock = vi.fn(); +const toastErrorMock = vi.fn(); + +vi.mock("sonner", () => ({ + toast: { + success: (...args: unknown[]) => toastSuccessMock(...args), + error: (...args: unknown[]) => toastErrorMock(...args), + }, +})); + +const openFileDialogMock = vi.fn(); +const importConfigMock = vi.fn(); + +vi.mock("@/lib/api", () => ({ + settingsApi: { + openFileDialog: (...args: unknown[]) => openFileDialogMock(...args), + importConfigFromFile: (...args: unknown[]) => importConfigMock(...args), + saveFileDialog: vi.fn(), + exportConfigToFile: vi.fn(), + }, +})); + +describe("useImportExport Hook (edge cases)", () => { + beforeEach(() => { + openFileDialogMock.mockReset(); + importConfigMock.mockReset(); + toastSuccessMock.mockReset(); + toastErrorMock.mockReset(); + vi.useFakeTimers(); + }); + + afterEach(() => { + vi.useRealTimers(); + }); + + it("keeps state unchanged when file dialog resolves to null", async () => { + openFileDialogMock.mockResolvedValue(null); + const { result } = renderHook(() => useImportExport()); + + await act(async () => { + await result.current.selectImportFile(); + }); + + expect(result.current.selectedFile).toBe(""); + expect(result.current.status).toBe("idle"); + expect(toastErrorMock).not.toHaveBeenCalled(); + }); + + it("resetStatus clears errors but preserves selected file", async () => { + openFileDialogMock.mockResolvedValue("/config.json"); + importConfigMock.mockResolvedValue({ success: false, message: "broken" }); + const { result } = renderHook(() => useImportExport()); + + await act(async () => { + await result.current.selectImportFile(); + }); + + await act(async () => { + await result.current.importConfig(); + }); + + act(() => { + result.current.resetStatus(); + }); + + expect(result.current.selectedFile).toBe("/config.json"); + expect(result.current.status).toBe("idle"); + expect(result.current.errorMessage).toBeNull(); + expect(result.current.backupId).toBeNull(); + }); + +}); diff --git a/tests/hooks/useProviderActions.test.tsx b/tests/hooks/useProviderActions.test.tsx index 2e329ac..427b47b 100644 --- a/tests/hooks/useProviderActions.test.tsx +++ b/tests/hooks/useProviderActions.test.tsx @@ -223,6 +223,22 @@ describe("useProviderActions", () => { expect(toastErrorMock.mock.calls[0]?.[0]).toBe("Sync failed"); }); + it("propagates updateProvider errors", async () => { + updateProviderMutateAsync.mockRejectedValueOnce(new Error("update failed")); + const { wrapper } = createWrapper(); + const provider = createProvider(); + + const { result } = renderHook(() => useProviderActions("claude"), { + wrapper, + }); + + await expect( + act(async () => { + await result.current.updateProvider(provider); + }), + ).rejects.toThrow("update failed"); + }); + it("should use default error message when plugin sync fails without error message", async () => { switchProviderMutateAsync.mockResolvedValueOnce(undefined); settingsApiGetMock.mockResolvedValueOnce({ @@ -244,6 +260,20 @@ describe("useProviderActions", () => { expect(toastErrorMock.mock.calls[0]?.[0]).toBe("同步 Claude 插件失败"); }); + it("handles mutation errors when plugin sync is skipped", async () => { + switchProviderMutateAsync.mockRejectedValueOnce(new Error("switch failed")); + const { wrapper } = createWrapper(); + const provider = createProvider(); + + const { result } = renderHook(() => useProviderActions("codex"), { + wrapper, + }); + + await expect(result.current.switchProvider(provider)).resolves.toBeUndefined(); + expect(settingsApiGetMock).not.toHaveBeenCalled(); + expect(settingsApiApplyMock).not.toHaveBeenCalled(); + }); + it("should call delete mutation when calling deleteProvider", async () => { deleteProviderMutateAsync.mockResolvedValueOnce(undefined); const { wrapper } = createWrapper(); @@ -349,6 +379,55 @@ describe("useProviderActions", () => { expect(toastErrorMock.mock.calls[0]?.[0]).toBe("用量查询配置保存失败"); }); + + it("propagates addProvider errors to caller", async () => { + addProviderMutateAsync.mockRejectedValueOnce(new Error("add failed")); + const { wrapper } = createWrapper(); + + const { result } = renderHook(() => useProviderActions("claude"), { + wrapper, + }); + + await expect( + act(async () => { + await result.current.addProvider({ + name: "temp", + settingsConfig: {}, + } as Omit); + }), + ).rejects.toThrow("add failed"); + }); + + it("propagates deleteProvider errors to caller", async () => { + deleteProviderMutateAsync.mockRejectedValueOnce(new Error("delete failed")); + const { wrapper } = createWrapper(); + + const { result } = renderHook(() => useProviderActions("claude"), { + wrapper, + }); + + await expect( + act(async () => { + await result.current.deleteProvider("provider-2"); + }), + ).rejects.toThrow("delete failed"); + }); + + it("handles switch mutation errors silently", async () => { + switchProviderMutateAsync.mockRejectedValueOnce(new Error("switch failed")); + const { wrapper } = createWrapper(); + const provider = createProvider(); + + const { result } = renderHook(() => useProviderActions("claude"), { + wrapper, + }); + + await result.current.switchProvider(provider); + + expect(settingsApiGetMock).not.toHaveBeenCalled(); + expect(settingsApiApplyMock).not.toHaveBeenCalled(); + }); + it("should track pending state of all mutations in isLoading", () => { addProviderMutation.isPending = true; const { wrapper } = createWrapper(); @@ -360,3 +439,16 @@ describe("useProviderActions", () => { expect(result.current.isLoading).toBe(true); }); }); + it("clears loading flag when all mutations idle", () => { + addProviderMutation.isPending = false; + updateProviderMutation.isPending = false; + deleteProviderMutation.isPending = false; + switchProviderMutation.isPending = false; + + const { wrapper } = createWrapper(); + const { result } = renderHook(() => useProviderActions("claude"), { + wrapper, + }); + + expect(result.current.isLoading).toBe(false); + }); diff --git a/tests/hooks/useSettings.test.tsx b/tests/hooks/useSettings.test.tsx index 5cad220..da91602 100644 --- a/tests/hooks/useSettings.test.tsx +++ b/tests/hooks/useSettings.test.tsx @@ -275,4 +275,42 @@ describe("useSettings hook", () => { ); expect(metadataMock.setRequiresRestart).toHaveBeenCalledWith(false); }); + + it("returns null immediately when settings state is missing", async () => { + settingsFormMock = createSettingsFormMock({ + settings: null, + }); + + const { result } = renderHook(() => useSettings()); + + let resultValue: { requiresRestart: boolean } | null = null; + await act(async () => { + resultValue = await result.current.saveSettings(); + }); + + expect(resultValue).toBeNull(); + expect(mutateAsyncMock).not.toHaveBeenCalled(); + expect(setAppConfigDirOverrideMock).not.toHaveBeenCalled(); + }); + + it("throws when save mutation rejects and keeps restart flag untouched", async () => { + settingsFormMock = createSettingsFormMock(); + directorySettingsMock = createDirectorySettingsMock({ + appConfigDir: "/override/app", + initialAppConfigDir: "/override/app", + }); + const rejection = new Error("save failed"); + mutateAsyncMock.mockRejectedValueOnce(rejection); + + const { result } = renderHook(() => useSettings()); + + await expect( + act(async () => { + await result.current.saveSettings(); + }), + ).rejects.toThrow("save failed"); + + expect(setAppConfigDirOverrideMock).not.toHaveBeenCalled(); + expect(metadataMock.setRequiresRestart).not.toHaveBeenCalledWith(true); + }); });