テーブル駆動テストで並列実行を有効にするにはどうすればよいですか？

t.Run() で作成した各サブテスト内で t.Parallel() を呼び出してください。これにより、サブテストが他の並列テストと並行して実行できることを示します。競合条件を避けるために、ループ変数をキャプチャすることを忘れないでください。

t.Parallel() を使用するときにループ変数をキャプチャする必要がある理由はなぜですか？

Goでは、ループ変数はイテレーションの間で共有されます。サブテストが並列に実行される場合、すべてのサブテストが同じループ変数を参照する可能性があり、競合条件を引き起こすことがあります。 t.Parallel() を呼び出す前に、ループ内において tt := tt で変数をキャプチャしてください。

Goのデフォルトで並列に実行されるテストの数はいくつか？

デフォルトの並列度は -parallel フラグによって制御され、デフォルトでは GOMAXPROCS （通常はCPUコアの数）となります。 go test -parallel N を使用して、特定の上限値を設定することによってこれを上書きできます。

並列テストで競合条件を検出するにはどうすればよいですか？

-race フラグを使用してテストを実行します- go test -race ./... 。Goに組み込まれたレース検出機能は、データレースを識別し、報告することで、開発初期段階で並行性の問題を早期に発見するのに役立ちます。

すべてのテストを並列して実行しても安全ですか？

並列実行すべきではないテストは、状態を共有し、グローバル変数を変更する、またはデータベースやファイルなどの共有リソースにアクセスするテストです。互いに干渉しない独立したテストのみが、並列実行に安全です。

並列テストのパフォーマンス上の利点は何ですか？

並列テストは、特にI/Oに依存する処理において、テストスイートの実行時間を大幅に短縮できます。マルチコアシステムでは、CPUコアの数やテストの特性に応じて、2〜4倍以上の速度向上が見られることがあります。

どのテストを並列で実行するかをどう制御すればよいですか？

t.Parallel() を使用して、並列で実行できるテストをマークします。この呼び出しがないテストは順序よく実行されます。また、 go test -parallel N を使用して並列実行するテストの最大数を制限することもでき、 -run オプションで特定のテストを選び出すことも可能です。

Goにおける並列なテーブル駆動テスト

Goのテストを並列実行で高速化する

テーブル駆動テストは、Goで複数のシナリオを効率的にテストするための標準的なアプローチです。t.Parallel()を使用して並列実行を組み合わせることで、特にI/Oバウンドの操作ではテストスイートの実行時間を大幅に短縮できます。

ただし、並列テストは競合条件やテストの分離に関する一意の課題をもたらし、注意深く対処する必要があります。

Goでの並列テーブル駆動テスト - golang競合条件

並列テスト実行の理解

Goのtestingパッケージは、t.Parallel()メソッドを通じて並列テスト実行のための組み込みサポートを提供しています。テストがt.Parallel()を呼び出すと、テストランナーにこのテストが他の並列テストと安全に並列して実行できるという信号が送られます。これは、特に多くの独立したテストケースを同時に実行できるテーブル駆動テストと組み合わせて非常に強力です。

デフォルトの並列性はGOMAXPROCSで制御され、通常はあなたのマシン上のCPUコアの数と等しくなります。-parallelフラグを使用してこれを調整できます:go test -parallel 4は、CPUの数に関係なく並列テストを4つに制限します。これはリソース使用量を制御したり、テストに特定の並列性の要件がある場合に非常に役立ちます。

Goテストに初めて触れる開発者にとって、基礎の理解は非常に重要です。Goユニットテストのベストプラクティスガイドでは、テーブル駆動テスト、サブテスト、並列実行の基礎となるtestingパッケージの基本が説明されています。

基本的な並列テーブル駆動テストパターン

並列テーブル駆動テストの正しいパターンは以下の通りです:

