137 lines
5.9 KiB
Go
137 lines
5.9 KiB
Go
package claude
|
|
|
|
import (
|
|
"encoding/json"
|
|
"os"
|
|
"path/filepath"
|
|
"strings"
|
|
"testing"
|
|
"time"
|
|
|
|
"git.a-wan.net/alan/pipelines/internal/protocol"
|
|
)
|
|
|
|
func TestTaskProgressPreservesRecordedMetadataAndExit(t *testing.T) {
|
|
chat, s := backgroundSession(t)
|
|
source := toolUse(t, "toolu_meta", "Agent", map[string]any{"description": "Review release", "run_in_background": true})
|
|
var start map[string]any
|
|
json.Unmarshal(source, &start)
|
|
start["timestamp"] = "2026-11-05T09:18:00Z"
|
|
s.handleLine(nil, line(t, start))
|
|
s.handleLine(nil, line(t, map[string]any{"type": "system", "subtype": "task_started", "task_id": "task-meta", "tool_use_id": "toolu_meta", "task_type": "local_agent", "description": "Review release"}))
|
|
progress := map[string]any{"type": "system", "subtype": "task_progress", "task_id": "task-meta", "description": "Reviewing changes", "summary": "Checking focused tests", "last_tool_name": "Bash", "timestamp": "2026-11-05T09:20:00Z", "usage": map[string]any{"duration_ms": 120000, "tool_uses": 4, "total_tokens": 1500}}
|
|
s.handleLine(nil, line(t, progress))
|
|
tasks := running(t, chat)
|
|
if len(tasks) != 1 {
|
|
t.Fatalf("tasks=%+v", tasks)
|
|
}
|
|
task := tasks[0]
|
|
if task.StartedAt != 1793870280000 || task.UpdatedAt != 1793870400000 || task.TaskType != "local_agent" || task.Description != "Reviewing changes" || task.Progress != "Checking focused tests" || task.LastTool != "Bash" || *task.ToolCount != 4 || *task.TokenCount != 1500 || *task.DurationMS != 120000 {
|
|
t.Fatalf("metadata=%+v", task)
|
|
}
|
|
// A duplicate initiating message must not reset the progress snapshot.
|
|
s.handleLine(nil, line(t, start))
|
|
progress["usage"] = map[string]any{"duration_ms": 1000, "tool_uses": 1, "total_tokens": 1}
|
|
progress["summary"] = "stale"
|
|
s.handleLine(nil, line(t, progress))
|
|
task = running(t, chat)[0]
|
|
if task.StartedAt != 1793870280000 || task.Progress != "Checking focused tests" || *task.ToolCount != 4 || task.TaskType != "local_agent" || task.Description != "Reviewing changes" {
|
|
t.Fatalf("regressed metadata=%+v", task)
|
|
}
|
|
s.handleLine(nil, line(t, map[string]any{"type": "system", "subtype": "task_notification", "tool_use_id": "toolu_meta", "status": "completed", "summary": "Review complete", "usage": map[string]any{"duration_ms": 180000, "tool_uses": 5, "total_tokens": 2000}}))
|
|
if len(running(t, chat)) != 0 {
|
|
t.Fatal("task did not exit")
|
|
}
|
|
s.mu.Lock()
|
|
ended := s.shells["toolu_meta"].shell
|
|
s.mu.Unlock()
|
|
if ended.Status != protocol.ChatShellExited || ended.StartedAt != task.StartedAt || *ended.DurationMS != 180000 || ended.Progress != "Review complete" {
|
|
t.Fatalf("ended=%+v", ended)
|
|
}
|
|
}
|
|
|
|
func TestTaskStartRecoveredFromTranscriptAcrossReplay(t *testing.T) {
|
|
config := t.TempDir()
|
|
t.Setenv("CLAUDE_CONFIG_DIR", config)
|
|
dir := filepath.Join(config, "projects", "fixture")
|
|
if err := os.MkdirAll(dir, 0700); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
source := toolUse(t, "toolu_replay", "Bash", map[string]any{"command": "sleep 30", "run_in_background": true})
|
|
var entry map[string]any
|
|
json.Unmarshal(source, &entry)
|
|
entry["timestamp"] = "2026-11-05T09:18:00Z"
|
|
raw := line(t, entry)
|
|
if err := os.WriteFile(filepath.Join(dir, "ses_bg.jsonl"), append(raw, '\n'), 0600); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
for range 2 {
|
|
chat, s := backgroundSession(t)
|
|
s.silent = true // Reattached hosts reconstruct from the same original lines.
|
|
s.handleLine(nil, source) // CLI stream itself has no timestamp.
|
|
task := running(t, chat)[0]
|
|
if task.StartedAt != 1793870280000 || task.TaskType != "shell" {
|
|
t.Fatalf("transcript start=%+v", task)
|
|
}
|
|
again := running(t, chat)[0]
|
|
if task.StartedAt != again.StartedAt {
|
|
t.Fatal("read reset start")
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestMissingTaskTimingAndInvalidCountersStayUnknown(t *testing.T) {
|
|
chat, s := backgroundSession(t)
|
|
s.handleLine(nil, toolUse(t, "toolu_unknown", "Agent", map[string]any{"description": "Unknown timing"}))
|
|
s.handleLine(nil, line(t, map[string]any{"type": "system", "subtype": "task_progress", "tool_use_id": "toolu_unknown", "timestamp": "invalid", "summary": strings.Repeat("p", 4000), "usage": map[string]any{"duration_ms": -1, "tool_uses": -2, "total_tokens": -3}}))
|
|
task := running(t, chat)[0]
|
|
if task.StartedAt != 0 || task.UpdatedAt != 0 || task.DurationMS != nil || task.ToolCount != nil || task.TokenCount != nil || len(task.Progress) > 2100 {
|
|
t.Fatalf("invented/unbounded metadata=%+v", task)
|
|
}
|
|
}
|
|
|
|
func TestOptionalTranscriptLookupBacksOffAndCachesOversizedFiles(t *testing.T) {
|
|
config := t.TempDir()
|
|
t.Setenv("CLAUDE_CONFIG_DIR", config)
|
|
chat, s := backgroundSession(t)
|
|
s.handleLine(nil, toolUse(t, "toolu_cache", "Bash", map[string]any{"command": "sleep 30", "run_in_background": true}))
|
|
if task := running(t, chat)[0]; task.StartedAt != 0 {
|
|
t.Fatal("invented missing transcript time")
|
|
}
|
|
if s.shellLookupAfter.IsZero() || s.shellScanAfter.IsZero() {
|
|
t.Fatal("missing lookup has no retry backoff")
|
|
}
|
|
dir := filepath.Join(config, "projects", "fixture")
|
|
if err := os.MkdirAll(dir, 0700); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
path := filepath.Join(dir, "ses_bg.jsonl")
|
|
f, err := os.Create(path)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err = f.Truncate(maxTranscriptBytes + 1); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
f.Close()
|
|
s.shellLookupAfter = time.Time{}
|
|
s.shellScanAfter = time.Time{}
|
|
running(t, chat)
|
|
if s.shellTranscriptSize != maxTranscriptBytes+1 || s.shellTranscriptMtime == 0 {
|
|
t.Fatal("oversized read did not cache fingerprint")
|
|
}
|
|
// A repaired/changed source is read on the next retry; a prior failure is
|
|
// neither a fabricated start nor a permanent inability to enrich the task.
|
|
raw := toolUse(t, "toolu_cache", "Bash", map[string]any{"command": "sleep 30"})
|
|
var entry map[string]any
|
|
json.Unmarshal(raw, &entry)
|
|
entry["timestamp"] = "2026-11-05T09:18:00Z"
|
|
if err := os.WriteFile(path, append(line(t, entry), '\n'), 0600); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
s.shellScanAfter = time.Time{}
|
|
if task := running(t, chat)[0]; task.StartedAt != 1793870280000 {
|
|
t.Fatalf("repaired source not read: %+v", task)
|
|
}
|
|
}
|