Test Coverage Gaps Specification¶

func TestCompareVersions(t *testing.T) {
    tests := []struct {
        name     string
        a, b     string
        expected int
    }{
        {"equal", "1.0.0", "1.0.0", 0},
        {"a greater major", "2.0.0", "1.0.0", 1},
        {"b greater minor", "1.0.0", "1.1.0", -1},
        {"a greater patch", "1.0.2", "1.0.1", 1},
        {"prerelease vs release", "1.0.0-beta", "1.0.0", -1},
        {"v prefix", "v1.0.0", "1.0.0", 0},
        {"empty a", "", "1.0.0", -1},
        {"empty b", "1.0.0", "", 1},
        {"both empty", "", "", 0},
        {"invalid a", "not-a-version", "1.0.0", -1},
    }
    for _, tt := range tests {
        t.Run(tt.name, func(t *testing.T) {
            result := CompareVersions(tt.a, tt.b)
            assert.Equal(t, tt.expected, result)
        })
    }
}

func TestIsDevelopment(t *testing.T) {
    tests := []struct {
        name    string
        version string
        isDev   bool
    }{
        {"dev version", "dev", true},
        {"development", "development", true},
        {"release", "1.2.3", false},
        {"empty", "", true},
    }
    // ...
}

func TestGitLabClient_CreateRelease(t *testing.T) {
    server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        switch {
        case r.Method == "POST" && strings.Contains(r.URL.Path, "/releases"):
            w.WriteHeader(http.StatusCreated)
            json.NewEncoder(w).Encode(map[string]string{"tag_name": "v1.0.0"})
        default:
            w.WriteHeader(http.StatusNotFound)
        }
    }))
    defer server.Close()

    client := NewGitLabClient(server.URL, "test-token")
    err := client.CreateRelease(context.Background(), "v1.0.0", "Release notes")
    assert.NoError(t, err)
}

func TestGitLabClient_CreateRelease_Unauthorized(t *testing.T) {
    server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        w.WriteHeader(http.StatusUnauthorized)
    }))
    defer server.Close()

    client := NewGitLabClient(server.URL, "bad-token")
    err := client.CreateRelease(context.Background(), "v1.0.0", "notes")
    assert.Error(t, err)
}

type mockReleaseProvider struct {
    createFunc func(ctx context.Context, tag, notes string) error
    latestFunc func(ctx context.Context) (string, error)
}

func TestReleaseManager_Create(t *testing.T) {
    tests := []struct {
        name      string
        provider  mockReleaseProvider
        tag       string
        expectErr bool
    }{
        {
            name: "success",
            provider: mockReleaseProvider{
                createFunc: func(ctx context.Context, tag, notes string) error { return nil },
            },
            tag: "v1.0.0",
        },
        {
            name: "provider error",
            provider: mockReleaseProvider{
                createFunc: func(ctx context.Context, tag, notes string) error {
                    return errors.New("API error")
                },
            },
            tag:       "v1.0.0",
            expectErr: true,
        },
    }
    // ...
}

func TestClaude_Ask_Success(t *testing.T) {
    server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        resp := map[string]any{
            "content": []map[string]string{{"type": "text", "text": `{"answer": "42"}`}},
            "stop_reason": "end_turn",
        }
        json.NewEncoder(w).Encode(resp)
    }))
    defer server.Close()

    client := newTestClaudeClient(t, server.URL)
    var result struct{ Answer string }
    err := client.Ask(context.Background(), "What is the answer?", &result)
    assert.NoError(t, err)
    assert.Equal(t, "42", result.Answer)
}

func TestClaude_Ask_ContextCancelled(t *testing.T) {
    server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        time.Sleep(5 * time.Second) // simulate slow response
    }))
    defer server.Close()

    ctx, cancel := context.WithCancel(context.Background())
    cancel() // cancel immediately

    client := newTestClaudeClient(t, server.URL)
    var result string
    err := client.Ask(ctx, "question", &result)
    assert.Error(t, err)
}

func TestHTTPServer_StartStop(t *testing.T) {
    ctrl := controls.NewController(context.Background())
    srv := NewHTTPServer(ctrl, ":0") // random port

    ctrl.Start()
    // Verify server is accepting connections
    // ...
    ctrl.Stop()
    // Verify server has shut down
}

func TestGRPCServer_StartStop(t *testing.T) {
    ctrl := controls.NewController(context.Background())
    srv := NewGRPCServer(ctrl, ":0")

    ctrl.Start()
    // Verify gRPC server is serving
    // ...
    ctrl.Stop()
}

func TestParseNav_EmptyNav(t *testing.T) {
    result := ParseNav([]byte("nav: []"))
    assert.Empty(t, result)
}

func TestParseNav_NestedSections(t *testing.T) {
    yaml := `nav:
  - Home: index.md
  - Guide:
    - Getting Started: guide/start.md
    - Advanced:
      - Plugins: guide/advanced/plugins.md`
    result := ParseNav([]byte(yaml))
    assert.Len(t, result, 2)
    // verify nested structure
}

func TestParseNav_InvalidYAML(t *testing.T) {
    result := ParseNav([]byte("not: valid: yaml: ["))
    assert.Empty(t, result)
}

// testhelpers_test.go in pkg/chat/
func newMockAPIServer(t *testing.T, handler http.HandlerFunc) *httptest.Server {
    t.Helper()
    server := httptest.NewServer(handler)
    t.Cleanup(server.Close)
    return server
}

func newTestClaudeClient(t *testing.T, baseURL string) ChatClient {
    t.Helper()
    // construct client pointing at mock server
}