Files
pipelines/internal/tui/search_live_test.go
T
alan 80232a4ffe Add omni search: ranked mixed results in the TUI and CLI
Back the TUI "/" popup with the server's search command and add a matching
pipelines search CLI command.

- protocol: SearchRequest/SearchResponse and per-kind SearchResult payloads,
  one shared Label for the six-kind badge dispatch and RuneIndexFold for
  case-insensitive matching.
- pipeline: the read-only, ranked, bounded Store.Search implementation.
- cli: search QUERY [--type KIND] [--limit N] [--json], printing the shared
  label plus a text-field snippet when present.
- tui: type to search, up/down to choose, Enter to open and Esc to cancel over
  one mixed ranked list, with short type badges and a bracketed non-colour
  match marker; Enter navigates to the matched pipeline, run, step, field
  section or artifact entry.
- tests: protocol and TUI coverage, including an env-gated live test against
  the running server.
2026-10-16 23:03:17 +01:00

150 lines
4.6 KiB
Go

package tui
import (
"context"
"os"
"strconv"
"testing"
"time"
tea "github.com/charmbracelet/bubbletea"
"github.com/charmbracelet/x/ansi"
"git.a-wan.net/alan/pipelines/internal/protocol"
)
// TestLiveOmniSearchAgainstServer is an env-gated check against a running
// server: it drives the TUI's own '/' search, renders the popup, and presses
// Enter on a live result of each kind, reporting where navigation lands. It
// skips unless PIPELINES_LIVE_SEARCH is set so CI never needs a server.
func TestLiveOmniSearchAgainstServer(t *testing.T) {
if os.Getenv("PIPELINES_LIVE_SEARCH") == "" {
t.Skip("set PIPELINES_LIVE_SEARCH=1 to query the running server")
}
url := os.Getenv("PIPELINES_URL")
if url == "" {
url = "ws://127.0.0.1:8080/connect"
}
ctx, cancel := context.WithTimeout(context.Background(), 60*time.Second)
defer cancel()
m := New(ctx, url)
m.width, m.height = 120, 40
connected := m.connect()().(connectedMsg)
defer connected.conn.CloseNow()
updated, _ := m.Update(connected)
m = updated.(Model)
// Plain-text (never a type prefix) candidates per kind. The live store keeps
// changing as runs land, so a fixed query can stop matching a kind; the test
// uses the first candidate that still returns the kind it is checking.
candidates := map[string][]string{
protocol.SearchKindPipeline: {"demo", "pipeline", "test", "a"},
protocol.SearchKindVersion: {"1", "demo", "review", "test"},
protocol.SearchKindRun: {"succeeded", "failed", "running", "1"},
protocol.SearchKindStep: {"implementer", "reviewer", "planner", "success"},
protocol.SearchKindField: {"identity", "search", "error", "the"},
protocol.SearchKindArtifact: {"identity", "png", "log", "txt"},
}
for _, kind := range protocol.SearchKinds {
picked, query := -1, ""
for _, candidate := range candidates[kind] {
m = resetLiveSearch(m)
m = liveType(m, tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune{'/'}})
m = liveType(m, tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune(candidate)})
m = drainLiveSearch(t, m)
query = candidate
picked = -1
for i, result := range m.searchResults {
if result.Kind == kind {
picked = i
break
}
}
if picked >= 0 {
break
}
}
if picked < 0 {
t.Errorf("%s: no candidate query returned a %s result", kind, kind)
continue
}
m.commandIndex = picked
view := ansi.Strip(m.searchView(20))
t.Logf("%s: query %q rendered\n%s", kind, query, view)
updated, _ = m.Update(tea.KeyMsg{Type: tea.KeyEnter})
m = updated.(Model)
if where := liveNavigation(m); where == "" {
t.Errorf("%s: Enter did not navigate (result %+v)", kind, m.searchResults[picked])
} else {
t.Logf("%s: Enter navigates to %s", kind, where)
}
}
}
// liveType delivers one key and runs any command it produced (a text-input
// update or a search request written to the socket), mirroring the real
// bubbletea loop.
func liveType(m Model, msg tea.Msg) Model {
updated, cmd := m.Update(msg)
m = updated.(Model)
if cmd == nil {
return m
}
if batch, ok := cmd().(tea.BatchMsg); ok {
for _, c := range batch {
if c != nil {
c()
}
}
}
return m
}
// drainLiveSearch reads server frames until the outstanding search request is
// answered, so a slow or interleaved reply is still observed.
func drainLiveSearch(t *testing.T, m Model) Model {
t.Helper()
for i := 0; i < 100; i++ {
if !m.searchInFlight {
return m
}
updated, _ := m.Update(m.read()())
m = updated.(Model)
}
t.Fatalf("timed out waiting for the search reply")
return m
}
// resetLiveSearch returns the model to the home screen with no overlay, ready
// for the next '/' query.
func resetLiveSearch(m Model) Model {
m.closeSearch()
m.closeRuns()
m.keys.detail = false
m.detail = nil
m.detailLoading = false
m.requestedPipelineID = 0
m.requestedVersion = 0
m.artifactsOpen = false
return m
}
// liveNavigation describes where the last Enter landed, read from the same
// state the views use.
func liveNavigation(m Model) string {
switch {
case m.detailLoading:
return "pipeline detail #" + strconv.FormatInt(m.requestedPipelineID, 10)
case m.runOpen && m.pendingRunNav != nil && m.pendingRunNav.artifact != "":
return "run #" + strconv.FormatInt(m.pendingRunNav.runID, 10) + " artifacts (" + m.pendingRunNav.artifact + ")"
case m.runOpen && m.pendingRunNav != nil && m.pendingRunNav.section >= 0:
return "run #" + strconv.FormatInt(m.pendingRunNav.runID, 10) + " section " + runSections[m.pendingRunNav.section].Title
case m.runOpen && m.pendingRunNav != nil:
return "run #" + strconv.FormatInt(m.pendingRunNav.runID, 10) + " detail"
case m.artifactsOpen:
return "artifacts view"
}
return ""
}