mesh-delivery/modules/mesh-delivery-checker/internal/check/examiner_test.go

package check

import (
	"context"
	"encoding/json"
	"fmt"
	"os"
	"path/filepath"
	"strings"
	"sync"
	"testing"
	"time"

	"git.novox.be/novox/mesh-sdk/go/delivery"
	"git.novox.be/novox/mesh-sdk/go/delivery/buildrun"
)

// captured reads a result the build module's own code marshalled (testdata/captured/README).
func captured[T any](t testing.TB, name string) T {
	t.Helper()
	raw, err := os.ReadFile(filepath.Join("testdata", "captured", name+".json"))
	if err != nil {
		t.Fatal(err)
	}
	var v T
	if err := json.Unmarshal(raw, &v); err != nil {
		t.Fatal(err)
	}
	return v
}

type stepCall struct {
	module, node, tool string
	args               map[string]any
}

// fakeSteps stands for the build modules: a handler for each tool answers what the module's code answers.
type fakeSteps struct {
	mu       sync.Mutex
	calls    []stepCall
	handlers map[string]func(c stepCall) (any, error)
}

func (f *fakeSteps) Run(_ context.Context, module, node, tool string, args map[string]any) (json.RawMessage, error) {
	c := stepCall{module, node, tool, args}
	f.mu.Lock()
	f.calls = append(f.calls, c)
	h := f.handlers[tool]
	f.mu.Unlock()
	if h == nil {
		return nil, fmt.Errorf("the fake build module has no tool %s", tool)
	}
	v, err := h(c)
	if err != nil {
		return nil, err
	}
	return json.Marshal(v)
}

func (f *fakeSteps) tool(name string) []stepCall {
	f.mu.Lock()
	defer f.mu.Unlock()
	var out []stepCall
	for _, c := range f.calls {
		if strings.HasSuffix(c.tool, "_"+name) {
			out = append(out, c)
		}
	}
	return out
}

type entries []delivery.NodeToolchain

func (e entries) Entries(language string) []delivery.NodeToolchain {
	var out []delivery.NodeToolchain
	for _, x := range e {
		if x.Language == language {
			out = append(out, x)
		}
	}
	return out
}

type langs map[string][]string

func (l langs) BuildModules(repository string) []string {
	if m, ok := l[repository]; ok {
		return m
	}
	return []string{buildrun.GoBuildModule}
}

func goEntries(nodes ...string) entries {
	var e entries
	for _, n := range nodes {
		e = append(e, delivery.NodeToolchain{Node: n, Toolchain: delivery.Toolchain{Language: "go", Version: "go1.27.1", Recipe: "7"}})
		e = append(e, delivery.NodeToolchain{Node: n, Toolchain: delivery.Toolchain{Language: "typescript", Version: "node24", Recipe: "3"}})
	}
	return e
}

const digC = "cc33cc33cc33cc33cc33cc33cc33cc33cc33cc33cc33cc33cc33cc33cc33cc33"
const digD = "dd44dd44dd44dd44dd44dd44dd44dd44dd44dd44dd44dd44dd44dd44dd44dd44"

type bench struct {
	ex     *Examiner
	steps  *fakeSteps
	kept   *memKV
	prev   *memKV
	fetch  Fetched
	digest map[string]Digested // by level
	test   func(c stepCall) (any, error)
}

