632 lines
24 KiB
Go
632 lines
24 KiB
Go
|
// Package bot — Milestone 3 deterministic transport tests for the
|
||
|
|
// FastAPI agent service client.
|
||
|
|
//
|
||
|
|
// These tests use httptest.NewServer ONLY for the deterministic cases
|
||
|
|
// plan §10 M3 carves out: timeouts, malformed JSON, status-code retry
|
||
|
|
// matrix, context cancellation, and the application-error path. Live
|
||
|
|
// application-level success tests live in fastapi_live_test.go and are
|
||
|
|
// gated by CHATBOT_LOCAL_FASTAPI_URL.
|
||
|
|
//
|
||
|
|
// Compile contract: this file references bot.NewFastAPIClient,
|
||
|
|
// bot.FastAPIClient, bot.ChatRequest, bot.ChatResponse, bot.ChatScope,
|
||
|
|
// bot.ChatCallResult, bot.HealthResponse, bot.ConversationMessage,
|
||
|
|
// bot.Metadata, bot.AgentTelemetry, bot.Answer, bot.ErrorPayload,
|
||
|
|
// bot.WithBaseURL, bot.WithHTTPClient, bot.AttemptCounter,
|
||
|
|
// bot.ErrAgentApplicationError, bot.ErrAgentMissingAnswer,
|
||
|
|
// bot.ErrAgentInvalidResponse, bot.ErrHealthStatusNotOK,
|
||
|
|
// bot.ErrHealthMissingService — none of which exist yet. Backend-eng
|
||
|
|
// adds fastapi.go and the package compiles. Until then the file fails
|
||
|
|
// to compile — the failing state plan §10 M3 endorses.
|
||
|
|
//
|
||
|
|
// Plan reference: plans/chatbot_plan_codex.v10.md §7 (FastAPI Integration).
|
||
|
|
//
|
||
|
|
// Retry policy verbatim from §7:
|
||
|
|
// - Up to 3 attempts.
|
||
|
|
// - Retry HTTP 429, 500, 502, 503, 504, and transport timeouts.
|
||
|
|
// - Do not retry other 4xx responses.
|
||
|
|
// - Do not retry HTTP 200 with status:"error".
|
||
|
|
// - Reuse the same request_id for every attempt.
|
||
|
|
// - One parent context enforces total wall time.
|
||
|
|
package bot_test
|
||
|
|
|
||
|
|
import (
|
||
|
|
"context"
|
||
|
|
"encoding/json"
|
||
|
|
"errors"
|
||
|
|
"io"
|
||
|
|
"net/http"
|
||
|
|
"net/http/httptest"
|
||
|
|
"sync"
|
||
|
|
"sync/atomic"
|
||
|
|
"testing"
|
||
|
|
"time"
|
||
|
|
|
||
|
|
"queryorchestration/internal/bot"
|
||
|
|
"queryorchestration/internal/serviceconfig/chatbot"
|
||
|
|
|
||
|
|
"github.com/stretchr/testify/assert"
|
||
|
|
"github.com/stretchr/testify/require"
|
||
|
|
)
|
||
|
|
|
||
|
|
// fastAPITestRequestID is the deterministic request_id every test sends
|
||
|
|
// so the captured incoming-request assertions are reproducible. Plan §7:
|
||
|
|
// request_id format is "{sessionId}:{ordinal}" — the exact session/ordinal
|
||
|
|
// values do not matter at the client layer; the client must reuse the
|
||
|
|
// caller-supplied value verbatim across retries.
|
||
|
|
const fastAPITestRequestID = "00000000-0000-0000-0000-000000000001:1"
|
||
|
|
|
||
|
|
// shortTimeoutCfg returns a ChatbotConfig whose RequestTimeoutSeconds is
|
||
|
|
// 1 so timeout tests do not have to wait the production default of 60s.
|
||
|
|
// Tests that exercise the retry matrix without timeout pressure can use
|
||
|
|
// the same config; per-attempt timeout is a ceiling, not a floor.
|
||
|
|
func shortTimeoutCfg(baseURL string) chatbot.ChatbotConfig {
|
||
|
|
return chatbot.ChatbotConfig{
|
||
|
|
ServiceURL: baseURL,
|
||
|
|
APIKey: `{"AGENT_SERVICE_API_KEY":"value"}`,
|
||
|
|
RequestTimeoutSeconds: 1,
|
||
|
|
MaxTurnChars: 2000,
|
||
|
|
RecentTurns: 5,
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// validChatRequest returns a ChatRequest that satisfies the swagger's
|
||
|
|
// required-field set. Used by retry tests where the response shape is
|
||
|
|
// what we are exercising, not the request body.
|
||
|
|
func validChatRequest() bot.ChatRequest {
|
||
|
|
return bot.ChatRequest{
|
||
|
|
RequestID: fastAPITestRequestID,
|
||
|
|
UserID: "test-user",
|
||
|
|
SessionID: "00000000-0000-0000-0000-000000000001",
|
||
|
|
Message: "hello",
|
||
|
|
ConversationHistory: []bot.ConversationMessage{},
|
||
|
|
Scope: bot.ChatScope{
|
||
|
|
DocumentIDs: []string{},
|
||
|
|
FolderIDs: []string{},
|
||
|
|
},
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// successChatResponseBody returns a minimally-valid 200 response body
|
||
|
|
// matching the swagger's "Successful Response" shape.
|
||
|
|
func successChatResponseBody(t testing.TB, requestID string) []byte {
|
||
|
|
t.Helper()
|
||
|
|
body := bot.ChatResponse{
|
||
|
|
RequestID: requestID,
|
||
|
|
Status: "success",
|
||
|
|
Answer: &bot.Answer{
|
||
|
|
Text: "the answer",
|
||
|
|
ResultType: "summary",
|
||
|
|
Confidence: 0.95,
|
||
|
|
FollowUpSuggestions: []string{},
|
||
|
|
},
|
||
|
|
}
|
||
|
|
out, err := json.Marshal(body)
|
||
|
|
require.NoError(t, err)
|
||
|
|
return out
|
||
|
|
}
|
||
|
|
|
||
|
|
// errorChatResponseBody returns a 200 response body whose status is
|
||
|
|
// "error" — which per plan §7 must NOT be retried.
|
||
|
|
func errorChatResponseBody(t testing.TB, requestID, code, message string) []byte {
|
||
|
|
t.Helper()
|
||
|
|
body := bot.ChatResponse{
|
||
|
|
RequestID: requestID,
|
||
|
|
Status: "error",
|
||
|
|
Error: &bot.ErrorPayload{
|
||
|
|
Code: code,
|
||
|
|
Message: message,
|
||
|
|
},
|
||
|
|
}
|
||
|
|
out, err := json.Marshal(body)
|
||
|
|
require.NoError(t, err)
|
||
|
|
return out
|
||
|
|
}
|
||
|
|
|
||
|
|
// flakeServer returns an httptest.Server whose /agent/chat endpoint
|
||
|
|
// emits the responses in order and increments a request counter so
|
||
|
|
// tests can read AttemptCount and the captured request bodies.
|
||
|
|
type flakeServer struct {
|
||
|
|
server *httptest.Server
|
||
|
|
receivedBodies []bot.ChatRequest
|
||
|
|
receivedHeader []http.Header
|
||
|
|
mu sync.Mutex
|
||
|
|
hits int32
|
||
|
|
}
|
||
|
|
|
||
|
|
// newFlakeServer constructs a httptest.Server that emits the supplied
|
||
|
|
// (status, body) pairs in order. After the last pair the server keeps
|
||
|
|
// returning the final pair so a buggy retry loop is visible as
|
||
|
|
// AttemptCount > len(pairs).
|
||
|
|
func newFlakeServer(t testing.TB, responses []flakeResponse) *flakeServer {
|
||
|
|
t.Helper()
|
||
|
|
fs := &flakeServer{}
|
||
|
|
fs.server = httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
||
|
|
idx := int(atomic.AddInt32(&fs.hits, 1)) - 1
|
||
|
|
var capture bot.ChatRequest
|
||
|
|
bodyBytes, _ := io.ReadAll(r.Body)
|
||
|
|
_ = r.Body.Close()
|
||
|
|
_ = json.Unmarshal(bodyBytes, &capture)
|
||
|
|
fs.mu.Lock()
|
||
|
|
fs.receivedBodies = append(fs.receivedBodies, capture)
|
||
|
|
fs.receivedHeader = append(fs.receivedHeader, r.Header.Clone())
|
||
|
|
fs.mu.Unlock()
|
||
|
|
resp := responses[idx]
|
||
|
|
if idx >= len(responses) {
|
||
|
|
resp = responses[len(responses)-1]
|
||
|
|
}
|
||
|
|
if resp.delay > 0 {
|
||
|
|
select {
|
||
|
|
case <-time.After(resp.delay):
|
||
|
|
case <-r.Context().Done():
|
||
|
|
return
|
||
|
|
}
|
||
|
|
}
|
||
|
|
w.WriteHeader(resp.status)
|
||
|
|
_, _ = w.Write(resp.body)
|
||
|
|
}))
|
||
|
|
t.Cleanup(fs.server.Close)
|
||
|
|
return fs
|
||
|
|
}
|
||
|
|
|
||
|
|
// flakeResponse is one entry in the staged-response list a flakeServer
|
||
|
|
// returns. delay simulates a slow upstream so timeout tests do not need
|
||
|
|
// a separate harness.
|
||
|
|
type flakeResponse struct {
|
||
|
|
status int
|
||
|
|
body []byte
|
||
|
|
delay time.Duration
|
||
|
|
}
|
||
|
|
|
||
|
|
// asAttemptCounter returns the AttemptCount embedded in the err if it
|
||
|
|
// implements bot.AttemptCounter. Tests use this to assert the retry
|
||
|
|
// loop exhausted (or did not exhaust) the configured attempts.
|
||
|
|
func asAttemptCounter(t testing.TB, err error) int {
|
||
|
|
t.Helper()
|
||
|
|
require.Error(t, err, "expected AttemptCounter-bearing error, got nil")
|
||
|
|
var counter bot.AttemptCounter
|
||
|
|
if !errors.As(err, &counter) {
|
||
|
|
t.Fatalf("error %T does not implement bot.AttemptCounter: %v", err, err)
|
||
|
|
}
|
||
|
|
return counter.AttemptCount()
|
||
|
|
}
|
||
|
|
|
||
|
|
// ---------- retry matrix ----------
|
||
|
|
|
||
|
|
// TestFastAPIClient_Retry429ThenSuccess: 2x429 then 200 -> success on
|
||
|
|
// the third attempt. AttemptCount=3.
|
||
|
|
func TestFastAPIClient_Retry429ThenSuccess(t *testing.T) {
|
||
|
|
fs := newFlakeServer(t, []flakeResponse{
|
||
|
|
{status: http.StatusTooManyRequests, body: []byte(`{"error":"slow"}`)},
|
||
|
|
{status: http.StatusTooManyRequests, body: []byte(`{"error":"slow"}`)},
|
||
|
|
{status: http.StatusOK, body: successChatResponseBody(t, fastAPITestRequestID)},
|
||
|
|
})
|
||
|
|
|
||
|
|
client := bot.NewFastAPIClient(shortTimeoutCfg(fs.server.URL))
|
||
|
|
result, err := client.Chat(t.Context(), validChatRequest())
|
||
|
|
require.NoError(t, err)
|
||
|
|
require.NotNil(t, result.Response)
|
||
|
|
assert.Equal(t, "success", result.Response.Status)
|
||
|
|
assert.Equal(t, 3, result.AttemptCount, "two 429s then 200 -> 3 attempts")
|
||
|
|
}
|
||
|
|
|
||
|
|
// TestFastAPIClient_Retry500ThenSuccess: 1x500 then 200 -> AttemptCount=2.
|
||
|
|
func TestFastAPIClient_Retry500ThenSuccess(t *testing.T) {
|
||
|
|
fs := newFlakeServer(t, []flakeResponse{
|
||
|
|
{status: http.StatusInternalServerError, body: []byte(`{"error":"oops"}`)},
|
||
|
|
{status: http.StatusOK, body: successChatResponseBody(t, fastAPITestRequestID)},
|
||
|
|
})
|
||
|
|
|
||
|
|
client := bot.NewFastAPIClient(shortTimeoutCfg(fs.server.URL))
|
||
|
|
result, err := client.Chat(t.Context(), validChatRequest())
|
||
|
|
require.NoError(t, err)
|
||
|
|
assert.Equal(t, 2, result.AttemptCount)
|
||
|
|
}
|
||
|
|
|
||
|
|
// TestFastAPIClient_Retry502ThenSuccess: 1x502 then 200 -> AttemptCount=2.
|
||
|
|
func TestFastAPIClient_Retry502ThenSuccess(t *testing.T) {
|
||
|
|
fs := newFlakeServer(t, []flakeResponse{
|
||
|
|
{status: http.StatusBadGateway, body: []byte(`bad gateway`)},
|
||
|
|
{status: http.StatusOK, body: successChatResponseBody(t, fastAPITestRequestID)},
|
||
|
|
})
|
||
|
|
|
||
|
|
client := bot.NewFastAPIClient(shortTimeoutCfg(fs.server.URL))
|
||
|
|
result, err := client.Chat(t.Context(), validChatRequest())
|
||
|
|
require.NoError(t, err)
|
||
|
|
assert.Equal(t, 2, result.AttemptCount)
|
||
|
|
}
|
||
|
|
|
||
|
|
// TestFastAPIClient_Retry503ExhaustsAttempts: 3x503 -> final transport
|
||
|
|
// error after exhausting attempts. AttemptCount=3.
|
||
|
|
func TestFastAPIClient_Retry503ExhaustsAttempts(t *testing.T) {
|
||
|
|
fs := newFlakeServer(t, []flakeResponse{
|
||
|
|
{status: http.StatusServiceUnavailable, body: []byte(`unavailable`)},
|
||
|
|
{status: http.StatusServiceUnavailable, body: []byte(`unavailable`)},
|
||
|
|
{status: http.StatusServiceUnavailable, body: []byte(`unavailable`)},
|
||
|
|
})
|
||
|
|
|
||
|
|
client := bot.NewFastAPIClient(shortTimeoutCfg(fs.server.URL))
|
||
|
|
_, err := client.Chat(t.Context(), validChatRequest())
|
||
|
|
require.Error(t, err, "exhausted retries must surface as a non-nil error")
|
||
|
|
assert.Equal(t, 3, asAttemptCounter(t, err),
|
||
|
|
"plan §7: max attempts is 3")
|
||
|
|
}
|
||
|
|
|
||
|
|
// TestFastAPIClient_Retry504ThenSuccess: 1x504 then 200 -> AttemptCount=2.
|
||
|
|
func TestFastAPIClient_Retry504ThenSuccess(t *testing.T) {
|
||
|
|
fs := newFlakeServer(t, []flakeResponse{
|
||
|
|
{status: http.StatusGatewayTimeout, body: []byte(`timeout`)},
|
||
|
|
{status: http.StatusOK, body: successChatResponseBody(t, fastAPITestRequestID)},
|
||
|
|
})
|
||
|
|
|
||
|
|
client := bot.NewFastAPIClient(shortTimeoutCfg(fs.server.URL))
|
||
|
|
result, err := client.Chat(t.Context(), validChatRequest())
|
||
|
|
require.NoError(t, err)
|
||
|
|
assert.Equal(t, 2, result.AttemptCount)
|
||
|
|
}
|
||
|
|
|
||
|
|
// TestFastAPIClient_TimeoutRetried: server hangs longer than the
|
||
|
|
// per-request timeout (cfg.RequestTimeoutSeconds=1). Each attempt fires
|
||
|
|
// the per-attempt timeout; the retry loop attempts up to the limit and
|
||
|
|
// fails with AttemptCount=3.
|
||
|
|
func TestFastAPIClient_TimeoutRetried(t *testing.T) {
|
||
|
|
fs := newFlakeServer(t, []flakeResponse{
|
||
|
|
{status: http.StatusOK, body: successChatResponseBody(t, fastAPITestRequestID), delay: 5 * time.Second},
|
||
|
|
{status: http.StatusOK, body: successChatResponseBody(t, fastAPITestRequestID), delay: 5 * time.Second},
|
||
|
|
{status: http.StatusOK, body: successChatResponseBody(t, fastAPITestRequestID), delay: 5 * time.Second},
|
||
|
|
})
|
||
|
|
|
||
|
|
// Parent context budget: 10s, well above the aggregate of three 1s
|
||
|
|
// per-attempt timeouts. The client respects the per-attempt
|
||
|
|
// timeout, not the parent ctx, for retry decisions.
|
||
|
|
parentCtx, cancel := context.WithTimeout(t.Context(), 10*time.Second)
|
||
|
|
defer cancel()
|
||
|
|
|
||
|
|
client := bot.NewFastAPIClient(shortTimeoutCfg(fs.server.URL))
|
||
|
|
_, err := client.Chat(parentCtx, validChatRequest())
|
||
|
|
require.Error(t, err, "all attempts time out -> non-nil error")
|
||
|
|
assert.Equal(t, 3, asAttemptCounter(t, err))
|
||
|
|
}
|
||
|
|
|
||
|
|
// TestFastAPIClient_4xxNotRetried covers 400/401/403/404. Each must
|
||
|
|
// return immediately with AttemptCount=1.
|
||
|
|
func TestFastAPIClient_4xxNotRetried(t *testing.T) {
|
||
|
|
cases := []struct {
|
||
|
|
name string
|
||
|
|
status int
|
||
|
|
}{
|
||
|
|
{name: "400_bad_request", status: http.StatusBadRequest},
|
||
|
|
{name: "401_unauthorized", status: http.StatusUnauthorized},
|
||
|
|
{name: "403_forbidden", status: http.StatusForbidden},
|
||
|
|
{name: "404_not_found", status: http.StatusNotFound},
|
||
|
|
}
|
||
|
|
for _, c := range cases {
|
||
|
|
t.Run(c.name, func(t *testing.T) {
|
||
|
|
fs := newFlakeServer(t, []flakeResponse{
|
||
|
|
{status: c.status, body: []byte(`{"error":"nope"}`)},
|
||
|
|
// A second successful entry so a buggy retry would be
|
||
|
|
// caught by AttemptCount > 1.
|
||
|
|
{status: http.StatusOK, body: successChatResponseBody(t, fastAPITestRequestID)},
|
||
|
|
})
|
||
|
|
|
||
|
|
client := bot.NewFastAPIClient(shortTimeoutCfg(fs.server.URL))
|
||
|
|
_, err := client.Chat(t.Context(), validChatRequest())
|
||
|
|
require.Error(t, err)
|
||
|
|
assert.Equal(t, 1, asAttemptCounter(t, err),
|
||
|
|
"plan §7: do not retry %d", c.status)
|
||
|
|
})
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// TestFastAPIClient_RequestIDStableAcrossAttempts: same request_id used
|
||
|
|
// on every attempt. Captures every incoming request via the test server
|
||
|
|
// and asserts the request_id matches across all of them.
|
||
|
|
func TestFastAPIClient_RequestIDStableAcrossAttempts(t *testing.T) {
|
||
|
|
fs := newFlakeServer(t, []flakeResponse{
|
||
|
|
{status: http.StatusServiceUnavailable, body: []byte(`unavailable`)},
|
||
|
|
{status: http.StatusServiceUnavailable, body: []byte(`unavailable`)},
|
||
|
|
{status: http.StatusOK, body: successChatResponseBody(t, fastAPITestRequestID)},
|
||
|
|
})
|
||
|
|
|
||
|
|
client := bot.NewFastAPIClient(shortTimeoutCfg(fs.server.URL))
|
||
|
|
req := validChatRequest()
|
||
|
|
req.RequestID = "session-abc:7"
|
||
|
|
_, err := client.Chat(t.Context(), req)
|
||
|
|
require.NoError(t, err)
|
||
|
|
|
||
|
|
require.Len(t, fs.receivedBodies, 3, "must observe 3 attempts")
|
||
|
|
for i, captured := range fs.receivedBodies {
|
||
|
|
assert.Equal(t, "session-abc:7", captured.RequestID,
|
||
|
|
"plan §7: same request_id on every attempt; attempt %d had %q", i+1, captured.RequestID)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// TestFastAPIClient_ContextCancelStopsRetry: parent ctx canceled
|
||
|
|
// mid-retry -> no further attempts; error contains context.Canceled.
|
||
|
|
func TestFastAPIClient_ContextCancelStopsRetry(t *testing.T) {
|
||
|
|
// Each response delays 200ms so we have a window to cancel the ctx
|
||
|
|
// between the first and second attempts.
|
||
|
|
fs := newFlakeServer(t, []flakeResponse{
|
||
|
|
{status: http.StatusServiceUnavailable, body: []byte(`unavailable`), delay: 200 * time.Millisecond},
|
||
|
|
{status: http.StatusOK, body: successChatResponseBody(t, fastAPITestRequestID)},
|
||
|
|
{status: http.StatusOK, body: successChatResponseBody(t, fastAPITestRequestID)},
|
||
|
|
})
|
||
|
|
|
||
|
|
parentCtx, cancel := context.WithCancel(t.Context())
|
||
|
|
// Cancel while the first attempt is in flight.
|
||
|
|
go func() {
|
||
|
|
time.Sleep(50 * time.Millisecond)
|
||
|
|
cancel()
|
||
|
|
}()
|
||
|
|
|
||
|
|
client := bot.NewFastAPIClient(shortTimeoutCfg(fs.server.URL))
|
||
|
|
_, err := client.Chat(parentCtx, validChatRequest())
|
||
|
|
require.Error(t, err, "canceled parent ctx must surface as a non-nil error")
|
||
|
|
assert.True(t, errors.Is(err, context.Canceled),
|
||
|
|
"expected wrapped context.Canceled, got %v", err)
|
||
|
|
|
||
|
|
hits := atomic.LoadInt32(&fs.hits)
|
||
|
|
assert.LessOrEqualf(t, hits, int32(2),
|
||
|
|
"cancel must stop the retry loop; saw %d attempts", hits)
|
||
|
|
}
|
||
|
|
|
||
|
|
// TestFastAPIClient_TotalWallTimeBounded: parent ctx deadline shorter
|
||
|
|
// than aggregate retry budget -> client respects the deadline; the
|
||
|
|
// final AttemptCount is below the max.
|
||
|
|
func TestFastAPIClient_TotalWallTimeBounded(t *testing.T) {
|
||
|
|
fs := newFlakeServer(t, []flakeResponse{
|
||
|
|
{status: http.StatusServiceUnavailable, body: []byte(`unavailable`), delay: 800 * time.Millisecond},
|
||
|
|
{status: http.StatusServiceUnavailable, body: []byte(`unavailable`), delay: 800 * time.Millisecond},
|
||
|
|
{status: http.StatusServiceUnavailable, body: []byte(`unavailable`), delay: 800 * time.Millisecond},
|
||
|
|
})
|
||
|
|
|
||
|
|
// Total budget is 600ms — less than even one 800ms attempt. The
|
||
|
|
// client must not loop past the parent deadline.
|
||
|
|
parentCtx, cancel := context.WithTimeout(t.Context(), 600*time.Millisecond)
|
||
|
|
defer cancel()
|
||
|
|
|
||
|
|
client := bot.NewFastAPIClient(shortTimeoutCfg(fs.server.URL))
|
||
|
|
_, err := client.Chat(parentCtx, validChatRequest())
|
||
|
|
require.Error(t, err, "deadline-exceeded parent ctx must propagate")
|
||
|
|
count := asAttemptCounter(t, err)
|
||
|
|
assert.Lessf(t, count, 3,
|
||
|
|
"plan §7: parent ctx caps total wall time; saw AttemptCount=%d", count)
|
||
|
|
}
|
||
|
|
|
||
|
|
// TestFastAPIClient_MalformedJSONFails: 200 with a non-JSON body maps
|
||
|
|
// to a typed parse error; not retried.
|
||
|
|
func TestFastAPIClient_MalformedJSONFails(t *testing.T) {
|
||
|
|
fs := newFlakeServer(t, []flakeResponse{
|
||
|
|
{status: http.StatusOK, body: []byte(`<html>not json</html>`)},
|
||
|
|
// Second entry would be returned if a buggy client retried.
|
||
|
|
{status: http.StatusOK, body: successChatResponseBody(t, fastAPITestRequestID)},
|
||
|
|
})
|
||
|
|
|
||
|
|
client := bot.NewFastAPIClient(shortTimeoutCfg(fs.server.URL))
|
||
|
|
_, err := client.Chat(t.Context(), validChatRequest())
|
||
|
|
require.Error(t, err)
|
||
|
|
assert.True(t, errors.Is(err, bot.ErrAgentInvalidResponse),
|
||
|
|
"malformed JSON must wrap ErrAgentInvalidResponse, got %v", err)
|
||
|
|
assert.Equal(t, 1, asAttemptCounter(t, err),
|
||
|
|
"malformed JSON is not retried")
|
||
|
|
}
|
||
|
|
|
||
|
|
// ---------- application-error paths ----------
|
||
|
|
|
||
|
|
// TestFastAPIClient_200StatusErrorNotRetried: 200 with status:"error"
|
||
|
|
// maps to ErrAgentApplicationError; not retried; the FastAPI error JSON
|
||
|
|
// is preserved on the wrapped error so tx2 can persist it.
|
||
|
|
func TestFastAPIClient_200StatusErrorNotRetried(t *testing.T) {
|
||
|
|
body := errorChatResponseBody(t, fastAPITestRequestID, "validation_failed", "missing entity")
|
||
|
|
fs := newFlakeServer(t, []flakeResponse{
|
||
|
|
{status: http.StatusOK, body: body},
|
||
|
|
// Second entry would be a 200/success — observable as
|
||
|
|
// AttemptCount=2 if the client incorrectly retried.
|
||
|
|
{status: http.StatusOK, body: successChatResponseBody(t, fastAPITestRequestID)},
|
||
|
|
})
|
||
|
|
|
||
|
|
client := bot.NewFastAPIClient(shortTimeoutCfg(fs.server.URL))
|
||
|
|
_, err := client.Chat(t.Context(), validChatRequest())
|
||
|
|
require.Error(t, err)
|
||
|
|
assert.True(t, errors.Is(err, bot.ErrAgentApplicationError),
|
||
|
|
"200 status:error must wrap ErrAgentApplicationError")
|
||
|
|
assert.Equal(t, 1, asAttemptCounter(t, err),
|
||
|
|
"plan §7: 200 status:error is not retried")
|
||
|
|
assert.Contains(t, err.Error(), "validation_failed",
|
||
|
|
"FastAPI error code must surface in the wrapped error")
|
||
|
|
}
|
||
|
|
|
||
|
|
// TestFastAPIClient_AnswerTextEmpty covers the answer.text validation:
|
||
|
|
// empty / whitespace-only / null answer maps to ErrAgentMissingAnswer
|
||
|
|
// and is not retried.
|
||
|
|
func TestFastAPIClient_AnswerTextEmpty(t *testing.T) {
|
||
|
|
cases := []struct {
|
||
|
|
name string
|
||
|
|
body []byte
|
||
|
|
}{
|
||
|
|
{
|
||
|
|
name: "empty_string",
|
||
|
|
body: []byte(`{"request_id":"` + fastAPITestRequestID + `","status":"success","answer":{"text":"","result_type":"summary","confidence":0.5}}`),
|
||
|
|
},
|
||
|
|
{
|
||
|
|
name: "whitespace_only",
|
||
|
|
body: []byte(`{"request_id":"` + fastAPITestRequestID + `","status":"success","answer":{"text":" \t\n ","result_type":"summary","confidence":0.5}}`),
|
||
|
|
},
|
||
|
|
{
|
||
|
|
name: "answer_null",
|
||
|
|
body: []byte(`{"request_id":"` + fastAPITestRequestID + `","status":"success","answer":null}`),
|
||
|
|
},
|
||
|
|
{
|
||
|
|
name: "answer_missing",
|
||
|
|
body: []byte(`{"request_id":"` + fastAPITestRequestID + `","status":"success"}`),
|
||
|
|
},
|
||
|
|
}
|
||
|
|
|
||
|
|
for _, c := range cases {
|
||
|
|
t.Run(c.name, func(t *testing.T) {
|
||
|
|
fs := newFlakeServer(t, []flakeResponse{
|
||
|
|
{status: http.StatusOK, body: c.body},
|
||
|
|
{status: http.StatusOK, body: successChatResponseBody(t, fastAPITestRequestID)},
|
||
|
|
})
|
||
|
|
|
||
|
|
client := bot.NewFastAPIClient(shortTimeoutCfg(fs.server.URL))
|
||
|
|
_, err := client.Chat(t.Context(), validChatRequest())
|
||
|
|
require.Error(t, err)
|
||
|
|
assert.True(t, errors.Is(err, bot.ErrAgentMissingAnswer),
|
||
|
|
"empty/whitespace/null answer must wrap ErrAgentMissingAnswer, got %v", err)
|
||
|
|
assert.Equal(t, 1, asAttemptCounter(t, err),
|
||
|
|
"agent_missing_answer is not retried")
|
||
|
|
})
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// ---------- metadata + state handling ----------
|
||
|
|
|
||
|
|
// TestFastAPIClient_MissingMetadataUsesWallClock: 200 response with no
|
||
|
|
// metadata field. The client always populates SentAt and ReceivedAt on
|
||
|
|
// ChatCallResult so the caller (service layer) can fall back to wall
|
||
|
|
// clock when metadata is absent.
|
||
|
|
func TestFastAPIClient_MissingMetadataUsesWallClock(t *testing.T) {
|
||
|
|
body := []byte(`{"request_id":"` + fastAPITestRequestID + `","status":"success","answer":{"text":"ok","result_type":"summary","confidence":0.9}}`)
|
||
|
|
fs := newFlakeServer(t, []flakeResponse{
|
||
|
|
{status: http.StatusOK, body: body},
|
||
|
|
})
|
||
|
|
|
||
|
|
before := time.Now()
|
||
|
|
client := bot.NewFastAPIClient(shortTimeoutCfg(fs.server.URL))
|
||
|
|
result, err := client.Chat(t.Context(), validChatRequest())
|
||
|
|
after := time.Now()
|
||
|
|
require.NoError(t, err)
|
||
|
|
|
||
|
|
assert.False(t, result.SentAt.IsZero(), "client must populate SentAt")
|
||
|
|
assert.False(t, result.ReceivedAt.IsZero(), "client must populate ReceivedAt")
|
||
|
|
assert.Truef(t, !result.SentAt.Before(before),
|
||
|
|
"SentAt %v must not be before before=%v", result.SentAt, before)
|
||
|
|
assert.Truef(t, !result.ReceivedAt.After(after),
|
||
|
|
"ReceivedAt %v must not be after after=%v", result.ReceivedAt, after)
|
||
|
|
assert.Truef(t, !result.ReceivedAt.Before(result.SentAt),
|
||
|
|
"ReceivedAt %v must not be before SentAt %v", result.ReceivedAt, result.SentAt)
|
||
|
|
require.NotNil(t, result.Response)
|
||
|
|
assert.Nil(t, result.Response.Metadata,
|
||
|
|
"missing metadata field must deserialize to nil so the service can fall back to wall clock")
|
||
|
|
}
|
||
|
|
|
||
|
|
// TestFastAPIClient_UpdatedSessionStateNullPreservesPrior: response
|
||
|
|
// updated_session_state == null. The client must distinguish null from
|
||
|
|
// explicit {} so the service layer can apply plan §7's preserve-prior
|
||
|
|
// semantics.
|
||
|
|
func TestFastAPIClient_UpdatedSessionStateNullPreservesPrior(t *testing.T) {
|
||
|
|
body := []byte(`{"request_id":"` + fastAPITestRequestID + `","status":"success","answer":{"text":"ok","result_type":"summary","confidence":0.9},"updated_session_state":null}`)
|
||
|
|
fs := newFlakeServer(t, []flakeResponse{
|
||
|
|
{status: http.StatusOK, body: body},
|
||
|
|
})
|
||
|
|
|
||
|
|
client := bot.NewFastAPIClient(shortTimeoutCfg(fs.server.URL))
|
||
|
|
result, err := client.Chat(t.Context(), validChatRequest())
|
||
|
|
require.NoError(t, err)
|
||
|
|
require.NotNil(t, result.Response)
|
||
|
|
assert.Nil(t, result.Response.UpdatedSessionState,
|
||
|
|
"explicit null must deserialize to a nil UpdatedSessionState so the caller can preserve prior state")
|
||
|
|
}
|
||
|
|
|
||
|
|
// TestFastAPIClient_UpdatedSessionStateExplicitEmptyOverwrites: response
|
||
|
|
// updated_session_state == {}. Distinguishable from null; service layer
|
||
|
|
// will treat as overwrite.
|
||
|
|
func TestFastAPIClient_UpdatedSessionStateExplicitEmptyOverwrites(t *testing.T) {
|
||
|
|
body := []byte(`{"request_id":"` + fastAPITestRequestID + `","status":"success","answer":{"text":"ok","result_type":"summary","confidence":0.9},"updated_session_state":{}}`)
|
||
|
|
fs := newFlakeServer(t, []flakeResponse{
|
||
|
|
{status: http.StatusOK, body: body},
|
||
|
|
})
|
||
|
|
|
||
|
|
client := bot.NewFastAPIClient(shortTimeoutCfg(fs.server.URL))
|
||
|
|
result, err := client.Chat(t.Context(), validChatRequest())
|
||
|
|
require.NoError(t, err)
|
||
|
|
require.NotNil(t, result.Response)
|
||
|
|
assert.NotNil(t, result.Response.UpdatedSessionState,
|
||
|
|
"explicit empty object must deserialize to a non-nil UpdatedSessionState")
|
||
|
|
}
|
||
|
|
|
||
|
|
// ---------- header + auth ----------
|
||
|
|
|
||
|
|
// TestFastAPIClient_SendsAPIKeyHeader: every request carries the
|
||
|
|
// configured X-API-Key header verbatim. Plan §7 ("API key header") +
|
||
|
|
// plan §11 ("Header literal: X-API-Key: ...").
|
||
|
|
func TestFastAPIClient_SendsAPIKeyHeader(t *testing.T) {
|
||
|
|
fs := newFlakeServer(t, []flakeResponse{
|
||
|
|
{status: http.StatusOK, body: successChatResponseBody(t, fastAPITestRequestID)},
|
||
|
|
})
|
||
|
|
|
||
|
|
const apiKeyValue = `{"AGENT_SERVICE_API_KEY":"value"}`
|
||
|
|
cfg := shortTimeoutCfg(fs.server.URL)
|
||
|
|
cfg.APIKey = apiKeyValue
|
||
|
|
|
||
|
|
client := bot.NewFastAPIClient(cfg)
|
||
|
|
_, err := client.Chat(t.Context(), validChatRequest())
|
||
|
|
require.NoError(t, err)
|
||
|
|
|
||
|
|
require.Len(t, fs.receivedHeader, 1)
|
||
|
|
assert.Equal(t, apiKeyValue, fs.receivedHeader[0].Get("X-API-Key"),
|
||
|
|
"every request must carry X-API-Key with the configured value verbatim")
|
||
|
|
}
|
||
|
|
|
||
|
|
// ---------- health smoke ----------
|
||
|
|
|
||
|
|
// TestFastAPIClient_HealthSmokeOK: /health returns 200 + ok shape -> nil.
|
||
|
|
func TestFastAPIClient_HealthSmokeOK(t *testing.T) {
|
||
|
|
mux := http.NewServeMux()
|
||
|
|
mux.HandleFunc("/health", func(w http.ResponseWriter, _ *http.Request) {
|
||
|
|
w.WriteHeader(http.StatusOK)
|
||
|
|
_, _ = w.Write([]byte(`{"status":"ok","service":"aaria-chatbot","version":"0.1.0"}`))
|
||
|
|
})
|
||
|
|
server := httptest.NewServer(mux)
|
||
|
|
t.Cleanup(server.Close)
|
||
|
|
|
||
|
|
client := bot.NewFastAPIClient(shortTimeoutCfg(server.URL))
|
||
|
|
require.NoError(t, client.Health(t.Context()))
|
||
|
|
}
|
||
|
|
|
||
|
|
// TestFastAPIClient_HealthSmokeStatusNotOK: non-ok status -> typed error.
|
||
|
|
func TestFastAPIClient_HealthSmokeStatusNotOK(t *testing.T) {
|
||
|
|
mux := http.NewServeMux()
|
||
|
|
mux.HandleFunc("/health", func(w http.ResponseWriter, _ *http.Request) {
|
||
|
|
w.WriteHeader(http.StatusOK)
|
||
|
|
_, _ = w.Write([]byte(`{"status":"degraded","service":"aaria-chatbot","version":"0.1.0"}`))
|
||
|
|
})
|
||
|
|
server := httptest.NewServer(mux)
|
||
|
|
t.Cleanup(server.Close)
|
||
|
|
|
||
|
|
client := bot.NewFastAPIClient(shortTimeoutCfg(server.URL))
|
||
|
|
err := client.Health(t.Context())
|
||
|
|
require.Error(t, err)
|
||
|
|
assert.True(t, errors.Is(err, bot.ErrHealthStatusNotOK),
|
||
|
|
"non-ok status must wrap ErrHealthStatusNotOK, got %v", err)
|
||
|
|
}
|
||
|
|
|
||
|
|
// TestFastAPIClient_HealthSmokeMissingService: empty service or version
|
||
|
|
// -> typed error. Plan §7: "service and version must be non-empty".
|
||
|
|
func TestFastAPIClient_HealthSmokeMissingService(t *testing.T) {
|
||
|
|
cases := []struct {
|
||
|
|
name string
|
||
|
|
body string
|
||
|
|
}{
|
||
|
|
{name: "empty_service", body: `{"status":"ok","service":"","version":"0.1.0"}`},
|
||
|
|
{name: "empty_version", body: `{"status":"ok","service":"aaria-chatbot","version":""}`},
|
||
|
|
}
|
||
|
|
for _, c := range cases {
|
||
|
|
t.Run(c.name, func(t *testing.T) {
|
||
|
|
mux := http.NewServeMux()
|
||
|
|
mux.HandleFunc("/health", func(w http.ResponseWriter, _ *http.Request) {
|
||
|
|
w.WriteHeader(http.StatusOK)
|
||
|
|
_, _ = w.Write([]byte(c.body))
|
||
|
|
})
|
||
|
|
server := httptest.NewServer(mux)
|
||
|
|
t.Cleanup(server.Close)
|
||
|
|
|
||
|
|
client := bot.NewFastAPIClient(shortTimeoutCfg(server.URL))
|
||
|
|
err := client.Health(t.Context())
|
||
|
|
require.Error(t, err)
|
||
|
|
assert.True(t, errors.Is(err, bot.ErrHealthMissingService),
|
||
|
|
"empty service or version must wrap ErrHealthMissingService, got %v", err)
|
||
|
|
})
|
||
|
|
}
|
||
|
|
}
|