mesh-delivery/modules/mesh-delivery-assigner/internal/assigngraph/graph_test.go

package assigngraph

import (
	"context"
	"encoding/json"
	"errors"
	"fmt"
	"strings"
	"testing"
	"time"

	mma "git.novox.be/novox/mesh-contracts/go/seats/meshmoduleassigner"
	"git.novox.be/novox/mesh-delivery/modules/mesh-delivery-contracts/go/clients/meshcatalogclient"
	"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/meshwants"
)

type memObjects map[string][]byte

func (m memObjects) Put(_ context.Context, name string, data []byte) error {
	m[name] = data
	return nil
}
func (m memObjects) Get(_ context.Context, name string) ([]byte, error) {
	d, ok := m[name]
	if !ok {
		return nil, ErrNoObject
	}
	return d, nil
}
func (m memObjects) Names(context.Context) ([]string, error) {
	out := []string{}
	for n := range m {
		out = append(out, n)
	}
	return out, nil
}

func half(branch string, revision int64, entries ...meshcatalog.CatalogEntry) meshcatalogclient.Half {
	h := meshcatalogclient.Half{Revision: meshcatalog.CatalogRevision{Kind: "trunk", Branch: branch, Revision: revision, Source: revision + 10},
		Entries: map[string]meshcatalog.CatalogEntry{}}
	for _, e := range entries {
		h.Entries[e.Module] = e
		h.Revision.Entries = append(h.Revision.Entries, meshcatalog.EntryRef{Module: e.Module, Digest: "sha256:" + e.Module + e.Fp})
	}
	return h
}

