6ca415c134
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.
672 lines
23 KiB
Go
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)
|
|
}
|
|
}
|