// newBench is an examiner over fake build modules that merge cleanly, digest the captured fixture's packages and pass
// the captured slow fixture's result at both levels, on shanks.
func newBench(t testing.TB) *bench {
	b := &bench{steps: &fakeSteps{}, kept: newMemKV(), prev: newMemKV()}
	b.fetch = captured[Fetched](t, "go-fetch-clean")
	b.fetch.Modules, b.fetch.Changed, b.fetch.Trees = []string{"."}, []string{"README.md"}, nil
	one := captured[Digested](t, "go-digest")
	b.digest = map[string]Digested{
		delivery.LevelUnit:        {Level: "unit", Packages: map[string]string{"fixture/slow": digA}},
		delivery.LevelIntegration: {Level: "integration", Packages: map[string]string{"fixture/slow": digB}},
	}
	_ = one
	slow := captured[Tested](t, "go-test-slow")
	b.test = func(c stepCall) (any, error) {
		r := slow
		r.Level, _ = c.args["level"].(string)
		return r, nil
	}
	b.steps.handlers = map[string]func(stepCall) (any, error){
		"build_go_fetch":   func(stepCall) (any, error) { return b.fetch, nil },
		"build_node_fetch": func(stepCall) (any, error) { return b.fetch, nil },
		"build_go_digest":  func(c stepCall) (any, error) { return b.digest[c.args["level"].(string)], nil },
		"build_go_test":    func(c stepCall) (any, error) { return b.test(c) },
		"build_node_test":  func(c stepCall) (any, error) { return b.test(c) },
	}
	now := time.Date(2026, 10, 21, 19, 0, 0, 0, time.UTC)
	b.ex = &Examiner{Steps: b.steps, Toolchains: goEntries("shanks"), Places: &buildrun.Places{}, Kept: Kept{Store: b.kept}, Previews: b.prev,
		Modules: langs{}, Trunks: &Trunks{}, Now: func() time.Time { now = now.Add(50 * time.Millisecond); return now }}
	return b
}

func caseOf(t testing.TB, pulls ...delivery.CandidatePull) *Case {
	t.Helper()
	raw := candidateOf(t, "feat/x", pulls...)
	c, err := delivery.DecodeCandidate(raw)
	if err != nil {
		t.Fatal(err)
	}
	cs := CaseOf(c, map[string]string{repoA: trunkA, repoSDK: trunkS, "novox/mesh-controller": trunkA, "novox/mesh-catalog": trunkA})
	if cs == nil {
		t.Fatal("no case")
	}
	return cs
}

func (b *bench) judge(t testing.TB, cs *Case) Outcome {
	t.Helper()
	out, err := b.ex.Judge(context.Background(), cs)
	if err != nil {
		t.Fatal(err)
	}
	return out
}

func testedWith(t testing.TB, name string, edit func(*Tested)) Tested {
	r := captured[Tested](t, name)
	if edit != nil {
		edit(&r)
	}
	return r
}

func packagesOf(c stepCall) []string {
	var out []string
	if l, ok := c.args["packages"].([]string); ok {
		out = l
	}
	return out
}

func TestACleanMergeIsFetchedAtItsTrunkAndBothLevelsPass(t *testing.T) { // 1679/AC1
	b := newBench(t)
	cs := caseOf(t, pullOf(repoA, 7, head1))
	out := b.judge(t, cs)
	v := out.Verdict
	if v.State != delivery.VerdictPass || v.Levels[delivery.LevelUnit].Run != 2 || v.Levels[delivery.LevelIntegration].Run != 2 {
		t.Fatalf("verdict = %+v", v)
	}
	if v.Composition == nil || v.Composition.State != delivery.CompositionNotRun {
		t.Errorf("composition = %+v, want not run", v.Composition)
	}
	if len(v.Machines) != 1 || v.Machines[0] != "shanks" {
		t.Errorf("machines = %v", v.Machines)
	}
	fetch := b.steps.tool("fetch")
	if len(fetch) != 1 || fetch[0].args["repository"] != repoA || fetch[0].args["commit"] != head1 || fetch[0].args["base"] != trunkA || fetch[0].args["ref"] != "refs/pull/7/head" {
		t.Fatalf("fetch calls = %+v", fetch)
	}
	if v.Took.Clone <= 0 || v.Took.Unit <= 0 {
		t.Errorf("took = %+v, want the clone and the unit level timed", v.Took)
	}
	// What passed is kept under each level's digest.
	for _, k := range []string{"unit." + digA, "integration." + digB} {
		if _, _, found, _ := b.kept.Get(context.Background(), k); !found {
			t.Errorf("%s was not kept", k)
		}
	}
}

