feat: add aibtest package for testing utilities

This creates a proper testing package to address the tech debt identified
in issue #73. The package consolidates the scattered test helpers and
provides well-structured components that reduce boilerplate and improve
test readability.

New components:
- MockUpstreamServer: Simulates LLM provider API responses using txtar
  fixtures. Supports streaming/non-streaming responses and response
  mutation for multi-turn conversations.

- MockMCPServer: Provides a mock MCP server with integrated call tracking.
  Combines the server, HTTP endpoint, and call accumulator into a single
  struct, eliminating the need for separate callAccumulator management.

- MockRecorder: Implements aibridge.Recorder for testing with convenient
  accessor methods (Interceptions, TokenUsages, ToolUsages, etc.) and
  verification helpers (VerifyAllInterceptionsEnded, TotalInputTokens).

- TestBridge: Combines bridge, HTTP server, recorder, and optional MCP
  server into a single easy-to-use struct with DoAnthropicRequest and
  DoOpenAIRequest methods.

Helper functions:
- FilesMap, SetStreamingInRequest, CreateAnthropicMessagesRequest,
  CreateOpenAIChatCompletionsRequest, AnthropicConfig, OpenAIConfig

This addresses the issues mentioned in #73:
- callAccumulator is now integrated into MockMCPServer
- setupMCPServerProxiesForTest return values are consolidated into MockMCPServer
- Common test patterns are abstracted into TestBridge

Resolves #73

Author: ibetitsmike

aibtest/aibtest_test.go

