Add gotest adapter for standard Go tests

Similar to the Cypress adapter, this provides utilities for running
standard Go tests (*_test.go) via OTE without modifying test code.

Key features:
- Operators compile test packages into binaries (go test -c)
- Binaries are embedded in OTE extension binary (go:embed)
- At runtime, binaries are extracted and executed
- No hardcoded logic - operators provide all metadata

Example usage:
  //go:embed compiled_tests/*.test
  var embeddedTestBinaries embed.FS

  metadata := []gotest.GoTestConfig{
      {
          TestName:    "[sig-api-machinery] TestOperatorNamespace [Serial]",
          BinaryName:  "e2e.test",
          TestPattern: "TestOperatorNamespace",
          Tags:        []string{"Serial"},
          Lifecycle:   "Informing",
      },
  }
  specs, err := gotest.BuildExtensionTestSpecsFromGoTestMetadata(
      metadata, embeddedTestBinaries, "compiled_tests",
  )

Author: gangwgr

pkg/gotest/README.md

@@ -0,0 +1,250 @@
+# Go Test Adapter for OpenShift Tests Extension
+
+This package provides a reusable adapter for running standard Go tests within the OpenShift Tests Extension (OTE) framework.
+
+## Overview
+
+The Go test adapter allows you to:
+- Run standard `*_test.go` files as OTE tests
+- Embed compiled test binaries in your test extension
+- Configure test metadata (tags, timeouts, lifecycle) via source code comments
+- Automatically discover tests without manual registration
+- Support both serial and parallel test execution
+
+## Quick Start
+
+### 1. Write Standard Go Tests
+
+Write normal Go tests with metadata in comments:
+
+```go
+package eventttl_test
+
+import "testing"
+
+// Timeout: 60m
+// Tags: Serial
+// Lifecycle: Blocking
+func TestEventTTLController(t *testing.T) {
+    // Your test code here
+}
+
+// Tags: Parallel
+// Lifecycle: Informing
+func TestEventTTLValidation(t *testing.T) {
+    // This test can run in parallel
+}
+```
+
+### 2. Configure Your Build
+
+Add to your `Makefile`:
+
+```makefile
+# Directory structure
+TEST_EXTENSION_DIR := cmd/my-operator-tests-ext
+GOTEST_DIR := $(TEST_EXTENSION_DIR)/gotest
+COMPILED_TESTS_DIR := $(GOTEST_DIR)/compiled_tests
+
+# Build individual test binaries
+$(COMPILED_TESTS_DIR)/%.test: test/%
+	@mkdir -p $(COMPILED_TESTS_DIR)
+	go test -c -o $@ ./$<
+
+# Generate metadata.json from source comments
+$(COMPILED_TESTS_DIR)/metadata.json: test/*
+	@mkdir -p $(COMPILED_TESTS_DIR)
+	go run github.com/openshift-eng/openshift-tests-extension/pkg/gotest/cmd/generate-metadata \
+		$@ test/eventttl test/encryption
+
+# Build all test binaries
+.PHONY: build-test-binaries
+build-test-binaries: $(COMPILED_TESTS_DIR)/eventttl.test $(COMPILED_TESTS_DIR)/metadata.json
+```
+
+### 3. Integrate with Your Test Extension
+
+In your test extension's main.go:
+
+```go
+package main
+
+import (
+	"embed"
+	"log"
+
+	"github.com/openshift-eng/openshift-tests-extension/pkg/extension"
+	"github.com/openshift-eng/openshift-tests-extension/pkg/gotest"
+)
+
+//go:embed gotest/compiled_tests/*.test gotest/compiled_tests/metadata.json
+var compiledTests embed.FS
+
+func main() {
+	// Configure the gotest adapter
+	config := gotest.GoTestAdapterConfig{
+		TestPrefix:       "[sig-api-machinery] my-operator",
+		CompiledTests:    compiledTests,
+		CompiledTestsDir: "gotest/compiled_tests",
+		MetadataFileName: "metadata.json",
+	}
+
+	// Build test specs
+	specs, err := gotest.BuildExtensionTestSpecs(config)
+	if err != nil {
+		log.Fatalf("Failed to build test specs: %v", err)
+	}
+
+	// Register with OTE
+	ext := extension.New("my-operator-tests")
+	ext.AddTestSpecs(specs)
+	ext.Run()
+}
+```
+
+## Metadata Format
+
+Test metadata is specified in comments above test functions:
+
+### Timeout
+
+Specifies how long the test can run:
+
+```go
+// Timeout: 60m
+func TestLongRunning(t *testing.T) { ... }
+```
+
+### Tags
+
+Controls test execution mode:
+
+```go
+// Tags: Serial
+func TestSerial(t *testing.T) { ... }  // Runs only in serial mode
+
+// Tags: Parallel
+func TestParallel(t *testing.T) { ... }  // Can run in parallel
+
+// Tags: Serial, Slow
+func TestSlowSerial(t *testing.T) { ... }  // Multiple tags
+```
+
+**Important**: By default, tests are marked `Serial` for safety. Use `Parallel` tag only if your test is thread-safe.
+
+### Lifecycle
+
+Determines whether test failures block CI:
+
+```go
+// Lifecycle: Blocking
+func TestCritical(t *testing.T) { ... }  // Failures block CI
+
+// Lifecycle: Informing
+func TestOptional(t *testing.T) { ... }  // Failures don't block CI (default)
+```
+
+## Architecture
+
+### Build Time
+
+1. **Source Code** → `generate-metadata` tool scans `*_test.go` files
+2. **metadata.json** generated with all test metadata
+3. **Test Binaries** compiled using `go test -c`
+4. Both embedded in test extension binary via `//go:embed`
+
+### Runtime
+
+1. **Extraction**: Embedded binaries extracted to temp directory
+2. **Discovery**: Each binary queried with `-test.list` to find all tests
+3. **Metadata Lookup**: Test metadata loaded from `metadata.json`
+4. **Registration**: ExtensionTestSpecs created for each test
+5. **Execution**: Tests run via `-test.run` with exact test name
+
+## Advanced Usage
+
+### Custom Test Prefix
+
+The `TestPrefix` appears in all test names:
+
+```go
+config := gotest.GoTestAdapterConfig{
+	TestPrefix: "[sig-auth][Late] openshift-apiserver",
+	// ...
+}
+```
+
+Results in test names like:
+```
+[sig-auth][Late] openshift-apiserver TestAuthentication [Serial] [Timeout:30m]
+```
+
+### Multiple Test Directories
+
+Generate metadata from multiple directories:
+
+```bash
+go run .../generate-metadata metadata.json \
+	test/eventttl \
+	test/encryption \
+	test/validation
+```
+
+### Omitting Test Prefix
+
+Set `TestPrefix` to empty string for simple test names:
+
+```go
+config := gotest.GoTestAdapterConfig{
+	TestPrefix: "",  // Test names will be just "TestName [Tags]"
+	// ...
+}
+```
+
+## Directory Structure Example
+
+```
+my-operator/
+├── test/
+│   ├── eventttl/
+│   │   ├── controller_test.go
+│   │   └── validation_test.go
+│   └── encryption/
+│       └── rotation_test.go
+├── cmd/
+│   └── my-operator-tests-ext/
+│       ├── main.go
+│       └── gotest/
+│           └── compiled_tests/        # Generated at build time
+│               ├── eventttl.test      # Embedded binary
+│               ├── encryption.test    # Embedded binary
+│               └── metadata.json      # Embedded metadata
+└── Makefile
+```
+
+## Benefits
+
+1. **Reusable**: Same adapter works for all operators
+2. **Type-Safe**: Standard Go testing package
+3. **IDE Support**: Full IDE support for Go tests
+4. **No Manual Registration**: Tests auto-discovered
+5. **Build-Time Metadata**: No runtime parsing needed
+6. **OTE Integration**: Full OTE features (parallel execution, lifecycle, etc.)
+
+## Comparison with Ginkgo Adapter
+
+| Feature | Go Test Adapter | Ginkgo Adapter |
+|---------|----------------|----------------|
+| Test Framework | `testing.T` | Ginkgo/Gomega |
+| Discovery | `-test.list` | Ginkgo outline |
+| Metadata | Comments | Ginkgo labels |
+| Learning Curve | Low (standard Go) | Medium (Ginkgo DSL) |
+| Complexity | Simple | More features |
+
+## Contributing
+
+When contributing to other operators:
+- Use consistent `TestPrefix` format: `[sig-xxx] operator-name`
+- Default to `Serial` and `Informing` for safety
+- Document timeout requirements
+- Use `Blocking` lifecycle only for critical tests

