Add test for codeowners and cmd to find tests in go project without owners

Author: lukaszcl

tools/flakeguard/cmd/check_test_owners.go

@@ -0,0 +1,85 @@
+package cmd
+
+import (
+	"fmt"
+	"log"
+	"path/filepath"
+
+	"github.com/smartcontractkit/chainlink-testing-framework/tools/flakeguard/codeowners"
+	"github.com/smartcontractkit/chainlink-testing-framework/tools/flakeguard/reports"
+	"github.com/spf13/cobra"
+)
+
+var (
+	codeownersPath     string
+	printTestFunctions bool
+)
+
+// CheckTestOwnersCmd checks which tests lack code owners
+var CheckTestOwnersCmd = &cobra.Command{
+	Use:   "check-test-owners",
+	Short: "Check which tests in the project do not have code owners",
+	RunE: func(cmd *cobra.Command, args []string) error {
+		// Scan project for test functions
+		testFileMap, err := reports.ScanTestFiles(projectPath)
+		if err != nil {
+			log.Fatalf("Error scanning test files: %v", err)
+		}
+
+		// Parse CODEOWNERS file
+		codeOwnerPatterns, err := codeowners.Parse(codeownersPath)
+		if err != nil {
+			log.Fatalf("Error parsing CODEOWNERS file: %v", err)
+		}
+
+		// Check for tests without code owners
+		testsWithoutOwners := make(map[string]string) // Map of test names to their relative paths
+		for testName, filePath := range testFileMap {
+			relFilePath, err := filepath.Rel(projectPath, filePath)
+			if err != nil {
+				fmt.Printf("Error getting relative path for test %s: %v\n", testName, err)
+				continue
+			}
+			// Convert to Unix-style path for matching
+			relFilePath = filepath.ToSlash(relFilePath)
+
+			owners := codeowners.FindOwners(relFilePath, codeOwnerPatterns)
+			if len(owners) == 0 {
+				testsWithoutOwners[testName] = relFilePath
+			}
+		}
+
+		// Calculate percentages
+		totalTests := len(testFileMap)
+		totalWithoutOwners := len(testsWithoutOwners)
+		totalWithOwners := totalTests - totalWithoutOwners
+
+		percentageWithOwners := float64(totalWithOwners) / float64(totalTests) * 100
+		percentageWithoutOwners := float64(totalWithoutOwners) / float64(totalTests) * 100
+
+		// Report results
+		fmt.Printf("Total Test functions found: %d\n", totalTests)
+		fmt.Printf("Test functions with owners: %d (%.2f%%)\n", totalWithOwners, percentageWithOwners)
+		fmt.Printf("Test functions without owners: %d (%.2f%%)\n", totalWithoutOwners, percentageWithoutOwners)
+
+		if printTestFunctions {
+
+			if totalWithoutOwners > 0 {
+				fmt.Println("\nTest functions without owners:")
+				for testName, relPath := range testsWithoutOwners {
+					fmt.Printf("- %s (%s)\n", testName, relPath)
+				}
+			} else {
+				fmt.Println("All Test functions have code owners!")
+			}
+		}
+
+		return nil
+	},
+}
+
+func init() {
+	CheckTestOwnersCmd.Flags().StringVarP(&projectPath, "project-path", "p", ".", "Path to the root of the project")
+	CheckTestOwnersCmd.Flags().StringVarP(&codeownersPath, "codeowners-path", "c", ".github/CODEOWNERS", "Path to the CODEOWNERS file")
+	CheckTestOwnersCmd.Flags().BoolVarP(&printTestFunctions, "print-test-functions", "t", false, "Print all test functions without owners")
+}

tools/flakeguard/codeowners/parser.go

@@ -2,7 +2,9 @@ package codeowners
 
 import (
 	"bufio"
+	"fmt"
 	"os"
+	"path"
 	"path/filepath"
 	"regexp"
 	"strings"
@@ -35,29 +37,49 @@ func Parse(filePath string) ([]PatternOwner, error) {
 		fields := strings.Fields(line)
 		if len(fields) > 1 {
 			patterns = append(patterns, PatternOwner{
-				Pattern: fields[0],
+				Pattern: filepath.ToSlash(fields[0]), // Normalize to Unix-style
 				Owners:  fields[1:],
 			})
 		}
 	}
 	return patterns, scanner.Err()
 }
 