func TestOnlyThePackageWithoutAKeptVerdictRuns(t *testing.T) { // 1288/AC1
	b := newBench(t)
	b.digest[delivery.LevelUnit] = Digested{Level: "unit", Packages: map[string]string{"fixture/slow": digA, "fixture/other": digC}}
	if _, err := (Kept{Store: b.kept}).Keep(context.Background(), "unit", digC, keptValue("fixture/other", 40)); err != nil {
		t.Fatal(err)
	}
	out := b.judge(t, caseOf(t, pullOf(repoA, 7, head1)))
	tests := b.steps.tool("test")
	if len(tests) != 2 || strings.Join(packagesOf(tests[0]), ",") != "fixture/slow" || tests[0].args["level"] != "unit" {
		t.Fatalf("test calls = %+v, want the unit level of fixture/slow alone, then the integration level", tests)
	}
	if u := out.Verdict.Levels[delivery.LevelUnit]; u.Run != 2 || u.Kept != 40 {
		t.Errorf("unit = %+v, want 2 run and 40 kept", u)
	}
}

func TestAReAskRunsOnlyWhatFailedAndWhatChanged(t *testing.T) { // 1288/AC2, AC3
	b := newBench(t)
	failing := captured[Tested](t, "go-test-failing")
	b.digest[delivery.LevelUnit] = Digested{Level: "unit", Packages: map[string]string{"fixture/failing/bad": digA, "fixture/failing/good": digB}}
	b.test = func(c stepCall) (any, error) {
		if c.args["level"] == "unit" {
			return failing, nil
		}
		return captured[Tested](t, "go-test-slow"), nil
	}
	cs := caseOf(t, pullOf(repoA, 7, head1))
	first := b.judge(t, cs).Verdict
	if first.State != delivery.VerdictFail || first.Failed.Test != "unit: fixture/failing/bad.TestThreeIsFour" {
		t.Fatalf("first = %+v", first)
	}
	if _, _, found, _ := b.kept.Get(context.Background(), "unit."+digB); !found {
		t.Fatal("the package that passed in the failing run was not kept")
	}
	if _, _, found, _ := b.kept.Get(context.Background(), "unit."+digA); found {
		t.Fatal("the package that failed was kept")
	}
	// Asked again with nothing changed: only the failed package runs; the good one is taken.
	b.steps.calls = nil
	b.judge(t, caseOf(t, pullOf(repoA, 7, head1)))
	tests := b.steps.tool("test")
	if len(tests) == 0 || strings.Join(packagesOf(tests[0]), ",") != "fixture/failing/bad" {
		t.Fatalf("the re-ask ran %+v, want only fixture/failing/bad", tests)
	}
	// The trunk moved and one digest changed: that package runs, the unchanged one is taken.
	b.digest[delivery.LevelUnit] = Digested{Level: "unit", Packages: map[string]string{"fixture/failing/bad": digA, "fixture/failing/good": digD}}
	b.steps.calls = nil
	b.judge(t, caseOf(t, pullOf(repoA, 7, head1)))
	tests = b.steps.tool("test")
	if got := strings.Join(packagesOf(tests[0]), ","); got != "fixture/failing/bad,fixture/failing/good" && got != "fixture/failing/good,fixture/failing/bad" {
		t.Errorf("after a digest changed the run was %q, want the failed package and the changed one", got)
	}
}

func TestANodePackageIsNeverKeptAndRunsEveryCheck(t *testing.T) { // 1288/AC4, 1292/AC1
	b := newBench(t)
	b.ex.Modules = langs{repoA: {buildrun.NodeBuildModule}}
	b.fetch = captured[Fetched](t, "node-fetch-clean")
	b.test = func(c stepCall) (any, error) {
		return Tested{Level: c.args["level"].(string), Module: "modules/m", Passed: true, Elapsed: 0.4, Bound: 5}, nil
	}
	cs := caseOf(t, pullOf(repoA, 7, head1))
	for i := 0; i < 2; i++ {
		v := b.judge(t, cs).Verdict
		if v.State != delivery.VerdictPass || v.Levels[delivery.LevelUnit].Kept != 0 || v.Levels[delivery.LevelUnit].Run != 1 {
			t.Fatalf("round %d: verdict = %+v", i, v)
		}
	}
	if n := len(b.steps.tool("test")); n != 4 {
		t.Errorf("%d node test calls in two checks, want 4 (both levels each time)", n)
	}
	if n := len(b.steps.tool("digest")); n != 0 {
		t.Errorf("the node build module was asked for a digest %d times", n)
	}
	if keys, _ := b.kept.Keys(context.Background()); len(keys) != 0 {
		t.Errorf("kept %v for a node package", keys)
	}
}

