A re-pin that left the fingerprint as it was left the build made against the older pin as the one the mesh runs. The version line's fingerprint now takes the pins, so a re-pin moves the importer, which becomes a mover built against the release. An accepted series' older version no longer stands over a newer release. A re-pin that fails returns its error before the heard artifacts are forgotten, and a package-published heard again for a released version re-pins, so the redelivery recovers it. The release path and the seed's pins carry tests that fail without them (review round 2). Builds: design 47 H H-A-165, H-A-167, H-A-161
217 lines
11 KiB
Go
217 lines
11 KiB
Go
package index
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"strings"
|
|
"testing"
|
|
"time"
|
|
|
|
mcc "git.novox.be/novox/mesh-contracts/health-and-repair/go/clients/meshconditionsclient"
|
|
"git.novox.be/novox/mesh-delivery/modules/mesh-delivery-contracts/go/seats/meshcatalog"
|
|
"git.novox.be/novox/mesh-delivery/modules/mesh-delivery-contracts/go/seats/nodebuildgo"
|
|
"git.novox.be/novox/mesh-sdk/go/seatdef"
|
|
)
|
|
|
|
// Design 47 G §704: the seed asks `steps` of the build seat whose `build` rule matches each artifact, with {module,
|
|
// artifact, fingerprint, fetch} from the newest trunk entry; a seat that does not answer holds the seed and, after five
|
|
// minutes, is the finding call-unanswered (scope call, id <seat>.steps), cleared when it answers.
|
|
func TestTheSeedAsksStepsOfTheBuildSeatsOfTheTrunkEntries(t *testing.T) {
|
|
ctx := context.Background()
|
|
now := time.Date(2026, 11, 1, 3, 0, 0, 0, time.UTC)
|
|
w := newFindings()
|
|
ix := &Indexer{Module: testSelf, Findings: w, Heard: newMem(), Revisions: newMemObjects(1 << 20), Now: func() time.Time { return now }}
|
|
fp := "src2:" + strings.Repeat("a", 64)
|
|
entries := map[string]meshcatalog.CatalogEntry{"avahi": {Module: "avahi", Repository: "novox/r", Commit: "c1", Path: "mods/avahi", Fp: fp, Manifest: map[string]any{},
|
|
Artifacts: []meshcatalog.Artifact{{Ref: "avahi:program", Language: "go"}, {Ref: "avahi:image", Language: "go", Kind: "image"}},
|
|
Packages: map[string]string{"git.novox.be/novox/mesh-sdk": "v0.1.9", "git.novox.be/novox/mesh-contracts/go": ""}, // the second none released (H-A-161)
|
|
Inputs: &meshcatalog.EntryInputs{Paths: map[string][]string{"program": {"cmd"}}}}}
|
|
rev, objects, err := CatalogRevisionOf(meshcatalog.CatalogRevision{Revision: 3, Kind: "trunk"}, entries)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := KeepRevision(ctx, ix.Revisions, rev, objects); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defs := map[string]seatdef.Definition{
|
|
"node-build-go": {Acts: []seatdef.ActingRule{{Step: seatdef.StepBuild, On: "go"}}},
|
|
"node-build-image": {Acts: []seatdef.ActingRule{{Step: seatdef.StepBuild, On: seatdef.OnKindImage}}},
|
|
}
|
|
// the image artifact is built by both rules: the language's and the kind's
|
|
if _, err := ix.SeedModulesFrom(ctx, defs, nil); err == nil || !strings.Contains(err.Error(), "each build") {
|
|
t.Fatalf("two seats building one artifact: %v", err)
|
|
}
|
|
e := entries["avahi"]
|
|
e.Artifacts[1].Language = "dockerfile"
|
|
entries["avahi"] = e
|
|
rev, objects, _ = CatalogRevisionOf(meshcatalog.CatalogRevision{Revision: 4, Kind: "trunk"}, entries)
|
|
if err := KeepRevision(ctx, ix.Revisions, rev, objects); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
var got []nodebuildgo.StepsInput
|
|
goUp := false
|
|
call := func(_ context.Context, seat string, in nodebuildgo.StepsInput) (nodebuildgo.StepsAnswer, error) {
|
|
got = append(got, in)
|
|
if seat == "node-build-go" && !goUp {
|
|
return nodebuildgo.StepsAnswer{}, errors.New("no responders")
|
|
}
|
|
return nodebuildgo.StepsAnswer{Steps: []nodebuildgo.DetectedStep{{Step: "unit"}}}, nil
|
|
}
|
|
mods, err := ix.SeedModulesFrom(ctx, defs, call)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if len(mods) != 1 || mods[0].Module != "avahi" || mods[0].Origin != "novox/r" || mods[0].Path != "mods/avahi/module.json" || len(mods[0].Artifacts) != 2 {
|
|
t.Fatalf("the seed's modules: %+v", mods)
|
|
}
|
|
if a := mods[0].Artifacts[0]; a.Answered || a.Seat != "node-build-go" {
|
|
t.Errorf("the go artifact is %+v, want unanswered by node-build-go", a)
|
|
}
|
|
if a := mods[0].Artifacts[1]; !a.Answered || a.Seat != "node-build-image" || len(a.Steps) != 1 {
|
|
t.Errorf("the image artifact is %+v", a)
|
|
}
|
|
in := got[0]
|
|
if in.Module != "avahi" || in.Artifact != "avahi.program" || in.Fingerprint != fp || in.Fetch == nil || in.Fetch.Repository != "novox/r" || in.Fetch.Commit != "c1" || in.Fetch.Dir != "mods/avahi" || len(in.Fetch.Paths) != 1 || in.Fetch.Packages["git.novox.be/novox/mesh-sdk"] != "v0.1.9" {
|
|
t.Errorf("the steps input is %+v", in)
|
|
}
|
|
if _, pinned := in.Fetch.Packages["git.novox.be/novox/mesh-contracts/go"]; pinned {
|
|
t.Errorf("a package kept with no version is pinned in the fetch: %v", in.Fetch.Packages)
|
|
}
|
|
if len(w.Held()) != 0 {
|
|
t.Fatal("a call unanswered for no time wrote its finding")
|
|
}
|
|
now = now.Add(5 * time.Minute)
|
|
ix = &Indexer{Module: testSelf, Findings: w, Heard: ix.Heard, Revisions: ix.Revisions, Now: func() time.Time { return now }} // a restart keeps the time
|
|
if _, err := ix.SeedModulesFrom(ctx, defs, call); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if h := w.Held(); len(h) != 1 || h[0].Scope != mcc.ScopeCall || h[0].ID != "node-build-go.steps" || h[0].Kind != mcc.KindCallUnanswered {
|
|
t.Fatalf("the findings after five minutes: %+v", h)
|
|
}
|
|
goUp = true
|
|
if _, err := ix.SeedModulesFrom(ctx, defs, call); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if len(w.Held()) != 0 {
|
|
t.Errorf("the finding stands after the seat answered: %+v", w.Held())
|
|
}
|
|
}
|
|
|
|
// Design 47 G A-324, A-329: an archive and an upstream artifact, which the builder packs or fetches, are called of no build
|
|
// seat and seeded with lint, unit and integration bypass; a module with an artifact no build seat builds is left out of
|
|
// the seed, named in its ask, with the finding seed-left-out naming the artifact and its language, never the whole seed;
|
|
// the finding clears only once a build seat builds every artifact of it, or once it left the catalogue.
|
|
func TestTheSeedBypassesWhatTheBuilderPacksAndLeavesOutAModuleNoSeatBuilds(t *testing.T) {
|
|
ctx := context.Background()
|
|
w := newFindings()
|
|
ix := &Indexer{Module: testSelf, Findings: w, Heard: newMem(), Revisions: newMemObjects(1 << 20), Now: time.Now}
|
|
entries := map[string]meshcatalog.CatalogEntry{
|
|
"a": {Module: "a", Repository: "novox/a", Path: "a", Manifest: map[string]any{}, Artifacts: []meshcatalog.Artifact{{Ref: "a:files", Kind: "archive"}}},
|
|
"nats": {Module: "nats", Repository: "novox/n", Path: "n", Manifest: map[string]any{}, Artifacts: []meshcatalog.Artifact{{Ref: "nats:server", Kind: "upstream"}, {Ref: "nats:tools", Language: "go"}}},
|
|
"odd": {Module: "odd", Repository: "novox/o", Path: "o", Manifest: map[string]any{}, Artifacts: []meshcatalog.Artifact{{Ref: "odd:web", Language: "rust"}}},
|
|
}
|
|
keep := func(n int64) {
|
|
rev, objects, err := CatalogRevisionOf(meshcatalog.CatalogRevision{Revision: n, Kind: "trunk"}, entries)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := KeepRevision(ctx, ix.Revisions, rev, objects); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
keep(1)
|
|
defs := map[string]seatdef.Definition{"node-build-go": {Acts: []seatdef.ActingRule{{Step: seatdef.StepBuild, On: "go"}}}}
|
|
var called []string
|
|
call := func(_ context.Context, seat string, in nodebuildgo.StepsInput) (nodebuildgo.StepsAnswer, error) {
|
|
called = append(called, seat+" "+in.Artifact)
|
|
return nodebuildgo.StepsAnswer{Steps: []nodebuildgo.DetectedStep{{Step: "unit"}}}, nil
|
|
}
|
|
mods, err := ix.SeedModulesFrom(ctx, defs, call)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if strings.Join(called, "|") != "node-build-go nats.tools" {
|
|
t.Errorf("steps was called %q, want only of the go artifact", called)
|
|
}
|
|
if h := w.Held(); len(h) != 1 || h[0].Kind != SeedLeftOutKind || h[0].Scope != mcc.ScopeModule || h[0].ID != "odd" || !strings.Contains(h[0].Summary, "odd:web (language rust)") {
|
|
t.Fatalf("the findings: %+v", h)
|
|
}
|
|
seed, err := newRegRig().r.ComposeSeed(mods)
|
|
if err != nil || len(seed.Unanswered) != 0 || len(seed.Registrations) != 2 || len(seed.Left) != 1 || !strings.Contains(seed.Left[0], "odd (no build seat builds odd:web (language rust))") {
|
|
t.Fatalf("the seed: %+v, %v", seed, err)
|
|
}
|
|
bypass := meshcatalog.StepStatuses{Lint: "bypass", Unit: "bypass", Integration: "bypass"}
|
|
if a := seed.Registrations[0].Policy.Artifacts["files"]; seed.Registrations[0].Module != "a" || a != bypass {
|
|
t.Errorf("the archive's statuses are %+v in %s, want all three bypass", a, seed.Registrations[0].Module)
|
|
}
|
|
if p := seed.Registrations[1].Policy.Artifacts; p["server"] != bypass || p["tools"] != (meshcatalog.StepStatuses{Lint: "bypass", Integration: "bypass"}) {
|
|
t.Errorf("nats's statuses are %+v", p)
|
|
}
|
|
// A seed again with the language still unserved keeps the finding; once a seat builds it, it clears.
|
|
if _, err := ix.SeedModulesFrom(ctx, defs, call); err != nil || len(w.Held()) != 1 {
|
|
t.Fatalf("a second seed: %v, %+v", err, w.Held())
|
|
}
|
|
defs["node-build-rust"] = seatdef.Definition{Acts: []seatdef.ActingRule{{Step: seatdef.StepBuild, On: "rust"}}}
|
|
if _, err := ix.SeedModulesFrom(ctx, defs, call); err != nil || len(w.Held()) != 0 {
|
|
t.Fatalf("the seed with a rust build seat: %v, the findings %+v", err, w.Held())
|
|
}
|
|
// A module left out that leaves the catalogue clears its finding too.
|
|
delete(defs, "node-build-rust")
|
|
if _, err := ix.SeedModulesFrom(ctx, defs, call); err != nil || len(w.Held()) != 1 {
|
|
t.Fatalf("the seed without the rust seat again: %v, %+v", err, w.Held())
|
|
}
|
|
delete(entries, "odd")
|
|
keep(2)
|
|
if _, err := ix.SeedModulesFrom(ctx, defs, call); err != nil || len(w.Held()) != 0 {
|
|
t.Fatalf("the seed after odd left the catalogue: %v, the findings %+v", err, w.Held())
|
|
}
|
|
}
|
|
|
|
// Lead answer A-392: a seat that did not answer steps is called once in a seed; its later artifacts stay unanswered
|
|
// without a call, and an answering seat is called per artifact.
|
|
func TestTheSeedCallsAnUnansweringSeatOnce(t *testing.T) {
|
|
for _, tc := range []struct {
|
|
name string
|
|
up bool
|
|
wantCalls int
|
|
}{{"a seat that does not answer", false, 1}, {"a seat that answers", true, 3}} {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
ctx := context.Background()
|
|
ix := &Indexer{Module: testSelf, Findings: newFindings(), Heard: newMem(), Revisions: newMemObjects(1 << 20), Now: time.Now}
|
|
entries := map[string]meshcatalog.CatalogEntry{}
|
|
for _, m := range []string{"a", "b", "c"} {
|
|
entries[m] = meshcatalog.CatalogEntry{Module: m, Repository: "novox/r", Commit: "c1", Path: "mods/" + m, Fp: "src2:" + strings.Repeat("a", 64),
|
|
Manifest: map[string]any{}, Artifacts: []meshcatalog.Artifact{{Ref: m + ":program", Language: "go"}}}
|
|
}
|
|
rev, objects, err := CatalogRevisionOf(meshcatalog.CatalogRevision{Revision: 1, Kind: "trunk"}, entries)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := KeepRevision(ctx, ix.Revisions, rev, objects); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defs := map[string]seatdef.Definition{"node-build-go": {Acts: []seatdef.ActingRule{{Step: seatdef.StepBuild, On: "go"}}}}
|
|
calls := 0
|
|
call := func(context.Context, string, nodebuildgo.StepsInput) (nodebuildgo.StepsAnswer, error) {
|
|
calls++
|
|
if !tc.up {
|
|
return nodebuildgo.StepsAnswer{}, errors.New("no responders")
|
|
}
|
|
return nodebuildgo.StepsAnswer{}, nil
|
|
}
|
|
mods, err := ix.SeedModulesFrom(ctx, defs, call)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if calls != tc.wantCalls {
|
|
t.Errorf("calls = %d, want %d", calls, tc.wantCalls)
|
|
}
|
|
for _, m := range mods {
|
|
if a := m.Artifacts[0]; a.Answered != tc.up || a.Seat != "node-build-go" {
|
|
t.Errorf("%s: %+v", m.Module, a)
|
|
}
|
|
}
|
|
})
|
|
}
|
|
}
|