Fix

Author: lukaszcl

tools/flakeguard/reports/data.go

@@ -63,13 +63,15 @@ func GenerateSummaryData(tests []TestResult, maxPassRatio float64) SummaryData {
 		passes += result.Successes
 		fails += result.Failures
 		skips += result.Skips
+
 		if result.Panic {
 			panickedTests++
 			flakyTests++
 		} else if result.Race {
 			racedTests++
 			flakyTests++
-		} else if result.PassRatio < maxPassRatio {
+		} else if !result.Skipped && result.Runs > 0 && result.PassRatio < maxPassRatio {
+			// Exclude skipped tests and tests with no runs
 			flakyTests++
 		}
 	}
@@ -82,12 +84,14 @@ func GenerateSummaryData(tests []TestResult, maxPassRatio float64) SummaryData {
 		passPercentage = math.Round((float64(passes)/float64(runs)*100)*100) / 100
 		averagePassRatio = float64(passes) / float64(runs)
 	}
-	if len(tests) > 0 {
-		flakePercentage = math.Round((float64(flakyTests)/float64(len(tests))*100)*100) / 100
+	totalTests := len(tests)                 // Include skipped tests in total tests
+	totalExecutedTests := totalTests - skips // Tests that were actually executed
+	if totalExecutedTests > 0 {
+		flakePercentage = math.Round((float64(flakyTests)/float64(totalExecutedTests)*100)*100) / 100
 	}
 
 	return SummaryData{
-		TotalTests:       len(tests),
+		TotalTests:       totalTests,
 		PanickedTests:    panickedTests,
 		RacedTests:       racedTests,
 		FlakyTests:       flakyTests,
@@ -184,7 +188,7 @@ func mergeTestResults(a, b TestResult) TestResult {
 	if a.Runs > 0 {
 		a.PassRatio = float64(a.Successes) / float64(a.Runs)
 	} else {
-		a.PassRatio = 0.0
+		a.PassRatio = -1.0 // Indicate undefined pass ratio for skipped tests
 	}
 
 	return a

tools/flakeguard/reports/data_test.go

@@ -388,7 +388,7 @@ func TestAggregate_AllSkippedTests(t *testing.T) {
 				Skipped:     true,
 				Runs:        0,
 				Skips:       3,
-				PassRatio:   0.0, // Or set to -1 to indicate undefined
+				PassRatio:   -1, // 1 indicate undefined
 			},
 		},
 	}
@@ -403,7 +403,7 @@ func TestAggregate_AllSkippedTests(t *testing.T) {
 				Skipped:     true,
 				Runs:        0,
 				Skips:       2,
-				PassRatio:   0.0,
+				PassRatio:   -1,
 			},
 		},
 	}
