fix(op-acceptor): skip RunAll package when all tests excluded by --exclude-gates (#565)

* fix(op-acceptor): skip RunAll package invocation when all tests are excluded

When --exclude-gates is used, named tests in excluded gates are added to
SkipTests on their package's RunAll validator. If every test in a package
is in the skip list, go test is still invoked with -skip, which causes
TestMain to run (and any test infrastructure it sets up) even though no
tests will execute. On teardown, this infrastructure can hang (e.g. a
devnet with active snap sync connections that block p2p server shutdown).

Fix: before running a RunAll validator with a non-empty SkipTests list,
use "go test -list ." to enumerate the package's test functions cheaply.
If every listed function appears in SkipTests, return TestStatusSkip
immediately without invoking go test.

Adds a regression test that verifies the package is reported as skipped
(not failed) when all its tests are covered by the skip filter.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

* fix: use go list + file scan instead of go test -list to avoid TestMain

go test -list invokes the test binary which calls TestMain. Packages that
use presets.DoMain start a devnet in TestMain before m.Run(), so go test
-list would itself hang on the teardown we were trying to prevent.

Replace with a two-step approach that never runs the test binary:
1. go list -json to resolve the package's test source files (no build)
2. Scan those files with a regex for func Test* declarations

This correctly enumerates test functions without triggering TestMain or
any test infrastructure.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

* fix: exclude TestMain from test function scan

TestMain matches the ^func (Test\w+)( regex but is the harness entry
point, not a runnable test. Without this exclusion, any package defining
TestMain (like reqressyncdisabled) would never be detected as all-skipped
because TestMain is not in SkipTests — the pre-check returns false and
the devnet starts anyway.

Exclude fn == "TestMain" explicitly and add it to the regression test
to prevent the same oversight.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

---------

Co-authored-by: Claude <claude@anthropic.com>
Co-authored-by: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: smartcontracts

op-acceptor/runner/runner.go

@@ -1,6 +1,7 @@
 package runner
 
 import (
+	"bufio"
 	"bytes"
 	"context"
 	"encoding/json"
@@ -715,6 +716,24 @@ func (r *runner) RunTest(ctx context.Context, metadata types.ValidatorMetadata)
 // runAllTestsInPackage discovers and runs all tests in a package
 // Executes the entire package as a single go test process to preserve intra-package parallelism.
 func (r *runner) runAllTestsInPackage(ctx context.Context, metadata types.ValidatorMetadata) (*types.TestResult, error) {
+	// If the validator has a non-empty SkipTests list, check whether every test
+	// in the package would be skipped. If so, skip the entire invocation to avoid
+	// spinning up expensive test infrastructure (e.g. devnets) that will never
+	// actually run any tests and may hang on teardown.
+	if len(metadata.SkipTests) > 0 {
+		if all, err := r.allTestsWouldBeSkipped(ctx, metadata); err != nil {
+			r.log.Warn("Could not determine if all tests are skipped; proceeding normally",
+				"package", metadata.Package, "err", err)
+		} else if all {
+			r.log.Info("All tests in package are excluded by skip filter; skipping package invocation",
+				"package", metadata.Package, "skipTests", metadata.SkipTests)
+			return &types.TestResult{
+				Metadata: metadata,
+				Status:   types.TestStatusSkip,
+			}, nil
+		}
+	}
+
 	pkgMeta := metadata
 	pkgMeta.RunAll = false
 	pkgMeta.FuncName = ""
@@ -728,6 +747,91 @@ func (r *runner) runAllTestsInPackage(ctx context.Context, metadata types.Valida
 	return res, err
 }
 
+// testFuncPattern matches top-level Go test function declarations. We only
+// match Test* here because SkipTests comes from explicit YAML entries which
+// are invariably Test* functions; Benchmark* and Fuzz* are not skipped via
+// -skip in normal acceptance test runs.
+var testFuncPattern = regexp.MustCompile(`^func (Test\w+)\(`)
+
+// allTestsWouldBeSkipped returns true if every top-level Test* function in the
+// package source is present in metadata.SkipTests, meaning no tests would
+// actually run.
+//
+// Critically, this must NOT invoke the test binary because TestMain can start
+// expensive infrastructure (devnets) that hangs on teardown when 0 tests run.
+// Instead we use "go list -json" to resolve the package's test source files
+// and scan them with a regex — no compilation or execution required.
+func (r *runner) allTestsWouldBeSkipped(ctx context.Context, metadata types.ValidatorMetadata) (bool, error) {
+	// Resolve test source files via "go list -json" (no build, no test binary).
+	listCmd, cleanup := r.testCommandContext(ctx, r.goBinary, "list", "-json", metadata.Package)
+	defer cleanup()
+
+	var listOut bytes.Buffer
+	listCmd.Stdout = &listOut
+	listCmd.Stderr = io.Discard
+
+	if err := listCmd.Run(); err != nil {
+		return false, fmt.Errorf("go list -json failed for %s: %w", metadata.Package, err)
+	}
+
+	var pkgInfo struct {
+		Dir          string
+		TestGoFiles  []string
+		XTestGoFiles []string
+	}
+	if err := json.Unmarshal(listOut.Bytes(), &pkgInfo); err != nil {
+		return false, fmt.Errorf("parsing go list output for %s: %w", metadata.Package, err)
+	}
+
+	skipSet := make(map[string]struct{}, len(metadata.SkipTests))
+	for _, s := range metadata.SkipTests {
+		skipSet[s] = struct{}{}
+	}
+
+	testFiles := append(pkgInfo.TestGoFiles, pkgInfo.XTestGoFiles...)
+	foundAny := false
+	for _, file := range testFiles {
+		fns, err := scanTestFunctions(filepath.Join(pkgInfo.Dir, file))
+		if err != nil {
+			return false, fmt.Errorf("scanning %s: %w", file, err)
+		}
+		for _, fn := range fns {
+			// TestMain is the test harness entry point, not an actual test function.
+			// The Go testing framework never runs it as a test, so exclude it.
+			if fn == "TestMain" {
+				continue
+			}
+			foundAny = true
+			if _, skip := skipSet[fn]; !skip {
+				return false, nil // at least one test would run
+			}
+		}
+	}
+
+	// If no Test* functions were found at all, do not treat that as "all
+	// skipped" — let the normal execution path handle the empty-package case.
+	return foundAny, nil
+}
+
+// scanTestFunctions opens a Go test source file and returns the names of all
+// top-level Test* functions found in it.
+func scanTestFunctions(path string) ([]string, error) {
+	f, err := os.Open(path)
+	if err != nil {
+		return nil, err
+	}
+	defer f.Close()
+
+	var funcs []string
+	scanner := bufio.NewScanner(f)
+	for scanner.Scan() {
+		if m := testFuncPattern.FindStringSubmatch(scanner.Text()); m != nil {
+			funcs = append(funcs, m[1])
+		}
+	}
+	return funcs, scanner.Err()
+}
+
 // runTestList runs a list of tests and aggregates their results
 func (r *runner) runTestList(ctx context.Context, metadata types.ValidatorMetadata, testNames []string) (*types.TestResult, error) {
 	if len(testNames) == 0 {

op-acceptor/runner/runner_test.go

@@ -2354,3 +2354,75 @@ func TestChildPkg(t *testing.T) { t.Log("child ok") }
 	assert.True(t, hasParent, "should contain TestParentPkg from parent package")
 	assert.True(t, hasChild, "should contain TestChildPkg from child subpackage")
 }
+
+// TestRunAllTests_SkipWhenAllTestsExcluded verifies that when every test in a RunAll
+// package appears in the SkipTests list, the package is not invoked at all and the
+// result is reported as skipped. This prevents expensive test infrastructure (like
+// devnets) from starting when no tests would actually run.
+func TestRunAllTests_SkipWhenAllTestsExcluded(t *testing.T) {
+	ctx := context.Background()
+
+	// Package has one test: TestOnlyTest.
+	// It is listed in a "quarantine" gate so that exclude-gates sets SkipTests.
+	// The "production" gate uses a RunAll validator for the same package.
+	configContent := []byte(`
+gates:
+  - id: quarantine
+    tests:
+      - package: ./feature
+        name: TestOnlyTest
+  - id: production
+    tests:
+      - package: ./feature
+`)
+	// Include a TestMain to verify it is not mistaken for a test function and
+	// does not prevent the all-skipped detection from working.
+	testContent := []byte(`
+package feature_test
+
+import (
+	"os"
+	"testing"
+)
+
+func TestMain(m *testing.M) { os.Exit(m.Run()) }
+
+func TestOnlyTest(t *testing.T) { t.Log("only test") }
+`)
+
+	testDir := t.TempDir()
+	initGoModule(t, testDir, "test")
+	featureDir := filepath.Join(testDir, "feature")
+	require.NoError(t, os.MkdirAll(featureDir, 0755))
+	require.NoError(t, os.WriteFile(filepath.Join(featureDir, "example_test.go"), testContent, 0644))
+
+	validatorConfigPath := filepath.Join(testDir, "validators.yaml")
+	require.NoError(t, os.WriteFile(validatorConfigPath, configContent, 0644))
+
+	reg, err := registry.NewRegistry(registry.Config{
+		ValidatorConfigFile: validatorConfigPath,
+		ExcludeGates:        []string{"quarantine"},
+	})
+	require.NoError(t, err)
+
+	r, err := NewTestRunner(Config{
+		Registry: reg,
+		WorkDir:  testDir,
+		Log:      testlog.Logger(t, slog.LevelDebug),
+	})
+	require.NoError(t, err)
+
+	result, err := r.RunAllTests(ctx)
+	require.NoError(t, err)
+
+	// The production gate should have a skipped result for the package (not a failure).
+	require.Contains(t, result.Gates, "production")
+	gate := result.Gates["production"]
+	require.Len(t, gate.Tests, 1)
+	var pkgResult *types.TestResult
+	for _, v := range gate.Tests {
+		pkgResult = v
+	}
+	require.NotNil(t, pkgResult)
+	assert.Equal(t, types.TestStatusSkip, pkgResult.Status, "package with all tests excluded should be reported as skipped, not failed")
+}