style: prettier格式化测试文件

apps/web/src/test/api/assets.test.ts

@@ -1,5 +1,28 @@
 import { describe, expect, it, vi, beforeEach } from "vitest"
-import { getAssetDiagnosis, getAssetLibraries, createAssetLibrary, ensureDefaultLibrary, deleteAssetLibrary, getAssets, getAssetsByKind, createAsset, updateAsset, updateAssetReviewStatus, deleteAsset, uploadAsset, prepareDirectUpload, completeDirectUpload, uploadAssetDirect, getIngestJob, submitClassificationJob, getClassificationJob, batchDeleteAssets, batchTagAssets, batchClassifyAssets, batchMarkAssets } from "@/api/assets"
+import {
+  getAssetDiagnosis,
+  getAssetLibraries,
+  createAssetLibrary,
+  ensureDefaultLibrary,
+  deleteAssetLibrary,
+  getAssets,
+  getAssetsByKind,
+  createAsset,
+  updateAsset,
+  updateAssetReviewStatus,
+  deleteAsset,
+  uploadAsset,
+  prepareDirectUpload,
+  completeDirectUpload,
+  uploadAssetDirect,
+  getIngestJob,
+  submitClassificationJob,
+  getClassificationJob,
+  batchDeleteAssets,
+  batchTagAssets,
+  batchClassifyAssets,
+  batchMarkAssets,
+} from "@/api/assets"
 
 const mockGet = vi.fn()
 const mockPost = vi.fn()
@@ -24,11 +47,12 @@ vi.mock("@/api/projects", async (importOriginal) => {
   const actual = await importOriginal<typeof import("@/api/projects")>()
   return {
     ...actual,
-    getOrCreateDefaultProject: vi.fn().mockResolvedValue({ id: "default-project-id", name: "Default Project", description: "" }),
+    getOrCreateDefaultProject: vi
+      .fn()
+      .mockResolvedValue({ id: "default-project-id", name: "Default Project", description: "" }),
   }
 })
 
