package pipeline import ( "context" "reflect" "strings" "testing" "time" "git.a-wan.net/alan/pipelines/internal/protocol" ) func TestSearchKindOnlyCanonicalRows(t *testing.T) { store, _ := searchFixture(t) ctx := context.Background() for _, kind := range protocol.SearchKinds { t.Run(kind, func(t *testing.T) { for _, query := range []string{"", " \t\n "} { response, err := store.Search(ctx, protocol.SearchRequest{Query: query, Kind: " " + kind + " "}, time.Now()) if err != nil { t.Fatal(err) } if len(response.Results) == 0 || response.Kind != kind || response.Query != query { t.Fatalf("missing kind-only results: %+v", response) } for _, hit := range response.Results { if hit.Kind != kind || hit.Target == "" { t.Fatalf("invalid canonical hit: %+v", hit) } } } }) } } func TestSearchKindOnlyValidationAndLimits(t *testing.T) { store, _ := searchFixture(t) ctx := context.Background() for _, kind := range []string{"bogus", "PIPELINE", "pipeline' OR 1=1 --"} { if _, err := store.Search(ctx, protocol.SearchRequest{Kind: kind}, time.Now()); err == nil { t.Fatalf("blank text bypassed validation for %q", kind) } } for _, query := range []string{"", " \n\t"} { response, err := store.Search(ctx, protocol.SearchRequest{Query: query}, time.Now()) if err != nil || response.Results == nil || len(response.Results) != 0 || response.Truncated { t.Fatalf("empty all-kind query must remain a no-op: %+v %v", response, err) } } for _, limit := range []int{-1, 0, 1, protocol.SearchMaxLimit + 1} { response, err := store.Search(ctx, protocol.SearchRequest{Kind: protocol.SearchKindField, Limit: limit}, time.Now()) if err != nil || response.Cap != searchLimit(limit) || len(response.Results) > response.Cap { t.Fatalf("kind-only limit %d: %+v %v", limit, response, err) } if limit == 1 && (len(response.Results) != 1 || !response.Truncated) { t.Fatalf("expected bounded/truncated fields: %+v", response) } } } func TestSearchKindOnlyRecencyThenNumericID(t *testing.T) { store, run := searchFixture(t) ctx := context.Background() for i := 0; i < 11; i++ { _, err := store.db.Exec(`INSERT INTO pipeline_runs(pipeline_id,version,request_key,workspace,allow_tools,write_paths,input_json,created_at) SELECT pipeline_id,version,printf('recent-%d',?),workspace,allow_tools,write_paths,input_json,'2020-01-01 00:00:00' FROM pipeline_runs WHERE id=?`, i, run) if err != nil { t.Fatal(err) } } // The oldest ID is newest by timestamp, followed by equal-time numeric IDs. if _, err := store.db.Exec("UPDATE pipeline_runs SET created_at='2030-01-01 00:00:00' WHERE id=?", run); err != nil { t.Fatal(err) } response, err := store.Search(ctx, protocol.SearchRequest{Kind: protocol.SearchKindRun, Limit: 4}, time.Now()) if err != nil { t.Fatal(err) } var ids []int64 for _, hit := range response.Results { ids = append(ids, hit.Run.ID) } if !reflect.DeepEqual(ids, []int64{run, run + 11, run + 10, run + 9}) || !response.Truncated { t.Fatalf("recency/ID ordering or limit: %+v", response) } again, err := store.Search(ctx, protocol.SearchRequest{Kind: protocol.SearchKindRun, Limit: 4}, time.Now()) if err != nil || !reflect.DeepEqual(response, again) { t.Fatalf("kind-only results changed between reads: %+v %v", again, err) } } func TestSearchRecentCanonicalIndexes(t *testing.T) { store, _ := searchFixture(t) for _, tc := range []struct{ query, index string }{ {"SELECT pipeline_id,version FROM pipeline_versions ORDER BY created_at DESC,pipeline_id DESC,version DESC LIMIT 51", "search_versions_recent"}, {"SELECT p.id FROM pipelines p JOIN pipeline_versions v ON v.pipeline_id=p.id WHERE v.version=(SELECT MAX(version) FROM pipeline_versions WHERE pipeline_id=p.id) ORDER BY v.created_at DESC,v.pipeline_id DESC,v.version DESC LIMIT 51", "search_versions_recent"}, {"SELECT id FROM pipeline_runs ORDER BY created_at DESC,id DESC LIMIT 51", "search_runs_recent"}, {"SELECT run_id,sequence FROM run_steps ORDER BY started_at DESC,run_id DESC,sequence DESC LIMIT 51", "search_steps_recent"}, {"SELECT a.run_id,a.sequence FROM pipeline_runs r CROSS JOIN step_artifacts a ON a.run_id=r.id ORDER BY r.created_at DESC,r.id DESC,a.sequence DESC LIMIT 2001", "search_runs_recent"}, } { rows, err := store.db.Query("EXPLAIN QUERY PLAN " + tc.query) if err != nil { t.Fatal(err) } var plan string for rows.Next() { var id, parent, unused int var detail string if err := rows.Scan(&id, &parent, &unused, &detail); err != nil { t.Fatal(err) } plan += detail } rows.Close() if !strings.Contains(plan, tc.index) || strings.Contains(plan, "USE TEMP B-TREE FOR ORDER BY") { t.Fatalf("recent rows must use ordered canonical index: %s", plan) } } } func TestSearchKindOnlyMaximumResultCap(t *testing.T) { store, run := searchFixture(t) _, err := store.db.Exec(`WITH RECURSIVE n(x) AS (VALUES(1) UNION ALL SELECT x+1 FROM n WHERE x<250) INSERT INTO pipeline_runs(pipeline_id,version,request_key,workspace,allow_tools,write_paths,input_json) SELECT r.pipeline_id,r.version,printf('cap-%d',n.x),r.workspace,r.allow_tools,r.write_paths,r.input_json FROM pipeline_runs r CROSS JOIN n WHERE r.id=?`, run) if err != nil { t.Fatal(err) } for _, limit := range []int{0, 1, 9999} { response, err := store.Search(context.Background(), protocol.SearchRequest{Kind: protocol.SearchKindRun, Limit: limit}, time.Now()) if err != nil || len(response.Results) != searchLimit(limit) || !response.Truncated || response.ScannedSteps != 0 || response.ScannedBytes != 0 { t.Fatalf("kind-only cap %d not enforced: %+v %v", limit, response, err) } } } func TestSearchKindOnlyPipelineIsLatestCanonicalVersion(t *testing.T) { store, _ := searchFixture(t) _, err := store.db.Exec(`INSERT INTO pipeline_versions(pipeline_id,version,source,content_hash,graph_json,created_at) SELECT pipeline_id,version+1,source,content_hash||'-next',graph_json,'2031-01-01 00:00:00' FROM pipeline_versions`) if err != nil { t.Fatal(err) } response, err := store.Search(context.Background(), protocol.SearchRequest{Kind: protocol.SearchKindPipeline}, time.Now()) if err != nil || len(response.Results) != 1 || response.Results[0].Pipeline.Version != 2 { t.Fatalf("pipeline browse must return latest canonical version only: %+v %v", response, err) } versions, err := store.Search(context.Background(), protocol.SearchRequest{Kind: protocol.SearchKindVersion}, time.Now()) if err != nil || len(versions.Results) != 2 || versions.Results[0].Version.Version != 2 { t.Fatalf("version browse must retain history in recent order: %+v %v", versions, err) } }