feat: create analyze command

Signed-off-by: Alessio Greggi <ale_grey_91@hotmail.it>

cmd/analyze.go

@@ -0,0 +1,181 @@
+/*
+Copyright © 2024 Alessio Greggi
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+package cmd
+
+import (
+ "fmt"
+ "io"
+ "os"
+ "path/filepath"
+ "strings"
+
+ "github.com/alegrey91/harpoon/internal/analyzer"
+ "github.com/alegrey91/harpoon/internal/executor"
+ "github.com/alegrey91/harpoon/internal/metadata"
+ "github.com/spf13/cobra"
+)
+
+var excludedPaths []string
+var exclude string
+var saveAnalysis bool
+
+// captureCmd represents the create args
+var analyzeCmd = &cobra.Command{
+ Use: "analyze",
+ Short: "Analyze infers the symbols of functions that are tested by unit-tests",
+ Long: `
+`,
+ Example: " harpoon analyze --exclude vendor/ /path/to/repo/",
+ Run: func(cmd *cobra.Command, args []string) {
+ if exclude != "" {
+ excludedPaths = strings.Split(exclude, ",")
+ }
+
+ file, err := os.Open("go.mod")
+ if err != nil {
+ fmt.Printf("failed to open %s: %v\n", "go.mod", err)
+ return
+ }
+ defer file.Close()
+
+ moduleName, err := analyzer.GetModuleName(file)
+ if err != nil {
+ fmt.Println("module name not found in go.mod")
+ return
+ }
+
+ symbolsList := metadata.NewSymbolsList()
+
+ // Walk the directory to find all _test.go files
+ err = filepath.Walk(".", func(path string, info os.FileInfo, err error) error {
+ if err != nil {
+ return fmt.Errorf("error walking filesystem: %v", err)
+ }
+ fmt.Printf("analyzing file: %s\n", path)
+
+ if shouldSkipPath(path) {
+ fmt.Println("file was skipped")
+ if info.IsDir() {
+ return filepath.SkipDir
+ }
+ return nil
+ }
+
+ if !info.IsDir() && strings.HasSuffix(info.Name(), "_test.go") {
+ fmt.Println("analyzing symbols")
+ symbolNames, err := analyzer.AnalyzeTestFile(moduleName, path)
+ if err != nil {
+ return fmt.Errorf("unable to infer symbols from test file: %s", path)
+ }
+
+ fmt.Println("building test binary")
+ // build test binary
+ os.Mkdir(".harpoon", 0644)
+ pkgPath := getPackagePath(path)
+ testFile := filepath.Base(path)
+ testFile = strings.ReplaceAll(testFile, "_test.go", ".test")
+ _, err = executor.Build(pkgPath, ".harpoon/"+testFile)
+ if err != nil {
+ return fmt.Errorf("failed to build test file: %v", err)
+ }
+
+ symbolsOrig := metadata.NewSymbolsOrigin(".harpoon/" + testFile)
+
+ fmt.Println("test: .harpoon/" + testFile)
+ for _, symbol := range symbolNames {
+ // retrieve tested function from symbol
+ parts := strings.Split(symbol, ".")
+ testedFunction := parts[len(parts)-1]
+
+ // retrieve source file from _test.go file
+ sourceFile := strings.ReplaceAll(path, "_test", "")
+ file, err := os.Open(sourceFile)
+ if err != nil {
+ return fmt.Errorf("failed to open %s: %v", sourceFile, err)
+ }
+ defer file.Close()
+
+ functionExists, err := analyzer.CheckFunctionExists(testedFunction, file)
+ if !functionExists {
+ fmt.Printf("function not found: %v\n", err)
+ continue
+ }
+ symbolsOrig.Add(symbol)
+ }
+ if !symbolsOrig.IsEmpty() {
+ symbolsList.Add(symbolsOrig)
+ }
+ }
+ return nil
+ })
+
+ if err != nil {
+ fmt.Printf("error walking the path: %v\n", err)
+ }
+
+ // store to file
+ file, err = os.Create(".harpoon.yml")
+ if err != nil {
+ fmt.Printf("failed to create symbols list file")
+ return
+ }
+ mw := io.Writer(file)
+ fmt.Fprintln(mw, symbolsList.String())
+ fmt.Println("file .harpoon.yml is ready")
+ },
+}
+
+func init() {
+ rootCmd.AddCommand(analyzeCmd)
+
+ analyzeCmd.Flags().StringVarP(&exclude, "exclude", "e", "", "Skip directories specified in the comma separated list")
+ analyzeCmd.Flags().BoolVarP(&saveAnalysis, "save", "s", false, "Save analysis in a file")
+}
+
+func shouldSkipPath(path string) bool {
+ for _, excludedPath := range excludedPaths {
+ if strings.Contains(path, excludedPath) {
+ return true
+ }
+ }
+ return false
+}
+
+func getPackagePath(inputPath string) string {
+ // Normalize the path
+ normalizedPath := filepath.Clean(inputPath)
+
+ // Get the directory part of the path if it's a file path
+ dirPath := normalizedPath
+ if !strings.HasSuffix(inputPath, "/") {
+ dirPath = filepath.Dir(normalizedPath)
+ }
+
+ // Ensure the path starts with "./"
+ if !strings.HasPrefix(dirPath, ".") {
+ dirPath = "./" + dirPath
+ }
+
+ // Remove any leading "../" or "./" parts not relevant to the target directory structure
+ // Adjust this according to your specific requirements
+ dirPath = strings.TrimPrefix(dirPath, "../")
+ dirPath = strings.TrimPrefix(dirPath, "./")
+
+ // Add "./" at the start again if necessary
+ dirPath = "./" + dirPath
+
+ return dirPath
+}

internal/analyzer/analyze.go

@@ -0,0 +1,83 @@
+package analyzer
+
+import (
+ "bufio"
+ "fmt"
+ "go/ast"
+ "go/parser"
+ "go/token"
+ "os"
+ "path/filepath"
+ "strings"
+)
+
+func isTestFunction(name string) bool {
+ return strings.HasPrefix(name, "Test") || strings.HasPrefix(name, "Test_")
+}
+
+func getTestedFunctionName(testName string) string {
+ if strings.HasPrefix(testName, "Test_") {
+ return testName[5:] // Remove "Test_"
+ }
+ return testName[4:] // Remove "Test"
+}
+
+func AnalyzeTestFile(moduleName, path string) ([]string, error) {
+ fset := token.NewFileSet()
+ node, err := parser.ParseFile(fset, path, nil, parser.AllErrors)
+ if err != nil {
+ return []string{}, fmt.Errorf("failed to parse %s: %v", path, err)
+ }
+
+ // retrieve the last directory from the module name
+ lastDirectory := filepath.Base(filepath.Clean(moduleName))
+ // remove the file from the directory
+ dir, _ := filepath.Split(path)
+ // remove the / char from the end of the path
+ dir = strings.TrimSuffix(dir, "/")
+ // remove all the ../ from the path
+ dir = strings.ReplaceAll(dir, "../", "")
+ // remove the base directory since it is already present in the module name
+ dir = strings.TrimPrefix(dir, lastDirectory+"/")
+
+ var functionList []string
+ for _, decl := range node.Decls {
+ if fn, isFn := decl.(*ast.FuncDecl); isFn {
+ if isTestFunction(fn.Name.Name) {
+ testedFunction := getTestedFunctionName(fn.Name.Name)
+ functionList = append(functionList, fmt.Sprintf("%s/%s.%s", moduleName, dir, testedFunction))
+ }
+ }
+ }
+ return functionList, nil
+}
+
+func GetModuleName(goModFile *os.File) (string, error) {
+ scanner := bufio.NewScanner(goModFile)
+ for scanner.Scan() {
+ line := scanner.Text()
+ if strings.HasPrefix(line, "module ") {
+ return strings.TrimSpace(strings.TrimPrefix(line, "module ")), nil
+ }
+ }
+
+ if err := scanner.Err(); err != nil {
+ return "", fmt.Errorf("error reading %s: %v", goModFile.Name(), err)
+ }
+ return "", fmt.Errorf("unable to find module in file: %s", goModFile.Name())
+}
+
+func CheckFunctionExists(functionName string, goFile *os.File) (bool, error) {
+ scanner := bufio.NewScanner(goFile)
+ for scanner.Scan() {
+ line := scanner.Text()
+ if strings.Contains(line, "func "+functionName) {
+ return true, nil
+ }
+ }
+
+ if err := scanner.Err(); err != nil {
+ return false, fmt.Errorf("error reading %s: %v", goFile.Name(), err)
+ }
+ return false, fmt.Errorf("unable to find function \"%s\" in %s file", functionName, goFile.Name())
+}

internal/executor/exec.go

@@ -23,3 +23,20 @@ func Run(cmd []string, cmdOutput bool, wg *sync.WaitGroup) {
 
  command.Wait()
 }
+
+func Build(packagePath, outputFile string) (string, error) {
+ cmd := exec.Command(
+ "go",
+ "test",
+ "-gcflags", "-N -l", // disable optimization
+ "-c", packagePath, // build test binary
+ "-o", outputFile, // save it in a dedicated directory
+ )
+ stdout, err := cmd.Output()
+
+ if err != nil {
+ return "", fmt.Errorf("failed to execute build command: %v", err)
+ }
+
+ return string(stdout), nil
+}

internal/metadata/metadata.go

@@ -0,0 +1,47 @@
+package metadata
+
+import "fmt"
+
+type SymbolsList struct {
+ SymbolsOrigins []SymbolsOrigin
+}
+
+func NewSymbolsList() *SymbolsList {
+ return &SymbolsList{}
+}
+
+func (sl *SymbolsList) Add(so *SymbolsOrigin) {
+ sl.SymbolsOrigins = append(sl.SymbolsOrigins, *so)
+}
+
+func (sl *SymbolsList) String() string {
+ output := "---\n"
+ output += "symbolsOrigins:\n"
+ for _, symbolsOrigin := range sl.SymbolsOrigins {
+ output += fmt.Sprintf(" - %s:\n", symbolsOrigin.TestBinaryPath)
+ output += " symbols:\n"
+ for _, symbol := range symbolsOrigin.Symbols {
+ output += fmt.Sprintf(" - %s\n", symbol)
+ }
+ }
+ return output
+}
+
+type SymbolsOrigin struct {
+ TestBinaryPath string
+ Symbols []string
+}
+
+func NewSymbolsOrigin(testBinPath string) *SymbolsOrigin {
+ return &SymbolsOrigin{
+ TestBinaryPath: testBinPath,
+ }
+}
+
+func (so *SymbolsOrigin) IsEmpty() bool {
+ return len(so.Symbols) == 0
+}
+
+func (so *SymbolsOrigin) Add(symbol string) {
+ so.Symbols = append(so.Symbols, symbol)
+}