fix

Author: lukaszcl

tools/flakeguard/runner/runner.go

@@ -77,7 +77,7 @@ func (r *Runner) RunTestPackages(packages []string) (*reports.TestReport, error)
 	}
 
 	// Parse initial results.
-	results, err := r.parseTestResults(jsonFilePaths)
+	results, err := r.parseTestResults(jsonFilePaths, "run")
 	if err != nil {
 		return nil, fmt.Errorf("failed to parse test results: %w", err)
 	}
@@ -124,7 +124,7 @@ func (r *Runner) RunTestCmd(testCmd []string) (*reports.TestReport, error) {
 		}
 	}
 
-	results, err := r.parseTestResults(jsonFilePaths)
+	results, err := r.parseTestResults(jsonFilePaths, "run")
 	if err != nil {
 		return nil, fmt.Errorf("failed to parse test results: %w", err)
 	}
@@ -300,7 +300,7 @@ func (e entry) String() string {
 // panics and failures at that point.
 // Subtests add more complexity, as panics in subtests are only reported in their parent's output,
 // and cannot be accurately attributed to the subtest that caused them.
-func (r *Runner) parseTestResults(filePaths []string) ([]reports.TestResult, error) {
+func (r *Runner) parseTestResults(filePaths []string, runPrefix string) ([]reports.TestResult, error) {
 	// If the option is enabled, transform each JSON output file before parsing.
 	if r.IgnoreParentFailuresOnSubtests {
 		transformedPaths, err := r.transformTestOutputFiles(filePaths)
@@ -326,7 +326,7 @@ func (r *Runner) parseTestResults(filePaths []string) ([]reports.TestResult, err
 	// Process each file
 	for _, filePath := range filePaths {
 		runNumber++
-		runID := fmt.Sprintf("run%d", runNumber)
+		runID := fmt.Sprintf("%s%d", runPrefix, runNumber)
 		file, err := os.Open(filePath)
 		if err != nil {
 			return nil, fmt.Errorf("failed to open test output file: %w", err)
@@ -763,7 +763,7 @@ func (r *Runner) rerunFailedTests(results []reports.TestResult) ([]reports.TestR
 				return nil, fmt.Errorf("error on rerunCmd for test %s: %w", fTest.TestName, err)
 			}
 
-			additionalResults, err := r.parseTestResults([]string{jsonFilePath})
+			additionalResults, err := r.parseTestResults([]string{jsonFilePath}, "rerun")
 			if err != nil {
 				return nil, fmt.Errorf("failed to parse rerun results: %w", err)
 			}
@@ -796,16 +796,7 @@ func (r *Runner) buildGoTestCommandForTest(t reports.TestResult) []string {
 	return cmd
 }
 
-// appendUnique appends s to slice if not already present.
-func appendUnique(slice []string, s string) []string {
-	for _, v := range slice {
-		if v == s {
-			return slice
-		}
-	}
-	return append(slice, s)
-}
-
+// mergeTestResults merges additional test results into the existing results slice.
 // mergeTestResults merges additional test results into the existing results slice.
 func mergeTestResults(mainResults *[]reports.TestResult, additional []reports.TestResult) {
 	for _, add := range additional {
@@ -821,9 +812,21 @@ func mergeTestResults(mainResults *[]reports.TestResult, additional []reports.Te
 				// Merge durations
 				(*mainResults)[i].Durations = append((*mainResults)[i].Durations, add.Durations...)
 
-				// Because PassedOutputs and FailedOutputs are now []string:
-				(*mainResults)[i].PassedOutputs = append((*mainResults)[i].PassedOutputs, add.PassedOutputs...)
-				(*mainResults)[i].FailedOutputs = append((*mainResults)[i].FailedOutputs, add.FailedOutputs...)
+				// Merge maps for PassedOutputs
+				if (*mainResults)[i].PassedOutputs == nil {
+					(*mainResults)[i].PassedOutputs = make(map[string][]string)
+				}
+				for runID, outputs := range add.PassedOutputs {
+					(*mainResults)[i].PassedOutputs[runID] = append((*mainResults)[i].PassedOutputs[runID], outputs...)
+				}
+
+				// Merge maps for FailedOutputs
+				if (*mainResults)[i].FailedOutputs == nil {
+					(*mainResults)[i].FailedOutputs = make(map[string][]string)
+				}
+				for runID, outputs := range add.FailedOutputs {
+					(*mainResults)[i].FailedOutputs[runID] = append((*mainResults)[i].FailedOutputs[runID], outputs...)
+				}
 
 				// Update pass ratio
 				if (*mainResults)[i].Runs > 0 {

tools/flakeguard/runner/runner_test.go

@@ -537,6 +537,68 @@ func TestFailedOutputs(t *testing.T) {
 	}
 }
 
+func TestRerunFailed(t *testing.T) {
+	t.Parallel()
+
+	// Configure a runner that will rerun failed tests
+	runner := Runner{
+		ProjectPath:      "./",
+		Verbose:          true,
+		RunCount:         2,                    // Run tests twice initially
+		RerunFailed:      3,                    // Rerun failing tests 3 more times
+		SelectTests:      []string{"TestFail"}, // This test is known to always fail
+		CollectRawOutput: true,
+	}
+
+	testReport, err := runner.RunTestPackages([]string{flakyTestPackagePath})
+	require.NoError(t, err, "running tests should not produce an unexpected error")
+
+	// Verify we have the expected number of results
+	require.Equal(t, 1, len(testReport.Results), "expected exactly one test result")
+
+	// Find the TestFail result
+	var testFailResult *reports.TestResult
+	for i := range testReport.Results {
+		if testReport.Results[i].TestName == "TestFail" {
+			testFailResult = &testReport.Results[i]
+			break
+		}
+	}
+	require.NotNil(t, testFailResult, "expected TestFail result not found in report")
+
+	// TestFail should have run 5 times (2 initial + 3 reruns)
+	require.Equal(t, 5, testFailResult.Runs, "TestFail should have run 5 times (2 initial + 3 reruns)")
+
+	// Verify that we have outputs from failed runs
+	require.NotEmpty(t, testFailResult.FailedOutputs, "expected failed outputs for TestFail")
+	require.Empty(t, testFailResult.PassedOutputs, "TestFail should have no passed outputs")
+
+	// We should have outputs from both run and rerun prefixes
+	hasRunOutput := false
+	hasRerunOutput := false
+
+	// Check if we have outputs from both original runs and reruns
+	for runID := range testFailResult.FailedOutputs {
+		t.Logf("Found failed outputs for run %s", runID)
+		if strings.HasPrefix(runID, "run") {
+			hasRunOutput = true
+		} else if strings.HasPrefix(runID, "rerun") {
+			hasRerunOutput = true
+		}
+	}
+
+	require.True(t, hasRunOutput, "expected outputs from initial runs")
+	require.True(t, hasRerunOutput, "expected outputs from reruns")
+
+	// Check that the PassRatio is 0 (since TestFail always fails)
+	require.Equal(t, 0.0, testFailResult.PassRatio, "TestFail should have a pass ratio of 0.0")
+
+	// Verify that the test ran exactly 5 times and all were failures
+	require.Equal(t, 5, testFailResult.Failures, "TestFail should have failed 5 times")
+	require.Equal(t, 0, testFailResult.Successes, "TestFail should have passed 0 times")
+	require.Equal(t, 5, testFailResult.Successes+testFailResult.Failures, "total of successes and failures should equal 5")
+}
+
 func TestSkippedTests(t *testing.T) {
 	t.Parallel()