test: webapp/src/server配下のusecasesとutilsにテストを追加

以下のモジュールにテストを追加:
- get-sankey-aggregation-usecase.ts
- get-transactions-by-slug-usecase.ts
- get-monthly-transaction-aggregation-usecase.ts
- get-balance-sheet-usecase.ts
- get-all-transactions-by-slug-usecase.ts
- get-transactions-for-csv-usecase.ts
- sankey-id-utils.ts

テスト方針:
- モジュールの主要な責務を確認するテストを中心に作成
- ハッピーケースとエッジケースを重点的にカバー
- infra層（リポジトリ実装）のテストは除外
- 100%カバレッジは目指さない

Co-Authored-By: jujunjun110@gmail.com <jujunjun110@gmail.com>

Author: devin-ai-integration[bot]

webapp/tests/server/usecases/get-all-transactions-by-slug-usecase.test.ts

@@ -0,0 +1,166 @@
+import { GetAllTransactionsBySlugUsecase } from "@/server/usecases/get-all-transactions-by-slug-usecase";
+import type { ITransactionRepository } from "@/server/repositories/interfaces/transaction-repository.interface";
+import type { IPoliticalOrganizationRepository } from "@/server/repositories/interfaces/political-organization-repository.interface";
+import type { Transaction } from "@/shared/models/transaction";
+
+const createMockTransaction = (overrides: Partial<Transaction> = {}): Transaction => ({
+  id: "test-id-1",
+  political_organization_id: "org-1",
+  transaction_no: "T001",
+  transaction_date: new Date("2025-08-15"),
+  financial_year: 2025,
+  transaction_type: "expense",
+  debit_account: "政治活動費",
+  debit_amount: 100000,
+  credit_account: "現金",
+  credit_amount: 100000,
+  friendly_category: "支出",
+  category_key: "political-activity",
+  label: "テスト取引",
+  hash: "test-hash",
+  created_at: new Date(),
+  updated_at: new Date(),
+  ...overrides,
+});
+
+const mockTransactionRepository = {
+  findAll: jest.fn(),
+  getLastUpdatedAt: jest.fn(),
+} as unknown as ITransactionRepository;
+
+const mockPoliticalOrganizationRepository = {
+  findBySlugs: jest.fn(),
+} as unknown as IPoliticalOrganizationRepository;
+
+describe("GetAllTransactionsBySlugUsecase", () => {
+  let usecase: GetAllTransactionsBySlugUsecase;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    usecase = new GetAllTransactionsBySlugUsecase(
+      mockTransactionRepository,
+      mockPoliticalOrganizationRepository,
+    );
+  });
+
+  it("should return all transactions for valid organization", async () => {
+    const mockOrganizations = [{ id: "1", slug: "test-org", displayName: "テスト組織" }];
+    const mockTransactions = [
+      createMockTransaction({ id: "1" }),
+      createMockTransaction({ id: "2" }),
+      createMockTransaction({ id: "3" }),
+    ];
+
+    (mockPoliticalOrganizationRepository.findBySlugs as jest.Mock).mockResolvedValue(
+      mockOrganizations,
+    );
+    (mockTransactionRepository.findAll as jest.Mock).mockResolvedValue(mockTransactions);
+    (mockTransactionRepository.getLastUpdatedAt as jest.Mock).mockResolvedValue(
+      new Date("2025-01-01"),
+    );
+
+    const result = await usecase.execute({
+      slugs: ["test-org"],
+      financialYear: 2025,
+    });
+
+    expect(result.transactions).toHaveLength(3);
+    expect(result.total).toBe(3);
+    expect(result.politicalOrganizations).toEqual(mockOrganizations);
+    expect(result.lastUpdatedAt).toBe("2025-01-01T00:00:00.000Z");
+  });
+
+  it("should throw error when organization not found", async () => {
+    (mockPoliticalOrganizationRepository.findBySlugs as jest.Mock).mockResolvedValue([]);
+
+    await expect(
+      usecase.execute({
+        slugs: ["non-existent-org"],
+        financialYear: 2025,
+      }),
+    ).rejects.toThrow('Political organizations with slugs "non-existent-org" not found');
+  });
+
+  it("should pass filter parameters correctly", async () => {
+    const mockOrganizations = [{ id: "1", slug: "test-org" }];
+
+    (mockPoliticalOrganizationRepository.findBySlugs as jest.Mock).mockResolvedValue(
+      mockOrganizations,
+    );
+    (mockTransactionRepository.findAll as jest.Mock).mockResolvedValue([]);
+    (mockTransactionRepository.getLastUpdatedAt as jest.Mock).mockResolvedValue(null);
+
+    const dateFrom = new Date("2025-01-01");
+    const dateTo = new Date("2025-12-31");
+
+    await usecase.execute({
+      slugs: ["test-org"],
+      financialYear: 2025,
+      transactionType: "income",
+      dateFrom,
+      dateTo,
+      categories: ["donation-personal"],
+      sortBy: "date",
+      order: "desc",
+    });
+
+    expect(mockTransactionRepository.findAll).toHaveBeenCalledWith(
+      expect.objectContaining({
+        political_organization_ids: ["1"],
+        transaction_type: "income",
+        date_from: dateFrom,
+        date_to: dateTo,
+        category_keys: ["donation-personal"],
+        financial_year: 2025,
+      }),
+      expect.objectContaining({
+        sortBy: "date",
+        order: "desc",
+      }),
+    );
+  });
+
+  it("should handle multiple organizations", async () => {
+    const mockOrganizations = [
+      { id: "1", slug: "org-1" },
+      { id: "2", slug: "org-2" },
+    ];
+
+    (mockPoliticalOrganizationRepository.findBySlugs as jest.Mock).mockResolvedValue(
+      mockOrganizations,
+    );
+    (mockTransactionRepository.findAll as jest.Mock).mockResolvedValue([]);
+    (mockTransactionRepository.getLastUpdatedAt as jest.Mock).mockResolvedValue(null);
+
+    await usecase.execute({
+      slugs: ["org-1", "org-2"],
+      financialYear: 2025,
+    });
+
+    expect(mockTransactionRepository.findAll).toHaveBeenCalledWith(
+      expect.objectContaining({
+        political_organization_ids: ["1", "2"],
+      }),
+      expect.any(Object),
+    );
+  });
+
+  it("should handle empty transactions", async () => {
+    const mockOrganizations = [{ id: "1", slug: "test-org" }];
+
+    (mockPoliticalOrganizationRepository.findBySlugs as jest.Mock).mockResolvedValue(
+      mockOrganizations,
+    );
+    (mockTransactionRepository.findAll as jest.Mock).mockResolvedValue([]);
+    (mockTransactionRepository.getLastUpdatedAt as jest.Mock).mockResolvedValue(null);
+
+    const result = await usecase.execute({
+      slugs: ["test-org"],
+      financialYear: 2025,
+    });
+
+    expect(result.transactions).toEqual([]);
+    expect(result.total).toBe(0);
+    expect(result.lastUpdatedAt).toBeNull();
+  });
+});

