はじめに

テストコードの作成は、ソフトウェア品質を担保する上で不可欠なプロセスです。しかし、実際の開発現場では「時間がない」「テストの書き方がわからない」「どこまでテストすべきかわからない」といった理由で、テストが後回しにされることも少なくありません。

Claude Codeは、公式ドキュメントの「Work with tests」セクションで示されているように、テストワークフローを強力にサポートします。コードベース全体を理解するエージェント型アプローチにより、テストされていないコードの特定から、既存のテストパターンに沿ったテストケースの自動生成まで、テスト作成のあらゆるフェーズを効率化できます。

本記事では、Claude Codeを活用してテストカバレッジを向上させ、品質の高いテストコードを効率的に書くための実践的なテクニックを解説します。この記事を読むことで、以下のことができるようになります。

  • テストされていないコードを特定し、優先順位をつける
  • 既存のテストパターンに沿ったテストケースを自動生成する
  • エッジケースや境界値を網羅したテストを作成する
  • テスト実行から失敗時の修正までのワークフローを自動化する

実行環境

  • オペレーティングシステム: macOS 10.15以上、Ubuntu 20.04以上/Debian 10以上、Windows 10以上（WSL 1/2またはGit for Windows）
  • ハードウェア: 4GB以上のRAM
  • Node.js 18以上（npmインストールの場合のみ必要）
  • インターネット接続（認証およびAI処理に必要）
  • シェル環境: Bash、Zsh、またはFish推奨

前提条件

  • コマンドライン操作の基礎知識
  • Gitの基本操作（clone、commit、push等）
  • プログラミングの基礎知識（言語は問わない）
  • Claude.aiまたはAnthropic Consoleアカウント
  • Claude Codeのインストールと認証が完了していること

テスト作成ワークフローの全体像

Claude Codeを使ったテスト作成の全体的なワークフローを確認しましょう。

flowchart TD
    A[テストされていないコードの特定] --> B[優先度の高いコードを選定]
    B --> C[既存テストパターンの分析]
    C --> D[テストケースの自動生成]
    D --> E[エッジケースの追加]
    E --> F[テストの実行]
    F --> G{テスト成功?}
    G -->|Yes| H[カバレッジレポート確認]
    G -->|No| I[失敗原因の分析]
    I --> J[コードまたはテストの修正]
    J --> F
    H --> K{目標達成?}
    K -->|Yes| L[コミット]
    K -->|No| A

このワークフローの特徴は、Claude Codeがテスト作成の各フェーズで具体的な支援を提供できる点です。単にテストを生成するだけでなく、テストが失敗した場合の原因分析と修正まで一貫してサポートします。

テストされていないコードの特定

テストカバレッジを向上させる第一歩は、現在テストされていないコードを把握することです。

カバレッジレポートからの分析

プロジェクトにカバレッジ計測ツールが導入されている場合、Claude Codeにレポートを分析させることができます。

1
2

> カバレッジレポートを確認して、カバレッジが低いファイルをリストアップして。
> 特にビジネスロジックを含むファイルを優先的に教えて。

Claude Codeは、カバレッジレポートを解析し、以下のような分析結果を提供します。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

⏺ カバレッジ分析結果:

■ カバレッジが低いファイル（ビジネスロジック優先）

1. src/services/PaymentService.ts - 23%
   - processPayment(): 未テスト
   - refundTransaction(): 未テスト
   - validatePaymentMethod(): 部分的

2. src/services/OrderService.ts - 35%
   - calculateTotalPrice(): 未テスト
   - applyDiscount(): 未テスト
   - validateOrder(): テスト済み

3. src/utils/validators.ts - 41%
   - validateEmail(): テスト済み
   - validatePhoneNumber(): 未テスト
   - validatePostalCode(): 未テスト

■ 推奨優先順位:
1. PaymentService - 決済処理のため最重要
2. OrderService - 注文計算のコアロジック
3. validators - 入力検証の信頼性確保

