DX177 - Fix flakeguard parser panic (#1683)

* Improve panic attribution logic in Flakeguard test runner

* Show "Failed Tests On The First Run" in console

Author: lukaszcl

tools/flakeguard/cmd/run.go

@@ -184,6 +184,10 @@ var RunTestsCmd = &cobra.Command{
 				flushSummaryAndExit(0)
 			}
 
+			fmt.Fprint(&summaryBuffer, "\nFailed Tests On The First Run:\n\n")
+			reports.PrintTestResultsTable(&summaryBuffer, failedTests, false, false, true, false)
+			fmt.Fprintln(&summaryBuffer)
+
 			rerunResults, rerunJsonOutputPaths, err := testRunner.RerunFailedTests(failedTests, rerunFailedCount)
 			if err != nil {
 				log.Fatal().Err(err).Msg("Error rerunning failed tests")
@@ -203,8 +207,8 @@ var RunTestsCmd = &cobra.Command{
 				flushSummaryAndExit(ErrorExitCode)
 			}
 
-			fmt.Fprint(&summaryBuffer, "\nFailed Tests That Were Rerun:\n\n")
-			reports.PrintTestResultsTable(&summaryBuffer, rerunResults, false, false, true)
+			fmt.Fprint(&summaryBuffer, "\nFailed Tests After Rerun:\n\n")
+			reports.PrintTestResultsTable(&summaryBuffer, rerunResults, false, false, true, true)
 			fmt.Fprintln(&summaryBuffer)
 
 			// Save the rerun test report to file

tools/flakeguard/reports/presentation.go

@@ -78,11 +78,18 @@ func generateTestResultsTable(
 func generateShortTestResultsTable(
 	results []TestResult,
 	markdown bool,
+	showEverPassed bool,
 	filter func(TestResult) bool,
 ) [][]string {
 	p := message.NewPrinter(language.English)
 
-	headers := []string{"Name", "Ever Passed", "Runs", "Successes", "Code Owners", "Path"}
+	// Build headers dynamically
+	var headers []string
+	headers = append(headers, "Name")
+	if showEverPassed {
+		headers = append(headers, "Ever Passed")
+	}
+	headers = append(headers, "Runs", "Successes", "Code Owners", "Path")
 
 	// Optionally format the headers for Markdown
 	if markdown {
@@ -112,14 +119,17 @@ func generateShortTestResultsTable(
 			owners = strings.Join(r.CodeOwners, ", ")
 		}
 
-		row := []string{
-			r.TestName,                   // "Name"
-			passed,                       // "Passed"
-			p.Sprintf("%d", r.Runs),      // "Runs"
-			p.Sprintf("%d", r.Successes), // "Passes"
-			owners,                       // "Code Owners"
-			r.TestPath,                   // "Path"
+		// Build row dynamically
+		row := []string{r.TestName}
+		if showEverPassed {
+			row = append(row, passed)
 		}
+		row = append(row,
+			p.Sprintf("%d", r.Runs),
+			p.Sprintf("%d", r.Successes),
+			owners,
+			r.TestPath,
+		)
 
 		table = append(table, row)
 	}
@@ -143,13 +153,14 @@ func PrintTestResultsTable(
 	results []TestResult,
 	markdown bool,
 	collapsible bool,
-	shortTable bool) {
+	shortTable bool,
+	showEverPassed bool) {
 	filter := func(result TestResult) bool {
 		return true // Include all tests
 	}
 	var table [][]string
 	if shortTable {
-		table = generateShortTestResultsTable(results, markdown, filter)
+		table = generateShortTestResultsTable(results, markdown, showEverPassed, filter)
 	} else {
 		table = generateTestResultsTable(results, markdown, filter)
 	}

tools/flakeguard/runner/runner.go

@@ -381,7 +381,11 @@ func (r *Runner) parseTestResults(jsonOutputPaths []string, runPrefix string, ru
 
 			if (panicDetectionMode || raceDetectionMode) && entryLine.Action == "fail" { // End of panic or race output
 				if panicDetectionMode {
-					panicTest, timeout, err := attributePanicToTest(entryLine.Package, detectedEntries)
+					var outputs []string
+					for _, entry := range detectedEntries {
+						outputs = append(outputs, entry.Output)
+					}
+					panicTest, timeout, err := attributePanicToTest(outputs)
 					if err != nil {
 						return nil, err
 					}
@@ -614,23 +618,23 @@ func (r *Runner) transformTestOutputFiles(filePaths []string) ([]string, error)
 }
 
 // attributePanicToTest properly attributes panics to the test that caused them.
-func attributePanicToTest(panicPackage string, panicEntries []entry) (test string, timeout bool, err error) {
-	regexSanitizePanicPackage := filepath.Base(panicPackage)
-	panicAttributionRe := regexp.MustCompile(fmt.Sprintf(`%s\.(Test[^\.\(]+)`, regexSanitizePanicPackage))
-	timeoutAttributionRe := regexp.MustCompile(`(Test.*?)\W+\(.*\)`)
-	entriesOutputs := []string{}
-	for _, entry := range panicEntries {
-		entriesOutputs = append(entriesOutputs, entry.Output)
-		if matches := panicAttributionRe.FindStringSubmatch(entry.Output); len(matches) > 1 {
+func attributePanicToTest(outputs []string) (test string, timeout bool, err error) {
+	// Regex to extract a valid test function name.
+	testNameRe := regexp.MustCompile(`(?:.*\.)?(Test[A-Z]\w+)(?:\.[^(]+)?\s*\(`)
+	// Regex to detect timeout messages (accepting "timeout", "timedout", or "timed out", case-insensitive).
+	timeoutRe := regexp.MustCompile(`(?i)(timeout|timedout|timed\s*out)`)
+	for _, o := range outputs {
+		outputs = append(outputs, o)
+		if matches := testNameRe.FindStringSubmatch(o); len(matches) > 1 {
 			testName := strings.TrimSpace(matches[1])
+			if timeoutRe.MatchString(o) {
+				return testName, true, nil
+			}
 			return testName, false, nil
 		}
-		if matches := timeoutAttributionRe.FindStringSubmatch(entry.Output); len(matches) > 1 {
-			testName := strings.TrimSpace(matches[1])
-			return testName, true, nil
-		}
 	}
-	return "", false, fmt.Errorf("failed to attribute panic to test, using regex %s on these strings:\n%s", panicAttributionRe.String(), strings.Join(entriesOutputs, ""))
+	return "", false, fmt.Errorf("failed to attribute panic to test, using regex %s on these strings:\n%s",
+		testNameRe.String(), strings.Join(outputs, ""))
 }
 
 // attributeRaceToTest properly attributes races to the test that caused them.