path: root/vrsite/app_test.go

package main

import (
	"net/http"
	"net/http/httptest"
	"net/url"
	"os"
	"os/exec"
	"path/filepath"
	"strings"
	"testing"
	"time"
)

func logLines(lines ...string) string { return strings.Join(lines, "\n") + "\n" }

const (
	noteA = `{"time":"2026-07-20T10:00:00Z","op":"note","session":"s1","agent":"codex","model":"gpt-5.6-sol","reasoning":"max","dir":"/repo","change":"aaa","file":"src/lib.rs","start":10,"end":20,"note_id":1,"type":"struct","text":"Cache is a two-level map"}`
	noteB = `{"time":"2026-07-25T10:00:00Z","op":"note","session":"s2","agent":"claude","model":"claude-fable-5","reasoning":"xhigh","dir":"/repo","change":"aaa","file":"src/main.rs","note_id":1,"text":"entry point does too much"}`
	readA = `{"time":"2026-07-20T09:59:00Z","op":"read","session":"s1","agent":"codex","model":"gpt-5.6-sol","dir":"/repo","change":"aaa","file":"src/lib.rs","start":1,"end":30}`
	grepA = `{"time":"2026-07-20T09:58:00Z","op":"grep","session":"s1","agent":"codex","dir":"/repo","change":"aaa","file":"src/lib.rs","pattern":"Cache","matches":3}`
)

func testSite(t *testing.T) *Site {
	t.Helper()
	s := buildModel("test", parseLog([]byte(logLines(grepA, readA, noteA, noteB))))
	s.Theme, s.Light = loadTheme("", "", "dark"), loadTheme("", "", "light")
	return s
}

func TestBuildModel(t *testing.T) {
	s := testSite(t)
	if s.Change != "aaa" {
		t.Errorf("site change = %q, want aaa", s.Change)
	}
	if len(s.Agents) != 2 || s.Agents[0].Bit != 1 || s.Agents[1].Bit != 2 {
		t.Errorf("agents = %+v", s.Agents)
	}
	f := s.Files["src/lib.rs"]
	if f == nil || f.Reads != 1 || f.Greps != 1 || len(f.Notes) != 1 {
		t.Fatalf("src/lib.rs = %+v", f)
	}
	if f.Cov[15] != 1 || f.Mask != 1 {
		t.Errorf("coverage = %v mask %d", f.Cov, f.Mask)
	}
	if got := s.Notes[0].When; got == "" {
		t.Error("note has no rendered timestamp")
	}
}

// A ninth agent gets no color instead of overflowing the uint8 mask (and the
// per-mask CSS it would generate).
func TestAgentColorsAreBounded(t *testing.T) {
	var lines []string
	for i := 0; i < maxAgents+3; i++ {
		lines = append(lines, `{"time":"2026-07-20T10:00:00Z","op":"note","agent":"a`+string(rune('a'+i))+`","change":"aaa","note_id":1,"text":"x"}`)
	}
	s := buildModel("t", parseLog([]byte(logLines(lines...))))
	if len(s.Agents) != maxAgents+3 {
		t.Fatalf("agents = %d", len(s.Agents))
	}
	for i, a := range s.Agents {
		if i < maxAgents && a.Bit == 0 {
			t.Errorf("agent %d has no bit", i)
		}
		if i >= maxAgents && a.Bit != 0 {
			t.Errorf("agent %d got bit %d, want none", i, a.Bit)
		}
	}
	if n := len(s.masks()); n != 1<<maxAgents-1 {
		t.Errorf("masks = %d, want %d", n, 1<<maxAgents-1)
	}
}