webapp/tests/server/usecases/get-balance-sheet-usecase.test.ts

@@ -0,0 +1,149 @@
+import { GetBalanceSheetUsecase } from "@/server/usecases/get-balance-sheet-usecase";
+import type { ITransactionRepository } from "@/server/repositories/interfaces/transaction-repository.interface";
+import type { IBalanceSnapshotRepository } from "@/server/repositories/interfaces/balance-snapshot-repository.interface";
+import type { IPoliticalOrganizationRepository } from "@/server/repositories/interfaces/political-organization-repository.interface";
+
+const mockTransactionRepository = {
+  getBorrowingIncomeTotal: jest.fn(),
+  getBorrowingExpenseTotal: jest.fn(),
+  getLiabilityBalance: jest.fn(),
+} as unknown as ITransactionRepository;
+
+const mockBalanceSnapshotRepository = {
+  getTotalLatestBalanceByOrgIds: jest.fn(),
+} as unknown as IBalanceSnapshotRepository;
+
+const mockPoliticalOrganizationRepository = {
+  findBySlugs: jest.fn(),
+} as unknown as IPoliticalOrganizationRepository;
+
+describe("GetBalanceSheetUsecase", () => {
+  let usecase: GetBalanceSheetUsecase;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    usecase = new GetBalanceSheetUsecase(
+      mockTransactionRepository,
+      mockBalanceSnapshotRepository,
+      mockPoliticalOrganizationRepository,
+    );
+  });
+
+  it("should return balance sheet data with positive net assets", async () => {
+    const mockOrganizations = [{ id: "1", slug: "test-org" }];
+
+    (mockPoliticalOrganizationRepository.findBySlugs as jest.Mock).mockResolvedValue(
+      mockOrganizations,
+    );
+    (mockBalanceSnapshotRepository.getTotalLatestBalanceByOrgIds as jest.Mock).mockResolvedValue(
+      1000000,
+    );
+    (mockTransactionRepository.getBorrowingIncomeTotal as jest.Mock).mockResolvedValue(500000);
+    (mockTransactionRepository.getBorrowingExpenseTotal as jest.Mock).mockResolvedValue(200000);
+    (mockTransactionRepository.getLiabilityBalance as jest.Mock).mockResolvedValue(100000);
+
+    const result = await usecase.execute({
+      slugs: ["test-org"],
+      financialYear: 2025,
+    });
+
+    expect(result.balanceSheetData.left.currentAssets).toBe(1000000);
+    expect(result.balanceSheetData.left.fixedAssets).toBe(0);
+    expect(result.balanceSheetData.right.currentLiabilities).toBe(100000);
+    expect(result.balanceSheetData.right.fixedLiabilities).toBe(300000);
+    expect(result.balanceSheetData.right.netAssets).toBe(600000);
+    expect(result.balanceSheetData.left.debtExcess).toBe(0);
+  });
+
+  it("should return balance sheet data with debt excess", async () => {
+    const mockOrganizations = [{ id: "1", slug: "test-org" }];
+
+    (mockPoliticalOrganizationRepository.findBySlugs as jest.Mock).mockResolvedValue(
+      mockOrganizations,
+    );
+    (mockBalanceSnapshotRepository.getTotalLatestBalanceByOrgIds as jest.Mock).mockResolvedValue(
+      100000,
+    );
+    (mockTransactionRepository.getBorrowingIncomeTotal as jest.Mock).mockResolvedValue(1000000);
+    (mockTransactionRepository.getBorrowingExpenseTotal as jest.Mock).mockResolvedValue(0);
+    (mockTransactionRepository.getLiabilityBalance as jest.Mock).mockResolvedValue(200000);
+
+    const result = await usecase.execute({
+      slugs: ["test-org"],
+      financialYear: 2025,
+    });
+
+    expect(result.balanceSheetData.left.currentAssets).toBe(100000);
+    expect(result.balanceSheetData.left.fixedAssets).toBe(0);
+    expect(result.balanceSheetData.right.currentLiabilities).toBe(200000);
+    expect(result.balanceSheetData.right.fixedLiabilities).toBe(1000000);
+    expect(result.balanceSheetData.right.netAssets).toBe(0);
+    expect(result.balanceSheetData.left.debtExcess).toBe(1100000);
+  });
+
+  it("should handle zero balance case", async () => {
+    const mockOrganizations = [{ id: "1", slug: "test-org" }];
+
+    (mockPoliticalOrganizationRepository.findBySlugs as jest.Mock).mockResolvedValue(
+      mockOrganizations,
+    );
+    (mockBalanceSnapshotRepository.getTotalLatestBalanceByOrgIds as jest.Mock).mockResolvedValue(
+      500000,
+    );
+    (mockTransactionRepository.getBorrowingIncomeTotal as jest.Mock).mockResolvedValue(500000);
+    (mockTransactionRepository.getBorrowingExpenseTotal as jest.Mock).mockResolvedValue(0);
+    (mockTransactionRepository.getLiabilityBalance as jest.Mock).mockResolvedValue(0);
+
+    const result = await usecase.execute({
+      slugs: ["test-org"],
+      financialYear: 2025,
+    });
+
+    expect(result.balanceSheetData.right.netAssets).toBe(0);
+    expect(result.balanceSheetData.left.debtExcess).toBe(0);
+  });
+
+  it("should handle multiple organizations", async () => {
+    const mockOrganizations = [
+      { id: "1", slug: "org-1" },
+      { id: "2", slug: "org-2" },
+    ];
+
+    (mockPoliticalOrganizationRepository.findBySlugs as jest.Mock).mockResolvedValue(
+      mockOrganizations,
+    );
+    (mockBalanceSnapshotRepository.getTotalLatestBalanceByOrgIds as jest.Mock).mockResolvedValue(
+      2000000,
+    );
+    (mockTransactionRepository.getBorrowingIncomeTotal as jest.Mock).mockResolvedValue(0);
+    (mockTransactionRepository.getBorrowingExpenseTotal as jest.Mock).mockResolvedValue(0);
+    (mockTransactionRepository.getLiabilityBalance as jest.Mock).mockResolvedValue(0);
+
+    const result = await usecase.execute({
+      slugs: ["org-1", "org-2"],
+      financialYear: 2025,
+    });
+
+    expect(result.balanceSheetData.left.currentAssets).toBe(2000000);
+    expect(mockBalanceSnapshotRepository.getTotalLatestBalanceByOrgIds).toHaveBeenCalledWith([
+      "1",
+      "2",
+    ]);
+  });
+
+  it("should handle empty organization list gracefully", async () => {
+    (mockPoliticalOrganizationRepository.findBySlugs as jest.Mock).mockResolvedValue([]);
+    (mockBalanceSnapshotRepository.getTotalLatestBalanceByOrgIds as jest.Mock).mockResolvedValue(0);
+    (mockTransactionRepository.getBorrowingIncomeTotal as jest.Mock).mockResolvedValue(0);
+    (mockTransactionRepository.getBorrowingExpenseTotal as jest.Mock).mockResolvedValue(0);
+    (mockTransactionRepository.getLiabilityBalance as jest.Mock).mockResolvedValue(0);
+
+    const result = await usecase.execute({
+      slugs: ["non-existent-org"],
+      financialYear: 2025,
+    });
+
+    expect(result.balanceSheetData.left.currentAssets).toBe(0);
+    expect(result.balanceSheetData.right.netAssets).toBe(0);
+  });
+});

