G-24: one composition run per candidate and machine, one test run per level, every reading step timed #244

Merged
mesh-tools merged 49 commits from fix/47-G-shared-runs into main 2026-11-17 12:15:36 +00:00
Showing only changes of commit a96f873e21 - Show all commits
@@ -0,0 +1,536 @@
//go:build integration
package main
import (
"context"
"encoding/json"
"os"
"path/filepath"
"strings"
"sync"
"sync/atomic"
"testing"
"time"
"github.com/nats-io/nats.go"
"github.com/nats-io/nats.go/jetstream"
builds "git.novox.be/novox/mesh-delivery/modules/mesh-delivery-contracts/go/seats/meshbuilds"
catalog "git.novox.be/novox/mesh-delivery/modules/mesh-delivery-contracts/go/seats/meshcatalog"
seat "git.novox.be/novox/mesh-delivery/modules/mesh-delivery-contracts/go/seats/meshpipelinerunner"
"git.novox.be/novox/mesh-delivery/modules/mesh-delivery-contracts/go/seats/nodebuildgo"
"git.novox.be/novox/mesh-sdk/go/buscompose"
"git.novox.be/novox/mesh-sdk/go/catalogue"
"git.novox.be/novox/mesh-sdk/go/process"
"git.novox.be/novox/mesh-sdk/go/seatlist"
"git.novox.be/novox/mesh-sdk/go/testbus"
"git.novox.be/novox/mesh-sdk/go/views"
"git.novox.be/novox/mesh-sdk/go/views/viewstest"
"mesh-delivery-pipeline/internal/pipeline"
)
// Test 109 (design 47 G §733 *Whole (runner…)*, §724 to §728, §535 and §647 as A-466y and A-466z amend them; A-468f: in
// mesh-delivery with a fixture build seat holder; A-470f: no reader-only refusal). The runner whole against the real bus: a
// module whose program and tools bundle test one directory asks one unit and one integration run, both artifacts' steps
// ending with its result and shared; a failing test fails once and is counted once; a rerun of one artifact's failed step
// that passes moves the other's, the pipeline ending again, and an accepted step does not move; a runner restarted during a
// run takes it up by its ask, its clock holding that ask (A-470n); a test run waiting with a holder present is not failed;
// a replaced reader leaves the ask to the other readers; a run that keeps saying its progress past its bound is not ended,
// and a taken ask silent for its bound ends could not run with its readers, its ask dropped; a second revision with the
// same digests asks its own runs; a seat the seat-holders view names no holder for ends its pipeline failed at once, its
// other steps not asked (A-470g, A-470h); the process answers test-runs with its fill against test-runs-cap-mib and
// test-runs-drop deletes the key and its output object (A-470i); at the cap a step ends could not run, naming the fill.
// The step bound is two seconds here, as the setting test-step-bound names it, where the mesh's is 30 minutes.
func TestTestRunsAreAskedOncePerLevelAndMoveEveryReader(t *testing.T) {
url := testbus.URL(t)
nc, err := nats.Connect(url)
if err != nil {
t.Fatal(err)
}
defer nc.Close()
js, err := jetstream.New(nc)
if err != nil {
t.Fatal(err)
}
ctx, cancel := context.WithTimeout(context.Background(), 60*time.Second)
defer cancel()
const module = "mesh-delivery-pipeline"
for _, state := range []string{"pipelines", "kept", "toolchains", "findings", "first-views", "consumers", "aged", "recoveries"} {
if _, err := js.CreateKeyValue(ctx, jetstream.KeyValueConfig{Bucket: module + "_" + state, History: 1}); err != nil {
t.Fatal(err)
}
}
for _, state := range []string{"bounds", TestRunsState} {
if _, err := js.CreateKeyValue(ctx, jetstream.KeyValueConfig{Bucket: module + "_" + state, History: 1, LimitMarkerTTL: time.Minute}); err != nil {
t.Fatal(err)
}
}
// test-runs' own object store, made with the state (A-469e).
if _, err := js.CreateObjectStore(ctx, jetstream.ObjectStoreConfig{Bucket: catalogue.BusName(module, catalogue.StateObjectsName(TestRunsState))}); err != nil {
t.Fatal(err)
}
if _, err := js.CreateStream(ctx, jetstream.StreamConfig{Name: buscompose.LogStreamName(module, seat.StateStepLog), Subjects: []string{buscompose.LogSubject(module, seat.StateStepLog) + ".>"}}); err != nil {
t.Fatal(err)
}
events, err := js.CreateStream(ctx, jetstream.StreamConfig{Name: process.EventsStream, Subjects: []string{"mesh.mod.*.event.>", "mesh.seat.*.event.>", "mesh.stream.*.event.>"}})
if err != nil {
t.Fatal(err)
}
if _, err := events.CreateOrUpdateConsumer(ctx, jetstream.ConsumerConfig{Durable: "n1_" + module, AckPolicy: jetstream.AckExplicitPolicy}); err != nil {
t.Fatal(err)
}
if _, err := js.CreateStream(ctx, jetstream.StreamConfig{Name: "ASKS", Subjects: []string{"mesh.seat.*.accept.>"}, Retention: jetstream.WorkQueuePolicy}); err != nil {
t.Fatal(err)
}
// The seat-holders view of the seat mesh-module-assigner's claimant (§647, A-466z), served as its owner does: node-build-go
// has a holder, node-build-node none.
holders := viewstest.Serve(t, ctx, js, nc, "assigner", "seat-holders", "assigner.seat-holders", "n1_"+module)
if _, err := holders.Put(ctx, "node-build-go", []byte(`{"holders":[{"module":"mesh-build-go"}]}`)); err != nil {
t.Fatal(err)
}
// The registrations: app tests its program and tools bundle from one directory, its unit step required and its
// integration step optional; web is built by node-build-node.
policy := catalog.Policy{Steps: catalog.StepStatuses{Lint: "bypass", Unit: "required", Integration: "optional", Composition: "bypass", Review: "bypass", Approval: "bypass"}}
regs := []catalog.Registration{{Module: "app", Branches: []string{"main"}, Origin: "o/app", Policy: policy},
{Module: "web", Branches: []string{"main"}, Origin: "o/web", Policy: policy}}
answer := func(subject string, body any) {
if _, err := nc.Subscribe(subject, func(m *nats.Msg) {
raw, _ := json.Marshal(map[string]any{"result": body})
_ = m.Respond(raw)
}); err != nil {
t.Fatal(err)
}
}
answer("mesh.seat.mesh-catalog.call.registrations.*", catalog.RegistrationsAnswer{Registrations: regs})
answer("mesh.seat.mesh-hand-acts.call.hand-act.*", map[string]any{})
entries := []catalog.CatalogEntry{
{Module: "app", Commit: "c1", Fp: "src2:aa", Path: "modules/app", Repository: "o/app",
Artifacts: []catalog.Artifact{{Ref: "app:program", Language: "go"}, {Ref: "app:tools", Language: "go"}}},
{Module: "web", Commit: "w1", Fp: "src2:ww", Path: "modules/web", Repository: "o/web", Artifacts: []catalog.Artifact{{Ref: "web:program", Language: "node"}}},
{Module: "mesh-build-go", Acts: []catalog.ActingRule{{Seat: "node-build-go", Step: "build", On: "go"}}},
{Module: "mesh-build-node", Acts: []catalog.ActingRule{{Seat: "node-build-node", Step: "build", On: "node"}}},
{Module: "assigner", Manifest: map[string]any{"module": "assigner", "version": "0.1", "claims": []any{map[string]any{"name": seatlist.HolderSeat, "scope": "mesh"}}}},
}
var revision atomic.Int64
revision.Store(1)
if _, err := nc.Subscribe("mesh.seat.mesh-catalog.call.revision.*", func(m *nats.Msg) {
r := revision.Load()
raw, _ := json.Marshal(map[string]any{"result": catalog.RevisionAnswer{Revision: &catalog.CatalogRevision{Revision: r, Kind: "trunk", Branch: "main", Source: 2 + r}, Entries: entries}})
_ = m.Respond(raw)
}); err != nil {
t.Fatal(err)
}
def, err := os.ReadFile("../../../mesh-delivery-contracts/seats/mesh-pipeline-runner/seat.json")
if err != nil {
t.Fatal(err)
}
if _, err := nc.Subscribe("mesh.seat.mesh-catalog.call."+seatlist.Verb+".*", func(m *nats.Msg) {
var in struct {
Seat string `json:"seat"`
}
_ = json.Unmarshal(m.Data, &in)
entry := seatlist.Entry{Seat: seat.Seat, Source: seatlist.SourceTrunk, Digest: "sha256:runner"}
var result any = seatlist.Listing{Revision: 1, Seats: []seatlist.Entry{entry}}
if in.Seat != "" {
entry.Definition = def
result = seatlist.Answer{Seat: in.Seat, Found: in.Seat == seat.Seat, Entry: &entry, Revision: 1}
}
raw, _ := json.Marshal(map[string]any{"result": result})
_ = m.Respond(raw)
}); err != nil {
t.Fatal(err)
}
// Every pipeline-ended said, and every drop asked of a build seat.
var mu sync.Mutex
var endings []seat.PipelineEnded
var drops []string
if _, err := nc.Subscribe("mesh.seat.mesh-pipeline-runner.event.pipeline-ended.>", func(m *nats.Msg) {
var e seat.PipelineEnded
if json.Unmarshal(m.Data, &e) == nil {
mu.Lock()
endings = append(endings, e)
mu.Unlock()
}
}); err != nil {
t.Fatal(err)
}
if _, err := nc.Subscribe("mesh.seat.*.call.drop.>", func(m *nats.Msg) {
mu.Lock()
drops = append(drops, string(m.Data))
mu.Unlock()
raw, _ := json.Marshal(map[string]any{"result": map[string]any{}})
_ = m.Respond(raw)
}); err != nil {
t.Fatal(err)
}
ended := func(key string) []seat.PipelineEnded {
mu.Lock()
defer mu.Unlock()
var out []seat.PipelineEnded
for _, e := range endings {
if e.Pipeline == key {
out = append(out, e)
}
}
return out
}
// The settings, as the manifest's resources write them (A-469x): a cap of 1 MiB, a step bound of two seconds.
dir := t.TempDir()
files := map[string]string{envRunsCap: "1", envStepBound: "2s"}
env := map[string]string{}
for name, content := range files {
path := filepath.Join(dir, name)
if err := os.WriteFile(path, []byte(content), 0o600); err != nil {
t.Fatal(err)
}
env[name] = path
}
broker := filepath.Join(dir, "broker")
raw, _ := json.Marshal(process.Account{URL: url, Node: "n1", Module: module, User: "runner", Password: "x"})
if err := os.WriteFile(broker, raw, 0o600); err != nil {
t.Fatal(err)
}
env[process.BrokerFileEnv] = broker
logs := &syncBuffer{}
start := func() func() {
runCtx, stop := context.WithCancel(ctx)
done := make(chan error, 1)
go func() { done <- run(runCtx, func(k string) string { return env[k] }, logs) }()
return func() { stop(); <-done }
}
stop := start()
defer func() { stop() }()
pipelines, err := js.KeyValue(ctx, module+"_pipelines")
if err != nil {
t.Fatal(err)
}
runsKV, err := js.KeyValue(ctx, module+"_"+TestRunsState)
if err != nil {
t.Fatal(err)
}
firstViews, err := js.KeyValue(ctx, module+"_"+views.StatusState)
if err != nil {
t.Fatal(err)
}
// The seat-holders view's first view is read before any pipeline is placed, so a seat is judged from it (A-466y).
waitFor(t, ctx, logs, func() bool {
e, err := firstViews.Get(ctx, views.StatusKey("assigner", "seat-holders"))
var s views.Status
return err == nil && json.Unmarshal(e.Value(), &s) == nil && !s.Answered.IsZero()
})
takeIn := func(module, commit, fp string, source, rev int64) {
taken, _ := json.Marshal(catalog.TakeInTaken{Key: "m." + commit, Kind: "taken", Branch: "main", Source: source, Revision: rev,
Entries: []catalog.TakeInEntry{{Module: module, Commit: commit, Fingerprint: fp}}})
if _, err := js.Publish(ctx, "mesh.mod.mesh-delivery-indexer.event.take-in.taken", taken); err != nil {
t.Fatal(err)
}
}
placed := func(key string) seat.Pipeline {
var p seat.Pipeline
waitFor(t, ctx, logs, func() bool { return readPipeline(ctx, pipelines, key, &p) && len(p.Steps) > 1 })
return p
}
read := func(key string) seat.Pipeline {
var p seat.Pipeline
readPipeline(ctx, pipelines, key, &p)
return p
}
step := func(p seat.Pipeline, artifact, name string) seat.StepResult {
for _, s := range p.Steps {
if s.Artifact == artifact && s.Step == name {
return s
}
}
return seat.StepResult{}
}
runOf := func(key string) (pipeline.Run, bool) {
e, err := runsKV.Get(ctx, key)
var r pipeline.Run
return r, err == nil && json.Unmarshal(e.Value(), &r) == nil
}
runKeys := func(candidate string) []string {
ks, _ := runsKV.Keys(ctx)
var out []string
for _, k := range ks {
if !pipeline.IsRunBound(k) && strings.HasPrefix(k, candidate+".") {
out = append(out, k)
}
}
return out
}
runOfStep := func(key, artifact, name string) (string, pipeline.Run) {
var run string
var r pipeline.Run
waitFor(t, ctx, logs, func() bool {
s := step(read(key), artifact, name)
if len(s.Shared) == 0 {
return false
}
run = s.Shared[0].Run
got, ok := runOf(run)
r = got
return ok && r.Ask != ""
})
return run, r
}
publish := func(subject string, body any) {
raw, _ := json.Marshal(body)
if _, err := js.Publish(ctx, subject, raw); err != nil {
t.Fatal(err)
}
}
taken := func(ask string) {
publish(nodebuildgo.SubjectAskTaken("n1"), nodebuildgo.AskTaken{Ask: ask, Asker: module, Node: "n1", At: time.Now()})
}
endAsk := func(key, ask, name, outcome string, tests *nodebuildgo.TestCounts) {
now := time.Now()
publish(nodebuildgo.SubjectStepEnded("n1"), nodebuildgo.StepEnded{ID: ask, Ask: ask, Asker: module, Pipeline: key, Module: "app", Commit: "c1",
Fingerprint: "src2:aa", Step: name, Node: "n1", Outcome: outcome, Tests: tests, At: now, Ended: &now})
}
passBuild := func(key, module, commit, fp string) {
ask := step(read(key), "", seat.StepResultStepBuild).Ask
publish("mesh.seat.mesh-builds.event.step-ended.n1", builds.StepEnded{ID: ask, Pipeline: key, Step: "build", Node: "n1", Outcome: "passed",
Entries: []builds.BuildEntry{{Module: module, Commit: commit, Fingerprint: fp}}})
}
call := func(verb string, in, out any) string {
var reply struct {
Result json.RawMessage `json:"result"`
Error string `json:"error"`
}
waitFor(t, ctx, logs, func() bool {
m, err := nc.Request("mesh.seat.mesh-pipeline-runner.call."+verb+".agent~dev", mustJSON(in), 2*time.Second)
reply.Error = ""
return err == nil && json.Unmarshal(m.Data, &reply) == nil && !strings.Contains(reply.Error, "not yet read")
})
if out != nil && reply.Error == "" {
_ = json.Unmarshal(reply.Result, out)
}
return reply.Error
}
// One unit run and one integration run for both artifacts (§724), each read by both, waiting for a build node until its
// ask is taken (A-469b), its holder present and nothing failing it (A-466y).
const p3 = "main.3.app"
takeIn("app", "c1", "src2:aa", 3, 1)
passBuild(p3, "app", "c1", "src2:aa")
unitRun, unit := runOfStep(p3, "app:program", "unit")
integRun, integ := runOfStep(p3, "app:program", "integration")
if got := runKeys("main.1"); len(got) != 2 || len(unit.Readers) != 2 || len(integ.Readers) != 2 {
t.Fatalf("runs %v, unit readers %+v, integration readers %+v; want one run per level read by both artifacts", got, unit.Readers, integ.Readers)
}
if s := step(read(p3), "app:tools", "unit"); s.Outcome != seat.StepResultOutcomeWaitingForABuildNode || s.Ask != "" || s.Shared[0].Ask != unit.Ask {
t.Fatalf("the tools' unit step = %+v; want it waiting for a build node, reading the program's run", s)
}
// A runner restarted during a run takes it up again by its ask (§725): the run's end, heard after the restart, ends both.
taken(unit.Ask)
waitFor(t, ctx, logs, func() bool { r, _ := runOf(unitRun); return r.Node == "n1" })
// Its clock holds the run's ask (A-470n).
waitFor(t, ctx, logs, func() bool {
e, err := runsKV.Get(ctx, pipeline.BoundPrefix+unitRun)
return err == nil && strings.Contains(string(e.Value()), `"ask":"`+unit.Ask+`"`)
})
stop()
stop = start()
// It keeps saying its progress past its bound and is not ended (§725, §720).
// Each progress is heard before the next is said: the run's clock is written again (its bound key's revision rises).
boundRev := func() uint64 {
e, err := runsKV.Get(ctx, pipeline.BoundPrefix+unitRun)
if err != nil {
return 0
}
return e.Revision()
}
for at := time.Now(); time.Since(at) < 3*time.Second; {
before := boundRev()
publish(nodebuildgo.SubjectStepProgress("n1"), nodebuildgo.StepProgress{Ask: unit.Ask, Asker: module, Phase: "run", At: time.Now()})
waitFor(t, ctx, logs, func() bool { return boundRev() > before })
}
if r, _ := runOf(unitRun); r.Ended != nil {
t.Fatalf("a run saying its progress past its bound ended: %+v", r)
}
// A failing test fails once and is counted once (§726).
endAsk(p3, unit.Ask, "unit", "failed", &nodebuildgo.TestCounts{Unit: 5})
taken(integ.Ask)
endAsk(p3, integ.Ask, "integration", "failed", &nodebuildgo.TestCounts{Integration: 2})
waitFor(t, ctx, logs, func() bool { return len(ended(p3)) == 1 })
p := read(p3)
for _, a := range []string{"app:program", "app:tools"} {
if s := step(p, a, "unit"); s.Outcome != seat.StepResultOutcomeFailed || len(s.Shared) == 0 || s.Shared[0].Run != unitRun {
t.Errorf("%s's unit step = %+v; want failed with the run in shared", a, s)
}
}
for _, k := range []string{unitRun, integRun} {
if r, _ := runOf(k); r.Ended == nil || r.Outcome != seat.StepResultOutcomeFailed {
t.Errorf("the run %s at its end = %+v; want it ended failed", k, r)
}
}
if e := ended(p3)[0]; e.Outcome != seat.PipelineEndedOutcomeFailed || e.Tests == nil || e.Tests.Unit != 5 || e.Tests.Integration != 2 {
t.Fatalf("pipeline-ended = %+v; want failed, the tests counted once", e)
}
// An accepted step does not move; a rerun of the program's unit step that passes moves the tools' to passed, and the
// pipeline says pipeline-ended again (§727, A-470d).
if e := call(seat.VerbAccept, seat.AcceptInput{Pipeline: p3, Step: "integration", Artifact: "app:program", Why: "flaky"}, nil); e != "" {
t.Fatalf("accept: %s", e)
}
if e := call(seat.VerbRerun, seat.RerunInput{Pipeline: p3, Step: "unit", Artifact: "app:program", Why: "fixed"}, nil); e != "" {
t.Fatalf("rerun: %s", e)
}
var again pipeline.Run
waitFor(t, ctx, logs, func() bool { r, ok := runOf(unitRun); again = r; return ok && r.Ended == nil && r.Ask != unit.Ask })
taken(again.Ask)
endAsk(p3, again.Ask, "unit", "passed", &nodebuildgo.TestCounts{Unit: 5})
if e := call(seat.VerbRerun, seat.RerunInput{Pipeline: p3, Step: "integration", Artifact: "app:tools", Why: "fixed"}, nil); e != "" {
t.Fatalf("rerun: %s", e)
}
var integAgain pipeline.Run
waitFor(t, ctx, logs, func() bool {
r, ok := runOf(integRun)
integAgain = r
return ok && r.Ended == nil && r.Ask != integ.Ask
})
taken(integAgain.Ask)
endAsk(p3, integAgain.Ask, "integration", "passed", nil)
waitFor(t, ctx, logs, func() bool {
e := ended(p3)
return len(e) >= 2 && e[len(e)-1].Outcome == seat.PipelineEndedOutcomePassed
})
p = read(p3)
if s := step(p, "app:tools", "unit"); s.Outcome != seat.StepResultOutcomePassed || !s.Rerun {
t.Errorf("the tools' unit step = %+v; want moved to passed, marked a rerun", s)
}
if s := step(p, "app:program", "integration"); s.Outcome != seat.StepResultOutcomeAccepted {
t.Errorf("the accepted step = %+v; want it accepted still", s)
}
for _, k := range []string{unitRun, integRun} {
if r, _ := runOf(k); r.Ended == nil || r.Outcome != seat.StepResultOutcomePassed {
t.Errorf("the run %s after its rerun = %+v; want it ended passed", k, r)
}
}
if e := ended(p3); e[len(e)-1].EndCount <= e[0].EndCount {
t.Errorf("pipeline-ended counts %d then %d; want a higher end count", e[0].EndCount, e[len(e)-1].EndCount)
}
// A second revision with the same digests asks its own runs, so a failed test runs again (§724).
revision.Store(2)
publish(catalog.SubjectCatalogRevision("main"), catalog.CatalogRevisionEvent{V: 1, Revision: 2, Kind: "trunk", Branch: "main", Source: 4})
const p4, p5 = "main.4.app", "main.5.app"
takeIn("app", "c1", "src2:aa", 4, 2)
placed(p4)
run4, r4 := runOfStep(p4, "app:program", "integration")
if !strings.HasPrefix(run4, "main.2.") || r4.Ask == integ.Ask {
t.Fatalf("revision 2's integration run %s (%s); want its own", run4, r4.Ask)
}
// A replaced reader leaves the ask to the other readers (§726): a second pipeline of the same candidate and digest reads
// the run, the first is cancelled and leaves it, and the run's ask is not dropped.
takeIn("app", "c1", "src2:aa", 5, 2)
placed(p5)
waitFor(t, ctx, logs, func() bool { r, _ := runOf(run4); return len(r.Readers) == 4 })
if e := call(seat.VerbCancel, seat.CancelInput{Pipeline: p4, Why: "replaced"}, nil); e != "" {
t.Fatalf("cancel: %s", e)
}
waitFor(t, ctx, logs, func() bool {
r, _ := runOf(run4)
return len(r.Readers) == 2 && r.Readers[0].Pipeline == p5 && r.Readers[1].Pipeline == p5
})
if r, _ := runOf(run4); r.Ended != nil || r.Ask != r4.Ask {
t.Fatalf("the run of the replaced readers = %+v; want it running under its ask", r)
}
mu.Lock()
dropped := append([]string(nil), drops...)
mu.Unlock()
if len(dropped) != 0 {
t.Fatalf("drops asked %v; want none while a reader is left\n%s", dropped, logs.String())
}
// A taken ask silent for its bound ends could not run with its readers, its ask dropped (§725, §720).
taken(r4.Ask)
waitFor(t, ctx, logs, func() bool {
return step(read(p5), "app:tools", "integration").Outcome == seat.StepResultOutcomeCouldNotRun &&
step(read(p5), "app:program", "integration").Outcome == seat.StepResultOutcomeCouldNotRun
})
if r, _ := runOf(run4); r.Ended == nil || r.Outcome != seat.StepResultOutcomeCouldNotRun || !strings.Contains(r.Said, "test-step-bound") {
t.Errorf("the silent run = %+v; want it ended could not run, naming its bound", r)
}
waitFor(t, ctx, logs, func() bool {
mu.Lock()
defer mu.Unlock()
return len(drops) == 1 && strings.Contains(drops[0], r4.Ask)
})
// A seat the seat-holders view names no holder for ends the pipeline failed at once, naming it, its other steps not
// asked (§535, §647; A-470g, A-470h).
const web = "main.5.web"
takeIn("web", "w1", "src2:ww", 5, 2)
waitFor(t, ctx, logs, func() bool { return len(ended(web)) == 1 })
if e := ended(web)[0]; e.Outcome != seat.PipelineEndedOutcomeFailed || e.Why != "the seat node-build-node has no holder: the seat-holders view names none" {
t.Fatalf("pipeline-ended = %+v; want failed at once naming the seat", e)
}
// The steps of the seat with no holder end could not run, a bypassed step stays bypassed, every other ends not asked,
// and none is asked (A-470h).
for _, s := range read(web).Steps {
want := seat.StepResultOutcomeNotAsked
switch {
case s.Status == seat.StepResultStatusBypass:
want = seat.StepResultOutcomeBypassed
case s.Seat == "node-build-node":
want = seat.StepResultOutcomeCouldNotRun
}
if s.Outcome != want || s.Ask != "" {
t.Errorf("the step %s %s of the pipeline with no holder = %s (ask %q); want %s", s.Artifact, s.Step, s.Outcome, s.Ask, want)
}
}
// test-runs is answered by the process, its fill against test-runs-cap-mib (A-470i), each run's packages from its output
// object; test-runs-drop deletes the key and its object (§728).
var runs seat.TestRunsAnswer
if e := call(seat.VerbTestRuns, seat.TestRunsInput{Candidate: "main.1"}, &runs); e != "" || len(runs.Runs) != 2 || runs.Fill.Cap != 1<<20 || runs.Fill.Store != TestRunsState {
t.Fatalf("test-runs = %+v (%s); want main.1's two runs, the fill against 1 MiB", runs, e)
}
objects, err := js.ObjectStore(ctx, catalogue.BusName(module, catalogue.StateObjectsName(TestRunsState)))
if err != nil {
t.Fatal(err)
}
if _, err := objects.GetInfo(ctx, unitRun); err != nil {
t.Fatalf("the unit run's output object: %v", err)
}
var drop seat.TestRunsDropAnswer
if e := call(seat.VerbTestRunsDrop, seat.TestRunsDropInput{Key: unitRun, Why: "test 109"}, &drop); e != "" || drop.Run.Key != unitRun {
t.Fatalf("test-runs-drop = %+v (%s)", drop, e)
}
if _, ok := runOf(unitRun); ok {
t.Error("the dropped run's key is kept")
}
if _, err := objects.GetInfo(ctx, unitRun); err == nil {
t.Error("the dropped run's output object is kept")
}
// At the cap a step ends could not run, naming the fill (§725, A-469d).
pad := make([]byte, 600<<10)
for _, k := range []string{"pad.a", "pad.b"} {
if _, err := runsKV.Put(ctx, k, pad); err != nil {
t.Fatal(err)
}
}
revision.Store(3)
publish(catalog.SubjectCatalogRevision("main"), catalog.CatalogRevisionEvent{V: 1, Revision: 3, Kind: "trunk", Branch: "main", Source: 5})
const p6 = "main.6.app"
takeIn("app", "c1", "src2:aa", 6, 3)
waitFor(t, ctx, logs, func() bool {
s := step(read(p6), "app:program", "unit")
return s.Outcome == seat.StepResultOutcomeCouldNotRun && strings.Contains(s.Why, "test-runs-cap-mib")
})
}
func mustJSON(v any) []byte {
raw, _ := json.Marshal(v)
return raw
}