func TestCalculate(t *testing.T) {
    tests := []struct {
        name     string
        a, b     int
        op       string
        expected int
        wantErr  bool
    }{
        {"addition", 2, 3, "+", 5, false},
        {"subtraction", 5, 3, "-", 2, false},
        {"multiplication", 4, 3, "*", 12, false},
        {"division", 10, 2, "/", 5, false},
        {"division by zero", 10, 0, "/", 0, true},
    }

    for _, tt := range tests {
        tt := tt // ループ変数をキャプチャ
        t.Run(tt.name, func(t *testing.T) {
            t.Parallel() // 並列実行を有効にする
            result, err := Calculate(tt.a, tt.b, tt.op)
            
            if (err != nil) != tt.wantErr {
                t.Errorf("Calculate() error = %v, wantErr %v", err, tt.wantErr)
                return
            }
            
            if result != tt.expected {
                t.Errorf("Calculate(%d, %d, %q) = %d; want %d", 
                    tt.a, tt.b, tt.op, result, tt.expected)
            }
        })
    }
}

重要な行はt.Run()の前にtt := ttです。これはループ変数をキャプチャし、各並列サブテストがテストケースデータのコピーを使用することを保証します。

ループ変数のキャプチャ問題

t.Parallel()とテーブル駆動テストを使用する際の最も一般的な落とし穴の一つです。Goでは、ループ変数ttがすべてのイテレーションで共有されます。サブテストが並列して実行される場合、すべてが同じtt変数を参照する可能性があり、ループが継続するにつれてこの変数が上書きされます。これにより、競合条件や予測不能なテスト失敗が生じます。

誤った方法（競合条件）:

for _, tt := range tests {
    t.Run(tt.name, func(t *testing.T) {
        t.Parallel()
        // すべてのサブテストが同じtt値を参照する可能性がある！
        result := Calculate(tt.a, tt.b, tt.op)
    })
}

正しい方法（キャプチャされた変数）:

for _, tt := range tests {
    tt := tt // ループ変数をキャプチャ
    t.Run(tt.name, func(t *testing.T) {
        t.Parallel()
        // 各サブテストがttのコピーを使用する
        result := Calculate(tt.a, tt.b, tt.op)
    })
}

tt := ttの代入は、ループイテレーションにスコープされた新しい変数を作成し、各ゴルーチンがテストケースデータのコピーを使用することを保証します。

テストの独立性の確保

並列テストが正しく動作するためには、各テストが完全に独立している必要があります。以下のようなことは避けてください:

グローバルな状態や変数を共有する
同期なしに共有リソースを変更する
実行順序に依存する
協調なしに同じファイル、データベース、ネットワークリソースにアクセスする

独立した並列テストの例:

func TestValidateEmail(t *testing.T) {
    tests := []struct {
        name    string
        email   string
        wantErr bool
    }{
        {"valid email", "user@example.com", false},
        {"invalid format", "not-an-email", true},
        {"missing domain", "user@", true},
    }

    for _, tt := range tests {
        tt := tt
        t.Run(tt.name, func(t *testing.T) {
            t.Parallel()
            err := ValidateEmail(tt.email)
            if (err != nil) != tt.wantErr {
                t.Errorf("ValidateEmail(%q) error = %v, wantErr %v", 
                    tt.email, err, tt.wantErr)
            }
        })
    }
}

各テストケースは共有状態を持たず、並列実行に安全です。

レース条件の検出

Goは並列テストでデータレースを検出するための強力なレース検出器を提供しています。開発中は常に-raceフラグを使用して並列テストを実行してください:

go test -race ./...

レース検出器は、適切な同期なしに共有メモリへの同時アクセスを報告します。これは、特定のタイミング条件下でしか現れない微妙なバグを検出するため非常に重要です。

レース条件の例:

var counter int // 共有状態 - 危険！

func TestIncrement(t *testing.T) {
    tests := []struct {
        name string
        want int
    }{
        {"test1", 1},
        {"test2", 2},
    }

    for _, tt := range tests {
        tt := tt
        t.Run(tt.name, func(t *testing.T) {
            t.Parallel()
            counter++ // レース条件！
            if counter != tt.want {
                t.Errorf("counter = %d, want %d", counter, tt.want)
            }
        })
    }
}

これを-raceで実行すると、counterの同時変更が検出されます。解決策は、共有状態ではなくローカル変数を使用して各テストを独立させる方法です。

パフォーマンス上の利点