func TestTheChangesOwnFailingTestRunsFirstAndNothingElseRuns(t *testing.T) { // 1289/AC1, AC2
	b := newBench(t)
	b.fetch.Changed = []string{"modules/m/internal/b/b_test.go"}
	b.digest[delivery.LevelUnit] = Digested{Level: "unit", Packages: map[string]string{"m/internal/a": digA, "m/internal/b": digB}}
	failing := captured[Tested](t, "go-test-failing")
	b.test = func(c stepCall) (any, error) {
		if got := packagesOf(c); len(got) == 1 && got[0] == "m/internal/b" {
			return failing, nil
		}
		return captured[Tested](t, "go-test-slow"), nil
	}
	out := b.judge(t, caseOf(t, pullOf(repoA, 7, head1)))
	if out.Verdict.State != delivery.VerdictFail || !strings.Contains(out.Verdict.Failed.Test, "TestThreeIsFour") {
		t.Fatalf("verdict = %+v", out.Verdict)
	}
	tests := b.steps.tool("test")
	if len(tests) != 1 || strings.Join(packagesOf(tests[0]), ",") != "m/internal/b" {
		t.Fatalf("test calls = %+v, want only m/internal/b, once", tests)
	}
	if n := len(b.steps.tool("digest")); n != 1 {
		t.Errorf("%d digest calls, want the unit level's alone (the check stopped)", n)
	}
	if out.Verdict.Composition == nil || out.Verdict.Composition.State != delivery.CompositionNotRun {
		t.Errorf("composition = %+v", out.Verdict.Composition)
	}
}

func TestTheChangesOwnPassingTestRunsFirstAndTheRestFollow(t *testing.T) { // 1289/AC3
	b := newBench(t)
	b.fetch.Changed = []string{"modules/m/internal/b/b_test.go", "modules/m/internal/a/a.go"}
	b.digest[delivery.LevelUnit] = Digested{Level: "unit", Packages: map[string]string{"m/internal/a": digA, "m/internal/b": digB}}
	out := b.judge(t, caseOf(t, pullOf(repoA, 7, head1)))
	if out.Verdict.State != delivery.VerdictPass {
		t.Fatalf("verdict = %+v", out.Verdict)
	}
	var unit []string
	for _, c := range b.steps.tool("test") {
		if c.args["level"] == "unit" {
			unit = append(unit, strings.Join(packagesOf(c), ","))
		}
	}
	if strings.Join(unit, " | ") != "m/internal/b | m/internal/a" {
		t.Errorf("the unit level ran %v, want the changed test's package first, then the rest", unit)
	}
}

func TestAHeadThatDoesNotMergeEndsFailedNamingTheFilesAndRunsNoTest(t *testing.T) { // 1289/AC4
	b := newBench(t)
	b.fetch = captured[Fetched](t, "go-fetch-conflict")
	out := b.judge(t, caseOf(t, pullOf(repoA, 7, head1)))
	f := out.Verdict.Failed
	if out.Verdict.State != delivery.VerdictFail || f.Machine != "shanks" || !strings.Contains(f.Words, "files in conflict: a.go, sub/b.go") {
		t.Fatalf("verdict = %+v", out.Verdict)
	}
	if n := len(b.steps.tool("digest")) + len(b.steps.tool("test")); n != 0 {
		t.Errorf("%d digest and test steps ran after a conflict", n)
	}
}

