mirror of
https://github.com/warmbly/warmbly.git
synced 2026-11-17 08:18:51 +00:00
132 lines
3.9 KiB
Go
132 lines
3.9 KiB
Go
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/app/credits"
|
|
"github.com/warmbly/warmbly/internal/models"
|
|
"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 countingCredits struct {
|
|
editCredits
|
|
charges int
|
|
}
|
|
|
|
func (r *countingCredits) Charge(context.Context, uuid.UUID, credits.Usage, string, string) (models.Micro, error) {
|
|
r.charges++
|
|
return 20_000, 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 ||
|
|
done.ChargedUSD == nil || *done.ChargedUSD != 0.02 || done.BalanceUSD == nil || *done.BalanceUSD != 0.82 {
|
|
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 TestStreamedFailureChargesNothing(t *testing.T) {
|
|
cases := []struct {
|
|
name string
|
|
deltas []string
|
|
cancel bool
|
|
}{
|
|
{"provider failed mid-stream", []string{"Hi"}, false},
|
|
{"caller left after reading", []string{"Hi"}, true},
|
|
{"caller left before any text", nil, true},
|
|
}
|
|
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 := &countingCredits{}
|
|
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.charges != 0 {
|
|
t.Errorf("a failed generation was charged %d times", credits.charges)
|
|
}
|
|
})
|
|
}
|
|
}
|