Basic test skips

Author: kalverra

tools/flakeguard/cmd/make_pr.go

@@ -9,6 +9,7 @@ import (
 	"github.com/go-git/go-git/v5"
 	"github.com/go-git/go-git/v5/plumbing"
 	"github.com/google/go-github/v72/github"
+	"github.com/smartcontractkit/chainlink-testing-framework/tools/flakeguard/golang"
 	"github.com/smartcontractkit/chainlink-testing-framework/tools/flakeguard/localdb"
 	"github.com/spf13/cobra"
 	"golang.org/x/oauth2"
@@ -36,34 +37,39 @@ func makePR(cmd *cobra.Command, args []string) error {
 		return err
 	}
 
-	entries := db.GetAllEntries()
+	currentlyFlakyEntries := db.GetAllCurrentlyFlakyEntries()
 
 	branchName := fmt.Sprintf("flakeguard-skip-%s", time.Now().Format("20060102150405"))
-	w, err := repo.Worktree()
+	targetRepoWorktree, err := repo.Worktree()
 	if err != nil {
 		return err
 	}
-	err = w.Checkout(&git.CheckoutOptions{
+	err = targetRepoWorktree.Checkout(&git.CheckoutOptions{
 		Branch: plumbing.NewBranchReferenceName(branchName),
 		Create: true,
 	})
 	if err != nil {
 		return err
 	}
 
-	for _, entry := range entries {
-		// Find the test function in the codebase and skip it
-
-		entry.SkippedAt = time.Now()
-		db.UpsertEntry(entry.TestPackage, entry.TestName, entry.JiraTicket, entry.SkippedAt, entry.AssigneeID)
+	testsToSkip := []golang.SkipTest{}
+	for _, entry := range currentlyFlakyEntries {
+		testsToSkip = append(testsToSkip, golang.SkipTest{
+			Package: entry.TestPackage,
+			Name:    entry.TestName,
+		})
+	}
 
+	err = golang.SkipTests(repoPath, testsToSkip)
+	if err != nil {
+		return err
 	}
 
-	_, err = w.Add(".")
+	_, err = targetRepoWorktree.Add(".")
 	if err != nil {
 		return err
 	}
-	_, err = w.Commit("Skips flaky tests", &git.CommitOptions{})
+	_, err = targetRepoWorktree.Commit("Skips flaky tests", &git.CommitOptions{})
 	if err != nil {
 		return err
 	}

tools/flakeguard/golang/golang.go

@@ -5,7 +5,13 @@ import (
 	"bytes"
 	"encoding/json"
 	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/printer"
+	"go/token"
+	"os"
 	"os/exec"
+	"path/filepath"
 	"strings"
 
 	"github.com/rs/zerolog/log"
@@ -197,3 +203,89 @@ func FilterPackagesWithTests(pkgs []string) []string {
 	}
 	return testPkgs
 }
+
+// SkipTest is a struct that contains the package and name of the test to skip
+type SkipTest struct {
+	Package string
+	Name    string
+}
+
+// SkipTests finds all package/test pairs provided and skips them
+func SkipTests(repoPath string, testsToSkip []SkipTest) error {
+	for _, testToSkip := range testsToSkip {
+		cmd := exec.Command("go", "list", "-json", testToSkip.Package)
+		out, err := cmd.CombinedOutput()
+		if err != nil {
+			return fmt.Errorf("error getting package path for %s: %w", testToSkip.Package, err)
+		}
+		packagePath := strings.TrimSpace(string(out))
+		log.Debug().Str("package", testToSkip.Package).Str("test", testToSkip.Name).Str("packagePath", packagePath).Msg("Skipping test")
+
+		err = filepath.Walk(filepath.Join(repoPath, packagePath), func(path string, info os.FileInfo, err error) error {
+			if err != nil {
+				return err
+			}
+			if info.IsDir() || !strings.HasSuffix(info.Name(), "_test.go") {
+				return nil
+			}
+
+			fset := token.NewFileSet()
+			fileAst, err := parser.ParseFile(fset, path, nil, parser.ParseComments)
+			if err != nil {
+				return err
+			}
+
+			found := false
+			ast.Inspect(fileAst, func(n ast.Node) bool {
+				fn, ok := n.(*ast.FuncDecl)
+				if !ok || fn.Name.Name != testToSkip.Name {
+					return true
+				}
+				// Check if first parameter is *testing.T
+				if fn.Type.Params != nil && len(fn.Type.Params.List) > 0 {
+					param := fn.Type.Params.List[0]
+					if starExpr, ok := param.Type.(*ast.StarExpr); ok {
+						if sel, ok := starExpr.X.(*ast.SelectorExpr); ok && sel.Sel.Name == "T" {
+							// Insert t.Skip as first statement
+							skipStmt := &ast.ExprStmt{
+								X: &ast.CallExpr{
+									Fun: &ast.SelectorExpr{
+										X:   ast.NewIdent(param.Names[0].Name),
+										Sel: ast.NewIdent("Skip"),
+									},
+									Args: []ast.Expr{
+										&ast.BasicLit{
+											Kind:  token.STRING,
+											Value: "\"skipped by flakeguard\"",
+										},
+									},
+								},
+							}
+							fn.Body.List = append([]ast.Stmt{skipStmt}, fn.Body.List...)
+							found = true
+							return false // stop
+						}
+					}
+				}
+				return true
+			})
+
+			if found {
+				// Write back the file
+				var out strings.Builder
+				if err := printer.Fprint(&out, fset, fileAst); err != nil {
+					return err
+				}
+				if err := os.WriteFile(path, []byte(out.String()), info.Mode()); err != nil {
+					return err
+				}
+				return filepath.SkipDir // stop walking
+			}
+			return fmt.Errorf("test function %s not found in package %s", testToSkip.Name, testToSkip.Package)
+		})
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}

tools/flakeguard/localdb/localdb.go

@@ -202,6 +202,20 @@ func (db *DB) GetAllEntries() []Entry {
 	return entries
 }
 
+// GetAllCurrentlyFlakyEntries returns all entries that currently have an open Jira ticket
+// for being a flaky test.
+func (db *DB) GetAllCurrentlyFlakyEntries() []Entry {
+	db.mu.RLock()
+	defer db.mu.RUnlock()
+	entries := make([]Entry, 0, len(db.data))
+	for _, entry := range db.data {
+		if entry.JiraTicket != "" {
+			entries = append(entries, entry)
+		}
+	}
+	return entries
+}
+
 // DefaultDBPath returns the default DB file path in the user's home directory.
 // Renamed from getDefaultDBPath to be exported.
 // If the user's home directory cannot be determined, it falls back to the current directory.