func TestNoQualifyingNodeIsAFailureOfTheNodes(t *testing.T) { // N6/AC4
	b := newBench(t)
	b.ex.Toolchains = entries{}
	out := b.judge(t, caseOf(t, pullOf(repoA, 7, head1)))
	if !IsNodesFailure(out.Verdict) {
		t.Fatalf("verdict = %+v, want a failure of the nodes", out.Verdict)
	}
	b.ex.Toolchains = goEntries("shanks")
	b.ex.Presence = offline{}
	if out = b.judge(t, caseOf(t, pullOf(repoA, 7, head1))); !IsNodesFailure(out.Verdict) {
		t.Fatalf("an offline node: verdict = %+v", out.Verdict)
	}
}

type offline struct{}

func (offline) Online(string) bool { return false }

func TestAStepThatFailsIsAVerdictNamingTheNode(t *testing.T) {
	b := newBench(t)
	b.steps.handlers["build_go_fetch"] = func(stepCall) (any, error) { return nil, fmt.Errorf("the step failed: ssh refused") }
	out := b.judge(t, caseOf(t, pullOf(repoA, 7, head1)))
	if f := out.Verdict.Failed; out.Verdict.State != delivery.VerdictFail || f.Machine != "shanks" || !strings.Contains(f.Words, "ssh refused") {
		t.Fatalf("verdict = %+v", out.Verdict)
	}
}

func TestALevelWhoseDigestIsNotNamedRunsWholeAndKeepsNothing(t *testing.T) { // 1287/AC4
	b := newBench(t)
	b.steps.handlers["build_go_digest"] = func(stepCall) (any, error) { return nil, fmt.Errorf("go list failed") }
	out := b.judge(t, caseOf(t, pullOf(repoA, 7, head1)))
	if out.Verdict.State != delivery.VerdictPass {
		t.Fatalf("verdict = %+v", out.Verdict)
	}
	tests := b.steps.tool("test")
	if len(tests) != 2 || tests[0].args["packages"] != nil {
		t.Errorf("test calls = %+v, want each level once, whole", tests)
	}
	if keys, _ := b.kept.Keys(context.Background()); len(keys) != 0 {
		t.Errorf("kept %v with no digest", keys)
	}
}

func TestALevelOverItsBoundIsNamedWithItsSlowestTestsAndKeepsItsVerdict(t *testing.T) { // 1300/AC3
	b := newBench(t)
	b.test = func(c stepCall) (any, error) {
		return testedWith(t, "go-test-slow", func(r *Tested) {
			r.Level = c.args["level"].(string)
			r.OverBound = true
			r.OverWhich = "run"
			r.Elapsed = 7
		}), nil
	}
	out := b.judge(t, caseOf(t, pullOf(repoA, 7, head1)))
	v := out.Verdict
	if v.State != delivery.VerdictPass || strings.Join(v.OverBound, ",") != "unit,integration" {
		t.Fatalf("verdict = %+v", v)
	}
	if len(out.Slowest) == 0 || !strings.Contains(out.Slowest[0], "TestTakesAWhile") {
		t.Errorf("slowest = %v", out.Slowest)
	}
}

func TestSkippedTestsAreCountedPerLevel(t *testing.T) { // 1300/AC6, 1251
	b := newBench(t)
	b.test = func(c stepCall) (any, error) {
		return testedWith(t, "go-test-slow", func(r *Tested) { r.Level = c.args["level"].(string); r.Skipped = 3 }), nil
	}
	v := b.judge(t, caseOf(t, pullOf(repoA, 7, head1))).Verdict
	if v.Levels[delivery.LevelUnit].Skipped != 3 || v.Levels[delivery.LevelIntegration].Skipped != 3 {
		t.Errorf("levels = %+v", v.Levels)
	}
}

