test: add comprehensive Phase 0 test suite — 67 tests, 90.9% coverage
Add parser_test.go (22 tests), search_test.go (9 tests), html_test.go (6 tests), video_test.go (12 tests), and bench_test.go (4 benchmarks) covering all Phase 0 TODO items: - ParseTranscript: minimal JSONL, all 7 tool types, errors, truncated/malformed input, large sessions (1100+ events), nested array/map results, mixed content - ListSessions: empty dir, single/multi sorted, non-JSONL ignored, modtime fallback - extractToolInput: all tool types plus nil, invalid JSON, unknown tool fallback - extractResultContent: string, array, map, and other types - Search: empty dir, no matches, multi-match, case insensitive, output matching - RenderHTML: basic, empty, errors, XSS escaping, label types, invalid path - generateTape/extractCommand: all event types, empty/failed commands, truncation - Benchmarks: 2.2MB and 11MB ParseTranscript, ListSessions, Search with b.Loop() go vet ./... clean, go test -race ./... clean. Co-Authored-By: Virgil <virgil@lethean.io> Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
This commit is contained in:
Snider
parent
b620417ef0
commit
f40caaa593
6 changed files with 1213 additions and 981 deletions
10
TODO.md
10
TODO.md
|
|
@ -6,11 +6,11 @@ Dispatched from core/go orchestration. Pick up tasks in order.
|
|||
|
||||
## Phase 0: Hardening & Test Coverage
|
||||
|
||||
- [x] **Add parser tests** — 51 tests, 90.9% coverage. `7771e64`
|
||||
- [x] **Add ListSessions tests** — 5 tests (empty, single, sorted, non-jsonl, malformed). `7771e64`
|
||||
- [x] **Tool extraction coverage** — All 7 tool types + unknown fallback + nil. `7771e64`
|
||||
- [x] **Benchmark parsing** — `BenchmarkParseTranscript` with 4000-line JSONL. `7771e64`
|
||||
- [x] **`go vet ./...` clean** — No warnings. `7771e64`
|
||||
- [x] **Add parser tests** — Test `ParseTranscript()` with: minimal valid JSONL (1 user + 1 assistant message), tool call events (Bash, Read, Edit, Write, Grep, Glob, Task), truncated JSONL (incomplete last line), empty file, malformed JSON lines (should skip gracefully), very large session (1000+ events), nested tool results with arrays and maps. Also added HTML, video, and search tests. 67 tests, 90.9% coverage.
|
||||
- [x] **Add ListSessions tests** — Test with: empty directory, single session, multiple sessions sorted by date, non-.jsonl files ignored, malformed JSONL fallback to modtime.
|
||||
- [x] **Tool extraction coverage** — Test `extractToolInput()` for each supported tool type (Bash, Read, Edit, Write, Grep, Glob, Task) plus nil input, invalid JSON, and unknown tool fallback.
|
||||
- [x] **Benchmark parsing** — `BenchmarkParseTranscript` with 2.2MB (5K tools) and 11MB (25K tools) JSONL files. Plus `BenchmarkListSessions` and `BenchmarkSearch`. Uses `b.Loop()` (Go 1.25+).
|
||||
- [x] **`go vet ./...` clean** — Verified clean, no warnings.
|
||||
|
||||
## Phase 1: Parser Robustness
|
||||
|
||||
|
|
|
|||
155
bench_test.go
Normal file
155
bench_test.go
Normal file
|
|
@ -0,0 +1,155 @@
|
|||
// SPDX-Licence-Identifier: EUPL-1.2
|
||||
package session
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"os"
|
||||
"path/filepath"
|
||||
"strings"
|
||||
"testing"
|
||||
)
|
||||
|
||||
// BenchmarkParseTranscript benchmarks parsing a ~1MB+ JSONL file.
|
||||
func BenchmarkParseTranscript(b *testing.B) {
|
||||
dir := b.TempDir()
|
||||
path := generateBenchJSONL(b, dir, 5000) // ~1MB+ of JSONL
|
||||
|
||||
b.ResetTimer()
|
||||
b.ReportAllocs()
|
||||
|
||||
for b.Loop() {
|
||||
sess, err := ParseTranscript(path)
|
||||
if err != nil {
|
||||
b.Fatal(err)
|
||||
}
|
||||
if len(sess.Events) == 0 {
|
||||
b.Fatal("expected events")
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// BenchmarkParseTranscript_Large benchmarks a larger ~5MB file.
|
||||
func BenchmarkParseTranscript_Large(b *testing.B) {
|
||||
dir := b.TempDir()
|
||||
path := generateBenchJSONL(b, dir, 25000) // ~5MB
|
||||
|
||||
b.ResetTimer()
|
||||
b.ReportAllocs()
|
||||
|
||||
for b.Loop() {
|
||||
_, err := ParseTranscript(path)
|
||||
if err != nil {
|
||||
b.Fatal(err)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// BenchmarkListSessions benchmarks listing sessions in a directory.
|
||||
func BenchmarkListSessions(b *testing.B) {
|
||||
dir := b.TempDir()
|
||||
|
||||
// Create 20 session files
|
||||
for i := 0; i < 20; i++ {
|
||||
generateBenchJSONL(b, dir, 100)
|
||||
}
|
||||
|
||||
b.ResetTimer()
|
||||
b.ReportAllocs()
|
||||
|
||||
for b.Loop() {
|
||||
sessions, err := ListSessions(dir)
|
||||
if err != nil {
|
||||
b.Fatal(err)
|
||||
}
|
||||
if len(sessions) == 0 {
|
||||
b.Fatal("expected sessions")
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// BenchmarkSearch benchmarks searching across multiple sessions.
|
||||
func BenchmarkSearch(b *testing.B) {
|
||||
dir := b.TempDir()
|
||||
|
||||
// Create 10 session files with varied content
|
||||
for i := 0; i < 10; i++ {
|
||||
generateBenchJSONL(b, dir, 500)
|
||||
}
|
||||
|
||||
b.ResetTimer()
|
||||
b.ReportAllocs()
|
||||
|
||||
for b.Loop() {
|
||||
_, err := Search(dir, "echo")
|
||||
if err != nil {
|
||||
b.Fatal(err)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// generateBenchJSONL creates a synthetic JSONL file with the given number of tool pairs.
|
||||
// Returns the file path.
|
||||
func generateBenchJSONL(b testing.TB, dir string, numTools int) string {
|
||||
b.Helper()
|
||||
|
||||
var sb strings.Builder
|
||||
baseTS := "2026-02-20T10:00:00Z"
|
||||
|
||||
// Opening user message
|
||||
sb.WriteString(fmt.Sprintf(`{"type":"user","timestamp":"%s","sessionId":"bench","message":{"role":"user","content":[{"type":"text","text":"Start benchmark session"}]}}`, baseTS))
|
||||
sb.WriteByte('\n')
|
||||
|
||||
for i := 0; i < numTools; i++ {
|
||||
toolID := fmt.Sprintf("tool-%d", i)
|
||||
offset := i * 2
|
||||
|
||||
// Alternate between different tool types for realistic distribution
|
||||
var toolUse, toolResult string
|
||||
switch i % 5 {
|
||||
case 0: // Bash
|
||||
toolUse = fmt.Sprintf(`{"type":"assistant","timestamp":"2026-02-20T10:%02d:%02dZ","sessionId":"bench","message":{"role":"assistant","content":[{"type":"tool_use","name":"Bash","id":"%s","input":{"command":"echo iteration %d","description":"echo test"}}]}}`,
|
||||
offset/60, offset%60, toolID, i)
|
||||
toolResult = fmt.Sprintf(`{"type":"user","timestamp":"2026-02-20T10:%02d:%02dZ","sessionId":"bench","message":{"role":"user","content":[{"type":"tool_result","tool_use_id":"%s","content":"iteration %d output line one\niteration %d output line two","is_error":false}]}}`,
|
||||
(offset+1)/60, (offset+1)%60, toolID, i, i)
|
||||
case 1: // Read
|
||||
toolUse = fmt.Sprintf(`{"type":"assistant","timestamp":"2026-02-20T10:%02d:%02dZ","sessionId":"bench","message":{"role":"assistant","content":[{"type":"tool_use","name":"Read","id":"%s","input":{"file_path":"/tmp/bench/file-%d.go"}}]}}`,
|
||||
offset/60, offset%60, toolID, i)
|
||||
toolResult = fmt.Sprintf(`{"type":"user","timestamp":"2026-02-20T10:%02d:%02dZ","sessionId":"bench","message":{"role":"user","content":[{"type":"tool_result","tool_use_id":"%s","content":"package main\n\nfunc main() {\n\tfmt.Println(%d)\n}","is_error":false}]}}`,
|
||||
(offset+1)/60, (offset+1)%60, toolID, i)
|
||||
case 2: // Edit
|
||||
toolUse = fmt.Sprintf(`{"type":"assistant","timestamp":"2026-02-20T10:%02d:%02dZ","sessionId":"bench","message":{"role":"assistant","content":[{"type":"tool_use","name":"Edit","id":"%s","input":{"file_path":"/tmp/bench/file-%d.go","old_string":"old","new_string":"new"}}]}}`,
|
||||
offset/60, offset%60, toolID, i)
|
||||
toolResult = fmt.Sprintf(`{"type":"user","timestamp":"2026-02-20T10:%02d:%02dZ","sessionId":"bench","message":{"role":"user","content":[{"type":"tool_result","tool_use_id":"%s","content":"ok","is_error":false}]}}`,
|
||||
(offset+1)/60, (offset+1)%60, toolID)
|
||||
case 3: // Grep
|
||||
toolUse = fmt.Sprintf(`{"type":"assistant","timestamp":"2026-02-20T10:%02d:%02dZ","sessionId":"bench","message":{"role":"assistant","content":[{"type":"tool_use","name":"Grep","id":"%s","input":{"pattern":"TODO","path":"/tmp/bench"}}]}}`,
|
||||
offset/60, offset%60, toolID)
|
||||
toolResult = fmt.Sprintf(`{"type":"user","timestamp":"2026-02-20T10:%02d:%02dZ","sessionId":"bench","message":{"role":"user","content":[{"type":"tool_result","tool_use_id":"%s","content":"/tmp/bench/file.go:10: // TODO fix this","is_error":false}]}}`,
|
||||
(offset+1)/60, (offset+1)%60, toolID)
|
||||
case 4: // Glob
|
||||
toolUse = fmt.Sprintf(`{"type":"assistant","timestamp":"2026-02-20T10:%02d:%02dZ","sessionId":"bench","message":{"role":"assistant","content":[{"type":"tool_use","name":"Glob","id":"%s","input":{"pattern":"**/*.go"}}]}}`,
|
||||
offset/60, offset%60, toolID)
|
||||
toolResult = fmt.Sprintf(`{"type":"user","timestamp":"2026-02-20T10:%02d:%02dZ","sessionId":"bench","message":{"role":"user","content":[{"type":"tool_result","tool_use_id":"%s","content":"/tmp/a.go\n/tmp/b.go\n/tmp/c.go","is_error":false}]}}`,
|
||||
(offset+1)/60, (offset+1)%60, toolID)
|
||||
}
|
||||
|
||||
sb.WriteString(toolUse)
|
||||
sb.WriteByte('\n')
|
||||
sb.WriteString(toolResult)
|
||||
sb.WriteByte('\n')
|
||||
}
|
||||
|
||||
// Closing assistant message
|
||||
sb.WriteString(fmt.Sprintf(`{"type":"assistant","timestamp":"2026-02-20T12:00:00Z","sessionId":"bench","message":{"role":"assistant","content":[{"type":"text","text":"Benchmark session complete."}]}}%s`, "\n"))
|
||||
|
||||
name := fmt.Sprintf("bench-%d.jsonl", numTools)
|
||||
path := filepath.Join(dir, name)
|
||||
if err := os.WriteFile(path, []byte(sb.String()), 0644); err != nil {
|
||||
b.Fatal(err)
|
||||
}
|
||||
|
||||
info, _ := os.Stat(path)
|
||||
b.Logf("Generated %s: %d bytes, %d tool pairs", name, info.Size(), numTools)
|
||||
|
||||
return path
|
||||
}
|
||||
407
html_test.go
407
html_test.go
|
|
@ -1,8 +1,8 @@
|
|||
// SPDX-Licence-Identifier: EUPL-1.2
|
||||
package session
|
||||
|
||||
import (
|
||||
"os"
|
||||
"path/filepath"
|
||||
"strings"
|
||||
"testing"
|
||||
"time"
|
||||
|
|
@ -11,333 +11,228 @@ import (
|
|||
"github.com/stretchr/testify/require"
|
||||
)
|
||||
|
||||
func TestRenderHTML_BasicSession(t *testing.T) {
|
||||
func TestRenderHTML_BasicSession_Good(t *testing.T) {
|
||||
dir := t.TempDir()
|
||||
outputPath := dir + "/output.html"
|
||||
|
||||
sess := &Session{
|
||||
ID: "test-session-abcdef12",
|
||||
ID: "test-session-12345678",
|
||||
Path: "/tmp/test.jsonl",
|
||||
StartTime: baseTime,
|
||||
EndTime: baseTime.Add(5 * time.Minute),
|
||||
StartTime: time.Date(2026, 2, 20, 10, 0, 0, 0, time.UTC),
|
||||
EndTime: time.Date(2026, 2, 20, 10, 5, 30, 0, time.UTC),
|
||||
Events: []Event{
|
||||
{
|
||||
Timestamp: baseTime,
|
||||
Timestamp: time.Date(2026, 2, 20, 10, 0, 0, 0, time.UTC),
|
||||
Type: "user",
|
||||
Input: "Please list files",
|
||||
Input: "Hello, please help me",
|
||||
},
|
||||
{
|
||||
Timestamp: baseTime.Add(time.Second),
|
||||
Type: "tool_use",
|
||||
Tool: "Bash",
|
||||
ToolID: "tu_1",
|
||||
Input: "ls -la # list files",
|
||||
Output: "total 42\ndrwxr-xr-x 3 user user 4096 Feb 19 .",
|
||||
Duration: 2 * time.Second,
|
||||
Success: true,
|
||||
},
|
||||
{
|
||||
Timestamp: baseTime.Add(3 * time.Second),
|
||||
Timestamp: time.Date(2026, 2, 20, 10, 0, 1, 0, time.UTC),
|
||||
Type: "assistant",
|
||||
Input: "The directory contains 42 items.",
|
||||
Input: "Sure, let me check.",
|
||||
},
|
||||
},
|
||||
}
|
||||
|
||||
dir := t.TempDir()
|
||||
outputPath := filepath.Join(dir, "out.html")
|
||||
err := RenderHTML(sess, outputPath)
|
||||
require.NoError(t, err)
|
||||
|
||||
data, err := os.ReadFile(outputPath)
|
||||
require.NoError(t, err)
|
||||
html := string(data)
|
||||
|
||||
t.Run("contains_doctype", func(t *testing.T) {
|
||||
assert.True(t, strings.HasPrefix(html, "<!DOCTYPE html>"))
|
||||
})
|
||||
|
||||
t.Run("contains_session_id", func(t *testing.T) {
|
||||
assert.Contains(t, html, "test-ses")
|
||||
})
|
||||
|
||||
t.Run("contains_timestamp", func(t *testing.T) {
|
||||
assert.Contains(t, html, "2026-02-19 10:00:00")
|
||||
})
|
||||
|
||||
t.Run("contains_tool_count", func(t *testing.T) {
|
||||
assert.Contains(t, html, "1 tool calls")
|
||||
})
|
||||
|
||||
t.Run("contains_user_event", func(t *testing.T) {
|
||||
assert.Contains(t, html, "User")
|
||||
assert.Contains(t, html, "Please list files")
|
||||
})
|
||||
|
||||
t.Run("contains_bash_event", func(t *testing.T) {
|
||||
assert.Contains(t, html, "Bash")
|
||||
assert.Contains(t, html, "ls -la")
|
||||
})
|
||||
|
||||
t.Run("contains_assistant_event", func(t *testing.T) {
|
||||
assert.Contains(t, html, "Claude")
|
||||
})
|
||||
|
||||
t.Run("contains_js_functions", func(t *testing.T) {
|
||||
assert.Contains(t, html, "function toggle(")
|
||||
assert.Contains(t, html, "function filterEvents(")
|
||||
})
|
||||
|
||||
t.Run("contains_success_icon", func(t *testing.T) {
|
||||
assert.Contains(t, html, "✓") // Tick mark
|
||||
})
|
||||
|
||||
t.Run("html_ends_properly", func(t *testing.T) {
|
||||
assert.True(t, strings.HasSuffix(strings.TrimSpace(html), "</html>"))
|
||||
})
|
||||
}
|
||||
|
||||
func TestRenderHTML_EmptySession(t *testing.T) {
|
||||
sess := &Session{
|
||||
ID: "empty-session",
|
||||
Path: "/tmp/empty.jsonl",
|
||||
StartTime: baseTime,
|
||||
EndTime: baseTime,
|
||||
Events: nil,
|
||||
}
|
||||
|
||||
dir := t.TempDir()
|
||||
outputPath := filepath.Join(dir, "empty.html")
|
||||
err := RenderHTML(sess, outputPath)
|
||||
require.NoError(t, err)
|
||||
|
||||
data, err := os.ReadFile(outputPath)
|
||||
require.NoError(t, err)
|
||||
html := string(data)
|
||||
|
||||
assert.Contains(t, html, "<!DOCTYPE html>")
|
||||
assert.Contains(t, html, "0 tool calls")
|
||||
// No error count span should appear in the stats.
|
||||
assert.NotContains(t, html, `class="err">`)
|
||||
}
|
||||
|
||||
func TestRenderHTML_WithErrors(t *testing.T) {
|
||||
sess := &Session{
|
||||
ID: "error-session",
|
||||
Path: "/tmp/err.jsonl",
|
||||
StartTime: baseTime,
|
||||
EndTime: baseTime.Add(10 * time.Second),
|
||||
Events: []Event{
|
||||
{
|
||||
Timestamp: baseTime,
|
||||
Timestamp: time.Date(2026, 2, 20, 10, 0, 2, 0, time.UTC),
|
||||
Type: "tool_use",
|
||||
Tool: "Bash",
|
||||
ToolID: "tu_ok",
|
||||
Input: "echo ok",
|
||||
Output: "ok",
|
||||
ToolID: "t1",
|
||||
Input: "ls -la",
|
||||
Output: "total 42",
|
||||
Duration: time.Second,
|
||||
Success: true,
|
||||
},
|
||||
{
|
||||
Timestamp: baseTime.Add(2 * time.Second),
|
||||
Timestamp: time.Date(2026, 2, 20, 10, 0, 4, 0, time.UTC),
|
||||
Type: "tool_use",
|
||||
Tool: "Bash",
|
||||
ToolID: "tu_err",
|
||||
Input: "false",
|
||||
Output: "exit 1",
|
||||
Duration: time.Second,
|
||||
Success: false,
|
||||
ErrorMsg: "exit 1",
|
||||
},
|
||||
},
|
||||
}
|
||||
|
||||
dir := t.TempDir()
|
||||
outputPath := filepath.Join(dir, "errors.html")
|
||||
err := RenderHTML(sess, outputPath)
|
||||
require.NoError(t, err)
|
||||
|
||||
data, err := os.ReadFile(outputPath)
|
||||
require.NoError(t, err)
|
||||
html := string(data)
|
||||
|
||||
assert.Contains(t, html, "2 tool calls")
|
||||
assert.Contains(t, html, "1 errors")
|
||||
assert.Contains(t, html, `class="err"`)
|
||||
assert.Contains(t, html, "✗") // Cross mark for error
|
||||
}
|
||||
|
||||
func TestRenderHTML_DurationFormatting(t *testing.T) {
|
||||
sess := &Session{
|
||||
ID: "dur-test",
|
||||
Path: "/tmp/dur.jsonl",
|
||||
StartTime: baseTime,
|
||||
EndTime: baseTime.Add(2 * time.Hour),
|
||||
Events: []Event{
|
||||
{
|
||||
Timestamp: baseTime,
|
||||
Type: "tool_use",
|
||||
Tool: "Bash",
|
||||
ToolID: "tu_ms",
|
||||
Input: "fast cmd",
|
||||
Tool: "Read",
|
||||
ToolID: "t2",
|
||||
Input: "/tmp/file.go",
|
||||
Output: "package main",
|
||||
Duration: 500 * time.Millisecond,
|
||||
Success: true,
|
||||
},
|
||||
},
|
||||
}
|
||||
|
||||
err := RenderHTML(sess, outputPath)
|
||||
require.NoError(t, err)
|
||||
|
||||
content, err := os.ReadFile(outputPath)
|
||||
require.NoError(t, err)
|
||||
|
||||
html := string(content)
|
||||
|
||||
// Basic structure checks
|
||||
assert.Contains(t, html, "<!DOCTYPE html>")
|
||||
assert.Contains(t, html, "test-ses") // shortID of "test-session-12345678"
|
||||
assert.Contains(t, html, "2026-02-20 10:00:00")
|
||||
assert.Contains(t, html, "5m30s") // duration
|
||||
assert.Contains(t, html, "2 tool calls")
|
||||
assert.Contains(t, html, "ls -la")
|
||||
assert.Contains(t, html, "total 42")
|
||||
assert.Contains(t, html, "/tmp/file.go")
|
||||
assert.Contains(t, html, "User") // user event label
|
||||
assert.Contains(t, html, "Claude") // assistant event label
|
||||
assert.Contains(t, html, "Bash")
|
||||
assert.Contains(t, html, "Read")
|
||||
// Should contain JS for toggle and filter
|
||||
assert.Contains(t, html, "function toggle")
|
||||
assert.Contains(t, html, "function filterEvents")
|
||||
}
|
||||
|
||||
func TestRenderHTML_EmptySession_Good(t *testing.T) {
|
||||
dir := t.TempDir()
|
||||
outputPath := dir + "/empty.html"
|
||||
|
||||
sess := &Session{
|
||||
ID: "empty",
|
||||
Path: "/tmp/empty.jsonl",
|
||||
StartTime: time.Date(2026, 2, 20, 10, 0, 0, 0, time.UTC),
|
||||
EndTime: time.Date(2026, 2, 20, 10, 0, 0, 0, time.UTC),
|
||||
Events: nil,
|
||||
}
|
||||
|
||||
err := RenderHTML(sess, outputPath)
|
||||
require.NoError(t, err)
|
||||
|
||||
content, err := os.ReadFile(outputPath)
|
||||
require.NoError(t, err)
|
||||
|
||||
html := string(content)
|
||||
assert.Contains(t, html, "<!DOCTYPE html>")
|
||||
assert.Contains(t, html, "0 tool calls")
|
||||
// Should NOT contain error span
|
||||
assert.NotContains(t, html, "errors</span>")
|
||||
}
|
||||
|
||||
func TestRenderHTML_WithErrors_Good(t *testing.T) {
|
||||
dir := t.TempDir()
|
||||
outputPath := dir + "/errors.html"
|
||||
|
||||
sess := &Session{
|
||||
ID: "err-session",
|
||||
Path: "/tmp/err.jsonl",
|
||||
StartTime: time.Date(2026, 2, 20, 10, 0, 0, 0, time.UTC),
|
||||
EndTime: time.Date(2026, 2, 20, 10, 1, 0, 0, time.UTC),
|
||||
Events: []Event{
|
||||
{
|
||||
Timestamp: baseTime.Add(time.Second),
|
||||
Timestamp: time.Date(2026, 2, 20, 10, 0, 0, 0, time.UTC),
|
||||
Type: "tool_use",
|
||||
Tool: "Bash",
|
||||
ToolID: "tu_sec",
|
||||
Input: "slow cmd",
|
||||
Duration: 45 * time.Second,
|
||||
Success: true,
|
||||
Input: "cat /nonexistent",
|
||||
Output: "No such file",
|
||||
Duration: 100 * time.Millisecond,
|
||||
Success: false,
|
||||
ErrorMsg: "No such file",
|
||||
},
|
||||
{
|
||||
Timestamp: baseTime.Add(time.Minute),
|
||||
Timestamp: time.Date(2026, 2, 20, 10, 0, 30, 0, time.UTC),
|
||||
Type: "tool_use",
|
||||
Tool: "Bash",
|
||||
ToolID: "tu_min",
|
||||
Input: "very slow cmd",
|
||||
Duration: 3*time.Minute + 30*time.Second,
|
||||
Input: "echo ok",
|
||||
Output: "ok",
|
||||
Duration: 50 * time.Millisecond,
|
||||
Success: true,
|
||||
},
|
||||
},
|
||||
}
|
||||
|
||||
dir := t.TempDir()
|
||||
outputPath := filepath.Join(dir, "dur.html")
|
||||
err := RenderHTML(sess, outputPath)
|
||||
require.NoError(t, err)
|
||||
|
||||
data, err := os.ReadFile(outputPath)
|
||||
content, err := os.ReadFile(outputPath)
|
||||
require.NoError(t, err)
|
||||
html := string(data)
|
||||
|
||||
assert.Contains(t, html, "500ms")
|
||||
assert.Contains(t, html, "45.0s")
|
||||
assert.Contains(t, html, "3m30s")
|
||||
assert.Contains(t, html, "2h0m") // Header duration
|
||||
html := string(content)
|
||||
assert.Contains(t, html, "1 errors")
|
||||
assert.Contains(t, html, `class="event error"`)
|
||||
assert.Contains(t, html, "✗") // cross mark for failed
|
||||
assert.Contains(t, html, "✓") // check mark for success
|
||||
}
|
||||
|
||||
func TestRenderHTML_HTMLEscaping(t *testing.T) {
|
||||
func TestRenderHTML_SpecialCharacters_Good(t *testing.T) {
|
||||
dir := t.TempDir()
|
||||
outputPath := dir + "/special.html"
|
||||
|
||||
sess := &Session{
|
||||
ID: "escape-test",
|
||||
Path: "/tmp/esc.jsonl",
|
||||
StartTime: baseTime,
|
||||
EndTime: baseTime.Add(time.Second),
|
||||
ID: "special",
|
||||
Path: "/tmp/special.jsonl",
|
||||
StartTime: time.Date(2026, 2, 20, 10, 0, 0, 0, time.UTC),
|
||||
EndTime: time.Date(2026, 2, 20, 10, 0, 1, 0, time.UTC),
|
||||
Events: []Event{
|
||||
{
|
||||
Timestamp: baseTime,
|
||||
Type: "user",
|
||||
Input: `<script>alert("xss")</script>`,
|
||||
},
|
||||
{
|
||||
Timestamp: baseTime,
|
||||
Timestamp: time.Date(2026, 2, 20, 10, 0, 0, 0, time.UTC),
|
||||
Type: "tool_use",
|
||||
Tool: "Bash",
|
||||
ToolID: "tu_esc",
|
||||
Input: `echo "<b>bold</b>"`,
|
||||
Output: `<b>bold</b>`,
|
||||
Input: `echo "<script>alert('xss')</script>"`,
|
||||
Output: `<script>alert('xss')</script>`,
|
||||
Duration: time.Second,
|
||||
Success: true,
|
||||
},
|
||||
{
|
||||
Timestamp: time.Date(2026, 2, 20, 10, 0, 0, 0, time.UTC),
|
||||
Type: "user",
|
||||
Input: `User says: "quotes & <brackets>"`,
|
||||
},
|
||||
},
|
||||
}
|
||||
|
||||
dir := t.TempDir()
|
||||
outputPath := filepath.Join(dir, "esc.html")
|
||||
err := RenderHTML(sess, outputPath)
|
||||
require.NoError(t, err)
|
||||
|
||||
data, err := os.ReadFile(outputPath)
|
||||
content, err := os.ReadFile(outputPath)
|
||||
require.NoError(t, err)
|
||||
html := string(data)
|
||||
|
||||
// Raw angle brackets must be escaped.
|
||||
assert.NotContains(t, html, `<script>alert`)
|
||||
html := string(content)
|
||||
|
||||
// Script tags should be escaped, never raw
|
||||
assert.NotContains(t, html, "<script>alert")
|
||||
assert.Contains(t, html, "<script>")
|
||||
assert.Contains(t, html, "&")
|
||||
}
|
||||
|
||||
func TestRenderHTML_InvalidPath(t *testing.T) {
|
||||
sess := &Session{ID: "x", StartTime: baseTime, EndTime: baseTime}
|
||||
err := RenderHTML(sess, "/nonexistent/dir/out.html")
|
||||
func TestRenderHTML_InvalidPath_Ugly(t *testing.T) {
|
||||
sess := &Session{
|
||||
ID: "test",
|
||||
Events: nil,
|
||||
}
|
||||
|
||||
err := RenderHTML(sess, "/nonexistent/dir/output.html")
|
||||
require.Error(t, err)
|
||||
assert.Contains(t, err.Error(), "create html")
|
||||
}
|
||||
|
||||
func TestRenderHTML_AllEventTypes(t *testing.T) {
|
||||
// Verify that the label logic covers all event types.
|
||||
func TestRenderHTML_LabelsByToolType_Good(t *testing.T) {
|
||||
dir := t.TempDir()
|
||||
outputPath := dir + "/labels.html"
|
||||
|
||||
sess := &Session{
|
||||
ID: "labels",
|
||||
Path: "/tmp/labels.jsonl",
|
||||
StartTime: baseTime,
|
||||
EndTime: baseTime.Add(10 * time.Second),
|
||||
StartTime: time.Date(2026, 2, 20, 10, 0, 0, 0, time.UTC),
|
||||
EndTime: time.Date(2026, 2, 20, 10, 0, 5, 0, time.UTC),
|
||||
Events: []Event{
|
||||
{Timestamp: baseTime, Type: "user", Input: "user msg"},
|
||||
{Timestamp: baseTime, Type: "assistant", Input: "assistant msg"},
|
||||
{Timestamp: baseTime, Type: "tool_use", Tool: "Bash", Input: "cmd", Success: true, Duration: time.Second},
|
||||
{Timestamp: baseTime, Type: "tool_use", Tool: "Read", Input: "/path", Success: true, Duration: time.Second},
|
||||
{Timestamp: baseTime, Type: "tool_use", Tool: "Edit", Input: "/path (edit)", Success: true, Duration: time.Second},
|
||||
{Timestamp: baseTime, Type: "tool_use", Tool: "Write", Input: "/path (10 bytes)", Success: true, Duration: time.Second},
|
||||
{Timestamp: baseTime, Type: "tool_use", Tool: "Grep", Input: "/TODO/ in .", Success: true, Duration: time.Second},
|
||||
{Timestamp: baseTime, Type: "tool_use", Tool: "Glob", Input: "**/*.go", Success: true, Duration: time.Second},
|
||||
{Type: "tool_use", Tool: "Bash", Input: "ls", Timestamp: time.Date(2026, 2, 20, 10, 0, 0, 0, time.UTC), Success: true},
|
||||
{Type: "tool_use", Tool: "Read", Input: "/file", Timestamp: time.Date(2026, 2, 20, 10, 0, 1, 0, time.UTC), Success: true},
|
||||
{Type: "tool_use", Tool: "Glob", Input: "**/*.go", Timestamp: time.Date(2026, 2, 20, 10, 0, 2, 0, time.UTC), Success: true},
|
||||
{Type: "tool_use", Tool: "Grep", Input: "/TODO/ in .", Timestamp: time.Date(2026, 2, 20, 10, 0, 3, 0, time.UTC), Success: true},
|
||||
{Type: "tool_use", Tool: "Edit", Input: "/file (edit)", Timestamp: time.Date(2026, 2, 20, 10, 0, 4, 0, time.UTC), Success: true},
|
||||
{Type: "tool_use", Tool: "Write", Input: "/file (100 bytes)", Timestamp: time.Date(2026, 2, 20, 10, 0, 5, 0, time.UTC), Success: true},
|
||||
},
|
||||
}
|
||||
|
||||
dir := t.TempDir()
|
||||
outputPath := filepath.Join(dir, "labels.html")
|
||||
err := RenderHTML(sess, outputPath)
|
||||
require.NoError(t, err)
|
||||
|
||||
data, err := os.ReadFile(outputPath)
|
||||
content, err := os.ReadFile(outputPath)
|
||||
require.NoError(t, err)
|
||||
html := string(data)
|
||||
|
||||
// Check label assignments.
|
||||
assert.Contains(t, html, "Message") // User event label
|
||||
assert.Contains(t, html, "Response") // Assistant event label
|
||||
assert.Contains(t, html, "Command") // Bash event label
|
||||
assert.Contains(t, html, "Target") // Read/Grep/Glob event label
|
||||
assert.Contains(t, html, "File") // Edit/Write event label
|
||||
}
|
||||
|
||||
// -- shortID tests --
|
||||
|
||||
func TestShortID(t *testing.T) {
|
||||
tests := []struct {
|
||||
name string
|
||||
id string
|
||||
want string
|
||||
}{
|
||||
{"long id", "abcdef1234567890", "abcdef12"},
|
||||
{"short id", "abc", "abc"},
|
||||
{"exactly 8", "abcdefgh", "abcdefgh"},
|
||||
{"empty", "", ""},
|
||||
}
|
||||
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
assert.Equal(t, tt.want, shortID(tt.id))
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
// -- formatDuration tests --
|
||||
|
||||
func TestFormatDuration(t *testing.T) {
|
||||
tests := []struct {
|
||||
name string
|
||||
d time.Duration
|
||||
want string
|
||||
}{
|
||||
{"milliseconds", 500 * time.Millisecond, "500ms"},
|
||||
{"seconds", 45 * time.Second, "45.0s"},
|
||||
{"minutes", 3*time.Minute + 30*time.Second, "3m30s"},
|
||||
{"hours", 2*time.Hour + 15*time.Minute, "2h15m"},
|
||||
{"zero", 0, "0ms"},
|
||||
{"sub-millisecond", 500 * time.Microsecond, "0ms"},
|
||||
}
|
||||
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
assert.Equal(t, tt.want, formatDuration(tt.d))
|
||||
})
|
||||
}
|
||||
html := string(content)
|
||||
|
||||
// Bash gets "Command" label
|
||||
assert.True(t, strings.Contains(html, "Command"), "Bash events should use 'Command' label")
|
||||
// Read, Glob, Grep get "Target" label
|
||||
assert.True(t, strings.Contains(html, "Target"), "Read/Glob/Grep events should use 'Target' label")
|
||||
// Edit, Write get "File" label
|
||||
assert.True(t, strings.Contains(html, "File"), "Edit/Write events should use 'File' label")
|
||||
}
|
||||
|
|
|
|||
1037
parser_test.go
1037
parser_test.go
File diff suppressed because it is too large
Load diff
259
search_test.go
259
search_test.go
|
|
@ -1,173 +1,146 @@
|
|||
// SPDX-Licence-Identifier: EUPL-1.2
|
||||
package session
|
||||
|
||||
import (
|
||||
"os"
|
||||
"path/filepath"
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
"github.com/stretchr/testify/assert"
|
||||
"github.com/stretchr/testify/require"
|
||||
)
|
||||
|
||||
func TestSearch_FindsMatchingToolEvents(t *testing.T) {
|
||||
func TestSearch_EmptyDir_Good(t *testing.T) {
|
||||
dir := t.TempDir()
|
||||
lines := []string{
|
||||
`{"type":"assistant","timestamp":"` + ts(baseTime, 0) + `","sessionId":"s1","message":{"role":"assistant","content":[{"type":"tool_use","id":"tu_1","name":"Bash","input":{"command":"go test ./..."}}]}}`,
|
||||
`{"type":"user","timestamp":"` + ts(baseTime, time.Second) + `","sessionId":"s1","message":{"role":"user","content":[{"type":"tool_result","tool_use_id":"tu_1","content":"PASS"}]}}`,
|
||||
`{"type":"assistant","timestamp":"` + ts(baseTime, 2*time.Second) + `","sessionId":"s1","message":{"role":"assistant","content":[{"type":"tool_use","id":"tu_2","name":"Grep","input":{"pattern":"TODO","path":"/src"}}]}}`,
|
||||
`{"type":"user","timestamp":"` + ts(baseTime, 3*time.Second) + `","sessionId":"s1","message":{"role":"user","content":[{"type":"tool_result","tool_use_id":"tu_2","content":"main.go:42: // TODO fix this"}]}}`,
|
||||
}
|
||||
writeTempJSONL(t, dir, "session.jsonl", lines...)
|
||||
|
||||
t.Run("match_input", func(t *testing.T) {
|
||||
results, err := Search(dir, "go test")
|
||||
require.NoError(t, err)
|
||||
require.Len(t, results, 1)
|
||||
assert.Equal(t, "session", results[0].SessionID)
|
||||
assert.Equal(t, "Bash", results[0].Tool)
|
||||
assert.Contains(t, results[0].Match, "go test")
|
||||
})
|
||||
|
||||
t.Run("match_output", func(t *testing.T) {
|
||||
results, err := Search(dir, "TODO fix")
|
||||
require.NoError(t, err)
|
||||
require.Len(t, results, 1)
|
||||
assert.Equal(t, "Grep", results[0].Tool)
|
||||
})
|
||||
|
||||
t.Run("case_insensitive", func(t *testing.T) {
|
||||
results, err := Search(dir, "PASS")
|
||||
require.NoError(t, err)
|
||||
require.Len(t, results, 1)
|
||||
})
|
||||
|
||||
t.Run("no_match", func(t *testing.T) {
|
||||
results, err := Search(dir, "nonexistent query")
|
||||
require.NoError(t, err)
|
||||
assert.Empty(t, results)
|
||||
})
|
||||
}
|
||||
|
||||
func TestSearch_SkipsNonToolEvents(t *testing.T) {
|
||||
dir := t.TempDir()
|
||||
lines := []string{
|
||||
`{"type":"user","timestamp":"` + ts(baseTime, 0) + `","sessionId":"s2","message":{"role":"user","content":[{"type":"text","text":"find all TODO items"}]}}`,
|
||||
`{"type":"assistant","timestamp":"` + ts(baseTime, time.Second) + `","sessionId":"s2","message":{"role":"assistant","content":[{"type":"text","text":"I will search for TODO items."}]}}`,
|
||||
}
|
||||
writeTempJSONL(t, dir, "notool.jsonl", lines...)
|
||||
|
||||
// The text "TODO" exists in user and assistant messages but Search only
|
||||
// looks at tool_use events.
|
||||
results, err := Search(dir, "TODO")
|
||||
require.NoError(t, err)
|
||||
assert.Empty(t, results)
|
||||
}
|
||||
|
||||
func TestSearch_EmptyDirectory(t *testing.T) {
|
||||
dir := t.TempDir()
|
||||
results, err := Search(dir, "anything")
|
||||
require.NoError(t, err)
|
||||
assert.Empty(t, results)
|
||||
}
|
||||
|
||||
func TestSearch_MultipleSessions(t *testing.T) {
|
||||
func TestSearch_NoMatches_Good(t *testing.T) {
|
||||
dir := t.TempDir()
|
||||
writeJSONL(t, dir, "session.jsonl",
|
||||
toolUseEntry(ts(0), "Bash", "tool-1", map[string]interface{}{
|
||||
"command": "ls -la",
|
||||
}),
|
||||
toolResultEntry(ts(1), "tool-1", "total 42", false),
|
||||
)
|
||||
|
||||
// Session A has a matching tool call.
|
||||
linesA := []string{
|
||||
`{"type":"assistant","timestamp":"` + ts(baseTime, 0) + `","sessionId":"a","message":{"role":"assistant","content":[{"type":"tool_use","id":"tu_a","name":"Read","input":{"file_path":"/tmp/config.yaml"}}]}}`,
|
||||
`{"type":"user","timestamp":"` + ts(baseTime, time.Second) + `","sessionId":"a","message":{"role":"user","content":[{"type":"tool_result","tool_use_id":"tu_a","content":"port: 8080"}]}}`,
|
||||
}
|
||||
// Session B has a different matching tool call.
|
||||
linesB := []string{
|
||||
`{"type":"assistant","timestamp":"` + ts(baseTime, 0) + `","sessionId":"b","message":{"role":"assistant","content":[{"type":"tool_use","id":"tu_b","name":"Bash","input":{"command":"cat /tmp/config.yaml"}}]}}`,
|
||||
`{"type":"user","timestamp":"` + ts(baseTime, time.Second) + `","sessionId":"b","message":{"role":"user","content":[{"type":"tool_result","tool_use_id":"tu_b","content":"port: 8080"}]}}`,
|
||||
}
|
||||
|
||||
writeTempJSONL(t, dir, "a.jsonl", linesA...)
|
||||
writeTempJSONL(t, dir, "b.jsonl", linesB...)
|
||||
|
||||
results, err := Search(dir, "config.yaml")
|
||||
require.NoError(t, err)
|
||||
assert.Len(t, results, 2, "should find matches in both sessions")
|
||||
}
|
||||
|
||||
func TestSearch_IgnoresNonJSONLFiles(t *testing.T) {
|
||||
dir := t.TempDir()
|
||||
// Write a .txt file containing the search term.
|
||||
require.NoError(t, os.WriteFile(filepath.Join(dir, "notes.txt"), []byte("config.yaml"), 0644))
|
||||
|
||||
results, err := Search(dir, "config.yaml")
|
||||
results, err := Search(dir, "nonexistent-query")
|
||||
require.NoError(t, err)
|
||||
assert.Empty(t, results)
|
||||
}
|
||||
|
||||
func TestSearch_MalformedSessionSkipped(t *testing.T) {
|
||||
func TestSearch_SingleMatch_Good(t *testing.T) {
|
||||
dir := t.TempDir()
|
||||
// A completely invalid JSONL file.
|
||||
writeTempJSONL(t, dir, "broken.jsonl", `{not valid json at all`)
|
||||
// A valid session with a match.
|
||||
lines := []string{
|
||||
`{"type":"assistant","timestamp":"` + ts(baseTime, 0) + `","sessionId":"ok","message":{"role":"assistant","content":[{"type":"tool_use","id":"tu_ok","name":"Bash","input":{"command":"echo found"}}]}}`,
|
||||
`{"type":"user","timestamp":"` + ts(baseTime, time.Second) + `","sessionId":"ok","message":{"role":"user","content":[{"type":"tool_result","tool_use_id":"tu_ok","content":"found"}]}}`,
|
||||
}
|
||||
writeTempJSONL(t, dir, "valid.jsonl", lines...)
|
||||
writeJSONL(t, dir, "session.jsonl",
|
||||
toolUseEntry(ts(0), "Bash", "tool-1", map[string]interface{}{
|
||||
"command": "go test ./...",
|
||||
}),
|
||||
toolResultEntry(ts(1), "tool-1", "PASS ok mypackage 0.5s", false),
|
||||
)
|
||||
|
||||
results, err := Search(dir, "found")
|
||||
require.NoError(t, err)
|
||||
assert.Len(t, results, 1, "should find match in valid session, ignoring broken one")
|
||||
}
|
||||
|
||||
func TestSearch_MatchUsesInputAsContext(t *testing.T) {
|
||||
dir := t.TempDir()
|
||||
lines := []string{
|
||||
`{"type":"assistant","timestamp":"` + ts(baseTime, 0) + `","sessionId":"ctx","message":{"role":"assistant","content":[{"type":"tool_use","id":"tu_ctx","name":"Bash","input":{"command":"deploy production"}}]}}`,
|
||||
`{"type":"user","timestamp":"` + ts(baseTime, time.Second) + `","sessionId":"ctx","message":{"role":"user","content":[{"type":"tool_result","tool_use_id":"tu_ctx","content":"deployed successfully"}]}}`,
|
||||
}
|
||||
writeTempJSONL(t, dir, "ctx.jsonl", lines...)
|
||||
|
||||
// Search matches on output but Match field should show input.
|
||||
results, err := Search(dir, "deployed")
|
||||
require.NoError(t, err)
|
||||
require.Len(t, results, 1)
|
||||
assert.Contains(t, results[0].Match, "deploy production",
|
||||
"Match context should be the tool input, not output")
|
||||
}
|
||||
|
||||
func TestSearch_MatchFallsBackToOutput(t *testing.T) {
|
||||
// When a tool_use event has empty input but matching output, Match should
|
||||
// show the (truncated) output. We simulate this by creating a session
|
||||
// where the tool input resolves to empty.
|
||||
dir := t.TempDir()
|
||||
lines := []string{
|
||||
`{"type":"assistant","timestamp":"` + ts(baseTime, 0) + `","sessionId":"fb","message":{"role":"assistant","content":[{"type":"tool_use","id":"tu_fb","name":"Bash","input":{}}]}}`,
|
||||
`{"type":"user","timestamp":"` + ts(baseTime, time.Second) + `","sessionId":"fb","message":{"role":"user","content":[{"type":"tool_result","tool_use_id":"tu_fb","content":"fallback output text"}]}}`,
|
||||
}
|
||||
writeTempJSONL(t, dir, "fallback.jsonl", lines...)
|
||||
|
||||
results, err := Search(dir, "fallback output")
|
||||
require.NoError(t, err)
|
||||
require.Len(t, results, 1)
|
||||
assert.Contains(t, results[0].Match, "fallback output")
|
||||
}
|
||||
|
||||
func TestSearchResult_Fields(t *testing.T) {
|
||||
// Verify that SearchResult fields are populated correctly.
|
||||
dir := t.TempDir()
|
||||
lines := []string{
|
||||
`{"type":"assistant","timestamp":"` + ts(baseTime, 0) + `","sessionId":"fields","message":{"role":"assistant","content":[{"type":"tool_use","id":"tu_f","name":"Grep","input":{"pattern":"error","path":"/var/log"}}]}}`,
|
||||
`{"type":"user","timestamp":"` + ts(baseTime, time.Second) + `","sessionId":"fields","message":{"role":"user","content":[{"type":"tool_result","tool_use_id":"tu_f","content":"found 3 errors"}]}}`,
|
||||
}
|
||||
writeTempJSONL(t, dir, "fields.jsonl", lines...)
|
||||
|
||||
results, err := Search(dir, "error")
|
||||
results, err := Search(dir, "go test")
|
||||
require.NoError(t, err)
|
||||
require.Len(t, results, 1)
|
||||
|
||||
r := results[0]
|
||||
assert.Equal(t, "fields", r.SessionID)
|
||||
assert.False(t, r.Timestamp.IsZero())
|
||||
assert.Equal(t, "Grep", r.Tool)
|
||||
assert.NotEmpty(t, r.Match)
|
||||
assert.Equal(t, "session", results[0].SessionID)
|
||||
assert.Equal(t, "Bash", results[0].Tool)
|
||||
assert.Contains(t, results[0].Match, "go test")
|
||||
}
|
||||
|
||||
func TestSearch_MultipleMatches_Good(t *testing.T) {
|
||||
dir := t.TempDir()
|
||||
writeJSONL(t, dir, "session1.jsonl",
|
||||
toolUseEntry(ts(0), "Bash", "t1", map[string]interface{}{
|
||||
"command": "go test ./...",
|
||||
}),
|
||||
toolResultEntry(ts(1), "t1", "PASS", false),
|
||||
toolUseEntry(ts(2), "Bash", "t2", map[string]interface{}{
|
||||
"command": "go test -race ./...",
|
||||
}),
|
||||
toolResultEntry(ts(3), "t2", "PASS", false),
|
||||
)
|
||||
writeJSONL(t, dir, "session2.jsonl",
|
||||
toolUseEntry(ts(0), "Bash", "t3", map[string]interface{}{
|
||||
"command": "go test -bench=.",
|
||||
}),
|
||||
toolResultEntry(ts(1), "t3", "PASS", false),
|
||||
)
|
||||
|
||||
results, err := Search(dir, "go test")
|
||||
require.NoError(t, err)
|
||||
assert.Len(t, results, 3, "should find matches across both sessions")
|
||||
}
|
||||
|
||||
func TestSearch_CaseInsensitive_Good(t *testing.T) {
|
||||
dir := t.TempDir()
|
||||
writeJSONL(t, dir, "session.jsonl",
|
||||
toolUseEntry(ts(0), "Bash", "t1", map[string]interface{}{
|
||||
"command": "GO TEST ./...",
|
||||
}),
|
||||
toolResultEntry(ts(1), "t1", "PASS", false),
|
||||
)
|
||||
|
||||
results, err := Search(dir, "go test")
|
||||
require.NoError(t, err)
|
||||
assert.Len(t, results, 1, "search should be case-insensitive")
|
||||
}
|
||||
|
||||
func TestSearch_MatchesInOutput_Good(t *testing.T) {
|
||||
dir := t.TempDir()
|
||||
writeJSONL(t, dir, "session.jsonl",
|
||||
toolUseEntry(ts(0), "Bash", "t1", map[string]interface{}{
|
||||
"command": "cat log.txt",
|
||||
}),
|
||||
toolResultEntry(ts(1), "t1", "ERROR: connection refused to database", false),
|
||||
)
|
||||
|
||||
results, err := Search(dir, "connection refused")
|
||||
require.NoError(t, err)
|
||||
require.Len(t, results, 1, "should match against output text")
|
||||
// Match field should contain the input (command) since it's non-empty
|
||||
assert.Contains(t, results[0].Match, "cat log.txt")
|
||||
}
|
||||
|
||||
func TestSearch_SkipsNonToolEvents_Good(t *testing.T) {
|
||||
dir := t.TempDir()
|
||||
writeJSONL(t, dir, "session.jsonl",
|
||||
userTextEntry(ts(0), "Please search for something"),
|
||||
assistantTextEntry(ts(1), "I will search for something"),
|
||||
)
|
||||
|
||||
// "search" appears in user and assistant text, but Search only checks tool_use events
|
||||
results, err := Search(dir, "search")
|
||||
require.NoError(t, err)
|
||||
assert.Empty(t, results, "should only match tool_use events, not user/assistant text")
|
||||
}
|
||||
|
||||
func TestSearch_NonJSONLIgnored_Good(t *testing.T) {
|
||||
dir := t.TempDir()
|
||||
require.NoError(t, os.WriteFile(filepath.Join(dir, "readme.md"), []byte("go test"), 0644))
|
||||
|
||||
results, err := Search(dir, "go test")
|
||||
require.NoError(t, err)
|
||||
assert.Empty(t, results, "non-JSONL files should be ignored")
|
||||
}
|
||||
|
||||
func TestSearch_MalformedSessionSkipped_Bad(t *testing.T) {
|
||||
dir := t.TempDir()
|
||||
|
||||
// One broken session and one valid session
|
||||
writeJSONL(t, dir, "broken.jsonl",
|
||||
`{not valid json at all`,
|
||||
)
|
||||
writeJSONL(t, dir, "valid.jsonl",
|
||||
toolUseEntry(ts(0), "Bash", "t1", map[string]interface{}{
|
||||
"command": "go test ./...",
|
||||
}),
|
||||
toolResultEntry(ts(1), "t1", "PASS", false),
|
||||
)
|
||||
|
||||
results, err := Search(dir, "go test")
|
||||
require.NoError(t, err)
|
||||
assert.Len(t, results, 1, "should still find matches in valid sessions")
|
||||
}
|
||||
|
|
|
|||
326
video_test.go
326
video_test.go
|
|
@ -1,6 +1,8 @@
|
|||
// SPDX-Licence-Identifier: EUPL-1.2
|
||||
package session
|
||||
|
||||
import (
|
||||
"os/exec"
|
||||
"strings"
|
||||
"testing"
|
||||
"time"
|
||||
|
|
@ -9,219 +11,197 @@ import (
|
|||
"github.com/stretchr/testify/require"
|
||||
)
|
||||
|
||||
// NOTE: RenderMP4 requires the external `vhs` binary and writes to temp files
|
||||
// then calls exec. We test generateTape (the pure logic) directly, and verify
|
||||
// RenderMP4 returns a sensible error when vhs is absent.
|
||||
|
||||
func TestRenderMP4_VHSNotInstalled(t *testing.T) {
|
||||
func TestGenerateTape_BasicSession_Good(t *testing.T) {
|
||||
sess := &Session{
|
||||
ID: "video-test",
|
||||
StartTime: baseTime,
|
||||
EndTime: baseTime.Add(time.Minute),
|
||||
}
|
||||
|
||||
err := RenderMP4(sess, "/tmp/out.mp4")
|
||||
if err == nil {
|
||||
t.Skip("vhs is installed on this system; skipping missing-binary test")
|
||||
}
|
||||
assert.Contains(t, err.Error(), "vhs not installed")
|
||||
}
|
||||
|
||||
func TestGenerateTape_EmptySession(t *testing.T) {
|
||||
sess := &Session{
|
||||
ID: "empty-tape",
|
||||
StartTime: baseTime,
|
||||
EndTime: baseTime,
|
||||
Events: nil,
|
||||
}
|
||||
|
||||
tape := generateTape(sess, "/tmp/empty.mp4")
|
||||
|
||||
assert.Contains(t, tape, "Output /tmp/empty.mp4")
|
||||
assert.Contains(t, tape, "Set FontSize 16")
|
||||
assert.Contains(t, tape, "Set Width 1400")
|
||||
assert.Contains(t, tape, "Set Height 800")
|
||||
assert.Contains(t, tape, "Set Theme")
|
||||
assert.Contains(t, tape, "# Session empty-ta")
|
||||
assert.Contains(t, tape, "Sleep 3s") // Final sleep
|
||||
}
|
||||
|
||||
func TestGenerateTape_BashEvents(t *testing.T) {
|
||||
sess := &Session{
|
||||
ID: "bash-tape-session-long-id",
|
||||
StartTime: baseTime,
|
||||
EndTime: baseTime.Add(10 * time.Second),
|
||||
ID: "tape-test-12345678",
|
||||
StartTime: time.Date(2026, 2, 20, 10, 0, 0, 0, time.UTC),
|
||||
Events: []Event{
|
||||
{
|
||||
Type: "tool_use",
|
||||
Tool: "Bash",
|
||||
Input: "ls -la # list files",
|
||||
Output: "total 10\nfile1.go\nfile2.go",
|
||||
Input: "go test ./...",
|
||||
Output: "PASS",
|
||||
Success: true,
|
||||
},
|
||||
{
|
||||
Type: "tool_use",
|
||||
Tool: "Bash",
|
||||
Input: "false",
|
||||
Output: "exit 1",
|
||||
Success: false,
|
||||
ErrorMsg: "exit 1",
|
||||
Type: "tool_use",
|
||||
Tool: "Read",
|
||||
Input: "/tmp/file.go",
|
||||
Output: "package main",
|
||||
Success: true,
|
||||
},
|
||||
},
|
||||
}
|
||||
|
||||
tape := generateTape(sess, "/tmp/bash.mp4")
|
||||
tape := generateTape(sess, "/tmp/output.mp4")
|
||||
|
||||
t.Run("title_uses_short_id", func(t *testing.T) {
|
||||
assert.Contains(t, tape, "# Session bash-tap")
|
||||
})
|
||||
|
||||
t.Run("bash_command_shown", func(t *testing.T) {
|
||||
assert.Contains(t, tape, `"$ ls -la"`)
|
||||
})
|
||||
|
||||
t.Run("bash_output_shown", func(t *testing.T) {
|
||||
assert.Contains(t, tape, "file1.go")
|
||||
})
|
||||
|
||||
t.Run("success_indicator", func(t *testing.T) {
|
||||
assert.Contains(t, tape, "OK")
|
||||
})
|
||||
|
||||
t.Run("failure_indicator", func(t *testing.T) {
|
||||
assert.Contains(t, tape, "FAILED")
|
||||
})
|
||||
assert.Contains(t, tape, "Output /tmp/output.mp4")
|
||||
assert.Contains(t, tape, "Set FontSize 16")
|
||||
assert.Contains(t, tape, "tape-tes") // shortID
|
||||
assert.Contains(t, tape, "2026-02-20 10:00")
|
||||
assert.Contains(t, tape, `"$ go test ./..."`)
|
||||
assert.Contains(t, tape, "PASS")
|
||||
assert.Contains(t, tape, `"# ✓ OK"`)
|
||||
assert.Contains(t, tape, "# Read: /tmp/file.go")
|
||||
}
|
||||
|
||||
func TestGenerateTape_ReadEditWriteEvents(t *testing.T) {
|
||||
sess := &Session{
|
||||
ID: "file-ops",
|
||||
StartTime: baseTime,
|
||||
EndTime: baseTime.Add(5 * time.Second),
|
||||
Events: []Event{
|
||||
{Type: "tool_use", Tool: "Read", Input: "/tmp/foo.go", Success: true},
|
||||
{Type: "tool_use", Tool: "Edit", Input: "/tmp/foo.go (edit)", Success: true},
|
||||
{Type: "tool_use", Tool: "Write", Input: "/tmp/bar.go (100 bytes)", Success: true},
|
||||
},
|
||||
}
|
||||
|
||||
tape := generateTape(sess, "/tmp/files.mp4")
|
||||
|
||||
assert.Contains(t, tape, "# Read: /tmp/foo.go")
|
||||
assert.Contains(t, tape, "# Edit: /tmp/foo.go (edit)")
|
||||
assert.Contains(t, tape, "# Write: /tmp/bar.go (100 bytes)")
|
||||
}
|
||||
|
||||
func TestGenerateTape_TaskEvents(t *testing.T) {
|
||||
sess := &Session{
|
||||
ID: "task-session",
|
||||
StartTime: baseTime,
|
||||
EndTime: baseTime.Add(5 * time.Second),
|
||||
Events: []Event{
|
||||
{Type: "tool_use", Tool: "Task", Input: "[research] summarise the codebase", Success: true},
|
||||
},
|
||||
}
|
||||
|
||||
tape := generateTape(sess, "/tmp/task.mp4")
|
||||
assert.Contains(t, tape, "# Agent: [research] summarise the codebase")
|
||||
}
|
||||
|
||||
func TestGenerateTape_SkipsNonToolEvents(t *testing.T) {
|
||||
func TestGenerateTape_SkipsNonToolEvents_Good(t *testing.T) {
|
||||
sess := &Session{
|
||||
ID: "skip-test",
|
||||
StartTime: baseTime,
|
||||
EndTime: baseTime.Add(5 * time.Second),
|
||||
StartTime: time.Date(2026, 2, 20, 10, 0, 0, 0, time.UTC),
|
||||
Events: []Event{
|
||||
{Type: "user", Input: "user message"},
|
||||
{Type: "assistant", Input: "assistant message"},
|
||||
{Type: "tool_use", Tool: "Bash", Input: "echo ok", Output: "ok", Success: true},
|
||||
{Type: "user", Input: "Hello"},
|
||||
{Type: "assistant", Input: "Hi there"},
|
||||
{Type: "tool_use", Tool: "Bash", Input: "echo hi", Output: "hi", Success: true},
|
||||
},
|
||||
}
|
||||
|
||||
tape := generateTape(sess, "/tmp/skip.mp4")
|
||||
tape := generateTape(sess, "/tmp/out.mp4")
|
||||
|
||||
// User and assistant messages should not appear as typed commands.
|
||||
assert.NotContains(t, tape, "user message")
|
||||
assert.NotContains(t, tape, "assistant message")
|
||||
assert.Contains(t, tape, "$ echo ok")
|
||||
// User and assistant events should NOT appear in the tape
|
||||
assert.NotContains(t, tape, "Hello")
|
||||
assert.NotContains(t, tape, "Hi there")
|
||||
// Bash command should appear
|
||||
assert.Contains(t, tape, "echo hi")
|
||||
}
|
||||
|
||||
func TestGenerateTape_LongOutputTruncated(t *testing.T) {
|
||||
longOutput := strings.Repeat("x", 500)
|
||||
func TestGenerateTape_FailedCommand_Good(t *testing.T) {
|
||||
sess := &Session{
|
||||
ID: "trunc-out",
|
||||
StartTime: baseTime,
|
||||
EndTime: baseTime.Add(5 * time.Second),
|
||||
ID: "fail-test",
|
||||
StartTime: time.Date(2026, 2, 20, 10, 0, 0, 0, time.UTC),
|
||||
Events: []Event{
|
||||
{Type: "tool_use", Tool: "Bash", Input: "cmd", Output: longOutput, Success: true},
|
||||
{
|
||||
Type: "tool_use",
|
||||
Tool: "Bash",
|
||||
Input: "cat /missing",
|
||||
Output: "No such file",
|
||||
Success: false,
|
||||
},
|
||||
},
|
||||
}
|
||||
|
||||
tape := generateTape(sess, "/tmp/trunc.mp4")
|
||||
// Output in the tape should be truncated at 200 chars + "...".
|
||||
assert.Contains(t, tape, "...")
|
||||
// The full 500-char string should not appear.
|
||||
assert.NotContains(t, tape, longOutput)
|
||||
tape := generateTape(sess, "/tmp/out.mp4")
|
||||
assert.Contains(t, tape, `"# ✗ FAILED"`)
|
||||
}
|
||||
|
||||
func TestGenerateTape_EmptyBashCommand(t *testing.T) {
|
||||
func TestGenerateTape_LongOutput_Good(t *testing.T) {
|
||||
sess := &Session{
|
||||
ID: "long-test",
|
||||
StartTime: time.Date(2026, 2, 20, 10, 0, 0, 0, time.UTC),
|
||||
Events: []Event{
|
||||
{
|
||||
Type: "tool_use",
|
||||
Tool: "Bash",
|
||||
Input: "cat huge.log",
|
||||
Output: strings.Repeat("x", 300),
|
||||
Success: true,
|
||||
},
|
||||
},
|
||||
}
|
||||
|
||||
tape := generateTape(sess, "/tmp/out.mp4")
|
||||
// Output should be truncated to 200 chars + "..."
|
||||
assert.Contains(t, tape, "...")
|
||||
}
|
||||
|
||||
func TestGenerateTape_TaskEvent_Good(t *testing.T) {
|
||||
sess := &Session{
|
||||
ID: "task-test",
|
||||
StartTime: time.Date(2026, 2, 20, 10, 0, 0, 0, time.UTC),
|
||||
Events: []Event{
|
||||
{
|
||||
Type: "tool_use",
|
||||
Tool: "Task",
|
||||
Input: "[research] Analyse code structure",
|
||||
},
|
||||
},
|
||||
}
|
||||
|
||||
tape := generateTape(sess, "/tmp/out.mp4")
|
||||
assert.Contains(t, tape, "# Agent: [research] Analyse code structure")
|
||||
}
|
||||
|
||||
func TestGenerateTape_EditWriteEvents_Good(t *testing.T) {
|
||||
sess := &Session{
|
||||
ID: "edit-test",
|
||||
StartTime: time.Date(2026, 2, 20, 10, 0, 0, 0, time.UTC),
|
||||
Events: []Event{
|
||||
{Type: "tool_use", Tool: "Edit", Input: "/tmp/app.go (edit)"},
|
||||
{Type: "tool_use", Tool: "Write", Input: "/tmp/new.go (50 bytes)"},
|
||||
},
|
||||
}
|
||||
|
||||
tape := generateTape(sess, "/tmp/out.mp4")
|
||||
assert.Contains(t, tape, "# Edit: /tmp/app.go (edit)")
|
||||
assert.Contains(t, tape, "# Write: /tmp/new.go (50 bytes)")
|
||||
}
|
||||
|
||||
func TestGenerateTape_EmptySession_Good(t *testing.T) {
|
||||
sess := &Session{
|
||||
ID: "empty-test",
|
||||
StartTime: time.Date(2026, 2, 20, 10, 0, 0, 0, time.UTC),
|
||||
Events: nil,
|
||||
}
|
||||
|
||||
tape := generateTape(sess, "/tmp/out.mp4")
|
||||
|
||||
// Should still have the header and trailer
|
||||
assert.Contains(t, tape, "Output /tmp/out.mp4")
|
||||
assert.Contains(t, tape, "Sleep 3s")
|
||||
// No tool events
|
||||
lines := strings.Split(tape, "\n")
|
||||
var toolLines int
|
||||
for _, line := range lines {
|
||||
if strings.Contains(line, "$ ") || strings.Contains(line, "# Read:") ||
|
||||
strings.Contains(line, "# Edit:") || strings.Contains(line, "# Write:") {
|
||||
toolLines++
|
||||
}
|
||||
}
|
||||
assert.Equal(t, 0, toolLines)
|
||||
}
|
||||
|
||||
func TestGenerateTape_BashEmptyCommand_Bad(t *testing.T) {
|
||||
sess := &Session{
|
||||
ID: "empty-cmd",
|
||||
StartTime: baseTime,
|
||||
EndTime: baseTime.Add(time.Second),
|
||||
StartTime: time.Date(2026, 2, 20, 10, 0, 0, 0, time.UTC),
|
||||
Events: []Event{
|
||||
{Type: "tool_use", Tool: "Bash", Input: "", Success: true},
|
||||
{Type: "tool_use", Tool: "Bash", Input: "", Output: "", Success: true},
|
||||
},
|
||||
}
|
||||
|
||||
tape := generateTape(sess, "/tmp/empty-cmd.mp4")
|
||||
// An empty command should be skipped (no "$ " line).
|
||||
lines := strings.Split(tape, "\n")
|
||||
for _, line := range lines {
|
||||
assert.NotContains(t, line, `"$ "`)
|
||||
}
|
||||
tape := generateTape(sess, "/tmp/out.mp4")
|
||||
// Empty command should be skipped (extractCommand returns "")
|
||||
assert.NotContains(t, tape, `"$ "`)
|
||||
}
|
||||
|
||||
func TestGenerateTape_SkipsGrepGlob(t *testing.T) {
|
||||
// Grep and Glob tool_use events are not handled in the switch,
|
||||
// so they should produce no typed output in the tape.
|
||||
func TestExtractCommand_Good(t *testing.T) {
|
||||
assert.Equal(t, "ls -la", extractCommand("ls -la # list files"))
|
||||
assert.Equal(t, "go test ./...", extractCommand("go test ./..."))
|
||||
assert.Equal(t, "echo hello", extractCommand("echo hello"))
|
||||
}
|
||||
|
||||
func TestExtractCommand_NoDescription_Good(t *testing.T) {
|
||||
assert.Equal(t, "plain command", extractCommand("plain command"))
|
||||
}
|
||||
|
||||
func TestExtractCommand_DescriptionAtStart_Good(t *testing.T) {
|
||||
// " # " at position 0 means idx <= 0, so it returns the whole input
|
||||
result := extractCommand(" # description only")
|
||||
assert.Equal(t, " # description only", result)
|
||||
}
|
||||
|
||||
func TestRenderMP4_NoVHS_Ugly(t *testing.T) {
|
||||
// Skip if vhs is actually installed (this tests the error path)
|
||||
if _, err := exec.LookPath("vhs"); err == nil {
|
||||
t.Skip("vhs is installed; skipping missing-vhs test")
|
||||
}
|
||||
|
||||
sess := &Session{
|
||||
ID: "grep-glob",
|
||||
StartTime: baseTime,
|
||||
EndTime: baseTime.Add(5 * time.Second),
|
||||
Events: []Event{
|
||||
{Type: "tool_use", Tool: "Grep", Input: "/TODO/ in .", Success: true},
|
||||
{Type: "tool_use", Tool: "Glob", Input: "**/*.go", Success: true},
|
||||
},
|
||||
ID: "no-vhs",
|
||||
StartTime: time.Now(),
|
||||
}
|
||||
|
||||
tape := generateTape(sess, "/tmp/gg.mp4")
|
||||
// Title and settings should exist, but no Grep/Glob content.
|
||||
assert.Contains(t, tape, "Output /tmp/gg.mp4")
|
||||
assert.NotContains(t, tape, "TODO")
|
||||
assert.NotContains(t, tape, "*.go")
|
||||
}
|
||||
|
||||
// -- extractCommand tests --
|
||||
|
||||
func TestExtractCommand(t *testing.T) {
|
||||
tests := []struct {
|
||||
name string
|
||||
input string
|
||||
want string
|
||||
}{
|
||||
{"with description", "ls -la # list files", "ls -la"},
|
||||
{"without description", "pwd", "pwd"},
|
||||
// extractCommand naively splits on first " # " so embedded hashes are truncated.
|
||||
{"hash in command", "echo 'hello # world'", "echo 'hello"},
|
||||
{"description at start", " # desc", " # desc"}, // idx == 0, not > 0
|
||||
{"empty", "", ""},
|
||||
}
|
||||
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
got := extractCommand(tt.input)
|
||||
require.Equal(t, tt.want, got)
|
||||
})
|
||||
}
|
||||
err := RenderMP4(sess, "/tmp/test.mp4")
|
||||
require.Error(t, err)
|
||||
assert.Contains(t, err.Error(), "vhs not installed")
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Reference in a new issue