Files
archie/internal/tools/builtin/read_test.go
T
sam bf7eb16bc4 fix(builtin): bound read/edit filesystem work by DefaultToolTimeout
WIRE: read and edit each declared a DefaultToolTimeout deadline and then
discarded it, so the documented contract (Tools that exceed this are
cancelled) was a no-op on the live tool-executor path. Wire the deadline
through runWithContext, the same helper write already uses, so a hung
filesystem cannot block the tool executor.
2026-09-15 13:12:21 +10:00

234 lines
7.5 KiB
Go

package builtin
import (
"context"
"encoding/json"
"fmt"
"os"
"path/filepath"
"strings"
"testing"
"time"
)
func execRead(t *testing.T, cwd, params string) Result {
t.Helper()
tool := NewReadTool(cwd, nil)
res, err := tool.Execute(context.Background(), json.RawMessage(params), nil)
if err != nil {
t.Fatalf("unexpected error: %v", err)
}
return res
}
func TestReadTool_RawContentNoGutter(t *testing.T) {
tmp := t.TempDir()
writeReadTestFile(t, tmp, "f.txt", "alpha\nbeta\ngamma\n")
res := execRead(t, tmp, `{"path": "f.txt"}`)
if res.IsError {
t.Fatalf("unexpected tool error: %s", res.Content)
}
if strings.Contains(res.Content, "│") {
t.Fatalf("expected raw content without line-number gutter, got:\n%s", res.Content)
}
if !strings.HasPrefix(res.Content, "alpha\nbeta\ngamma") {
t.Fatalf("unexpected content:\n%s", res.Content)
}
}
func TestReadToolAcceptsFileAlias(t *testing.T) {
tmp := t.TempDir()
writeReadTestFile(t, tmp, "f.txt", "alpha\nbeta\n")
res := execRead(t, tmp, `{"file":"f.txt"}`)
if res.IsError || !strings.HasPrefix(res.Content, "alpha\nbeta") {
t.Fatalf("file alias result = %#v", res)
}
}
func TestReadToolDefaultsToBoundedOutput(t *testing.T) {
tmp := t.TempDir()
lines := make([]string, DefaultReadLines+10)
for i := range lines {
lines[i] = fmt.Sprintf("line %d", i+1)
}
writeReadTestFile(t, tmp, "f.txt", strings.Join(lines, "\n"))
res := execRead(t, tmp, `{"path":"f.txt"}`)
if res.IsError || !strings.Contains(res.Content, fmt.Sprintf("Use offset=%d to continue", DefaultReadLines+1)) {
t.Fatalf("bounded read result = %s", res.Content)
}
}
func TestReadTool_UserLimitContinuationNotice(t *testing.T) {
tmp := t.TempDir()
var lines []string
for i := 1; i <= 50; i++ {
lines = append(lines, fmt.Sprintf("line %d", i))
}
writeReadTestFile(t, tmp, "f.txt", strings.Join(lines, "\n"))
res := execRead(t, tmp, `{"path": "f.txt", "offset": 10, "limit": 5}`)
if res.IsError {
t.Fatalf("unexpected tool error: %s", res.Content)
}
if !strings.HasPrefix(res.Content, "line 10") {
t.Fatalf("expected content to start at line 10, got:\n%s", res.Content)
}
if !strings.Contains(res.Content, "Use offset=15 to continue") {
t.Fatalf("expected continuation notice with offset=15, got:\n%s", res.Content)
}
if !strings.Contains(res.Content, "more lines in file") {
t.Fatalf("expected remaining-lines notice, got:\n%s", res.Content)
}
}
func TestReadTool_TruncationContinuationNotice(t *testing.T) {
tmp := t.TempDir()
var lines []string
for i := 1; i <= DefaultMaxLines+500; i++ {
lines = append(lines, fmt.Sprintf("line %d", i))
}
writeReadTestFile(t, tmp, "f.txt", strings.Join(lines, "\n"))
res := execRead(t, tmp, `{"path": "f.txt", "full": true}`)
if res.IsError {
t.Fatalf("unexpected tool error: %s", res.Content)
}
notice := fmt.Sprintf("[showing lines 1-%d of %d. Use offset=%d to continue.]", DefaultMaxLines, DefaultMaxLines+500, DefaultMaxLines+1)
if !strings.Contains(res.Content, notice) {
t.Fatalf("expected notice %q, got tail:\n%s", notice, res.Content[len(res.Content)-200:])
}
}
func TestReadTool_FirstLineExceedsByteLimit(t *testing.T) {
tmp := t.TempDir()
writeReadTestFile(t, tmp, "big.min.js", strings.Repeat("x", DefaultMaxBytes+100))
res := execRead(t, tmp, `{"path": "big.min.js"}`)
if res.IsError {
t.Fatalf("unexpected tool error: %s", res.Content)
}
if !strings.Contains(res.Content, "Use shell: sed -n '1p'") {
t.Fatalf("expected shell fallback hint, got:\n%s", res.Content)
}
}
func writeReadTestFile(t *testing.T, dir, name, content string) {
t.Helper()
if err := os.WriteFile(filepath.Join(dir, name), []byte(content), 0o644); err != nil {
t.Fatal(err)
}
}
func TestReadTool_DirectoryReturnsListing(t *testing.T) {
tmp := t.TempDir()
writeReadTestFile(t, tmp, "alpha.go", "package a\n")
writeReadTestFile(t, tmp, "beta.go", "package b\n")
if err := os.Mkdir(filepath.Join(tmp, "sub"), 0o755); err != nil {
t.Fatal(err)
}
res := execRead(t, tmp, `{"path": "."}`)
if res.IsError {
t.Fatalf("expected a listing, not an error: %s", res.Content)
}
for _, want := range []string{"alpha.go", "beta.go", "sub/"} {
if !strings.Contains(res.Content, want) {
t.Fatalf("listing missing %q, got:\n%s", want, res.Content)
}
}
if !strings.Contains(res.Content, "is a directory") {
t.Fatalf("expected the listing to say the path is a directory, got:\n%s", res.Content)
}
}
// A directory must not satisfy the read-before-write check: marking it read
// would let a later write to a same-named file bypass the guard.
func TestReadTool_DirectoryDoesNotMarkRead(t *testing.T) {
tmp := t.TempDir()
rt := NewReadTracker()
tool := NewReadTool(tmp, rt)
res, err := tool.Execute(context.Background(), json.RawMessage(`{"path": "."}`), nil)
if err != nil {
t.Fatalf("unexpected error: %v", err)
}
if res.IsError {
t.Fatalf("unexpected tool error: %s", res.Content)
}
if err := rt.CheckRead(tmp, "."); err == nil {
t.Fatal("reading a directory must not mark it as read")
}
}
// 5 reads in the analysed corpus failed on plausible-but-wrong paths, each
// costing a round trip plus a follow-up find.
func TestReadTool_NotFoundSuggestsNearestPaths(t *testing.T) {
tmp := t.TempDir()
if err := os.MkdirAll(filepath.Join(tmp, "internal", "ui", "theme"), 0o755); err != nil {
t.Fatal(err)
}
writeReadTestFile(t, filepath.Join(tmp, "internal", "ui", "theme"), "theme.go", "package theme\n")
res := execRead(t, tmp, `{"path":"internal/theme/theme.go"}`)
if !res.IsError {
t.Fatal("expected a not-found error")
}
if !strings.Contains(res.Content, filepath.Join("internal", "ui", "theme", "theme.go")) {
t.Fatalf("expected the real path to be suggested, got:\n%s", res.Content)
}
}
func TestReadTool_NotFoundWithNoCandidateStaysPlain(t *testing.T) {
tmp := t.TempDir()
writeReadTestFile(t, tmp, "other.go", "package other\n")
res := execRead(t, tmp, `{"path":"internal/nothing/absent.go"}`)
if !res.IsError {
t.Fatal("expected a not-found error")
}
if strings.Contains(res.Content, "did you mean") {
t.Fatalf("no candidate should mean no suggestion, got:\n%s", res.Content)
}
}
// The real-world miss was internal/theme/theme.go: the directory exists but
// holds differently-named files, so a basename search finds nothing. Listing
// the directory that does exist is the useful answer.
func TestReadTool_NotFoundListsExistingParentDir(t *testing.T) {
tmp := t.TempDir()
if err := os.MkdirAll(filepath.Join(tmp, "internal", "theme"), 0o755); err != nil {
t.Fatal(err)
}
writeReadTestFile(t, filepath.Join(tmp, "internal", "theme"), "colors.go", "package theme\n")
res := execRead(t, tmp, `{"path":"internal/theme/theme.go"}`)
if !res.IsError {
t.Fatal("expected a not-found error")
}
if !strings.Contains(res.Content, "colors.go") {
t.Fatalf("expected the existing directory to be listed, got:\n%s", res.Content)
}
}
// TestReadToolHonoursDeadlineOnExpiredContext pins the DefaultToolTimeout
// contract: when the caller's context is already expired, read must not
// ignore that deadline and read the file anyway.
func TestReadToolHonoursDeadlineOnExpiredContext(t *testing.T) {
tmp := t.TempDir()
writeReadTestFile(t, tmp, "f.txt", "alpha\nbeta\n")
ctx, cancel := context.WithDeadline(context.Background(), time.Now().Add(-time.Second))
defer cancel()
tool := NewReadTool(tmp, nil)
res, err := tool.Execute(ctx, json.RawMessage(`{"path":"f.txt"}`), nil)
if err != nil {
t.Fatalf("unexpected error: %v", err)
}
if !res.IsError {
t.Fatalf("read on an expired context must not succeed; got content %q", res.Content)
}
}