-// FindOwners determines the owners for a given file path based on patterns
+func IsWildcardPattern(pattern string) bool {
+	return strings.ContainsAny(pattern, "*?[")
+}
+
+// FindOwners finds the owners of a file based on the CODEOWNERS patterns
 func FindOwners(filePath string, patterns []PatternOwner) []string {
-	// Convert filePath to Unix-style for matching
+	// Normalize the file path to Unix-style
 	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, "/")
+		// Normalize the pattern to Unix-style and remove leading and trailing slashes
+		normalizedPattern := filepath.ToSlash(strings.TrimPrefix(pattern.Pattern, "/"))
+		normalizedPattern = strings.TrimSuffix(normalizedPattern, "/")
 
-		// Match if the file is in the directory or is an exact match
-		if strings.HasPrefix(relFilePath, patternPath) || relFilePath == patternPath {
-			matchedOwners = pattern.Owners
+		if IsWildcardPattern(normalizedPattern) {
+			matched, err := path.Match(normalizedPattern, relFilePath)
+			if err != nil {
+				fmt.Printf("Error matching pattern: %s to file: %s, error: %v\n", normalizedPattern, relFilePath, err)
+				continue
+			}
+
+			if matched {
+				matchedOwners = pattern.Owners
+			}
+		} else {
+			if relFilePath == normalizedPattern {
+				// Exact file or directory match
+				matchedOwners = pattern.Owners
+			} else if strings.HasPrefix(relFilePath, normalizedPattern+"/") {
+				// File is under the directory pattern
+				matchedOwners = pattern.Owners
+			}
 		}
 	}
+
 	return matchedOwners
 }

tools/flakeguard/codeowners/parser_test.go

@@ -0,0 +1,77 @@
+package codeowners
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestFindOwners(t *testing.T) {
+	tests := []struct {
+		name           string
+		filePath       string
+		patterns       []PatternOwner
+		expectedOwners []string
+	}{
+		{
+			name:     "Exact match",
+			filePath: "core/services/job/job_test.go",
+			patterns: []PatternOwner{
+				{Pattern: "/core/services/job", Owners: []string{"@team1", "@team2"}}, // Leading /
+			},
+			expectedOwners: []string{"@team1", "@team2"},
+		},
+		{
+			name:     "Wildcard match",
+			filePath: "core/services/ocr_test.go",
+			patterns: []PatternOwner{
+				{Pattern: "/core/services/ocr*", Owners: []string{"@ocr-team"}}, // Leading /
+			},
+			expectedOwners: []string{"@ocr-team"},
+		},
+		{
+			name:     "No match",
+			filePath: "core/services/unknown/unknown_test.go",
+			patterns: []PatternOwner{
+				{Pattern: "/core/services/job", Owners: []string{"@team1"}},     // Leading /
+				{Pattern: "/core/services/ocr*", Owners: []string{"@ocr-team"}}, // Leading /
+			},
+			expectedOwners: nil,
+		},
+		{
+			name:     "Multiple matches, last wins",
+			filePath: "core/services/ocr_test.go",
+			patterns: []PatternOwner{
+				{Pattern: "/core/services/*", Owners: []string{"@general-team"}}, // Leading /
+				{Pattern: "/core/services/ocr*", Owners: []string{"@ocr-team"}},  // Leading /
+			},
+			expectedOwners: []string{"@ocr-team"},
+		},
+		{
+			name:     "Directory match",
+			filePath: "core/services/job/subdir/job_test.go",
+			patterns: []PatternOwner{
+				{Pattern: "/core/services/job", Owners: []string{"@team1"}}, // Leading /
+			},
+			expectedOwners: []string{"@team1"},
+		},
+		{
+			name:     "Leading slash directory match",
+			filePath: "core/capabilities/compute/compute_test.go",
+			patterns: []PatternOwner{
+				{
+					Pattern: "/core/capabilities/",
+					Owners:  []string{"@smartcontractkit/keystone", "@smartcontractkit/capabilities-team"},
+				},
+			},
+			expectedOwners: []string{"@smartcontractkit/keystone", "@smartcontractkit/capabilities-team"},
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			owners := FindOwners(test.filePath, test.patterns)
+			assert.Equal(t, test.expectedOwners, owners)
+		})
+	}
+}

tools/flakeguard/main.go

@@ -29,6 +29,7 @@ func init() {
 	rootCmd.AddCommand(cmd.FindTestsCmd)
 	rootCmd.AddCommand(cmd.RunTestsCmd)
 	rootCmd.AddCommand(cmd.AggregateResultsCmd)
+	rootCmd.AddCommand(cmd.CheckTestOwnersCmd)
 }
 
 func main() {