webapp/tests/server/usecases/get-monthly-transaction-aggregation-usecase.test.ts

@@ -0,0 +1,133 @@
+import { GetMonthlyTransactionAggregationUsecase } from "@/server/usecases/get-monthly-transaction-aggregation-usecase";
+import type {
+  ITransactionRepository,
+  MonthlyAggregation,
+} from "@/server/repositories/interfaces/transaction-repository.interface";
+import type { IPoliticalOrganizationRepository } from "@/server/repositories/interfaces/political-organization-repository.interface";
+
+const mockTransactionRepository = {
+  getMonthlyAggregation: jest.fn(),
+} as unknown as ITransactionRepository;
+
+const mockPoliticalOrganizationRepository = {
+  findBySlugs: jest.fn(),
+} as unknown as IPoliticalOrganizationRepository;
+
+describe("GetMonthlyTransactionAggregationUsecase", () => {
+  let usecase: GetMonthlyTransactionAggregationUsecase;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    usecase = new GetMonthlyTransactionAggregationUsecase(
+      mockTransactionRepository,
+      mockPoliticalOrganizationRepository,
+    );
+  });
+
+  it("should return monthly aggregation data for valid organization", async () => {
+    const mockOrganizations = [{ id: "1", slug: "test-org" }];
+    const mockMonthlyData: MonthlyAggregation[] = [
+      { yearMonth: "2025-01", income: 1000000, expense: 500000 },
+      { yearMonth: "2025-02", income: 800000, expense: 600000 },
+      { yearMonth: "2025-03", income: 1200000, expense: 400000 },
+    ];
+
+    (mockPoliticalOrganizationRepository.findBySlugs as jest.Mock).mockResolvedValue(
+      mockOrganizations,
+    );
+    (mockTransactionRepository.getMonthlyAggregation as jest.Mock).mockResolvedValue(
+      mockMonthlyData,
+    );
+
+    const result = await usecase.execute({
+      slugs: ["test-org"],
+      financialYear: 2025,
+    });
+
+    expect(result.monthlyData).toHaveLength(3);
+    expect(result.monthlyData[0]).toEqual({
+      yearMonth: "2025-01",
+      income: 1000000,
+      expense: 500000,
+    });
+    expect(mockPoliticalOrganizationRepository.findBySlugs).toHaveBeenCalledWith(["test-org"]);
+    expect(mockTransactionRepository.getMonthlyAggregation).toHaveBeenCalledWith(["1"], 2025);
+  });
+
+  it("should throw error when organization not found", async () => {
+    (mockPoliticalOrganizationRepository.findBySlugs as jest.Mock).mockResolvedValue([]);
+
+    await expect(
+      usecase.execute({
+        slugs: ["non-existent-org"],
+        financialYear: 2025,
+      }),
+    ).rejects.toThrow('Political organizations with slugs "non-existent-org" not found');
+  });
+
+  it("should handle multiple organizations", async () => {
+    const mockOrganizations = [
+      { id: "1", slug: "org-1" },
+      { id: "2", slug: "org-2" },
+    ];
+    const mockMonthlyData: MonthlyAggregation[] = [
+      { yearMonth: "2025-01", income: 2000000, expense: 1000000 },
+    ];
+
+    (mockPoliticalOrganizationRepository.findBySlugs as jest.Mock).mockResolvedValue(
+      mockOrganizations,
+    );
+    (mockTransactionRepository.getMonthlyAggregation as jest.Mock).mockResolvedValue(
+      mockMonthlyData,
+    );
+
+    const result = await usecase.execute({
+      slugs: ["org-1", "org-2"],
+      financialYear: 2025,
+    });
+
+    expect(result.monthlyData).toHaveLength(1);
+    expect(mockTransactionRepository.getMonthlyAggregation).toHaveBeenCalledWith(
+      ["1", "2"],
+      2025,
+    );
+  });
+
+  it("should handle empty monthly data", async () => {
+    const mockOrganizations = [{ id: "1", slug: "test-org" }];
+
+    (mockPoliticalOrganizationRepository.findBySlugs as jest.Mock).mockResolvedValue(
+      mockOrganizations,
+    );
+    (mockTransactionRepository.getMonthlyAggregation as jest.Mock).mockResolvedValue([]);
+
+    const result = await usecase.execute({
+      slugs: ["test-org"],
+      financialYear: 2025,
+    });
+
+    expect(result.monthlyData).toEqual([]);
+  });
+
+  it("should handle different financial years", async () => {
+    const mockOrganizations = [{ id: "1", slug: "test-org" }];
+    const mockMonthlyData: MonthlyAggregation[] = [
+      { yearMonth: "2024-04", income: 500000, expense: 300000 },
+    ];
+
+    (mockPoliticalOrganizationRepository.findBySlugs as jest.Mock).mockResolvedValue(
+      mockOrganizations,
+    );
+    (mockTransactionRepository.getMonthlyAggregation as jest.Mock).mockResolvedValue(
+      mockMonthlyData,
+    );
+
+    const result = await usecase.execute({
+      slugs: ["test-org"],
+      financialYear: 2024,
+    });
+
+    expect(result.monthlyData).toHaveLength(1);
+    expect(mockTransactionRepository.getMonthlyAggregation).toHaveBeenCalledWith(["1"], 2024);
+  });
+});

