package handler import ( "context" "encoding/json" "errors" "net/http" "net/http/httptest" "strings" "testing" "github.com/gin-gonic/gin" "github.com/google/uuid" "github.com/warmbly/warmbly/internal/api/middleware" "github.com/warmbly/warmbly/internal/errx" "github.com/warmbly/warmbly/internal/pkg/generation" ) // streamProvider writes deltas through CompleteStream, then fails with err when set. type streamProvider struct { editProvider deltas []string err error } func (p *streamProvider) CompleteStream(ctx context.Context, req generation.CompletionRequest, onDelta func(string)) (*generation.WritingResult, error) { p.got = req for _, d := range p.deltas { onDelta(d) } if p.err != nil { return nil, p.err } return &generation.WritingResult{Text: strings.Join(p.deltas, ""), Model: "test-model", TokensUsed: 9}, nil } type refundCredits struct { editCredits refunds int } // Grant fails on a cancelled context, as the ledger's transaction does. func (r *refundCredits) Grant(ctx context.Context, _ uuid.UUID, _ int, _ string) (int, *errx.Error) { if ctx.Err() != nil { return 0, errx.New(errx.Internal, "context cancelled") } r.refunds++ return 42, nil } func streamEdit(t *testing.T, h *Handler, ctx context.Context) []writingEvent { t.Helper() gin.SetMode(gin.TestMode) rec := httptest.NewRecorder() c, _ := gin.CreateTestContext(rec) c.Set(middleware.OrganizationIDKey, uuid.New()) c.Request = httptest.NewRequestWithContext(ctx, http.MethodPost, "/generation/edit", strings.NewReader(`{"text":"Hi {{.FirstName}}, quick one.","instruction":"shorten"}`)) c.Request.Header.Set("Content-Type", "application/json") c.Request.Header.Set("Accept", "text/event-stream") h.GenerateEdit(c) if ct := rec.Header().Get("Content-Type"); ct != "text/event-stream" { t.Fatalf("content type %q: %s", ct, rec.Body.String()) } var events []writingEvent for _, frame := range strings.Split(strings.TrimSpace(rec.Body.String()), "\n\n") { var ev writingEvent if err := json.Unmarshal([]byte(strings.TrimPrefix(frame, "data: ")), &ev); err != nil { t.Fatalf("frame %q: %v", frame, err) } events = append(events, ev) } return events } func TestGenerateEditStreamsTheTextAsItIsWritten(t *testing.T) { p := &streamProvider{deltas: []string{"Hi {{.FirstName}}", ", one ", "question."}} h := &Handler{FeatureGateService: editGate{}, CreditService: editCredits{}, AIProvider: p} events := streamEdit(t, h, context.Background()) if len(events) != 4 { t.Fatalf("want 3 deltas and done, got %+v", events) } for i, d := range p.deltas { if events[i].Type != "delta" || events[i].Text != d { t.Errorf("event %d = %+v, want delta %q", i, events[i], d) } } done := events[3] if done.Type != "done" || done.Text != "Hi {{.FirstName}}, one question." || done.CreditsCharged == nil || *done.CreditsCharged != 1 { t.Errorf("unexpected done event: %+v", done) } if p.got.System != generation.BuildEditRules(generation.VoiceContext{}) { t.Error("the streamed edit is not running on the edit rules") } } func TestStreamedFailureRefundsUnlessTheCallerLeft(t *testing.T) { cases := []struct { name string deltas []string cancel bool refunds int }{ {"provider failed mid-stream", []string{"Hi"}, false, 1}, {"caller left after reading", []string{"Hi"}, true, 0}, {"caller left before any text", nil, true, 1}, } for _, tc := range cases { t.Run(tc.name, func(t *testing.T) { ctx, cancel := context.WithCancel(context.Background()) defer cancel() if tc.cancel { cancel() } credits := &refundCredits{} p := &streamProvider{deltas: tc.deltas, err: errors.New("boom")} h := &Handler{FeatureGateService: editGate{}, CreditService: credits, AIProvider: p} events := streamEdit(t, h, ctx) if last := events[len(events)-1]; last.Type != "error" { t.Errorf("last event %+v, want error", last) } if credits.refunds != tc.refunds { t.Errorf("refunds %d, want %d", credits.refunds, tc.refunds) } }) } }