並列実行はテストスイートの実行時間を大幅に短縮する可能性があります。速度向上は以下の要因に依存します:

CPUコアの数: より多くのコアは同時に多くのテストを実行可能
テストの特性: I/OバウンドテストはCPUバウンドテストより多くの利点
テスト数: テストスイートが大きいほど、絶対的な時間の節約が大きくなる

パフォーマンスの測定:

# 逐次実行
go test -parallel 1 ./...

# 並列実行（デフォルト）
go test ./...

# カスタム並列性
go test -parallel 8 ./...

多くのI/O操作（データベースクエリ、HTTPリクエスト、ファイル操作）があるテストスイートでは、現代のマルチコアシステムで2〜4倍の速度向上が達成できます。CPUバウンドテストでは、CPUリソースの競合により恩恵が少なくなることがあります。

並列性の制御

並列テスト実行を制御するにはいくつかのオプションがあります:

1. 最大並列テスト数の制限:

go test -parallel 4 ./...

2. GOMAXPROCSの設定:

GOMAXPROCS=2 go test ./...

3. 選択的な並列実行:

特定のテストにのみt.Parallel()をマークします。この呼び出しがないテストは逐次実行され、一部のテストが順序で実行されたりリソースを共有する必要がある場合に有用です。

4. 条件付き並列実行:

func TestExpensive(t *testing.T) {
    if testing.Short() {
        t.Skip("short modeで高コストテストをスキップ")
    }
    t.Parallel()
    // 高コストテストのロジック
}

一般的なパターンとベストプラクティス

パターン1: 並列実行前のセットアップ

すべてのテストケースに共通するセットアップが必要な場合は、ループの前に実行します:

func TestWithSetup(t *testing.T) {
    // 並列実行前のセットアップコード
    db := setupTestDatabase(t)
    defer db.Close()

    tests := []struct {
        name string
        id   int
    }{
        {"user1", 1},
        {"user2", 2},
    }

    for _, tt := range tests {
        tt := tt
        t.Run(tt.name, func(t *testing.T) {
            t.Parallel()
            // 各テストはdbを使用
            user := db.GetUser(tt.id)
            // テストロジック...
        })
    }
}

パターン2: テストごとのセットアップ

孤立したセットアップが必要な場合は、各サブテスト内で実行します:

func TestWithPerTestSetup(t *testing.T) {
    tests := []struct {
        name string
        data string
    }{
        {"test1", "data1"},
        {"test2", "data2"},
    }

    for _, tt := range tests {
        tt := tt
        t.Run(tt.name, func(t *testing.T) {
            t.Parallel()
            // 各テストが独自のセットアップを取得
            tempFile := createTempFile(t, tt.data)
            defer os.Remove(tempFile)
            // テストロジック...
        })
    }
}

パターン3: 逐次と並列の混合

同じファイル内で逐次と並列のテストを混在させることができます:

func TestSequential(t *testing.T) {
    // t.Parallel()がない - 逐次実行
    // 他のテストが順序で実行される必要がある場合に良い
}

func TestParallel(t *testing.T) {
    tests := []struct{ name string }{{"test1"}, {"test2"}}
    for _, tt := range tests {
        tt := tt
        t.Run(tt.name, func(t *testing.T) {
            t.Parallel() // これらは並列で実行される
        })
    }
}

並列実行を使用しないべきケース

並列実行は常に適切ではありません。以下のケースでは避けてください:

テストが状態を共有する: グローバル変数、シングルトン、または共有リソース
テストが共有ファイルを変更する: 一時ファイル、テストデータベース、または設定ファイル
テストが実行順序に依存する: 一部のテストが他のテストの前に実行される必要がある
テストがすでに高速な場合: 並列化のオーバーヘッドが利益を上回る可能性がある
リソース制約: 並列化されたテストがメモリやCPUを過剰に使用する場合

データベース関連のテストでは、トランザクションロールバックやテストごとに別のデータベースを使用することを検討してください。Goでのマルチテナントデータベースパターンガイドでは、並列テストと相性の良い分離戦略が説明されています。

高度な: 並列コードのテスト

並列コード自体（テストを並列で実行することではなく）をテストするには、追加の技術が必要です:

