add -f to smart-test run (#166)

* rename {get,list,cancel}x subcommands

* bugfix

* rename "test" to "smart-test"

* execution subcommand

* add x alias

* add -f to smart-test run

* Bug fix in label processing

---------

Co-authored-by: Daniel De Vera <[email protected]>

Author: scott-cotton

internal/command/smarttest/run.go

@@ -6,6 +6,7 @@ import (
 	"fmt"
 	"io"
 	"os"
+	"strconv"
 	"time"
 
 	"github.com/signadot/cli/internal/config"
@@ -42,27 +43,14 @@ func run(ctx context.Context, cfg *config.SmartTestRun, wOut, wErr io.Writer,
 		return err
 	}
 
-	// create a test finder
-	tf, err := repoconfig.NewTestFinder(cfg.Directory)
+	testFiles, gitRepo, err := testFilesAndRepo(cfg)
 	if err != nil {
 		return err
 	}
 
-	// find tests
-	testFiles, err := tf.FindTestFiles()
-	if err != nil {
-		return err
-	}
-	if len(testFiles) == 0 {
-		return errors.New("could not find any test")
-	}
-
 	// create a run ID
 	runID := repoconfig.GenerateRunID()
 
-	// get the git repo (if any)
-	gitRepo := tf.GetGitRepo()
-
 	// trigger test executions
 	err = triggerTests(cfg, runID, gitRepo, testFiles)
 	if err != nil {
@@ -106,6 +94,38 @@ func run(ctx context.Context, cfg *config.SmartTestRun, wOut, wErr io.Writer,
 	return structuredOutput(cfg, wOut, runID, txs)
 }
 
+func testFilesAndRepo(cfg *config.SmartTestRun) ([]repoconfig.TestFile, *repoconfig.GitRepo, error) {
+	if cfg.File == "-" {
+		host, err := os.Hostname()
+		if err != nil {
+			host = "unknown"
+		}
+		pid := strconv.Itoa(os.Getpid())
+		return []repoconfig.TestFile{
+			{
+				Name:   host + "-" + "stdin-" + pid,
+				Reader: os.Stdin,
+			},
+		}, nil, nil
+	}
+	// create a test finder
+	// NOTE: at most one of cfg.{Dir,File} is non-empty
+	tf, err := repoconfig.NewTestFinder(cfg.Directory + cfg.File)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	// find tests
+	testFiles, err := tf.FindTestFiles()
+	if err != nil {
+		return nil, nil, fmt.Errorf("error finding test files: %w", err)
+	}
+	if len(testFiles) == 0 {
+		return nil, nil, errors.New("could not find any test")
+	}
+	return testFiles, tf.GetGitRepo(), nil
+}
+
 func validateRun(cfg *config.SmartTestRun) error {
 	count := 0
 	if cfg.Cluster != "" {
@@ -153,6 +173,28 @@ func validateRun(cfg *config.SmartTestRun) error {
 		}
 	}
 
+	if cfg.Directory != "" && cfg.File != "" {
+		return fmt.Errorf("cannot specify both directory and file")
+	}
+	if cfg.Directory != "" {
+		st, err := os.Stat(cfg.Directory)
+		if err != nil {
+			return fmt.Errorf("unable to stat input directory: %w", err)
+		}
+		if !st.IsDir() {
+			return fmt.Errorf("%q is not a directory", cfg.Directory)
+		}
+	}
+	if cfg.File != "" && cfg.File != "-" {
+		st, err := os.Stat(cfg.File)
+		if err != nil {
+			return fmt.Errorf("unable to stat input file: %w", err)
+		}
+		if st.IsDir() {
+			return fmt.Errorf("%q is not a file", cfg.File)
+		}
+	}
+
 	return nil
 }
 
@@ -186,11 +228,15 @@ func triggerTests(cfg *config.SmartTestRun, runID string,
 	for _, tf := range testFiles {
 		if gitRepo != nil {
 			// define the repo path
-			repoPath, err := repoconfig.GetRelativePathFromGitRoot(gitRepo.Path, tf.Path)
-			if err != nil {
-				return err
+			if tf.Reader == nil {
+				repoPath, err := repoconfig.GetRelativePathFromGitRoot(gitRepo.Path, tf.Path)
+				if err != nil {
+					return err
+				}
+				spec.Path = repoPath
+			} else {
+				spec.Path = tf.Path
 			}
-			spec.Path = repoPath
 		}
 		// define the test name
 		spec.TestName = tf.Name
@@ -200,7 +246,15 @@ func triggerTests(cfg *config.SmartTestRun, runID string,
 			spec.Labels[k] = v
 		}
 		// define the script
-		scriptContent, err := os.ReadFile(tf.Path)
+		var (
+			scriptContent []byte
+			err           error
+		)
+		if tf.Reader != nil {
+			scriptContent, err = io.ReadAll(tf.Reader)
+		} else {
+			scriptContent, err = os.ReadFile(tf.Path)
+		}
 		if err != nil {
 			return fmt.Errorf("failed to read test file %q: %w", tf.Path, err)
 		}

internal/config/smarttest.go

@@ -19,6 +19,7 @@ type SmartTest struct {
 type SmartTestRun struct {
 	*SmartTest
 	Directory  string
+	File       string
 	Labels     RunLabels
 	Cluster    string
 	Sandbox    string
@@ -62,6 +63,7 @@ func (tl RunLabels) Type() string {
 // AddFlags adds the flags for the test run command
 func (c *SmartTestRun) AddFlags(cmd *cobra.Command) {
 	cmd.Flags().StringVarP(&c.Directory, "directory", "d", "", "Base directory for finding tests")
+	cmd.Flags().StringVarP(&c.File, "file", "f", "", "Smart Test file to run")
 	cmd.Flags().StringVar(&c.Cluster, "cluster", "", "Cluster where to run tests")
 	cmd.Flags().StringVar(&c.Sandbox, "sandbox", "", "Sandbox where to run tests")
 	cmd.Flags().StringVar(&c.RouteGroup, "route-group", "", "Route group where to run tests")

internal/repoconfig/config.go

@@ -2,6 +2,7 @@ package repoconfig
 
 import (
 	"fmt"
+	"io"
 	"math/rand"
 	"os"
 	"path/filepath"
@@ -18,6 +19,7 @@ type Config struct {
 type TestFile struct {
 	Name   string            // Test name
 	Path   string            // Full path relative to base directory
+	Reader io.Reader         // if Path is empty, may be a Reader
 	Labels map[string]string // Labels from all parent directories
 }
 

internal/repoconfig/finder.go

@@ -12,17 +12,17 @@ type TestFinder struct {
 	repo     *GitRepo
 	basePath string
 
-	dirLabelsCache map[string]map[string]string
+	dirLabelsCache LabelsCache
 }
 
-func NewTestFinder(inputDir string) (*TestFinder, error) {
+func NewTestFinder(inputPath string) (*TestFinder, error) {
 	var tf *TestFinder
 
-	if inputDir != "" {
+	if inputPath != "" {
 		// use the provided dir as the base for finding tests
 
 		// make the input dir absolute
-		basePath, err := filepath.Abs(inputDir)
+		basePath, err := filepath.Abs(inputPath)
 		if err != nil {
 			return nil, fmt.Errorf("failed to convert input dir into an absolute dir: %w", err)
 		}
@@ -78,7 +78,7 @@ func NewTestFinder(inputDir string) (*TestFinder, error) {
 	}
 
 	// build the label cache
-	dirLabelsCache, err := buildLabelsCache(tf.basePath)
+	dirLabelsCache, err := NewLabelsCache(tf.basePath)
 	if err != nil {
 		return nil, err
 	}
@@ -140,12 +140,9 @@ func (tf *TestFinder) processTestFile(path string, testFileMap map[string]TestFi
 		return nil
 	}
 
-	dirPath := filepath.Dir(relPath)
-	var labels map[string]string
-	if dirLabels, exists := tf.dirLabelsCache[dirPath]; exists {
-		labels = dirLabels
-	} else {
-		labels = make(map[string]string)
+	labels, err := tf.dirLabelsCache.ForFile(relPath)
+	if err != nil {
+		return fmt.Errorf("unable to get labels for path %q: %w", relPath, err)
 	}
 
 	testFileMap[relPath] = TestFile{

internal/repoconfig/labels.go

@@ -9,6 +9,29 @@ import (
 	"strings"
 )
 
+type LabelsCache interface {
+	ForFile(p string) (map[string]string, error)
+}
+
+type labelsCache struct {
+	root      string
+	labelsMap map[string]map[string]string
+}
+
+// ForFile: finds the labels for a given path relative to the labels cache root.
+func (l *labelsCache) ForFile(relFile string) (map[string]string, error) {
+	relDir := filepath.Dir(relFile)
+	return l.labelsMap[relDir], nil
+}
+
+func NewLabelsCache(rootPath string) (LabelsCache, error) {
+	cache, err := buildLabelsCache(rootPath)
+	if err != nil {
+		return nil, err
+	}
+	return &labelsCache{root: rootPath, labelsMap: cache}, nil
+}
+
 // readLabels reads labels from a .labels file
 func readLabels(filePath string) (map[string]string, error) {
 	file, err := os.Open(filePath)