func TestAGroupIsOneVerdictAndEachMembersTestsReadTheOthersAtTheirHeads(t *testing.T) { // 1624/AC1
	b := newBench(t)
	cs := caseOf(t, pullOf(repoA, 7, head1), pullOf(repoSDK, 12, head2))
	v := b.judge(t, cs).Verdict
	if v.State != delivery.VerdictPass {
		t.Fatalf("verdict = %+v", v)
	}
	fetch := b.steps.tool("fetch")
	if len(fetch) != 2 {
		t.Fatalf("%d fetches, want one for each member", len(fetch))
	}
	var forA []BesideRef
	for _, f := range fetch {
		if f.args["repository"] == repoA {
			forA, _ = f.args["beside"].([]BesideRef)
		}
	}
	found := false
	for _, r := range forA {
		if r.Repository == repoSDK && r.Commit == head2 && r.Ref == "refs/pull/12/head" {
			found = true
		}
	}
	if !found {
		t.Errorf("mesh-delivery's tests were not given the SDK member at its head: %+v", forA)
	}
}

func TestAnExaminerIsAJudgeOfTheChecker(t *testing.T) {
	var _ Judge = (*Examiner)(nil)
}

const (
	manA = "0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a"
)

func TestACleanMergeWritesItsPreviewWithTheTreesManifestsAndLocks(t *testing.T) { // 1445/AC1
	b := newBench(t)
	b.fetch.Trees = map[string]MergeTree{
		"modules/avahi": {Tree: "7777777777777777777777777777777777777777", Manifest: manA, Locks: map[string]string{"go.sum": "ff00"}},
		"modules/bare":  {Tree: "8888888888888888888888888888888888888888"}, // no manifest digest: left out
	}
	b.judge(t, caseOf(t, pullOf(repoA, 7, head1)))
	key, _ := delivery.PreviewKey(repoA, head1, trunkA)
	raw, _, found, _ := b.prev.Get(context.Background(), key)
	if !found {
		t.Fatalf("no preview %s; the bucket holds %v", key, b.prev.vals)
	}
	pv, err := delivery.DecodePreview(raw)
	if err != nil {
		t.Fatal(err)
	}
	m := pv.Modules["modules/avahi"]
	if pv.Merge != b.fetch.Merge || pv.Trunk != trunkA || pv.Head != head1 || len(pv.Modules) != 1 || m.Tree != "7777777777777777777777777777777777777777" || m.Manifest != manA || m.Locks["go.sum"] != "ff00" {
		t.Errorf("preview = %+v", pv)
	}
}

func TestAHeadThatDoesNotMergeWritesAPreviewOfItsConflictsAlone(t *testing.T) { // 1445/AC5
	b := newBench(t)
	b.fetch = captured[Fetched](t, "go-fetch-conflict")
	b.judge(t, caseOf(t, pullOf(repoA, 7, head1)))
	key, _ := delivery.PreviewKey(repoA, head1, trunkA)
	raw, _, found, _ := b.prev.Get(context.Background(), key)
	if !found {
		t.Fatalf("no preview for a head that does not merge; the bucket holds %v", b.prev.vals)
	}
	pv, err := delivery.DecodePreview(raw)
	if err != nil || strings.Join(pv.Conflicts, ",") != "a.go,sub/b.go" || pv.Merge != "" || len(pv.Modules) != 0 {
		t.Errorf("preview = %+v, %v, want the files in conflict and no merge", pv, err)
	}
}

func TestAPreviewIsWrittenOnceAndAnExistingKeyStands(t *testing.T) {
	b := newBench(t)
	b.judge(t, caseOf(t, pullOf(repoA, 7, head1)))
	b.fetch.Merge = "5656565656565656565656565656565656565656"
	b.judge(t, caseOf(t, pullOf(repoA, 7, head1)))
	key, _ := delivery.PreviewKey(repoA, head1, trunkA)
	if b.prev.creates[key] != 1 {
		t.Errorf("the preview was created %d times, want once", b.prev.creates[key])
	}
	raw, _, _, _ := b.prev.Get(context.Background(), key)
	if pv, _ := delivery.DecodePreview(raw); pv.Merge == b.fetch.Merge {
		t.Error("the second merge commit replaced the first")
	}
}