func TestFilterNotes(t *testing.T) {
	s := testSite(t)
	for _, tc := range []struct {
		name string
		f    NoteFilter
		want []string
	}{
		{"all", NoteFilter{}, []string{"src/main.rs", "src/lib.rs"}}, // newest first
		{"text", NoteFilter{Text: "two-level"}, []string{"src/lib.rs"}},
		{"text is case-insensitive", NoteFilter{Text: "CACHE"}, []string{"src/lib.rs"}},
		{"file substring", NoteFilter{File: "main"}, []string{"src/main.rs"}},
		{"agent", NoteFilter{Agent: "claude"}, []string{"src/main.rs"}},
		{"model", NoteFilter{Model: "gpt-5.6-sol"}, []string{"src/lib.rs"}},
		{"session", NoteFilter{Session: "s2"}, []string{"src/main.rs"}},
		{"kind", NoteFilter{Kind: "struct"}, []string{"src/lib.rs"}},
		{"from", NoteFilter{From: "2026-07-21"}, []string{"src/main.rs"}},
		{"to", NoteFilter{To: "2026-07-21"}, []string{"src/lib.rs"}},
		{"range", NoteFilter{From: "2026-07-19", To: "2026-07-26"}, []string{"src/main.rs", "src/lib.rs"}},
		{"combined", NoteFilter{Agent: "codex", Text: "map"}, []string{"src/lib.rs"}},
		{"no match", NoteFilter{Agent: "codex", Text: "nothing"}, nil},
	} {
		t.Run(tc.name, func(t *testing.T) {
			var got []string
			for _, n := range s.FilterNotes(tc.f) {
				got = append(got, n.File)
			}
			if strings.Join(got, ",") != strings.Join(tc.want, ",") {
				t.Errorf("got %v, want %v", got, tc.want)
			}
		})
	}
}

func TestFacetsAreDistinctAndSorted(t *testing.T) {
	fa := testSite(t).Facets()
	if strings.Join(fa.Agents, ",") != "claude,codex" {
		t.Errorf("agents = %v", fa.Agents)
	}
	if strings.Join(fa.Kinds, ",") != "struct" {
		t.Errorf("kinds = %v", fa.Kinds)
	}
	if strings.Join(fa.Sessions, ",") != "s1,s2" {
		t.Errorf("sessions = %v", fa.Sessions)
	}
}

func TestSessionsReportWhatIsRunning(t *testing.T) {
	now := time.Date(2026, 7, 25, 10, 1, 0, 0, time.UTC)
	ss := testSite(t).Sessions(now, liveWindow, 10)
	if len(ss) != 2 {
		t.Fatalf("sessions = %d", len(ss))
	}
	if ss[0].ID != "s2" || !ss[0].Live {
		t.Errorf("newest session = %+v, want s2 live", ss[0])
	}
	if ss[1].ID != "s1" || ss[1].Live {
		t.Errorf("older session = %+v, want s1 not live", ss[1])
	}
	if ss[1].LastOp != "note on src/lib.rs" || ss[1].Reads != 1 || ss[1].Greps != 1 {
		t.Errorf("s1 activity = %q %d/%d", ss[1].LastOp, ss[1].Reads, ss[1].Greps)
	}
}

func TestNextNoteIDCountsPerSession(t *testing.T) {
	entries := parseLog([]byte(logLines(noteA, noteB)))
	if got := nextNoteID(entries, "s1"); got != 2 {
		t.Errorf("s1 next = %d, want 2", got)
	}
	if got := nextNoteID(entries, "web:me"); got != 1 {
		t.Errorf("fresh session next = %d, want 1", got)
	}
}

// The graph art in front of a templated row must not end up inside a field.
func TestParseRows(t *testing.T) {
	out := "@  \x1eabc123\x1fabc1\x1fdef456\x1fdef4\x1fme@x\x1f2026-07-20 10:00\x1fmain\x1fworking copy\x1ffix the thing\n" +
		"│\n" +
		"~\n"
	rows := parseRows([]byte(out), false)
	if len(rows) != 3 {
		t.Fatalf("rows = %d", len(rows))
	}
	r := rows[0]
	if r.Graph != "@  " || r.ID != "abc123" || r.Short != "abc1" || r.CommitShort != "def4" ||
		r.Author != "me@x" || r.Refs != "main" || r.Flags != "working copy" || r.Desc != "fix the thing" {
		t.Errorf("row = %+v", r)
	}
	if !rows[1].Blank() || rows[1].Graph != "│" {
		t.Errorf("graph-only row = %+v", rows[1])
	}
	op := parseRows([]byte("@  \x1eopid\x1fopid1\x1f\x1f\x1fme@host\x1f2026-07-20 10:00:00\x1f\x1f10:00:05\x1fsnapshot\n"), true)
	if len(op) != 1 || op[0].End != "10:00:05" || op[0].Flags != "" || op[0].Desc != "snapshot" {
		t.Errorf("op row = %+v", op)
	}
}

