Add codeowners to aggregated results

Author: lukaszcl

seth/contract_store.go

@@ -42,16 +42,16 @@ func (c *ContractStore) GetABI(name string) (*abi.ABI, bool) {
 
 	abi, ok := c.ABIs[name]
 	return &abi, ok
-}
+}g
 
 func (c *ContractStore) GetAllABIs() []*abi.ABI {
 	c.mu.Lock()
 	defer c.mu.Unlock()
 
 	var allABIs []*abi.ABI
 	for _, a := range c.ABIs {
-		aCopy := a //nolint
-		allABIs = append(allABIs, &aCopy)
+		alias := a
+		allABIs = append(allABIs, &alias)
 	}
 
 	return allABIs

tools/flakeguard/cmd/aggregate_results.go

@@ -11,6 +11,8 @@ var (
 	resultsFolderPath string
 	outputResultsPath string
 	outputLogsPath    string
+	codeOwnersPath    string
+	projectPath       string
 	maxPassRatio      float64
 	filterFailed      bool
 )
@@ -24,6 +26,20 @@ var AggregateResultsCmd = &cobra.Command{
 			log.Fatalf("Error aggregating results: %v", err)
 		}
 
+		// Map test results to paths
+		err = reports.MapTestResultsToPaths(allReport, projectPath)
+		if err != nil {
+			log.Fatalf("Error mapping test results to paths: %v", err)
+		}
+
+		// Map test results to owners if CODEOWNERS path is provided
+		if codeOwnersPath != "" {
+			err = reports.MapTestResultsToOwners(allReport, codeOwnersPath)
+			if err != nil {
+				log.Fatalf("Error mapping test results to owners: %v", err)
+			}
+		}
+
 		var resultsToSave []reports.TestResult
 
 		if filterFailed {
@@ -52,4 +68,7 @@ func init() {
 	AggregateResultsCmd.Flags().StringVarP(&outputLogsPath, "output-logs", "l", "", "Path to output the filtered test logs in JSON format")
 	AggregateResultsCmd.Flags().Float64VarP(&maxPassRatio, "max-pass-ratio", "m", 1.0, "The maximum (non-inclusive) pass ratio threshold for a test to be considered a failure. Any tests below this pass rate will be considered flaky.")
 	AggregateResultsCmd.Flags().BoolVarP(&filterFailed, "filter-failed", "f", false, "If true, filter and output only failed tests based on the max-pass-ratio threshold")
+	AggregateResultsCmd.Flags().StringVarP(&codeOwnersPath, "codeowners-path", "c", "", "Path to the CODEOWNERS file")
+	AggregateResultsCmd.Flags().StringVarP(&projectPath, "project-path", "r", ".", "The path to the Go project. Default is the current directory. Useful for subprojects")
+
 }

tools/flakeguard/codeowners/parser.go

@@ -0,0 +1,63 @@
+package codeowners
+
+import (
+	"bufio"
+	"os"
+	"path/filepath"
+	"regexp"
+	"strings"
+)
+
+// PatternOwner maps a file pattern to its owners
+type PatternOwner struct {
+	Pattern string
+	Owners  []string
+}
+
+// Parse reads the CODEOWNERS file and returns a list of PatternOwner
+func Parse(filePath string) ([]PatternOwner, error) {
+	file, err := os.Open(filePath)
+	if err != nil {
+		return nil, err
+	}
+	defer file.Close()
+
+	var patterns []PatternOwner
+	scanner := bufio.NewScanner(file)
+	commentPattern := regexp.MustCompile(`^\s*#`)
+
+	for scanner.Scan() {
+		line := strings.TrimSpace(scanner.Text())
+		if line == "" || commentPattern.MatchString(line) {
+			continue
+		}
+
+		fields := strings.Fields(line)
+		if len(fields) > 1 {
+			patterns = append(patterns, PatternOwner{
+				Pattern: fields[0],
+				Owners:  fields[1:],
+			})
+		}
+	}
+	return patterns, scanner.Err()
+}
+
+// FindOwners determines the owners for a given file path based on patterns
+func FindOwners(filePath string, patterns []PatternOwner) []string {
+	// Convert filePath to Unix-style for matching
+	relFilePath := filepath.ToSlash(filePath)
+
+	var matchedOwners []string
+	for _, pattern := range patterns {
+		// Ensure the pattern is also converted to Unix-style
+		patternPath := strings.TrimPrefix(pattern.Pattern, "/")
+		patternPath = strings.TrimSuffix(patternPath, "/")
+
+		// Match if the file is in the directory or is an exact match
+		if strings.HasPrefix(relFilePath, patternPath) || relFilePath == patternPath {
+			matchedOwners = pattern.Owners
+		}
+	}
+	return matchedOwners
+}

tools/flakeguard/reports/codebase_scanner.go

@@ -0,0 +1,50 @@
+package reports
+
+import (
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"os"
+	"path/filepath"
+	"strings"
+)
+
+// TestFileMap maps test function names to their file paths.
+type TestFileMap map[string]string
+
+// ScanTestFiles scans the codebase for test functions and maps them to file paths.
+func ScanTestFiles(rootDir string) (TestFileMap, error) {
+	testFileMap := make(TestFileMap)
+
+	err := filepath.Walk(rootDir, func(path string, info os.FileInfo, err error) error {
+		if err != nil {
+			return err
+		}
+		if !strings.HasSuffix(path, "_test.go") {
+			return nil
+		}
+
+		// Parse the file
+		fset := token.NewFileSet()
+		node, err := parser.ParseFile(fset, path, nil, parser.AllErrors)
+		if err != nil {
+			return err
+		}
+
+		// Traverse the AST to find test functions
+		ast.Inspect(node, func(n ast.Node) bool {
+			funcDecl, ok := n.(*ast.FuncDecl)
+			if !ok {
+				return true
+			}
+			if strings.HasPrefix(funcDecl.Name.Name, "Test") {
+				// Add both the package and test function to the map
+				testFileMap[funcDecl.Name.Name] = path
+			}
+			return true
+		})
+		return nil
+	})
+
+	return testFileMap, err
+}

tools/flakeguard/reports/owner_mapper.go

@@ -0,0 +1,24 @@
+package reports
+
+import "github.com/smartcontractkit/chainlink-testing-framework/tools/flakeguard/codeowners"
+
+// MapTestResultsToOwners maps test results to their code owners based on the TestPath and CODEOWNERS file.
+func MapTestResultsToOwners(report *TestReport, codeOwnersPath string) error {
+	// Parse the CODEOWNERS file
+	codeOwnerPatterns, err := codeowners.Parse(codeOwnersPath)
+	if err != nil {
+		return err
+	}
+
+	// Assign owners to each test result
+	for i, result := range report.Results {
+		if result.TestPath != "NOT FOUND" {
+			report.Results[i].TestOwners = codeowners.FindOwners(result.TestPath, codeOwnerPatterns)
+		} else {
+			// Mark owners as unknown for unmapped tests
+			report.Results[i].TestOwners = []string{"UNKNOWN"}
+		}
+	}
+
+	return nil
+}

tools/flakeguard/reports/path_mapper.go

@@ -0,0 +1,47 @@
+package reports
+
+import (
+	"fmt"
+	"path/filepath"
+	"strings"
+)
+
+// MapTestResultsToPaths maps test results to their corresponding file paths.
+func MapTestResultsToPaths(report *TestReport, rootDir string) error {
+	// Scan the codebase for test functions
+	testFileMap, err := ScanTestFiles(rootDir)
+	if err != nil {
+		return err
+	}
+
+	// Assign file paths to each test result
+	for i, result := range report.Results {
+		testName := result.TestName
+		var filePath string
+
+		// Handle subtests
+		if strings.Contains(testName, "/") {
+			parentTestName := strings.SplitN(testName, "/", 2)[0] // Extract parent test
+			if path, exists := testFileMap[parentTestName]; exists {
+				filePath = path
+			}
+		} else if path, exists := testFileMap[testName]; exists {
+			// Handle normal tests
+			filePath = path
+		}
+
+		// Normalize filePath to be relative to the project root
+		if filePath != "" {
+			relFilePath, err := filepath.Rel(rootDir, filePath)
+			if err != nil {
+				return fmt.Errorf("error getting relative path: %v", err)
+			}
+			report.Results[i].TestPath = relFilePath
+		} else {
+			// Log or mark tests not found in the codebase
+			report.Results[i].TestPath = "NOT FOUND"
+		}
+	}
+
+	return nil
+}

tools/flakeguard/reports/reports.go

@@ -43,6 +43,8 @@ type TestResult struct {
 	Outputs        []string        `json:"outputs,omitempty"` // Stores outputs for a test
 	Durations      []time.Duration // Stores elapsed time for each run of the test
 	PackageOutputs []string        `json:"package_outputs,omitempty"` // Stores package-level outputs
+	TestPath       string          // Path to the test file
+	TestOwners     []string        // Owners of the test
 }
 
 // FilterFailedTests returns a slice of TestResult where the pass ratio is below the specified threshold.