46db0a3e16
A paste fires exactly one grammar checkpoint, and a failed one never retried until the next keystroke — stranding the writer on "Petal's helper is resting" after a paste. Long docs make it worse: their 15-25s checks have a wide window to catch a transient 502 from the shared Ollama (co-tenant apps load other models and evict the 9B). A failed pass also burned the per-document rate-limit slot, so a retry within 30s hit the throttle path and got an empty set back. - llm.RateLimiter.Release rolls back a slot when its pass fails; Allow now returns the recorded timestamp so Release only frees its own slot. - suggestions.runPass releases the slot on LLM failure before returning 502. - useCheckpoint auto-retries a failed checkpoint with backoff (3/12/35s), keeping the breathing dot up and only flagging "resting" once retries exhaust. Claude-Session: https://claude.ai/code/session_016Yr6jELuRc7hyzYLccQKZd
109 lines
3.0 KiB
Go
109 lines
3.0 KiB
Go
package llm
|
|
|
|
import (
|
|
"testing"
|
|
"time"
|
|
)
|
|
|
|
func TestParseCheckpoint(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
raw string
|
|
want int
|
|
wantErr bool
|
|
}{
|
|
{
|
|
name: "clean json",
|
|
raw: `{"suggestions":[{"original":"I has","replacement":"I have","explanation":"subject-verb agreement","type":"grammar"}]}`,
|
|
want: 1,
|
|
},
|
|
{
|
|
name: "wrapped in markdown fence",
|
|
raw: "Here you go:\n```json\n{\"suggestions\":[{\"original\":\"a apple\",\"replacement\":\"an apple\",\"explanation\":\"use an before a vowel\",\"type\":\"grammar\"}]}\n```",
|
|
want: 1,
|
|
},
|
|
{
|
|
name: "empty suggestions",
|
|
raw: `{"suggestions":[]}`,
|
|
want: 0,
|
|
},
|
|
{
|
|
name: "drops items with empty original",
|
|
raw: `{"suggestions":[{"original":"","replacement":"x","explanation":"e","type":"grammar"},{"original":"teh","replacement":"the","explanation":"typo","type":"grammar"}]}`,
|
|
want: 1,
|
|
},
|
|
{
|
|
name: "no json at all",
|
|
raw: "I could not find any issues!",
|
|
wantErr: true,
|
|
},
|
|
{
|
|
name: "braces inside string values",
|
|
raw: `{"suggestions":[{"original":"use {x}","replacement":"use x","explanation":"drop the braces","type":"clarity"}]}`,
|
|
want: 1,
|
|
},
|
|
}
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
got, err := ParseCheckpoint(tt.raw)
|
|
if tt.wantErr {
|
|
if err == nil {
|
|
t.Fatalf("expected error, got none")
|
|
}
|
|
return
|
|
}
|
|
if err != nil {
|
|
t.Fatalf("unexpected error: %v", err)
|
|
}
|
|
if len(got) != tt.want {
|
|
t.Fatalf("got %d suggestions, want %d", len(got), tt.want)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestRateLimiter(t *testing.T) {
|
|
rl := NewRateLimiter(30 * time.Second)
|
|
|
|
ok, _, at := rl.Allow("doc1")
|
|
if !ok {
|
|
t.Fatal("first call should be allowed")
|
|
}
|
|
if ok, retry, _ := rl.Allow("doc1"); ok || retry <= 0 {
|
|
t.Fatalf("immediate second call should be throttled, got ok=%v retry=%v", ok, retry)
|
|
}
|
|
// A different document is independent.
|
|
if ok, _, _ := rl.Allow("doc2"); !ok {
|
|
t.Fatal("different doc should be allowed")
|
|
}
|
|
|
|
// Releasing doc1's slot (as a failed pass does) lets the next check re-run
|
|
// immediately instead of waiting out the interval.
|
|
rl.Release("doc1", at)
|
|
if ok, _, _ := rl.Allow("doc1"); !ok {
|
|
t.Fatal("after Release the next call should be allowed again")
|
|
}
|
|
// Release only rolls back its own slot: a stale timestamp must not evict the
|
|
// slot a newer Allow holds (so a late failure can't cancel a fresh in-flight
|
|
// check). doc2 still holds its slot from above; a zero-time Release is a no-op.
|
|
rl.Release("doc2", time.Time{})
|
|
if ok, _, _ := rl.Allow("doc2"); ok {
|
|
t.Fatal("stale Release must not free doc2's current slot")
|
|
}
|
|
}
|
|
|
|
func TestTruncateDoc(t *testing.T) {
|
|
short := "hello"
|
|
if got := TruncateDoc(short); got != short {
|
|
t.Fatalf("short doc should be unchanged")
|
|
}
|
|
long := make([]byte, maxDocChars+500)
|
|
for i := range long {
|
|
long[i] = 'a'
|
|
}
|
|
got := TruncateDoc(string(long))
|
|
if len(got) != maxDocChars {
|
|
t.Fatalf("truncated length = %d, want %d", len(got), maxDocChars)
|
|
}
|
|
}
|