Function TestGenerateParallelErrorHandling

codegen/generator/generate_merge_test.go:210–250

TestGenerateParallelErrorHandling verifies that when file rendering fails in the parallel worker pool, the first error is captured and returned while other workers continue processing.

(t *testing.T)

// in the parallel worker pool, the first error is captured and returned while
// other workers continue processing.
func TestGenerateParallelErrorHandling(t *testing.T) {
	t.Cleanup(func() { Generators = generators })

	// Create multiple files where some will fail to render due to invalid paths.
	// Worker pool should capture first error but continue processing other files.
	Generators = func(cmd string) ([]Genfunc, error) {
		return []Genfunc{
			func(genpkg string, roots []eval.Root) ([]*codegen.File, error) {
				files := make([]*codegen.File, 5)
				for i := 0; i < 5; i++ {
					f := &codegen.File{
						Path: filepath.Join(codegen.Gendir, "types", "file"+string(rune('0'+i))+".go"),
					}
					f.SectionTemplates = []*codegen.SectionTemplate{
						codegen.Header("Types", "types", nil),
						{Name: "type", Source: "type T" + string(rune('0'+i)) + " struct{}\n"},
					}
					// Make file 2 fail by adding an invalid path character after writing starts
					if i == 2 {
						// Use a FinalizeFunc that returns an error
						f.FinalizeFunc = func(fp string) error {
							return os.ErrInvalid
						}
					}
					files[i] = f
				}
				return files, nil
			},
		}, nil
	}

	dir := t.TempDir()
	_, err := Generate(dir, "gen", false)
	if err == nil {
		t.Fatal("expected error from parallel generation, got nil")
	}
	// Verify we got an error (the first one encountered)
	if !strings.Contains(err.Error(), "invalid") && !strings.Contains(err.Error(), "finalize") {
		t.Fatalf("unexpected error message: %v", err)
	}
}

// TestGenerateParallelSingleFile verifies that parallel file writing works
// correctly with just a single file (minimal parallelism edge case).