func TestTheIndexerIsToldOfAPreviewOnceWhenItIsCreated(t *testing.T) { // 1445/AC4 (the checker's half)
	b := newBench(t)
	var told []string
	b.ex.Announce = func(_ context.Context, event, key string) { told = append(told, event+" "+key) }
	b.judge(t, caseOf(t, pullOf(repoA, 7, head1)))
	b.judge(t, caseOf(t, pullOf(repoA, 7, head1)))
	key, _ := delivery.PreviewKey(repoA, head1, trunkA)
	if len(told) != 1 || told[0] != EventPreviewWritten+" "+key {
		t.Errorf("told %v, want once of %s", told, key)
	}
}

type fakeBuilds map[string]delivery.BuilderBuild

func (f fakeBuilds) Build(_ context.Context, module, fp2 string) (delivery.BuilderBuild, bool, error) {
	b, ok := f[module+" "+fp2]
	return b, ok, nil
}

func TestTheOutcomeSaysIfEachCandidatesModuleIsBuiltFailedOrWaiting(t *testing.T) { // N7/AC1 (the checker reads the builder's keys)
	b := newBench(t)
	fpA := "src2:" + strings.Repeat("a", 64)
	fpB := "src2:" + strings.Repeat("b", 64)
	fpC := "src2:" + strings.Repeat("c", 64)
	b.ex.Builds = fakeBuilds{
		"avahi " + fpA:      {State: delivery.BuildDone},
		"mesh-tools " + fpB: {State: delivery.BuildFailed, Error: "boom"},
		// netcheck has no key yet
	}
	p := pullOf(repoA, 7, head1)
	p.Modules = []string{"avahi", "mesh-tools", "netcheck", "nofp"}
	p.Fps = map[string]delivery.CandidateModule{"avahi": {FP2: fpA}, "mesh-tools": {FP2: fpB}, "netcheck": {FP2: fpC}, "nofp": {None2: "toolchain not yet reported"}}
	out := b.judge(t, caseOf(t, p))
	var got []string
	for _, n := range out.Builds {
		got = append(got, n.Module+" "+n.State)
	}
	if strings.Join(got, ", ") != "avahi built, mesh-tools failed, netcheck waiting" {
		t.Errorf("builds = %v, want one note for each module that has a fingerprint, sorted", got)
	}
}

// trunksOf are trunk heads of every repository, as the gate's source names them.
func trunksOf(t *testing.T, heads map[string]string) *Trunks {
	t.Helper()
	data, err := delivery.EncodeSource(delivery.Source{Group: "g", Heads: heads})
	if err != nil {
		t.Fatal(err)
	}
	tr := &Trunks{}
	tr.Put(data, false)
	return tr
}

func TestNothingIsKeptForAWorkspaceGivenSiblingsBeside(t *testing.T) { // review D1, ADR 0444, issue 1287
	b := newBench(t)
	b.ex.Trunks = trunksOf(t, map[string]string{repoSDK: trunkS, "novox/mesh-catalog": trunkA})
	b.judge(t, caseOf(t, pullOf(repoA, 7, head1)))
	if got := len(b.steps.tool("fetch")); got != 1 || b.steps.tool("fetch")[0].args["beside"] == nil {
		t.Fatalf("the fetch was not given siblings: %+v", b.steps.tool("fetch"))
	}
	if keys, _ := b.kept.Keys(context.Background()); len(keys) != 0 {
		t.Errorf("kept %v for a package whose tests may read a sibling the digest does not cover", keys)
	}
	// And a kept verdict of the same digest from elsewhere is not taken for it: everything runs.
	if _, err := (Kept{Store: b.kept}).Keep(context.Background(), "unit", digA, keptValue("fixture/slow", 2)); err != nil {
		t.Fatal(err)
	}
	b.steps.calls = nil
	b.judge(t, caseOf(t, pullOf(repoA, 7, head1)))
	if n := len(b.steps.tool("test")); n != 2 {
		t.Errorf("%d test steps, want both levels run whole", n)
	}
}