webapp/tests/server/usecases/get-sankey-aggregation-usecase.test.ts

@@ -0,0 +1,204 @@
+import { GetSankeyAggregationUsecase } from "@/server/usecases/get-sankey-aggregation-usecase";
+import type {
+  ITransactionRepository,
+  SankeyCategoryAggregationResult,
+} from "@/server/repositories/interfaces/transaction-repository.interface";
+import type { IPoliticalOrganizationRepository } from "@/server/repositories/interfaces/political-organization-repository.interface";
+import type {
+  IBalanceSnapshotRepository,
+  TotalBalancesByYear,
+} from "@/server/repositories/interfaces/balance-snapshot-repository.interface";
+
+const mockTransactionRepository = {
+  getCategoryAggregationForSankey: jest.fn(),
+  getLiabilityBalance: jest.fn(),
+} as unknown as ITransactionRepository;
+
+const mockPoliticalOrganizationRepository = {
+  findBySlugs: jest.fn(),
+} as unknown as IPoliticalOrganizationRepository;
+
+const mockBalanceSnapshotRepository = {
+  getTotalLatestBalancesByYear: jest.fn(),
+} as unknown as IBalanceSnapshotRepository;
+
+describe("GetSankeyAggregationUsecase", () => {
+  let usecase: GetSankeyAggregationUsecase;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    usecase = new GetSankeyAggregationUsecase(
+      mockTransactionRepository,
+      mockPoliticalOrganizationRepository,
+      mockBalanceSnapshotRepository,
+    );
+  });
+
+  it("should return sankey data for valid organization", async () => {
+    const mockOrganizations = [{ id: "1", slug: "test-org" }];
+    const mockAggregation: SankeyCategoryAggregationResult = {
+      income: [
+        {
+          category: "寄附",
+          subcategory: "個人からの寄附",
+          totalAmount: 1000000,
+        },
+      ],
+      expense: [
+        {
+          category: "政治活動費",
+          subcategory: "宣伝費",
+          totalAmount: 500000,
+        },
+      ],
+    };
+    const mockBalances: TotalBalancesByYear = {
+      currentYear: 300000,
+      previousYear: 200000,
+    };
+
+    (mockPoliticalOrganizationRepository.findBySlugs as jest.Mock).mockResolvedValue(
+      mockOrganizations,
+    );
+    (mockTransactionRepository.getCategoryAggregationForSankey as jest.Mock).mockResolvedValue(
+      mockAggregation,
+    );
+    (mockBalanceSnapshotRepository.getTotalLatestBalancesByYear as jest.Mock).mockResolvedValue(
+      mockBalances,
+    );
+    (mockTransactionRepository.getLiabilityBalance as jest.Mock).mockResolvedValue(0);
+
+    const result = await usecase.execute({
+      slugs: ["test-org"],
+      financialYear: 2025,
+      categoryType: "political-category",
+    });
+
+    expect(result.sankeyData).toBeDefined();
+    expect(result.sankeyData.nodes).toBeDefined();
+    expect(result.sankeyData.links).toBeDefined();
+    expect(mockPoliticalOrganizationRepository.findBySlugs).toHaveBeenCalledWith(["test-org"]);
+    expect(mockTransactionRepository.getCategoryAggregationForSankey).toHaveBeenCalledWith(
+      ["1"],
+      2025,
+      "political-category",
+    );
+  });
+
+  it("should handle friendly-category type", async () => {
+    const mockOrganizations = [{ id: "1", slug: "test-org" }];
+    const mockAggregation: SankeyCategoryAggregationResult = {
+      income: [{ category: "寄附", totalAmount: 1000000 }],
+      expense: [{ category: "政治活動費", totalAmount: 500000 }],
+    };
+    const mockBalances: TotalBalancesByYear = {
+      currentYear: 0,
+      previousYear: 0,
+    };
+
+    (mockPoliticalOrganizationRepository.findBySlugs as jest.Mock).mockResolvedValue(
+      mockOrganizations,
+    );
+    (mockTransactionRepository.getCategoryAggregationForSankey as jest.Mock).mockResolvedValue(
+      mockAggregation,
+    );
+    (mockBalanceSnapshotRepository.getTotalLatestBalancesByYear as jest.Mock).mockResolvedValue(
+      mockBalances,
+    );
+    (mockTransactionRepository.getLiabilityBalance as jest.Mock).mockResolvedValue(0);
+
+    const result = await usecase.execute({
+      slugs: ["test-org"],
+      financialYear: 2025,
+      categoryType: "friendly-category",
+    });
+
+    expect(result.sankeyData).toBeDefined();
+    expect(mockTransactionRepository.getCategoryAggregationForSankey).toHaveBeenCalledWith(
+      ["1"],
+      2025,
+      "friendly-category",
+    );
+  });
+
+  it("should throw error when organization not found", async () => {
+    (mockPoliticalOrganizationRepository.findBySlugs as jest.Mock).mockResolvedValue([]);
+
+    await expect(
+      usecase.execute({
+        slugs: ["non-existent-org"],
+        financialYear: 2025,
+      }),
+    ).rejects.toThrow('Political organizations with slugs "non-existent-org" not found');
+  });
+
+  it("should handle multiple organizations", async () => {
+    const mockOrganizations = [
+      { id: "1", slug: "org-1" },
+      { id: "2", slug: "org-2" },
+    ];
+    const mockAggregation: SankeyCategoryAggregationResult = {
+      income: [{ category: "寄附", totalAmount: 2000000 }],
+      expense: [{ category: "政治活動費", totalAmount: 1000000 }],
+    };
+    const mockBalances: TotalBalancesByYear = {
+      currentYear: 500000,
+      previousYear: 300000,
+    };
+
+    (mockPoliticalOrganizationRepository.findBySlugs as jest.Mock).mockResolvedValue(
+      mockOrganizations,
+    );
+    (mockTransactionRepository.getCategoryAggregationForSankey as jest.Mock).mockResolvedValue(
+      mockAggregation,
+    );
+    (mockBalanceSnapshotRepository.getTotalLatestBalancesByYear as jest.Mock).mockResolvedValue(
+      mockBalances,
+    );
+    (mockTransactionRepository.getLiabilityBalance as jest.Mock).mockResolvedValue(0);
+
+    const result = await usecase.execute({
+      slugs: ["org-1", "org-2"],
+      financialYear: 2025,
+    });
+
+    expect(result.sankeyData).toBeDefined();
+    expect(mockTransactionRepository.getCategoryAggregationForSankey).toHaveBeenCalledWith(
+      ["1", "2"],
+      2025,
+      undefined,
+    );
+  });
+
+  it("should handle empty aggregation data", async () => {
+    const mockOrganizations = [{ id: "1", slug: "test-org" }];
+    const mockAggregation: SankeyCategoryAggregationResult = {
+      income: [],
+      expense: [],
+    };
+    const mockBalances: TotalBalancesByYear = {
+      currentYear: 0,
+      previousYear: 0,
+    };
+
+    (mockPoliticalOrganizationRepository.findBySlugs as jest.Mock).mockResolvedValue(
+      mockOrganizations,
+    );
+    (mockTransactionRepository.getCategoryAggregationForSankey as jest.Mock).mockResolvedValue(
+      mockAggregation,
+    );
+    (mockBalanceSnapshotRepository.getTotalLatestBalancesByYear as jest.Mock).mockResolvedValue(
+      mockBalances,
+    );
+    (mockTransactionRepository.getLiabilityBalance as jest.Mock).mockResolvedValue(0);
+
+    const result = await usecase.execute({
+      slugs: ["test-org"],
+      financialYear: 2025,
+    });
+
+    expect(result.sankeyData).toBeDefined();
+    expect(result.sankeyData.nodes).toHaveLength(1);
+    expect(result.sankeyData.nodes[0].label).toBe("合計");
+  });
+});