func TestCheckRevsetRejectsFlags(t *testing.T) {
	if err := checkRevset("--config=x"); err == nil {
		t.Error("a leading dash must be refused, jj would read it as a flag")
	}
	if err := checkRevset("all() & file(x)"); err != nil {
		t.Errorf("plain revset refused: %v", err)
	}
}

func TestHrefModes(t *testing.T) {
	live := &page{Live: true, Root: "/"}
	if got := live.Href("code", "src/a b.rs"); got != "/code/src/a%20b.rs" {
		t.Errorf("live code href = %q", got)
	}
	live.Rev = "xyz"
	if got := live.Href("code", "src/a.rs"); got != "/code/src/a.rs?rev=xyz" {
		t.Errorf("live code href with rev = %q", got)
	}
	if got := live.Href("notes"); got != "/notes" {
		t.Errorf("live notes href = %q", got)
	}
	static := &page{Root: "../"}
	if got := static.Href("code", "src/a.rs"); got != "../code/src/a.rs.html" {
		t.Errorf("static code href = %q", got)
	}
	if got := static.Href("change", "abc"); got != "" {
		t.Errorf("static change href = %q, want none", got)
	}
}

// ── the web app, end to end ───────────────────────────────────────────────

// testRepo makes a one-commit jj repo and returns its path plus the change id.
func testRepo(t *testing.T) (string, string) {
	t.Helper()
	if _, err := exec.LookPath("jj"); err != nil {
		t.Skip("jj not installed")
	}
	dir := t.TempDir()
	env := append(os.Environ(), "JJ_USER=test", "[email protected]", "HOME="+dir)
	runJJ := func(args ...string) {
		t.Helper()
		cmd := exec.Command("jj", args...)
		cmd.Dir, cmd.Env = dir, env
		if out, err := cmd.CombinedOutput(); err != nil {
			t.Fatalf("jj %s: %v\n%s", strings.Join(args, " "), err, out)
		}
	}
	runJJ("git", "init")
	if err := os.WriteFile(filepath.Join(dir, "hello.txt"), []byte("one\ntwo\nthree\n"), 0o644); err != nil {
		t.Fatal(err)
	}
	runJJ("describe", "-m", "first change")
	change, err := resolveChange(dir, "@")
	if err != nil {
		t.Fatal(err)
	}
	return dir, change
}

func testServer(t *testing.T) (*server, string, string) {
	t.Helper()
	repo, change := testRepo(t)
	logPath := filepath.Join(t.TempDir(), "trace.jsonl")
	entry := `{"time":"2026-07-20T10:00:00Z","op":"read","session":"s1","agent":"codex","model":"gpt-5.6-sol","dir":"` +
		repo + `","change":"` + change + `","file":"hello.txt","start":1,"end":2}`
	note := `{"time":"2026-07-20T10:01:00Z","op":"note","session":"s1","agent":"codex","model":"gpt-5.6-sol","dir":"` +
		repo + `","change":"` + change + `","file":"hello.txt","start":2,"end":2,"note_id":1,"text":"second line matters"}`
	if err := os.WriteFile(logPath, []byte(logLines(entry, note)), 0o644); err != nil {
		t.Fatal(err)
	}
	sv := newServer(logPath, repo, "test", "tester", loadTheme("", "", "dark"), loadTheme("", "", "light"))
	return sv, logPath, change
}

func get(t *testing.T, h http.Handler, path string, hx bool) *httptest.ResponseRecorder {
	t.Helper()
	r := httptest.NewRequest("GET", path, nil)
	if hx {
		r.Header.Set("HX-Request", "true")
	}
	w := httptest.NewRecorder()
	h.ServeHTTP(w, r)
	return w
}

