Add test re-exec pattern for simulating handler behaviors

Introduce HandlerConfig struct and refactor NewHandler to support custom args/env. Add TestMain-based re-exec pattern allowing the test binary to serve as both test runner and mock handler subprocess.

This enables unit testing of different handler behaviors (normal, crash, hang, unresponsive) without external fixtures, verifying the runner correctly handles each scenario.

Author: stringintech

Makefile

@@ -20,7 +20,7 @@ mock-handler:
 
 test:
 	@echo "Running runner unit tests..."
-	go test ./runner/...
+	go test -v ./runner/...
 	@echo "Running conformance tests with mock handler..."
 	$(RUNNER_BIN) -handler $(MOCK_HANDLER_BIN)
 

runner/handler.go

@@ -18,6 +18,13 @@ var (
 	ErrHandlerClosed = errors.New("handler closed unexpectedly")
 )
 
+// HandlerConfig configures a handler process
+type HandlerConfig struct {
+	Path string
+	Args []string
+	Env  []string
+}
+
 // Handler manages a conformance handler process communicating via stdin/stdout
 type Handler struct {
 	cmd    *exec.Cmd
@@ -26,9 +33,12 @@ type Handler struct {
 	stderr io.ReadCloser
 }
 
-// NewHandler spawns a new handler process at the given path
-func NewHandler(path string) (*Handler, error) {
-	cmd := exec.Command(path)
+// NewHandler spawns a new handler process with the given configuration
+func NewHandler(cfg HandlerConfig) (*Handler, error) {
+	cmd := exec.Command(cfg.Path, cfg.Args...)
+	if cfg.Env != nil {
+		cmd.Env = append(cmd.Environ(), cfg.Env...)
+	}
 
 	stdin, err := cmd.StdinPipe()
 	if err != nil {

runner/handler_test.go

@@ -0,0 +1,98 @@
+package runner
+
+import (
+	"bufio"
+	"fmt"
+	"os"
+	"testing"
+)
+
+const (
+	// envTestAsSubprocess signals the binary to run as a subprocess helper.
+	envTestAsSubprocess = "TEST_AS_SUBPROCESS"
+
+	// envTestHelperName specifies which helper function to execute in subprocess mode.
+	envTestHelperName = "TEST_HELPER_NAME"
+
+	helperNameNormal = "normal"
+)
+
+// testHelpers maps helper names to functions that simulate different handler behaviors.
+var testHelpers = map[string]func(){
+	helperNameNormal: helperNormal,
+}
+
+// TestMain allows the test binary to serve two purposes:
+// 1. Normal mode: runs tests when TEST_AS_SUBPROCESS != "1"
+// 2. Subprocess mode: executes a helper function when TEST_AS_SUBPROCESS == "1"
+//
+// This enables tests to spawn the binary itself as a mock handler subprocess,
+// avoiding the need for separate test fixture binaries.
+func TestMain(m *testing.M) {
+	if os.Getenv(envTestAsSubprocess) != "1" {
+		// Run tests normally
+		os.Exit(m.Run())
+	}
+
+	// Run as subprocess helper based on which helper is requested
+	helperName := os.Getenv(envTestHelperName)
+	if helper, ok := testHelpers[helperName]; ok {
+		helper()
+	} else {
+		fmt.Fprintf(os.Stderr, "Unknown test helper: %s\n", helperName)
+		os.Exit(1)
+	}
+}
+
+// TestHandler_NormalOperation tests that a well-behaved handler works correctly
+func TestHandler_NormalOperation(t *testing.T) {
+	h, err := newHandlerForTest(t, helperNameNormal)
+	if err != nil {
+		t.Fatalf("Failed to create handler: %v", err)
+	}
+	defer h.Close()
+
+	// Send a request to the handler
+	request := `{"id":1,"method":"test"}`
+	if err := h.SendLine([]byte(request)); err != nil {
+		t.Fatalf("Failed to send request: %v", err)
+	}
+
+	// Read the response
+	line, err := h.ReadLine()
+	if err != nil {
+		t.Fatalf("Failed to read line: %v", err)
+	}
+
+	expected := `{"id":1,"result":true}`
+	if string(line) != expected {
+		t.Errorf("Expected %q, got %q", expected, string(line))
+	}
+}
+
+// helperNormal simulates a normal well-behaved handler that reads a request,
+// validates it, and sends a response.
+func helperNormal() {
+	// Read requests from stdin and respond with expected results
+	scanner := bufio.NewScanner(os.Stdin)
+	for scanner.Scan() {
+		request := scanner.Text()
+		expected := `{"id":1,"method":"test"}`
+		if request != expected {
+			fmt.Fprintf(os.Stderr, "Expected request %q, got %q\n", expected, request)
+			os.Exit(1)
+		}
+		fmt.Println(`{"id":1,"result":true}`)
+	}
+}
+
+// newHandlerForTest creates a Handler that runs a test helper as a subprocess.
+// The helperName identifies which helper to run (e.g., "normal", "crash", "hang").
+func newHandlerForTest(t *testing.T, helperName string) (*Handler, error) {
+	t.Helper()
+
+	return NewHandler(HandlerConfig{
+		Path: os.Args[0],
+		Env:  []string{"TEST_AS_SUBPROCESS=1", "TEST_HELPER_NAME=" + helperName},
+	})
+}

runner/runner.go

@@ -22,7 +22,7 @@ func NewTestRunner(handlerPath string) (*TestRunner, error) {
 		return nil, fmt.Errorf("handler binary not found: %s", handlerPath)
 	}
 
-	handler, err := NewHandler(handlerPath)
+	handler, err := NewHandler(HandlerConfig{Path: handlerPath})
 	if err != nil {
 		return nil, err
 	}
@@ -36,7 +36,7 @@ func NewTestRunner(handlerPath string) (*TestRunner, error) {
 // SendRequest sends a request to the handler, spawning a new handler if needed
 func (tr *TestRunner) SendRequest(req Request) error {
 	if tr.handler == nil {
-		handler, err := NewHandler(tr.handlerPath)
+		handler, err := NewHandler(HandlerConfig{Path: tr.handlerPath})
 		if err != nil {
 			return fmt.Errorf("failed to spawn new handler: %w", err)
 		}