test(provider): 增强 openaicompat 子包覆盖率

Generated with [codeagent](https://github.com/qbox/codeagent)
Co-authored-by: phantom5099 <245659304+phantom5099@users.noreply.github.com>

Author: xgopilot

internal/provider/openaicompat/chatcompletions/request_test.go

@@ -0,0 +1,145 @@
+package chatcompletions
+
+import (
+	"context"
+	"io"
+	"strings"
+	"testing"
+
+	"neo-code/internal/provider"
+	providertypes "neo-code/internal/provider/types"
+)
+
+type stubAssetReader struct {
+	data map[string][]byte
+	mime map[string]string
+}
+
+func (s *stubAssetReader) Open(_ context.Context, assetID string) (io.ReadCloser, string, error) {
+	content, ok := s.data[assetID]
+	if !ok {
+		return nil, "", io.EOF
+	}
+	return io.NopCloser(strings.NewReader(string(content))), s.mime[assetID], nil
+}
+
+func TestBuildRequestUsesDefaultModelAndNormalizesTools(t *testing.T) {
+	t.Parallel()
+
+	cfg := provider.RuntimeConfig{DefaultModel: "gpt-default"}
+	payload, err := BuildRequest(context.Background(), cfg, providertypes.GenerateRequest{
+		SystemPrompt: "system",
+		Messages: []providertypes.Message{
+			{
+				Role:  providertypes.RoleUser,
+				Parts: []providertypes.ContentPart{providertypes.NewTextPart("hello"), providertypes.NewTextPart(" world")},
+			},
+		},
+		Tools: []providertypes.ToolSpec{{
+			Name:   "run",
+			Schema: map[string]any{"type": "array"},
+		}},
+	})
+	if err != nil {
+		t.Fatalf("BuildRequest() error = %v", err)
+	}
+	if payload.Model != "gpt-default" {
+		t.Fatalf("expected default model, got %q", payload.Model)
+	}
+	if !payload.Stream {
+		t.Fatal("expected stream=true")
+	}
+	if len(payload.Messages) != 2 {
+		t.Fatalf("expected system+user messages, got %d", len(payload.Messages))
+	}
+	if payload.Messages[1].Content != "hello world" {
+		t.Fatalf("expected collapsed user content, got %+v", payload.Messages[1].Content)
+	}
+	if len(payload.Tools) != 1 || payload.ToolChoice != "auto" {
+		t.Fatalf("expected one auto tool, got choice=%q tools=%d", payload.ToolChoice, len(payload.Tools))
+	}
+	if gotType, _ := payload.Tools[0].Function.Parameters["type"].(string); gotType != "object" {
+		t.Fatalf("expected normalized object schema, got %q", gotType)
+	}
+}
+
+func TestBuildRequestAndToOpenAIMessageErrors(t *testing.T) {
+	t.Parallel()
+
+	t.Run("missing model", func(t *testing.T) {
+		t.Parallel()
+
+		_, err := BuildRequest(context.Background(), provider.RuntimeConfig{}, providertypes.GenerateRequest{})
+		if err == nil || !strings.Contains(err.Error(), "model is empty") {
+			t.Fatalf("expected model error, got %v", err)
+		}
+	})
+
+	t.Run("session asset missing reader", func(t *testing.T) {
+		t.Parallel()
+
+		_, err := ToOpenAIMessage(context.Background(), providertypes.Message{
+			Role: providertypes.RoleUser,
+			Parts: []providertypes.ContentPart{
+				providertypes.NewSessionAssetImagePart("asset_1", "image/png"),
+			},
+		}, nil)
+		if err == nil || !strings.Contains(err.Error(), "session_asset reader is not configured") {
+			t.Fatalf("expected missing reader error, got %v", err)
+		}
+	})
+
+	t.Run("unsupported image source", func(t *testing.T) {
+		t.Parallel()
+
+		_, _, err := toOpenAIMessageWithBudget(context.Background(), providertypes.Message{
+			Role: providertypes.RoleUser,
+			Parts: []providertypes.ContentPart{{
+				Kind: providertypes.ContentPartImage,
+				Image: &providertypes.ImagePart{
+					SourceType: "unsupported",
+				},
+			}},
+		}, nil, 1024, providertypes.DefaultSessionAssetLimits())
+		if err == nil || !strings.Contains(err.Error(), "unsupported source type") {
+			t.Fatalf("expected unsupported source type error, got %v", err)
+		}
+	})
+}
+
+func TestToOpenAIMessageMapsToolCallsAndSessionAsset(t *testing.T) {
+	t.Parallel()
+
+	reader := &stubAssetReader{
+		data: map[string][]byte{"asset_1": []byte("PNG")},
+		mime: map[string]string{"asset_1": "image/png"},
+	}
+	msg, used, err := toOpenAIMessageWithBudget(context.Background(), providertypes.Message{
+		Role: providertypes.RoleAssistant,
+		Parts: []providertypes.ContentPart{
+			providertypes.NewTextPart("look"),
+			providertypes.NewSessionAssetImagePart("asset_1", "image/png"),
+		},
+		ToolCalls: []providertypes.ToolCall{{
+			ID:        "call_1",
+			Name:      "read_file",
+			Arguments: "{\"path\":\"README.md\"}",
+		}},
+	}, reader, 1024, providertypes.DefaultSessionAssetLimits())
+	if err != nil {
+		t.Fatalf("toOpenAIMessageWithBudget() error = %v", err)
+	}
+	if used <= 0 {
+		t.Fatalf("expected consumed session asset bytes, got %d", used)
+	}
+	parts, ok := msg.Content.([]MessageContentPart)
+	if !ok || len(parts) != 2 {
+		t.Fatalf("expected 2 multimodal parts, got %+v", msg.Content)
+	}
+	if parts[1].ImageURL == nil || !strings.HasPrefix(parts[1].ImageURL.URL, "data:image/png;base64,") {
+		t.Fatalf("expected encoded data url, got %+v", parts[1].ImageURL)
+	}
+	if len(msg.ToolCalls) != 1 || msg.ToolCalls[0].Function.Name != "read_file" {
+		t.Fatalf("expected mapped tool call, got %+v", msg.ToolCalls)
+	}
+}

internal/provider/openaicompat/chatcompletions/stream_test.go

@@ -0,0 +1,161 @@
+package chatcompletions
+
+import (
+	"context"
+	"errors"
+	"strings"
+	"testing"
+
+	"neo-code/internal/provider"
+	providertypes "neo-code/internal/provider/types"
+)
+
+func TestConsumeStreamEmitsTextToolAndDone(t *testing.T) {
+	t.Parallel()
+
+	sseBody := strings.Join([]string{
+		`data: {"choices":[{"index":0,"delta":{"content":"Hi "}}]}`,
+		"",
+		`data: {"choices":[{"index":0,"delta":{"tool_calls":[{"index":0,"id":"call_1","function":{"name":"read_file","arguments":"{\"path\":"}}]}}]}`,
+		"",
+		`data: {"choices":[{"index":0,"delta":{"tool_calls":[{"index":0,"function":{"arguments":"\"README.md\"}"}}]},"finish_reason":"stop"}],"usage":{"prompt_tokens":12,"completion_tokens":8,"total_tokens":20}}`,
+		"",
+		"data: [DONE]",
+		"",
+	}, "\n")
+
+	events := make(chan providertypes.StreamEvent, 16)
+	err := ConsumeStream(context.Background(), strings.NewReader(sseBody), events)
+	if err != nil {
+		t.Fatalf("ConsumeStream() error = %v", err)
+	}
+
+	collected := drainChatEvents(events)
+	if len(collected) != 5 {
+		t.Fatalf("expected 5 events, got %d", len(collected))
+	}
+	text, err := collected[0].TextDeltaValue()
+	if err != nil || text.Text != "Hi " {
+		t.Fatalf("expected text delta event, got err=%v event=%+v", err, collected[0])
+	}
+	start, err := collected[1].ToolCallStartValue()
+	if err != nil || start.Index != 0 || start.ID != "call_1" || start.Name != "read_file" {
+		t.Fatalf("expected tool start event, got err=%v event=%+v", err, collected[1])
+	}
+	delta1, err := collected[2].ToolCallDeltaValue()
+	if err != nil || delta1.ArgumentsDelta != "{\"path\":" {
+		t.Fatalf("expected first tool delta, got err=%v event=%+v", err, collected[2])
+	}
+	delta2, err := collected[3].ToolCallDeltaValue()
+	if err != nil || delta2.ArgumentsDelta != "\"README.md\"}" {
+		t.Fatalf("expected second tool delta, got err=%v event=%+v", err, collected[3])
+	}
+	done, err := collected[4].MessageDoneValue()
+	if err != nil {
+		t.Fatalf("expected message done event, got err=%v", err)
+	}
+	if done.FinishReason != "stop" {
+		t.Fatalf("expected stop finish reason, got %q", done.FinishReason)
+	}
+	if done.Usage == nil || done.Usage.TotalTokens != 20 {
+		t.Fatalf("expected usage tokens in done event, got %+v", done.Usage)
+	}
+}
+
+func TestConsumeStreamErrorAndEOFBranches(t *testing.T) {
+	t.Parallel()
+
+	t.Run("error payload", func(t *testing.T) {
+		t.Parallel()
+
+		err := ConsumeStream(context.Background(), strings.NewReader("data: {\"error\":{\"message\":\"bad key\"}}\n\n"), make(chan providertypes.StreamEvent, 2))
+		if err == nil || !strings.Contains(err.Error(), "bad key") {
+			t.Fatalf("expected error payload propagation, got %v", err)
+		}
+	})
+
+	t.Run("EOF with finish_reason still emits done", func(t *testing.T) {
+		t.Parallel()
+
+		sseBody := "data: {\"choices\":[{\"delta\":{},\"finish_reason\":\"stop\"}]}\n\n"
+		events := make(chan providertypes.StreamEvent, 2)
+		err := ConsumeStream(context.Background(), strings.NewReader(sseBody), events)
+		if err != nil {
+			t.Fatalf("expected graceful finish on EOF with finish_reason, got %v", err)
+		}
+		collected := drainChatEvents(events)
+		if len(collected) != 1 {
+			t.Fatalf("expected one done event, got %d", len(collected))
+		}
+		done, err := collected[0].MessageDoneValue()
+		if err != nil || done.FinishReason != "stop" {
+			t.Fatalf("expected stop done event, got err=%v event=%+v", err, collected[0])
+		}
+	})
+
+	t.Run("EOF without done marker and finish reason", func(t *testing.T) {
+		t.Parallel()
+
+		err := ConsumeStream(context.Background(), strings.NewReader("data: {\"choices\":[{\"delta\":{\"content\":\"x\"}}]}\n\n"), make(chan providertypes.StreamEvent, 2))
+		if err == nil {
+			t.Fatal("expected interrupted error")
+		}
+		if !errors.Is(err, provider.ErrStreamInterrupted) {
+			t.Fatalf("expected ErrStreamInterrupted, got %v", err)
+		}
+	})
+}
+
+func TestExtractAndMergeHelpers(t *testing.T) {
+	t.Parallel()
+
+	usage := providertypes.Usage{InputTokens: 1}
+	extractStreamUsage(&usage, &StreamUsage{PromptTokens: 3, CompletionTokens: 4, TotalTokens: 7})
+	if usage.TotalTokens != 7 || usage.InputTokens != 3 || usage.OutputTokens != 4 {
+		t.Fatalf("unexpected usage mapping: %+v", usage)
+	}
+
+	events := make(chan providertypes.StreamEvent, 4)
+	toolCalls := map[int]*providertypes.ToolCall{}
+	if err := mergeToolCallDelta(context.Background(), events, toolCalls, StreamToolCallDelta{
+		Index: 0,
+		ID:    "call_1",
+		Function: FunctionCall{
+			Name:      "edit",
+			Arguments: "{",
+		},
+	}); err != nil {
+		t.Fatalf("first mergeToolCallDelta() error = %v", err)
+	}
+	if err := mergeToolCallDelta(context.Background(), events, toolCalls, StreamToolCallDelta{
+		Index: 0,
+		Function: FunctionCall{
+			Arguments: "}",
+		},
+	}); err != nil {
+		t.Fatalf("second mergeToolCallDelta() error = %v", err)
+	}
+	if toolCalls[0].Arguments != "{}" {
+		t.Fatalf("expected accumulated arguments, got %q", toolCalls[0].Arguments)
+	}
+
+	collected := drainChatEvents(events)
+	if len(collected) != 3 {
+		t.Fatalf("expected start+2deltas events, got %d", len(collected))
+	}
+	if _, err := collected[0].ToolCallStartValue(); err != nil {
+		t.Fatalf("expected first event to be tool start, got err=%v", err)
+	}
+}
+
+func drainChatEvents(events <-chan providertypes.StreamEvent) []providertypes.StreamEvent {
+	out := make([]providertypes.StreamEvent, 0, len(events))
+	for {
+		select {
+		case ev := <-events:
+			out = append(out, ev)
+		default:
+			return out
+		}
+	}
+}