Skip to content

Every agent's model. One place. Codex on DeepSeek, Claude Code on Kimi, from the menu bar.

provider: in a test binary served.json is written as an answer is noted, so no write outlives its test

yetoneae019defed23
diff --git a/internal/provider/served.go b/internal/provider/served.go
index 52a9fabe1..c86700d75 100644
--- a/internal/provider/served.go
+++ b/internal/provider/served.go
@@ -15,6 +15,7 @@ import (
"strings"
"sync"
"sync/atomic"
+ "testing"
"time"
)
@@ -91,8 +92,18 @@ func ServedID(p Provider) string {
// many requests a second writes it once in a while, not once a request
// (a read, a write and a rename on every answer). A crash loses what was
// noted in that last moment; FlushServed, as the gateway ends, loses
-// nothing.
-var servedFlushAfter = 2 * time.Second
+// nothing. In a test binary it is 0, the file written at once, as it
+// was: a write waiting outlived the test that noted it and wrote into its
+// temp folder as the folder was being removed ("directory not empty").
+var servedFlushAfter = writeBehind(2 * time.Second)
+
+// writeBehind is d, or 0 in a test binary: no timer outlives a test.
+func writeBehind(d time.Duration) time.Duration {
+ if testing.Testing() {
+ return 0
+ }
+ return d
+}
// servedFlush is the write NoteServed has waiting, and the one being made.
var servedFlush struct {
@@ -108,9 +119,12 @@ func NoteServed(p Provider, at time.Time) {
id := ServedID(p)
path := servedPath()
servedAt.Lock()
- moved := false
+ moved, now := false, false
defer func() {
servedAt.Unlock()
+ if now {
+ flushServed(path)
+ }
if moved {
servedMoved()
}
@@ -128,7 +142,9 @@ func NoteServed(p Provider, at time.Time) {
}
if !servedFlush.pending {
servedFlush.pending = true
- time.AfterFunc(servedFlushAfter, func() { flushServed(path) })
+ if now = servedFlushAfter <= 0; !now {
+ time.AfterFunc(servedFlushAfter, func() { flushServed(path) })
+ }
}
}
diff --git a/internal/provider/served_test.go b/internal/provider/served_test.go
index 0012e55de..c99d15ae9 100644
--- a/internal/provider/served_test.go
+++ b/internal/provider/served_test.go
@@ -98,6 +98,29 @@ func TestCardsLastServed(t *testing.T) {
}
}
+// In a test binary served.json is written as an answer is noted: a write
+// left waiting outlived the test that noted it, and wrote into its temp
+// folder as the folder was being removed (BenchmarkGroupOverhead failed
+// "TempDir RemoveAll cleanup: … directory not empty").
+func TestNoteServedInATestWritesAtOnce(t *testing.T) {
+ home := t.TempDir()
+ t.Setenv("HOME", home)
+ t.Setenv("USERPROFILE", home)
+ t.Setenv("XDG_CONFIG_HOME", t.TempDir())
+ at := time.Now().Truncate(time.Second)
+ NoteServed(Provider{ID: "dk", Key: "sk-key-0002"}, at)
+ var m map[string]time.Time
+ if b, err := os.ReadFile(servedPath()); err != nil || json.Unmarshal(b, &m) != nil || !m["dk#"+KeyID("sk-key-0002")].Equal(at) {
+ t.Fatalf("not written as the answer was noted: %v %v", err, m)
+ }
+ servedFlush.Lock()
+ pending := servedFlush.pending
+ servedFlush.Unlock()
+ if pending {
+ t.Fatal("a write left waiting past the test")
+ }
+}
+
// A request answered isn't a read and a write of served.json: what is
// noted is written once, within servedFlushAfter, however many requests
// were answered meanwhile, or as the gateway ends (FlushServed); the file
@@ -117,6 +140,8 @@ func TestNoteServedWritesBehind(t *testing.T) {
if err := os.WriteFile(servedPath(), other, 0o600); err != nil {
t.Fatal(err)
}
+ defer func(d time.Duration) { servedFlushAfter = d }(servedFlushAfter)
+ servedFlushAfter = 2 * time.Second // as outside a test binary
servedFlush.Lock()
writes := servedFlush.writes
servedFlush.Unlock()
@@ -150,7 +175,6 @@ func TestNoteServedWritesBehind(t *testing.T) {
t.Fatalf("file %s", b)
}
// and by itself, a moment later
- defer func(d time.Duration) { servedFlushAfter = d }(servedFlushAfter)
servedFlushAfter = time.Millisecond
NoteServed(Provider{ID: "dk", Key: "sk-key-0001"}, now.Add(time.Second))
for deadline := time.Now().Add(10 * time.Second); ; {