func TestConcurrentOperation(t *testing.T) {
    tests := []struct {
        name      string
        goroutines int
    }{
        {"2 goroutines", 2},
        {"10 goroutines", 10},
        {"100 goroutines", 100},
    }

    for _, tt := range tests {
        tt := tt
        t.Run(tt.name, func(t *testing.T) {
            t.Parallel()
            
            var wg sync.WaitGroup
            results := make(chan int, tt.goroutines)
            
            for i := 0; i < tt.goroutines; i++ {
                wg.Add(1)
                go func() {
                    defer wg.Done()
                    results <- performOperation()
                }()
            }
            
            wg.Wait()
            close(results)
            
            // 結果を検証
            count := 0
            for range results {
                count++
            }
            if count != tt.goroutines {
                t.Errorf("expected %d results, got %d", tt.goroutines, count)
            }
        })
    }
}

このようなテストは常に-raceフラグで実行し、テストコード内のデータレースを検出する必要があります。

CI/CDとの統合

並列テストはCI/CDパイプラインとシームレスに統合できます。ほとんどのCIシステムは複数のCPUコアを提供しており、並列実行は非常に有益です:

# GitHub Actionsの例
- name: テストを実行
  run: |
    go test -race -coverprofile=coverage.out -parallel 4 ./...
    go tool cover -html=coverage.out -o coverage.html

-raceフラグは特にCIで、ローカル開発では見られない並列性のバグを検出するために非常に重要です。

並列テスト失敗のデバッグ

並列テストが間歇的に失敗する場合、デバッグは困難です:

-raceフラグで実行: データレースを特定
並列性を減らす: go test -parallel 1で失敗が消えるか確認
特定のテストを実行: go test -run TestNameで問題を特定
ロギングを追加: t.Log()で実行順序を追跡
共有状態を確認: グローバル変数、シングルトン、または共有リソースを確認

テストが逐次実行では成功するが並列実行では失敗する場合、競合条件または共有状態の問題がある可能性があります。

実際の例: HTTPハンドラのテスト

HTTPハンドラを並列でテストする実用的な例です:

func TestHTTPHandlers(t *testing.T) {
    router := setupRouter()
    
    tests := []struct {
        name       string
        method     string
        path       string
        statusCode int
    }{
        {"GET users", "GET", "/users", 200},
        {"GET user by ID", "GET", "/users/1", 200},
        {"POST user", "POST", "/users", 201},
        {"DELETE user", "DELETE", "/users/1", 204},
    }

    for _, tt := range tests {
        tt := tt
        t.Run(tt.name, func(t *testing.T) {
            t.Parallel()
            
            req := httptest.NewRequest(tt.method, tt.path, nil)
            w := httptest.NewRecorder()
            
            router.ServeHTTP(w, req)
            
            if w.Code != tt.statusCode {
                t.Errorf("expected status %d, got %d", tt.statusCode, w.Code)
            }
        })
    }
}

各テストはhttptest.NewRecorder()を使用し、これは孤立した応答レコーダーを作成し、並列実行に安全です。

結論

Goでのテーブル駆動テストの並列実行は、テストスイートの実行時間を短縮する強力な技術です。成功の鍵はループ変数のキャプチャ要件の理解、テストの独立性の確保、およびレース検出器を使用して並列性の問題を早期に検出することです。

覚えておいてください:

すべてのtt := ttでループ変数をキャプチャし、t.Parallel()の前に
テストが共有状態を持たず独立していることを確認
開発中は-raceフラグでテストを実行
必要に応じて-parallelフラグで並列性を制御
リソースを共有するテストでは並列実行を避ける

これらの実践に従うことで、テストスイートを高速化しつつ信頼性を保つことができます。より詳しいGoテストパターンについては、Goユニットテストガイドを参照してください。これはテーブル駆動テスト、モック、およびその他の必須テスト技術をカバーしています。

より大きなGoアプリケーションを構築する際、これらのテスト実践はさまざまなドメインに適用されます。たとえば、CobraとViperを使用したGo CLIアプリケーションの構築では、コマンドハンドラや設定解析のテストに類似した並列テストパターンを使用します。