mesh-controller/internal/inventory/collection_test.go

package inventory

import (
	"context"
	"fmt"
	"testing"

	"github.com/novox/mesh-controller/internal/catalogue"
)

// What the store keeps, and what it may let go (novox/hq ADR 0189, issue 108).
//
// The store has collected nothing since it was raised, and the registry's own answer — collect
// what no tag names — would delete images machines are running, because the mesh pushes under one
// moving tag and pins by digest. So the rule is the mesh's, read from its own records, and these
// are the three reasons an artifact stays and the one reason it goes.

// ref is an artifact reference as the mesh records one.
func ref(module, artifact string, n int) string {
	return fmt.Sprintf("%s%s/%s@sha256:%064x", catalogue.ArtifactStoreScheme, module, artifact, n)
}

// built records one successful build of a module publishing one image.
func built(t *testing.T, inv *Inventory, id, module string, n int) string {
	t.Helper()
	reference := ref(module, "app", n)
	b := aBuild(id, module, "")
	b.Made = []Artifact{{Name: "app", Kind: "image", Reference: reference}}
	if err := inv.RecordBuild(context.Background(), b); err != nil {
		t.Fatal(err)
	}
	return reference
}

func TestTheStoreKeepsTheRecentBuildsAndLetsGoOfTheRest(t *testing.T) {
	inv := fresh(t)
	ctx := context.Background()

	// Eight builds of one module, oldest first. Five are kept — the newest, and the four a
	// release that turns out wrong can be taken back to.
	var made []string
	for i := 1; i <= 8; i++ {
		made = append(made, built(t, inv, fmt.Sprintf("b%02d", i), "web", i))
	}

	go_, err := inv.ToCollect(ctx)
	if err != nil {
		t.Fatal(err)
	}
	want := made[:3] // the three oldest
	if len(go_) != len(want) {
		t.Fatalf("offered %v to collect; want the %d oldest of %d", go_, len(want), len(made))
	}
	for i := range want {
		if go_[i] != want[i] {
			t.Fatalf("offered %v; want %v — and in that order, so a failed sweep is safe to run again",
				go_, want)
		}
	}
}

func TestADefinitionNamingAnArtifactKeepsItHoweverOldItIs(t *testing.T) {
	// The floor: no age limit. A module recorded at an older commit still names what the mesh
	// would hand a machine now, and that is what must not be collected out from under it.
	inv := fresh(t)
	ctx := context.Background()

	var made []string
	for i := 1; i <= 8; i++ {
		made = append(made, built(t, inv, fmt.Sprintf("b%02d", i), "web", i))
	}
	oldest := made[0]

	// A definition the mesh holds, whose container runs that oldest image.
	m := catalogue.Manifest{Module: "web", Version: "1", Resources: []map[string]any{{
		"id": "app", "type": "container", "name": "web", "image": oldest,
	}}}
	if err := inv.RegisterModule(ctx, m, Source{Repository: "https://forge.invalid/web.git"}); err != nil {
		t.Fatal(err)
	}

	go_, err := inv.ToCollect(ctx)
	if err != nil {
		t.Fatal(err)
	}
	for _, reference := range go_ {
		if reference == oldest {
			t.Fatalf("the mesh offered to collect %s, which a definition it holds names", oldest)
		}
	}
	if len(go_) != 2 {
		t.Fatalf("offered %v; want the two oldest that nothing names", go_)
	}
}

func TestWhatHasBeenCollectedIsNotOfferedAgain(t *testing.T) {
	// Without this the sweep reissues a delete for every artifact it has ever collected, every
	// time it runs, for ever — a number of requests that grows with the mesh's whole history.
	inv := fresh(t)
	ctx := context.Background()
	for i := 1; i <= 7; i++ {
		built(t, inv, fmt.Sprintf("b%02d", i), "web", i)
	}
	first, err := inv.ToCollect(ctx)
	if err != nil {
		t.Fatal(err)
	}
	if len(first) != 2 {
		t.Fatalf("offered %v, want two", first)
	}
	if err := inv.MarkCollected(ctx, first); err != nil {
		t.Fatal(err)
	}
	again, err := inv.ToCollect(ctx)
	if err != nil {
		t.Fatal(err)
	}
	if len(again) != 0 {
		t.Fatalf("offered %v again after collecting it", again)
	}
}

func TestAFailedBuildNamesNothingToCollectAndEachModuleIsCountedOnItsOwn(t *testing.T) {
	inv := fresh(t)
	ctx := context.Background()

	// A failed build published nothing, so it is neither kept nor collected — and it must not
	// count against the module's five.
	for i := 1; i <= 6; i++ {
		built(t, inv, fmt.Sprintf("w%02d", i), "web", i)
	}
	if err := inv.RecordBuild(ctx, aBuild("w99", "web", "the recipe would not build")); err != nil {
		t.Fatal(err)
	}
	// And a second module with three builds keeps all three: five each, not five between them.
	for i := 1; i <= 3; i++ {
		built(t, inv, fmt.Sprintf("d%02d", i), "db", 100+i)
	}

	go_, err := inv.ToCollect(ctx)
	if err != nil {
		t.Fatal(err)
	}
	if len(go_) != 1 || go_[0] != ref("web", "app", 1) {
		t.Fatalf("offered %v; want only web's oldest — db's three are all within its five", go_)
	}
}

// An artifact recorded with the store's old address is offered for collection, in the vocabulary
// the rest of the mesh speaks (novox/hq issue 226).
//
// Before references were kept without an address the mesh recorded
// `<host>:<port>/<path>@sha256:…` (04-ISSUES/102). Those are the oldest artifacts, which makes
// them exactly the ones an oldest-first sweep reaches first — and the first live run met one,
// read "I will not address this" as "the store refuses everything", and collected none of 1681.
func TestAnArtifactRecordedWithAnAddressIsOfferedAsTheMeshRecordsOne(t *testing.T) {
	inv := fresh(t)
	ctx := context.Background()

	// The oldest build published the old way; five newer ones fill the module's five.
	old := aBuild("a00", "tools", "")
	old.Made = []Artifact{{Name: "build", Kind: "image",
		Reference: "127.0.0.1:5100/tools/build@sha256:" + fmt.Sprintf("%064x", 1)}}
	if err := inv.RecordBuild(ctx, old); err != nil {
		t.Fatal(err)
	}
	for i := 2; i <= 6; i++ {
		built(t, inv, fmt.Sprintf("a%02d", i), "tools", i)
	}

	go_, err := inv.ToCollect(ctx)
	if err != nil {
		t.Fatal(err)
	}
	want := ref("tools", "build", 1)
	if len(go_) != 1 || go_[0] != want {
		t.Fatalf("offered %v; want %q — the address is a route to the artifact, not part of its "+
			"name, and the sweep speaks the name", go_, want)
	}
	// And marking it collected uses that same name, so the next sweep does not offer it again
	// under a spelling it has not seen.
	if err := inv.MarkCollected(ctx, go_); err != nil {
		t.Fatal(err)
	}
	again, err := inv.ToCollect(ctx)
	if err != nil {
		t.Fatal(err)
	}
	if len(again) != 0 {
		t.Fatalf("offered %v again after collecting it", again)
	}
}