-
 describe("assets API", () => {
   beforeEach(() => {
     vi.clearAllMocks()
@@ -39,345 +63,345 @@ describe("assets API", () => {
     mockPatch.mockResolvedValue({ data: { success: true, items: [] } })
   })
 
-      describe("getAssetDiagnosis", () => {
-      it("should resolve successfully", async () => {
-        await expect(getAssetDiagnosis("test-assetId?")).resolves.not.toThrow()
-      })
-
-      it("should reject on API error", async () => {
-        mockGet.mockRejectedValue(new Error("Network error"))
-        mockPost.mockRejectedValue(new Error("Network error"))
-        mockPut.mockRejectedValue(new Error("Network error"))
-        mockDelete.mockRejectedValue(new Error("Network error"))
-        mockPatch.mockRejectedValue(new Error("Network error"))
-
-        await expect(getAssetDiagnosis("test-assetId?")).rejects.toThrow()
-      })
+  describe("getAssetDiagnosis", () => {
+    it("should resolve successfully", async () => {
+      await expect(getAssetDiagnosis("test-assetId?")).resolves.not.toThrow()
     })
 
-    describe("getAssetLibraries", () => {
-      it("should resolve successfully", async () => {
-        await expect(getAssetLibraries()).resolves.not.toThrow()
-      })
+    it("should reject on API error", async () => {
+      mockGet.mockRejectedValue(new Error("Network error"))
+      mockPost.mockRejectedValue(new Error("Network error"))
+      mockPut.mockRejectedValue(new Error("Network error"))
+      mockDelete.mockRejectedValue(new Error("Network error"))
+      mockPatch.mockRejectedValue(new Error("Network error"))
 
-      it("should reject on API error", async () => {
-        mockGet.mockRejectedValue(new Error("Network error"))
-        mockPost.mockRejectedValue(new Error("Network error"))
-        mockPut.mockRejectedValue(new Error("Network error"))
-        mockDelete.mockRejectedValue(new Error("Network error"))
-        mockPatch.mockRejectedValue(new Error("Network error"))
+      await expect(getAssetDiagnosis("test-assetId?")).rejects.toThrow()
+    })
+  })
 
-        await expect(getAssetLibraries()).rejects.toThrow()
-      })
+  describe("getAssetLibraries", () => {
+    it("should resolve successfully", async () => {
+      await expect(getAssetLibraries()).resolves.not.toThrow()
     })
 
-    describe("createAssetLibrary", () => {
-      it("should resolve successfully", async () => {
-        await expect(createAssetLibrary({ name: "test-item" })).resolves.not.toThrow()
-      })
+    it("should reject on API error", async () => {
+      mockGet.mockRejectedValue(new Error("Network error"))
+      mockPost.mockRejectedValue(new Error("Network error"))
+      mockPut.mockRejectedValue(new Error("Network error"))
+      mockDelete.mockRejectedValue(new Error("Network error"))
+      mockPatch.mockRejectedValue(new Error("Network error"))
 
-      it("should reject on API error", async () => {
-        mockGet.mockRejectedValue(new Error("Network error"))
-        mockPost.mockRejectedValue(new Error("Network error"))
-        mockPut.mockRejectedValue(new Error("Network error"))
-        mockDelete.mockRejectedValue(new Error("Network error"))
-        mockPatch.mockRejectedValue(new Error("Network error"))
+      await expect(getAssetLibraries()).rejects.toThrow()
+    })
+  })
 
-        await expect(createAssetLibrary({ name: "test-item" })).rejects.toThrow()
-      })
+  describe("createAssetLibrary", () => {
+    it("should resolve successfully", async () => {
+      await expect(createAssetLibrary({ name: "test-item" })).resolves.not.toThrow()
     })
 
-    describe("ensureDefaultLibrary", () => {
-      it("should resolve successfully", async () => {
-        await expect(ensureDefaultLibrary({ name: "test-item" })).resolves.not.toThrow()
-      })
+    it("should reject on API error", async () => {
+      mockGet.mockRejectedValue(new Error("Network error"))
+      mockPost.mockRejectedValue(new Error("Network error"))
+      mockPut.mockRejectedValue(new Error("Network error"))
+      mockDelete.mockRejectedValue(new Error("Network error"))
+      mockPatch.mockRejectedValue(new Error("Network error"))
 
-      it("should reject on API error", async () => {
-        mockGet.mockRejectedValue(new Error("Network error"))
-        mockPost.mockRejectedValue(new Error("Network error"))
-        mockPut.mockRejectedValue(new Error("Network error"))
-        mockDelete.mockRejectedValue(new Error("Network error"))
-        mockPatch.mockRejectedValue(new Error("Network error"))
+      await expect(createAssetLibrary({ name: "test-item" })).rejects.toThrow()
+    })
+  })
 
-        await expect(ensureDefaultLibrary({ name: "test-item" })).rejects.toThrow()
-      })
+  describe("ensureDefaultLibrary", () => {
+    it("should resolve successfully", async () => {
+      await expect(ensureDefaultLibrary({ name: "test-item" })).resolves.not.toThrow()
     })
 
-    describe("deleteAssetLibrary", () => {
-      it("should resolve successfully", async () => {
-        await expect(deleteAssetLibrary("test-libraryId")).resolves.not.toThrow()
-      })
+    it("should reject on API error", async () => {
+      mockGet.mockRejectedValue(new Error("Network error"))
+      mockPost.mockRejectedValue(new Error("Network error"))
+      mockPut.mockRejectedValue(new Error("Network error"))
+      mockDelete.mockRejectedValue(new Error("Network error"))
+      mockPatch.mockRejectedValue(new Error("Network error"))
 
-      it("should reject on API error", async () => {
-        mockGet.mockRejectedValue(new Error("Network error"))
-        mockPost.mockRejectedValue(new Error("Network error"))
-        mockPut.mockRejectedValue(new Error("Network error"))
-        mockDelete.mockRejectedValue(new Error("Network error"))
-        mockPatch.mockRejectedValue(new Error("Network error"))
+      await expect(ensureDefaultLibrary({ name: "test-item" })).rejects.toThrow()
+    })
+  })
 
-        await expect(deleteAssetLibrary("test-libraryId")).rejects.toThrow()
-      })
+  describe("deleteAssetLibrary", () => {
+    it("should resolve successfully", async () => {
+      await expect(deleteAssetLibrary("test-libraryId")).resolves.not.toThrow()
     })
 
-    describe("getAssets", () => {
-      it("should resolve successfully", async () => {
-        await expect(getAssets("test-libraryId")).resolves.not.toThrow()
-      })
+    it("should reject on API error", async () => {
+      mockGet.mockRejectedValue(new Error("Network error"))
+      mockPost.mockRejectedValue(new Error("Network error"))
+      mockPut.mockRejectedValue(new Error("Network error"))
+      mockDelete.mockRejectedValue(new Error("Network error"))
+      mockPatch.mockRejectedValue(new Error("Network error"))
 
-      it("should reject on API error", async () => {
-        mockGet.mockRejectedValue(new Error("Network error"))
-        mockPost.mockRejectedValue(new Error("Network error"))
-        mockPut.mockRejectedValue(new Error("Network error"))
-        mockDelete.mockRejectedValue(new Error("Network error"))
-        mockPatch.mockRejectedValue(new Error("Network error"))
+      await expect(deleteAssetLibrary("test-libraryId")).rejects.toThrow()
+    })
+  })
 
-        await expect(getAssets("test-libraryId")).rejects.toThrow()
-      })
+  describe("getAssets", () => {
+    it("should resolve successfully", async () => {
+      await expect(getAssets("test-libraryId")).resolves.not.toThrow()
     })
 
-    describe("getAssetsByKind", () => {
-      it("should resolve successfully", async () => {
-        await expect(getAssetsByKind("test-kind")).resolves.not.toThrow()
-      })
+    it("should reject on API error", async () => {
+      mockGet.mockRejectedValue(new Error("Network error"))
+      mockPost.mockRejectedValue(new Error("Network error"))
+      mockPut.mockRejectedValue(new Error("Network error"))
+      mockDelete.mockRejectedValue(new Error("Network error"))
+      mockPatch.mockRejectedValue(new Error("Network error"))
 
-      it("should reject on API error", async () => {
-        mockGet.mockRejectedValue(new Error("Network error"))
-        mockPost.mockRejectedValue(new Error("Network error"))
-        mockPut.mockRejectedValue(new Error("Network error"))
-        mockDelete.mockRejectedValue(new Error("Network error"))
-        mockPatch.mockRejectedValue(new Error("Network error"))
+      await expect(getAssets("test-libraryId")).rejects.toThrow()
+    })
+  })
 
-        await expect(getAssetsByKind("test-kind")).rejects.toThrow()
-      })
+  describe("getAssetsByKind", () => {
+    it("should resolve successfully", async () => {
+      await expect(getAssetsByKind("test-kind")).resolves.not.toThrow()
     })
 
-    describe("createAsset", () => {
-      it("should resolve successfully", async () => {
-        await expect(createAsset({ name: "test-item" })).resolves.not.toThrow()
-      })
+    it("should reject on API error", async () => {
+      mockGet.mockRejectedValue(new Error("Network error"))
+      mockPost.mockRejectedValue(new Error("Network error"))
+      mockPut.mockRejectedValue(new Error("Network error"))
+      mockDelete.mockRejectedValue(new Error("Network error"))
+      mockPatch.mockRejectedValue(new Error("Network error"))
 
-      it("should reject on API error", async () => {
-        mockGet.mockRejectedValue(new Error("Network error"))
-        mockPost.mockRejectedValue(new Error("Network error"))
-        mockPut.mockRejectedValue(new Error("Network error"))
-        mockDelete.mockRejectedValue(new Error("Network error"))
-        mockPatch.mockRejectedValue(new Error("Network error"))
+      await expect(getAssetsByKind("test-kind")).rejects.toThrow()
+    })
+  })
 
-        await expect(createAsset({ name: "test-item" })).rejects.toThrow()
-      })
+  describe("createAsset", () => {
+    it("should resolve successfully", async () => {
+      await expect(createAsset({ name: "test-item" })).resolves.not.toThrow()
     })
 
-    describe("updateAsset", () => {
-      it("should resolve successfully", async () => {
-        await expect(updateAsset("test-assetId")).resolves.not.toThrow()
-      })
+    it("should reject on API error", async () => {
+      mockGet.mockRejectedValue(new Error("Network error"))
+      mockPost.mockRejectedValue(new Error("Network error"))
+      mockPut.mockRejectedValue(new Error("Network error"))
+      mockDelete.mockRejectedValue(new Error("Network error"))
+      mockPatch.mockRejectedValue(new Error("Network error"))
 
-      it("should reject on API error", async () => {
-        mockGet.mockRejectedValue(new Error("Network error"))
-        mockPost.mockRejectedValue(new Error("Network error"))
-        mockPut.mockRejectedValue(new Error("Network error"))
-        mockDelete.mockRejectedValue(new Error("Network error"))
-        mockPatch.mockRejectedValue(new Error("Network error"))
+      await expect(createAsset({ name: "test-item" })).rejects.toThrow()
+    })
+  })
 
-        await expect(updateAsset("test-assetId")).rejects.toThrow()
-      })
+  describe("updateAsset", () => {
+    it("should resolve successfully", async () => {
+      await expect(updateAsset("test-assetId")).resolves.not.toThrow()
     })
 
-    describe("updateAssetReviewStatus", () => {
-      it("should resolve successfully", async () => {
-        await expect(updateAssetReviewStatus("test-assetId")).resolves.not.toThrow()
-      })
+    it("should reject on API error", async () => {
+      mockGet.mockRejectedValue(new Error("Network error"))
+      mockPost.mockRejectedValue(new Error("Network error"))
+      mockPut.mockRejectedValue(new Error("Network error"))
+      mockDelete.mockRejectedValue(new Error("Network error"))
+      mockPatch.mockRejectedValue(new Error("Network error"))
 
-      it("should reject on API error", async () => {
-        mockGet.mockRejectedValue(new Error("Network error"))
-        mockPost.mockRejectedValue(new Error("Network error"))
-        mockPut.mockRejectedValue(new Error("Network error"))
-        mockDelete.mockRejectedValue(new Error("Network error"))
-        mockPatch.mockRejectedValue(new Error("Network error"))
+      await expect(updateAsset("test-assetId")).rejects.toThrow()
+    })
+  })
 
-        await expect(updateAssetReviewStatus("test-assetId")).rejects.toThrow()
-      })
+  describe("updateAssetReviewStatus", () => {
+    it("should resolve successfully", async () => {
+      await expect(updateAssetReviewStatus("test-assetId")).resolves.not.toThrow()
     })
 
-    describe("deleteAsset", () => {
-      it("should resolve successfully", async () => {
-        await expect(deleteAsset("test-assetId")).resolves.not.toThrow()
-      })
+    it("should reject on API error", async () => {
+      mockGet.mockRejectedValue(new Error("Network error"))
+      mockPost.mockRejectedValue(new Error("Network error"))
+      mockPut.mockRejectedValue(new Error("Network error"))
+      mockDelete.mockRejectedValue(new Error("Network error"))
+      mockPatch.mockRejectedValue(new Error("Network error"))
 
-      it("should reject on API error", async () => {
-        mockGet.mockRejectedValue(new Error("Network error"))
-        mockPost.mockRejectedValue(new Error("Network error"))
-        mockPut.mockRejectedValue(new Error("Network error"))
-        mockDelete.mockRejectedValue(new Error("Network error"))
-        mockPatch.mockRejectedValue(new Error("Network error"))
+      await expect(updateAssetReviewStatus("test-assetId")).rejects.toThrow()
+    })
+  })
 
-        await expect(deleteAsset("test-assetId")).rejects.toThrow()
-      })
+  describe("deleteAsset", () => {
+    it("should resolve successfully", async () => {
+      await expect(deleteAsset("test-assetId")).resolves.not.toThrow()
     })
 
-    describe("uploadAsset", () => {
-      it("should resolve successfully", async () => {
-        await expect(uploadAsset(new FormData())).resolves.not.toThrow()
-      })
+    it("should reject on API error", async () => {
+      mockGet.mockRejectedValue(new Error("Network error"))
+      mockPost.mockRejectedValue(new Error("Network error"))
+      mockPut.mockRejectedValue(new Error("Network error"))
+      mockDelete.mockRejectedValue(new Error("Network error"))
+      mockPatch.mockRejectedValue(new Error("Network error"))
 
-      it("should reject on API error", async () => {
-        mockGet.mockRejectedValue(new Error("Network error"))
-        mockPost.mockRejectedValue(new Error("Network error"))
-        mockPut.mockRejectedValue(new Error("Network error"))
-        mockDelete.mockRejectedValue(new Error("Network error"))
-        mockPatch.mockRejectedValue(new Error("Network error"))
+      await expect(deleteAsset("test-assetId")).rejects.toThrow()
+    })
+  })
 
-        await expect(uploadAsset(new FormData())).rejects.toThrow()
-      })
+  describe("uploadAsset", () => {
+    it("should resolve successfully", async () => {
+      await expect(uploadAsset(new FormData())).resolves.not.toThrow()
     })
 
-    describe("prepareDirectUpload", () => {
-      it("should resolve successfully", async () => {
-        await expect(prepareDirectUpload({ name: "test-item" })).resolves.not.toThrow()
-      })
+    it("should reject on API error", async () => {
+      mockGet.mockRejectedValue(new Error("Network error"))
+      mockPost.mockRejectedValue(new Error("Network error"))
+      mockPut.mockRejectedValue(new Error("Network error"))
+      mockDelete.mockRejectedValue(new Error("Network error"))
+      mockPatch.mockRejectedValue(new Error("Network error"))
 
-      it("should reject on API error", async () => {
-        mockGet.mockRejectedValue(new Error("Network error"))
-        mockPost.mockRejectedValue(new Error("Network error"))
-        mockPut.mockRejectedValue(new Error("Network error"))
-        mockDelete.mockRejectedValue(new Error("Network error"))
-        mockPatch.mockRejectedValue(new Error("Network error"))
+      await expect(uploadAsset(new FormData())).rejects.toThrow()
+    })
+  })
 
-        await expect(prepareDirectUpload({ name: "test-item" })).rejects.toThrow()
-      })
+  describe("prepareDirectUpload", () => {
+    it("should resolve successfully", async () => {
+      await expect(prepareDirectUpload({ name: "test-item" })).resolves.not.toThrow()
     })
 
-    describe("completeDirectUpload", () => {
-      it("should resolve successfully", async () => {
-        await expect(completeDirectUpload({ name: "test-item" })).resolves.not.toThrow()
-      })
+    it("should reject on API error", async () => {
+      mockGet.mockRejectedValue(new Error("Network error"))
+      mockPost.mockRejectedValue(new Error("Network error"))
+      mockPut.mockRejectedValue(new Error("Network error"))
+      mockDelete.mockRejectedValue(new Error("Network error"))
+      mockPatch.mockRejectedValue(new Error("Network error"))
 
-      it("should reject on API error", async () => {
-        mockGet.mockRejectedValue(new Error("Network error"))
-        mockPost.mockRejectedValue(new Error("Network error"))
-        mockPut.mockRejectedValue(new Error("Network error"))
-        mockDelete.mockRejectedValue(new Error("Network error"))
-        mockPatch.mockRejectedValue(new Error("Network error"))
+      await expect(prepareDirectUpload({ name: "test-item" })).rejects.toThrow()
+    })
+  })
 
-        await expect(completeDirectUpload({ name: "test-item" })).rejects.toThrow()
-      })
+  describe("completeDirectUpload", () => {
+    it("should resolve successfully", async () => {
+      await expect(completeDirectUpload({ name: "test-item" })).resolves.not.toThrow()
     })
 
-    describe.skip("uploadAssetDirect", () => {
-      it("should resolve successfully", async () => {
-        // XMLHttpRequest + OSS 直传，需要复杂 mock，跳过以保证覆盖率
-      })
+    it("should reject on API error", async () => {
+      mockGet.mockRejectedValue(new Error("Network error"))
+      mockPost.mockRejectedValue(new Error("Network error"))
+      mockPut.mockRejectedValue(new Error("Network error"))
+      mockDelete.mockRejectedValue(new Error("Network error"))
+      mockPatch.mockRejectedValue(new Error("Network error"))
+
+      await expect(completeDirectUpload({ name: "test-item" })).rejects.toThrow()
+    })
+  })
+
+  describe.skip("uploadAssetDirect", () => {
+    it("should resolve successfully", async () => {
+      // XMLHttpRequest + OSS 直传，需要复杂 mock，跳过以保证覆盖率
+    })
+  })
+
+  describe("getIngestJob", () => {
+    it("should resolve successfully", async () => {
+      await expect(getIngestJob("test-jobId")).resolves.not.toThrow()
     })
 
-    describe("getIngestJob", () => {
-      it("should resolve successfully", async () => {
-        await expect(getIngestJob("test-jobId")).resolves.not.toThrow()
-      })
+    it("should reject on API error", async () => {
+      mockGet.mockRejectedValue(new Error("Network error"))
+      mockPost.mockRejectedValue(new Error("Network error"))
+      mockPut.mockRejectedValue(new Error("Network error"))
+      mockDelete.mockRejectedValue(new Error("Network error"))
+      mockPatch.mockRejectedValue(new Error("Network error"))
 
-      it("should reject on API error", async () => {
-        mockGet.mockRejectedValue(new Error("Network error"))
-        mockPost.mockRejectedValue(new Error("Network error"))
-        mockPut.mockRejectedValue(new Error("Network error"))
-        mockDelete.mockRejectedValue(new Error("Network error"))
-        mockPatch.mockRejectedValue(new Error("Network error"))
+      await expect(getIngestJob("test-jobId")).rejects.toThrow()
+    })
+  })
 
-        await expect(getIngestJob("test-jobId")).rejects.toThrow()
-      })
+  describe("submitClassificationJob", () => {
+    it("should resolve successfully", async () => {
+      await expect(submitClassificationJob({ name: "test-item" })).resolves.not.toThrow()
     })
 
-    describe("submitClassificationJob", () => {
-      it("should resolve successfully", async () => {
-        await expect(submitClassificationJob({ name: "test-item" })).resolves.not.toThrow()
-      })
+    it("should reject on API error", async () => {
+      mockGet.mockRejectedValue(new Error("Network error"))
+      mockPost.mockRejectedValue(new Error("Network error"))
+      mockPut.mockRejectedValue(new Error("Network error"))
+      mockDelete.mockRejectedValue(new Error("Network error"))
+      mockPatch.mockRejectedValue(new Error("Network error"))
 
-      it("should reject on API error", async () => {
-        mockGet.mockRejectedValue(new Error("Network error"))
-        mockPost.mockRejectedValue(new Error("Network error"))
-        mockPut.mockRejectedValue(new Error("Network error"))
-        mockDelete.mockRejectedValue(new Error("Network error"))
-        mockPatch.mockRejectedValue(new Error("Network error"))
+      await expect(submitClassificationJob({ name: "test-item" })).rejects.toThrow()
+    })
+  })
 
-        await expect(submitClassificationJob({ name: "test-item" })).rejects.toThrow()
-      })
+  describe("getClassificationJob", () => {
+    it("should resolve successfully", async () => {
+      await expect(getClassificationJob("test-jobId")).resolves.not.toThrow()
     })
 
-    describe("getClassificationJob", () => {
-      it("should resolve successfully", async () => {
-        await expect(getClassificationJob("test-jobId")).resolves.not.toThrow()
-      })
+    it("should reject on API error", async () => {
+      mockGet.mockRejectedValue(new Error("Network error"))
+      mockPost.mockRejectedValue(new Error("Network error"))
+      mockPut.mockRejectedValue(new Error("Network error"))
+      mockDelete.mockRejectedValue(new Error("Network error"))
+      mockPatch.mockRejectedValue(new Error("Network error"))
 
-      it("should reject on API error", async () => {
-        mockGet.mockRejectedValue(new Error("Network error"))
-        mockPost.mockRejectedValue(new Error("Network error"))
-        mockPut.mockRejectedValue(new Error("Network error"))
-        mockDelete.mockRejectedValue(new Error("Network error"))
-        mockPatch.mockRejectedValue(new Error("Network error"))
+      await expect(getClassificationJob("test-jobId")).rejects.toThrow()
+    })
+  })
 
-        await expect(getClassificationJob("test-jobId")).rejects.toThrow()
-      })
+  describe("batchDeleteAssets", () => {
+    it("should resolve successfully", async () => {
+      await expect(batchDeleteAssets(["item-1", "item-2"])).resolves.not.toThrow()
     })
 
-    describe("batchDeleteAssets", () => {
-      it("should resolve successfully", async () => {
-        await expect(batchDeleteAssets(["item-1", "item-2"])).resolves.not.toThrow()
-      })
+    it("should reject on API error", async () => {
+      mockGet.mockRejectedValue(new Error("Network error"))
+      mockPost.mockRejectedValue(new Error("Network error"))
+      mockPut.mockRejectedValue(new Error("Network error"))
+      mockDelete.mockRejectedValue(new Error("Network error"))
+      mockPatch.mockRejectedValue(new Error("Network error"))
 
-      it("should reject on API error", async () => {
-        mockGet.mockRejectedValue(new Error("Network error"))
-        mockPost.mockRejectedValue(new Error("Network error"))
-        mockPut.mockRejectedValue(new Error("Network error"))
-        mockDelete.mockRejectedValue(new Error("Network error"))
-        mockPatch.mockRejectedValue(new Error("Network error"))
+      await expect(batchDeleteAssets(["item-1", "item-2"])).rejects.toThrow()
+    })
+  })
 
-        await expect(batchDeleteAssets(["item-1", "item-2"])).rejects.toThrow()
-      })
+  describe("batchTagAssets", () => {
+    it("should resolve successfully", async () => {
+      await expect(batchTagAssets({ name: "test-item" })).resolves.not.toThrow()
     })
 
-    describe("batchTagAssets", () => {
-      it("should resolve successfully", async () => {
-        await expect(batchTagAssets({ name: "test-item" })).resolves.not.toThrow()
-      })
+    it("should reject on API error", async () => {
+      mockGet.mockRejectedValue(new Error("Network error"))
+      mockPost.mockRejectedValue(new Error("Network error"))
+      mockPut.mockRejectedValue(new Error("Network error"))
+      mockDelete.mockRejectedValue(new Error("Network error"))
+      mockPatch.mockRejectedValue(new Error("Network error"))
 
-      it("should reject on API error", async () => {
-        mockGet.mockRejectedValue(new Error("Network error"))
-        mockPost.mockRejectedValue(new Error("Network error"))
-        mockPut.mockRejectedValue(new Error("Network error"))
-        mockDelete.mockRejectedValue(new Error("Network error"))
-        mockPatch.mockRejectedValue(new Error("Network error"))
+      await expect(batchTagAssets({ name: "test-item" })).rejects.toThrow()
+    })
+  })
 
-        await expect(batchTagAssets({ name: "test-item" })).rejects.toThrow()
-      })
+  describe("batchClassifyAssets", () => {
+    it("should resolve successfully", async () => {
+      await expect(batchClassifyAssets({ name: "test-item" })).resolves.not.toThrow()
     })
 
-    describe("batchClassifyAssets", () => {
-      it("should resolve successfully", async () => {
-        await expect(batchClassifyAssets({ name: "test-item" })).resolves.not.toThrow()
-      })
+    it("should reject on API error", async () => {
+      mockGet.mockRejectedValue(new Error("Network error"))
+      mockPost.mockRejectedValue(new Error("Network error"))
+      mockPut.mockRejectedValue(new Error("Network error"))
+      mockDelete.mockRejectedValue(new Error("Network error"))
+      mockPatch.mockRejectedValue(new Error("Network error"))
 
-      it("should reject on API error", async () => {
-        mockGet.mockRejectedValue(new Error("Network error"))
-        mockPost.mockRejectedValue(new Error("Network error"))
-        mockPut.mockRejectedValue(new Error("Network error"))
-        mockDelete.mockRejectedValue(new Error("Network error"))
-        mockPatch.mockRejectedValue(new Error("Network error"))
+      await expect(batchClassifyAssets({ name: "test-item" })).rejects.toThrow()
+    })
+  })
 
-        await expect(batchClassifyAssets({ name: "test-item" })).rejects.toThrow()
-      })
+  describe("batchMarkAssets", () => {
+    it("should resolve successfully", async () => {
+      await expect(batchMarkAssets({ name: "test-item" })).resolves.not.toThrow()
     })
 
-    describe("batchMarkAssets", () => {
-      it("should resolve successfully", async () => {
-        await expect(batchMarkAssets({ name: "test-item" })).resolves.not.toThrow()
-      })
+    it("should reject on API error", async () => {
+      mockGet.mockRejectedValue(new Error("Network error"))
+      mockPost.mockRejectedValue(new Error("Network error"))
+      mockPut.mockRejectedValue(new Error("Network error"))
+      mockDelete.mockRejectedValue(new Error("Network error"))
+      mockPatch.mockRejectedValue(new Error("Network error"))
 
-      it("should reject on API error", async () => {
-        mockGet.mockRejectedValue(new Error("Network error"))
-        mockPost.mockRejectedValue(new Error("Network error"))
-        mockPut.mockRejectedValue(new Error("Network error"))
-        mockDelete.mockRejectedValue(new Error("Network error"))
-        mockPatch.mockRejectedValue(new Error("Network error"))
-
-        await expect(batchMarkAssets({ name: "test-item" })).rejects.toThrow()
-      })
+      await expect(batchMarkAssets({ name: "test-item" })).rejects.toThrow()
     })
+  })
 })

apps/web/src/test/api/bgm.test.ts

@@ -20,7 +20,6 @@ vi.mock("@/api/client", () => ({
 vi.mock("antd", () => ({ message: { error: vi.fn(), success: vi.fn() } }))
 vi.mock("@/store/authStore", () => ({ useAuthStore: { getState: vi.fn(() => ({})) } }))
 
-
 describe("bgm API", () => {
   beforeEach(() => {
     vi.clearAllMocks()
@@ -31,19 +30,19 @@ describe("bgm API", () => {
     mockPatch.mockResolvedValue({ data: { success: true, items: [] } })
   })
 
-      describe("getBgmPresets", () => {
-      it("should resolve successfully", async () => {
-        await expect(getBgmPresets("test-params?")).resolves.not.toThrow()
-      })
-
-      it("should reject on API error", async () => {
-        mockGet.mockRejectedValue(new Error("Network error"))
-        mockPost.mockRejectedValue(new Error("Network error"))
-        mockPut.mockRejectedValue(new Error("Network error"))
-        mockDelete.mockRejectedValue(new Error("Network error"))
-        mockPatch.mockRejectedValue(new Error("Network error"))
-
-        await expect(getBgmPresets("test-params?")).rejects.toThrow()
-      })
+  describe("getBgmPresets", () => {
+    it("should resolve successfully", async () => {
+      await expect(getBgmPresets("test-params?")).resolves.not.toThrow()
     })
+
+    it("should reject on API error", async () => {
+      mockGet.mockRejectedValue(new Error("Network error"))
+      mockPost.mockRejectedValue(new Error("Network error"))
+      mockPut.mockRejectedValue(new Error("Network error"))
+      mockDelete.mockRejectedValue(new Error("Network error"))
+      mockPatch.mockRejectedValue(new Error("Network error"))
+
+      await expect(getBgmPresets("test-params?")).rejects.toThrow()
+    })
+  })
 })

apps/web/src/test/api/duplication.test.ts

@@ -1,5 +1,11 @@
 import { describe, expect, it, vi, beforeEach } from "vitest"
-import { uploadForDuplication, getDuplicationRecords, getDuplicationDetail, deleteDuplicationRecord, retryDuplication } from "@/api/duplication"
+import {
+  uploadForDuplication,
+  getDuplicationRecords,
+  getDuplicationDetail,
+  deleteDuplicationRecord,
+  retryDuplication,
+} from "@/api/duplication"
 
 const mockGet = vi.fn()
 const mockPost = vi.fn()
@@ -20,7 +26,6 @@ vi.mock("@/api/client", () => ({
 vi.mock("antd", () => ({ message: { error: vi.fn(), success: vi.fn() } }))
 vi.mock("@/store/authStore", () => ({ useAuthStore: { getState: vi.fn(() => ({})) } }))
 
-
 describe("duplication API", () => {
   beforeEach(() => {
     vi.clearAllMocks()
@@ -31,83 +36,83 @@ describe("duplication API", () => {
     mockPatch.mockResolvedValue({ data: { success: true, items: [] } })
   })
 
-      describe("uploadForDuplication", () => {
-      it("should resolve successfully", async () => {
-        await expect(uploadForDuplication(new File(["test"], "test.txt"))).resolves.not.toThrow()
-      })
-
-      it("should reject on API error", async () => {
-        mockGet.mockRejectedValue(new Error("Network error"))
-        mockPost.mockRejectedValue(new Error("Network error"))
-        mockPut.mockRejectedValue(new Error("Network error"))
-        mockDelete.mockRejectedValue(new Error("Network error"))
-        mockPatch.mockRejectedValue(new Error("Network error"))
-
-        await expect(uploadForDuplication(new File(["test"], "test.txt"))).rejects.toThrow()
-      })
+  describe("uploadForDuplication", () => {
+    it("should resolve successfully", async () => {
+      await expect(uploadForDuplication(new File(["test"], "test.txt"))).resolves.not.toThrow()
     })
 
-    describe("getDuplicationRecords", () => {
-      it("should resolve successfully", async () => {
-        await expect(getDuplicationRecords()).resolves.not.toThrow()
-      })
+    it("should reject on API error", async () => {
+      mockGet.mockRejectedValue(new Error("Network error"))
+      mockPost.mockRejectedValue(new Error("Network error"))
+      mockPut.mockRejectedValue(new Error("Network error"))
+      mockDelete.mockRejectedValue(new Error("Network error"))
+      mockPatch.mockRejectedValue(new Error("Network error"))
 
-      it("should reject on API error", async () => {
-        mockGet.mockRejectedValue(new Error("Network error"))
-        mockPost.mockRejectedValue(new Error("Network error"))
-        mockPut.mockRejectedValue(new Error("Network error"))
-        mockDelete.mockRejectedValue(new Error("Network error"))
-        mockPatch.mockRejectedValue(new Error("Network error"))
+      await expect(uploadForDuplication(new File(["test"], "test.txt"))).rejects.toThrow()
+    })
+  })
 
-        await expect(getDuplicationRecords()).rejects.toThrow()
-      })
+  describe("getDuplicationRecords", () => {
+    it("should resolve successfully", async () => {
+      await expect(getDuplicationRecords()).resolves.not.toThrow()
     })
 
-    describe("getDuplicationDetail", () => {
-      it("should resolve successfully", async () => {
-        await expect(getDuplicationDetail("test-recordId")).resolves.not.toThrow()
-      })
+    it("should reject on API error", async () => {
+      mockGet.mockRejectedValue(new Error("Network error"))
+      mockPost.mockRejectedValue(new Error("Network error"))
+      mockPut.mockRejectedValue(new Error("Network error"))
+      mockDelete.mockRejectedValue(new Error("Network error"))
+      mockPatch.mockRejectedValue(new Error("Network error"))
 
-      it("should reject on API error", async () => {
-        mockGet.mockRejectedValue(new Error("Network error"))
-        mockPost.mockRejectedValue(new Error("Network error"))
-        mockPut.mockRejectedValue(new Error("Network error"))
-        mockDelete.mockRejectedValue(new Error("Network error"))
-        mockPatch.mockRejectedValue(new Error("Network error"))
+      await expect(getDuplicationRecords()).rejects.toThrow()
+    })
+  })
 
-        await expect(getDuplicationDetail("test-recordId")).rejects.toThrow()
-      })
+  describe("getDuplicationDetail", () => {
+    it("should resolve successfully", async () => {
+      await expect(getDuplicationDetail("test-recordId")).resolves.not.toThrow()
     })
 
-    describe("deleteDuplicationRecord", () => {
-      it("should resolve successfully", async () => {
-        await expect(deleteDuplicationRecord("test-recordId")).resolves.not.toThrow()
-      })
+    it("should reject on API error", async () => {
+      mockGet.mockRejectedValue(new Error("Network error"))
+      mockPost.mockRejectedValue(new Error("Network error"))
+      mockPut.mockRejectedValue(new Error("Network error"))
+      mockDelete.mockRejectedValue(new Error("Network error"))
+      mockPatch.mockRejectedValue(new Error("Network error"))
 
-      it("should reject on API error", async () => {
-        mockGet.mockRejectedValue(new Error("Network error"))
-        mockPost.mockRejectedValue(new Error("Network error"))
-        mockPut.mockRejectedValue(new Error("Network error"))
-        mockDelete.mockRejectedValue(new Error("Network error"))
-        mockPatch.mockRejectedValue(new Error("Network error"))
+      await expect(getDuplicationDetail("test-recordId")).rejects.toThrow()
+    })
+  })
 
-        await expect(deleteDuplicationRecord("test-recordId")).rejects.toThrow()
-      })
+  describe("deleteDuplicationRecord", () => {
+    it("should resolve successfully", async () => {
+      await expect(deleteDuplicationRecord("test-recordId")).resolves.not.toThrow()
     })
 
-    describe("retryDuplication", () => {
-      it("should resolve successfully", async () => {
-        await expect(retryDuplication("test-recordId")).resolves.not.toThrow()
-      })
+    it("should reject on API error", async () => {
+      mockGet.mockRejectedValue(new Error("Network error"))
+      mockPost.mockRejectedValue(new Error("Network error"))
+      mockPut.mockRejectedValue(new Error("Network error"))
+      mockDelete.mockRejectedValue(new Error("Network error"))
+      mockPatch.mockRejectedValue(new Error("Network error"))
 
-      it("should reject on API error", async () => {
-        mockGet.mockRejectedValue(new Error("Network error"))
-        mockPost.mockRejectedValue(new Error("Network error"))
-        mockPut.mockRejectedValue(new Error("Network error"))
-        mockDelete.mockRejectedValue(new Error("Network error"))
-        mockPatch.mockRejectedValue(new Error("Network error"))
-
-        await expect(retryDuplication("test-recordId")).rejects.toThrow()
-      })
+      await expect(deleteDuplicationRecord("test-recordId")).rejects.toThrow()
     })
+  })
+
+  describe("retryDuplication", () => {
+    it("should resolve successfully", async () => {
+      await expect(retryDuplication("test-recordId")).resolves.not.toThrow()
+    })
+
+    it("should reject on API error", async () => {
+      mockGet.mockRejectedValue(new Error("Network error"))
+      mockPost.mockRejectedValue(new Error("Network error"))
+      mockPut.mockRejectedValue(new Error("Network error"))
+      mockDelete.mockRejectedValue(new Error("Network error"))
+      mockPatch.mockRejectedValue(new Error("Network error"))
+
+      await expect(retryDuplication("test-recordId")).rejects.toThrow()
+    })
+  })
 })

apps/web/src/test/api/editPlans.test.ts

@@ -1,5 +1,29 @@
 import { describe, expect, it, vi, beforeEach } from "vitest"
-import { getEditPlans, getEditPlan, createEditPlan, updateEditPlan, deleteEditPlan, generateEditPlan, getGenerationStatus, aiRecommendClips, generateCover, getEditPlanGenerations, getGenerationTaskResults, cancelGeneration, getEditPlanClips, getEditPlanClip, createEditPlanClip, updateEditPlanClip, deleteEditPlanClip, reorderEditPlanClips, batchDeleteEditPlanClips, createClipsFromAssets, copyEditPlan, getMediaAssets, getMediaAsset } from "@/api/editPlans"
+import {
+  getEditPlans,
+  getEditPlan,
+  createEditPlan,
+  updateEditPlan,
+  deleteEditPlan,
+  generateEditPlan,
+  getGenerationStatus,
+  aiRecommendClips,
+  generateCover,
+  getEditPlanGenerations,
+  getGenerationTaskResults,
+  cancelGeneration,
+  getEditPlanClips,
+  getEditPlanClip,
+  createEditPlanClip,
+  updateEditPlanClip,
+  deleteEditPlanClip,
+  reorderEditPlanClips,
+  batchDeleteEditPlanClips,
+  createClipsFromAssets,
+  copyEditPlan,
+  getMediaAssets,
+  getMediaAsset,
+} from "@/api/editPlans"
 
 const mockGet = vi.fn()
 const mockPost = vi.fn()
@@ -20,7 +44,6 @@ vi.mock("@/api/client", () => ({
 vi.mock("antd", () => ({ message: { error: vi.fn(), success: vi.fn() } }))
 vi.mock("@/store/authStore", () => ({ useAuthStore: { getState: vi.fn(() => ({})) } }))
 
-
 describe("editPlans API", () => {
   beforeEach(() => {
     vi.clearAllMocks()
@@ -31,371 +54,371 @@ describe("editPlans API", () => {
     mockPatch.mockResolvedValue({ data: { success: true, items: [] } })
   })
 
-      describe("getEditPlans", () => {
-      it("should resolve successfully", async () => {
-        await expect(getEditPlans("test-params?")).resolves.not.toThrow()
-      })
-
-      it("should reject on API error", async () => {
-        mockGet.mockRejectedValue(new Error("Network error"))
-        mockPost.mockRejectedValue(new Error("Network error"))
-        mockPut.mockRejectedValue(new Error("Network error"))
-        mockDelete.mockRejectedValue(new Error("Network error"))
-        mockPatch.mockRejectedValue(new Error("Network error"))
-
-        await expect(getEditPlans("test-params?")).rejects.toThrow()
-      })
+  describe("getEditPlans", () => {
+    it("should resolve successfully", async () => {
+      await expect(getEditPlans("test-params?")).resolves.not.toThrow()
     })
 
-    describe("getEditPlan", () => {
-      it("should resolve successfully", async () => {
-        await expect(getEditPlan("test-planId")).resolves.not.toThrow()
-      })
+    it("should reject on API error", async () => {
+      mockGet.mockRejectedValue(new Error("Network error"))
+      mockPost.mockRejectedValue(new Error("Network error"))
+      mockPut.mockRejectedValue(new Error("Network error"))
+      mockDelete.mockRejectedValue(new Error("Network error"))
+      mockPatch.mockRejectedValue(new Error("Network error"))
 
-      it("should reject on API error", async () => {
-        mockGet.mockRejectedValue(new Error("Network error"))
-        mockPost.mockRejectedValue(new Error("Network error"))
-        mockPut.mockRejectedValue(new Error("Network error"))
-        mockDelete.mockRejectedValue(new Error("Network error"))
-        mockPatch.mockRejectedValue(new Error("Network error"))
+      await expect(getEditPlans("test-params?")).rejects.toThrow()
+    })
+  })
 
-        await expect(getEditPlan("test-planId")).rejects.toThrow()
-      })
+  describe("getEditPlan", () => {
+    it("should resolve successfully", async () => {
+      await expect(getEditPlan("test-planId")).resolves.not.toThrow()
     })
 
-    describe("createEditPlan", () => {
-      it("should resolve successfully", async () => {
-        await expect(createEditPlan({ name: "test-item" })).resolves.not.toThrow()
-      })
+    it("should reject on API error", async () => {
+      mockGet.mockRejectedValue(new Error("Network error"))
+      mockPost.mockRejectedValue(new Error("Network error"))
+      mockPut.mockRejectedValue(new Error("Network error"))
+      mockDelete.mockRejectedValue(new Error("Network error"))
+      mockPatch.mockRejectedValue(new Error("Network error"))
 
-      it("should reject on API error", async () => {
-        mockGet.mockRejectedValue(new Error("Network error"))
-        mockPost.mockRejectedValue(new Error("Network error"))
-        mockPut.mockRejectedValue(new Error("Network error"))
-        mockDelete.mockRejectedValue(new Error("Network error"))
-        mockPatch.mockRejectedValue(new Error("Network error"))
+      await expect(getEditPlan("test-planId")).rejects.toThrow()
+    })
+  })
 
-        await expect(createEditPlan({ name: "test-item" })).rejects.toThrow()
-      })
+  describe("createEditPlan", () => {
+    it("should resolve successfully", async () => {
+      await expect(createEditPlan({ name: "test-item" })).resolves.not.toThrow()
     })
 
-    describe("updateEditPlan", () => {
-      it("should resolve successfully", async () => {
-        await expect(updateEditPlan("test-planId")).resolves.not.toThrow()
-      })
+    it("should reject on API error", async () => {
+      mockGet.mockRejectedValue(new Error("Network error"))
+      mockPost.mockRejectedValue(new Error("Network error"))
+      mockPut.mockRejectedValue(new Error("Network error"))
+      mockDelete.mockRejectedValue(new Error("Network error"))
+      mockPatch.mockRejectedValue(new Error("Network error"))
 
-      it("should reject on API error", async () => {
-        mockGet.mockRejectedValue(new Error("Network error"))
-        mockPost.mockRejectedValue(new Error("Network error"))
-        mockPut.mockRejectedValue(new Error("Network error"))
-        mockDelete.mockRejectedValue(new Error("Network error"))
-        mockPatch.mockRejectedValue(new Error("Network error"))
+      await expect(createEditPlan({ name: "test-item" })).rejects.toThrow()
+    })
+  })
 
-        await expect(updateEditPlan("test-planId")).rejects.toThrow()
-      })
+  describe("updateEditPlan", () => {
+    it("should resolve successfully", async () => {
+      await expect(updateEditPlan("test-planId")).resolves.not.toThrow()
     })
 
-    describe("deleteEditPlan", () => {
-      it("should resolve successfully", async () => {
-        await expect(deleteEditPlan("test-planId")).resolves.not.toThrow()
-      })
+    it("should reject on API error", async () => {
+      mockGet.mockRejectedValue(new Error("Network error"))
+      mockPost.mockRejectedValue(new Error("Network error"))
+      mockPut.mockRejectedValue(new Error("Network error"))
+      mockDelete.mockRejectedValue(new Error("Network error"))
+      mockPatch.mockRejectedValue(new Error("Network error"))
 
-      it("should reject on API error", async () => {
-        mockGet.mockRejectedValue(new Error("Network error"))
-        mockPost.mockRejectedValue(new Error("Network error"))
-        mockPut.mockRejectedValue(new Error("Network error"))
-        mockDelete.mockRejectedValue(new Error("Network error"))
-        mockPatch.mockRejectedValue(new Error("Network error"))
+      await expect(updateEditPlan("test-planId")).rejects.toThrow()
+    })
+  })
 
-        await expect(deleteEditPlan("test-planId")).rejects.toThrow()
-      })
+  describe("deleteEditPlan", () => {
+    it("should resolve successfully", async () => {
+      await expect(deleteEditPlan("test-planId")).resolves.not.toThrow()
     })
 
-    describe("generateEditPlan", () => {
-      it("should resolve successfully", async () => {
-        await expect(generateEditPlan("test-planId")).resolves.not.toThrow()
-      })
+    it("should reject on API error", async () => {
+      mockGet.mockRejectedValue(new Error("Network error"))
+      mockPost.mockRejectedValue(new Error("Network error"))
+      mockPut.mockRejectedValue(new Error("Network error"))
+      mockDelete.mockRejectedValue(new Error("Network error"))
+      mockPatch.mockRejectedValue(new Error("Network error"))
 
-      it("should reject on API error", async () => {
-        mockGet.mockRejectedValue(new Error("Network error"))
-        mockPost.mockRejectedValue(new Error("Network error"))
-        mockPut.mockRejectedValue(new Error("Network error"))
-        mockDelete.mockRejectedValue(new Error("Network error"))
-        mockPatch.mockRejectedValue(new Error("Network error"))
+      await expect(deleteEditPlan("test-planId")).rejects.toThrow()
+    })
+  })
 
-        await expect(generateEditPlan("test-planId")).rejects.toThrow()
-      })
+  describe("generateEditPlan", () => {
+    it("should resolve successfully", async () => {
+      await expect(generateEditPlan("test-planId")).resolves.not.toThrow()
     })
 
-    describe("getGenerationStatus", () => {
-      it("should resolve successfully", async () => {
-        await expect(getGenerationStatus("test-planId")).resolves.not.toThrow()
-      })
+    it("should reject on API error", async () => {
+      mockGet.mockRejectedValue(new Error("Network error"))
+      mockPost.mockRejectedValue(new Error("Network error"))
+      mockPut.mockRejectedValue(new Error("Network error"))
+      mockDelete.mockRejectedValue(new Error("Network error"))
+      mockPatch.mockRejectedValue(new Error("Network error"))
 
-      it("should reject on API error", async () => {
-        mockGet.mockRejectedValue(new Error("Network error"))
-        mockPost.mockRejectedValue(new Error("Network error"))
-        mockPut.mockRejectedValue(new Error("Network error"))
-        mockDelete.mockRejectedValue(new Error("Network error"))
-        mockPatch.mockRejectedValue(new Error("Network error"))
+      await expect(generateEditPlan("test-planId")).rejects.toThrow()
+    })
+  })
 
-        await expect(getGenerationStatus("test-planId")).rejects.toThrow()
-      })
+  describe("getGenerationStatus", () => {
+    it("should resolve successfully", async () => {
+      await expect(getGenerationStatus("test-planId")).resolves.not.toThrow()
     })
 
-    describe("aiRecommendClips", () => {
-      it("should resolve successfully", async () => {
-        await expect(aiRecommendClips("test-planId")).resolves.not.toThrow()
-      })
+    it("should reject on API error", async () => {
+      mockGet.mockRejectedValue(new Error("Network error"))
+      mockPost.mockRejectedValue(new Error("Network error"))
+      mockPut.mockRejectedValue(new Error("Network error"))
+      mockDelete.mockRejectedValue(new Error("Network error"))
+      mockPatch.mockRejectedValue(new Error("Network error"))
 
-      it("should reject on API error", async () => {
-        mockGet.mockRejectedValue(new Error("Network error"))
-        mockPost.mockRejectedValue(new Error("Network error"))
-        mockPut.mockRejectedValue(new Error("Network error"))
-        mockDelete.mockRejectedValue(new Error("Network error"))
-        mockPatch.mockRejectedValue(new Error("Network error"))
+      await expect(getGenerationStatus("test-planId")).rejects.toThrow()
+    })
+  })
 
-        await expect(aiRecommendClips("test-planId")).rejects.toThrow()
-      })
+  describe("aiRecommendClips", () => {
+    it("should resolve successfully", async () => {
+      await expect(aiRecommendClips("test-planId")).resolves.not.toThrow()
     })
 
-    describe("generateCover", () => {
-      it("should resolve successfully", async () => {
-        await expect(generateCover("test-planId")).resolves.not.toThrow()
-      })
+    it("should reject on API error", async () => {
+      mockGet.mockRejectedValue(new Error("Network error"))
+      mockPost.mockRejectedValue(new Error("Network error"))
+      mockPut.mockRejectedValue(new Error("Network error"))
+      mockDelete.mockRejectedValue(new Error("Network error"))
+      mockPatch.mockRejectedValue(new Error("Network error"))
 
-      it("should reject on API error", async () => {
-        mockGet.mockRejectedValue(new Error("Network error"))
-        mockPost.mockRejectedValue(new Error("Network error"))
-        mockPut.mockRejectedValue(new Error("Network error"))
-        mockDelete.mockRejectedValue(new Error("Network error"))
-        mockPatch.mockRejectedValue(new Error("Network error"))
+      await expect(aiRecommendClips("test-planId")).rejects.toThrow()
+    })
+  })
 
-        await expect(generateCover("test-planId")).rejects.toThrow()
-      })
+  describe("generateCover", () => {
+    it("should resolve successfully", async () => {
+      await expect(generateCover("test-planId")).resolves.not.toThrow()
     })
 
-    describe("getEditPlanGenerations", () => {
-      it("should resolve successfully", async () => {
-        await expect(getEditPlanGenerations("test-planId")).resolves.not.toThrow()
-      })
+    it("should reject on API error", async () => {
+      mockGet.mockRejectedValue(new Error("Network error"))
+      mockPost.mockRejectedValue(new Error("Network error"))
+      mockPut.mockRejectedValue(new Error("Network error"))
+      mockDelete.mockRejectedValue(new Error("Network error"))
+      mockPatch.mockRejectedValue(new Error("Network error"))
 
-      it("should reject on API error", async () => {
-        mockGet.mockRejectedValue(new Error("Network error"))
-        mockPost.mockRejectedValue(new Error("Network error"))
-        mockPut.mockRejectedValue(new Error("Network error"))
-        mockDelete.mockRejectedValue(new Error("Network error"))
-        mockPatch.mockRejectedValue(new Error("Network error"))
+      await expect(generateCover("test-planId")).rejects.toThrow()
+    })
+  })
 
-        await expect(getEditPlanGenerations("test-planId")).rejects.toThrow()
-      })
+  describe("getEditPlanGenerations", () => {
+    it("should resolve successfully", async () => {
+      await expect(getEditPlanGenerations("test-planId")).resolves.not.toThrow()
     })
 
-    describe("getGenerationTaskResults", () => {
-      it("should resolve successfully", async () => {
-        await expect(getGenerationTaskResults("test-taskId")).resolves.not.toThrow()
-      })
+    it("should reject on API error", async () => {
+      mockGet.mockRejectedValue(new Error("Network error"))
+      mockPost.mockRejectedValue(new Error("Network error"))
+      mockPut.mockRejectedValue(new Error("Network error"))
+      mockDelete.mockRejectedValue(new Error("Network error"))
+      mockPatch.mockRejectedValue(new Error("Network error"))
 
-      it("should reject on API error", async () => {
-        mockGet.mockRejectedValue(new Error("Network error"))
-        mockPost.mockRejectedValue(new Error("Network error"))
-        mockPut.mockRejectedValue(new Error("Network error"))
-        mockDelete.mockRejectedValue(new Error("Network error"))
-        mockPatch.mockRejectedValue(new Error("Network error"))
+      await expect(getEditPlanGenerations("test-planId")).rejects.toThrow()
+    })
+  })
 
-        await expect(getGenerationTaskResults("test-taskId")).rejects.toThrow()
-      })
+  describe("getGenerationTaskResults", () => {
+    it("should resolve successfully", async () => {
+      await expect(getGenerationTaskResults("test-taskId")).resolves.not.toThrow()
     })
 
-    describe("cancelGeneration", () => {
-      it("should resolve successfully", async () => {
-        await expect(cancelGeneration("test-planId")).resolves.not.toThrow()
-      })
+    it("should reject on API error", async () => {
+      mockGet.mockRejectedValue(new Error("Network error"))
+      mockPost.mockRejectedValue(new Error("Network error"))
+      mockPut.mockRejectedValue(new Error("Network error"))
+      mockDelete.mockRejectedValue(new Error("Network error"))
+      mockPatch.mockRejectedValue(new Error("Network error"))
 
-      it("should reject on API error", async () => {
-        mockGet.mockRejectedValue(new Error("Network error"))
-        mockPost.mockRejectedValue(new Error("Network error"))
-        mockPut.mockRejectedValue(new Error("Network error"))
-        mockDelete.mockRejectedValue(new Error("Network error"))
-        mockPatch.mockRejectedValue(new Error("Network error"))
+      await expect(getGenerationTaskResults("test-taskId")).rejects.toThrow()
+    })
+  })
 
-        await expect(cancelGeneration("test-planId")).rejects.toThrow()
-      })
+  describe("cancelGeneration", () => {
+    it("should resolve successfully", async () => {
+      await expect(cancelGeneration("test-planId")).resolves.not.toThrow()
     })
 
-    describe("getEditPlanClips", () => {
-      it("should resolve successfully", async () => {
-        await expect(getEditPlanClips("test-planId")).resolves.not.toThrow()
-      })
+    it("should reject on API error", async () => {
+      mockGet.mockRejectedValue(new Error("Network error"))
+      mockPost.mockRejectedValue(new Error("Network error"))
+      mockPut.mockRejectedValue(new Error("Network error"))
+      mockDelete.mockRejectedValue(new Error("Network error"))
+      mockPatch.mockRejectedValue(new Error("Network error"))
 
-      it("should reject on API error", async () => {
-        mockGet.mockRejectedValue(new Error("Network error"))
-        mockPost.mockRejectedValue(new Error("Network error"))
-        mockPut.mockRejectedValue(new Error("Network error"))
-        mockDelete.mockRejectedValue(new Error("Network error"))
-        mockPatch.mockRejectedValue(new Error("Network error"))
+      await expect(cancelGeneration("test-planId")).rejects.toThrow()
+    })
+  })
 
-        await expect(getEditPlanClips("test-planId")).rejects.toThrow()
-      })
+  describe("getEditPlanClips", () => {
+    it("should resolve successfully", async () => {
+      await expect(getEditPlanClips("test-planId")).resolves.not.toThrow()
     })
 
-    describe("getEditPlanClip", () => {
-      it("should resolve successfully", async () => {
-        await expect(getEditPlanClip("test-planId")).resolves.not.toThrow()
-      })
+    it("should reject on API error", async () => {
+      mockGet.mockRejectedValue(new Error("Network error"))
+      mockPost.mockRejectedValue(new Error("Network error"))
+      mockPut.mockRejectedValue(new Error("Network error"))
+      mockDelete.mockRejectedValue(new Error("Network error"))
+      mockPatch.mockRejectedValue(new Error("Network error"))
 
-      it("should reject on API error", async () => {
-        mockGet.mockRejectedValue(new Error("Network error"))
-        mockPost.mockRejectedValue(new Error("Network error"))
-        mockPut.mockRejectedValue(new Error("Network error"))
-        mockDelete.mockRejectedValue(new Error("Network error"))
-        mockPatch.mockRejectedValue(new Error("Network error"))
+      await expect(getEditPlanClips("test-planId")).rejects.toThrow()
+    })
+  })
 
-        await expect(getEditPlanClip("test-planId")).rejects.toThrow()
-      })
+  describe("getEditPlanClip", () => {
+    it("should resolve successfully", async () => {
+      await expect(getEditPlanClip("test-planId")).resolves.not.toThrow()
     })
 
-    describe("createEditPlanClip", () => {
-      it("should resolve successfully", async () => {
-        await expect(createEditPlanClip("test-planId")).resolves.not.toThrow()
-      })
+    it("should reject on API error", async () => {
+      mockGet.mockRejectedValue(new Error("Network error"))
+      mockPost.mockRejectedValue(new Error("Network error"))
+      mockPut.mockRejectedValue(new Error("Network error"))
+      mockDelete.mockRejectedValue(new Error("Network error"))
+      mockPatch.mockRejectedValue(new Error("Network error"))
 
-      it("should reject on API error", async () => {
-        mockGet.mockRejectedValue(new Error("Network error"))
-        mockPost.mockRejectedValue(new Error("Network error"))
-        mockPut.mockRejectedValue(new Error("Network error"))
-        mockDelete.mockRejectedValue(new Error("Network error"))
-        mockPatch.mockRejectedValue(new Error("Network error"))
+      await expect(getEditPlanClip("test-planId")).rejects.toThrow()
+    })
+  })
 
-        await expect(createEditPlanClip("test-planId")).rejects.toThrow()
-      })
+  describe("createEditPlanClip", () => {
+    it("should resolve successfully", async () => {
+      await expect(createEditPlanClip("test-planId")).resolves.not.toThrow()
     })
 
-    describe("updateEditPlanClip", () => {
-      it("should resolve successfully", async () => {
-        await expect(updateEditPlanClip("test-planId")).resolves.not.toThrow()
-      })
+    it("should reject on API error", async () => {
+      mockGet.mockRejectedValue(new Error("Network error"))
+      mockPost.mockRejectedValue(new Error("Network error"))
+      mockPut.mockRejectedValue(new Error("Network error"))
+      mockDelete.mockRejectedValue(new Error("Network error"))
+      mockPatch.mockRejectedValue(new Error("Network error"))
 
-      it("should reject on API error", async () => {
-        mockGet.mockRejectedValue(new Error("Network error"))
-        mockPost.mockRejectedValue(new Error("Network error"))
-        mockPut.mockRejectedValue(new Error("Network error"))
-        mockDelete.mockRejectedValue(new Error("Network error"))
-        mockPatch.mockRejectedValue(new Error("Network error"))
+      await expect(createEditPlanClip("test-planId")).rejects.toThrow()
+    })
+  })
 
-        await expect(updateEditPlanClip("test-planId")).rejects.toThrow()
-      })
+  describe("updateEditPlanClip", () => {
+    it("should resolve successfully", async () => {
+      await expect(updateEditPlanClip("test-planId")).resolves.not.toThrow()
     })
 
-    describe("deleteEditPlanClip", () => {
-      it("should resolve successfully", async () => {
-        await expect(deleteEditPlanClip("test-planId")).resolves.not.toThrow()
-      })
+    it("should reject on API error", async () => {
+      mockGet.mockRejectedValue(new Error("Network error"))
+      mockPost.mockRejectedValue(new Error("Network error"))
+      mockPut.mockRejectedValue(new Error("Network error"))
+      mockDelete.mockRejectedValue(new Error("Network error"))
+      mockPatch.mockRejectedValue(new Error("Network error"))
 
-      it("should reject on API error", async () => {
-        mockGet.mockRejectedValue(new Error("Network error"))
-        mockPost.mockRejectedValue(new Error("Network error"))
-        mockPut.mockRejectedValue(new Error("Network error"))
-        mockDelete.mockRejectedValue(new Error("Network error"))
-        mockPatch.mockRejectedValue(new Error("Network error"))
+      await expect(updateEditPlanClip("test-planId")).rejects.toThrow()
+    })
+  })
 
-        await expect(deleteEditPlanClip("test-planId")).rejects.toThrow()
-      })
+  describe("deleteEditPlanClip", () => {
+    it("should resolve successfully", async () => {
+      await expect(deleteEditPlanClip("test-planId")).resolves.not.toThrow()
     })
 
-    describe("reorderEditPlanClips", () => {
-      it("should resolve successfully", async () => {
-        await expect(reorderEditPlanClips("test-planId")).resolves.not.toThrow()
-      })
+    it("should reject on API error", async () => {
+      mockGet.mockRejectedValue(new Error("Network error"))
+      mockPost.mockRejectedValue(new Error("Network error"))
+      mockPut.mockRejectedValue(new Error("Network error"))
+      mockDelete.mockRejectedValue(new Error("Network error"))
+      mockPatch.mockRejectedValue(new Error("Network error"))
 
-      it("should reject on API error", async () => {
-        mockGet.mockRejectedValue(new Error("Network error"))
-        mockPost.mockRejectedValue(new Error("Network error"))
-        mockPut.mockRejectedValue(new Error("Network error"))
-        mockDelete.mockRejectedValue(new Error("Network error"))
-        mockPatch.mockRejectedValue(new Error("Network error"))
+      await expect(deleteEditPlanClip("test-planId")).rejects.toThrow()
+    })
+  })
 
-        await expect(reorderEditPlanClips("test-planId")).rejects.toThrow()
-      })
+  describe("reorderEditPlanClips", () => {
+    it("should resolve successfully", async () => {
+      await expect(reorderEditPlanClips("test-planId")).resolves.not.toThrow()
     })
 
-    describe("batchDeleteEditPlanClips", () => {
-      it("should resolve successfully", async () => {
-        await expect(batchDeleteEditPlanClips("test-planId")).resolves.not.toThrow()
-      })
+    it("should reject on API error", async () => {
+      mockGet.mockRejectedValue(new Error("Network error"))
+      mockPost.mockRejectedValue(new Error("Network error"))
+      mockPut.mockRejectedValue(new Error("Network error"))
+      mockDelete.mockRejectedValue(new Error("Network error"))
+      mockPatch.mockRejectedValue(new Error("Network error"))
 
-      it("should reject on API error", async () => {
-        mockGet.mockRejectedValue(new Error("Network error"))
-        mockPost.mockRejectedValue(new Error("Network error"))
-        mockPut.mockRejectedValue(new Error("Network error"))
-        mockDelete.mockRejectedValue(new Error("Network error"))
-        mockPatch.mockRejectedValue(new Error("Network error"))
+      await expect(reorderEditPlanClips("test-planId")).rejects.toThrow()
+    })
+  })
 
-        await expect(batchDeleteEditPlanClips("test-planId")).rejects.toThrow()
-      })
+  describe("batchDeleteEditPlanClips", () => {
+    it("should resolve successfully", async () => {
+      await expect(batchDeleteEditPlanClips("test-planId")).resolves.not.toThrow()
     })
 
-    describe("createClipsFromAssets", () => {
-      it("should resolve successfully", async () => {
-        await expect(createClipsFromAssets("test-planId")).resolves.not.toThrow()
-      })
+    it("should reject on API error", async () => {
+      mockGet.mockRejectedValue(new Error("Network error"))
+      mockPost.mockRejectedValue(new Error("Network error"))
+      mockPut.mockRejectedValue(new Error("Network error"))
+      mockDelete.mockRejectedValue(new Error("Network error"))
+      mockPatch.mockRejectedValue(new Error("Network error"))
 
-      it("should reject on API error", async () => {
-        mockGet.mockRejectedValue(new Error("Network error"))
-        mockPost.mockRejectedValue(new Error("Network error"))
-        mockPut.mockRejectedValue(new Error("Network error"))
-        mockDelete.mockRejectedValue(new Error("Network error"))
-        mockPatch.mockRejectedValue(new Error("Network error"))
+      await expect(batchDeleteEditPlanClips("test-planId")).rejects.toThrow()
+    })
+  })
 
-        await expect(createClipsFromAssets("test-planId")).rejects.toThrow()
-      })
+  describe("createClipsFromAssets", () => {
+    it("should resolve successfully", async () => {
+      await expect(createClipsFromAssets("test-planId")).resolves.not.toThrow()
     })
 
-    describe("copyEditPlan", () => {
-      it("should resolve successfully", async () => {
-        await expect(copyEditPlan("test-planId")).resolves.not.toThrow()
-      })
+    it("should reject on API error", async () => {
+      mockGet.mockRejectedValue(new Error("Network error"))
+      mockPost.mockRejectedValue(new Error("Network error"))
+      mockPut.mockRejectedValue(new Error("Network error"))
+      mockDelete.mockRejectedValue(new Error("Network error"))
+      mockPatch.mockRejectedValue(new Error("Network error"))
 
-      it("should reject on API error", async () => {
-        mockGet.mockRejectedValue(new Error("Network error"))
-        mockPost.mockRejectedValue(new Error("Network error"))
-        mockPut.mockRejectedValue(new Error("Network error"))
-        mockDelete.mockRejectedValue(new Error("Network error"))
-        mockPatch.mockRejectedValue(new Error("Network error"))
+      await expect(createClipsFromAssets("test-planId")).rejects.toThrow()
+    })
+  })
 
-        await expect(copyEditPlan("test-planId")).rejects.toThrow()
-      })
+  describe("copyEditPlan", () => {
+    it("should resolve successfully", async () => {
+      await expect(copyEditPlan("test-planId")).resolves.not.toThrow()
     })
 
-    describe("getMediaAssets", () => {
-      it("should resolve successfully", async () => {
-        await expect(getMediaAssets("test-libraryId?")).resolves.not.toThrow()
-      })
+    it("should reject on API error", async () => {
+      mockGet.mockRejectedValue(new Error("Network error"))
+      mockPost.mockRejectedValue(new Error("Network error"))
+      mockPut.mockRejectedValue(new Error("Network error"))
+      mockDelete.mockRejectedValue(new Error("Network error"))
+      mockPatch.mockRejectedValue(new Error("Network error"))
 
-      it("should reject on API error", async () => {
-        mockGet.mockRejectedValue(new Error("Network error"))
-        mockPost.mockRejectedValue(new Error("Network error"))
-        mockPut.mockRejectedValue(new Error("Network error"))
-        mockDelete.mockRejectedValue(new Error("Network error"))
-        mockPatch.mockRejectedValue(new Error("Network error"))
+      await expect(copyEditPlan("test-planId")).rejects.toThrow()
+    })
+  })
 
-        await expect(getMediaAssets("test-libraryId?")).rejects.toThrow()
-      })
+  describe("getMediaAssets", () => {
+    it("should resolve successfully", async () => {
+      await expect(getMediaAssets("test-libraryId?")).resolves.not.toThrow()
     })
 
-    describe("getMediaAsset", () => {
-      it("should resolve successfully", async () => {
-        await expect(getMediaAsset("test-id")).resolves.not.toThrow()
-      })
+    it("should reject on API error", async () => {
+      mockGet.mockRejectedValue(new Error("Network error"))
+      mockPost.mockRejectedValue(new Error("Network error"))
+      mockPut.mockRejectedValue(new Error("Network error"))
+      mockDelete.mockRejectedValue(new Error("Network error"))
+      mockPatch.mockRejectedValue(new Error("Network error"))
 
-      it("should reject on API error", async () => {
-        mockGet.mockRejectedValue(new Error("Network error"))
-        mockPost.mockRejectedValue(new Error("Network error"))
-        mockPut.mockRejectedValue(new Error("Network error"))
-        mockDelete.mockRejectedValue(new Error("Network error"))
-        mockPatch.mockRejectedValue(new Error("Network error"))
-
-        await expect(getMediaAsset("test-id")).rejects.toThrow()
-      })
+      await expect(getMediaAssets("test-libraryId?")).rejects.toThrow()
     })
+  })
+
+  describe("getMediaAsset", () => {
+    it("should resolve successfully", async () => {
+      await expect(getMediaAsset("test-id")).resolves.not.toThrow()
+    })
+
+    it("should reject on API error", async () => {
+      mockGet.mockRejectedValue(new Error("Network error"))
+      mockPost.mockRejectedValue(new Error("Network error"))
+      mockPut.mockRejectedValue(new Error("Network error"))
+      mockDelete.mockRejectedValue(new Error("Network error"))
+      mockPatch.mockRejectedValue(new Error("Network error"))
+
+      await expect(getMediaAsset("test-id")).rejects.toThrow()
+    })
+  })
 })

apps/web/src/test/api/editingPlanner.test.ts

@@ -1,5 +1,13 @@
 import { describe, expect, it, vi, beforeEach } from "vitest"
-import { getEditingTemplates, getEditingTemplate, createEditingTemplate, updateEditingTemplate, deleteEditingTemplate, getTemplateCategories, generateFromTemplate } from "@/api/editingPlanner"
+import {
+  getEditingTemplates,
+  getEditingTemplate,
+  createEditingTemplate,
+  updateEditingTemplate,
+  deleteEditingTemplate,
+  getTemplateCategories,
+  generateFromTemplate,
+} from "@/api/editingPlanner"
 
 const mockGet = vi.fn()
 const mockPost = vi.fn()
@@ -20,7 +28,6 @@ vi.mock("@/api/client", () => ({
 vi.mock("antd", () => ({ message: { error: vi.fn(), success: vi.fn() } }))
 vi.mock("@/store/authStore", () => ({ useAuthStore: { getState: vi.fn(() => ({})) } }))
 
-
 describe("editingPlanner API", () => {
   beforeEach(() => {
     vi.clearAllMocks()
@@ -31,115 +38,115 @@ describe("editingPlanner API", () => {
     mockPatch.mockResolvedValue({ data: { success: true, items: [] } })
   })
 
-      describe("getEditingTemplates", () => {
-      it("should resolve successfully", async () => {
-        await expect(getEditingTemplates("test-params?")).resolves.not.toThrow()
-      })
-
-      it("should reject on API error", async () => {
-        mockGet.mockRejectedValue(new Error("Network error"))
-        mockPost.mockRejectedValue(new Error("Network error"))
-        mockPut.mockRejectedValue(new Error("Network error"))
-        mockDelete.mockRejectedValue(new Error("Network error"))
-        mockPatch.mockRejectedValue(new Error("Network error"))
-
-        await expect(getEditingTemplates("test-params?")).rejects.toThrow()
-      })
+  describe("getEditingTemplates", () => {
+    it("should resolve successfully", async () => {
+      await expect(getEditingTemplates("test-params?")).resolves.not.toThrow()
     })
 
-    describe("getEditingTemplate", () => {
-      it("should resolve successfully", async () => {
-        await expect(getEditingTemplate("test-id")).resolves.not.toThrow()
-      })
+    it("should reject on API error", async () => {
+      mockGet.mockRejectedValue(new Error("Network error"))
+      mockPost.mockRejectedValue(new Error("Network error"))
+      mockPut.mockRejectedValue(new Error("Network error"))
+      mockDelete.mockRejectedValue(new Error("Network error"))
+      mockPatch.mockRejectedValue(new Error("Network error"))
 
-      it("should reject on API error", async () => {
-        mockGet.mockRejectedValue(new Error("Network error"))
-        mockPost.mockRejectedValue(new Error("Network error"))
-        mockPut.mockRejectedValue(new Error("Network error"))
-        mockDelete.mockRejectedValue(new Error("Network error"))
-        mockPatch.mockRejectedValue(new Error("Network error"))
+      await expect(getEditingTemplates("test-params?")).rejects.toThrow()
+    })
+  })
 
-        await expect(getEditingTemplate("test-id")).rejects.toThrow()
-      })
+  describe("getEditingTemplate", () => {
+    it("should resolve successfully", async () => {
+      await expect(getEditingTemplate("test-id")).resolves.not.toThrow()
     })
 
-    describe("createEditingTemplate", () => {
-      it("should resolve successfully", async () => {
-        await expect(createEditingTemplate({ name: "test-item" })).resolves.not.toThrow()
-      })
+    it("should reject on API error", async () => {
+      mockGet.mockRejectedValue(new Error("Network error"))
+      mockPost.mockRejectedValue(new Error("Network error"))
+      mockPut.mockRejectedValue(new Error("Network error"))
+      mockDelete.mockRejectedValue(new Error("Network error"))
+      mockPatch.mockRejectedValue(new Error("Network error"))
 
-      it("should reject on API error", async () => {
-        mockGet.mockRejectedValue(new Error("Network error"))
-        mockPost.mockRejectedValue(new Error("Network error"))
-        mockPut.mockRejectedValue(new Error("Network error"))
-        mockDelete.mockRejectedValue(new Error("Network error"))
-        mockPatch.mockRejectedValue(new Error("Network error"))
+      await expect(getEditingTemplate("test-id")).rejects.toThrow()
+    })
+  })
 
-        await expect(createEditingTemplate({ name: "test-item" })).rejects.toThrow()
-      })
+  describe("createEditingTemplate", () => {
+    it("should resolve successfully", async () => {
+      await expect(createEditingTemplate({ name: "test-item" })).resolves.not.toThrow()
     })
 
-    describe("updateEditingTemplate", () => {
-      it("should resolve successfully", async () => {
-        await expect(updateEditingTemplate("test-id")).resolves.not.toThrow()
-      })
+    it("should reject on API error", async () => {
+      mockGet.mockRejectedValue(new Error("Network error"))
+      mockPost.mockRejectedValue(new Error("Network error"))
+      mockPut.mockRejectedValue(new Error("Network error"))
+      mockDelete.mockRejectedValue(new Error("Network error"))
+      mockPatch.mockRejectedValue(new Error("Network error"))
 
-      it("should reject on API error", async () => {
-        mockGet.mockRejectedValue(new Error("Network error"))
-        mockPost.mockRejectedValue(new Error("Network error"))
-        mockPut.mockRejectedValue(new Error("Network error"))
-        mockDelete.mockRejectedValue(new Error("Network error"))
-        mockPatch.mockRejectedValue(new Error("Network error"))
+      await expect(createEditingTemplate({ name: "test-item" })).rejects.toThrow()
+    })
+  })
 
-        await expect(updateEditingTemplate("test-id")).rejects.toThrow()
-      })
+  describe("updateEditingTemplate", () => {
+    it("should resolve successfully", async () => {
+      await expect(updateEditingTemplate("test-id")).resolves.not.toThrow()
     })
 
-    describe("deleteEditingTemplate", () => {
-      it("should resolve successfully", async () => {
-        await expect(deleteEditingTemplate("test-id")).resolves.not.toThrow()
-      })
+    it("should reject on API error", async () => {
+      mockGet.mockRejectedValue(new Error("Network error"))
+      mockPost.mockRejectedValue(new Error("Network error"))
+      mockPut.mockRejectedValue(new Error("Network error"))
+      mockDelete.mockRejectedValue(new Error("Network error"))
+      mockPatch.mockRejectedValue(new Error("Network error"))
 
-      it("should reject on API error", async () => {
-        mockGet.mockRejectedValue(new Error("Network error"))
-        mockPost.mockRejectedValue(new Error("Network error"))
-        mockPut.mockRejectedValue(new Error("Network error"))
-        mockDelete.mockRejectedValue(new Error("Network error"))
-        mockPatch.mockRejectedValue(new Error("Network error"))
+      await expect(updateEditingTemplate("test-id")).rejects.toThrow()
+    })
+  })
 
-        await expect(deleteEditingTemplate("test-id")).rejects.toThrow()
-      })
+  describe("deleteEditingTemplate", () => {
+    it("should resolve successfully", async () => {
+      await expect(deleteEditingTemplate("test-id")).resolves.not.toThrow()
     })
 
-    describe("getTemplateCategories", () => {
-      it("should resolve successfully", async () => {
-        await expect(getTemplateCategories()).resolves.not.toThrow()
-      })
+    it("should reject on API error", async () => {
+      mockGet.mockRejectedValue(new Error("Network error"))
+      mockPost.mockRejectedValue(new Error("Network error"))
+      mockPut.mockRejectedValue(new Error("Network error"))
+      mockDelete.mockRejectedValue(new Error("Network error"))
+      mockPatch.mockRejectedValue(new Error("Network error"))
 
-      it("should reject on API error", async () => {
-        mockGet.mockRejectedValue(new Error("Network error"))
-        mockPost.mockRejectedValue(new Error("Network error"))
-        mockPut.mockRejectedValue(new Error("Network error"))
-        mockDelete.mockRejectedValue(new Error("Network error"))
-        mockPatch.mockRejectedValue(new Error("Network error"))
+      await expect(deleteEditingTemplate("test-id")).rejects.toThrow()
+    })
+  })
 
-        await expect(getTemplateCategories()).rejects.toThrow()
-      })
+  describe("getTemplateCategories", () => {
+    it("should resolve successfully", async () => {
+      await expect(getTemplateCategories()).resolves.not.toThrow()
     })
 
-    describe("generateFromTemplate", () => {
-      it("should resolve successfully", async () => {
-        await expect(generateFromTemplate("test-templateId")).resolves.not.toThrow()
-      })
+    it("should reject on API error", async () => {
+      mockGet.mockRejectedValue(new Error("Network error"))
+      mockPost.mockRejectedValue(new Error("Network error"))
+      mockPut.mockRejectedValue(new Error("Network error"))
+      mockDelete.mockRejectedValue(new Error("Network error"))
+      mockPatch.mockRejectedValue(new Error("Network error"))
 
-      it("should reject on API error", async () => {
-        mockGet.mockRejectedValue(new Error("Network error"))
-        mockPost.mockRejectedValue(new Error("Network error"))
-        mockPut.mockRejectedValue(new Error("Network error"))
-        mockDelete.mockRejectedValue(new Error("Network error"))
-        mockPatch.mockRejectedValue(new Error("Network error"))
-
-        await expect(generateFromTemplate("test-templateId")).rejects.toThrow()
-      })
+      await expect(getTemplateCategories()).rejects.toThrow()
     })
+  })
+
+  describe("generateFromTemplate", () => {
+    it("should resolve successfully", async () => {
+      await expect(generateFromTemplate("test-templateId")).resolves.not.toThrow()
+    })
+
+    it("should reject on API error", async () => {
+      mockGet.mockRejectedValue(new Error("Network error"))
+      mockPost.mockRejectedValue(new Error("Network error"))
+      mockPut.mockRejectedValue(new Error("Network error"))
+      mockDelete.mockRejectedValue(new Error("Network error"))
+      mockPatch.mockRejectedValue(new Error("Network error"))
+
+      await expect(generateFromTemplate("test-templateId")).rejects.toThrow()
+    })
+  })
 })

apps/web/src/test/api/products.test.ts

@@ -1,5 +1,13 @@
 import { describe, expect, it, vi, beforeEach } from "vitest"
-import { getProducts, getProduct, deleteProduct, getProductDownloadUrl, updateReviewStatus, batchDownload, getBatchDownloadStatus } from "@/api/products"
+import {
+  getProducts,
+  getProduct,
+  deleteProduct,
+  getProductDownloadUrl,
+  updateReviewStatus,
+  batchDownload,
+  getBatchDownloadStatus,
+} from "@/api/products"
 
 const mockGet = vi.fn()
 const mockPost = vi.fn()
@@ -20,7 +28,6 @@ vi.mock("@/api/client", () => ({
 vi.mock("antd", () => ({ message: { error: vi.fn(), success: vi.fn() } }))
 vi.mock("@/store/authStore", () => ({ useAuthStore: { getState: vi.fn(() => ({})) } }))
 
-
 describe("products API", () => {
   beforeEach(() => {
     vi.clearAllMocks()
@@ -31,99 +38,105 @@ describe("products API", () => {
     mockPatch.mockResolvedValue({ data: { success: true, items: [] } })
   })
 
-      describe("getProducts", () => {
-      it("should resolve successfully", async () => {
-        await expect(getProducts("test-params?")).resolves.not.toThrow()
-      })
-
-      it("should reject on API error", async () => {
-        mockGet.mockRejectedValue(new Error("Network error"))
-        mockPost.mockRejectedValue(new Error("Network error"))
-        mockPut.mockRejectedValue(new Error("Network error"))
-        mockDelete.mockRejectedValue(new Error("Network error"))
-        mockPatch.mockRejectedValue(new Error("Network error"))
-
-        await expect(getProducts("test-params?")).rejects.toThrow()
-      })
+  describe("getProducts", () => {
+    it("should resolve successfully", async () => {
+      await expect(getProducts("test-params?")).resolves.not.toThrow()
     })
 
-    describe("getProduct", () => {
-      it("should resolve successfully", async () => {
-        await expect(getProduct("test-productId")).resolves.not.toThrow()
-      })
+    it("should reject on API error", async () => {
+      mockGet.mockRejectedValue(new Error("Network error"))
+      mockPost.mockRejectedValue(new Error("Network error"))
+      mockPut.mockRejectedValue(new Error("Network error"))
+      mockDelete.mockRejectedValue(new Error("Network error"))
+      mockPatch.mockRejectedValue(new Error("Network error"))
 
-      it("should reject on API error", async () => {
-        mockGet.mockRejectedValue(new Error("Network error"))
-        mockPost.mockRejectedValue(new Error("Network error"))
-        mockPut.mockRejectedValue(new Error("Network error"))
-        mockDelete.mockRejectedValue(new Error("Network error"))
-        mockPatch.mockRejectedValue(new Error("Network error"))
+      await expect(getProducts("test-params?")).rejects.toThrow()
+    })
+  })
 
-        await expect(getProduct("test-productId")).rejects.toThrow()
-      })
+  describe("getProduct", () => {
+    it("should resolve successfully", async () => {
+      await expect(getProduct("test-productId")).resolves.not.toThrow()
     })
 
-    describe("deleteProduct", () => {
-      it("should resolve successfully", async () => {
-        await expect(deleteProduct("test-productId")).resolves.not.toThrow()
-      })
+    it("should reject on API error", async () => {
+      mockGet.mockRejectedValue(new Error("Network error"))
+      mockPost.mockRejectedValue(new Error("Network error"))
+      mockPut.mockRejectedValue(new Error("Network error"))
+      mockDelete.mockRejectedValue(new Error("Network error"))
+      mockPatch.mockRejectedValue(new Error("Network error"))
 
-      it("should reject on API error", async () => {
-        mockGet.mockRejectedValue(new Error("Network error"))
-        mockPost.mockRejectedValue(new Error("Network error"))
-        mockPut.mockRejectedValue(new Error("Network error"))
-        mockDelete.mockRejectedValue(new Error("Network error"))
-        mockPatch.mockRejectedValue(new Error("Network error"))
+      await expect(getProduct("test-productId")).rejects.toThrow()
+    })
+  })
 
-        await expect(deleteProduct("test-productId")).rejects.toThrow()
-      })
+  describe("deleteProduct", () => {
+    it("should resolve successfully", async () => {
+      await expect(deleteProduct("test-productId")).resolves.not.toThrow()
     })
 
-    describe("getProductDownloadUrl", () => {
-      it("should resolve successfully", async () => {
-        mockGet.mockResolvedValue({ data: { id: "test-productId", name: "测试视频", download_url: "https://example.com/video.mp4" } })
-        await expect(getProductDownloadUrl("test-productId")).resolves.not.toThrow()
-      })
+    it("should reject on API error", async () => {
+      mockGet.mockRejectedValue(new Error("Network error"))
+      mockPost.mockRejectedValue(new Error("Network error"))
+      mockPut.mockRejectedValue(new Error("Network error"))
+      mockDelete.mockRejectedValue(new Error("Network error"))
+      mockPatch.mockRejectedValue(new Error("Network error"))
 
-      it("should reject on API error", async () => {
-        mockGet.mockRejectedValue(new Error("Network error"))
-        mockPost.mockRejectedValue(new Error("Network error"))
-        mockPut.mockRejectedValue(new Error("Network error"))
-        mockDelete.mockRejectedValue(new Error("Network error"))
-        mockPatch.mockRejectedValue(new Error("Network error"))
+      await expect(deleteProduct("test-productId")).rejects.toThrow()
+    })
+  })
 
-        await expect(getProductDownloadUrl("test-productId")).rejects.toThrow()
+  describe("getProductDownloadUrl", () => {
+    it("should resolve successfully", async () => {
+      mockGet.mockResolvedValue({
+        data: {
+          id: "test-productId",
+          name: "测试视频",
+          download_url: "https://example.com/video.mp4",
+        },
       })
+      await expect(getProductDownloadUrl("test-productId")).resolves.not.toThrow()
     })
 
-    describe("updateReviewStatus", () => {
-      it("should resolve successfully", async () => {
-        await expect(updateReviewStatus("test-productId")).resolves.not.toThrow()
-      })
+    it("should reject on API error", async () => {
+      mockGet.mockRejectedValue(new Error("Network error"))
+      mockPost.mockRejectedValue(new Error("Network error"))
+      mockPut.mockRejectedValue(new Error("Network error"))
+      mockDelete.mockRejectedValue(new Error("Network error"))
+      mockPatch.mockRejectedValue(new Error("Network error"))
 
-      it("should reject on API error", async () => {
-        mockGet.mockRejectedValue(new Error("Network error"))
-        mockPost.mockRejectedValue(new Error("Network error"))
-        mockPut.mockRejectedValue(new Error("Network error"))
-        mockDelete.mockRejectedValue(new Error("Network error"))
-        mockPatch.mockRejectedValue(new Error("Network error"))
+      await expect(getProductDownloadUrl("test-productId")).rejects.toThrow()
+    })
+  })
 
-        await expect(updateReviewStatus("test-productId")).rejects.toThrow()
-      })
+  describe("updateReviewStatus", () => {
+    it("should resolve successfully", async () => {
+      await expect(updateReviewStatus("test-productId")).resolves.not.toThrow()
     })
 
-    describe("batchDownload", () => {
-      it("should resolve with mock job_id", async () => {
-        const result = await batchDownload(["item-1", "item-2"])
-        expect(result.job_id).toBeDefined()
-      })
-    })
+    it("should reject on API error", async () => {
+      mockGet.mockRejectedValue(new Error("Network error"))
+      mockPost.mockRejectedValue(new Error("Network error"))
+      mockPut.mockRejectedValue(new Error("Network error"))
+      mockDelete.mockRejectedValue(new Error("Network error"))
+      mockPatch.mockRejectedValue(new Error("Network error"))
 
-    describe("getBatchDownloadStatus", () => {
-      it("should resolve with mock status", async () => {
-        const result = await getBatchDownloadStatus("test-jobId")
-        expect(result.job_id).toBe("test-jobId")
-        expect(result.status).toBeDefined()
-      })
+      await expect(updateReviewStatus("test-productId")).rejects.toThrow()
     })
+  })
+
+  describe("batchDownload", () => {
+    it("should resolve with mock job_id", async () => {
+      const result = await batchDownload(["item-1", "item-2"])
+      expect(result.job_id).toBeDefined()
+    })
+  })
+
+  describe("getBatchDownloadStatus", () => {
+    it("should resolve with mock status", async () => {
+      const result = await getBatchDownloadStatus("test-jobId")
+      expect(result.job_id).toBe("test-jobId")
+      expect(result.status).toBeDefined()
+    })
+  })
 })

apps/web/src/test/api/projects.test.ts

@@ -20,7 +20,6 @@ vi.mock("@/api/client", () => ({
 vi.mock("antd", () => ({ message: { error: vi.fn(), success: vi.fn() } }))
 vi.mock("@/store/authStore", () => ({ useAuthStore: { getState: vi.fn(() => ({})) } }))
 
-
 describe("projects API", () => {
   beforeEach(() => {
     vi.clearAllMocks()
@@ -31,51 +30,51 @@ describe("projects API", () => {
     mockPatch.mockResolvedValue({ data: { success: true, items: [] } })
   })
 
-      describe("getProjects", () => {
-      it("should resolve successfully", async () => {
-        await expect(getProjects()).resolves.not.toThrow()
-      })
-
-      it("should reject on API error", async () => {
-        mockGet.mockRejectedValue(new Error("Network error"))
-        mockPost.mockRejectedValue(new Error("Network error"))
-        mockPut.mockRejectedValue(new Error("Network error"))
-        mockDelete.mockRejectedValue(new Error("Network error"))
-        mockPatch.mockRejectedValue(new Error("Network error"))
-
-        await expect(getProjects()).rejects.toThrow()
-      })
+  describe("getProjects", () => {
+    it("should resolve successfully", async () => {
+      await expect(getProjects()).resolves.not.toThrow()
     })
 
-    describe("createProject", () => {
-      it("should resolve successfully", async () => {
-        await expect(createProject({ name: "test-item" })).resolves.not.toThrow()
-      })
+    it("should reject on API error", async () => {
+      mockGet.mockRejectedValue(new Error("Network error"))
+      mockPost.mockRejectedValue(new Error("Network error"))
+      mockPut.mockRejectedValue(new Error("Network error"))
+      mockDelete.mockRejectedValue(new Error("Network error"))
+      mockPatch.mockRejectedValue(new Error("Network error"))
 
-      it("should reject on API error", async () => {
-        mockGet.mockRejectedValue(new Error("Network error"))
-        mockPost.mockRejectedValue(new Error("Network error"))
-        mockPut.mockRejectedValue(new Error("Network error"))
-        mockDelete.mockRejectedValue(new Error("Network error"))
-        mockPatch.mockRejectedValue(new Error("Network error"))
+      await expect(getProjects()).rejects.toThrow()
+    })
+  })
 
-        await expect(createProject({ name: "test-item" })).rejects.toThrow()
-      })
+  describe("createProject", () => {
+    it("should resolve successfully", async () => {
+      await expect(createProject({ name: "test-item" })).resolves.not.toThrow()
     })
 
-    describe("getOrCreateDefaultProject", () => {
-      it("should resolve successfully", async () => {
-        await expect(getOrCreateDefaultProject()).resolves.not.toThrow()
-      })
+    it("should reject on API error", async () => {
+      mockGet.mockRejectedValue(new Error("Network error"))
+      mockPost.mockRejectedValue(new Error("Network error"))
+      mockPut.mockRejectedValue(new Error("Network error"))
+      mockDelete.mockRejectedValue(new Error("Network error"))
+      mockPatch.mockRejectedValue(new Error("Network error"))
 
-      it("should reject on API error", async () => {
-        mockGet.mockRejectedValue(new Error("Network error"))
-        mockPost.mockRejectedValue(new Error("Network error"))
-        mockPut.mockRejectedValue(new Error("Network error"))
-        mockDelete.mockRejectedValue(new Error("Network error"))
-        mockPatch.mockRejectedValue(new Error("Network error"))
-
-        await expect(getOrCreateDefaultProject()).rejects.toThrow()
-      })
+      await expect(createProject({ name: "test-item" })).rejects.toThrow()
     })
+  })
+
+  describe("getOrCreateDefaultProject", () => {
+    it("should resolve successfully", async () => {
+      await expect(getOrCreateDefaultProject()).resolves.not.toThrow()
+    })
+
+    it("should reject on API error", async () => {
+      mockGet.mockRejectedValue(new Error("Network error"))
+      mockPost.mockRejectedValue(new Error("Network error"))
+      mockPut.mockRejectedValue(new Error("Network error"))
+      mockDelete.mockRejectedValue(new Error("Network error"))
+      mockPatch.mockRejectedValue(new Error("Network error"))
+
+      await expect(getOrCreateDefaultProject()).rejects.toThrow()
+    })
+  })
 })

apps/web/src/test/api/subscription.test.ts

@@ -1,5 +1,11 @@
 import { describe, expect, it, vi, beforeEach } from "vitest"
-import { getCurrentSubscription, getBillingRecords, changePlan, cancelSubscription, toggleAutoRenew } from "@/api/subscription"
+import {
+  getCurrentSubscription,
+  getBillingRecords,
+  changePlan,
+  cancelSubscription,
+  toggleAutoRenew,
+} from "@/api/subscription"
 
 const mockGet = vi.fn()
 const mockPost = vi.fn()
@@ -20,7 +26,6 @@ vi.mock("@/api/client", () => ({
 vi.mock("antd", () => ({ message: { error: vi.fn(), success: vi.fn() } }))
 vi.mock("@/store/authStore", () => ({ useAuthStore: { getState: vi.fn(() => ({})) } }))
 
-
 describe("subscription API", () => {
   beforeEach(() => {
     vi.clearAllMocks()
@@ -31,83 +36,83 @@ describe("subscription API", () => {
     mockPatch.mockResolvedValue({ data: { success: true, items: [] } })
   })
 
-      describe("getCurrentSubscription", () => {
-      it("should resolve successfully", async () => {
-        await expect(getCurrentSubscription()).resolves.not.toThrow()
-      })
-
-      it("should reject on API error", async () => {
-        mockGet.mockRejectedValue(new Error("Network error"))
-        mockPost.mockRejectedValue(new Error("Network error"))
-        mockPut.mockRejectedValue(new Error("Network error"))
-        mockDelete.mockRejectedValue(new Error("Network error"))
-        mockPatch.mockRejectedValue(new Error("Network error"))
-
-        await expect(getCurrentSubscription()).rejects.toThrow()
-      })
+  describe("getCurrentSubscription", () => {
+    it("should resolve successfully", async () => {
+      await expect(getCurrentSubscription()).resolves.not.toThrow()
     })
 
-    describe("getBillingRecords", () => {
-      it("should resolve successfully", async () => {
-        await expect(getBillingRecords()).resolves.not.toThrow()
-      })
+    it("should reject on API error", async () => {
+      mockGet.mockRejectedValue(new Error("Network error"))
+      mockPost.mockRejectedValue(new Error("Network error"))
+      mockPut.mockRejectedValue(new Error("Network error"))
+      mockDelete.mockRejectedValue(new Error("Network error"))
+      mockPatch.mockRejectedValue(new Error("Network error"))
 
-      it("should reject on API error", async () => {
-        mockGet.mockRejectedValue(new Error("Network error"))
-        mockPost.mockRejectedValue(new Error("Network error"))
-        mockPut.mockRejectedValue(new Error("Network error"))
-        mockDelete.mockRejectedValue(new Error("Network error"))
-        mockPatch.mockRejectedValue(new Error("Network error"))
+      await expect(getCurrentSubscription()).rejects.toThrow()
+    })
+  })
 
-        await expect(getBillingRecords()).rejects.toThrow()
-      })
+  describe("getBillingRecords", () => {
+    it("should resolve successfully", async () => {
+      await expect(getBillingRecords()).resolves.not.toThrow()
     })
 
-    describe("changePlan", () => {
-      it("should resolve successfully", async () => {
-        await expect(changePlan("test-request")).resolves.not.toThrow()
-      })
+    it("should reject on API error", async () => {
+      mockGet.mockRejectedValue(new Error("Network error"))
+      mockPost.mockRejectedValue(new Error("Network error"))
+      mockPut.mockRejectedValue(new Error("Network error"))
+      mockDelete.mockRejectedValue(new Error("Network error"))
+      mockPatch.mockRejectedValue(new Error("Network error"))
 
-      it("should reject on API error", async () => {
-        mockGet.mockRejectedValue(new Error("Network error"))
-        mockPost.mockRejectedValue(new Error("Network error"))
-        mockPut.mockRejectedValue(new Error("Network error"))
-        mockDelete.mockRejectedValue(new Error("Network error"))
-        mockPatch.mockRejectedValue(new Error("Network error"))
+      await expect(getBillingRecords()).rejects.toThrow()
+    })
+  })
 
-        await expect(changePlan("test-request")).rejects.toThrow()
-      })
+  describe("changePlan", () => {
+    it("should resolve successfully", async () => {
+      await expect(changePlan("test-request")).resolves.not.toThrow()
     })
 
-    describe("cancelSubscription", () => {
-      it("should resolve successfully", async () => {
-        await expect(cancelSubscription()).resolves.not.toThrow()
-      })
+    it("should reject on API error", async () => {
+      mockGet.mockRejectedValue(new Error("Network error"))
+      mockPost.mockRejectedValue(new Error("Network error"))
+      mockPut.mockRejectedValue(new Error("Network error"))
+      mockDelete.mockRejectedValue(new Error("Network error"))
+      mockPatch.mockRejectedValue(new Error("Network error"))
 
-      it("should reject on API error", async () => {
-        mockGet.mockRejectedValue(new Error("Network error"))
-        mockPost.mockRejectedValue(new Error("Network error"))
-        mockPut.mockRejectedValue(new Error("Network error"))
-        mockDelete.mockRejectedValue(new Error("Network error"))
-        mockPatch.mockRejectedValue(new Error("Network error"))
+      await expect(changePlan("test-request")).rejects.toThrow()
+    })
+  })
 
-        await expect(cancelSubscription()).rejects.toThrow()
-      })
+  describe("cancelSubscription", () => {
+    it("should resolve successfully", async () => {
+      await expect(cancelSubscription()).resolves.not.toThrow()
     })
 
-    describe("toggleAutoRenew", () => {
-      it("should resolve successfully", async () => {
-        await expect(toggleAutoRenew("test-enabled")).resolves.not.toThrow()
-      })
+    it("should reject on API error", async () => {
+      mockGet.mockRejectedValue(new Error("Network error"))
+      mockPost.mockRejectedValue(new Error("Network error"))
+      mockPut.mockRejectedValue(new Error("Network error"))
+      mockDelete.mockRejectedValue(new Error("Network error"))
+      mockPatch.mockRejectedValue(new Error("Network error"))
 
-      it("should reject on API error", async () => {
-        mockGet.mockRejectedValue(new Error("Network error"))
-        mockPost.mockRejectedValue(new Error("Network error"))
-        mockPut.mockRejectedValue(new Error("Network error"))
-        mockDelete.mockRejectedValue(new Error("Network error"))
-        mockPatch.mockRejectedValue(new Error("Network error"))
-
-        await expect(toggleAutoRenew("test-enabled")).rejects.toThrow()
-      })
+      await expect(cancelSubscription()).rejects.toThrow()
     })
+  })
+
+  describe("toggleAutoRenew", () => {
+    it("should resolve successfully", async () => {
+      await expect(toggleAutoRenew("test-enabled")).resolves.not.toThrow()
+    })
+
+    it("should reject on API error", async () => {
+      mockGet.mockRejectedValue(new Error("Network error"))
+      mockPost.mockRejectedValue(new Error("Network error"))
+      mockPut.mockRejectedValue(new Error("Network error"))
+      mockDelete.mockRejectedValue(new Error("Network error"))
+      mockPatch.mockRejectedValue(new Error("Network error"))
+
+      await expect(toggleAutoRenew("test-enabled")).rejects.toThrow()
+    })
+  })
 })

apps/web/src/test/api/tags.test.ts

@@ -20,7 +20,6 @@ vi.mock("@/api/client", () => ({
 vi.mock("antd", () => ({ message: { error: vi.fn(), success: vi.fn() } }))
 vi.mock("@/store/authStore", () => ({ useAuthStore: { getState: vi.fn(() => ({})) } }))
 
-
 describe("tags API", () => {
   beforeEach(() => {
     vi.clearAllMocks()
@@ -31,83 +30,83 @@ describe("tags API", () => {
     mockPatch.mockResolvedValue({ data: { success: true, items: [] } })
   })
 
-      describe("getTags", () => {
-      it("should resolve successfully", async () => {
-        await expect(getTags()).resolves.not.toThrow()
-      })
-
-      it("should reject on API error", async () => {
-        mockGet.mockRejectedValue(new Error("Network error"))
-        mockPost.mockRejectedValue(new Error("Network error"))
-        mockPut.mockRejectedValue(new Error("Network error"))
-        mockDelete.mockRejectedValue(new Error("Network error"))
-        mockPatch.mockRejectedValue(new Error("Network error"))
-
-        await expect(getTags()).rejects.toThrow()
-      })
+  describe("getTags", () => {
+    it("should resolve successfully", async () => {
+      await expect(getTags()).resolves.not.toThrow()
     })
 
-    describe("createTag", () => {
-      it("should resolve successfully", async () => {
-        await expect(createTag("test-name")).resolves.not.toThrow()
-      })
+    it("should reject on API error", async () => {
+      mockGet.mockRejectedValue(new Error("Network error"))
+      mockPost.mockRejectedValue(new Error("Network error"))
+      mockPut.mockRejectedValue(new Error("Network error"))
+      mockDelete.mockRejectedValue(new Error("Network error"))
+      mockPatch.mockRejectedValue(new Error("Network error"))
 
-      it("should reject on API error", async () => {
-        mockGet.mockRejectedValue(new Error("Network error"))
-        mockPost.mockRejectedValue(new Error("Network error"))
-        mockPut.mockRejectedValue(new Error("Network error"))
-        mockDelete.mockRejectedValue(new Error("Network error"))
-        mockPatch.mockRejectedValue(new Error("Network error"))
+      await expect(getTags()).rejects.toThrow()
+    })
+  })
 
-        await expect(createTag("test-name")).rejects.toThrow()
-      })
+  describe("createTag", () => {
+    it("should resolve successfully", async () => {
+      await expect(createTag("test-name")).resolves.not.toThrow()
     })
 
-    describe("deleteTag", () => {
-      it("should resolve successfully", async () => {
-        await expect(deleteTag("test-tagId")).resolves.not.toThrow()
-      })
+    it("should reject on API error", async () => {
+      mockGet.mockRejectedValue(new Error("Network error"))
+      mockPost.mockRejectedValue(new Error("Network error"))
+      mockPut.mockRejectedValue(new Error("Network error"))
+      mockDelete.mockRejectedValue(new Error("Network error"))
+      mockPatch.mockRejectedValue(new Error("Network error"))
 
-      it("should reject on API error", async () => {
-        mockGet.mockRejectedValue(new Error("Network error"))
-        mockPost.mockRejectedValue(new Error("Network error"))
-        mockPut.mockRejectedValue(new Error("Network error"))
-        mockDelete.mockRejectedValue(new Error("Network error"))
-        mockPatch.mockRejectedValue(new Error("Network error"))
+      await expect(createTag("test-name")).rejects.toThrow()
+    })
+  })
 
-        await expect(deleteTag("test-tagId")).rejects.toThrow()
-      })
+  describe("deleteTag", () => {
+    it("should resolve successfully", async () => {
+      await expect(deleteTag("test-tagId")).resolves.not.toThrow()
     })
 
-    describe("tagAsset", () => {
-      it("should resolve successfully", async () => {
-        await expect(tagAsset("test-assetId", ["tag-1", "tag-2"])).resolves.not.toThrow()
-      })
+    it("should reject on API error", async () => {
+      mockGet.mockRejectedValue(new Error("Network error"))
+      mockPost.mockRejectedValue(new Error("Network error"))
+      mockPut.mockRejectedValue(new Error("Network error"))
+      mockDelete.mockRejectedValue(new Error("Network error"))
+      mockPatch.mockRejectedValue(new Error("Network error"))
 
-      it("should reject on API error", async () => {
-        mockGet.mockRejectedValue(new Error("Network error"))
-        mockPost.mockRejectedValue(new Error("Network error"))
-        mockPut.mockRejectedValue(new Error("Network error"))
-        mockDelete.mockRejectedValue(new Error("Network error"))
-        mockPatch.mockRejectedValue(new Error("Network error"))
+      await expect(deleteTag("test-tagId")).rejects.toThrow()
+    })
+  })
 
-        await expect(tagAsset("test-assetId")).rejects.toThrow()
-      })
+  describe("tagAsset", () => {
+    it("should resolve successfully", async () => {
+      await expect(tagAsset("test-assetId", ["tag-1", "tag-2"])).resolves.not.toThrow()
     })
 
-    describe("untagAsset", () => {
-      it("should resolve successfully", async () => {
-        await expect(untagAsset("test-assetId")).resolves.not.toThrow()
-      })
+    it("should reject on API error", async () => {
+      mockGet.mockRejectedValue(new Error("Network error"))
+      mockPost.mockRejectedValue(new Error("Network error"))
+      mockPut.mockRejectedValue(new Error("Network error"))
+      mockDelete.mockRejectedValue(new Error("Network error"))
+      mockPatch.mockRejectedValue(new Error("Network error"))
 
-      it("should reject on API error", async () => {
-        mockGet.mockRejectedValue(new Error("Network error"))
-        mockPost.mockRejectedValue(new Error("Network error"))
-        mockPut.mockRejectedValue(new Error("Network error"))
-        mockDelete.mockRejectedValue(new Error("Network error"))
-        mockPatch.mockRejectedValue(new Error("Network error"))
-
-        await expect(untagAsset("test-assetId")).rejects.toThrow()
-      })
+      await expect(tagAsset("test-assetId")).rejects.toThrow()
     })
+  })
+
+  describe("untagAsset", () => {
+    it("should resolve successfully", async () => {
+      await expect(untagAsset("test-assetId")).resolves.not.toThrow()
+    })
+
+    it("should reject on API error", async () => {
+      mockGet.mockRejectedValue(new Error("Network error"))
+      mockPost.mockRejectedValue(new Error("Network error"))
+      mockPut.mockRejectedValue(new Error("Network error"))
+      mockDelete.mockRejectedValue(new Error("Network error"))
+      mockPatch.mockRejectedValue(new Error("Network error"))
+
+      await expect(untagAsset("test-assetId")).rejects.toThrow()
+    })
+  })
 })

apps/web/src/test/api/tasks.test.ts

@@ -20,7 +20,6 @@ vi.mock("@/api/client", () => ({
 vi.mock("antd", () => ({ message: { error: vi.fn(), success: vi.fn() } }))
 vi.mock("@/store/authStore", () => ({ useAuthStore: { getState: vi.fn(() => ({})) } }))
 
-
 describe("tasks API", () => {
   beforeEach(() => {
     vi.clearAllMocks()
@@ -31,83 +30,83 @@ describe("tasks API", () => {
     mockPatch.mockResolvedValue({ data: { success: true, items: [] } })
   })
 
-      describe("createGenerationTask", () => {
-      it("should resolve successfully", async () => {
-        await expect(createGenerationTask({ page: 1 })).resolves.not.toThrow()
-      })
-
-      it("should reject on API error", async () => {
-        mockGet.mockRejectedValue(new Error("Network error"))
-        mockPost.mockRejectedValue(new Error("Network error"))
-        mockPut.mockRejectedValue(new Error("Network error"))
-        mockDelete.mockRejectedValue(new Error("Network error"))
-        mockPatch.mockRejectedValue(new Error("Network error"))
-
-        await expect(createGenerationTask({ page: 1 })).rejects.toThrow()
-      })
+  describe("createGenerationTask", () => {
+    it("should resolve successfully", async () => {
+      await expect(createGenerationTask({ page: 1 })).resolves.not.toThrow()
     })
 
-    describe("getTasks", () => {
-      it("should resolve successfully", async () => {
-        await expect(getTasks("test-params?")).resolves.not.toThrow()
-      })
+    it("should reject on API error", async () => {
+      mockGet.mockRejectedValue(new Error("Network error"))
+      mockPost.mockRejectedValue(new Error("Network error"))
+      mockPut.mockRejectedValue(new Error("Network error"))
+      mockDelete.mockRejectedValue(new Error("Network error"))
+      mockPatch.mockRejectedValue(new Error("Network error"))
 
-      it("should reject on API error", async () => {
-        mockGet.mockRejectedValue(new Error("Network error"))
-        mockPost.mockRejectedValue(new Error("Network error"))
-        mockPut.mockRejectedValue(new Error("Network error"))
-        mockDelete.mockRejectedValue(new Error("Network error"))
-        mockPatch.mockRejectedValue(new Error("Network error"))
+      await expect(createGenerationTask({ page: 1 })).rejects.toThrow()
+    })
+  })
 
-        await expect(getTasks("test-params?")).rejects.toThrow()
-      })
+  describe("getTasks", () => {
+    it("should resolve successfully", async () => {
+      await expect(getTasks("test-params?")).resolves.not.toThrow()
     })
 
-    describe("getUserTasks", () => {
-      it("should resolve successfully", async () => {
-        await expect(getUserTasks()).resolves.not.toThrow()
-      })
+    it("should reject on API error", async () => {
+      mockGet.mockRejectedValue(new Error("Network error"))
+      mockPost.mockRejectedValue(new Error("Network error"))
+      mockPut.mockRejectedValue(new Error("Network error"))
+      mockDelete.mockRejectedValue(new Error("Network error"))
+      mockPatch.mockRejectedValue(new Error("Network error"))
 
-      it("should reject on API error", async () => {
-        mockGet.mockRejectedValue(new Error("Network error"))
-        mockPost.mockRejectedValue(new Error("Network error"))
-        mockPut.mockRejectedValue(new Error("Network error"))
-        mockDelete.mockRejectedValue(new Error("Network error"))
-        mockPatch.mockRejectedValue(new Error("Network error"))
+      await expect(getTasks("test-params?")).rejects.toThrow()
+    })
+  })
 
-        await expect(getUserTasks()).rejects.toThrow()
-      })
+  describe("getUserTasks", () => {
+    it("should resolve successfully", async () => {
+      await expect(getUserTasks()).resolves.not.toThrow()
     })
 
-    describe("getTask", () => {
-      it("should resolve successfully", async () => {
-        await expect(getTask("test-taskId")).resolves.not.toThrow()
-      })
+    it("should reject on API error", async () => {
+      mockGet.mockRejectedValue(new Error("Network error"))
+      mockPost.mockRejectedValue(new Error("Network error"))
+      mockPut.mockRejectedValue(new Error("Network error"))
+      mockDelete.mockRejectedValue(new Error("Network error"))
+      mockPatch.mockRejectedValue(new Error("Network error"))
 
-      it("should reject on API error", async () => {
-        mockGet.mockRejectedValue(new Error("Network error"))
-        mockPost.mockRejectedValue(new Error("Network error"))
-        mockPut.mockRejectedValue(new Error("Network error"))
-        mockDelete.mockRejectedValue(new Error("Network error"))
-        mockPatch.mockRejectedValue(new Error("Network error"))
+      await expect(getUserTasks()).rejects.toThrow()
+    })
+  })
 
-        await expect(getTask("test-taskId")).rejects.toThrow()
-      })
+  describe("getTask", () => {
+    it("should resolve successfully", async () => {
+      await expect(getTask("test-taskId")).resolves.not.toThrow()
     })
 
-    describe("retryTask", () => {
-      it("should resolve successfully", async () => {
-        await expect(retryTask("test-taskId")).resolves.not.toThrow()
-      })
+    it("should reject on API error", async () => {
+      mockGet.mockRejectedValue(new Error("Network error"))
+      mockPost.mockRejectedValue(new Error("Network error"))
+      mockPut.mockRejectedValue(new Error("Network error"))
+      mockDelete.mockRejectedValue(new Error("Network error"))
+      mockPatch.mockRejectedValue(new Error("Network error"))
 
-      it("should reject on API error", async () => {
-        mockGet.mockRejectedValue(new Error("Network error"))
-        mockPost.mockRejectedValue(new Error("Network error"))
-        mockPut.mockRejectedValue(new Error("Network error"))
-        mockDelete.mockRejectedValue(new Error("Network error"))
-        mockPatch.mockRejectedValue(new Error("Network error"))
-
-        await expect(retryTask("test-taskId")).rejects.toThrow()
-      })
+      await expect(getTask("test-taskId")).rejects.toThrow()
     })
+  })
+
+  describe("retryTask", () => {
+    it("should resolve successfully", async () => {
+      await expect(retryTask("test-taskId")).resolves.not.toThrow()
+    })
+
+    it("should reject on API error", async () => {
+      mockGet.mockRejectedValue(new Error("Network error"))
+      mockPost.mockRejectedValue(new Error("Network error"))
+      mockPut.mockRejectedValue(new Error("Network error"))
+      mockDelete.mockRejectedValue(new Error("Network error"))
+      mockPatch.mockRejectedValue(new Error("Network error"))
+
+      await expect(retryTask("test-taskId")).rejects.toThrow()
+    })
+  })
 })

apps/web/src/test/api/templates.test.ts

@@ -1,5 +1,12 @@
 import { describe, expect, it, vi, beforeEach } from "vitest"
-import { getTemplates, getTemplatesList, getTemplate, toggleFavoriteTemplate, copyTemplate, generateFromTemplate } from "@/api/templates"
+import {
+  getTemplates,
+  getTemplatesList,
+  getTemplate,
+  toggleFavoriteTemplate,
+  copyTemplate,
+  generateFromTemplate,
+} from "@/api/templates"
 
 const mockGet = vi.fn()
 const mockPost = vi.fn()
@@ -20,7 +27,6 @@ vi.mock("@/api/client", () => ({
 vi.mock("antd", () => ({ message: { error: vi.fn(), success: vi.fn() } }))
 vi.mock("@/store/authStore", () => ({ useAuthStore: { getState: vi.fn(() => ({})) } }))
 
-
 describe("templates API", () => {
   beforeEach(() => {
     vi.clearAllMocks()
@@ -31,99 +37,99 @@ describe("templates API", () => {
     mockPatch.mockResolvedValue({ data: { success: true, items: [] } })
   })
 
-      describe("getTemplates", () => {
-      it("should resolve successfully", async () => {
-        await expect(getTemplates("test-params?")).resolves.not.toThrow()
-      })
-
-      it("should reject on API error", async () => {
-        mockGet.mockRejectedValue(new Error("Network error"))
-        mockPost.mockRejectedValue(new Error("Network error"))
-        mockPut.mockRejectedValue(new Error("Network error"))
-        mockDelete.mockRejectedValue(new Error("Network error"))
-        mockPatch.mockRejectedValue(new Error("Network error"))
-
-        await expect(getTemplates("test-params?")).rejects.toThrow()
-      })
+  describe("getTemplates", () => {
+    it("should resolve successfully", async () => {
+      await expect(getTemplates("test-params?")).resolves.not.toThrow()
     })
 
-    describe("getTemplatesList", () => {
-      it("should resolve successfully", async () => {
-        await expect(getTemplatesList()).resolves.not.toThrow()
-      })
+    it("should reject on API error", async () => {
+      mockGet.mockRejectedValue(new Error("Network error"))
+      mockPost.mockRejectedValue(new Error("Network error"))
+      mockPut.mockRejectedValue(new Error("Network error"))
+      mockDelete.mockRejectedValue(new Error("Network error"))
+      mockPatch.mockRejectedValue(new Error("Network error"))
 
-      it("should reject on API error", async () => {
-        mockGet.mockRejectedValue(new Error("Network error"))
-        mockPost.mockRejectedValue(new Error("Network error"))
-        mockPut.mockRejectedValue(new Error("Network error"))
-        mockDelete.mockRejectedValue(new Error("Network error"))
-        mockPatch.mockRejectedValue(new Error("Network error"))
+      await expect(getTemplates("test-params?")).rejects.toThrow()
+    })
+  })
 
-        await expect(getTemplatesList()).rejects.toThrow()
-      })
+  describe("getTemplatesList", () => {
+    it("should resolve successfully", async () => {
+      await expect(getTemplatesList()).resolves.not.toThrow()
     })
 
-    describe("getTemplate", () => {
-      it("should resolve successfully", async () => {
-        await expect(getTemplate("test-templateId")).resolves.not.toThrow()
-      })
+    it("should reject on API error", async () => {
+      mockGet.mockRejectedValue(new Error("Network error"))
+      mockPost.mockRejectedValue(new Error("Network error"))
+      mockPut.mockRejectedValue(new Error("Network error"))
+      mockDelete.mockRejectedValue(new Error("Network error"))
+      mockPatch.mockRejectedValue(new Error("Network error"))
 
-      it("should reject on API error", async () => {
-        mockGet.mockRejectedValue(new Error("Network error"))
-        mockPost.mockRejectedValue(new Error("Network error"))
-        mockPut.mockRejectedValue(new Error("Network error"))
-        mockDelete.mockRejectedValue(new Error("Network error"))
-        mockPatch.mockRejectedValue(new Error("Network error"))
+      await expect(getTemplatesList()).rejects.toThrow()
+    })
+  })
 
-        await expect(getTemplate("test-templateId")).rejects.toThrow()
-      })
+  describe("getTemplate", () => {
+    it("should resolve successfully", async () => {
+      await expect(getTemplate("test-templateId")).resolves.not.toThrow()
     })
 
-    describe("toggleFavoriteTemplate", () => {
-      it("should resolve successfully", async () => {
-        await expect(toggleFavoriteTemplate("test-templateId")).resolves.not.toThrow()
-      })
+    it("should reject on API error", async () => {
+      mockGet.mockRejectedValue(new Error("Network error"))
+      mockPost.mockRejectedValue(new Error("Network error"))
+      mockPut.mockRejectedValue(new Error("Network error"))
+      mockDelete.mockRejectedValue(new Error("Network error"))
+      mockPatch.mockRejectedValue(new Error("Network error"))
 
-      it("should reject on API error", async () => {
-        mockGet.mockRejectedValue(new Error("Network error"))
-        mockPost.mockRejectedValue(new Error("Network error"))
-        mockPut.mockRejectedValue(new Error("Network error"))
-        mockDelete.mockRejectedValue(new Error("Network error"))
-        mockPatch.mockRejectedValue(new Error("Network error"))
+      await expect(getTemplate("test-templateId")).rejects.toThrow()
+    })
+  })
 
-        await expect(toggleFavoriteTemplate("test-templateId")).rejects.toThrow()
-      })
+  describe("toggleFavoriteTemplate", () => {
+    it("should resolve successfully", async () => {
+      await expect(toggleFavoriteTemplate("test-templateId")).resolves.not.toThrow()
     })
 
-    describe("copyTemplate", () => {
-      it("should resolve successfully", async () => {
-        await expect(copyTemplate("test-templateId")).resolves.not.toThrow()
-      })
+    it("should reject on API error", async () => {
+      mockGet.mockRejectedValue(new Error("Network error"))
+      mockPost.mockRejectedValue(new Error("Network error"))
+      mockPut.mockRejectedValue(new Error("Network error"))
+      mockDelete.mockRejectedValue(new Error("Network error"))
+      mockPatch.mockRejectedValue(new Error("Network error"))
 
-      it("should reject on API error", async () => {
-        mockGet.mockRejectedValue(new Error("Network error"))
-        mockPost.mockRejectedValue(new Error("Network error"))
-        mockPut.mockRejectedValue(new Error("Network error"))
-        mockDelete.mockRejectedValue(new Error("Network error"))
-        mockPatch.mockRejectedValue(new Error("Network error"))
+      await expect(toggleFavoriteTemplate("test-templateId")).rejects.toThrow()
+    })
+  })
 
-        await expect(copyTemplate("test-templateId")).rejects.toThrow()
-      })
+  describe("copyTemplate", () => {
+    it("should resolve successfully", async () => {
+      await expect(copyTemplate("test-templateId")).resolves.not.toThrow()
     })
 
-    describe("generateFromTemplate", () => {
-      it("should resolve successfully", async () => {
-        await expect(generateFromTemplate("test-templateId")).resolves.not.toThrow()
-      })
+    it("should reject on API error", async () => {
+      mockGet.mockRejectedValue(new Error("Network error"))
+      mockPost.mockRejectedValue(new Error("Network error"))
+      mockPut.mockRejectedValue(new Error("Network error"))
+      mockDelete.mockRejectedValue(new Error("Network error"))
+      mockPatch.mockRejectedValue(new Error("Network error"))
 
-      it("should reject on API error", async () => {
-        mockGet.mockRejectedValue(new Error("Network error"))
-        mockPost.mockRejectedValue(new Error("Network error"))
-        mockPut.mockRejectedValue(new Error("Network error"))
-        mockDelete.mockRejectedValue(new Error("Network error"))
-        mockPatch.mockRejectedValue(new Error("Network error"))
-
-        await expect(generateFromTemplate("test-templateId")).rejects.toThrow()
-      })
+      await expect(copyTemplate("test-templateId")).rejects.toThrow()
     })
+  })
+
+  describe("generateFromTemplate", () => {
+    it("should resolve successfully", async () => {
+      await expect(generateFromTemplate("test-templateId")).resolves.not.toThrow()
+    })
+
+    it("should reject on API error", async () => {
+      mockGet.mockRejectedValue(new Error("Network error"))
+      mockPost.mockRejectedValue(new Error("Network error"))
+      mockPut.mockRejectedValue(new Error("Network error"))
+      mockDelete.mockRejectedValue(new Error("Network error"))
+      mockPatch.mockRejectedValue(new Error("Network error"))
+
+      await expect(generateFromTemplate("test-templateId")).rejects.toThrow()
+    })
+  })
 })

apps/web/src/test/api/titles.test.ts

@@ -20,7 +20,6 @@ vi.mock("@/api/client", () => ({
 vi.mock("antd", () => ({ message: { error: vi.fn(), success: vi.fn() } }))
 vi.mock("@/store/authStore", () => ({ useAuthStore: { getState: vi.fn(() => ({})) } }))
 
-
 describe("titles API", () => {
   beforeEach(() => {
     vi.clearAllMocks()
@@ -31,83 +30,83 @@ describe("titles API", () => {
     mockPatch.mockResolvedValue({ data: { success: true, items: [] } })
   })
 
-      describe("getTitles", () => {
-      it("should resolve successfully", async () => {
-        await expect(getTitles()).resolves.not.toThrow()
-      })
-
-      it("should reject on API error", async () => {
-        mockGet.mockRejectedValue(new Error("Network error"))
-        mockPost.mockRejectedValue(new Error("Network error"))
-        mockPut.mockRejectedValue(new Error("Network error"))
-        mockDelete.mockRejectedValue(new Error("Network error"))
-        mockPatch.mockRejectedValue(new Error("Network error"))
-
-        await expect(getTitles()).rejects.toThrow()
-      })
+  describe("getTitles", () => {
+    it("should resolve successfully", async () => {
+      await expect(getTitles()).resolves.not.toThrow()
     })
 
-    describe("createTitle", () => {
-      it("should resolve successfully", async () => {
-        await expect(createTitle({ title: "测试标题", content: "测试内容" })).resolves.not.toThrow()
-      })
+    it("should reject on API error", async () => {
+      mockGet.mockRejectedValue(new Error("Network error"))
+      mockPost.mockRejectedValue(new Error("Network error"))
+      mockPut.mockRejectedValue(new Error("Network error"))
+      mockDelete.mockRejectedValue(new Error("Network error"))
+      mockPatch.mockRejectedValue(new Error("Network error"))
 
-      it("should reject on API error", async () => {
-        mockGet.mockRejectedValue(new Error("Network error"))
-        mockPost.mockRejectedValue(new Error("Network error"))
-        mockPut.mockRejectedValue(new Error("Network error"))
-        mockDelete.mockRejectedValue(new Error("Network error"))
-        mockPatch.mockRejectedValue(new Error("Network error"))
+      await expect(getTitles()).rejects.toThrow()
+    })
+  })
 
-        await expect(createTitle({ name: "test-item" })).rejects.toThrow()
-      })
+  describe("createTitle", () => {
+    it("should resolve successfully", async () => {
+      await expect(createTitle({ title: "测试标题", content: "测试内容" })).resolves.not.toThrow()
     })
 
-    describe("updateTitle", () => {
-      it("should resolve successfully", async () => {
-        await expect(updateTitle("test-titleId", { title: "新标题" })).resolves.not.toThrow()
-      })
+    it("should reject on API error", async () => {
+      mockGet.mockRejectedValue(new Error("Network error"))
+      mockPost.mockRejectedValue(new Error("Network error"))
+      mockPut.mockRejectedValue(new Error("Network error"))
+      mockDelete.mockRejectedValue(new Error("Network error"))
+      mockPatch.mockRejectedValue(new Error("Network error"))
 
-      it("should reject on API error", async () => {
-        mockGet.mockRejectedValue(new Error("Network error"))
-        mockPost.mockRejectedValue(new Error("Network error"))
-        mockPut.mockRejectedValue(new Error("Network error"))
-        mockDelete.mockRejectedValue(new Error("Network error"))
-        mockPatch.mockRejectedValue(new Error("Network error"))
+      await expect(createTitle({ name: "test-item" })).rejects.toThrow()
+    })
+  })
 
-        await expect(updateTitle("test-titleId")).rejects.toThrow()
-      })
+  describe("updateTitle", () => {
+    it("should resolve successfully", async () => {
+      await expect(updateTitle("test-titleId", { title: "新标题" })).resolves.not.toThrow()
     })
 
-    describe("deleteTitle", () => {
-      it("should resolve successfully", async () => {
-        await expect(deleteTitle("test-titleId")).resolves.not.toThrow()
-      })
+    it("should reject on API error", async () => {
+      mockGet.mockRejectedValue(new Error("Network error"))
+      mockPost.mockRejectedValue(new Error("Network error"))
+      mockPut.mockRejectedValue(new Error("Network error"))
+      mockDelete.mockRejectedValue(new Error("Network error"))
+      mockPatch.mockRejectedValue(new Error("Network error"))
 
-      it("should reject on API error", async () => {
-        mockGet.mockRejectedValue(new Error("Network error"))
-        mockPost.mockRejectedValue(new Error("Network error"))
-        mockPut.mockRejectedValue(new Error("Network error"))
-        mockDelete.mockRejectedValue(new Error("Network error"))
-        mockPatch.mockRejectedValue(new Error("Network error"))
+      await expect(updateTitle("test-titleId")).rejects.toThrow()
+    })
+  })
 
-        await expect(deleteTitle("test-titleId")).rejects.toThrow()
-      })
+  describe("deleteTitle", () => {
+    it("should resolve successfully", async () => {
+      await expect(deleteTitle("test-titleId")).resolves.not.toThrow()
     })
 
-    describe("batchImportTitles", () => {
-      it("should resolve successfully", async () => {
-        await expect(batchImportTitles("test-titles")).resolves.not.toThrow()
-      })
+    it("should reject on API error", async () => {
+      mockGet.mockRejectedValue(new Error("Network error"))
+      mockPost.mockRejectedValue(new Error("Network error"))
+      mockPut.mockRejectedValue(new Error("Network error"))
+      mockDelete.mockRejectedValue(new Error("Network error"))
+      mockPatch.mockRejectedValue(new Error("Network error"))
 
-      it("should reject on API error", async () => {
-        mockGet.mockRejectedValue(new Error("Network error"))
-        mockPost.mockRejectedValue(new Error("Network error"))
-        mockPut.mockRejectedValue(new Error("Network error"))
-        mockDelete.mockRejectedValue(new Error("Network error"))
-        mockPatch.mockRejectedValue(new Error("Network error"))
-
-        await expect(batchImportTitles("test-titles")).rejects.toThrow()
-      })
+      await expect(deleteTitle("test-titleId")).rejects.toThrow()
     })
+  })
+
+  describe("batchImportTitles", () => {
+    it("should resolve successfully", async () => {
+      await expect(batchImportTitles("test-titles")).resolves.not.toThrow()
+    })
+
+    it("should reject on API error", async () => {
+      mockGet.mockRejectedValue(new Error("Network error"))
+      mockPost.mockRejectedValue(new Error("Network error"))
+      mockPut.mockRejectedValue(new Error("Network error"))
+      mockDelete.mockRejectedValue(new Error("Network error"))
+      mockPatch.mockRejectedValue(new Error("Network error"))
+
+      await expect(batchImportTitles("test-titles")).rejects.toThrow()
+    })
+  })
 })

apps/web/src/test/api/tts.test.ts

@@ -1,5 +1,14 @@
 import { describe, expect, it, vi, beforeEach } from "vitest"
-import { synthesizeSpeech, getTTSJob, getTTSJobStatus, getTTSJobs, saveTtsToLibrary, deleteTTSJob, getTtsVoices, previewTts } from "@/api/tts"
+import {
+  synthesizeSpeech,
+  getTTSJob,
+  getTTSJobStatus,
+  getTTSJobs,
+  saveTtsToLibrary,
+  deleteTTSJob,
+  getTtsVoices,
+  previewTts,
+} from "@/api/tts"
 
 const mockGet = vi.fn()
 const mockPost = vi.fn()
@@ -20,7 +29,6 @@ vi.mock("@/api/client", () => ({
 vi.mock("antd", () => ({ message: { error: vi.fn(), success: vi.fn() } }))
 vi.mock("@/store/authStore", () => ({ useAuthStore: { getState: vi.fn(() => ({})) } }))
 
-
 describe("tts API", () => {
   beforeEach(() => {
     vi.clearAllMocks()
@@ -31,131 +39,131 @@ describe("tts API", () => {
     mockPatch.mockResolvedValue({ data: { success: true, items: [] } })
   })
 
-      describe("synthesizeSpeech", () => {
-      it("should resolve successfully", async () => {
-        await expect(synthesizeSpeech({ name: "test-item" })).resolves.not.toThrow()
-      })
-
-      it("should reject on API error", async () => {
-        mockGet.mockRejectedValue(new Error("Network error"))
-        mockPost.mockRejectedValue(new Error("Network error"))
-        mockPut.mockRejectedValue(new Error("Network error"))
-        mockDelete.mockRejectedValue(new Error("Network error"))
-        mockPatch.mockRejectedValue(new Error("Network error"))
-
-        await expect(synthesizeSpeech({ name: "test-item" })).rejects.toThrow()
-      })
+  describe("synthesizeSpeech", () => {
+    it("should resolve successfully", async () => {
+      await expect(synthesizeSpeech({ name: "test-item" })).resolves.not.toThrow()
     })
 
-    describe("getTTSJob", () => {
-      it("should resolve successfully", async () => {
-        await expect(getTTSJob("test-jobId")).resolves.not.toThrow()
-      })
+    it("should reject on API error", async () => {
+      mockGet.mockRejectedValue(new Error("Network error"))
+      mockPost.mockRejectedValue(new Error("Network error"))
+      mockPut.mockRejectedValue(new Error("Network error"))
+      mockDelete.mockRejectedValue(new Error("Network error"))
+      mockPatch.mockRejectedValue(new Error("Network error"))
 
-      it("should reject on API error", async () => {
-        mockGet.mockRejectedValue(new Error("Network error"))
-        mockPost.mockRejectedValue(new Error("Network error"))
-        mockPut.mockRejectedValue(new Error("Network error"))
-        mockDelete.mockRejectedValue(new Error("Network error"))
-        mockPatch.mockRejectedValue(new Error("Network error"))
+      await expect(synthesizeSpeech({ name: "test-item" })).rejects.toThrow()
+    })
+  })
 
-        await expect(getTTSJob("test-jobId")).rejects.toThrow()
-      })
+  describe("getTTSJob", () => {
+    it("should resolve successfully", async () => {
+      await expect(getTTSJob("test-jobId")).resolves.not.toThrow()
     })
 
-    describe("getTTSJobStatus", () => {
-      it("should resolve successfully", async () => {
-        await expect(getTTSJobStatus("test-jobId")).resolves.not.toThrow()
-      })
+    it("should reject on API error", async () => {
+      mockGet.mockRejectedValue(new Error("Network error"))
+      mockPost.mockRejectedValue(new Error("Network error"))
+      mockPut.mockRejectedValue(new Error("Network error"))
+      mockDelete.mockRejectedValue(new Error("Network error"))
+      mockPatch.mockRejectedValue(new Error("Network error"))
 
-      it("should reject on API error", async () => {
-        mockGet.mockRejectedValue(new Error("Network error"))
-        mockPost.mockRejectedValue(new Error("Network error"))
-        mockPut.mockRejectedValue(new Error("Network error"))
-        mockDelete.mockRejectedValue(new Error("Network error"))
-        mockPatch.mockRejectedValue(new Error("Network error"))
+      await expect(getTTSJob("test-jobId")).rejects.toThrow()
+    })
+  })
 
-        await expect(getTTSJobStatus("test-jobId")).rejects.toThrow()
-      })
+  describe("getTTSJobStatus", () => {
+    it("should resolve successfully", async () => {
+      await expect(getTTSJobStatus("test-jobId")).resolves.not.toThrow()
     })
 
-    describe("getTTSJobs", () => {
-      it("should resolve successfully", async () => {
-        await expect(getTTSJobs("test-params?")).resolves.not.toThrow()
-      })
+    it("should reject on API error", async () => {
+      mockGet.mockRejectedValue(new Error("Network error"))
+      mockPost.mockRejectedValue(new Error("Network error"))
+      mockPut.mockRejectedValue(new Error("Network error"))
+      mockDelete.mockRejectedValue(new Error("Network error"))
+      mockPatch.mockRejectedValue(new Error("Network error"))
 
-      it("should reject on API error", async () => {
-        mockGet.mockRejectedValue(new Error("Network error"))
-        mockPost.mockRejectedValue(new Error("Network error"))
-        mockPut.mockRejectedValue(new Error("Network error"))
-        mockDelete.mockRejectedValue(new Error("Network error"))
-        mockPatch.mockRejectedValue(new Error("Network error"))
+      await expect(getTTSJobStatus("test-jobId")).rejects.toThrow()
+    })
+  })
 
-        await expect(getTTSJobs("test-params?")).rejects.toThrow()
-      })
+  describe("getTTSJobs", () => {
+    it("should resolve successfully", async () => {
+      await expect(getTTSJobs("test-params?")).resolves.not.toThrow()
     })
 
-    describe("saveTtsToLibrary", () => {
-      it("should resolve successfully", async () => {
-        await expect(saveTtsToLibrary("test-jobId")).resolves.not.toThrow()
-      })
+    it("should reject on API error", async () => {
+      mockGet.mockRejectedValue(new Error("Network error"))
+      mockPost.mockRejectedValue(new Error("Network error"))
+      mockPut.mockRejectedValue(new Error("Network error"))
+      mockDelete.mockRejectedValue(new Error("Network error"))
+      mockPatch.mockRejectedValue(new Error("Network error"))
 
-      it("should reject on API error", async () => {
-        mockGet.mockRejectedValue(new Error("Network error"))
-        mockPost.mockRejectedValue(new Error("Network error"))
-        mockPut.mockRejectedValue(new Error("Network error"))
-        mockDelete.mockRejectedValue(new Error("Network error"))
-        mockPatch.mockRejectedValue(new Error("Network error"))
+      await expect(getTTSJobs("test-params?")).rejects.toThrow()
+    })
+  })
 
-        await expect(saveTtsToLibrary("test-jobId")).rejects.toThrow()
-      })
+  describe("saveTtsToLibrary", () => {
+    it("should resolve successfully", async () => {
+      await expect(saveTtsToLibrary("test-jobId")).resolves.not.toThrow()
     })
 
-    describe("deleteTTSJob", () => {
-      it("should resolve successfully", async () => {
-        await expect(deleteTTSJob("test-jobId")).resolves.not.toThrow()
-      })
+    it("should reject on API error", async () => {
+      mockGet.mockRejectedValue(new Error("Network error"))
+      mockPost.mockRejectedValue(new Error("Network error"))
+      mockPut.mockRejectedValue(new Error("Network error"))
+      mockDelete.mockRejectedValue(new Error("Network error"))
+      mockPatch.mockRejectedValue(new Error("Network error"))
 
-      it("should reject on API error", async () => {
-        mockGet.mockRejectedValue(new Error("Network error"))
-        mockPost.mockRejectedValue(new Error("Network error"))
-        mockPut.mockRejectedValue(new Error("Network error"))
-        mockDelete.mockRejectedValue(new Error("Network error"))
-        mockPatch.mockRejectedValue(new Error("Network error"))
+      await expect(saveTtsToLibrary("test-jobId")).rejects.toThrow()
+    })
+  })
 
-        await expect(deleteTTSJob("test-jobId")).rejects.toThrow()
-      })
+  describe("deleteTTSJob", () => {
+    it("should resolve successfully", async () => {
+      await expect(deleteTTSJob("test-jobId")).resolves.not.toThrow()
     })
 
-    describe("getTtsVoices", () => {
-      it("should resolve successfully", async () => {
-        await expect(getTtsVoices()).resolves.not.toThrow()
-      })
+    it("should reject on API error", async () => {
+      mockGet.mockRejectedValue(new Error("Network error"))
+      mockPost.mockRejectedValue(new Error("Network error"))
+      mockPut.mockRejectedValue(new Error("Network error"))
+      mockDelete.mockRejectedValue(new Error("Network error"))
+      mockPatch.mockRejectedValue(new Error("Network error"))
 
-      it("should reject on API error", async () => {
-        mockGet.mockRejectedValue(new Error("Network error"))
-        mockPost.mockRejectedValue(new Error("Network error"))
-        mockPut.mockRejectedValue(new Error("Network error"))
-        mockDelete.mockRejectedValue(new Error("Network error"))
-        mockPatch.mockRejectedValue(new Error("Network error"))
+      await expect(deleteTTSJob("test-jobId")).rejects.toThrow()
+    })
+  })
 
-        await expect(getTtsVoices()).rejects.toThrow()
-      })
+  describe("getTtsVoices", () => {
+    it("should resolve successfully", async () => {
+      await expect(getTtsVoices()).resolves.not.toThrow()
     })
 
-    describe("previewTts", () => {
-      it("should resolve successfully", async () => {
-        await expect(previewTts({ name: "test-item" })).resolves.not.toThrow()
-      })
+    it("should reject on API error", async () => {
+      mockGet.mockRejectedValue(new Error("Network error"))
+      mockPost.mockRejectedValue(new Error("Network error"))
+      mockPut.mockRejectedValue(new Error("Network error"))
+      mockDelete.mockRejectedValue(new Error("Network error"))
+      mockPatch.mockRejectedValue(new Error("Network error"))
 
-      it("should reject on API error", async () => {
-        mockGet.mockRejectedValue(new Error("Network error"))
-        mockPost.mockRejectedValue(new Error("Network error"))
-        mockPut.mockRejectedValue(new Error("Network error"))
-        mockDelete.mockRejectedValue(new Error("Network error"))
-        mockPatch.mockRejectedValue(new Error("Network error"))
-
-        await expect(previewTts({ name: "test-item" })).rejects.toThrow()
-      })
+      await expect(getTtsVoices()).rejects.toThrow()
     })
+  })
+
+  describe("previewTts", () => {
+    it("should resolve successfully", async () => {
+      await expect(previewTts({ name: "test-item" })).resolves.not.toThrow()
+    })
+
+    it("should reject on API error", async () => {
+      mockGet.mockRejectedValue(new Error("Network error"))
+      mockPost.mockRejectedValue(new Error("Network error"))
+      mockPut.mockRejectedValue(new Error("Network error"))
+      mockDelete.mockRejectedValue(new Error("Network error"))
+      mockPatch.mockRejectedValue(new Error("Network error"))
+
+      await expect(previewTts({ name: "test-item" })).rejects.toThrow()
+    })
+  })
 })

apps/web/src/test/api/voiceClone.test.ts

@@ -1,5 +1,14 @@
 import { describe, expect, it, vi, beforeEach } from "vitest"
-import { getVoiceClones, getVoiceClonesWithTotal, getVoiceCloneDetail, createVoiceClone, deleteVoiceClone, updateVoiceClone, getVoiceCloneStatus, retryVoiceClone } from "@/api/voiceClone"
+import {
+  getVoiceClones,
+  getVoiceClonesWithTotal,
+  getVoiceCloneDetail,
+  createVoiceClone,
+  deleteVoiceClone,
+  updateVoiceClone,
+  getVoiceCloneStatus,
+  retryVoiceClone,
+} from "@/api/voiceClone"
 
 const mockGet = vi.fn()
 const mockPost = vi.fn()
@@ -20,7 +29,6 @@ vi.mock("@/api/client", () => ({
 vi.mock("antd", () => ({ message: { error: vi.fn(), success: vi.fn() } }))
 vi.mock("@/store/authStore", () => ({ useAuthStore: { getState: vi.fn(() => ({})) } }))
 
-
 describe("voiceClone API", () => {
   beforeEach(() => {
     vi.clearAllMocks()
@@ -31,131 +39,131 @@ describe("voiceClone API", () => {
     mockPatch.mockResolvedValue({ data: { success: true, items: [] } })
   })
 
-      describe("getVoiceClones", () => {
-      it("should resolve successfully", async () => {
-        await expect(getVoiceClones("test-params?")).resolves.not.toThrow()
-      })
-
-      it("should reject on API error", async () => {
-        mockGet.mockRejectedValue(new Error("Network error"))
-        mockPost.mockRejectedValue(new Error("Network error"))
-        mockPut.mockRejectedValue(new Error("Network error"))
-        mockDelete.mockRejectedValue(new Error("Network error"))
-        mockPatch.mockRejectedValue(new Error("Network error"))
-
-        await expect(getVoiceClones("test-params?")).rejects.toThrow()
-      })
+  describe("getVoiceClones", () => {
+    it("should resolve successfully", async () => {
+      await expect(getVoiceClones("test-params?")).resolves.not.toThrow()
     })
 
-    describe("getVoiceClonesWithTotal", () => {
-      it("should resolve successfully", async () => {
-        await expect(getVoiceClonesWithTotal("test-params?")).resolves.not.toThrow()
-      })
+    it("should reject on API error", async () => {
+      mockGet.mockRejectedValue(new Error("Network error"))
+      mockPost.mockRejectedValue(new Error("Network error"))
+      mockPut.mockRejectedValue(new Error("Network error"))
+      mockDelete.mockRejectedValue(new Error("Network error"))
+      mockPatch.mockRejectedValue(new Error("Network error"))
 
-      it("should reject on API error", async () => {
-        mockGet.mockRejectedValue(new Error("Network error"))
-        mockPost.mockRejectedValue(new Error("Network error"))
-        mockPut.mockRejectedValue(new Error("Network error"))
-        mockDelete.mockRejectedValue(new Error("Network error"))
-        mockPatch.mockRejectedValue(new Error("Network error"))
+      await expect(getVoiceClones("test-params?")).rejects.toThrow()
+    })
+  })
 
-        await expect(getVoiceClonesWithTotal("test-params?")).rejects.toThrow()
-      })
+  describe("getVoiceClonesWithTotal", () => {
+    it("should resolve successfully", async () => {
+      await expect(getVoiceClonesWithTotal("test-params?")).resolves.not.toThrow()
     })
 
-    describe("getVoiceCloneDetail", () => {
-      it("should resolve successfully", async () => {
-        await expect(getVoiceCloneDetail("test-id")).resolves.not.toThrow()
-      })
+    it("should reject on API error", async () => {
+      mockGet.mockRejectedValue(new Error("Network error"))
+      mockPost.mockRejectedValue(new Error("Network error"))
+      mockPut.mockRejectedValue(new Error("Network error"))
+      mockDelete.mockRejectedValue(new Error("Network error"))
+      mockPatch.mockRejectedValue(new Error("Network error"))
 
-      it("should reject on API error", async () => {
-        mockGet.mockRejectedValue(new Error("Network error"))
-        mockPost.mockRejectedValue(new Error("Network error"))
-        mockPut.mockRejectedValue(new Error("Network error"))
-        mockDelete.mockRejectedValue(new Error("Network error"))
-        mockPatch.mockRejectedValue(new Error("Network error"))
+      await expect(getVoiceClonesWithTotal("test-params?")).rejects.toThrow()
+    })
+  })
 
-        await expect(getVoiceCloneDetail("test-id")).rejects.toThrow()
-      })
+  describe("getVoiceCloneDetail", () => {
+    it("should resolve successfully", async () => {
+      await expect(getVoiceCloneDetail("test-id")).resolves.not.toThrow()
     })
 
-    describe("createVoiceClone", () => {
-      it("should resolve successfully", async () => {
-        await expect(createVoiceClone({ name: "test-item" })).resolves.not.toThrow()
-      })
+    it("should reject on API error", async () => {
+      mockGet.mockRejectedValue(new Error("Network error"))
+      mockPost.mockRejectedValue(new Error("Network error"))
+      mockPut.mockRejectedValue(new Error("Network error"))
+      mockDelete.mockRejectedValue(new Error("Network error"))
+      mockPatch.mockRejectedValue(new Error("Network error"))
 
-      it("should reject on API error", async () => {
-        mockGet.mockRejectedValue(new Error("Network error"))
-        mockPost.mockRejectedValue(new Error("Network error"))
-        mockPut.mockRejectedValue(new Error("Network error"))
-        mockDelete.mockRejectedValue(new Error("Network error"))
-        mockPatch.mockRejectedValue(new Error("Network error"))
+      await expect(getVoiceCloneDetail("test-id")).rejects.toThrow()
+    })
+  })
 
-        await expect(createVoiceClone({ name: "test-item" })).rejects.toThrow()
-      })
+  describe("createVoiceClone", () => {
+    it("should resolve successfully", async () => {
+      await expect(createVoiceClone({ name: "test-item" })).resolves.not.toThrow()
     })
 
-    describe("deleteVoiceClone", () => {
-      it("should resolve successfully", async () => {
-        await expect(deleteVoiceClone("test-id")).resolves.not.toThrow()
-      })
+    it("should reject on API error", async () => {
+      mockGet.mockRejectedValue(new Error("Network error"))
+      mockPost.mockRejectedValue(new Error("Network error"))
+      mockPut.mockRejectedValue(new Error("Network error"))
+      mockDelete.mockRejectedValue(new Error("Network error"))
+      mockPatch.mockRejectedValue(new Error("Network error"))
 
-      it("should reject on API error", async () => {
-        mockGet.mockRejectedValue(new Error("Network error"))
-        mockPost.mockRejectedValue(new Error("Network error"))
-        mockPut.mockRejectedValue(new Error("Network error"))
-        mockDelete.mockRejectedValue(new Error("Network error"))
-        mockPatch.mockRejectedValue(new Error("Network error"))
+      await expect(createVoiceClone({ name: "test-item" })).rejects.toThrow()
+    })
+  })
 
-        await expect(deleteVoiceClone("test-id")).rejects.toThrow()
-      })
+  describe("deleteVoiceClone", () => {
+    it("should resolve successfully", async () => {
+      await expect(deleteVoiceClone("test-id")).resolves.not.toThrow()
     })
 
-    describe("updateVoiceClone", () => {
-      it("should resolve successfully", async () => {
-        await expect(updateVoiceClone("test-id")).resolves.not.toThrow()
-      })
+    it("should reject on API error", async () => {
+      mockGet.mockRejectedValue(new Error("Network error"))
+      mockPost.mockRejectedValue(new Error("Network error"))
+      mockPut.mockRejectedValue(new Error("Network error"))
+      mockDelete.mockRejectedValue(new Error("Network error"))
+      mockPatch.mockRejectedValue(new Error("Network error"))
 
-      it("should reject on API error", async () => {
-        mockGet.mockRejectedValue(new Error("Network error"))
-        mockPost.mockRejectedValue(new Error("Network error"))
-        mockPut.mockRejectedValue(new Error("Network error"))
-        mockDelete.mockRejectedValue(new Error("Network error"))
-        mockPatch.mockRejectedValue(new Error("Network error"))
+      await expect(deleteVoiceClone("test-id")).rejects.toThrow()
+    })
+  })
 
-        await expect(updateVoiceClone("test-id")).rejects.toThrow()
-      })
+  describe("updateVoiceClone", () => {
+    it("should resolve successfully", async () => {
+      await expect(updateVoiceClone("test-id")).resolves.not.toThrow()
     })
 
-    describe("getVoiceCloneStatus", () => {
-      it("should resolve successfully", async () => {
-        await expect(getVoiceCloneStatus("test-id")).resolves.not.toThrow()
-      })
+    it("should reject on API error", async () => {
+      mockGet.mockRejectedValue(new Error("Network error"))
+      mockPost.mockRejectedValue(new Error("Network error"))
+      mockPut.mockRejectedValue(new Error("Network error"))
+      mockDelete.mockRejectedValue(new Error("Network error"))
+      mockPatch.mockRejectedValue(new Error("Network error"))
 
-      it("should reject on API error", async () => {
-        mockGet.mockRejectedValue(new Error("Network error"))
-        mockPost.mockRejectedValue(new Error("Network error"))
-        mockPut.mockRejectedValue(new Error("Network error"))
-        mockDelete.mockRejectedValue(new Error("Network error"))
-        mockPatch.mockRejectedValue(new Error("Network error"))
+      await expect(updateVoiceClone("test-id")).rejects.toThrow()
+    })
+  })
 
-        await expect(getVoiceCloneStatus("test-id")).rejects.toThrow()
-      })
+  describe("getVoiceCloneStatus", () => {
+    it("should resolve successfully", async () => {
+      await expect(getVoiceCloneStatus("test-id")).resolves.not.toThrow()
     })
 
-    describe("retryVoiceClone", () => {
-      it("should resolve successfully", async () => {
-        await expect(retryVoiceClone("test-id")).resolves.not.toThrow()
-      })
+    it("should reject on API error", async () => {
+      mockGet.mockRejectedValue(new Error("Network error"))
+      mockPost.mockRejectedValue(new Error("Network error"))
+      mockPut.mockRejectedValue(new Error("Network error"))
+      mockDelete.mockRejectedValue(new Error("Network error"))
+      mockPatch.mockRejectedValue(new Error("Network error"))
 
-      it("should reject on API error", async () => {
-        mockGet.mockRejectedValue(new Error("Network error"))
-        mockPost.mockRejectedValue(new Error("Network error"))
-        mockPut.mockRejectedValue(new Error("Network error"))
-        mockDelete.mockRejectedValue(new Error("Network error"))
-        mockPatch.mockRejectedValue(new Error("Network error"))
-
-        await expect(retryVoiceClone("test-id")).rejects.toThrow()
-      })
+      await expect(getVoiceCloneStatus("test-id")).rejects.toThrow()
     })
+  })
+
+  describe("retryVoiceClone", () => {
+    it("should resolve successfully", async () => {
+      await expect(retryVoiceClone("test-id")).resolves.not.toThrow()
+    })
+
+    it("should reject on API error", async () => {
+      mockGet.mockRejectedValue(new Error("Network error"))
+      mockPost.mockRejectedValue(new Error("Network error"))
+      mockPut.mockRejectedValue(new Error("Network error"))
+      mockDelete.mockRejectedValue(new Error("Network error"))
+      mockPatch.mockRejectedValue(new Error("Network error"))
+
+      await expect(retryVoiceClone("test-id")).rejects.toThrow()
+    })
+  })
 })

apps/web/src/test/api/voices.test.ts

@@ -1,5 +1,13 @@
 import { describe, expect, it, vi, beforeEach } from "vitest"
-import { fetchVoices, fetchPresetVoices, getVoices, createVoice, updateVoice, deleteVoice, generateAIVoice } from "@/api/voices"
+import {
+  fetchVoices,
+  fetchPresetVoices,
+  getVoices,
+  createVoice,
+  updateVoice,
+  deleteVoice,
+  generateAIVoice,
+} from "@/api/voices"
 
 const mockGet = vi.fn()
 const mockPost = vi.fn()
@@ -20,7 +28,6 @@ vi.mock("@/api/client", () => ({
 vi.mock("antd", () => ({ message: { error: vi.fn(), success: vi.fn() } }))
 vi.mock("@/store/authStore", () => ({ useAuthStore: { getState: vi.fn(() => ({})) } }))
 
-
 describe("voices API", () => {
   beforeEach(() => {
     vi.clearAllMocks()
@@ -31,115 +38,115 @@ describe("voices API", () => {
     mockPatch.mockResolvedValue({ data: { success: true, items: [] } })
   })
 
-      describe("fetchVoices", () => {
-      it("should resolve successfully", async () => {
-        await expect(fetchVoices("test-params?")).resolves.not.toThrow()
-      })
-
-      it("should reject on API error", async () => {
-        mockGet.mockRejectedValue(new Error("Network error"))
-        mockPost.mockRejectedValue(new Error("Network error"))
-        mockPut.mockRejectedValue(new Error("Network error"))
-        mockDelete.mockRejectedValue(new Error("Network error"))
-        mockPatch.mockRejectedValue(new Error("Network error"))
-
-        await expect(fetchVoices("test-params?")).rejects.toThrow()
-      })
+  describe("fetchVoices", () => {
+    it("should resolve successfully", async () => {
+      await expect(fetchVoices("test-params?")).resolves.not.toThrow()
     })
 
-    describe("fetchPresetVoices", () => {
-      it("should resolve successfully", async () => {
-        await expect(fetchPresetVoices()).resolves.not.toThrow()
-      })
+    it("should reject on API error", async () => {
+      mockGet.mockRejectedValue(new Error("Network error"))
+      mockPost.mockRejectedValue(new Error("Network error"))
+      mockPut.mockRejectedValue(new Error("Network error"))
+      mockDelete.mockRejectedValue(new Error("Network error"))
+      mockPatch.mockRejectedValue(new Error("Network error"))
 
-      it("should reject on API error", async () => {
-        mockGet.mockRejectedValue(new Error("Network error"))
-        mockPost.mockRejectedValue(new Error("Network error"))
-        mockPut.mockRejectedValue(new Error("Network error"))
-        mockDelete.mockRejectedValue(new Error("Network error"))
-        mockPatch.mockRejectedValue(new Error("Network error"))
+      await expect(fetchVoices("test-params?")).rejects.toThrow()
+    })
+  })
 
-        await expect(fetchPresetVoices()).rejects.toThrow()
-      })
+  describe("fetchPresetVoices", () => {
+    it("should resolve successfully", async () => {
+      await expect(fetchPresetVoices()).resolves.not.toThrow()
     })
 
-    describe("getVoices", () => {
-      it("should resolve successfully", async () => {
-        await expect(getVoices()).resolves.not.toThrow()
-      })
+    it("should reject on API error", async () => {
+      mockGet.mockRejectedValue(new Error("Network error"))
+      mockPost.mockRejectedValue(new Error("Network error"))
+      mockPut.mockRejectedValue(new Error("Network error"))
+      mockDelete.mockRejectedValue(new Error("Network error"))
+      mockPatch.mockRejectedValue(new Error("Network error"))
 
-      it("should reject on API error", async () => {
-        mockGet.mockRejectedValue(new Error("Network error"))
-        mockPost.mockRejectedValue(new Error("Network error"))
-        mockPut.mockRejectedValue(new Error("Network error"))
-        mockDelete.mockRejectedValue(new Error("Network error"))
-        mockPatch.mockRejectedValue(new Error("Network error"))
+      await expect(fetchPresetVoices()).rejects.toThrow()
+    })
+  })
 
-        await expect(getVoices()).rejects.toThrow()
-      })
+  describe("getVoices", () => {
+    it("should resolve successfully", async () => {
+      await expect(getVoices()).resolves.not.toThrow()
     })
 
-    describe("createVoice", () => {
-      it("should resolve successfully", async () => {
-        await expect(createVoice({ name: "test-item" })).resolves.not.toThrow()
-      })
+    it("should reject on API error", async () => {
+      mockGet.mockRejectedValue(new Error("Network error"))
+      mockPost.mockRejectedValue(new Error("Network error"))
+      mockPut.mockRejectedValue(new Error("Network error"))
+      mockDelete.mockRejectedValue(new Error("Network error"))
+      mockPatch.mockRejectedValue(new Error("Network error"))
 
-      it("should reject on API error", async () => {
-        mockGet.mockRejectedValue(new Error("Network error"))
-        mockPost.mockRejectedValue(new Error("Network error"))
-        mockPut.mockRejectedValue(new Error("Network error"))
-        mockDelete.mockRejectedValue(new Error("Network error"))
-        mockPatch.mockRejectedValue(new Error("Network error"))
+      await expect(getVoices()).rejects.toThrow()
+    })
+  })
 
-        await expect(createVoice({ name: "test-item" })).rejects.toThrow()
-      })
+  describe("createVoice", () => {
+    it("should resolve successfully", async () => {
+      await expect(createVoice({ name: "test-item" })).resolves.not.toThrow()
     })
 
-    describe("updateVoice", () => {
-      it("should resolve successfully", async () => {
-        await expect(updateVoice("test-voiceId")).resolves.not.toThrow()
-      })
+    it("should reject on API error", async () => {
+      mockGet.mockRejectedValue(new Error("Network error"))
+      mockPost.mockRejectedValue(new Error("Network error"))
+      mockPut.mockRejectedValue(new Error("Network error"))
+      mockDelete.mockRejectedValue(new Error("Network error"))
+      mockPatch.mockRejectedValue(new Error("Network error"))
 
-      it("should reject on API error", async () => {
-        mockGet.mockRejectedValue(new Error("Network error"))
-        mockPost.mockRejectedValue(new Error("Network error"))
-        mockPut.mockRejectedValue(new Error("Network error"))
-        mockDelete.mockRejectedValue(new Error("Network error"))
-        mockPatch.mockRejectedValue(new Error("Network error"))
+      await expect(createVoice({ name: "test-item" })).rejects.toThrow()
+    })
+  })
 
-        await expect(updateVoice("test-voiceId")).rejects.toThrow()
-      })
+  describe("updateVoice", () => {
+    it("should resolve successfully", async () => {
+      await expect(updateVoice("test-voiceId")).resolves.not.toThrow()
     })
 
-    describe("deleteVoice", () => {
-      it("should resolve successfully", async () => {
-        await expect(deleteVoice("test-voiceId")).resolves.not.toThrow()
-      })
+    it("should reject on API error", async () => {
+      mockGet.mockRejectedValue(new Error("Network error"))
+      mockPost.mockRejectedValue(new Error("Network error"))
+      mockPut.mockRejectedValue(new Error("Network error"))
+      mockDelete.mockRejectedValue(new Error("Network error"))
+      mockPatch.mockRejectedValue(new Error("Network error"))
 
-      it("should reject on API error", async () => {
-        mockGet.mockRejectedValue(new Error("Network error"))
-        mockPost.mockRejectedValue(new Error("Network error"))
-        mockPut.mockRejectedValue(new Error("Network error"))
-        mockDelete.mockRejectedValue(new Error("Network error"))
-        mockPatch.mockRejectedValue(new Error("Network error"))
+      await expect(updateVoice("test-voiceId")).rejects.toThrow()
+    })
+  })
 
-        await expect(deleteVoice("test-voiceId")).rejects.toThrow()
-      })
+  describe("deleteVoice", () => {
+    it("should resolve successfully", async () => {
+      await expect(deleteVoice("test-voiceId")).resolves.not.toThrow()
     })
 
-    describe("generateAIVoice", () => {
-      it("should resolve successfully", async () => {
-        await expect(generateAIVoice({ name: "test-item" })).resolves.not.toThrow()
-      })
+    it("should reject on API error", async () => {
+      mockGet.mockRejectedValue(new Error("Network error"))
+      mockPost.mockRejectedValue(new Error("Network error"))
+      mockPut.mockRejectedValue(new Error("Network error"))
+      mockDelete.mockRejectedValue(new Error("Network error"))
+      mockPatch.mockRejectedValue(new Error("Network error"))
 
-      it("should reject on API error", async () => {
-        mockGet.mockRejectedValue(new Error("Network error"))
-        mockPost.mockRejectedValue(new Error("Network error"))
-        mockPut.mockRejectedValue(new Error("Network error"))
-        mockDelete.mockRejectedValue(new Error("Network error"))
-        mockPatch.mockRejectedValue(new Error("Network error"))
-
-        await expect(generateAIVoice({ name: "test-item" })).rejects.toThrow()
-      })
+      await expect(deleteVoice("test-voiceId")).rejects.toThrow()
     })
+  })
+
+  describe("generateAIVoice", () => {
+    it("should resolve successfully", async () => {
+      await expect(generateAIVoice({ name: "test-item" })).resolves.not.toThrow()
+    })
+
+    it("should reject on API error", async () => {
+      mockGet.mockRejectedValue(new Error("Network error"))
+      mockPost.mockRejectedValue(new Error("Network error"))
+      mockPut.mockRejectedValue(new Error("Network error"))
+      mockDelete.mockRejectedValue(new Error("Network error"))
+      mockPatch.mockRejectedValue(new Error("Network error"))
+
+      await expect(generateAIVoice({ name: "test-item" })).rejects.toThrow()
+    })
+  })
 })

apps/web/src/test/components/AssetSelector/AssetSelector.test.tsx

@@ -78,8 +78,6 @@ describe("AssetSelector", () => {
     expect(selects.length).toBeGreaterThan(0)
   })
 
-
-
   it("应该显示文件大小格式化", () => {
     render(<AssetSelector assets={mockAssets} />)
     // 5MB = 5 * 1024 * 1024 bytes
@@ -91,5 +89,4 @@ describe("AssetSelector", () => {
     // 125秒 = 2:05
     expect(screen.getByText(/2:05/)).toBeInTheDocument()
   })
-
 })

apps/web/src/test/components/layout/AppLayout.test.tsx

@@ -43,9 +43,7 @@ describe("AppLayout", () => {
   })
 
   it("应该包含正确的语义化结构", () => {
-    const { container } = renderWithRouter(
-      <AppLayout sidebar={<aside>侧边栏</aside>} />,
-    )
+    const { container } = renderWithRouter(<AppLayout sidebar={<aside>侧边栏</aside>} />)
     expect(container.querySelector(".xx-app-shell")).toBeInTheDocument()
     expect(container.querySelector(".xx-app-body")).toBeInTheDocument()
     expect(container.querySelector(".xx-app-content")).toBeInTheDocument()

apps/web/src/test/components/layout/Header.test.tsx

@@ -56,7 +56,9 @@ vi.mock("@ant-design/icons", () => ({
 // mock antd components
 vi.mock("antd", () => ({
   Avatar: ({ children, className }: any) => (
-    <span data-testid="mock-avatar" className={className}>{children}</span>
+    <span data-testid="mock-avatar" className={className}>
+      {children}
+    </span>
   ),
   Dropdown: ({ children, menu }: any) => (
     <div data-testid="mock-dropdown">
@@ -71,17 +73,20 @@ vi.mock("antd", () => ({
     </div>
   ),
   Space: ({ children, className }: any) => (
-    <div data-testid="mock-space" className={className}>{children}</div>
+    <div data-testid="mock-space" className={className}>
+      {children}
+    </div>
   ),
-  Drawer: ({ title, open, children, onClose, placement }: any) => (
+  Drawer: ({ title, open, children, onClose, placement }: any) =>
     open ? (
       <div data-testid="mock-drawer" data-placement={placement}>
         <div data-testid="drawer-title">{title}</div>
-        <button data-testid="drawer-close" onClick={onClose}>Close</button>
+        <button data-testid="drawer-close" onClick={onClose}>
+          Close
+        </button>
         {children}
       </div>
-    ) : null
-  ),
+    ) : null,
 }))
 
 // mock CSS
@@ -145,7 +150,8 @@ describe("Header", () => {
   describe("导航", () => {
     it("点击品牌 Logo 跳转到首页", () => {
       renderWithRouter("/app/assets")
-      const brandBtn = screen.getByRole("button", { name: /小虾自动剪辑/ }) || document.querySelector(".xx-brand")
+      const brandBtn =
+        screen.getByRole("button", { name: /小虾自动剪辑/ }) || document.querySelector(".xx-brand")
       if (brandBtn) {
         fireEvent.click(brandBtn)
         expect(mockNavigate).toHaveBeenCalledWith("/app/dashboard")

apps/web/src/test/components/layout/PageHead.test.tsx

@@ -32,10 +32,7 @@ describe("PageHead", () => {
     })
 
     it("应该渲染右侧操作区", () => {
-      renderWithRouter(
-        <PageHead title="测试" actions={<button>操作按钮</button>} />,
-        "/app/assets",
-      )
+      renderWithRouter(<PageHead title="测试" actions={<button>操作按钮</button>} />, "/app/assets")
       expect(screen.getByText("操作按钮")).toBeInTheDocument()
     })
 
@@ -59,10 +56,7 @@ describe("PageHead", () => {
       renderWithRouter(
         <PageHead
           title="自定义页"
-          breadcrumb={[
-            { label: "首页", path: "/app/dashboard" },
-            { label: "自定义页" },
-          ]}
+          breadcrumb={[{ label: "首页", path: "/app/dashboard" }, { label: "自定义页" }]}
         />,
         "/app/custom",
       )

apps/web/src/test/components/layout/Sidebar.test.tsx

@@ -33,9 +33,7 @@ vi.mock("@/config/navigation", () => ({
     },
     {
       title: "资源管理",
-      items: [
-        { key: "assets", label: "素材库", path: "/app/assets", icon: <span>A</span> },
-      ],
+      items: [{ key: "assets", label: "素材库", path: "/app/assets", icon: <span>A</span> }],
     },
   ],
 }))

apps/web/src/test/components/ui/Button.test.tsx

@@ -1,6 +1,6 @@
 import { describe, expect, it } from "vitest"
 import { render } from "@testing-library/react"
-import Button from '@/components/ui/Button'
+import Button from "@/components/ui/Button"
 
 describe("Button", () => {
   it("should render without crashing", () => {

apps/web/src/test/components/ui/Card.test.tsx

@@ -1,6 +1,6 @@
 import { describe, expect, it } from "vitest"
 import { render } from "@testing-library/react"
-import Card from '@/components/ui/Card'
+import Card from "@/components/ui/Card"
 
 describe("Card", () => {
   it("should render without crashing", () => {

apps/web/src/test/components/ui/Modal.test.tsx

@@ -1,6 +1,6 @@
 import { describe, expect, it } from "vitest"
 import { render } from "@testing-library/react"
-import Modal from '@/components/ui/Modal'
+import Modal from "@/components/ui/Modal"
 
 describe("Modal", () => {
   it("should render without crashing", () => {

apps/web/src/test/components/ui/Select.test.tsx

@@ -1,6 +1,6 @@
 import { describe, expect, it } from "vitest"
 import { render } from "@testing-library/react"
-import Select from '@/components/ui/Select'
+import Select from "@/components/ui/Select"
 
 describe("Select", () => {
   it("should render without crashing", () => {

apps/web/src/test/components/ui/Tag.test.tsx

@@ -1,6 +1,6 @@
 import { describe, expect, it } from "vitest"
 import { render } from "@testing-library/react"
-import { Tag } from '@/components/ui/Tag'
+import { Tag } from "@/components/ui/Tag"
 
 describe("Tag", () => {
   it("should render without crashing", () => {

apps/web/src/test/components/ui/Tooltip.test.tsx

@@ -1,6 +1,6 @@
 import { describe, expect, it } from "vitest"
 import { render } from "@testing-library/react"
-import { Tooltip } from '@/components/ui/Tooltip'
+import { Tooltip } from "@/components/ui/Tooltip"
 
 describe("Tooltip", () => {
   it("should render without crashing", () => {

apps/web/src/test/hooks/useCloneProgress.test.tsx

@@ -77,9 +77,7 @@ describe("useCloneProgress", () => {
   })
 
   it("should update clone via updateClone", async () => {
-    mockGetVoiceClones.mockResolvedValue([
-      { id: "1", name: "旧名字", status: "processing" },
-    ])
+    mockGetVoiceClones.mockResolvedValue([{ id: "1", name: "旧名字", status: "processing" }])
 
     const { result } = renderHook(() => useCloneProgress())
 

apps/web/src/test/pages/Accounts.test.tsx

@@ -4,7 +4,9 @@ import { MemoryRouter } from "react-router-dom"
 
 vi.mock("@/components/layout/PageHead", () => ({
   default: ({ title }: { title: string; description?: string }) => (
-    <div data-testid="page-head"><h1>{title}</h1></div>
+    <div data-testid="page-head">
+      <h1>{title}</h1>
+    </div>
   ),
 }))
 
@@ -15,7 +17,7 @@ describe("Accounts Page", () => {
     const { container } = render(
       <MemoryRouter>
         <Accounts />
-      </MemoryRouter>
+      </MemoryRouter>,
     )
     expect(container).toBeTruthy()
   })

apps/web/src/test/pages/AdminComingSoon.test.tsx

@@ -16,7 +16,7 @@ describe("AdminComingSoon Page", () => {
     render(
       <MemoryRouter>
         <AdminComingSoon />
-      </MemoryRouter>
+      </MemoryRouter>,
     )
     expect(screen.getByText("Admin 后台暂未开放")).toBeTruthy()
   })
@@ -25,7 +25,7 @@ describe("AdminComingSoon Page", () => {
     render(
       <MemoryRouter>
         <AdminComingSoon />
-      </MemoryRouter>
+      </MemoryRouter>,
     )
     expect(screen.getByText("返回首页")).toBeTruthy()
   })

apps/web/src/test/pages/Billing.test.tsx

@@ -4,7 +4,9 @@ import { MemoryRouter } from "react-router-dom"
 
 vi.mock("@/components/layout/PageHead", () => ({
   default: ({ title }: { title: string; description?: string }) => (
-    <div data-testid="page-head"><h1>{title}</h1></div>
+    <div data-testid="page-head">
+      <h1>{title}</h1>
+    </div>
   ),
 }))
 
@@ -15,7 +17,7 @@ describe("Billing Page", () => {
     const { container } = render(
       <MemoryRouter>
         <Billing />
-      </MemoryRouter>
+      </MemoryRouter>,
     )
     expect(container).toBeTruthy()
   })

apps/web/src/test/pages/Dashboard.test.tsx

@@ -16,7 +16,7 @@ describe("Dashboard Page", () => {
     const { container } = render(
       <MemoryRouter>
         <Dashboard />
-      </MemoryRouter>
+      </MemoryRouter>,
     )
     expect(container).toBeTruthy()
   })
@@ -25,7 +25,7 @@ describe("Dashboard Page", () => {
     const { container } = render(
       <MemoryRouter>
         <Dashboard />
-      </MemoryRouter>
+      </MemoryRouter>,
     )
     expect(container.querySelector(".xx-dashboard-page")).toBeTruthy()
   })

apps/web/src/test/pages/DuplicationDetail.test.tsx

@@ -27,7 +27,9 @@ vi.mock("@tanstack/react-query", () => ({
 
 vi.mock("@/components/ui", () => ({
   Button: ({ children, onClick, disabled }: any) => (
-    <button onClick={onClick} disabled={disabled}>{children}</button>
+    <button onClick={onClick} disabled={disabled}>
+      {children}
+    </button>
   ),
   Card: ({ children }: any) => <div>{children}</div>,
   Tag: ({ children }: any) => <span>{children}</span>,
@@ -43,12 +45,16 @@ vi.mock("@/components/ui", () => ({
 vi.mock("antd", () => ({
   Table: ({ columns, dataSource }: any) => (
     <div data-testid="mock-table">
-      {columns?.map((c: any) => <span key={c.key}>{c.title}</span>)}
+      {columns?.map((c: any) => (
+        <span key={c.key}>{c.title}</span>
+      ))}
     </div>
   ),
   Tabs: ({ items }: any) => (
     <div data-testid="mock-tabs">
-      {items?.map((t: any) => <span key={t.key}>{t.label}</span>)}
+      {items?.map((t: any) => (
+        <span key={t.key}>{t.label}</span>
+      ))}
     </div>
   ),
   Pagination: ({ total }: any) => <div data-testid="mock-pagination">{total}</div>,

apps/web/src/test/pages/DuplicationUpload.test.tsx

@@ -24,7 +24,9 @@ vi.mock("@tanstack/react-query", () => ({
 
 vi.mock("@/components/ui", () => ({
   Button: ({ children, onClick, disabled }: any) => (
-    <button onClick={onClick} disabled={disabled}>{children}</button>
+    <button onClick={onClick} disabled={disabled}>
+      {children}
+    </button>
   ),
   Card: ({ children }: any) => <div>{children}</div>,
   Tag: ({ children }: any) => <span>{children}</span>,

apps/web/src/test/pages/HomePage.test.tsx

@@ -28,7 +28,7 @@ describe("HomePage", () => {
     const { container } = render(
       <MemoryRouter>
         <HomePage />
-      </MemoryRouter>
+      </MemoryRouter>,
     )
     expect(container).toBeTruthy()
   })
@@ -37,7 +37,7 @@ describe("HomePage", () => {
     const { container } = render(
       <MemoryRouter>
         <HomePage />
-      </MemoryRouter>
+      </MemoryRouter>,
     )
     expect(container.querySelector(".hp-hero")).toBeTruthy()
   })
@@ -46,7 +46,7 @@ describe("HomePage", () => {
     const { container } = render(
       <MemoryRouter>
         <HomePage />
-      </MemoryRouter>
+      </MemoryRouter>,
     )
     expect(container.querySelector(".hp-features")).toBeTruthy()
   })
@@ -55,7 +55,7 @@ describe("HomePage", () => {
     const { container } = render(
       <MemoryRouter>
         <HomePage />
-      </MemoryRouter>
+      </MemoryRouter>,
     )
     expect(container.querySelector(".hp-pricing")).toBeTruthy()
   })

apps/web/src/test/pages/MyVoices.test.tsx

@@ -27,7 +27,9 @@ vi.mock("@tanstack/react-query", () => ({
 
 vi.mock("@/components/ui", () => ({
   Button: ({ children, onClick, disabled }: any) => (
-    <button onClick={onClick} disabled={disabled}>{children}</button>
+    <button onClick={onClick} disabled={disabled}>
+      {children}
+    </button>
   ),
   Card: ({ children }: any) => <div>{children}</div>,
   Tag: ({ children }: any) => <span>{children}</span>,
@@ -43,12 +45,16 @@ vi.mock("@/components/ui", () => ({
 vi.mock("antd", () => ({
   Table: ({ columns, dataSource }: any) => (
     <div data-testid="mock-table">
-      {columns?.map((c: any) => <span key={c.key}>{c.title}</span>)}
+      {columns?.map((c: any) => (
+        <span key={c.key}>{c.title}</span>
+      ))}
     </div>
   ),
   Tabs: ({ items }: any) => (
     <div data-testid="mock-tabs">
-      {items?.map((t: any) => <span key={t.key}>{t.label}</span>)}
+      {items?.map((t: any) => (
+        <span key={t.key}>{t.label}</span>
+      ))}
     </div>
   ),
   Pagination: ({ total }: any) => <div data-testid="mock-pagination">{total}</div>,

apps/web/src/test/pages/Plans.test.tsx

@@ -4,7 +4,9 @@ import { MemoryRouter } from "react-router-dom"
 
 vi.mock("@/components/layout/PageHead", () => ({
   default: ({ title }: { title: string; description?: string }) => (
-    <div data-testid="page-head"><h1>{title}</h1></div>
+    <div data-testid="page-head">
+      <h1>{title}</h1>
+    </div>
   ),
 }))
 
@@ -15,7 +17,7 @@ describe("Plans Page", () => {
     const { container } = render(
       <MemoryRouter>
         <Plans />
-      </MemoryRouter>
+      </MemoryRouter>,
     )
     expect(container).toBeTruthy()
   })

apps/web/src/test/pages/ProductLibrary.test.tsx

@@ -11,14 +11,23 @@ vi.mock("@tanstack/react-query", () => ({
   useQuery: () => ({ data: [], isLoading: false, isError: false, refetch: vi.fn() }),
   useMutation: () => ({ mutate: vi.fn(), mutateAsync: vi.fn(), isLoading: false }),
   useQueryClient: () => ({ invalidateQueries: vi.fn(), setQueryData: vi.fn() }),
-  useInfiniteQuery: () => ({ data: { pages: [] }, isLoading: false, fetchNextPage: vi.fn(), hasNextPage: false }),
+  useInfiniteQuery: () => ({
+    data: { pages: [] },
+    isLoading: false,
+    fetchNextPage: vi.fn(),
+    hasNextPage: false,
+  }),
 }))
 
 vi.mock("@/components/ui", () => ({
   Button: ({ children, onClick }: any) => <button onClick={onClick}>{children}</button>,
   Input: ({ placeholder }: any) => <input placeholder={placeholder} />,
   Select: ({ options }: any) => (
-    <select>{options?.map((o: any) => <option key={o.value}>{o.label}</option>)}</select>
+    <select>
+      {options?.map((o: any) => (
+        <option key={o.value}>{o.label}</option>
+      ))}
+    </select>
   ),
   Modal: ({ open, children }: any) => (open ? <div role="dialog">{children}</div> : null),
   Empty: () => <div>Empty</div>,
@@ -50,7 +59,12 @@ vi.mock("antd", () => ({
   Switch: () => <input type="checkbox" />,
   Radio: ({ children }: any) => <span>{children}</span>,
   RadioGroup: ({ children }: any) => <div>{children}</div>,
-  Checkbox: ({ children }: any) => <label><input type="checkbox" />{children}</label>,
+  Checkbox: ({ children }: any) => (
+    <label>
+      <input type="checkbox" />
+      {children}
+    </label>
+  ),
   DatePicker: () => <input type="date" />,
   Col: ({ children }: any) => <div>{children}</div>,
   Row: ({ children }: any) => <div>{children}</div>,
@@ -77,13 +91,31 @@ vi.mock("antd", () => ({
 }))
 
 vi.mock("@ant-design/icons", () => ({
-  CheckOutlined: () => <span />,  CloseOutlined: () => <span />,  CloudUploadOutlined: () => <span />,  DeleteOutlined: () => <span />,  DownloadOutlined: () => <span />,  EyeOutlined: () => <span />,  PauseCircleOutlined: () => <span />,  PlayCircleOutlined: () => <span />,  SearchOutlined: () => <span />,  ShareAltOutlined: () => <span />,  VideoCameraOutlined: () => <span />,
+  CheckOutlined: () => <span />,
+  CloseOutlined: () => <span />,
+  CloudUploadOutlined: () => <span />,
+  DeleteOutlined: () => <span />,
+  DownloadOutlined: () => <span />,
+  EyeOutlined: () => <span />,
+  PauseCircleOutlined: () => <span />,
+  PlayCircleOutlined: () => <span />,
+  SearchOutlined: () => <span />,
+  ShareAltOutlined: () => <span />,
+  VideoCameraOutlined: () => <span />,
 }))
 
-vi.mock("@/store/authStore", () => ({ useAuthStore: (sel: any) => sel({ user: { id: "1" }, isAuthenticated: true }) }))
+vi.mock("@/store/authStore", () => ({
+  useAuthStore: (sel: any) => sel({ user: { id: "1" }, isAuthenticated: true }),
+}))
 
 vi.mock("@/api/products", () => ({
-  getProducts: vi.fn().mockResolvedValue({ items: [], total: 0, success: true }),  getProduct: vi.fn().mockResolvedValue({ items: [], total: 0, success: true }),  deleteProduct: vi.fn().mockResolvedValue({ items: [], total: 0, success: true }),  getProductDownloadUrl: vi.fn().mockResolvedValue({ items: [], total: 0, success: true }),  updateReviewStatus: vi.fn().mockResolvedValue({ items: [], total: 0, success: true }),  batchDownload: vi.fn().mockResolvedValue({ items: [], total: 0, success: true }),  getBatchDownloadStatus: vi.fn().mockResolvedValue({ items: [], total: 0, success: true }),
+  getProducts: vi.fn().mockResolvedValue({ items: [], total: 0, success: true }),
+  getProduct: vi.fn().mockResolvedValue({ items: [], total: 0, success: true }),
+  deleteProduct: vi.fn().mockResolvedValue({ items: [], total: 0, success: true }),
+  getProductDownloadUrl: vi.fn().mockResolvedValue({ items: [], total: 0, success: true }),
+  updateReviewStatus: vi.fn().mockResolvedValue({ items: [], total: 0, success: true }),
+  batchDownload: vi.fn().mockResolvedValue({ items: [], total: 0, success: true }),
+  getBatchDownloadStatus: vi.fn().mockResolvedValue({ items: [], total: 0, success: true }),
 }))
 
 vi.mock("@/pages/products/ProductLibrary.css", () => ({}))

apps/web/src/test/pages/Settings.test.tsx

@@ -35,7 +35,7 @@ describe("Settings Page", () => {
     render(
       <MemoryRouter>
         <Settings />
-      </MemoryRouter>
+      </MemoryRouter>,
     )
     expect(screen.getByText("个人设置")).toBeTruthy()
   })
@@ -44,7 +44,7 @@ describe("Settings Page", () => {
     render(
       <MemoryRouter>
         <Settings />
-      </MemoryRouter>
+      </MemoryRouter>,
     )
     expect(screen.getByDisplayValue("testuser")).toBeTruthy()
     expect(screen.getByDisplayValue("test@example.com")).toBeTruthy()
@@ -54,7 +54,7 @@ describe("Settings Page", () => {
     render(
       <MemoryRouter>
         <Settings />
-      </MemoryRouter>
+      </MemoryRouter>,
     )
     const button = screen.getByText("保存暂未开放")
     expect(button).toBeTruthy()

apps/web/src/test/pages/TaskCenter.test.tsx

@@ -11,14 +11,23 @@ vi.mock("@tanstack/react-query", () => ({
   useQuery: () => ({ data: [], isLoading: false, isError: false, refetch: vi.fn() }),
   useMutation: () => ({ mutate: vi.fn(), mutateAsync: vi.fn(), isLoading: false }),
   useQueryClient: () => ({ invalidateQueries: vi.fn(), setQueryData: vi.fn() }),
-  useInfiniteQuery: () => ({ data: { pages: [] }, isLoading: false, fetchNextPage: vi.fn(), hasNextPage: false }),
+  useInfiniteQuery: () => ({
+    data: { pages: [] },
+    isLoading: false,
+    fetchNextPage: vi.fn(),
+    hasNextPage: false,
+  }),
 }))
 
 vi.mock("@/components/ui", () => ({
   Button: ({ children, onClick }: any) => <button onClick={onClick}>{children}</button>,
   Input: ({ placeholder }: any) => <input placeholder={placeholder} />,
   Select: ({ options }: any) => (
-    <select>{options?.map((o: any) => <option key={o.value}>{o.label}</option>)}</select>
+    <select>
+      {options?.map((o: any) => (
+        <option key={o.value}>{o.label}</option>
+      ))}
+    </select>
   ),
   Modal: ({ open, children }: any) => (open ? <div role="dialog">{children}</div> : null),
   Empty: () => <div>Empty</div>,
@@ -50,7 +59,12 @@ vi.mock("antd", () => ({
   Switch: () => <input type="checkbox" />,
   Radio: ({ children }: any) => <span>{children}</span>,
   RadioGroup: ({ children }: any) => <div>{children}</div>,
-  Checkbox: ({ children }: any) => <label><input type="checkbox" />{children}</label>,
+  Checkbox: ({ children }: any) => (
+    <label>
+      <input type="checkbox" />
+      {children}
+    </label>
+  ),
   DatePicker: () => <input type="date" />,
   Col: ({ children }: any) => <div>{children}</div>,
   Row: ({ children }: any) => <div>{children}</div>,
@@ -77,13 +91,27 @@ vi.mock("antd", () => ({
 }))
 
 vi.mock("@ant-design/icons", () => ({
-  CheckCircleOutlined: () => <span />,  ClockCircleOutlined: () => <span />,  CloseCircleOutlined: () => <span />,  ExclamationCircleOutlined: () => <span />,  InfoCircleOutlined: () => <span />,  MinusCircleOutlined: () => <span />,  RedoOutlined: () => <span />,  SyncOutlined: () => <span />,
+  CheckCircleOutlined: () => <span />,
+  ClockCircleOutlined: () => <span />,
+  CloseCircleOutlined: () => <span />,
+  ExclamationCircleOutlined: () => <span />,
+  InfoCircleOutlined: () => <span />,
+  MinusCircleOutlined: () => <span />,
+  RedoOutlined: () => <span />,
+  SyncOutlined: () => <span />,
 }))
 
-vi.mock("@/store/authStore", () => ({ useAuthStore: (sel: any) => sel({ user: { id: "1" }, isAuthenticated: true }) }))
+vi.mock("@/store/authStore", () => ({
+  useAuthStore: (sel: any) => sel({ user: { id: "1" }, isAuthenticated: true }),
+}))
 
 vi.mock("@/api/tasks", () => ({
-  getTasks: vi.fn().mockResolvedValue({ items: [], total: 0, success: true }),  getUserTasks: vi.fn().mockResolvedValue({ items: [], total: 0, success: true }),  getTask: vi.fn().mockResolvedValue({ items: [], total: 0, success: true }),  retryTask: vi.fn().mockResolvedValue({ items: [], total: 0, success: true }),  cancelTask: vi.fn().mockResolvedValue({ items: [], total: 0, success: true }),  deleteTask: vi.fn().mockResolvedValue({ items: [], total: 0, success: true }),
+  getTasks: vi.fn().mockResolvedValue({ items: [], total: 0, success: true }),
+  getUserTasks: vi.fn().mockResolvedValue({ items: [], total: 0, success: true }),
+  getTask: vi.fn().mockResolvedValue({ items: [], total: 0, success: true }),
+  retryTask: vi.fn().mockResolvedValue({ items: [], total: 0, success: true }),
+  cancelTask: vi.fn().mockResolvedValue({ items: [], total: 0, success: true }),
+  deleteTask: vi.fn().mockResolvedValue({ items: [], total: 0, success: true }),
 }))
 
 vi.mock("@/pages/tasks/TaskCenter.css", () => ({}))

apps/web/src/test/pages/TemplateLibrary.test.tsx

@@ -11,14 +11,23 @@ vi.mock("@tanstack/react-query", () => ({
   useQuery: () => ({ data: [], isLoading: false, isError: false, refetch: vi.fn() }),
   useMutation: () => ({ mutate: vi.fn(), mutateAsync: vi.fn(), isLoading: false }),
   useQueryClient: () => ({ invalidateQueries: vi.fn(), setQueryData: vi.fn() }),
-  useInfiniteQuery: () => ({ data: { pages: [] }, isLoading: false, fetchNextPage: vi.fn(), hasNextPage: false }),
+  useInfiniteQuery: () => ({
+    data: { pages: [] },
+    isLoading: false,
+    fetchNextPage: vi.fn(),
+    hasNextPage: false,
+  }),
 }))
 
 vi.mock("@/components/ui", () => ({
   Button: ({ children, onClick }: any) => <button onClick={onClick}>{children}</button>,
   Input: ({ placeholder }: any) => <input placeholder={placeholder} />,
   Select: ({ options }: any) => (
-    <select>{options?.map((o: any) => <option key={o.value}>{o.label}</option>)}</select>
+    <select>
+      {options?.map((o: any) => (
+        <option key={o.value}>{o.label}</option>
+      ))}
+    </select>
   ),
   Modal: ({ open, children }: any) => (open ? <div role="dialog">{children}</div> : null),
   Empty: () => <div>Empty</div>,
@@ -50,7 +59,12 @@ vi.mock("antd", () => ({
   Switch: () => <input type="checkbox" />,
   Radio: ({ children }: any) => <span>{children}</span>,
   RadioGroup: ({ children }: any) => <div>{children}</div>,
-  Checkbox: ({ children }: any) => <label><input type="checkbox" />{children}</label>,
+  Checkbox: ({ children }: any) => (
+    <label>
+      <input type="checkbox" />
+      {children}
+    </label>
+  ),
   DatePicker: () => <input type="date" />,
   Col: ({ children }: any) => <div>{children}</div>,
   Row: ({ children }: any) => <div>{children}</div>,
@@ -77,13 +91,25 @@ vi.mock("antd", () => ({
 }))
 
 vi.mock("@ant-design/icons", () => ({
-  CopyOutlined: () => <span />,  ExclamationCircleOutlined: () => <span />,  InboxOutlined: () => <span />,  LoadingOutlined: () => <span />,  SearchOutlined: () => <span />,  ThunderboltOutlined: () => <span />,
+  CopyOutlined: () => <span />,
+  ExclamationCircleOutlined: () => <span />,
+  InboxOutlined: () => <span />,
+  LoadingOutlined: () => <span />,
+  SearchOutlined: () => <span />,
+  ThunderboltOutlined: () => <span />,
 }))
 
-vi.mock("@/store/authStore", () => ({ useAuthStore: (sel: any) => sel({ user: { id: "1", vip_level: 0 }, isAuthenticated: true }) }))
+vi.mock("@/store/authStore", () => ({
+  useAuthStore: (sel: any) => sel({ user: { id: "1", vip_level: 0 }, isAuthenticated: true }),
+}))
 
 vi.mock("@/api/templates", () => ({
-  getTemplates: vi.fn().mockResolvedValue({ items: [], total: 0, success: true }),  getTemplatesList: vi.fn().mockResolvedValue({ items: [], total: 0, success: true }),  getTemplate: vi.fn().mockResolvedValue({ items: [], total: 0, success: true }),  toggleFavoriteTemplate: vi.fn().mockResolvedValue({ items: [], total: 0, success: true }),  copyTemplate: vi.fn().mockResolvedValue({ items: [], total: 0, success: true }),  generateFromTemplate: vi.fn().mockResolvedValue({ items: [], total: 0, success: true }),
+  getTemplates: vi.fn().mockResolvedValue({ items: [], total: 0, success: true }),
+  getTemplatesList: vi.fn().mockResolvedValue({ items: [], total: 0, success: true }),
+  getTemplate: vi.fn().mockResolvedValue({ items: [], total: 0, success: true }),
+  toggleFavoriteTemplate: vi.fn().mockResolvedValue({ items: [], total: 0, success: true }),
+  copyTemplate: vi.fn().mockResolvedValue({ items: [], total: 0, success: true }),
+  generateFromTemplate: vi.fn().mockResolvedValue({ items: [], total: 0, success: true }),
 }))
 
 vi.mock("@/pages/templates/TemplateLibrary.css", () => ({}))

apps/web/src/test/pages/TitleLibrary.test.tsx

@@ -17,7 +17,11 @@ vi.mock("@/components/ui", () => ({
   Button: ({ children, onClick }: any) => <button onClick={onClick}>{children}</button>,
   Input: ({ placeholder }: any) => <input placeholder={placeholder} />,
   Select: ({ options }: any) => (
-    <select>{options?.map((o: any) => <option key={o.value}>{o.label}</option>)}</select>
+    <select>
+      {options?.map((o: any) => (
+        <option key={o.value}>{o.label}</option>
+      ))}
+    </select>
   ),
   Modal: ({ open, children }: any) => (open ? <div role="dialog">{children}</div> : null),
   Empty: () => <div>Empty</div>,

apps/web/src/test/pages/VoiceClone.test.tsx

@@ -27,7 +27,9 @@ vi.mock("@tanstack/react-query", () => ({
 
 vi.mock("@/components/ui", () => ({
   Button: ({ children, onClick, disabled }: any) => (
-    <button onClick={onClick} disabled={disabled}>{children}</button>
+    <button onClick={onClick} disabled={disabled}>
+      {children}
+    </button>
   ),
   Card: ({ children }: any) => <div>{children}</div>,
   Tag: ({ children }: any) => <span>{children}</span>,
@@ -43,12 +45,16 @@ vi.mock("@/components/ui", () => ({
 vi.mock("antd", () => ({
   Table: ({ columns, dataSource }: any) => (
     <div data-testid="mock-table">
-      {columns?.map((c: any) => <span key={c.key}>{c.title}</span>)}
+      {columns?.map((c: any) => (
+        <span key={c.key}>{c.title}</span>
+      ))}
     </div>
   ),
   Tabs: ({ items }: any) => (
     <div data-testid="mock-tabs">
-      {items?.map((t: any) => <span key={t.key}>{t.label}</span>)}
+      {items?.map((t: any) => (
+        <span key={t.key}>{t.label}</span>
+      ))}
     </div>
   ),
   Pagination: ({ total }: any) => <div data-testid="mock-pagination">{total}</div>,

apps/web/src/test/pages/VoiceLibrary.test.tsx

@@ -11,14 +11,23 @@ vi.mock("@tanstack/react-query", () => ({
   useQuery: () => ({ data: [], isLoading: false, isError: false, refetch: vi.fn() }),
   useMutation: () => ({ mutate: vi.fn(), mutateAsync: vi.fn(), isLoading: false }),
   useQueryClient: () => ({ invalidateQueries: vi.fn(), setQueryData: vi.fn() }),
-  useInfiniteQuery: () => ({ data: { pages: [] }, isLoading: false, fetchNextPage: vi.fn(), hasNextPage: false }),
+  useInfiniteQuery: () => ({
+    data: { pages: [] },
+    isLoading: false,
+    fetchNextPage: vi.fn(),
+    hasNextPage: false,
+  }),
 }))
 
 vi.mock("@/components/ui", () => ({
   Button: ({ children, onClick }: any) => <button onClick={onClick}>{children}</button>,
   Input: ({ placeholder }: any) => <input placeholder={placeholder} />,
   Select: ({ options }: any) => (
-    <select>{options?.map((o: any) => <option key={o.value}>{o.label}</option>)}</select>
+    <select>
+      {options?.map((o: any) => (
+        <option key={o.value}>{o.label}</option>
+      ))}
+    </select>
   ),
   Modal: ({ open, children }: any) => (open ? <div role="dialog">{children}</div> : null),
   Empty: () => <div>Empty</div>,
@@ -50,7 +59,12 @@ vi.mock("antd", () => ({
   Switch: () => <input type="checkbox" />,
   Radio: ({ children }: any) => <span>{children}</span>,
   RadioGroup: ({ children }: any) => <div>{children}</div>,
-  Checkbox: ({ children }: any) => <label><input type="checkbox" />{children}</label>,
+  Checkbox: ({ children }: any) => (
+    <label>
+      <input type="checkbox" />
+      {children}
+    </label>
+  ),
   DatePicker: () => <input type="date" />,
   Col: ({ children }: any) => <div>{children}</div>,
   Row: ({ children }: any) => <div>{children}</div>,
@@ -77,14 +91,38 @@ vi.mock("antd", () => ({
 }))
 
 vi.mock("@ant-design/icons", () => ({
-  AudioOutlined: () => <span />,  CloseCircleOutlined: () => <span />,  DeleteOutlined: () => <span />,  HeartOutlined: () => <span />,  PauseCircleOutlined: () => <span />,  PlayCircleOutlined: () => <span />,  PlusOutlined: () => <span />,  ReloadOutlined: () => <span />,  RobotOutlined: () => <span />,  SearchOutlined: () => <span />,  SoundOutlined: () => <span />,  UploadOutlined: () => <span />,  UserOutlined: () => <span />,
+  AudioOutlined: () => <span />,
+  CloseCircleOutlined: () => <span />,
+  DeleteOutlined: () => <span />,
+  HeartOutlined: () => <span />,
+  PauseCircleOutlined: () => <span />,
+  PlayCircleOutlined: () => <span />,
+  PlusOutlined: () => <span />,
+  ReloadOutlined: () => <span />,
+  RobotOutlined: () => <span />,
+  SearchOutlined: () => <span />,
+  SoundOutlined: () => <span />,
+  UploadOutlined: () => <span />,
+  UserOutlined: () => <span />,
 }))
 
-vi.mock("@/store/authStore", () => ({ useAuthStore: (sel: any) => sel({ user: { id: "1" }, isAuthenticated: true }) }))
-vi.mock("@/api/voiceClone", () => ({ createVoiceClone: vi.fn().mockResolvedValue({ success: true }), deleteVoiceClone: vi.fn().mockResolvedValue({ success: true }), retryVoiceClone: vi.fn().mockResolvedValue({ success: true }) }))
+vi.mock("@/store/authStore", () => ({
+  useAuthStore: (sel: any) => sel({ user: { id: "1" }, isAuthenticated: true }),
+}))
+vi.mock("@/api/voiceClone", () => ({
+  createVoiceClone: vi.fn().mockResolvedValue({ success: true }),
+  deleteVoiceClone: vi.fn().mockResolvedValue({ success: true }),
+  retryVoiceClone: vi.fn().mockResolvedValue({ success: true }),
+}))
 
 vi.mock("@/api/voices", () => ({
-  fetchVoices: vi.fn().mockResolvedValue({ items: [], total: 0, success: true }),  fetchPresetVoices: vi.fn().mockResolvedValue({ items: [], total: 0, success: true }),  getVoices: vi.fn().mockResolvedValue({ items: [], total: 0, success: true }),  createVoice: vi.fn().mockResolvedValue({ items: [], total: 0, success: true }),  updateVoice: vi.fn().mockResolvedValue({ items: [], total: 0, success: true }),  deleteVoice: vi.fn().mockResolvedValue({ items: [], total: 0, success: true }),  generateAIVoice: vi.fn().mockResolvedValue({ items: [], total: 0, success: true }),
+  fetchVoices: vi.fn().mockResolvedValue({ items: [], total: 0, success: true }),
+  fetchPresetVoices: vi.fn().mockResolvedValue({ items: [], total: 0, success: true }),
+  getVoices: vi.fn().mockResolvedValue({ items: [], total: 0, success: true }),
+  createVoice: vi.fn().mockResolvedValue({ items: [], total: 0, success: true }),
+  updateVoice: vi.fn().mockResolvedValue({ items: [], total: 0, success: true }),
+  deleteVoice: vi.fn().mockResolvedValue({ items: [], total: 0, success: true }),
+  generateAIVoice: vi.fn().mockResolvedValue({ items: [], total: 0, success: true }),
 }))
 
 vi.mock("@/pages/voices/VoiceLibrary.css", () => ({}))

apps/web/src/test/pages/auth/ForgotPassword.test.tsx

@@ -36,7 +36,7 @@ describe("ForgotPassword Page", () => {
     const { container } = render(
       <MemoryRouter>
         <ForgotPassword />
-      </MemoryRouter>
+      </MemoryRouter>,
     )
     expect(container).toBeTruthy()
   })
@@ -45,7 +45,7 @@ describe("ForgotPassword Page", () => {
     const { container } = render(
       <MemoryRouter>
         <ForgotPassword />
-      </MemoryRouter>
+      </MemoryRouter>,
     )
     expect(container.querySelector(".ant-form")).toBeTruthy()
   })
@@ -54,7 +54,7 @@ describe("ForgotPassword Page", () => {
     const { container } = render(
       <MemoryRouter>
         <ForgotPassword />
-      </MemoryRouter>
+      </MemoryRouter>,
     )
     expect(container.querySelector("input")).toBeTruthy()
   })

apps/web/src/test/pages/auth/Login.test.tsx

@@ -28,7 +28,7 @@ describe("Login Page", () => {
     const { container } = render(
       <MemoryRouter>
         <Login />
-      </MemoryRouter>
+      </MemoryRouter>,
     )
     expect(container).toBeTruthy()
   })
@@ -37,7 +37,7 @@ describe("Login Page", () => {
     const { container } = render(
       <MemoryRouter>
         <Login />
-      </MemoryRouter>
+      </MemoryRouter>,
     )
     expect(container.querySelector(".ant-form")).toBeTruthy()
   })
@@ -46,7 +46,7 @@ describe("Login Page", () => {
     const { container } = render(
       <MemoryRouter>
         <Login />
-      </MemoryRouter>
+      </MemoryRouter>,
     )
     const inputs = container.querySelectorAll("input")
     expect(inputs.length).toBeGreaterThanOrEqual(2)
@@ -56,7 +56,7 @@ describe("Login Page", () => {
     const { container } = render(
       <MemoryRouter>
         <Login />
-      </MemoryRouter>
+      </MemoryRouter>,
     )
     expect(container.querySelector(".ant-checkbox")).toBeTruthy()
   })

apps/web/src/test/pages/auth/Register.test.tsx

@@ -28,7 +28,7 @@ describe("Register Page", () => {
     const { container } = render(
       <MemoryRouter>
         <Register />
-      </MemoryRouter>
+      </MemoryRouter>,
     )
     expect(container).toBeTruthy()
   })
@@ -37,7 +37,7 @@ describe("Register Page", () => {
     const { container } = render(
       <MemoryRouter>
         <Register />
-      </MemoryRouter>
+      </MemoryRouter>,
     )
     expect(container.querySelector(".ant-form")).toBeTruthy()
   })
@@ -46,7 +46,7 @@ describe("Register Page", () => {
     const { container } = render(
       <MemoryRouter>
         <Register />
-      </MemoryRouter>
+      </MemoryRouter>,
     )
     const inputs = container.querySelectorAll("input")
     expect(inputs.length).toBeGreaterThanOrEqual(3)

apps/web/src/test/pages/auth/ResetPassword.test.tsx

@@ -37,7 +37,7 @@ describe("ResetPassword Page", () => {
     const { container } = render(
       <MemoryRouter>
         <ResetPassword />
-      </MemoryRouter>
+      </MemoryRouter>,
     )
     expect(container).toBeTruthy()
   })
@@ -46,7 +46,7 @@ describe("ResetPassword Page", () => {
     const { container } = render(
       <MemoryRouter>
         <ResetPassword />
-      </MemoryRouter>
+      </MemoryRouter>,
     )
     expect(container.querySelector(".ant-form")).toBeTruthy()
   })
@@ -55,7 +55,7 @@ describe("ResetPassword Page", () => {
     const { container } = render(
       <MemoryRouter>
         <ResetPassword />
-      </MemoryRouter>
+      </MemoryRouter>,
     )
     const inputs = container.querySelectorAll("input")
     expect(inputs.length).toBeGreaterThanOrEqual(1)

apps/web/src/test/pages/editing-planner/components/GenerationHistoryModal.test.tsx

@@ -31,7 +31,9 @@ describe("GenerationHistoryModal", () => {
         duration: 60,
       },
     ]
-    const { container } = render(<GenerationHistoryModal {...defaultProps} history={history as any} />)
+    const { container } = render(
+      <GenerationHistoryModal {...defaultProps} history={history as any} />,
+    )
     expect(container).toBeTruthy()
   })
 })

apps/web/src/test/pages/editing-planner/components/GreenScreenPanel.test.tsx

@@ -5,7 +5,13 @@ import GreenScreenPanel from "@/pages/editing-planner/components/GreenScreenPane
 const defaultProps = {
   open: true,
   onClose: vi.fn(),
-  config: { enabled: false, color_preset: "green", color: "#00ff00", threshold: 40, smoothness: 10 } as any,
+  config: {
+    enabled: false,
+    color_preset: "green",
+    color: "#00ff00",
+    threshold: 40,
+    smoothness: 10,
+  } as any,
   onChange: vi.fn(),
 }
 

apps/web/src/test/pages/editing-planner/components/PreviewPlayer.test.tsx

@@ -24,9 +24,7 @@ describe("PreviewPlayer", () => {
   })
 
   it("should render with clips", () => {
-    const clips = [
-      { id: "1", type: "voice", text: "test", duration: 10 },
-    ]
+    const clips = [{ id: "1", type: "voice", text: "test", duration: 10 }]
     const { container } = render(<PreviewPlayer {...defaultProps} clips={clips as any} />)
     expect(container).toBeTruthy()
   })