特定ファイルの未テスト関数を検出

特定のファイルに焦点を当てて、テストされていない関数を検出することもできます。公式ドキュメントでは、以下のような依頼方法が示されています。

1

> find functions in NotificationsService.swift that are not covered by tests

日本語で依頼する場合は、以下のように表現できます。

1
2

> @src/services/PaymentService.ts のテストされていない関数を特定して。
> 各関数の複雑度と重要度も評価して。

@記法でファイルを参照することで、Claude Codeは確実にそのファイルを分析対象とします。

テストファイルの有無を確認

大規模なプロジェクトでは、そもそもテストファイルが存在しないモジュールがあるかもしれません。

1
2

> このプロジェクトで、対応するテストファイルが存在しないソースファイルを
> リストアップして。src/services/ と src/utils/ を対象にして。

既存テストパターンの分析と踏襲

高品質なテストを作成するには、プロジェクト内の既存のテストパターンに従うことが重要です。Claude Codeは、コードベース全体を理解しているため、既存のパターンを自動的に検出し、それに沿ったテストを生成できます。

テストパターンの自動検出

プロジェクトのテストパターンをClaude Codeに分析させましょう。

1
2
3

> このプロジェクトのテストパターンを分析して。
> 使用しているテストフレームワーク、モックライブラリ、アサーションスタイル、
> ディレクトリ構造、命名規則を教えて。

Claude Codeは、以下のような分析結果を提供します。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

⏺ テストパターン分析結果:

■ フレームワークとライブラリ
- テストフレームワーク: Jest 29.x
- モックライブラリ: jest.mock(), jest.spyOn()
- アサーション: Jest built-in (expect)
- HTTPモック: msw (Mock Service Worker)

■ ディレクトリ構造
- テストファイル: __tests__/ ディレクトリに配置
- ファイル名: [対象ファイル名].test.ts

■ 命名規則
- describe: クラス名またはモジュール名
- it/test: "should [期待される動作]" 形式

■ セットアップパターン
- beforeEach: テストデータの初期化
- afterEach: モックのリセット
- 共通フィクスチャ: __tests__/fixtures/ に配置

■ モックパターン
- 外部API: msw handlers で定義
- 内部依存: jest.mock() で注入
- 日時: jest.useFakeTimers()

既存テストを参考にした生成

特定のテストファイルを参照して、同じパターンでテストを生成するよう依頼できます。

1
2
3

> @src/__tests__/UserService.test.ts のテストパターンに従って、
> PaymentServiceのテストを作成して。
> モック、セットアップ、アサーションの書き方を統一すること。

Claude Codeは、参照されたテストファイルの構造、セットアップ方法、アサーションスタイルを分析し、一貫性のあるテストを生成します。

テストケースの自動生成

テストされていないコードを特定し、既存のパターンを把握したら、いよいよテストを生成します。

基本的なテスト生成

公式ドキュメントでは、以下のシンプルな依頼でテストを生成できることが示されています。

1

> add tests for the notification service

より具体的に依頼することで、期待通りのテストを得られます。

1
2
3
4
5
6
7
8

> PaymentServiceの以下のメソッドに対するユニットテストを作成して：
> - processPayment()
> - refundTransaction()
> 
> 要件：
> - 正常系と異常系の両方をカバー
> - 外部決済APIはモック化
> - 既存のテストファイルと同じ構造で作成

生成されるテストの例

Claude Codeは、以下のような構造化されたテストを生成します。

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124

import { PaymentService } from '../services/PaymentService';
import { PaymentGateway } from '../external/PaymentGateway';

jest.mock('../external/PaymentGateway');

