Add mock handler

Implement a mock handler that validates the test framework itself.
The handler embeds test cases, reads requests from stdin, and returns expected responses from the JSON test files.

Author: stringintech

.github/workflows/test.yml

@@ -0,0 +1,24 @@
+name: CI
+
+on:
+  push:
+  pull_request:
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+
+    steps:
+    - name: Checkout code
+      uses: actions/checkout@v4
+
+    - name: Set up Go
+      uses: actions/setup-go@v5
+      with:
+        go-version: '1.23'
+
+    - name: Build
+      run: make build
+
+    - name: Run tests against mock handler
+      run: make test

.gitignore

@@ -0,0 +1 @@
+/build/

Makefile

@@ -0,0 +1,27 @@
+.PHONY: all build test clean runner mock-handler deps lint
+
+BUILD_DIR := build
+RUNNER_BIN := $(BUILD_DIR)/runner
+MOCK_HANDLER_BIN := $(BUILD_DIR)/mock-handler
+
+all: build test
+
+build: runner mock-handler
+
+runner:
+	@echo "Building test runner..."
+	@mkdir -p $(BUILD_DIR)
+	go build -o $(RUNNER_BIN) ./cmd/runner
+
+mock-handler:
+	@echo "Building mock handler..."
+	@mkdir -p $(BUILD_DIR)
+	go build -o $(MOCK_HANDLER_BIN) ./cmd/mock-handler
+
+test:
+	@echo "Running conformance tests with mock handler..."
+	$(RUNNER_BIN) -handler $(MOCK_HANDLER_BIN)
+
+clean:
+	@echo "Cleaning build artifacts..."
+	rm -rf $(BUILD_DIR)

README.md

@@ -32,8 +32,21 @@ The framework ensures that all language bindings (Go, Python, Rust, etc.) behave
 **This repository contains:**
 1. [**Test Runner**](./cmd/runner/main.go): Spawns handler binary, sends test requests via stdin, validates responses from stdout
 2. [**Test Cases**](./testdata): JSON files defining requests and expected responses
+3. [**Mock Handler**](./cmd/mock-handler/main.go): Validates the runner by echoing expected responses from test cases
 
 **Handler binaries** are not hosted in this repository. They must be implemented separately and should:
 - Implement the JSON protocol for communication with the test runner
 - Call the binding API to execute operations
-- Pin to a specific version/tag of this test repository
+- Pin to a specific version/tag of this test repository
+
+## Getting Started
+
+Build and test against the mock handler:
+
+```bash
+# Build both runner and mock handler
+make build
+
+# Run tests against the mock handler
+make test
+```

cmd/mock-handler/main.go

@@ -0,0 +1,158 @@
+package main
+
+import (
+	"bufio"
+	"encoding/json"
+	"fmt"
+	"io/fs"
+	"os"
+
+	"github.com/stringintech/kernel-bindings-tests/runner"
+	"github.com/stringintech/kernel-bindings-tests/testdata"
+)
+
+func main() {
+	// Build a map of test ID -> filename
+	testIndex, err := buildTestIndex()
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "Failed to build test index: %v\n", err)
+		os.Exit(1)
+	}
+
+	// Read requests from stdin and respond with expected results
+	scanner := bufio.NewScanner(os.Stdin)
+	for scanner.Scan() {
+		line := scanner.Text()
+		if err := handleRequest(line, testIndex); err != nil {
+			fmt.Fprintf(os.Stderr, "Error handling request: %v\n", err)
+			continue
+		}
+	}
+
+	if err := scanner.Err(); err != nil {
+		fmt.Fprintf(os.Stderr, "Error reading stdin: %v\n", err)
+		os.Exit(1)
+	}
+}
+
+// buildTestIndex creates a map of test ID -> filename without loading full test data
+func buildTestIndex() (map[string]string, error) {
+	testFiles, err := fs.Glob(testdata.FS, "*.json")
+	if err != nil {
+		return nil, fmt.Errorf("failed to find test files: %w", err)
+	}
+
+	index := make(map[string]string)
+	for _, testFile := range testFiles {
+		// Read file to extract test IDs only
+		data, err := fs.ReadFile(testdata.FS, testFile)
+		if err != nil {
+			return nil, fmt.Errorf("failed to read test file %s: %w", testFile, err)
+		}
+
+		// Parse just enough to get test IDs
+		var suite struct {
+			Tests []struct {
+				ID string `json:"id"`
+			} `json:"tests"`
+		}
+		if err := json.Unmarshal(data, &suite); err != nil {
+			return nil, fmt.Errorf("failed to parse test file %s: %w", testFile, err)
+		}
+
+		for _, test := range suite.Tests {
+			index[test.ID] = testFile
+		}
+	}
+
+	return index, nil
+}
+
+// handleRequest processes a single request and outputs the expected response
+func handleRequest(line string, testIndex map[string]string) error {
+	// Parse request
+	var req runner.Request
+	if err := json.Unmarshal([]byte(line), &req); err != nil {
+		return fmt.Errorf("failed to parse request: %w", err)
+	}
+
+	filename, ok := testIndex[req.ID]
+	if !ok {
+		resp := runner.Response{
+			ID: req.ID,
+			Error: &runner.ErrorObj{
+				Code:    "UNKNOWN_TEST",
+				Message: fmt.Sprintf("No test case found with ID: %s", req.ID),
+			},
+		}
+		return writeResponse(resp)
+	}
+
+	// Load the test suite containing this test case
+	suite, err := runner.LoadTestSuiteFromFS(testdata.FS, filename)
+	if err != nil {
+		resp := runner.Response{
+			ID: req.ID,
+			Error: &runner.ErrorObj{
+				Code:    "LOAD_ERROR",
+				Message: fmt.Sprintf("Failed to load test suite: %v", err),
+			},
+		}
+		return writeResponse(resp)
+	}
+
+	// Find the specific test case
+	var testCase *runner.TestCase
+	for _, test := range suite.Tests {
+		if test.ID == req.ID {
+			testCase = &test
+			break
+		}
+	}
+	if testCase == nil {
+		resp := runner.Response{
+			ID: req.ID,
+			Error: &runner.ErrorObj{
+				Code:    "TEST_NOT_FOUND",
+				Message: fmt.Sprintf("Test case %s not found in file %s", req.ID, filename),
+			},
+		}
+		return writeResponse(resp)
+	}
+
+	// Verify method matches
+	if req.Method != testCase.Method {
+		resp := runner.Response{
+			ID: req.ID,
+			Error: &runner.ErrorObj{
+				Code:    "METHOD_MISMATCH",
+				Message: fmt.Sprintf("Expected method %s, got %s", testCase.Method, req.Method),
+			},
+		}
+		return writeResponse(resp)
+	}
+
+	// Build response based on expected result
+	var resp runner.Response
+	resp.ID = req.ID
+	if testCase.Expected.Error != nil {
+		resp.Error = &runner.ErrorObj{
+			Code:    testCase.Expected.Error.Code,
+			Message: testCase.Expected.Error.Message,
+		}
+	}
+	if testCase.Expected.Success != nil {
+		resp.Result = *testCase.Expected.Success
+	}
+	return writeResponse(resp)
+}
+
+// writeResponse writes a response to stdout as JSON
+func writeResponse(resp runner.Response) error {
+	data, err := json.Marshal(resp)
+	if err != nil {
+		return fmt.Errorf("failed to marshal response: %w", err)
+	}
+	fmt.Println(string(data))
+	return nil
+}