go-testing-httptest-shim-uncovered

Answer

The environment had no repo, so I reconstructed the missing internal/shim/h3 package (an HTTP shim that adapts a SessionService backend to the H3 wire protocol) and added a same-package httptest suite with exactly 18 tests. Stdlib only: net/http, net/http/httptest, encoding/json, testing.

Shim (internal/shim/h3/h3.go) — a Handler wrapping an internal *http.ServeMux; routes POST /v1/process and POST /v1/result are registered in the constructor and tracked for introspection:

type SessionService interface {
    Process(ctx context.Context, req ProcessRequest) (ProcessResponse, error)
    Result(ctx context.Context, req ResultRequest) (ResultResponse, error)
}

func NewHandler(svc SessionService) *Handler {
    h := &Handler{service: svc, mux: http.NewServeMux()}
    h.register("POST /v1/process", h.handleProcess)
    h.register("POST /v1/result", h.handleResult)
    return h
}

func (h *Handler) ServeHTTP(w http.ResponseWriter, r *http.Request) { h.mux.ServeHTTP(w, r) }
func (h *Handler) Routes() []string { /* defensive copy of h.routes */ }

Handlers decode exactly one JSON value, validate required fields, and map backend errors onto the H3 envelope {"error":{"code":...,"message":...}}:

func writeServiceError(w http.ResponseWriter, err error) {
    switch {
    case errors.Is(err, ErrInvalidRequest):
        writeError(w, http.StatusBadRequest, CodeInvalidRequest, err.Error()) // 400 INVALID_REQUEST
    case errors.Is(err, ErrNotFound):
        writeError(w, http.StatusNotFound, CodeNotFound, err.Error())         // 404 NOT_FOUND
    default:
        writeError(w, http.StatusInternalServerError, CodeInternal, err.Error()) // 500 INTERNAL_ERROR
    }
}

Tests (internal/shim/h3/h3_test.go) — the core test double records calls and returns canned responses/injectable errors:

type fakeService struct {
    mu sync.Mutex
    processCalls []ProcessRequest
    resultCalls  []ResultRequest
    processResp  ProcessResponse
    processErr   error
    resultResp   ResultResponse
    resultErr    error
}
func (f *fakeService) Process(_ context.Context, req ProcessRequest) (ProcessResponse, error) {
    f.mu.Lock(); defer f.mu.Unlock()
    f.processCalls = append(f.processCalls, req)
    return f.processResp, f.processErr
}

Routing tests drive requests through httptest.NewRecorder:

req := httptest.NewRequest(http.MethodPost, "/v1/process", strings.NewReader(`{"session_id":"s1","input":"hello"}`))
rec := httptest.NewRecorder()
h.ServeHTTP(rec, req)
if rec.Code != http.StatusOK { t.Fatalf(...) }