func TestServerPages(t *testing.T) {
	sv, _, change := testServer(t)
	h := sv.handler()
	for _, tc := range []struct{ path, want string }{
		{"/", "second line matters"},
		{"/files", "hello.txt"},
		{"/tree", `class="file`},
		{"/notes", "second line matters"},
		{"/code/hello.txt", "three"},
		{"/jj", "revset"},
		{"/change/" + change, "first change"},
		{"/style.css", "--am1"},
		{"/app.js", "vrsite-mode"},
		{"/htmx.min.js", "htmx"},
	} {
		w := get(t, h, tc.path, false)
		if w.Code != 200 {
			t.Errorf("GET %s = %d", tc.path, w.Code)
			continue
		}
		if !strings.Contains(w.Body.String(), tc.want) {
			t.Errorf("GET %s does not mention %q", tc.path, tc.want)
		}
	}
}

func TestNotesFilterOverHTTP(t *testing.T) {
	sv, _, _ := testServer(t)
	h := sv.handler()
	if b := get(t, h, "/notes/list?text=second", true).Body.String(); !strings.Contains(b, "second line matters") {
		t.Error("matching filter dropped the note")
	}
	b := get(t, h, "/notes/list?text=absent", true).Body.String()
	if strings.Contains(b, "second line matters") || !strings.Contains(b, "no notes match") {
		t.Errorf("non-matching filter kept the note: %s", b)
	}
	if !strings.Contains(b, `id="notecount" hx-swap-oob`) {
		t.Error("list fragment does not carry the out-of-band count")
	}
}

// A comment posted from the browser lands in the log, shows up in the model,
// and leaves the repository alone.
func TestAddNoteAppendsToLog(t *testing.T) {
	sv, logPath, change := testServer(t)
	h := sv.handler()
	before, err := jjRun(sv.repo, "status")
	if err != nil {
		t.Fatal(err)
	}

	form := url.Values{"file": {"hello.txt"}, "start": {"3"}, "end": {"3"},
		"kind": {"line"}, "text": {"written from the browser"}, "rev": {"@"}}
	r := httptest.NewRequest("POST", "/notes", strings.NewReader(form.Encode()))
	r.Header.Set("Content-Type", "application/x-www-form-urlencoded")
	r.Header.Set("HX-Request", "true")
	w := httptest.NewRecorder()
	h.ServeHTTP(w, r)
	if w.Code != 200 {
		t.Fatalf("POST /notes = %d: %s", w.Code, w.Body)
	}
	if !strings.Contains(w.Body.String(), "written from the browser") {
		t.Errorf("response does not contain the new note: %s", w.Body)
	}

	b, err := os.ReadFile(logPath)
	if err != nil {
		t.Fatal(err)
	}
	entries := parseLog(b)
	last := entries[len(entries)-1]
	if last.Op != "note" || last.Agent != "tester" || last.Session != "web:tester" ||
		last.File != "hello.txt" || last.Start != 3 || last.Text != "written from the browser" {
		t.Errorf("appended entry = %+v", last)
	}
	if last.Change != change {
		t.Errorf("note change = %q, want %q", last.Change, change)
	}
	if last.NoteID != 1 {
		t.Errorf("note id = %d, want 1 (first of this session)", last.NoteID)
	}
	if last.Time == "" {
		t.Error("appended entry has no timestamp")
	}

	// visible without a restart, and the line is now marked as noted
	if body := get(t, h, "/code/hello.txt", false).Body.String(); !strings.Contains(body, "written from the browser") {
		t.Error("the new note is not on the file page")
	}
	after, err := jjRun(sv.repo, "status")
	if err != nil {
		t.Fatal(err)
	}
	if string(before) != string(after) {
		t.Errorf("the repository changed:\nbefore %s\nafter %s", before, after)
	}
}