@@ -0,0 +1,232 @@
+package aibtest_test
+
+import (
+	"context"
+	_ "embed"
+	"encoding/json"
+	"io"
+	"net/http"
+	"testing"
+	"time"
+
+	"github.com/coder/aibridge"
+	"github.com/coder/aibridge/aibtest"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"go.uber.org/goleak"
+)
+
+//go:embed testdata/anthropic_simple.txtar
+var anthropicSimple []byte
+
+//go:embed testdata/openai_simple.txtar
+var openaiSimple []byte
+
+func TestMain(m *testing.M) {
+	goleak.VerifyTestMain(m)
+}
+
+func TestMockUpstreamServer(t *testing.T) {
+	t.Parallel()
+
+	ctx, cancel := context.WithTimeout(t.Context(), time.Second*30)
+	t.Cleanup(cancel)
+
+	t.Run("serves streaming response", func(t *testing.T) {
+		t.Parallel()
+
+		srv := aibtest.NewMockUpstreamServer(t, ctx, anthropicSimple)
+
+		reqBody := srv.Files()[aibtest.FixtureRequest]
+		reqBody = aibtest.SetStreamingInRequest(t, reqBody, true)
+
+		req := aibtest.CreateAnthropicMessagesRequest(t, srv.URL, reqBody)
+		resp, err := http.DefaultClient.Do(req)
+		require.NoError(t, err)
+		defer resp.Body.Close()
+
+		require.Equal(t, http.StatusOK, resp.StatusCode)
+		require.Equal(t, "text/event-stream", resp.Header.Get("Content-Type"))
+		require.EqualValues(t, 1, srv.CallCount())
+	})
+
+	t.Run("serves non-streaming response", func(t *testing.T) {
+		t.Parallel()
+
+		srv := aibtest.NewMockUpstreamServer(t, ctx, anthropicSimple)
+
+		reqBody := srv.Files()[aibtest.FixtureRequest]
+		reqBody = aibtest.SetStreamingInRequest(t, reqBody, false)
+
+		req := aibtest.CreateAnthropicMessagesRequest(t, srv.URL, reqBody)
+		resp, err := http.DefaultClient.Do(req)
+		require.NoError(t, err)
+		defer resp.Body.Close()
+
+		require.Equal(t, http.StatusOK, resp.StatusCode)
+		require.Equal(t, "application/json", resp.Header.Get("Content-Type"))
+		require.EqualValues(t, 1, srv.CallCount())
+	})
+
+	t.Run("custom status code", func(t *testing.T) {
+		t.Parallel()
+
+		srv := aibtest.NewMockUpstreamServer(t, ctx, anthropicSimple, aibtest.WithStatusCode(http.StatusInternalServerError))
+
+		reqBody := srv.Files()[aibtest.FixtureRequest]
+		req := aibtest.CreateAnthropicMessagesRequest(t, srv.URL, reqBody)
+		resp, err := http.DefaultClient.Do(req)
+		require.NoError(t, err)
+		defer resp.Body.Close()
+
+		require.Equal(t, http.StatusInternalServerError, resp.StatusCode)
+	})
+}
+
+func TestMockMCPServer(t *testing.T) {
+	t.Parallel()
+
+	ctx, cancel := context.WithTimeout(t.Context(), time.Second*30)
+	t.Cleanup(cancel)
+
+	t.Run("tracks tool calls", func(t *testing.T) {
+		t.Parallel()
+
+		mcpServer := aibtest.NewMockMCPServer(t, aibtest.TestTracer(),
+			aibtest.WithToolNames([]string{"test_tool"}),
+		)
+
+		require.NoError(t, mcpServer.Init(ctx))
+
+		tools := mcpServer.Proxy.ListTools()
+		require.Len(t, tools, 1)
+		require.Equal(t, "test_tool", tools[0].Name)
+
+		// Call the tool using the tool ID (which is different from the name)
+		toolID := tools[0].ID
+		_, err := mcpServer.Proxy.CallTool(ctx, toolID, map[string]any{"arg": "value"})
+		require.NoError(t, err)
+
+		// GetToolCalls uses tool name
+		calls := mcpServer.GetToolCalls("test_tool")
+		require.Len(t, calls, 1)
+		require.Equal(t, 1, mcpServer.TotalCallCount())
+	})
+
+	t.Run("creates MCP manager", func(t *testing.T) {
+		t.Parallel()
+
+		mcpServer := aibtest.NewMockMCPServer(t, aibtest.TestTracer())
+		mgr := mcpServer.NewMCPManager(ctx, t, aibtest.TestTracer())
+
+		tools := mgr.ListTools()
+		require.NotEmpty(t, tools)
+	})
+}
+
+func TestMockRecorder(t *testing.T) {
+	t.Parallel()
+
+	ctx := t.Context()
+
+	t.Run("records interceptions", func(t *testing.T) {
+		t.Parallel()
+
+		recorder := aibtest.NewMockRecorder()
+
+		err := recorder.RecordInterception(ctx, &aibridge.InterceptionRecord{
+			ID:    "test-id",
+			Model: "test-model",
+		})
+		require.NoError(t, err)
+
+		interceptions := recorder.Interceptions()
+		require.Len(t, interceptions, 1)
+		assert.Equal(t, "test-id", interceptions[0].ID)
+	})
+
+	t.Run("records token usage", func(t *testing.T) {
+		t.Parallel()
+
+		recorder := aibtest.NewMockRecorder()
+
+		_ = recorder.RecordTokenUsage(ctx, &aibridge.TokenUsageRecord{Input: 10, Output: 20})
+		_ = recorder.RecordTokenUsage(ctx, &aibridge.TokenUsageRecord{Input: 5, Output: 15})
+
+		assert.EqualValues(t, 15, recorder.TotalInputTokens())
+		assert.EqualValues(t, 35, recorder.TotalOutputTokens())
+	})
+
+	t.Run("verifies interceptions ended", func(t *testing.T) {
+		t.Parallel()
+
+		recorder := aibtest.NewMockRecorder()
+
+		_ = recorder.RecordInterception(ctx, &aibridge.InterceptionRecord{ID: "test-id"})
+		_ = recorder.RecordInterceptionEnded(ctx, &aibridge.InterceptionRecordEnded{
+			ID:      "test-id",
+			EndedAt: time.Now(),
+		})
+
+		recorder.VerifyAllInterceptionsEnded(t)
+	})
+}
+
+func TestTestBridge(t *testing.T) {
+	t.Parallel()
+
+	ctx, cancel := context.WithTimeout(t.Context(), time.Second*30)
+	t.Cleanup(cancel)
+
+	t.Run("anthropic request", func(t *testing.T) {
+		t.Parallel()
+
+		upstream := aibtest.NewMockUpstreamServer(t, ctx, anthropicSimple)
+
+		bridge := aibtest.NewTestBridge(t, ctx, aibtest.TestBridgeOptions{
+			Provider: aibridge.NewAnthropicProvider(aibtest.AnthropicConfig(upstream.URL, aibtest.DefaultAPIKey), nil),
+		})
+
+		reqBody := upstream.Files()[aibtest.FixtureRequest]
+		resp := bridge.DoAnthropicRequest(t, reqBody)
+		defer resp.Body.Close()
+
+		require.Equal(t, http.StatusOK, resp.StatusCode)
+
+		body, err := io.ReadAll(resp.Body)
+		require.NoError(t, err)
+
+		// Verify it's valid JSON
+		var result map[string]any
+		require.NoError(t, json.Unmarshal(body, &result))
+
+		// Verify recorder captured the interception
+		bridge.Recorder.VerifyAllInterceptionsEnded(t)
+	})
+
+	t.Run("openai request", func(t *testing.T) {
+		t.Parallel()
+
+		upstream := aibtest.NewMockUpstreamServer(t, ctx, openaiSimple)
+
+		bridge := aibtest.NewTestBridge(t, ctx, aibtest.TestBridgeOptions{
+			Provider: aibridge.NewOpenAIProvider(aibtest.OpenAIConfig(upstream.URL, aibtest.DefaultAPIKey)),
+		})
+
+		reqBody := upstream.Files()[aibtest.FixtureRequest]
+		resp := bridge.DoOpenAIRequest(t, reqBody)
+		defer resp.Body.Close()
+
+		require.Equal(t, http.StatusOK, resp.StatusCode)
+
+		body, err := io.ReadAll(resp.Body)
+		require.NoError(t, err)
+
+		// Verify it's valid JSON
+		var result map[string]any
+		require.NoError(t, json.Unmarshal(body, &result))
+
+		// Verify recorder captured the interception
+		bridge.Recorder.VerifyAllInterceptionsEnded(t)
+	})
+}