webapp/tests/server/usecases/get-transactions-by-slug-usecase.test.ts

@@ -0,0 +1,270 @@
+import { GetTransactionsBySlugUsecase } from "@/server/usecases/get-transactions-by-slug-usecase";
+import type {
+  ITransactionRepository,
+  PaginatedResult,
+} from "@/server/repositories/interfaces/transaction-repository.interface";
+import type { IPoliticalOrganizationRepository } from "@/server/repositories/interfaces/political-organization-repository.interface";
+import type { Transaction } from "@/shared/models/transaction";
+
+const createMockTransaction = (overrides: Partial<Transaction> = {}): Transaction => ({
+  id: "test-id-1",
+  political_organization_id: "org-1",
+  transaction_no: "T001",
+  transaction_date: new Date("2025-08-15"),
+  financial_year: 2025,
+  transaction_type: "expense",
+  debit_account: "政治活動費",
+  debit_amount: 100000,
+  credit_account: "現金",
+  credit_amount: 100000,
+  friendly_category: "支出",
+  category_key: "political-activity",
+  label: "テスト取引",
+  hash: "test-hash",
+  created_at: new Date(),
+  updated_at: new Date(),
+  ...overrides,
+});
+
+const mockTransactionRepository = {
+  findWithPagination: jest.fn(),
+  getLastUpdatedAt: jest.fn(),
+} as unknown as ITransactionRepository;
+
+const mockPoliticalOrganizationRepository = {
+  findBySlugs: jest.fn(),
+} as unknown as IPoliticalOrganizationRepository;
+
+describe("GetTransactionsBySlugUsecase", () => {
+  let usecase: GetTransactionsBySlugUsecase;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    usecase = new GetTransactionsBySlugUsecase(
+      mockTransactionRepository,
+      mockPoliticalOrganizationRepository,
+    );
+  });
+
+  it("should return paginated transactions for valid organization", async () => {
+    const mockOrganizations = [{ id: "1", slug: "test-org", displayName: "テスト組織" }];
+    const mockTransactions = [
+      createMockTransaction({ id: "1" }),
+      createMockTransaction({ id: "2" }),
+    ];
+    const mockPaginatedResult: PaginatedResult<Transaction> = {
+      items: mockTransactions,
+      total: 2,
+      page: 1,
+      perPage: 50,
+      totalPages: 1,
+    };
+
+    (mockPoliticalOrganizationRepository.findBySlugs as jest.Mock).mockResolvedValue(
+      mockOrganizations,
+    );
+    (mockTransactionRepository.findWithPagination as jest.Mock).mockResolvedValue(
+      mockPaginatedResult,
+    );
+    (mockTransactionRepository.getLastUpdatedAt as jest.Mock).mockResolvedValue(
+      new Date("2025-01-01"),
+    );
+
+    const result = await usecase.execute({
+      slugs: ["test-org"],
+      financialYear: 2025,
+    });
+
+    expect(result.transactions).toHaveLength(2);
+    expect(result.total).toBe(2);
+    expect(result.page).toBe(1);
+    expect(result.perPage).toBe(50);
+    expect(result.totalPages).toBe(1);
+    expect(result.politicalOrganizations).toEqual(mockOrganizations);
+    expect(result.lastUpdatedAt).toBe("2025-01-01T00:00:00.000Z");
+  });
+
+  it("should throw error when organization not found", async () => {
+    (mockPoliticalOrganizationRepository.findBySlugs as jest.Mock).mockResolvedValue([]);
+
+    await expect(
+      usecase.execute({
+        slugs: ["non-existent-org"],
+        financialYear: 2025,
+      }),
+    ).rejects.toThrow('Political organizations with slugs "non-existent-org" not found');
+  });
+
+  it("should handle pagination parameters", async () => {
+    const mockOrganizations = [{ id: "1", slug: "test-org" }];
+    const mockPaginatedResult: PaginatedResult<Transaction> = {
+      items: [createMockTransaction()],
+      total: 100,
+      page: 2,
+      perPage: 10,
+      totalPages: 10,
+    };
+
+    (mockPoliticalOrganizationRepository.findBySlugs as jest.Mock).mockResolvedValue(
+      mockOrganizations,
+    );
+    (mockTransactionRepository.findWithPagination as jest.Mock).mockResolvedValue(
+      mockPaginatedResult,
+    );
+    (mockTransactionRepository.getLastUpdatedAt as jest.Mock).mockResolvedValue(null);
+
+    const result = await usecase.execute({
+      slugs: ["test-org"],
+      financialYear: 2025,
+      page: 2,
+      perPage: 10,
+    });
+
+    expect(result.page).toBe(2);
+    expect(result.perPage).toBe(10);
+    expect(result.totalPages).toBe(10);
+    expect(result.lastUpdatedAt).toBeNull();
+  });
+
+  it("should enforce perPage maximum of 100", async () => {
+    const mockOrganizations = [{ id: "1", slug: "test-org" }];
+    const mockPaginatedResult: PaginatedResult<Transaction> = {
+      items: [],
+      total: 0,
+      page: 1,
+      perPage: 100,
+      totalPages: 0,
+    };
+
+    (mockPoliticalOrganizationRepository.findBySlugs as jest.Mock).mockResolvedValue(
+      mockOrganizations,
+    );
+    (mockTransactionRepository.findWithPagination as jest.Mock).mockResolvedValue(
+      mockPaginatedResult,
+    );
+    (mockTransactionRepository.getLastUpdatedAt as jest.Mock).mockResolvedValue(null);
+
+    await usecase.execute({
+      slugs: ["test-org"],
+      financialYear: 2025,
+      perPage: 200,
+    });
+
+    expect(mockTransactionRepository.findWithPagination).toHaveBeenCalledWith(
+      expect.any(Object),
+      expect.objectContaining({ perPage: 100 }),
+    );
+  });
+
+  it("should enforce page minimum of 1", async () => {
+    const mockOrganizations = [{ id: "1", slug: "test-org" }];
+    const mockPaginatedResult: PaginatedResult<Transaction> = {
+      items: [],
+      total: 0,
+      page: 1,
+      perPage: 50,
+      totalPages: 0,
+    };
+
+    (mockPoliticalOrganizationRepository.findBySlugs as jest.Mock).mockResolvedValue(
+      mockOrganizations,
+    );
+    (mockTransactionRepository.findWithPagination as jest.Mock).mockResolvedValue(
+      mockPaginatedResult,
+    );
+    (mockTransactionRepository.getLastUpdatedAt as jest.Mock).mockResolvedValue(null);
+
+    await usecase.execute({
+      slugs: ["test-org"],
+      financialYear: 2025,
+      page: -1,
+    });
+
+    expect(mockTransactionRepository.findWithPagination).toHaveBeenCalledWith(
+      expect.any(Object),
+      expect.objectContaining({ page: 1 }),
+    );
+  });
+
+  it("should pass filter parameters correctly", async () => {
+    const mockOrganizations = [{ id: "1", slug: "test-org" }];
+    const mockPaginatedResult: PaginatedResult<Transaction> = {
+      items: [],
+      total: 0,
+      page: 1,
+      perPage: 50,
+      totalPages: 0,
+    };
+
+    (mockPoliticalOrganizationRepository.findBySlugs as jest.Mock).mockResolvedValue(
+      mockOrganizations,
+    );
+    (mockTransactionRepository.findWithPagination as jest.Mock).mockResolvedValue(
+      mockPaginatedResult,
+    );
+    (mockTransactionRepository.getLastUpdatedAt as jest.Mock).mockResolvedValue(null);
+
+    const dateFrom = new Date("2025-01-01");
+    const dateTo = new Date("2025-12-31");
+
+    await usecase.execute({
+      slugs: ["test-org"],
+      financialYear: 2025,
+      transactionType: "income",
+      dateFrom,
+      dateTo,
+      categories: ["donation-personal"],
+      sortBy: "date",
+      order: "desc",
+    });
+
+    expect(mockTransactionRepository.findWithPagination).toHaveBeenCalledWith(
+      expect.objectContaining({
+        political_organization_ids: ["1"],
+        transaction_type: "income",
+        date_from: dateFrom,
+        date_to: dateTo,
+        category_keys: ["donation-personal"],
+        financial_year: 2025,
+      }),
+      expect.objectContaining({
+        sortBy: "date",
+        order: "desc",
+      }),
+    );
+  });
+
+  it("should handle multiple organizations", async () => {
+    const mockOrganizations = [
+      { id: "1", slug: "org-1" },
+      { id: "2", slug: "org-2" },
+    ];
+    const mockPaginatedResult: PaginatedResult<Transaction> = {
+      items: [],
+      total: 0,
+      page: 1,
+      perPage: 50,
+      totalPages: 0,
+    };
+
+    (mockPoliticalOrganizationRepository.findBySlugs as jest.Mock).mockResolvedValue(
+      mockOrganizations,
+    );
+    (mockTransactionRepository.findWithPagination as jest.Mock).mockResolvedValue(
+      mockPaginatedResult,
+    );
+    (mockTransactionRepository.getLastUpdatedAt as jest.Mock).mockResolvedValue(null);
+
+    await usecase.execute({
+      slugs: ["org-1", "org-2"],
+      financialYear: 2025,
+    });
+
+    expect(mockTransactionRepository.findWithPagination).toHaveBeenCalledWith(
+      expect.objectContaining({
+        political_organization_ids: ["1", "2"],
+      }),
+      expect.any(Object),
+    );
+  });
+});