// Design 47 *Two graphs, one source of truth* (lines 1353-1366, 1416-1418) and *An acting part's new version acts first*
// (lines 1835-1836): each entry one module version on a node from the catalog graph of the branch its placement names,
// its edges provisioning and acting, a revision computed again from its inputs equal to the one kept.
func TestTheAssignmentGraphIsComputedFromItsInputsAndKept(t *testing.T) {
	ctx := context.Background()
	in := Inputs{
		Halves: map[string]meshcatalogclient.Half{"main": half("main", 7,
			meshcatalog.CatalogEntry{Module: "node-engine", Fp: "src2:e1", Acts: []meshcatalog.ActingRule{{Seat: "node-engine", Step: "compose", On: "every", Bound: "30m"}}},
			meshcatalog.CatalogEntry{Module: "build-go", Fp: "src2:b1", Acts: []meshcatalog.ActingRule{{Seat: "node-build-go", Step: "build", On: "go"}}},
			meshcatalog.CatalogEntry{Module: "postgres", Fp: "src2:p1", Provides: []string{"database"}},
			meshcatalog.CatalogEntry{Module: "web", Fp: "src2:w1", Requires: []string{"database", "secrets"}, Toolchains: map[string]meshcatalog.BuildEdge{"go": {Version: "1"}}},
		)},
		Placements: map[string]mma.Assignments{
			"anchor": {Node: "anchor", Modules: []mma.PlacedModule{{Module: "node-engine"}, {Module: "postgres"}, {Module: "build-go"},
				{Module: "web", Bindings: map[string]mma.Provider{"database": {Node: "anchor", Module: "postgres"}}}}},
			"laptop": {Node: "laptop", Modules: []mma.PlacedModule{{Module: "node-engine"}, {Module: "web", Build: "src2:w0"},
				{Module: "photos", Branch: "beta"}, {Module: "ghost"}}},
		},
		FirstBranch: func(module string) string {
			if module == "ghost" {
				return ""
			}
			return "main"
		},
	}
	c := Compute(in)
	byNode := map[string]meshwants.AssignmentEntry{}
	for _, ref := range c.Revision.Entries {
		byNode[ref.Node+"/"+ref.Module] = c.Entries[ref.Digest]
	}
	webA, webL := byNode["anchor/web"], byNode["laptop/web"]
	if len(c.Revision.Entries) != 6 || len(c.Revision.Catalogs) != 1 || c.Revision.Catalogs[0] != (meshwants.CatalogOf{Branch: "main", Revision: 7, Source: 17}) {
		t.Fatalf("revision %+v", c.Revision)
	}
	if webA.Branch != "main" || webA.Fp != "src2:w1" || webA.Catalog != "sha256:websrc2:w1" || webL.Fp != "src2:w0" {
		t.Errorf("web's entries: %+v, %+v (the placement's build is the version on laptop)", webA, webL)
	}
	want := []meshwants.Edge{
		{Kind: EdgeActing, Node: "anchor", Module: "build-go", Fp: "src2:b1", Seat: "node-build-go", Step: "build"},
		{Kind: EdgeActing, Node: "anchor", Module: "node-engine", Fp: "src2:e1", Seat: "node-engine", Step: "compose", Bound: "30m"},
		{Kind: EdgeProvisioning, Node: "anchor", Module: "postgres", Fp: "src2:p1", Provision: "database"},
	}
	if fmt.Sprint(webA.Edges) != fmt.Sprint(want) {
		t.Errorf("web on anchor's edges:\n got %+v\nwant %+v", webA.Edges, want)
	}
	// laptop's web: its own node's node-engine composes it, the build module placed once builds it, and no binding or pin
	// names a provider there.
	if e := webL.Edges; len(e) != 2 || e[0].Module != "build-go" || e[0].Node != "anchor" || e[1].Module != "node-engine" || e[1].Node != "laptop" {
		t.Errorf("web on laptop's edges: %+v", e)
	}
	if e := byNode["anchor/postgres"].Edges; len(e) != 1 || e[0].Module != "node-engine" {
		t.Errorf("postgres builds no Go, so only the node-engine acts on it: %+v", e)
	}
	if len(byNode["anchor/node-engine"].Edges) != 0 {
		t.Errorf("an acting part acts on itself: %+v", byNode["anchor/node-engine"].Edges)
	}
	if strings.Join(c.Uncomputed, "|") != "laptop/ghost: no watched branch: its placement names none and no registration of it is known|"+
		"laptop/photos: the catalog graph of the branch beta is not held" {
		t.Errorf("uncomputed %q", c.Uncomputed)
	}

	// Kept once; computed again from the same inputs it is the same revision, kept no second time.
	o := memObjects{}
	at := time.Date(2026, 11, 10, 18, 0, 0, 0, time.UTC)
	rev, kept, err := Keep(ctx, o, c, "catalog-revision", at)
	if err != nil || !kept || rev.Revision != 1 || rev.Cause != "catalog-revision" || len(o) != 7 {
		t.Fatalf("kept %v %+v (%v), objects %d", kept, rev, err, len(o))
	}
	if again, kept, err := Keep(ctx, o, Compute(in), "placement-changed", at); err != nil || kept || again.Revision != 1 {
		t.Errorf("recomputed from the same inputs: kept %v, %+v, %v", kept, again, err)
	}
	// A placement change moves laptop's web to the catalog's version: revision 2, one entry more stored, the rest shared.
	in.Placements["laptop"].Modules[1].Build = ""
	rev2, kept, err := Keep(ctx, o, Compute(in), "placement-changed", at)
	if err != nil || !kept || rev2.Revision != 2 || len(o) != 9 || rev2.Placements == rev.Placements {
		t.Fatalf("revision 2 %v %+v (%v), objects %d", kept, rev2, err, len(o))
	}

	// The verbs read only what is kept.
	r, err := Revision(ctx, o, meshwants.RevisionInput{})
	if err != nil || r.Revision.Revision != 2 {
		t.Errorf("revision = %+v, %v", r, err)
	}
	if _, err := Revision(ctx, o, meshwants.RevisionInput{Group: "g", Heads: "h"}); !errors.Is(err, ErrNoCandidate) {
		t.Errorf("a candidate's revision: %v", err)
	}
	e, err := Entry(ctx, o, meshwants.EntryInput{Revision: 1, Node: "laptop", Module: "web"})
	if err != nil || e.Entry.Fp != "src2:w0" || !strings.HasPrefix(e.Digest, "sha256:") {
		t.Errorf("entry = %+v, %v", e, err)
	}
	d, err := Difference(ctx, o, meshwants.DifferenceInput{From: 1, To: 2})
	if err != nil || len(d.Changes) != 1 || fmt.Sprint(d.Changes[0]) != fmt.Sprint(meshwants.Change{Node: "laptop", Module: "web", From: "src2:w0", To: "src2:w1"}) ||
		strings.Join(d.Nodes, ",") != "laptop" {
		t.Errorf("difference = %+v, %v", d, err)
	}
	if _, err := Difference(ctx, o, meshwants.DifferenceInput{To: 2}); err == nil {
		t.Error("a difference with one revision answered")
	}
	if ev := Event(rev2); ev.Revision != 2 || len(ev.Catalogs) != 1 || ev.Kind != "trunk" {
		t.Errorf("event %+v", ev)
	}
}

// Design 47 line 1385: a whole assignment graph revision of about 120 modules on four nodes is under the bus's 256 KiB
// value limit.
func TestARevisionOf120ModulesOnFourNodesFitsOneValue(t *testing.T) {
	var entries []meshcatalog.CatalogEntry
	placements := map[string]mma.Assignments{}
	for i := range 120 {
		entries = append(entries, meshcatalog.CatalogEntry{Module: fmt.Sprintf("module-%03d", i), Fp: "src2:" + strings.Repeat("a", 64)})
	}
	for _, node := range []string{"anchor", "home", "desk", "laptop"} {
		a := mma.Assignments{Node: node}
		for _, e := range entries {
			a.Modules = append(a.Modules, mma.PlacedModule{Module: e.Module})
		}
		placements[node] = a
	}
	h := half("main", 1, entries...)
	for i := range h.Revision.Entries {
		h.Revision.Entries[i].Digest = "sha256:" + strings.Repeat("b", 64)
	}
	c := Compute(Inputs{Halves: map[string]meshcatalogclient.Half{"main": h}, Placements: placements, FirstBranch: func(string) string { return "main" }})
	raw, _ := json.Marshal(c.Revision)
	if len(c.Revision.Entries) != 480 || len(raw) >= 256<<10 {
		t.Errorf("%d entries in %d bytes", len(c.Revision.Entries), len(raw))
	}
}