describe('PaymentService', () => {
  let paymentService: PaymentService;
  let mockPaymentGateway: jest.Mocked<PaymentGateway>;

  beforeEach(() => {
    mockPaymentGateway = new PaymentGateway() as jest.Mocked<PaymentGateway>;
    paymentService = new PaymentService(mockPaymentGateway);
    jest.clearAllMocks();
  });

  describe('processPayment', () => {
    it('should process payment successfully with valid card', async () => {
      // Arrange
      const paymentRequest = {
        amount: 1000,
        currency: 'JPY',
        cardToken: 'valid_token_123'
      };
      mockPaymentGateway.charge.mockResolvedValue({
        transactionId: 'txn_abc123',
        status: 'succeeded'
      });

      // Act
      const result = await paymentService.processPayment(paymentRequest);

      // Assert
      expect(result.success).toBe(true);
      expect(result.transactionId).toBe('txn_abc123');
      expect(mockPaymentGateway.charge).toHaveBeenCalledWith(
        expect.objectContaining({
          amount: 1000,
          currency: 'JPY'
        })
      );
    });

    it('should throw PaymentError when gateway returns declined', async () => {
      // Arrange
      const paymentRequest = {
        amount: 1000,
        currency: 'JPY',
        cardToken: 'declined_card_token'
      };
      mockPaymentGateway.charge.mockResolvedValue({
        transactionId: null,
        status: 'declined',
        errorCode: 'card_declined'
      });

      // Act & Assert
      await expect(paymentService.processPayment(paymentRequest))
        .rejects.toThrow('Payment declined: card_declined');
    });

    it('should handle gateway timeout gracefully', async () => {
      // Arrange
      const paymentRequest = {
        amount: 1000,
        currency: 'JPY',
        cardToken: 'valid_token_123'
      };
      mockPaymentGateway.charge.mockRejectedValue(
        new Error('Gateway timeout')
      );

      // Act & Assert
      await expect(paymentService.processPayment(paymentRequest))
        .rejects.toThrow('Payment processing failed: Gateway timeout');
    });
  });

  describe('refundTransaction', () => {
    it('should refund full amount when no partial amount specified', async () => {
      // Arrange
      const transactionId = 'txn_abc123';
      mockPaymentGateway.refund.mockResolvedValue({
        refundId: 'ref_xyz789',
        status: 'succeeded',
        amount: 1000
      });

      // Act
      const result = await paymentService.refundTransaction(transactionId);

      // Assert
      expect(result.success).toBe(true);
      expect(result.refundId).toBe('ref_xyz789');
      expect(mockPaymentGateway.refund).toHaveBeenCalledWith(
        transactionId,
        undefined
      );
    });

    it('should refund partial amount when specified', async () => {
      // Arrange
      const transactionId = 'txn_abc123';
      const partialAmount = 500;
      mockPaymentGateway.refund.mockResolvedValue({
        refundId: 'ref_xyz789',
        status: 'succeeded',
        amount: 500
      });

      // Act
      const result = await paymentService.refundTransaction(
        transactionId,
        partialAmount
      );

      // Assert
      expect(result.amount).toBe(500);
      expect(mockPaymentGateway.refund).toHaveBeenCalledWith(
        transactionId,
        500
      );
    });
  });
});

生成されたテストは、Arrange-Act-Assertパターンに従い、各テストケースが明確に構造化されています。

複数ファイルへのテスト一括生成

複数のサービスに対して一括でテストを生成することも可能です。

1
2
3

> src/services/ ディレクトリ内のすべてのサービスクラスに対して、
> 基本的なユニットテストを生成して。
> 各サービスの主要メソッドをカバーすること。

エッジケースと境界値のテスト

テストカバレッジを真に高めるには、正常系だけでなくエッジケースや境界値のテストが不可欠です。Claude Codeは、コードを分析してこれらのケースを提案できます。

エッジケースの自動提案

公式ドキュメントでは、以下のようにエッジケースの追加を依頼できることが示されています。

1

> add test cases for edge conditions in the notification service

より具体的に依頼する場合は、以下のように表現します。

1
2
3

> @src/services/OrderService.ts の calculateTotalPrice() メソッドに対して、
> エッジケースと境界値のテストケースを提案して。
> 各ケースがなぜ重要かも説明して。