webapp/tests/server/usecases/get-transactions-for-csv-usecase.test.ts

@@ -0,0 +1,172 @@
+import { GetTransactionsForCsvUsecase } from "@/server/usecases/get-transactions-for-csv-usecase";
+import type { ITransactionRepository } from "@/server/repositories/interfaces/transaction-repository.interface";
+import type { IPoliticalOrganizationRepository } from "@/server/repositories/interfaces/political-organization-repository.interface";
+import type { Transaction } from "@/shared/models/transaction";
+
+const createMockTransactionWithOrgName = (
+  overrides: Partial<Transaction & { political_organization_name: string }> = {},
+): Transaction & { political_organization_name: string } => ({
+  id: "test-id-1",
+  political_organization_id: "org-1",
+  political_organization_name: "テスト組織",
+  transaction_no: "T001",
+  transaction_date: new Date("2025-08-15"),
+  financial_year: 2025,
+  transaction_type: "expense",
+  debit_account: "政治活動費",
+  debit_amount: 100000,
+  credit_account: "現金",
+  credit_amount: 100000,
+  friendly_category: "支出",
+  category_key: "political-activity",
+  label: "テスト取引",
+  hash: "test-hash",
+  created_at: new Date(),
+  updated_at: new Date(),
+  ...overrides,
+});
+
+const mockTransactionRepository = {
+  findAllWithPoliticalOrganizationName: jest.fn(),
+} as unknown as ITransactionRepository;
+
+const mockPoliticalOrganizationRepository = {
+  findBySlugs: jest.fn(),
+} as unknown as IPoliticalOrganizationRepository;
+
+describe("GetTransactionsForCsvUsecase", () => {
+  let usecase: GetTransactionsForCsvUsecase;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    usecase = new GetTransactionsForCsvUsecase(
+      mockTransactionRepository,
+      mockPoliticalOrganizationRepository,
+    );
+  });
+
+  it("should return transactions with organization name for valid organization", async () => {
+    const mockOrganizations = [{ id: "1", slug: "test-org" }];
+    const mockTransactions = [
+      createMockTransactionWithOrgName({ id: "1", political_organization_name: "組織A" }),
+      createMockTransactionWithOrgName({ id: "2", political_organization_name: "組織A" }),
+    ];
+
+    (mockPoliticalOrganizationRepository.findBySlugs as jest.Mock).mockResolvedValue(
+      mockOrganizations,
+    );
+    (
+      mockTransactionRepository.findAllWithPoliticalOrganizationName as jest.Mock
+    ).mockResolvedValue(mockTransactions);
+
+    const result = await usecase.execute({
+      slugs: ["test-org"],
+      financialYear: 2025,
+    });
+
+    expect(result.transactions).toHaveLength(2);
+    expect(result.total).toBe(2);
+    expect(result.transactions[0].political_organization_name).toBe("組織A");
+  });
+
+  it("should throw error when organization not found", async () => {
+    (mockPoliticalOrganizationRepository.findBySlugs as jest.Mock).mockResolvedValue([]);
+
+    await expect(
+      usecase.execute({
+        slugs: ["non-existent-org"],
+        financialYear: 2025,
+      }),
+    ).rejects.toThrow('Political organizations with slugs "non-existent-org" not found');
+  });
+
+  it("should pass correct filters to repository", async () => {
+    const mockOrganizations = [{ id: "1", slug: "test-org" }];
+
+    (mockPoliticalOrganizationRepository.findBySlugs as jest.Mock).mockResolvedValue(
+      mockOrganizations,
+    );
+    (
+      mockTransactionRepository.findAllWithPoliticalOrganizationName as jest.Mock
+    ).mockResolvedValue([]);
+
+    await usecase.execute({
+      slugs: ["test-org"],
+      financialYear: 2025,
+    });
+
+    expect(mockTransactionRepository.findAllWithPoliticalOrganizationName).toHaveBeenCalledWith({
+      political_organization_ids: ["1"],
+      financial_year: 2025,
+    });
+  });
+
+  it("should handle multiple organizations", async () => {
+    const mockOrganizations = [
+      { id: "1", slug: "org-1" },
+      { id: "2", slug: "org-2" },
+    ];
+    const mockTransactions = [
+      createMockTransactionWithOrgName({ id: "1", political_organization_name: "組織A" }),
+      createMockTransactionWithOrgName({ id: "2", political_organization_name: "組織B" }),
+    ];
+
+    (mockPoliticalOrganizationRepository.findBySlugs as jest.Mock).mockResolvedValue(
+      mockOrganizations,
+    );
+    (
+      mockTransactionRepository.findAllWithPoliticalOrganizationName as jest.Mock
+    ).mockResolvedValue(mockTransactions);
+
+    const result = await usecase.execute({
+      slugs: ["org-1", "org-2"],
+      financialYear: 2025,
+    });
+
+    expect(result.transactions).toHaveLength(2);
+    expect(mockTransactionRepository.findAllWithPoliticalOrganizationName).toHaveBeenCalledWith({
+      political_organization_ids: ["1", "2"],
+      financial_year: 2025,
+    });
+  });
+
+  it("should handle empty transactions", async () => {
+    const mockOrganizations = [{ id: "1", slug: "test-org" }];
+
+    (mockPoliticalOrganizationRepository.findBySlugs as jest.Mock).mockResolvedValue(
+      mockOrganizations,
+    );
+    (
+      mockTransactionRepository.findAllWithPoliticalOrganizationName as jest.Mock
+    ).mockResolvedValue([]);
+
+    const result = await usecase.execute({
+      slugs: ["test-org"],
+      financialYear: 2025,
+    });
+
+    expect(result.transactions).toEqual([]);
+    expect(result.total).toBe(0);
+  });
+
+  it("should handle different financial years", async () => {
+    const mockOrganizations = [{ id: "1", slug: "test-org" }];
+
+    (mockPoliticalOrganizationRepository.findBySlugs as jest.Mock).mockResolvedValue(
+      mockOrganizations,
+    );
+    (
+      mockTransactionRepository.findAllWithPoliticalOrganizationName as jest.Mock
+    ).mockResolvedValue([]);
+
+    await usecase.execute({
+      slugs: ["test-org"],
+      financialYear: 2024,
+    });
+
+    expect(mockTransactionRepository.findAllWithPoliticalOrganizationName).toHaveBeenCalledWith({
+      political_organization_ids: ["1"],
+      financial_year: 2024,
+    });
+  });
+});