func TestAddNoteRejectsCrossOriginAndEmptyText(t *testing.T) {
	sv, _, _ := testServer(t)
	h := sv.handler()

	form := url.Values{"text": {"hi"}, "rev": {"@"}}
	r := httptest.NewRequest("POST", "/notes", strings.NewReader(form.Encode()))
	r.Header.Set("Content-Type", "application/x-www-form-urlencoded")
	r.Header.Set("Origin", "http://evil.example")
	w := httptest.NewRecorder()
	h.ServeHTTP(w, r)
	if w.Code != http.StatusForbidden {
		t.Errorf("cross-origin POST = %d, want 403", w.Code)
	}

	r = httptest.NewRequest("POST", "/notes", strings.NewReader(url.Values{"text": {"  "}}.Encode()))
	r.Header.Set("Content-Type", "application/x-www-form-urlencoded")
	w = httptest.NewRecorder()
	h.ServeHTTP(w, r)
	if w.Code != http.StatusBadRequest {
		t.Errorf("empty note = %d, want 400", w.Code)
	}
}

func TestJJQueries(t *testing.T) {
	sv, _, change := testServer(t)
	h := sv.handler()

	b := get(t, h, "/jj/log?revset="+url.QueryEscape("all()"), true).Body.String()
	if !strings.Contains(b, `href="/change/`+change) {
		t.Errorf("jj log has no link to the change: %s", b)
	}
	if !strings.Contains(b, "first change") {
		t.Error("jj log does not show the description")
	}
	b = get(t, h, "/jj/op?limit=5", true).Body.String()
	if !strings.Contains(b, "at_op=") {
		t.Errorf("op log has no --at-operation links: %s", b)
	}
	b = get(t, h, "/jj/log?revset="+url.QueryEscape("bogusfn(")+"", true).Body.String()
	if !strings.Contains(b, `class="err"`) {
		t.Errorf("a bad revset should report jj's error: %s", b)
	}
	b = get(t, h, "/jj/log?revset="+url.QueryEscape("--config=ui.paginate=never"), true).Body.String()
	if !strings.Contains(b, "must not start with") {
		t.Errorf("flag-like revset was not refused: %s", b)
	}
}

// Model files are shared across requests and cloned per render; run the
// handlers hard in parallel so -race can complain about it.
func TestConcurrentRequests(t *testing.T) {
	sv, _, change := testServer(t)
	h := sv.handler()
	paths := []string{"/", "/code/hello.txt", "/notes", "/notes/list?text=second",
		"/tree", "/files", "/activity?compact=1", "/change/" + change,
		"/code/hello.txt?rev=" + change}
	done := make(chan struct{})
	for i := 0; i < len(paths)*3; i++ {
		go func(p string) {
			defer func() { done <- struct{}{} }()
			if w := get(t, h, p, false); w.Code != 200 {
				t.Errorf("GET %s = %d", p, w.Code)
			}
		}(paths[i%len(paths)])
	}
	for i := 0; i < len(paths)*3; i++ {
		<-done
	}
}

func TestCodePageAtMissingRevision(t *testing.T) {
	sv, _, _ := testServer(t)
	w := get(t, sv.handler(), "/code/nope.txt", false)
	if w.Code != 200 || !strings.Contains(w.Body.String(), "not present at this change") {
		t.Errorf("missing file = %d: %s", w.Code, w.Body)
	}
}

func TestServerPicksUpLogAppendsFromOtherProcesses(t *testing.T) {
	sv, logPath, change := testServer(t)
	h := sv.handler()
	if strings.Contains(get(t, h, "/notes", false).Body.String(), "from another process") {
		t.Fatal("note exists before it was written")
	}
	f, err := os.OpenFile(logPath, os.O_APPEND|os.O_WRONLY, 0o644)
	if err != nil {
		t.Fatal(err)
	}
	line := `{"time":"2026-07-26T10:00:00Z","op":"note","session":"s9","agent":"vr","change":"` +
		change + `","file":"hello.txt","note_id":1,"text":"from another process"}`
	if _, err := f.WriteString(line + "\n"); err != nil {
		t.Fatal(err)
	}
	f.Close()
	// the poll is stat-based; make sure the mtime moved
	future := time.Now().Add(time.Second)
	os.Chtimes(logPath, future, future)

	if !strings.Contains(get(t, h, "/notes", false).Body.String(), "from another process") {
		t.Error("an append by vr was not picked up")
	}
}