Claude Codeは、コードを分析し、以下のような提案を行います。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

⏺ calculateTotalPrice() のエッジケース分析:

■ 境界値テスト
1. 空の注文（items.length === 0）
   - 理由: ゼロ除算やnull参照のリスク
   - 期待: 0円または適切なエラー

2. 単一アイテムの注文
   - 理由: ループ処理の最小ケース
   - 期待: 単価 × 数量の正確な計算

3. 大量アイテム（1000件以上）
   - 理由: パフォーマンスと精度の確認
   - 期待: 適切な時間内での正確な計算

■ エッジケース
4. 小数点を含む価格（例: 99.99円）
   - 理由: 浮動小数点の丸め誤差
   - 期待: 正確な合計（銀行丸め等）

5. 非常に大きな金額（Integer.MAX_VALUE付近）
   - 理由: オーバーフローのリスク
   - 期待: 適切なエラーまたは正確な計算

6. 負の数量
   - 理由: 不正入力のバリデーション
   - 期待: バリデーションエラー

7. 割引率が100%以上
   - 理由: 無料または負の合計のリスク
   - 期待: 0円（最小値制限）

■ 組み合わせケース
8. 複数の割引の同時適用
   - 理由: 割引計算順序の影響
   - 期待: 定義された順序での正確な適用

エッジケーステストの生成

提案されたエッジケースに基づいてテストを生成するよう依頼します。

1
2

> 提案されたエッジケースに基づいて、calculateTotalPrice() の
> テストケースを追加して。

Claude Codeは、以下のようなテストを生成します。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75

describe('calculateTotalPrice - Edge Cases', () => {
  describe('boundary values', () => {
    it('should return 0 for empty order', () => {
      const order = { items: [], discounts: [] };
      expect(orderService.calculateTotalPrice(order)).toBe(0);
    });

    it('should calculate correctly for single item', () => {
      const order = {
        items: [{ productId: 'p1', unitPrice: 100, quantity: 1 }],
        discounts: []
      };
      expect(orderService.calculateTotalPrice(order)).toBe(100);
    });

    it('should handle large number of items efficiently', () => {
      const items = Array.from({ length: 1000 }, (_, i) => ({
        productId: `p${i}`,
        unitPrice: 100,
        quantity: 1
      }));
      const order = { items, discounts: [] };
      
      const startTime = performance.now();
      const total = orderService.calculateTotalPrice(order);
      const duration = performance.now() - startTime;

      expect(total).toBe(100000);
      expect(duration).toBeLessThan(100); // 100ms以内
    });
  });

  describe('edge cases', () => {
    it('should handle decimal prices with banker rounding', () => {
      const order = {
        items: [
          { productId: 'p1', unitPrice: 99.99, quantity: 3 }
        ],
        discounts: []
      };
      // 99.99 * 3 = 299.97
      expect(orderService.calculateTotalPrice(order)).toBe(299.97);
    });

    it('should throw error for negative quantity', () => {
      const order = {
        items: [{ productId: 'p1', unitPrice: 100, quantity: -1 }],
        discounts: []
      };
      expect(() => orderService.calculateTotalPrice(order))
        .toThrow('Invalid quantity: must be positive');
    });

    it('should cap discount at 100% (total never goes negative)', () => {
      const order = {
        items: [{ productId: 'p1', unitPrice: 100, quantity: 1 }],
        discounts: [{ type: 'percentage', value: 150 }] // 150%割引
      };
      expect(orderService.calculateTotalPrice(order)).toBe(0);
    });
  });

  describe('combination cases', () => {
    it('should apply multiple discounts in correct order', () => {
      const order = {
        items: [{ productId: 'p1', unitPrice: 1000, quantity: 1 }],
        discounts: [
          { type: 'percentage', value: 10 },  // 10% off: 1000 -> 900
          { type: 'fixed', value: 100 }        // 100円引き: 900 -> 800
        ]
      };
      expect(orderService.calculateTotalPrice(order)).toBe(800);
    });
  });
});

