package index import ( "context" "encoding/json" "errors" "fmt" "strings" "testing" "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" ) // A-190: a kept call is asked again only while what it serves still stands; each of the indexer's four has its predicate. func TestKeptCallsOpenWhileTheirAskServesSomething(t *testing.T) { ctx := context.Background() t.Run("the take-in of a commit is pending while an entry names it or the take-in is made", func(t *testing.T) { pending := newMem() val, _ := encodePending(Pending{Seq: 1, Ref: &PendingRef{Repository: "novox/r", Merge: "c1"}}) if err := pending.Create(ctx, "m.1", val); err != nil { t.Fatal(err) } ix := &Indexer{Pending: pending} cancelled, cancel := context.WithCancel(ctx) cancel() for _, c := range []struct { name string ctx context.Context repo, commit string want bool }{ {"held", ctx, "novox/r", "c1", true}, {"taken in or dropped", ctx, "novox/r", "c2", false}, {"in hand", forTakeIn(ctx, "novox/r", "c2"), "novox/r", "c2", true}, {"in hand for another commit", forTakeIn(ctx, "novox/r", "c3"), "novox/r", "c2", false}, {"the take-in's context ended", cancelled, "novox/r", "c1", false}, } { if got, err := ix.TakeInPending(c.ctx, c.repo, c.commit); err != nil || got != c.want { t.Errorf("%s: pending = %v, %v, want %v", c.name, got, err, c.want) } } }) t.Run("the seed's candidate and the versions' module are in the newest trunk revision", func(t *testing.T) { ix := &Indexer{Revisions: newMemObjects(1 << 20)} keep := func(n int64, fp string) { rev, objects, err := CatalogRevisionOf(meshcatalog.CatalogRevision{Revision: n, Kind: "trunk"}, map[string]meshcatalog.CatalogEntry{"avahi": {Module: "avahi", Fp: fp, Manifest: map[string]any{}}}) if err == nil { err = KeepRevision(ctx, ix.Revisions, rev, objects) } if err != nil { t.Fatal(err) } } keep(1, "fp1") if held, err := ix.SeedEntryHeld(ctx, "avahi", "fp1"); err != nil || !held { t.Errorf("the entry at its fingerprint: %v, %v", held, err) } if in, err := ix.ModuleInNewestView(ctx, "avahi"); err != nil || !in { t.Errorf("the module in the view: %v, %v", in, err) } if in, _ := ix.ModuleInNewestView(ctx, "gone"); in { t.Error("a module the view does not hold is in it") } keep(2, "fp2") if held, _ := ix.SeedEntryHeld(ctx, "avahi", "fp1"); held { t.Error("a candidate the newest revision replaced is still held") } }) t.Run("a branch is watched while a registration names it", func(t *testing.T) { g := newRegRig() ix := &Indexer{Registry: g.r} raw, _ := json.Marshal(meshcatalog.Registration{Module: "avahi", Branches: []string{"main", "feat"}}) if err := g.r.Registrations.Create(ctx, "avahi", raw); err != nil { t.Fatal(err) } if w, err := ix.BranchWatched(ctx, TrunkBranch); err != nil || !w { t.Errorf("the trunk: %v, %v", w, err) } if w, _ := ix.BranchWatched(ctx, "feat"); !w { t.Error("a branch a registration names is not watched") } if w, _ := ix.BranchWatched(ctx, "other"); w { t.Error("a branch no registration names is watched") } }) } // A-190: a call that ends with its ask closed is not said unanswered: no finding, and the fill and the seed go on. func TestAClosedAskIsNotUnanswered(t *testing.T) { ctx := context.Background() closed := fmt.Errorf("steps: %w", ErrAskClosed) ix := &Indexer{Findings: newFindings(), Heard: newMem(), Revisions: newMemObjects(1 << 20), Versions: newMem()} rev, objects, _ := CatalogRevisionOf(meshcatalog.CatalogRevision{Revision: 1, Kind: "trunk"}, map[string]meshcatalog.CatalogEntry{"avahi": {Module: "avahi", Fp: "fp", Manifest: map[string]any{}, Artifacts: []meshcatalog.Artifact{{Ref: "avahi:program", Language: "go"}}}}) 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"}}}} if _, err := ix.SeedModulesFrom(ctx, defs, func(context.Context, string, nodebuildgo.StepsInput) (nodebuildgo.StepsAnswer, error) { return nodebuildgo.StepsAnswer{}, closed }); err != nil || len(ix.stepsSince) != 0 { t.Errorf("a closed steps ask counted unanswered: %v %v", err, ix.stepsSince) } if err := ix.FillVersions(ctx, func(context.Context, string, string) (BuilderVersionsAnswer, error) { return BuilderVersionsAnswer{}, fmt.Errorf("builder_versions: %w", ErrAskClosed) }); errors.Is(err, ErrAskClosed) || (err != nil && strings.Contains(err.Error(), "is not answered")) { t.Errorf("a closed versions ask is unanswered: %v", err) } }