Refactored, added comprehensive testing.

api/http_test.go

@@ -0,0 +1,193 @@
+package api
+
+import (
+	"bytes"
+	"encoding/json"
+	"io"
+	"net/http"
+	"strings"
+	"testing"
+	"time"
+
+	"git.wisehodl.dev/jay/aicli/config"
+	"github.com/stretchr/testify/assert"
+)
+
+type mockRoundTripper struct {
+	response *http.Response
+	err      error
+	request  *http.Request
+}
+
+func (m *mockRoundTripper) RoundTrip(req *http.Request) (*http.Response, error) {
+	m.request = req
+	return m.response, m.err
+}
+
+func makeResponse(statusCode int, body string) *http.Response {
+	return &http.Response{
+		StatusCode: statusCode,
+		Body:       io.NopCloser(strings.NewReader(body)),
+		Header:     make(http.Header),
+	}
+}
+
+func TestExecuteHTTP(t *testing.T) {
+	tests := []struct {
+		name        string
+		cfg         config.ConfigData
+		payload     map[string]interface{}
+		mockResp    *http.Response
+		mockErr     error
+		wantBody    string
+		wantErr     bool
+		errContains string
+	}{
+		{
+			name: "successful request",
+			cfg: config.ConfigData{
+				URL:    "https://api.example.com/chat",
+				APIKey: "sk-test123",
+			},
+			payload: map[string]interface{}{
+				"model": "gpt-4",
+			},
+			mockResp: makeResponse(200, `{"choices":[{"message":{"content":"response"}}]}`),
+			wantBody: `{"choices":[{"message":{"content":"response"}}]}`,
+			wantErr:  false,
+		},
+		{
+			name: "HTTP 400 error",
+			cfg: config.ConfigData{
+				URL:    "https://api.example.com/chat",
+				APIKey: "sk-test123",
+			},
+			payload:     map[string]interface{}{"model": "gpt-4"},
+			mockResp:    makeResponse(400, `{"error":"bad request"}`),
+			wantErr:     true,
+			errContains: "HTTP 400",
+		},
+		{
+			name: "HTTP 401 unauthorized",
+			cfg: config.ConfigData{
+				URL:    "https://api.example.com/chat",
+				APIKey: "invalid-key",
+			},
+			payload:     map[string]interface{}{"model": "gpt-4"},
+			mockResp:    makeResponse(401, `{"error":"unauthorized"}`),
+			wantErr:     true,
+			errContains: "HTTP 401",
+		},
+		{
+			name: "HTTP 429 rate limit",
+			cfg: config.ConfigData{
+				URL:    "https://api.example.com/chat",
+				APIKey: "sk-test123",
+			},
+			payload:     map[string]interface{}{"model": "gpt-4"},
+			mockResp:    makeResponse(429, `{"error":"rate limit exceeded"}`),
+			wantErr:     true,
+			errContains: "HTTP 429",
+		},
+		{
+			name: "HTTP 500 server error",
+			cfg: config.ConfigData{
+				URL:    "https://api.example.com/chat",
+				APIKey: "sk-test123",
+			},
+			payload:     map[string]interface{}{"model": "gpt-4"},
+			mockResp:    makeResponse(500, `{"error":"internal server error"}`),
+			wantErr:     true,
+			errContains: "HTTP 500",
+		},
+		{
+			name: "network error",
+			cfg: config.ConfigData{
+				URL:    "https://api.example.com/chat",
+				APIKey: "sk-test123",
+			},
+			payload:     map[string]interface{}{"model": "gpt-4"},
+			mockErr:     http.ErrHandlerTimeout,
+			wantErr:     true,
+			errContains: "execute request",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			transport := &mockRoundTripper{
+				response: tt.mockResp,
+				err:      tt.mockErr,
+			}
+			oldClient := httpClient
+			httpClient = &http.Client{
+				Timeout:   5 * time.Minute,
+				Transport: transport,
+			}
+			defer func() { httpClient = oldClient }()
+
+			got, err := executeHTTP(tt.cfg, tt.payload)
+
+			if tt.wantErr {
+				assert.Error(t, err)
+				if tt.errContains != "" {
+					assert.Contains(t, err.Error(), tt.errContains)
+				}
+				return
+			}
+
+			assert.NoError(t, err)
+			assert.Equal(t, tt.wantBody, string(got))
+		})
+	}
+}
+
+func TestExecuteHTTPHeaders(t *testing.T) {
+	cfg := config.ConfigData{
+		URL:    "https://api.example.com/chat",
+		APIKey: "sk-test-key",
+	}
+	payload := map[string]interface{}{"model": "gpt-4"}
+
+	transport := &mockRoundTripper{
+		response: makeResponse(200, `{"result":"ok"}`),
+	}
+	oldClient := httpClient
+	httpClient = &http.Client{
+		Timeout:   5 * time.Minute,
+		Transport: transport,
+	}
+	defer func() { httpClient = oldClient }()
+
+	_, err := executeHTTP(cfg, payload)
+	assert.NoError(t, err)
+
+	assert.Equal(t, "application/json", transport.request.Header.Get("Content-Type"))
+	assert.Equal(t, "Bearer sk-test-key", transport.request.Header.Get("Authorization"))
+}
+
+func TestExecuteHTTPTimeout(t *testing.T) {
+	cfg := config.ConfigData{
+		URL:    "https://api.example.com/chat",
+		APIKey: "sk-test123",
+	}
+	payload := map[string]interface{}{"model": "gpt-4"}
+
+	transport := &mockRoundTripper{
+		response: makeResponse(200, `{"ok":true}`),
+	}
+
+	client := &http.Client{
+		Timeout:   5 * time.Minute,
+		Transport: transport,
+	}
+
+	body, _ := json.Marshal(payload)
+	req, _ := http.NewRequest("POST", cfg.URL, bytes.NewReader(body))
+	req.Header.Set("Content-Type", "application/json")
+	req.Header.Set("Authorization", "Bearer "+cfg.APIKey)
+
+	resp, err := client.Do(req)
+	assert.NoError(t, err)
+	assert.Equal(t, 200, resp.StatusCode)
+}