テスト実行と失敗時の修正フロー

テストを生成した後は、実行して結果を確認し、必要に応じて修正を行います。Claude Codeは、このフローを効率的にサポートします。

テストの実行と結果確認

公式ドキュメントでは、テスト実行と修正を以下のように依頼できることが示されています。

1

> run the new tests and fix any failures

より詳細な依頼も可能です。

1
2

> PaymentServiceのテストを実行して、結果を報告して。
> 失敗したテストがあれば、原因を分析して。

Claude Codeは、テストを実行し、結果を分析します。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

⏺ テスト実行結果:

npm test -- PaymentService.test.ts

FAIL src/__tests__/PaymentService.test.ts

  ● PaymentService › processPayment › should throw PaymentError when gateway returns declined

    Expected: "Payment declined: card_declined"
    Received: "PaymentError: card_declined"

  ● PaymentService › refundTransaction › should refund partial amount when specified

    Expected: 500
    Received: undefined

■ 失敗原因の分析:

1. processPaymentのエラーメッセージ形式が実装と異なる
   - 実装: "PaymentError: {errorCode}"
   - テスト: "Payment declined: {errorCode}"

2. refundTransactionの戻り値構造が異なる
   - 実装: { success, refundId } (amountなし)
   - テスト: { success, refundId, amount }

自動修正の依頼

分析結果に基づいて、テストまたは実装の修正を依頼します。

1
2

> 失敗したテストを修正して。
> 実装の仕様に合わせてテストを更新すること。

Claude Codeは、実装コードを確認した上で、テストを適切に修正します。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

// 修正後のテスト
it('should throw PaymentError when gateway returns declined', async () => {
  // ...
  await expect(paymentService.processPayment(paymentRequest))
    .rejects.toThrow('PaymentError: card_declined');  // 修正
});

it('should refund partial amount when specified', async () => {
  // ...
  // Assert - 実装に合わせて修正
  expect(result.success).toBe(true);
  expect(result.refundId).toBe('ref_xyz789');
  // amount は戻り値に含まれないため削除
});

修正後の再実行

修正が完了したら、再度テストを実行して確認します。

1

> 修正したテストを再実行して、すべてパスすることを確認して。

テストとTDDの統合ワークフロー

Claude Codeは、TDD（テスト駆動開発）のワークフローもサポートします。新機能の実装時に、テストファーストで開発を進められます。

TDDサイクルでの活用

Red-Green-Refactorサイクルの各フェーズでClaude Codeを活用できます。

1
2
3
4
5
6
7

> 以下の仕様でユーザー登録機能を実装したい。
> まず、失敗するテストを書いて（Red）：
> 
> 仕様：
> - メールアドレスの重複チェック
> - パスワードは8文字以上で英数字混在必須
> - 登録成功時はユーザーIDを返す

Claude Codeは、まずテストを生成します。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

describe('UserRegistrationService', () => {
  describe('register', () => {
    it('should return user ID on successful registration', async () => {
      const result = await registrationService.register({
        email: 'newuser@example.com',
        password: 'SecurePass123'
      });
      
      expect(result.userId).toBeDefined();
      expect(typeof result.userId).toBe('string');
    });

    it('should throw DuplicateEmailError when email already exists', async () => {
      // 既存ユーザーを先に登録
      await registrationService.register({
        email: 'existing@example.com',
        password: 'SecurePass123'
      });

      // 同じメールで再登録を試行
      await expect(registrationService.register({
        email: 'existing@example.com',
        password: 'AnotherPass456'
      })).rejects.toThrow(DuplicateEmailError);
    });

    it('should throw ValidationError when password is less than 8 characters', async () => {
      await expect(registrationService.register({
        email: 'user@example.com',
        password: 'Short1'
      })).rejects.toThrow('Password must be at least 8 characters');
    });

    it('should throw ValidationError when password has no numbers', async () => {
      await expect(registrationService.register({
        email: 'user@example.com',
        password: 'NoNumbersHere'
      })).rejects.toThrow('Password must contain at least one number');
    });
  });
});