pkg/gotest/adapter.go

@@ -0,0 +1,136 @@
+package gotest
+
+import (
+	"embed"
+	"encoding/json"
+	"fmt"
+	"io/fs"
+	"os"
+	"path/filepath"
+
+	et "github.com/openshift-eng/openshift-tests-extension/pkg/extension/extensiontests"
+)
+
+// GoTestAdapterConfig configures the gotest adapter for an operator's test suite
+type GoTestAdapterConfig struct {
+	// TestPrefix is prepended to all test names (e.g., "[sig-api-machinery] kube-apiserver operator")
+	TestPrefix string
+
+	// CompiledTests is the embedded filesystem containing test binaries and metadata.json
+	CompiledTests embed.FS
+
+	// CompiledTestsDir is the directory path within the embed.FS (e.g., "compiled_tests")
+	CompiledTestsDir string
+
+	// MetadataFileName is the name of the metadata file (default: "metadata.json")
+	MetadataFileName string
+}
+
+// testMetadataCache holds parsed metadata for quick lookup
+var testMetadataCache map[string]TestMetadataEntry
+
+// MetadataFile holds all test metadata (must match generate_metadata.go)
+type MetadataFile struct {
+	TestDirectory string              `json:"testDirectory"`
+	Tests         []TestMetadataEntry `json:"tests"`
+}
+
+// TestMetadataEntry holds metadata for a single test (must match generate_metadata.go)
+type TestMetadataEntry struct {
+	Name      string   `json:"name"`
+	Timeout   string   `json:"timeout,omitempty"`
+	Tags      []string `json:"tags,omitempty"`
+	Lifecycle string   `json:"lifecycle,omitempty"`
+}
+
+// BuildExtensionTestSpecs discovers all Go tests from embedded test binaries
+// This follows the OTE adapter pattern (similar to Cypress/Ginkgo)
+func BuildExtensionTestSpecs(config GoTestAdapterConfig) (et.ExtensionTestSpecs, error) {
+	// Set defaults
+	if config.MetadataFileName == "" {
+		config.MetadataFileName = "metadata.json"
+	}
+
+	var specs et.ExtensionTestSpecs
+
+	// Load metadata from embedded JSON
+	if err := loadMetadata(config); err != nil {
+		return nil, fmt.Errorf("failed to load test metadata: %w", err)
+	}
+
+	// Extract embedded test binaries to temporary directory
+	tmpDir, err := os.MkdirTemp("", "gotest-adapter-*")
+	if err != nil {
+		return nil, fmt.Errorf("failed to create temp dir: %w", err)
+	}
+
+	// Walk through embedded test binaries
+	err = fs.WalkDir(config.CompiledTests, config.CompiledTestsDir, func(path string, d fs.DirEntry, err error) error {
+		if err != nil {
+			return err
+		}
+
+		if d.IsDir() || !d.Type().IsRegular() {
+			return nil
+		}
+
+		// Skip metadata file - it's not a binary
+		if filepath.Base(path) == config.MetadataFileName {
+			return nil
+		}
+
+		// Extract binary to temp directory
+		data, err := config.CompiledTests.ReadFile(path)
+		if err != nil {
+			return fmt.Errorf("failed to read embedded file %s: %w", path, err)
+		}
+
+		binaryName := filepath.Base(path)
+		tmpBinary := filepath.Join(tmpDir, binaryName)
+
+		if err := os.WriteFile(tmpBinary, data, 0755); err != nil {
+			return fmt.Errorf("failed to write binary %s: %w", tmpBinary, err)
+		}
+
+		// Discover tests from this binary
+		binarySpecs, err := discoverTestsFromBinary(tmpBinary, binaryName, config.TestPrefix)
+		if err != nil {
+			return fmt.Errorf("failed to discover tests from %s: %w", binaryName, err)
+		}
+
+		specs = append(specs, binarySpecs...)
+		return nil
+	})
+
+	if err != nil {
+		return nil, fmt.Errorf("failed to walk embedded tests: %w", err)
+	}
+
+	return specs, nil
+}
+
+// loadMetadata loads test metadata from embedded JSON file
+func loadMetadata(config GoTestAdapterConfig) error {
+	// Read metadata file from embedded filesystem
+	metadataPath := filepath.Join(config.CompiledTestsDir, config.MetadataFileName)
+	data, err := config.CompiledTests.ReadFile(metadataPath)
+	if err != nil {
+		return fmt.Errorf("failed to read %s: %w", metadataPath, err)
+	}
+
+	// Parse JSON
+	var metadataFiles []MetadataFile
+	if err := json.Unmarshal(data, &metadataFiles); err != nil {
+		return fmt.Errorf("failed to parse %s: %w", metadataPath, err)
+	}
+
+	// Build lookup map: testName -> metadata
+	testMetadataCache = make(map[string]TestMetadataEntry)
+	for _, file := range metadataFiles {
+		for _, test := range file.Tests {
+			testMetadataCache[test.Name] = test
+		}
+	}
+
+	return nil
+}