@@ -419,7 +419,7 @@ func TestAggregate_AllSkippedTests(t *testing.T) {
 		Skipped:     true,
 		Runs:        0,
 		Skips:       5,
-		PassRatio:   0.0,
+		PassRatio:   -1,
 	}
 
 	if len(aggregatedReport.Results) != 1 {

tools/flakeguard/reports/presentation.go

@@ -10,14 +10,15 @@ import (
 	"golang.org/x/text/message"
 )
 
-func GenerateResultsTable(
+func GenerateFlakyTestsTable(
 	results []TestResult,
 	expectedPassRatio float64,
 	markdown bool,
 ) [][]string {
 	p := message.NewPrinter(language.English)
 	sortTestResults(results)
 
+	// Headers in the requested order
 	headers := []string{
 		"Name",
 		"Pass Ratio",
@@ -34,18 +35,22 @@ func GenerateResultsTable(
 		"Code Owners",
 	}
 
+	// Format headers for Markdown if needed
 	if markdown {
 		for i, header := range headers {
 			headers[i] = fmt.Sprintf("**%s**", header)
 		}
 	}
 
+	// Initialize the table with headers
 	table := [][]string{headers}
+
 	for _, result := range results {
-		if result.PassRatio < expectedPassRatio {
+		// Exclude skipped tests and only include tests below the expected pass ratio
+		if !result.Skipped && result.PassRatio < expectedPassRatio {
 			row := []string{
 				result.TestName,
-				fmt.Sprintf("%.2f%%", result.PassRatio*100),
+				formatPassRatio(result.PassRatio),
 				fmt.Sprintf("%t", result.Panic),
 				fmt.Sprintf("%t", result.Timeout),
 				fmt.Sprintf("%t", result.Race),
@@ -58,7 +63,7 @@ func GenerateResultsTable(
 				avgDuration(result.Durations).String(),
 			}
 
-			// Code owners
+			// Add code owners
 			owners := "Unknown"
 			if len(result.CodeOwners) > 0 {
 				owners = strings.Join(result.CodeOwners, ", ")
@@ -71,6 +76,13 @@ func GenerateResultsTable(
 	return table
 }
 
+func formatPassRatio(passRatio float64) string {
+	if passRatio < 0 {
+		return "N/A" // Handle undefined pass ratios (e.g., skipped tests)
+	}
+	return fmt.Sprintf("%.2f%%", passRatio*100)
+}
+
 func GenerateMarkdownSummary(w io.Writer, testReport *TestReport, maxPassRatio float64) {
 	settingsTable := buildSettingsTable(testReport, maxPassRatio)
 	fmt.Fprint(w, "# Flakeguard Summary\n\n")
@@ -115,7 +127,7 @@ func RenderResults(
 	maxPassRatio float64,
 	markdown bool,
 ) {
-	resultsTable := GenerateResultsTable(tests, maxPassRatio, markdown)
+	resultsTable := GenerateFlakyTestsTable(tests, maxPassRatio, markdown)
 	summary := GenerateSummaryData(tests, maxPassRatio)
 	renderSummaryTable(w, summary, markdown)
 	renderTestResultsTable(w, resultsTable, markdown)

tools/flakeguard/reports/presentation_test.go

@@ -8,91 +8,66 @@ import (
 	"time"
 )
 
-// TestGenerateResultsTable tests the GenerateResultsTable function.
-func TestGenerateResultsTable(t *testing.T) {
-	testResults := []TestResult{
+func TestGenerateFlakyTestsTable(t *testing.T) {
+	results := []TestResult{
 		{
-			TestName:     "TestA",
-			PassRatio:    0.8,
-			Panic:        false,
-			Timeout:      false,
-			Race:         false,
-			Runs:         5,
-			Successes:    4,
-			Failures:     1,
-			Skips:        0,
-			TestPackage:  "pkg1",
-			PackagePanic: false,
-			Durations:    []time.Duration{time.Second, time.Second, time.Second, time.Second, time.Second},
-			CodeOwners:   []string{"owner1"},
+			TestName:    "TestFlaky",
+			PassRatio:   0.5,
+			Skipped:     false,
+			Runs:        2,
+			Successes:   1,
+			Failures:    1,
+			TestPackage: "pkg1",
+			CodeOwners:  []string{"owner1"},
 		},
 		{
-			TestName:     "TestB",
-			PassRatio:    1.0,
-			Panic:        false,
-			Timeout:      false,
-			Race:         false,
-			Runs:         3,
-			Successes:    3,
-			Failures:     0,
-			Skips:        0,
-			TestPackage:  "pkg2",
-			PackagePanic: false,
-			Durations:    []time.Duration{2 * time.Second, 2 * time.Second, 2 * time.Second},
-			CodeOwners:   []string{"owner2"},
+			TestName:    "TestSkipped",
+			PassRatio:   -1.0,
+			Skipped:     true,
+			Runs:        0,
+			Skips:       1,
+			TestPackage: "pkg2",
+			CodeOwners:  []string{"owner2"},
 		},
 	}
 
 	expectedPassRatio := 0.9
 	markdown := false
 
-	table := GenerateResultsTable(testResults, expectedPassRatio, markdown)
-
-	// Only TestA should be included since its PassRatio is below 0.9
-	if len(table) != 2 {
-		t.Fatalf("Expected table length 2 (headers + 1 row), got %d", len(table))
-	}
+	table := GenerateFlakyTestsTable(results, expectedPassRatio, markdown)
 
 	// Verify headers
-	headers := table[0]
 	expectedHeaders := []string{
-		"Name",
-		"Pass Ratio",
-		"Panicked?",
-		"Timed Out?",
-		"Race?",
-		"Runs",
-		"Successes",
-		"Failures",
-		"Skips",
-		"Package",
-		"Package Panicked?",
-		"Avg Duration",
-		"Code Owners",
+		"Name", "Pass Ratio", "Panicked?", "Timed Out?", "Race?", "Runs",
+		"Successes", "Failures", "Skips", "Package", "Package Panicked?",
+		"Avg Duration", "Code Owners",
 	}
-	if !reflect.DeepEqual(headers, expectedHeaders) {
-		t.Errorf("Expected headers %+v, got %+v", expectedHeaders, headers)
+	if !reflect.DeepEqual(table[0], expectedHeaders) {
+		t.Errorf("Expected headers %+v, got %+v", expectedHeaders, table[0])
+	}
+
+	// Verify rows (only TestFlaky should appear)
+	if len(table) != 2 { // 1 header row + 1 data row
+		t.Fatalf("Expected table length 2 (headers + 1 row), got %d", len(table))
 	}
 
-	// Verify row data
-	row := table[1]
 	expectedRow := []string{
-		"TestA",
-		"80.00%",
+		"TestFlaky",
+		"50.00%",
 		"false",
 		"false",
 		"false",
-		"5",
-		"4",
+		"2",
+		"1",
 		"1",
 		"0",
 		"pkg1",
 		"false",
-		"1s",
+		"0s",
 		"owner1",
 	}
-	if !reflect.DeepEqual(row, expectedRow) {
-		t.Errorf("Expected row %+v, got %+v", expectedRow, row)
+	if !reflect.DeepEqual(table[1], expectedRow) {
+		t.Errorf("Expected row %+v, got %+v", expectedRow, table[1])
 	}
 }