gora-cli 0.1.2__py3-none-any.whl

gora/go_tui/main_test.go

@@ -0,0 +1,626 @@
+package main
+
+import (
+	"database/sql"
+	"fmt"
+	"regexp"
+	"strings"
+	"testing"
+
+	"github.com/charmbracelet/bubbles/textinput"
+	tea "github.com/charmbracelet/bubbletea"
+	_ "modernc.org/sqlite"
+)
+
+var ansiPattern = regexp.MustCompile(`\x1b\[[0-9;?]*[ -/]*[@-~]`)
+
+func TestResultTableColumnsIncludeCreatedAndUpdated(t *testing.T) {
+	columns := resultTableColumns(120)
+	widths := map[string]int{}
+	for _, column := range columns {
+		widths[column.Title] = column.Width
+	}
+
+	if widths["updated"] <= 0 {
+		t.Fatalf("updated column hidden at normal width: %#v", widths)
+	}
+	if widths["created"] <= 0 {
+		t.Fatalf("created column hidden at normal width: %#v", widths)
+	}
+
+	rows := resultTableRows([]item{{
+		SessionKey:   "codex:abc",
+		Provider:     "codex",
+		Title:        "fix the terminal table layout",
+		CreatedAt:    "2026-06-18T19:00:00Z",
+		UpdatedAt:    "2026-06-18T20:09:35Z",
+		Cwd:          "/Users/mertdeveci/Desktop/Code/gora",
+		MessageCount: 42,
+	}}, 0)
+	if len(rows) != 1 {
+		t.Fatalf("rows = %d, want 1", len(rows))
+	}
+	got := strings.Join(rows[0], " ")
+	for _, expected := range []string{">", "2026-06-18 20:09", "2026-06-18 19:00", "fix the terminal table layout", "Desktop/Code/gora", "[Codex]", "42"} {
+		if !strings.Contains(got, expected) {
+			t.Fatalf("table row missing %q:\n%s", expected, got)
+		}
+	}
+}
+
+func TestRenderSelectedPreviewShowsMeaningfulContent(t *testing.T) {
+	row := item{
+		SessionKey:   "codex:abc",
+		Provider:     "codex",
+		Title:        "fix the terminal table layout",
+		Timestamp:    "2026-06-18T20:09:35Z",
+		CreatedAt:    "2026-06-18T19:00:00Z",
+		UpdatedAt:    "2026-06-18T20:09:35Z",
+		Cwd:          "/Users/mertdeveci/Desktop/Code/gora",
+		MessageCount: 42,
+		Preview:      "the row should show the matched prompt",
+	}
+	m := &model{results: []item{row}, resultsTable: newResultsTable()}
+	m.configureResultsTable(100, 10)
+
+	got := stripANSI(m.renderSelectedPreview(100, 10))
+	for _, expected := range []string{
+		"preview",
+		"fix the terminal table layout",
+		"Desktop/Code/gora",
+		"created 2026-06-18 19:00",
+		"updated 2026-06-18 20:09",
+		"42 messages",
+		"match the row should show the matched prompt",
+	} {
+		if !strings.Contains(got, expected) {
+			t.Fatalf("selected preview missing %q:\n%s", expected, got)
+		}
+	}
+}
+
+func TestResultTableRowsOnlyMarksSelected(t *testing.T) {
+	rows := resultTableRows([]item{
+		{SessionKey: "codex:first", Provider: "codex", Title: "first"},
+		{SessionKey: "codex:second", Provider: "codex", Title: "second"},
+	}, 1)
+
+	if rows[0][0] != "" {
+		t.Fatalf("first row marker = %q, want empty", rows[0][0])
+	}
+	if rows[1][0] != ">" {
+		t.Fatalf("second row marker = %q, want >", rows[1][0])
+	}
+}
+
+func TestRenderSearchInputFillsBackground(t *testing.T) {
+	search := textinput.New()
+	search.Placeholder = "type to search"
+	m := &model{search: search}
+
+	got := stripANSI(m.renderSearchInput(30))
+	if len([]rune(got)) != 30 {
+		t.Fatalf("placeholder width = %d, want 30: %q", len([]rune(got)), got)
+	}
+	if !strings.Contains(got, "type to search") {
+		t.Fatalf("placeholder missing: %q", got)
+	}
+}
+
+func TestOneLineStripsImageTags(t *testing.T) {
+	got := oneLine(`<image name=[Image #1] path="/tmp/screen.png"`)
+	if got != "image attachment" {
+		t.Fatalf("truncated image tag = %q, want image attachment", got)
+	}
+
+	got = oneLine(`<image name=[Image #1] path="/tmp/screen.png"> fix this layout`)
+	if got != "fix this layout" {
+		t.Fatalf("image tag text = %q, want prompt text", got)
+	}
+
+	got = oneLine(`</image> added liteparse in here`)
+	if got != "added liteparse in here" {
+		t.Fatalf("closing image tag text = %q, want prompt text", got)
+	}
+}
+
+func TestListSessionsFallsBackToFirstPrompt(t *testing.T) {
+	db, err := sql.Open("sqlite", ":memory:")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer db.Close()
+	mustExec(t, db, `
+		CREATE TABLE sessions (
+			session_key TEXT PRIMARY KEY,
+			provider TEXT NOT NULL,
+			parent_session_key TEXT,
+			title TEXT,
+			started_at TEXT,
+			updated_at TEXT,
+			imported_at TEXT,
+			cwd TEXT,
+			message_count INTEGER
+		);
+		CREATE TABLE messages (
+			session_key TEXT NOT NULL,
+			role TEXT NOT NULL,
+			ordinal INTEGER NOT NULL,
+			text TEXT NOT NULL
+		);
+		CREATE TABLE session_models (
+			session_key TEXT NOT NULL,
+			model TEXT NOT NULL
+		);
+	`)
+	mustExec(t, db, `
+		INSERT INTO sessions VALUES
+			('codex:context', 'codex', NULL, '# AGENTS.md instructions for repo', NULL, '2026-06-18T10:00:00Z', NULL, '/repo', 2),
+			('codex:control', 'codex', NULL, '<turn_aborted> previous turn stopped', NULL, '2026-06-18T09:00:00Z', NULL, '/repo', 1),
+			('codex:child', 'codex', 'codex:context', 'child review output', NULL, '2026-06-18T08:00:00Z', NULL, '/repo', 1);
+		INSERT INTO messages VALUES
+			('codex:context', 'user', 0, '# AGENTS.md instructions for repo'),
+			('codex:context', 'user', 1, 'real user prompt'),
+			('codex:control', 'user', 0, '<turn_aborted> previous turn stopped'),
+			('codex:child', 'assistant', 0, 'child review output');
+	`)
+
+	rows, err := listSessions(db, nil, nil, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(rows) != 1 {
+		t.Fatalf("rows = %d, want 1 displayable session", len(rows))
+	}
+	if rows[0].Title != "real user prompt" {
+		t.Fatalf("context title = %q, want real user prompt", rows[0].Title)
+	}
+}
+
+func TestListSessionsReturnsAllRows(t *testing.T) {
+	db := openListTestDB(t)
+	defer db.Close()
+
+	for index := range 250 {
+		key := "codex:session-" + stringID(index)
+		mustExec(t, db, `
+			INSERT INTO sessions VALUES (?, 'codex', NULL, ?, NULL, '2026-06-18T10:00:00Z', NULL, '/repo', 1);
+			INSERT INTO messages VALUES (?, 'user', 0, ?);
+		`, key, "prompt "+stringID(index), key, "prompt "+stringID(index))
+	}
+
+	rows, err := listSessions(db, nil, nil, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(rows) != 250 {
+		t.Fatalf("rows = %d, want 250", len(rows))
+	}
+}
+
+func TestListSessionsOrdersByUpdatedAndScansCreated(t *testing.T) {
+	db := openListTestDB(t)
+	defer db.Close()
+
+	mustExec(t, db, `
+		INSERT INTO sessions VALUES
+			('codex:old-created-new-updated', 'codex', NULL, 'new update', '2026-01-01T09:00:00Z', '2026-06-18T12:00:00Z', NULL, '/repo', 1),
+			('codex:new-created-old-updated', 'codex', NULL, 'old update', '2026-06-18T09:00:00Z', '2026-06-18T10:00:00Z', NULL, '/repo', 1);
+		INSERT INTO messages VALUES
+			('codex:old-created-new-updated', 'user', 0, 'new update'),
+			('codex:new-created-old-updated', 'user', 0, 'old update');
+	`)
+
+	rows, err := listSessions(db, nil, nil, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(rows) != 2 {
+		t.Fatalf("rows = %d, want 2", len(rows))
+	}
+	if rows[0].SessionKey != "codex:old-created-new-updated" {
+		t.Fatalf("first session = %q, want most recently updated", rows[0].SessionKey)
+	}
+	if rows[0].CreatedAt != "2026-01-01T09:00:00Z" {
+		t.Fatalf("created = %q", rows[0].CreatedAt)
+	}
+	if rows[0].UpdatedAt != "2026-06-18T12:00:00Z" {
+		t.Fatalf("updated = %q", rows[0].UpdatedAt)
+	}
+}
+
+func TestListSessionsSupportsMultiSelectFilters(t *testing.T) {
+	db := openListTestDB(t)
+	defer db.Close()
+
+	insertListSession(t, db, "claude:a", "claude", "/repo/a", "claude prompt a", "opus")
+	insertListSession(t, db, "claude:b", "claude", "/repo/b", "claude prompt b", "opus")
+	insertListSession(t, db, "claude:c", "claude", "/repo/c", "claude prompt c", "sonnet")
+	insertListSession(t, db, "codex:a", "codex", "/repo/a", "codex prompt a", "gpt")
+
+	rows, err := listSessions(db, []string{"claude"}, []string{"opus"}, []string{"/repo/a", "/repo/b"})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(rows) != 2 {
+		t.Fatalf("rows = %d, want 2", len(rows))
+	}
+	got := map[string]bool{}
+	for _, row := range rows {
+		got[row.SessionKey] = true
+	}
+	for _, key := range []string{"claude:a", "claude:b"} {
+		if !got[key] {
+			t.Fatalf("missing %s in filtered rows: %#v", key, got)
+		}
+	}
+}
+
+func TestRenderFiltersUsesEditableLabels(t *testing.T) {
+	m := &model{
+		providers:    map[string]bool{"claude": true},
+		repoFilters:  map[string]bool{"/repo/a": true, "/repo/b": true},
+		modelFilters: map[string]bool{},
+		providerOptions: []filterOption{
+			{Value: "claude", Label: "Claude Code"},
+		},
+		repoOptions: []filterOption{
+			{Value: "/repo/a", Label: "repo/a"},
+			{Value: "/repo/b", Label: "repo/b"},
+		},
+		focus: focusFilters,
+	}
+
+	got := stripANSI(m.renderFilters(100))
+	for _, forbidden := range []string{"F1", "F2", "F3", "F4", "F5"} {
+		if strings.Contains(got, forbidden) {
+			t.Fatalf("filter strip should not expose %s:\n%s", forbidden, got)
+		}
+	}
+	for _, expected := range []string{"Filters", "Ctrl-F Filters", "Harness: Claude Code", "Repo: 2 selected", "Enter edit"} {
+		if !strings.Contains(got, expected) {
+			t.Fatalf("filter strip missing %q:\n%s", expected, got)
+		}
+	}
+}
+
+func TestFilterListClickDoesNotSwitchSections(t *testing.T) {
+	m := &model{
+		providers:    map[string]bool{},
+		repoFilters:  map[string]bool{},
+		modelFilters: map[string]bool{},
+		providerOptions: []filterOption{
+			{Value: "codex", Label: "Codex"},
+		},
+		repoOptions: []filterOption{
+			{Value: "/repo/a", Label: "repo/a"},
+		},
+		filterSection: sectionRepos,
+		width:         100,
+	}
+
+	m.handleFilterClick(tea.MouseMsg{X: 1, Y: 6, Button: tea.MouseButtonLeft, Action: tea.MouseActionPress})
+
+	if m.filterSection != sectionRepos {
+		t.Fatalf("filter section = %v, want repos", m.filterSection)
+	}
+	if !m.repoFilters["/repo/a"] {
+		t.Fatalf("repo filter was not toggled: %#v", m.repoFilters)
+	}
+	if len(m.providers) != 0 {
+		t.Fatalf("provider filters changed on repo click: %#v", m.providers)
+	}
+}
+
+func TestFilterEnterSelectsAndAdvances(t *testing.T) {
+	m := &model{
+		providers: map[string]bool{},
+		providerOptions: []filterOption{
+			{Value: "claude", Label: "Claude Code"},
+		},
+		filterOpen:    true,
+		filterSection: sectionHarness,
+	}
+
+	_ = m.handleFilterKey(tea.KeyMsg{Type: tea.KeyEnter})
+
+	if !m.providers["claude"] {
+		t.Fatalf("provider was not selected: %#v", m.providers)
+	}
+	if m.filterSection != sectionRepos {
+		t.Fatalf("filter section = %v, want repos", m.filterSection)
+	}
+}
+
+func TestFilterShortcutsJumpSections(t *testing.T) {
+	m := &model{filterOpen: true}
+
+	_ = m.handleFilterKey(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune{'3'}})
+	if m.filterSection != sectionModels {
+		t.Fatalf("filter section = %v, want models", m.filterSection)
+	}
+
+	_ = m.handleFilterKey(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune{'r'}})
+	if m.filterSection != sectionRepos {
+		t.Fatalf("filter section = %v, want repos", m.filterSection)
+	}
+}
+
+func TestCtrlFOpenFiltersFromBrowse(t *testing.T) {
+	m := &model{search: textinput.New(), focus: focusSearch}
+
+	_ = m.handleKey(tea.KeyMsg{Type: tea.KeyCtrlF})
+
+	if !m.filterOpen {
+		t.Fatal("ctrl+f did not open filters")
+	}
+	if m.focus != focusFilters {
+		t.Fatalf("focus = %v, want filters", m.focus)
+	}
+}
+
+func TestRenderFilterStepsUsesFullLabels(t *testing.T) {
+	m := &model{filterSection: sectionRepos}
+	got := stripANSI(m.renderFilterSteps(120))
+
+	for _, expected := range []string{"1 Harness", "2 Repos", "3 Models", "4 Roles"} {
+		if !strings.Contains(got, expected) {
+			t.Fatalf("filter steps missing %q:\n%s", expected, got)
+		}
+	}
+	if strings.Contains(got, "Re...") {
+		t.Fatalf("filter steps should not truncate repos label:\n%s", got)
+	}
+}
+
+func TestTranscriptExportFormats(t *testing.T) {
+	row := item{
+		SessionKey: "codex:abc123",
+		Provider:   "codex",
+		Title:      "Fix export button",
+		Timestamp:  "2026-06-18T10:00:00Z",
+		Cwd:        "/repo",
+		Models:     "gpt-test",
+	}
+	messages := []transcriptMessage{
+		{Role: "user", Timestamp: "2026-06-18T10:00:01Z", Text: "please export this"},
+		{Role: "assistant", Timestamp: "2026-06-18T10:00:02Z", Model: "gpt-test", Text: "done"},
+	}
+
+	markdown := formatTranscriptExport(row, messages, "md")
+	for _, expected := range []string{"# Fix export button", "- **Harness:** Codex", "### USER", "please export this", "### ASSISTANT"} {
+		if !strings.Contains(markdown, expected) {
+			t.Fatalf("markdown export missing %q:\n%s", expected, markdown)
+		}
+	}
+
+	text := formatTranscriptExport(row, messages, "txt")
+	for _, expected := range []string{"Fix export button", "Harness: Codex", "USER  2026-06-18T10:00:01Z", "ASSISTANT  2026-06-18T10:00:02Z  gpt-test"} {
+		if !strings.Contains(text, expected) {
+			t.Fatalf("text export missing %q:\n%s", expected, text)
+		}
+	}
+}
+
+func TestLoadTranscriptMessagesIncludesToolRoles(t *testing.T) {
+	db, err := sql.Open("sqlite", ":memory:")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer db.Close()
+	mustExec(t, db, `
+		CREATE TABLE messages (
+			session_key TEXT NOT NULL,
+			role TEXT NOT NULL,
+			timestamp TEXT,
+			model TEXT,
+			text TEXT NOT NULL,
+			ordinal INTEGER NOT NULL
+		);
+	`)
+	mustExec(t, db, `INSERT INTO messages VALUES ('codex:abc', 'user', '2026-06-18T10:00:00Z', NULL, 'start', 0)`)
+	mustExec(t, db, `INSERT INTO messages VALUES ('codex:abc', 'tool-call', '2026-06-18T10:00:01Z', NULL, 'Tool call: exec_command', 1)`)
+	mustExec(t, db, `INSERT INTO messages VALUES ('codex:abc', 'tool', '2026-06-18T10:00:02Z', NULL, 'Tool result', 2)`)
+	mustExec(t, db, `INSERT INTO messages VALUES ('codex:abc', 'assistant', '2026-06-18T10:00:03Z', 'gpt-test', 'done', 3)`)
+
+	all, err := loadTranscriptMessages(db, "codex:abc", true)
+	if err != nil {
+		t.Fatal(err)
+	}
+	narrowed, err := loadTranscriptMessages(db, "codex:abc", false)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if got := transcriptRoles(all); got != "user,tool-call,tool,assistant" {
+		t.Fatalf("all roles = %q", got)
+	}
+	if got := transcriptRoles(narrowed); got != "user,assistant" {
+		t.Fatalf("narrowed roles = %q", got)
+	}
+}
+
+func TestLoadTranscriptPreviewMessagesSkipsHarnessNoise(t *testing.T) {
+	db, err := sql.Open("sqlite", ":memory:")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer db.Close()
+	mustExec(t, db, `
+		CREATE TABLE messages (
+			session_key TEXT NOT NULL,
+			role TEXT NOT NULL,
+			timestamp TEXT,
+			model TEXT,
+			text TEXT NOT NULL,
+			ordinal INTEGER NOT NULL
+		);
+	`)
+	mustExec(t, db, `INSERT INTO messages VALUES ('codex:abc', 'developer', '2026-06-18T10:00:00Z', NULL, 'developer rules', 0)`)
+	mustExec(t, db, `INSERT INTO messages VALUES ('codex:abc', 'user', '2026-06-18T10:00:01Z', NULL, '# AGENTS.md instructions for repo', 1)`)
+	mustExec(t, db, `INSERT INTO messages VALUES ('codex:abc', 'user', '2026-06-18T10:00:02Z', NULL, 'real user prompt', 2)`)
+	mustExec(t, db, `INSERT INTO messages VALUES ('codex:abc', 'tool', '2026-06-18T10:00:03Z', NULL, 'tool output', 3)`)
+
+	messages, err := loadTranscriptPreviewMessages(db, "codex:abc", true, 10)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if got := transcriptRoles(messages); got != "user,tool" {
+		t.Fatalf("preview roles = %q", got)
+	}
+	if messages[0].Text != "real user prompt" {
+		t.Fatalf("first preview text = %q", messages[0].Text)
+	}
+}
+
+func TestDetailWheelDoesNotChangeExportTarget(t *testing.T) {
+	first := item{SessionKey: "codex:first", Title: "first"}
+	second := item{SessionKey: "codex:second", Title: "second"}
+	m := &model{
+		results:    []item{first, second},
+		selected:   0,
+		detail:     true,
+		detailItem: first,
+	}
+
+	_ = m.handleMouse(tea.MouseMsg{Button: tea.MouseButtonWheelDown, Action: tea.MouseActionPress})
+	row, ok := m.exportTarget()
+	if !ok {
+		t.Fatal("expected export target")
+	}
+	if row.SessionKey != first.SessionKey {
+		t.Fatalf("export target = %q, want %q", row.SessionKey, first.SessionKey)
+	}
+	if m.selected != 0 {
+		t.Fatalf("selected changed to %d while detail was open", m.selected)
+	}
+}
+
+func transcriptRoles(messages []transcriptMessage) string {
+	roles := make([]string, 0, len(messages))
+	for _, message := range messages {
+		roles = append(roles, message.Role)
+	}
+	return strings.Join(roles, ",")
+}
+
+func TestDetailViewShowsExportStatus(t *testing.T) {
+	m := &model{
+		keys:       newKeyMap(),
+		helpBubble: newHelpModel(),
+		detail:     true,
+		detailItem: item{
+			SessionKey: "codex:first",
+			Provider:   "codex",
+			Title:      "first thread",
+			Timestamp:  "2026-06-18T10:00:00Z",
+			Cwd:        "/repo",
+		},
+		notice: "exported /tmp/thread.md",
+		width:  100,
+		height: 20,
+	}
+
+	got := stripANSI(m.detailView())
+	if !strings.Contains(got, "exported /tmp/thread.md") {
+		t.Fatalf("detail view missing export notice:\n%s", got)
+	}
+}
+
+func TestRenderBrowseActionsTracksExportButtons(t *testing.T) {
+	m := &model{keys: newKeyMap()}
+
+	got := stripANSI(m.renderBrowseActions(100, 12))
+	for _, expected := range []string{"ENTER Open", "M Markdown", "T Text"} {
+		if !strings.Contains(got, expected) {
+			t.Fatalf("action row missing %q:\n%s", expected, got)
+		}
+	}
+	if len(m.browseButtons) < 3 {
+		t.Fatalf("tracked buttons = %d, want at least 3", len(m.browseButtons))
+	}
+	if buttonActionAt(m.browseButtons, m.browseButtons[1].X, 12) != actionExportMarkdown {
+		t.Fatalf("markdown button hit did not map to export action: %#v", m.browseButtons)
+	}
+}
+
+func TestExportShortcutsDoNotStealSearchTyping(t *testing.T) {
+	db := openListTestDB(t)
+	defer db.Close()
+	search := textinput.New()
+	search.Focus()
+	m := &model{db: db, search: search, focus: focusSearch}
+
+	_ = m.handleKey(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune{'m'}})
+	_ = m.handleKey(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune{'t'}})
+
+	if m.search.Value() != "mt" {
+		t.Fatalf("search value = %q, want mt", m.search.Value())
+	}
+}
+
+func TestDedupeItemsDoesNotCapResults(t *testing.T) {
+	items := make([]item, 0, 300)
+	for index := range 300 {
+		items = append(items, item{SessionKey: "codex:session-" + stringID(index)})
+	}
+
+	deduped := dedupeItems(items)
+	if len(deduped) != 300 {
+		t.Fatalf("deduped rows = %d, want 300", len(deduped))
+	}
+}
+
+func openListTestDB(t *testing.T) *sql.DB {
+	t.Helper()
+	db, err := sql.Open("sqlite", ":memory:")
+	if err != nil {
+		t.Fatal(err)
+	}
+	mustExec(t, db, `
+		CREATE TABLE sessions (
+			session_key TEXT PRIMARY KEY,
+			provider TEXT NOT NULL,
+			parent_session_key TEXT,
+			title TEXT,
+			started_at TEXT,
+			updated_at TEXT,
+			imported_at TEXT,
+			cwd TEXT,
+			message_count INTEGER
+		);
+		CREATE TABLE messages (
+			session_key TEXT NOT NULL,
+			role TEXT NOT NULL,
+			ordinal INTEGER NOT NULL,
+			text TEXT NOT NULL
+		);
+		CREATE TABLE session_models (
+			session_key TEXT NOT NULL,
+			model TEXT NOT NULL
+		);
+	`)
+	return db
+}
+
+func insertListSession(t *testing.T, db *sql.DB, key string, provider string, cwd string, title string, modelName string) {
+	t.Helper()
+	mustExec(t, db, `INSERT INTO sessions VALUES (?, ?, NULL, ?, NULL, '2026-06-18T10:00:00Z', NULL, ?, 1)`, key, provider, title, cwd)
+	mustExec(t, db, `INSERT INTO messages VALUES (?, 'user', 0, ?)`, key, title)
+	mustExec(t, db, `INSERT INTO session_models VALUES (?, ?)`, key, modelName)
+}
+
+func mustExec(t *testing.T, db *sql.DB, query string, args ...any) {
+	t.Helper()
+	if _, err := db.Exec(query, args...); err != nil {
+		t.Fatal(err)
+	}
+}
+
+func stringID(value int) string {
+	return fmt.Sprintf("%03d", value)
+}
+
+func stripANSI(value string) string {
+	return ansiPattern.ReplaceAllString(value, "")
+}