テストを実行して失敗を確認した後、実装を依頼します。

1
2

> テストが失敗することを確認した。
> 次に、このテストをパスする最小限の実装を書いて（Green）。

カスタムテストコマンドの作成

頻繁に使用するテスト関連のタスクは、カスタムスラッシュコマンドとして定義しておくと便利です。

テスト生成コマンドの作成

.claude/commands/ ディレクトリにコマンドファイルを作成します。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

<!-- .claude/commands/generate-tests.md -->

以下のファイルに対するユニットテストを生成してください：

$ARGUMENTS

要件：
1. 既存のテストファイル（__tests__/ディレクトリ）のパターンに従う
2. 正常系、異常系、エッジケースをカバー
3. 外部依存はモック化
4. Arrange-Act-Assert パターンを使用
5. テスト名は "should [期待される動作]" 形式

このコマンドは以下のように使用できます。

1

> /generate-tests src/services/OrderService.ts

テスト修正コマンドの作成

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

<!-- .claude/commands/fix-tests.md -->

失敗しているテストを修正してください：

1. テストを実行して失敗を特定
2. 失敗原因を分析（実装の問題か、テストの問題か判断）
3. 適切な修正を適用
4. 再実行して成功を確認

対象: $ARGUMENTS

使用例：

1

> /fix-tests PaymentService

テストカバレッジの継続的な改善

カバレッジを向上させるためのClaude Codeの活用パターンを紹介します。

カバレッジレポートとの連携

カバレッジ計測ツールと連携して、効率的にカバレッジを向上させます。

1
2

> npm run test:coverage を実行して、カバレッジレポートを分析して。
> カバレッジが70%未満のファイルに対して、テストを追加して。

Plan Modeでのテスト戦略立案

大規模なテスト追加を行う前に、Plan Modeで戦略を立てることをお勧めします。

1

claude --permission-mode plan

1
2

> このプロジェクト全体のテストカバレッジを80%以上に引き上げたい。
> 現状分析と、段階的な改善計画を立てて。

Plan Modeでは、Claude Codeは読み取り専用で分析を行い、ファイルを変更せずに計画を提示します。計画に同意したら、通常モードに切り替えて実行します。

トラブルシューティング

テスト作成時によく遭遇する問題と解決方法を紹介します。

モックが正しく動作しない

1
2

> PaymentGatewayのモックが呼び出されていない。
> モックの設定を確認して、問題を特定して。

Claude Codeは、モックの設定、インポート順序、依存性注入の方法を分析し、問題を特定します。

非同期テストのタイムアウト

1

> テストがタイムアウトする。非同期処理の待ち方を確認して修正して。

テストの実行順序依存

1
2

> テストを単独で実行すると成功するが、全体で実行すると失敗する。
> テスト間の依存関係を分析して、独立したテストに修正して。

まとめ

Claude Codeを活用することで、テスト作成のあらゆるフェーズを効率化できます。

  • テストされていないコードの特定：カバレッジレポートの分析と優先順位付け
  • 既存パターンの踏襲：プロジェクトのテストスタイルを自動検出して一貫性を維持
  • テストケースの自動生成：正常系、異常系、エッジケースを網羅したテストの生成
  • 実行と修正のフロー：テスト失敗時の原因分析と修正の自動化

重要なのは、Claude Codeが生成したテストを鵜呑みにせず、レビューを行うことです。生成されたテストが本当にビジネス要件を検証しているか、重要なエッジケースが漏れていないかを確認しましょう。

また、テストは「書いて終わり」ではなく、継続的にメンテナンスが必要です。Claude Codeの/fix-testsのようなカスタムコマンドを活用して、テストの保守も効率化することをお勧めします。

参考リンク