Files
pipelines/internal/pipeline/search_test.go
T
alan 6ca415c134 Search: order results newest first in every group
Chat hits sort by the chat's last use whatever field matched, and run,
step, field, artifact and pipeline hits sort by their own date, before
the result cap applies so the cap drops the oldest. Each kind's row scan
also walks newest first. Score still reports the match tier. The app
sorts both groups newest first as well.
2026-11-03 13:35:27 +00:00

672 lines
23 KiB
Go

package pipeline
import (
"context"
"path/filepath"
"strconv"
"strings"
"testing"
"time"
"unicode/utf8"
"git.a-wan.net/alan/pipelines/internal/protocol"
)
// searchFixture builds one pipeline whose name, source, run, stage, field text
// and artifact all contain "zephyr", so a single free-text query exercises
// every kind.
func searchFixture(t *testing.T) (*Store, int64) {
t.Helper()
ctx := context.Background()
store, err := Open(filepath.Join(t.TempDir(), "search.db"))
if err != nil {
t.Fatal(err)
}
t.Cleanup(func() { store.Close() })
if _, err := store.Submit(ctx, "Zephyr Build", Template([]string{"zephyr"}, true)); err != nil {
t.Fatal(err)
}
items, err := store.List(ctx)
if err != nil {
t.Fatal(err)
}
definition, err := store.Get(ctx, items[0].ID, 1)
if err != nil {
t.Fatal(err)
}
run, _, err := store.CreateRun(ctx, definition, "zephyr-key", "/work/zephyr", false, nil, map[string]any{"prompt": "zephyr task"})
if err != nil {
t.Fatal(err)
}
if err := store.BeginStep(ctx, run, 1, "zephyr", map[string]any{"prompt": "zephyr task"}); err != nil {
t.Fatal(err)
}
artifactURL := "/artifacts/" + strconv.FormatInt(run, 10) + "/1/zephyr.txt"
if err := store.FinishStep(ctx, run, protocol.RunStep{
Sequence: 1, Status: "completed", Outcome: "success", Target: protocol.SuccessEnd,
Output: map[string]any{"summary": "zephyr completed"},
Control: &protocol.ControlEvidence{Visit: 1, MaxVisits: 2, ModelTarget: "zephyr-model"},
Artifacts: []protocol.StageArtifact{{Name: "zephyr.txt", SizeBytes: 12, ContentType: "text/plain", URL: artifactURL}},
}); err != nil {
t.Fatal(err)
}
if err := store.FinishRun(ctx, run, "succeeded", "success", "", map[string]any{"summary": "zephyr completed"}); err != nil {
t.Fatal(err)
}
return store, run
}
func searchKinds(response *protocol.SearchResponse) map[string]bool {
kinds := map[string]bool{}
for _, hit := range response.Results {
kinds[hit.Kind] = true
}
return kinds
}
func TestSearchReturnsEveryKind(t *testing.T) {
store, run := searchFixture(t)
response, err := store.Search(context.Background(), protocol.SearchRequest{Query: "zephyr"}, time.Now())
if err != nil {
t.Fatal(err)
}
kinds := searchKinds(response)
for _, kind := range protocol.SearchKinds {
if !kinds[kind] {
t.Fatalf("kind %q missing from %+v", kind, response.Results)
}
}
if response.Cap != protocol.SearchDefaultLimit || response.ScanBoundBytes != protocol.SearchMaxScanBytes {
t.Fatalf("bounds not reported: %+v", response)
}
if response.Truncated {
t.Fatalf("a tiny store must not report truncation: %+v", response)
}
// Every target must point at an addressable entity an existing command resolves.
ctx := context.Background()
for _, hit := range response.Results {
switch hit.Kind {
case protocol.SearchKindPipeline:
id := targetInt(t, hit.Target, "pipeline:")
if _, err := store.Get(ctx, id, 0); err != nil {
t.Fatalf("pipeline target %q does not resolve: %v", hit.Target, err)
}
case protocol.SearchKindVersion:
parts := strings.Split(strings.TrimPrefix(hit.Target, "pipeline:"), ":v")
if len(parts) != 2 {
t.Fatalf("bad version target %q", hit.Target)
}
if _, err := store.Get(ctx, parseInt(t, parts[0]), int(parseInt(t, parts[1]))); err != nil {
t.Fatalf("version target %q does not resolve: %v", hit.Target, err)
}
case protocol.SearchKindRun:
if _, err := store.GetRun(ctx, targetInt(t, hit.Target, "run:")); err != nil {
t.Fatalf("run target %q does not resolve: %v", hit.Target, err)
}
case protocol.SearchKindStep, protocol.SearchKindField:
fields := strings.Split(strings.TrimPrefix(hit.Target, "run:"), ":")
if len(fields) < 2 {
t.Fatalf("bad step/field target %q", hit.Target)
}
detail, err := store.GetRun(ctx, parseInt(t, fields[0]))
if err != nil {
t.Fatalf("step/field target %q does not resolve: %v", hit.Target, err)
}
sequence := parseInt(t, fields[1])
found := false
for _, step := range detail.Steps {
if int64(step.Sequence) == sequence {
found = true
}
}
if !found {
t.Fatalf("step/field target %q names no recorded step", hit.Target)
}
case protocol.SearchKindArtifact:
if !strings.HasPrefix(hit.Target, "/artifacts/") {
t.Fatalf("artifact target %q is not a served URL", hit.Target)
}
}
}
if run <= 0 {
t.Fatal("fixture run missing")
}
}
func targetInt(t *testing.T, target, prefix string) int64 {
t.Helper()
if !strings.HasPrefix(target, prefix) {
t.Fatalf("target %q lacks prefix %q", target, prefix)
}
return parseInt(t, strings.TrimPrefix(target, prefix))
}
func parseInt(t *testing.T, value string) int64 {
t.Helper()
n, err := parsePositiveInt(value)
if err != nil {
t.Fatalf("bad number %q: %v", value, err)
}
return n
}
func TestSearchFieldTextCoversInputOutputEvidence(t *testing.T) {
store, _ := searchFixture(t)
response, err := store.Search(context.Background(), protocol.SearchRequest{Query: "zephyr", Kind: protocol.SearchKindField}, time.Now())
if err != nil {
t.Fatal(err)
}
fields := map[string]bool{}
for _, hit := range response.Results {
if hit.Field == nil {
t.Fatalf("field kind without a field payload: %+v", hit)
}
fields[hit.Field.Field] = true
if !strings.Contains(hit.Field.Snippet, "zephyr") {
t.Fatalf("snippet lacks the match: %+v", hit.Field)
}
}
for _, field := range []string{"input", "output", "evidence"} {
if !fields[field] {
t.Fatalf("field text search missed %q: %+v", field, response.Results)
}
}
}
func TestSearchRankingExactSubstringBodyAndRecency(t *testing.T) {
ctx := context.Background()
store, err := Open(filepath.Join(t.TempDir(), "ranking.db"))
if err != nil {
t.Fatal(err)
}
defer store.Close()
submit := func(name string) {
if _, err := store.Submit(ctx, name, Template([]string{"one"}, true)); err != nil {
t.Fatal(err)
}
}
submit("alpha")
submit("alphabet")
items, _ := store.List(ctx)
definition, _ := store.Get(ctx, items[0].ID, 1)
run, _, err := store.CreateRun(ctx, definition, "alpha-key", "/work", false, nil, map[string]any{"prompt": "body alpha match"})
if err != nil {
t.Fatal(err)
}
if err := store.BeginStep(ctx, run, 1, "one", map[string]any{"prompt": "body alpha match"}); err != nil {
t.Fatal(err)
}
if err := store.FinishStep(ctx, run, protocol.RunStep{Sequence: 1, Status: "completed", Outcome: "success", Target: protocol.SuccessEnd}); err != nil {
t.Fatal(err)
}
response, err := store.Search(ctx, protocol.SearchRequest{Query: "alpha"}, time.Now())
if err != nil {
t.Fatal(err)
}
seen := map[int]bool{}
for _, hit := range response.Results {
seen[hit.Score] = true
}
assertNewestFirst(t, response.Results)
if !seen[3] || !seen[2] || !seen[1] {
t.Fatalf("expected exact/substring/body tiers: %+v", response.Results)
}
// Scores still record how a pipeline name matched.
exactIndex, substringIndex := -1, -1
for i, hit := range response.Results {
if hit.Pipeline == nil {
continue
}
if hit.Pipeline.Name == "alpha" {
exactIndex = i
}
if hit.Pipeline.Name == "alphabet" {
substringIndex = i
}
if hit.Pipeline.Name == "alpha" && hit.Score != 3 {
t.Fatalf("exact name scored %d", hit.Score)
}
if hit.Pipeline.Name == "alphabet" && hit.Score != 2 {
t.Fatalf("substring name scored %d", hit.Score)
}
}
if exactIndex < 0 || substringIndex < 0 {
t.Fatalf("both pipeline names must match: %+v", response.Results)
}
// Hits order by recency whatever their tier.
older, _, err := store.CreateRun(ctx, definition, "alpha-older", "/work", false, nil, map[string]any{"prompt": "alpha"})
if err != nil {
t.Fatal(err)
}
newer, _, err := store.CreateRun(ctx, definition, "alpha-newer", "/work", false, nil, map[string]any{"prompt": "alpha"})
if err != nil {
t.Fatal(err)
}
setCreated(t, store, older, "2026-01-01 00:00:00")
setCreated(t, store, newer, "2026-06-01 00:00:00")
response, err = store.Search(ctx, protocol.SearchRequest{Query: "alpha"}, time.Now())
if err != nil {
t.Fatal(err)
}
var olderIndex, newerIndex = -1, -1
for i, hit := range response.Results {
if hit.Run == nil || hit.Run.ID == 0 {
continue
}
if hit.Run.ID == older {
olderIndex = i
}
if hit.Run.ID == newer {
newerIndex = i
}
}
if olderIndex < 0 || newerIndex < 0 || newerIndex > olderIndex {
t.Fatalf("recency order lost: older=%d newer=%d", olderIndex, newerIndex)
}
assertNewestFirst(t, response.Results)
}
func assertNewestFirst(t *testing.T, results []protocol.SearchResult) {
t.Helper()
for i := 1; i < len(results); i++ {
if results[i-1].Recency < results[i].Recency {
t.Fatalf("results not newest first at %d: %+v", i, results)
}
}
}
// TestSearchOrdersByDateAndCapKeepsNewest: an exact pipeline-name match on an
// old pipeline sorts below a newer run's body match, and a cap keeps the
// newest hits rather than the best-scored ones.
func TestSearchOrdersByDateAndCapKeepsNewest(t *testing.T) {
ctx := context.Background()
store, err := Open(filepath.Join(t.TempDir(), "order.db"))
if err != nil {
t.Fatal(err)
}
defer store.Close()
if _, err := store.Submit(ctx, "gamma", Template([]string{"one"}, true)); err != nil {
t.Fatal(err)
}
items, _ := store.List(ctx)
definition, _ := store.Get(ctx, items[0].ID, 1)
if _, err := store.db.Exec("UPDATE pipeline_versions SET created_at='2020-01-01 00:00:00'"); err != nil {
t.Fatal(err)
}
var runs []int64
for i, created := range []string{"2026-03-01 00:00:00", "2026-01-01 00:00:00", "2026-02-01 00:00:00"} {
run, _, err := store.CreateRun(ctx, definition, "key-"+strconv.Itoa(i), "/work/gamma-"+strconv.Itoa(i), false, nil, nil)
if err != nil {
t.Fatal(err)
}
setCreated(t, store, run, created)
runs = append(runs, run)
}
response, err := store.Search(ctx, protocol.SearchRequest{Query: "gamma", Kind: protocol.SearchKindRun}, time.Now())
if err != nil {
t.Fatal(err)
}
if len(response.Results) != 3 || response.Results[0].Run.ID != runs[0] || response.Results[1].Run.ID != runs[2] || response.Results[2].Run.ID != runs[1] {
t.Fatalf("runs = %+v, want created newest first", response.Results)
}
all, err := store.Search(ctx, protocol.SearchRequest{Query: "gamma"}, time.Now())
if err != nil {
t.Fatal(err)
}
assertNewestFirst(t, all.Results)
last := all.Results[len(all.Results)-1]
if last.Pipeline == nil || last.Score != 3 {
t.Fatalf("oldest hit = %+v, want the exact-name pipeline last despite its score", last)
}
capped, err := store.Search(ctx, protocol.SearchRequest{Query: "gamma", Limit: 2}, time.Now())
if err != nil {
t.Fatal(err)
}
if !capped.Truncated || len(capped.Results) != 2 || capped.Results[0].Run.ID != runs[0] || capped.Results[1].Run.ID != runs[2] {
t.Fatalf("capped = %+v, want the two newest runs", capped.Results)
}
}
func TestSearchStatusWordsSelectRuns(t *testing.T) {
ctx := context.Background()
store, err := Open(filepath.Join(t.TempDir(), "statuses.db"))
if err != nil {
t.Fatal(err)
}
defer store.Close()
if _, err := store.Submit(ctx, "statuses", Template([]string{"one"}, true)); err != nil {
t.Fatal(err)
}
items, _ := store.List(ctx)
definition, _ := store.Get(ctx, items[0].ID, 1)
// One run per accepted status word, each with a distinct created_at so a
// date selector can never be mistaken for the status selector.
byStatus := map[string]int64{}
for i, status := range protocol.SearchStatuses {
run, _, err := store.CreateRun(ctx, definition, "status-"+status, "/work", false, nil, nil)
if err != nil {
t.Fatal(err)
}
if _, err := store.db.Exec("UPDATE pipeline_runs SET status=?,created_at=? WHERE id=?", status, "2026-01-0"+strconv.Itoa(i+1)+" 09:00:00", run); err != nil {
t.Fatal(err)
}
byStatus[status] = run
}
now := time.Date(2026, 10, 16, 12, 0, 0, 0, time.UTC)
for _, status := range protocol.SearchStatuses {
response, err := store.Search(ctx, protocol.SearchRequest{Query: status}, now)
if err != nil {
t.Fatal(err)
}
var runs []int64
for _, hit := range response.Results {
if hit.Run == nil {
t.Fatalf("status %q returned a non-run kind %q", status, hit.Kind)
}
runs = append(runs, hit.Run.ID)
}
if len(runs) != 1 || runs[0] != byStatus[status] {
t.Fatalf("status %q selected %v, want [%d]", status, runs, byStatus[status])
}
}
}
func TestSearchStatusAndDateSelectors(t *testing.T) {
ctx := context.Background()
store, err := Open(filepath.Join(t.TempDir(), "selector.db"))
if err != nil {
t.Fatal(err)
}
defer store.Close()
if _, err := store.Submit(ctx, "selectors", Template([]string{"one"}, true)); err != nil {
t.Fatal(err)
}
items, _ := store.List(ctx)
definition, _ := store.Get(ctx, items[0].ID, 1)
yesterdayRun, _, err := store.CreateRun(ctx, definition, "yesterday", "/work", false, nil, nil)
if err != nil {
t.Fatal(err)
}
todayRun, _, err := store.CreateRun(ctx, definition, "today", "/work", false, nil, nil)
if err != nil {
t.Fatal(err)
}
if err := store.FinishRun(ctx, yesterdayRun, "failed", "error", "boom", nil); err != nil {
t.Fatal(err)
}
setCreated(t, store, yesterdayRun, "2026-10-15 09:00:00")
setCreated(t, store, todayRun, "2026-10-16 09:00:00")
now := time.Date(2026, 10, 16, 12, 0, 0, 0, time.UTC)
selects := func(query string) map[int64]bool {
t.Helper()
response, err := store.Search(ctx, protocol.SearchRequest{Query: query}, now)
if err != nil {
t.Fatal(err)
}
ids := map[int64]bool{}
for _, hit := range response.Results {
if hit.Run != nil {
ids[hit.Run.ID] = true
}
}
return ids
}
if ids := selects("failed"); !ids[yesterdayRun] || ids[todayRun] {
t.Fatalf("status selector: %+v", ids)
}
if ids := selects("today"); !ids[todayRun] || ids[yesterdayRun] {
t.Fatalf("today selector: %+v", ids)
}
if ids := selects("yesterday"); !ids[yesterdayRun] || ids[todayRun] {
t.Fatalf("yesterday selector: %+v", ids)
}
if ids := selects("2026-10-15"); !ids[yesterdayRun] || ids[todayRun] {
t.Fatalf("literal date selector: %+v", ids)
}
if ids := selects("this week"); !ids[yesterdayRun] || !ids[todayRun] {
t.Fatalf("this week selector: %+v", ids)
}
// Non-selector text stays free text.
if ids := selects("selectors"); !ids[yesterdayRun] || !ids[todayRun] {
t.Fatalf("free text was misread as a selector: %+v", ids)
}
}
func TestParseSearchTerms(t *testing.T) {
now := time.Date(2026, 10, 16, 12, 0, 0, 0, time.UTC)
cases := []struct {
query string
status string
hasDate bool
from, to string
text string
}{
{query: "failed", status: "failed"},
{query: " RUNNING ", status: "running"},
{query: "today", hasDate: true, from: "2026-10-16 00:00:00", to: "2026-10-17 00:00:00"},
{query: "yesterday", hasDate: true, from: "2026-10-15 00:00:00", to: "2026-10-16 00:00:00"},
{query: "this week", hasDate: true, from: "2026-10-12 00:00:00", to: "2026-10-19 00:00:00"},
{query: "2026-10-05", hasDate: true, from: "2026-10-05 00:00:00", to: "2026-10-06 00:00:00"},
{query: "failed to build", text: "failed to build"},
{query: "build", text: "build"},
}
for _, test := range cases {
terms := parseSearchTerms(test.query, now)
if terms.Status != test.status || terms.Text != test.text || terms.HasDate != test.hasDate {
t.Fatalf("parse %q = %+v", test.query, terms)
}
if test.hasDate {
if got := terms.From.Format(searchSQLTime); got != test.from {
t.Fatalf("parse %q from = %s, want %s", test.query, got, test.from)
}
if got := terms.To.Format(searchSQLTime); got != test.to {
t.Fatalf("parse %q to = %s, want %s", test.query, got, test.to)
}
}
}
}
func TestSearchKindFilterAndLimits(t *testing.T) {
store, _ := searchFixture(t)
ctx := context.Background()
response, err := store.Search(ctx, protocol.SearchRequest{Query: "zephyr", Kind: protocol.SearchKindRun}, time.Now())
if err != nil {
t.Fatal(err)
}
for _, hit := range response.Results {
if hit.Kind != protocol.SearchKindRun {
t.Fatalf("kind filter leaked %q", hit.Kind)
}
}
if _, err := store.Search(ctx, protocol.SearchRequest{Query: "zephyr", Kind: "bogus"}, time.Now()); err == nil {
t.Fatal("invalid kind must return a clear error")
}
for _, test := range []struct {
limit int
want int
}{{limit: 0, want: protocol.SearchDefaultLimit}, {limit: -5, want: protocol.SearchDefaultLimit}, {limit: 1, want: 1}, {limit: 500, want: protocol.SearchMaxLimit}} {
response, err := store.Search(ctx, protocol.SearchRequest{Query: "zephyr", Limit: test.limit}, time.Now())
if err != nil {
t.Fatal(err)
}
if response.Cap != test.want {
t.Fatalf("limit %d => cap %d, want %d", test.limit, response.Cap, test.want)
}
if len(response.Results) > response.Cap {
t.Fatalf("limit %d returned %d results", test.limit, len(response.Results))
}
}
// A cap below the candidate count drops matches and must report Truncated.
truncated, err := store.Search(ctx, protocol.SearchRequest{Query: "zephyr", Limit: 1}, time.Now())
if err != nil {
t.Fatal(err)
}
if len(truncated.Results) != 1 || !truncated.Truncated {
t.Fatalf("result cap must truncate: %+v", truncated)
}
}
func TestSearchEdgeCases(t *testing.T) {
store, run := searchFixture(t)
ctx := context.Background()
empty, err := store.Search(ctx, protocol.SearchRequest{Query: " "}, time.Now())
if err != nil || len(empty.Results) != 0 {
t.Fatalf("empty query: %+v %v", empty, err)
}
none, err := store.Search(ctx, protocol.SearchRequest{Query: "no-such-token-xyzzy"}, time.Now())
if err != nil || len(none.Results) != 0 {
t.Fatalf("no-match query: %+v %v", none, err)
}
if none.Results == nil {
t.Fatal("results must be an empty slice, not nil")
}
// A run without a finish reports no duration.
setFinishedNull(t, store, run)
response, err := store.Search(ctx, protocol.SearchRequest{Query: "zephyr", Kind: protocol.SearchKindRun}, time.Now())
if err != nil {
t.Fatal(err)
}
for _, hit := range response.Results {
if hit.Run != nil && hit.Run.FinishedAt != "" {
t.Fatalf("null finished_at surfaced a value: %+v", hit.Run)
}
}
}
func TestSearchSnippetBoundaries(t *testing.T) {
if got := searchSnippet("prefix café résumé naïve suffix", "naïve"); !strings.Contains(got, "naïve") || !utf8.ValidString(got) {
t.Fatalf("unicode snippet malformed: %q", got)
}
if got := searchSnippet("line one\n\tline two\r\n zephyr here", "zephyr"); strings.ContainsAny(got, "\n\r\t") || !strings.Contains(got, "zephyr") {
t.Fatalf("whitespace snippet not normalized: %q", got)
}
if got := searchSnippet(strings.Repeat("é", 200)+"needle"+strings.Repeat("é", 200), "needle"); !utf8.ValidString(got) || !strings.Contains(got, "needle") {
t.Fatalf("boundary snippet malformed: %q", got)
}
if got := searchSnippet("no match here", "absent"); got == "" || !utf8.ValidString(got) {
t.Fatalf("no-match snippet must stay a clean line: %q", got)
}
}
func TestSearchScanBoundTruncates(t *testing.T) {
ctx := context.Background()
store, err := Open(filepath.Join(t.TempDir(), "scan.db"))
if err != nil {
t.Fatal(err)
}
defer store.Close()
if _, err := store.Submit(ctx, "scan", Template([]string{"one"}, true)); err != nil {
t.Fatal(err)
}
items, _ := store.List(ctx)
definition, _ := store.Get(ctx, items[0].ID, 1)
// An older step that does match, and a newer step whose body alone exceeds
// the scan budget: the budget must stop the scan and be reported.
older, _, err := store.CreateRun(ctx, definition, "scan-older", "/work", false, nil, nil)
if err != nil {
t.Fatal(err)
}
if err := store.BeginStep(ctx, older, 1, "one", nil); err != nil {
t.Fatal(err)
}
if err := store.FinishStep(ctx, older, protocol.RunStep{Sequence: 1, Status: "completed", Outcome: "success", Target: protocol.SuccessEnd, Output: map[string]any{"summary": "needle in older step"}}); err != nil {
t.Fatal(err)
}
newer, _, err := store.CreateRun(ctx, definition, "scan-newer", "/work", false, nil, nil)
if err != nil {
t.Fatal(err)
}
if err := store.BeginStep(ctx, newer, 1, "one", nil); err != nil {
t.Fatal(err)
}
blob := strings.Repeat("x", protocol.SearchMaxScanBytes+1024)
if err := store.FinishStep(ctx, newer, protocol.RunStep{Sequence: 1, Status: "completed", Outcome: "success", Target: protocol.SuccessEnd, Output: map[string]any{"blob": blob}}); err != nil {
t.Fatal(err)
}
response, err := store.Search(ctx, protocol.SearchRequest{Query: "needle"}, time.Now())
if err != nil {
t.Fatal(err)
}
if !response.Truncated {
t.Fatalf("scan bound not reported: %+v", response)
}
for _, hit := range response.Results {
if hit.Field != nil {
t.Fatalf("scan passed the bound and matched: %+v", hit.Field)
}
}
recent, err := store.Search(ctx, protocol.SearchRequest{Kind: protocol.SearchKindField}, time.Now())
if err != nil || !recent.Truncated || len(recent.Results) != 0 || recent.ScannedBytes > protocol.SearchMaxScanBytes {
t.Fatalf("kind-only fields bypassed the byte budget: %+v %v", recent, err)
}
}
// TestSearchScanBoundTruncatesByRowCount proves the step-count bound is
// observable: more recorded steps than the budget sets Truncated even though
// every body is tiny and fits the byte budget.
func TestSearchScanBoundTruncatesByRowCount(t *testing.T) {
ctx := context.Background()
store, err := Open(filepath.Join(t.TempDir(), "scanrows.db"))
if err != nil {
t.Fatal(err)
}
defer store.Close()
if _, err := store.Submit(ctx, "scanrows", Template([]string{"one"}, true)); err != nil {
t.Fatal(err)
}
items, _ := store.List(ctx)
definition, _ := store.Get(ctx, items[0].ID, 1)
run, _, err := store.CreateRun(ctx, definition, "scanrows", "/work", false, nil, nil)
if err != nil {
t.Fatal(err)
}
tx, err := store.db.Begin()
if err != nil {
t.Fatal(err)
}
for sequence := 1; sequence <= protocol.SearchMaxScanSteps+1; sequence++ {
if _, err := tx.Exec(`INSERT INTO run_steps(run_id,sequence,stage_key,input_json) VALUES(?,?,?,?)`, run, sequence, "one", "{}"); err != nil {
t.Fatal(err)
}
}
if err := tx.Commit(); err != nil {
t.Fatal(err)
}
response, err := store.Search(ctx, protocol.SearchRequest{Query: "needle"}, time.Now())
if err != nil {
t.Fatal(err)
}
if !response.Truncated {
t.Fatalf("step-count bound not reported: scanned_steps=%d total=%d", response.ScannedSteps, protocol.SearchMaxScanSteps+1)
}
if response.ScannedSteps != protocol.SearchMaxScanSteps {
t.Fatalf("scanned_steps=%d, want %d", response.ScannedSteps, protocol.SearchMaxScanSteps)
}
if response.ScannedBytes > protocol.SearchMaxScanBytes {
t.Fatalf("scanned_bytes=%d exceeds bound %d", response.ScannedBytes, protocol.SearchMaxScanBytes)
}
recent, err := store.Search(ctx, protocol.SearchRequest{Kind: protocol.SearchKindField}, time.Now())
if err != nil || !recent.Truncated || recent.ScannedSteps != protocol.SearchMaxScanSteps {
t.Fatalf("kind-only fields bypassed the step budget: %+v %v", recent, err)
}
}
func setCreated(t *testing.T, store *Store, runID int64, timestamp string) {
t.Helper()
if _, err := store.db.Exec("UPDATE pipeline_runs SET created_at=? WHERE id=?", timestamp, runID); err != nil {
t.Fatal(err)
}
}
func setFinishedNull(t *testing.T, store *Store, runID int64) {
t.Helper()
if _, err := store.db.Exec("UPDATE pipeline_runs SET finished_at=NULL,status='running' WHERE id=?", runID); err != nil {
t.Fatal(err)
}
}