jochen
e658a14296
mesh/merge-gate head e658a14296f9 merged into trunk 1826b68a22b5 — pass: builds build-agent, mesh-controller → ace, g14, novox, shanks; no bus step; every …
mesh/repo-check head e658a14296f9 merged into trunk 1826b68a22b5 — pass: its merge-check.sh passed
mesh/delivery delivered
A registered manifest carries no build, so mesh-tools' build.on naming the SDK's package and every bundle's toolchain were edges only before a module was first built: mesh-sdk 0.1.14 planned "sent nowhere". The relation now reads a package base from the recorded name@version against the package the mesh holds, and the toolchain from the bundles the resolved manifest keeps. Only records the mesh already keeps are read, so it holds for every module built before it and a rollback reads the same records. Replay R614.
249 lines
10 KiB
Go
249 lines
10 KiB
Go
package inventory
|
|
|
|
import (
|
|
"strings"
|
|
"testing"
|
|
|
|
"github.com/novox/mesh-controller/internal/catalogue"
|
|
)
|
|
|
|
// The catalogue's one dependency relation (novox/hq ADR 0162): four kinds of edge from one call.
|
|
func TestDependenciesAreOneRelationWithTheirKinds(t *testing.T) {
|
|
entry := func(name, repository string) Entry {
|
|
return Entry{Manifest: catalogue.Manifest{Module: name}, Source: Source{Repository: repository}}
|
|
}
|
|
builder := entry("builder", "http://forge/novox/mesh-catalog.git")
|
|
builder.Manifest.Claims = []catalogue.Claim{{Name: "node-build-agent", Scope: catalogue.ScopeNode}}
|
|
plugin := entry("shop-plugin", "http://forge/novox/mesh-catalog.git")
|
|
plugin.Manifest.Build = &catalogue.Build{On: []catalogue.BuildsOn{{Arg: "BASE", Module: "shop"}}}
|
|
entries := []Entry{
|
|
entry("mesh-tools", "http://forge/novox/mesh-tools.git"),
|
|
entry("shop", "http://forge/novox/mesh-catalog.git"),
|
|
plugin,
|
|
builder,
|
|
entry("mesh-controller", "http://forge/novox/mesh-controller.git"),
|
|
entry("route-proxy", "http://forge/novox/mesh-catalog.git"),
|
|
{Manifest: catalogue.Manifest{Module: "hand-made"}},
|
|
}
|
|
against := map[string][]string{
|
|
"shop": {catalogue.ArtifactStoreScheme + "mesh-tools/runtime@sha256:a"},
|
|
"builder": {catalogue.ArtifactStoreScheme + "mesh-tools/runtime@sha256:a"},
|
|
}
|
|
read := map[string][]ReadRepository{
|
|
"route-proxy": {{Repository: "http://forge/novox/mesh-controller.git", Ref: "main"}},
|
|
}
|
|
got := dependenciesOf(entries, against, read)
|
|
has := func(from, to, kind string) bool {
|
|
for _, e := range got {
|
|
if e == (Edge{From: from, To: to, Kind: kind}) {
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
for _, want := range []Edge{
|
|
{"shop", "mesh-tools", EdgeStandsOn},
|
|
{"builder", "mesh-tools", EdgeStandsOn},
|
|
{"shop-plugin", "shop", EdgeDeclared},
|
|
{"shop", "builder", EdgeBuiltBy},
|
|
{"mesh-controller", "builder", EdgeBuiltBy},
|
|
{"mesh-tools", "builder", EdgeBuiltBy},
|
|
} {
|
|
if !has(want.From, want.To, want.Kind) {
|
|
t.Errorf("missing %+v in %+v", want, got)
|
|
}
|
|
}
|
|
// Sharing a repository is no dependency (novox/hq ADR 0267 rule 4): what a build read draws no edge.
|
|
if has("route-proxy", "mesh-controller", EdgePackages) {
|
|
t.Error("a packages edge was drawn from what a build read")
|
|
}
|
|
if has("builder", "builder", EdgeBuiltBy) {
|
|
t.Error("the builder is not built by itself")
|
|
}
|
|
for _, e := range got {
|
|
if e.From == "hand-made" {
|
|
t.Errorf("a module with no source depends on nothing: %+v", e)
|
|
}
|
|
}
|
|
}
|
|
|
|
// novox/hq 04-ISSUES/211: a bundle stands on the toolchain it is compiled in, so a merge moving both
|
|
// builds the toolchain first — read from the manifest, before any build recorded it.
|
|
func TestABundleStandsOnTheToolchainItIsCompiledIn(t *testing.T) {
|
|
entries := []Entry{
|
|
{Manifest: catalogue.Manifest{Module: "mesh-tools"}, Source: Source{Repository: "novox/mesh-tools"}},
|
|
{Manifest: catalogue.Manifest{Module: "mesh-tools-go"}, Source: Source{Repository: "novox/mesh-tools-go"}},
|
|
{Manifest: catalogue.Manifest{Module: "node-tools", Build: &catalogue.Build{Artifacts: []catalogue.Artifact{
|
|
{Name: "runtime", Kind: catalogue.ArtifactBundle, Language: "go", System: "arch", From: "cmd/node-tools"}}}},
|
|
Source: Source{Repository: "novox/mesh-tools"}},
|
|
{Manifest: catalogue.Manifest{Module: "nftables", Build: &catalogue.Build{Artifacts: []catalogue.Artifact{
|
|
{Name: "tools", Kind: catalogue.ArtifactBundle, Language: "typescript", Entrypoints: []string{"tools/index.js"}}}}},
|
|
Source: Source{Repository: "novox/mesh-catalog"}},
|
|
{Manifest: catalogue.Manifest{Module: "photos", Build: &catalogue.Build{Artifacts: []catalogue.Artifact{
|
|
{Name: "server", Kind: catalogue.ArtifactImage, From: "Dockerfile"}}}},
|
|
Source: Source{Repository: "novox/photos"}},
|
|
}
|
|
edges := dependenciesOf(entries, nil, nil)
|
|
has := func(from, to string) bool {
|
|
for _, e := range edges {
|
|
if e.From == from && e.To == to && e.Kind == EdgeStandsOn {
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
if !has("nftables", "mesh-tools") {
|
|
t.Errorf("a TypeScript bundle does not stand on the TypeScript toolchain: %v", edges)
|
|
}
|
|
if !has("node-tools", "mesh-tools-go") {
|
|
t.Errorf("a Go bundle does not stand on the Go toolchain: %v", edges)
|
|
}
|
|
for _, e := range edges {
|
|
if e.From == "photos" && e.Kind == EdgeStandsOn {
|
|
t.Errorf("an image stands on a toolchain it is not compiled in: %v", e)
|
|
}
|
|
}
|
|
}
|
|
|
|
// novox/hq 04-ISSUES/212: a toolchain standing on the SDK's package is planned after the SDK, so a
|
|
// release of the SDK rebuilds the toolchain, and every bundle compiled in it after that.
|
|
func TestAToolchainStandingOnTheSDKFollowsIt(t *testing.T) {
|
|
entries := []Entry{
|
|
{Manifest: catalogue.Manifest{Module: "mesh-sdk"}},
|
|
{Manifest: catalogue.Manifest{Module: "mesh-tools", Build: &catalogue.Build{
|
|
On: []catalogue.BuildsOn{{Arg: "MESH_SDK", Module: "mesh-sdk", Artifact: "lib"}}}}},
|
|
}
|
|
edges := dependenciesOf(entries, nil, nil)
|
|
found := false
|
|
for _, e := range edges {
|
|
if e.From == "mesh-tools" && e.To == "mesh-sdk" {
|
|
found = true
|
|
}
|
|
}
|
|
if !found {
|
|
t.Errorf("no edge from the toolchain to the SDK: %v", edges)
|
|
}
|
|
}
|
|
|
|
// novox/hq issue 278: nothing depends on the build agent but by being built by it. A plan is widened
|
|
// only along the other kinds (reachableFrom), so this is what keeps a change to the build agent — its
|
|
// manifest or its program — from rebuilding what it builds: the relation holds no edge to it that could.
|
|
func TestNothingStandsOnTheBuildAgentOnlyIsBuiltByIt(t *testing.T) {
|
|
const catalogueRepo = "http://forge/novox/mesh-catalog.git"
|
|
agent := Entry{Manifest: catalogue.Manifest{Module: "build-agent",
|
|
Claims: []catalogue.Claim{{Name: "node-build-agent", Scope: catalogue.ScopeNode}}},
|
|
Source: Source{Repository: catalogueRepo, Path: "modules/build-agent"}}
|
|
bundle := Entry{Manifest: catalogue.Manifest{Module: "redis", Build: &catalogue.Build{
|
|
Artifacts: []catalogue.Artifact{{Name: "code", Kind: catalogue.ArtifactBundle, Language: "typescript"}}}},
|
|
Source: Source{Repository: catalogueRepo, Path: "modules/redis"}}
|
|
entries := []Entry{
|
|
agent, bundle,
|
|
{Manifest: catalogue.Manifest{Module: "postgres"}, Source: Source{Repository: catalogueRepo, Path: "modules/postgres"}},
|
|
{Manifest: catalogue.Manifest{Module: "mesh-tools"}, Source: Source{Repository: "http://forge/novox/mesh-tools.git"}},
|
|
{Manifest: catalogue.Manifest{Module: TheControlPlane}, Source: Source{Repository: "http://forge/novox/mesh-controller.git"}},
|
|
}
|
|
// A module packaging another repository depends on what is built from it, never on the agent.
|
|
read := map[string][]ReadRepository{"postgres": {{Repository: "http://forge/novox/mesh-tools.git"}}}
|
|
builtBy := 0
|
|
for _, e := range dependenciesOf(entries, nil, read) {
|
|
if e.To != "build-agent" {
|
|
continue
|
|
}
|
|
if e.Kind != EdgeBuiltBy {
|
|
t.Errorf("%s depends on the build agent as %s: a change to the agent would rebuild it", e.From, e.Kind)
|
|
}
|
|
builtBy++
|
|
}
|
|
if builtBy != 4 {
|
|
t.Errorf("everything source-built is built by the agent: %d edges", builtBy)
|
|
}
|
|
}
|
|
|
|
// A copy of an upstream image is no module's artifact (novox/hq ADR 0257), even when a module happens to
|
|
// carry the name its repository starts with.
|
|
func TestACopyOfAnUpstreamImageIsNoEdge(t *testing.T) {
|
|
entries := []Entry{
|
|
{Manifest: catalogue.Manifest{Module: "route-proxy"}},
|
|
{Manifest: catalogue.Manifest{Module: "upstream"}},
|
|
}
|
|
against := map[string][]string{
|
|
"route-proxy": {catalogue.ArtifactStoreScheme + "upstream/docker.io/library/golang@sha256:a"},
|
|
}
|
|
for _, e := range dependenciesOf(entries, against, nil) {
|
|
if e.From == "route-proxy" && e.To == "upstream" {
|
|
t.Fatalf("a copy of an upstream image was read as a module's artifact: %+v", e)
|
|
}
|
|
}
|
|
}
|
|
|
|
// **A built module keeps its build edges** (novox/hq issue 614). A manifest the mesh registers from a
|
|
// build carries no `build` (catalogue.Resolve drops it), so mesh-tools' `build.on` naming mesh-sdk's
|
|
// `lib` package and a provider's TypeScript bundle drew no edge once built, and a new SDK rebuilt
|
|
// neither. The package base is read from what the build was handed (`@novox/mesh-sdk@0.1.13`, the
|
|
// package's name whichever version the mesh holds now), the toolchain from the bundles it keeps.
|
|
func TestABuiltModuleKeepsItsBuildEdges(t *testing.T) {
|
|
built := func(name string, bundles ...catalogue.Bundle) Entry {
|
|
return Entry{Manifest: catalogue.Manifest{Module: name, Bundles: bundles},
|
|
Source: Source{Repository: "http://forge/novox/" + name + ".git"}}
|
|
}
|
|
entries := []Entry{
|
|
built("mesh-sdk"),
|
|
built("mesh-tools"),
|
|
built("mesh-tools-go"),
|
|
built("minio", catalogue.Bundle{Name: "code", Language: "typescript"}),
|
|
built("umami", catalogue.Bundle{Name: "code", Language: "TypeScript"}),
|
|
built("dnsmasq", catalogue.Bundle{Name: "tools", Language: "go"}),
|
|
built("plain"),
|
|
}
|
|
against := map[string][]string{
|
|
"mesh-tools": {"@novox/mesh-sdk@0.1.13",
|
|
catalogue.ArtifactStoreScheme + "upstream/docker.io/library/node@sha256:" + strings.Repeat("0", 64)},
|
|
// A package nobody in the mesh publishes is no edge.
|
|
"plain": {"left-pad@1.3.0"},
|
|
}
|
|
held := map[string]string{
|
|
"mesh-sdk/lib": "@novox/mesh-sdk@0.1.14",
|
|
"mesh-tools/runtime": catalogue.ArtifactStoreScheme + "mesh-tools/runtime@sha256:" + strings.Repeat("1", 64),
|
|
}
|
|
got := dependenciesWith(entries, against, held)
|
|
has := func(from, to string) bool {
|
|
for _, e := range got {
|
|
if e.From == from && e.To == to && e.Kind == EdgeStandsOn {
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
for _, want := range [][2]string{
|
|
{"mesh-tools", "mesh-sdk"},
|
|
{"minio", "mesh-tools"},
|
|
{"umami", "mesh-tools"},
|
|
{"dnsmasq", "mesh-tools-go"},
|
|
} {
|
|
if !has(want[0], want[1]) {
|
|
t.Errorf("no %s stands-on %s: %+v", want[0], want[1], got)
|
|
}
|
|
}
|
|
for _, e := range got {
|
|
if e.From == "plain" && e.Kind != EdgeBuiltBy {
|
|
t.Errorf("an unknown package drew an edge: %+v", e)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestAPackageNameIsReadOnlyFromAPackageReference(t *testing.T) {
|
|
for ref, want := range map[string]string{
|
|
"@novox/mesh-sdk@0.1.14": "@novox/mesh-sdk",
|
|
"left-pad@1.3.0": "left-pad",
|
|
"@novox/mesh-sdk": "",
|
|
"novox.internal:5100/mesh-tools/build@sha256:" + strings.Repeat("0", 64): "",
|
|
catalogue.ArtifactStoreScheme + "mesh-tools/build@sha256:0": "",
|
|
"http://store/v2/x/blobs/sha256:0": "",
|
|
"": "",
|
|
} {
|
|
if got := packageName(ref); got != want {
|
|
t.Errorf("packageName(%q) = %q, want %q", ref, got, want)
|
|
}
|
|
}
|
|
}
|