webapp/tests/server/utils/sankey-id-utils.test.ts

@@ -0,0 +1,57 @@
+import { createSafariCompatibleId } from "@/server/utils/sankey-id-utils";
+
+describe("createSafariCompatibleId", () => {
+  it("should keep alphanumeric characters unchanged", () => {
+    expect(createSafariCompatibleId("abc123")).toBe("abc123");
+    expect(createSafariCompatibleId("ABC")).toBe("ABC");
+    expect(createSafariCompatibleId("test-id")).toBe("test-id");
+    expect(createSafariCompatibleId("test_id")).toBe("test_id");
+  });
+
+  it("should convert Japanese characters to hash", () => {
+    const result = createSafariCompatibleId("寄附");
+    expect(result).not.toBe("寄附");
+    expect(result).toMatch(/^_[a-z0-9]+_[a-z0-9]+$/);
+  });
+
+  it("should convert spaces to hash", () => {
+    const result = createSafariCompatibleId("test id");
+    expect(result).not.toBe("test id");
+    expect(result).toContain("test");
+    expect(result).toContain("id");
+    expect(result).toMatch(/_[a-z0-9]+/);
+  });
+
+  it("should handle mixed content", () => {
+    const result = createSafariCompatibleId("income-寄附-123");
+    expect(result).toContain("income-");
+    expect(result).toContain("-123");
+    expect(result).not.toContain("寄附");
+  });
+
+  it("should produce consistent results for same input", () => {
+    const input = "政治活動費";
+    const result1 = createSafariCompatibleId(input);
+    const result2 = createSafariCompatibleId(input);
+    expect(result1).toBe(result2);
+  });
+
+  it("should handle empty string", () => {
+    expect(createSafariCompatibleId("")).toBe("");
+  });
+
+  it("should handle special characters", () => {
+    const result = createSafariCompatibleId("test@#$%");
+    expect(result).toContain("test");
+    expect(result).not.toContain("@");
+    expect(result).not.toContain("#");
+    expect(result).not.toContain("$");
+    expect(result).not.toContain("%");
+  });
+
+  it("should produce different hashes for different characters", () => {
+    const result1 = createSafariCompatibleId("あ");
+    const result2 = createSafariCompatibleId("い");
+    expect(result1).not.toBe(result2);
+  });
+});