feat(test): add -r/--recursive flag for test discovery

Default behavior is now non-recursive (only test the current/specified
directory). Use -r to walk subdirectories and discover all test packages.

Author: moshloop

testrunner/runner.go

@@ -66,6 +66,7 @@ type RunOptions struct {
 	TodoTemplate  string     `json:"todo_template,omitempty" flag:"todo-template"`                 // Path to TODO template file
 	WorkDir       string     `json:"work_dir,omitempty" flag:"work-dir"`                           // Working directory to run tests in
 	DryRun        bool       `json:"dry_run,omitempty" flag:"dry-run"`                             // Show what tests would be executed without running them
+	Recursive     bool       `json:"recursive,omitempty" flag:"recursive,r"`                       // Recursively discover test packages in subdirectories
 }
 
 func (opts RunOptions) Pretty() api.Text {
@@ -231,7 +232,7 @@ func (o *TestOrchestrator) detectAndRun(frameworks []Framework, startingPaths []
 		if len(startingPaths) > 0 {
 			packages, err = o.discoverPackagesInPaths(runner, startingPaths)
 		} else {
-			packages, err = runner.DiscoverPackages(o.WorkDir)
+			packages, err = runner.DiscoverPackages(o.WorkDir, o.Recursive)
 		}
 
 		if err != nil {
@@ -400,7 +401,7 @@ func (o *TestOrchestrator) discoverPackagesInPaths(runner runners.Runner, starti
 		}
 		logger.Debugf("Discovering packages in path: %s", fullPath)
 
-		packages, err := runner.DiscoverPackages(fullPath)
+		packages, err := runner.DiscoverPackages(fullPath, o.Recursive)
 		if err != nil {
 			return nil, fmt.Errorf("failed to discover packages in %s: %w", startPath, err)
 		}

testrunner/runners/ginkgo.go

@@ -56,13 +56,20 @@ func (r *Ginkgo) Detect(workDir string) (bool, error) {
 	return found, err
 }
 
-// DiscoverPackages returns all packages with Ginkgo tests.
-func (r *Ginkgo) DiscoverPackages(workDir string) ([]string, error) {
+// DiscoverPackages returns packages with Ginkgo tests.
+// When recursive is false, only the given directory is checked.
+func (r *Ginkgo) DiscoverPackages(workDir string, recursive bool) ([]string, error) {
+	if !recursive {
+		if r.dirHasGinkgoTests(workDir) {
+			return []string{r.getRelativePath(workDir)}, nil
+		}
+		return nil, nil
+	}
+
 	var packages []string
 	seen := make(map[string]bool)
 
 	err := filepath.Walk(workDir, func(path string, info os.FileInfo, err error) error {
-
 		if err != nil {
 			return err
 		}
@@ -139,6 +146,21 @@ func (r *Ginkgo) NormalizeFilePath(filePath string) string {
 	return r.normalizeFilePath(filePath)
 }
 
+func (r *Ginkgo) dirHasGinkgoTests(dir string) bool {
+	entries, err := os.ReadDir(dir)
+	if err != nil {
+		return false
+	}
+	for _, entry := range entries {
+		if !entry.IsDir() && strings.HasSuffix(entry.Name(), "_test.go") {
+			if r.hasGinkgoImports(filepath.Join(dir, entry.Name())) {
+				return true
+			}
+		}
+	}
+	return false
+}
+
 // hasGinkgoImports checks if a file imports ginkgo.
 func (r *Ginkgo) hasGinkgoImports(path string) bool {
 	content, err := os.ReadFile(path)

testrunner/runners/ginkgo_test.go

@@ -95,7 +95,7 @@ import . "github.com/onsi/ginkgo/v2"
 	}
 
 	runner := NewGinkgo(tmpDir)
-	packages, err := runner.DiscoverPackages(tmpDir)
+	packages, err := runner.DiscoverPackages(tmpDir, true)
 	if err != nil {
 		t.Fatalf("unexpected error: %v", err)
 	}

testrunner/runners/gotest.go

@@ -76,8 +76,16 @@ func (r *GoTest) packageHasNonGinkgoTests(pkgDir string) bool {
 	return false
 }
 
-// DiscoverPackages returns all packages with go test files (excluding Ginkgo-only packages).
-func (r *GoTest) DiscoverPackages(workDir string) ([]string, error) {
+// DiscoverPackages returns packages with go test files (excluding Ginkgo-only packages).
+// When recursive is false, only the given directory is checked.
+func (r *GoTest) DiscoverPackages(workDir string, recursive bool) ([]string, error) {
+	if !recursive {
+		if r.packageHasNonGinkgoTests(workDir) {
+			return []string{r.getRelativePath(workDir)}, nil
+		}
+		return nil, nil
+	}
+
 	var packages []string
 	seen := make(map[string]bool)
 
@@ -90,7 +98,6 @@ func (r *GoTest) DiscoverPackages(workDir string) ([]string, error) {
 			pkgDir := filepath.Dir(path)
 			if !seen[pkgDir] {
 				seen[pkgDir] = true
-				// Only include package if it has non-Ginkgo tests
 				if r.packageHasNonGinkgoTests(pkgDir) {
 					relPath := r.getRelativePath(pkgDir)
 					packages = append(packages, relPath)

testrunner/runners/gotest_test.go

@@ -54,7 +54,7 @@ func TestGoTestDiscoverPackages(t *testing.T) {
 	}
 
 	runner := NewGoTest(tmpDir)
-	packages, err := runner.DiscoverPackages(tmpDir)
+	packages, err := runner.DiscoverPackages(tmpDir, true)
 	if err != nil {
 		t.Fatalf("unexpected error: %v", err)
 	}
@@ -71,6 +71,45 @@ func TestGoTestDiscoverPackages(t *testing.T) {
 	}
 }
 
+func TestGoTestDiscoverPackagesNonRecursive(t *testing.T) {
+	tmpDir := t.TempDir()
+
+	// Create test file in root and in a subdirectory
+	if err := os.WriteFile(filepath.Join(tmpDir, "root_test.go"), []byte("package root\n"), 0644); err != nil {
+		t.Fatal(err)
+	}
+	subDir := filepath.Join(tmpDir, "sub")
+	if err := os.MkdirAll(subDir, 0755); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(filepath.Join(subDir, "sub_test.go"), []byte("package sub\n"), 0644); err != nil {
+		t.Fatal(err)
+	}
+
+	runner := NewGoTest(tmpDir)
+
+	// Non-recursive should only find root
+	packages, err := runner.DiscoverPackages(tmpDir, false)
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if len(packages) != 1 {
+		t.Fatalf("expected 1 package, got %d: %v", len(packages), packages)
+	}
+	if packages[0] != "./." {
+		t.Errorf("expected './.', got %s", packages[0])
+	}
+
+	// Recursive should find both
+	packages, err = runner.DiscoverPackages(tmpDir, true)
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if len(packages) != 2 {
+		t.Fatalf("expected 2 packages, got %d: %v", len(packages), packages)
+	}
+}
+
 func TestGoTestPackageHasTests(t *testing.T) {
 	tmpDir := t.TempDir()
 	pkgDir := filepath.Join(tmpDir, "pkg")
@@ -214,7 +253,7 @@ func TestExample(t *testing.T) {}
 	}
 
 	runner := NewGoTest(tmpDir)
-	packages, err := runner.DiscoverPackages(tmpDir)
+	packages, err := runner.DiscoverPackages(tmpDir, true)
 	if err != nil {
 		t.Fatalf("unexpected error: %v", err)
 	}

testrunner/runners/types.go

@@ -18,8 +18,9 @@ type Runner interface {
 	// Detect checks if this framework is used in the given working directory.
 	Detect(workDir string) (bool, error)
 
-	// DiscoverPackages returns all packages with tests for this framework.
-	DiscoverPackages(workDir string) ([]string, error)
+	// DiscoverPackages returns packages with tests for this framework.
+	// When recursive is true, it walks subdirectories; otherwise only the given directory.
+	DiscoverPackages(workDir string, recursive bool) ([]string, error)
 
 	// PackageHasTests checks if a package has tests for this framework.
 	PackageHasTests(packagePath string) (bool, error)