225 lines
8.8 KiB
Go
225 lines
8.8 KiB
Go
package inventory
|
||
|
||
import (
|
||
"encoding/json"
|
||
"fmt"
|
||
"strings"
|
||
"testing"
|
||
|
||
"github.com/novox/mesh-controller/internal/catalogue"
|
||
)
|
||
|
||
// novox/hq ADR 0325 §3, §11: a module gets one allocation, the same whoever asks and however often, from the range
|
||
// of its own; no allocation is 0 or a root group's; a number once given is never given again.
|
||
func TestAModuleIsGivenOneIdentityOnceAndNeverRoot(t *testing.T) {
|
||
inv := fresh(t)
|
||
ctx := t.Context()
|
||
radarr, err := inv.AllocateIdentity(ctx, "radarr")
|
||
if err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
again, err := inv.AllocateIdentity(ctx, "radarr")
|
||
if err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
if radarr != again {
|
||
t.Fatalf("radarr was given %+v, then %+v: one allocation per module", radarr, again)
|
||
}
|
||
plex, err := inv.AllocateIdentity(ctx, "plex")
|
||
if err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
for _, id := range []catalogue.ModuleIdentity{radarr, plex} {
|
||
if id.UID == 0 || id.GID == 0 || !catalogue.AllocatableID(id.UID) || !catalogue.AllocatableID(id.GID) ||
|
||
id.UID != id.GID {
|
||
t.Errorf("%s was given %d:%d: within %d–%d, never 0, uid and gid one number", id.Module, id.UID, id.GID,
|
||
catalogue.IdentityLow, catalogue.IdentityHigh)
|
||
}
|
||
}
|
||
if radarr.UID == plex.UID {
|
||
t.Fatalf("radarr and plex share %d", plex.UID)
|
||
}
|
||
|
||
// Read back as composition reads it, from another connection's view: the same numbers (stable across restarts
|
||
// and machines, since every machine's composition reads this one row).
|
||
all, err := inv.Identities(ctx)
|
||
if err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
if all["radarr"].UID != radarr.UID || all["plex"].UID != plex.UID {
|
||
t.Fatalf("the identities read back are %+v", all)
|
||
}
|
||
|
||
// A module forgotten keeps its row, and the next module is given a new number: never one given before.
|
||
if _, err := inv.store.Pool().Exec(ctx, `delete from module_identity where module = 'plex'`); err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
sonarr, err := inv.AllocateIdentity(ctx, "sonarr")
|
||
if err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
if sonarr.UID == plex.UID || sonarr.UID == radarr.UID {
|
||
t.Fatalf("sonarr was given %d, a number given before", sonarr.UID)
|
||
}
|
||
|
||
// The store itself refuses a number outside the range, root's above all: no write by hand makes one root.
|
||
for _, n := range []int{0, 10, 1000, 49999, 60000} {
|
||
if _, err := inv.store.Pool().Exec(ctx,
|
||
`insert into module_identity (module, uid, gid) values ($1, $2, $2)`, "byhand", n); err == nil {
|
||
t.Errorf("the store took %d as an identity", n)
|
||
}
|
||
}
|
||
}
|
||
|
||
// novox/hq ADR 0325 §8: a folder taken is recorded once per machine, under a warrant, and read back by its path.
|
||
func TestAFolderIsTakenOnceUnderAWarrant(t *testing.T) {
|
||
inv := fresh(t)
|
||
ctx := t.Context()
|
||
if _, err := inv.AddNode(ctx, "ace"); err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
if err := inv.RecordTaken(ctx, "ace", TakenFolder{Path: "/storage/media/movies/", By: "the operator"}); err == nil {
|
||
t.Fatal("a folder was recorded taken with no warrant")
|
||
}
|
||
first := TakenFolder{Path: "/storage/media/movies/", By: "the operator", Ask: "c01", Warrant: "c01", Said: "started"}
|
||
if err := inv.RecordTaken(ctx, "ace", first); err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
if err := inv.RecordTaken(ctx, "ace", TakenFolder{Path: "/storage/media/movies", By: "someone else", Ask: "c02",
|
||
Warrant: "c02"}); err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
kept, err := inv.KeptFolders(ctx, "ace")
|
||
if err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
got, has := kept["/storage/media/movies"]
|
||
if !has || got.Ask != "c01" || got.By != "the operator" {
|
||
t.Fatalf("the taken folder reads %+v (%v): the first take, by its clean path", got, has)
|
||
}
|
||
// The folder moved to another filesystem and the operator was asked again: the new take replaces the old.
|
||
if err := inv.RecordTaken(ctx, "ace", TakenFolder{Path: "/storage/media/movies", By: "the operator", Ask: "c03",
|
||
Warrant: "c03", Placed: "fs-0000000000ff"}); err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
kept, err = inv.KeptFolders(ctx, "ace")
|
||
if err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
if got := kept["/storage/media/movies"]; got.Ask != "c03" || got.Placed != "fs-0000000000ff" {
|
||
t.Fatalf("after a take on another filesystem the folder reads %+v", got)
|
||
}
|
||
}
|
||
|
||
// novox/hq issue 575: a module registered without the access movies, whose newest build on its branch declares it —
|
||
// the build the delivery under way brings — takes a proposal placing movies: judged against that build, not refused.
|
||
// Without such a build it is refused, as before.
|
||
func TestAPlacementIsJudgedAgainstTheBuildThatBringsTheAccess(t *testing.T) {
|
||
inv := fresh(t)
|
||
ctx := t.Context()
|
||
if _, err := inv.AddNode(ctx, "ace"); err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
registered := catalogue.Manifest{Module: "media-importer", Version: "1",
|
||
Accesses: []catalogue.Access{{ID: "downloads", Path: "/services/media/downloads", Mode: catalogue.AccessReadWrite}},
|
||
Resources: []map[string]any{{"id": "server", "type": "container", "name": "importer", "image": "x",
|
||
"volumes": []any{"${access:downloads}:/downloads"}}}}
|
||
if err := inv.RegisterModule(ctx, registered, Source{Repository: "https://forge.invalid/media.git",
|
||
Ref: "main", BuiltFrom: "c0ffee33"}); err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
placing := map[string]any{catalogue.AccessesSetting: map[string]any{"movies": "/storage/media/movies"}}
|
||
|
||
err := inv.JudgeSettings(ctx, "ace", "media-importer", placing)
|
||
if err == nil || !strings.Contains(err.Error(), `places the access "movies", which it does not declare`) {
|
||
t.Fatalf("a placement no build declares: %v", err)
|
||
}
|
||
|
||
// main's manifest — the build of #34 — declares movies.
|
||
ahead := registered
|
||
ahead.Accesses = append([]catalogue.Access{}, registered.Accesses...)
|
||
ahead.Accesses = append(ahead.Accesses, catalogue.Access{ID: "movies", Path: "/services/media/movies",
|
||
Mode: catalogue.AccessReadWrite})
|
||
raw, err := json.Marshal(ahead)
|
||
if err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
b := aBuild("b34", "media-importer", "")
|
||
b.Ref, b.Manifest = "main", raw
|
||
if err := inv.RecordBuild(ctx, b); err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
if err := inv.JudgeSettings(ctx, "ace", "media-importer", placing); err != nil {
|
||
t.Fatalf("the proposal placing movies, which main's build declares, was refused: %v", err)
|
||
}
|
||
if err := inv.SetSettings(ctx, "ace", "media-importer", placing); err != nil {
|
||
t.Fatalf("the layer placing movies was not stored: %v", err)
|
||
}
|
||
// Stored ahead, it does not cost the registered module its place: composition passes it by.
|
||
layers, err := inv.SettingsFor(ctx, "ace", "media-importer")
|
||
if err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
if err := catalogue.ComposesWith(registered, layers, false); err != nil {
|
||
t.Fatalf("the registered module no longer composes with the layer stored ahead: %v", err)
|
||
}
|
||
// A typo is still a typo: an access neither build declares is refused.
|
||
typo := map[string]any{catalogue.AccessesSetting: map[string]any{"moveis": "/storage/media/movies"}}
|
||
if err := inv.JudgeSettings(ctx, "ace", "media-importer", typo); err == nil {
|
||
t.Fatal("a placement no build declares was taken")
|
||
}
|
||
}
|
||
|
||
// Review of e1c2b744: only a build of the branch the module's record follows judges a placement ahead of it — never one
|
||
// from another branch, nor one with no branch, and a module registered with no branch is refused as before, saying so.
|
||
func TestOnlyABuildOfTheFollowedBranchJudgesAPlacementAhead(t *testing.T) {
|
||
inv := fresh(t)
|
||
ctx := t.Context()
|
||
if _, err := inv.AddNode(ctx, "ace"); err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
registered := catalogue.Manifest{Module: "importer", Version: "1",
|
||
Resources: []map[string]any{{"id": "server", "type": "container", "name": "importer", "image": "x"}}}
|
||
ahead := registered
|
||
ahead.Accesses = []catalogue.Access{{ID: "movies", Path: "/services/media/movies", Mode: catalogue.AccessReadWrite}}
|
||
raw, err := json.Marshal(ahead)
|
||
if err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
placing := map[string]any{catalogue.AccessesSetting: map[string]any{"movies": "/storage/media/movies"}}
|
||
if err := inv.RegisterModule(ctx, registered, Source{Repository: "https://forge.invalid/media.git", Ref: "main",
|
||
BuiltFrom: "c0ffee"}); err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
for i, ref := range []string{"feature", ""} {
|
||
b := aBuild(fmt.Sprintf("elsewhere%d", i), "importer", "")
|
||
b.Ref, b.Manifest = ref, raw
|
||
if err := inv.RecordBuild(ctx, b); err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
}
|
||
if err := inv.JudgeSettings(ctx, "ace", "importer", placing); err == nil {
|
||
t.Fatal("a build of another branch, or of none, judged the placement")
|
||
}
|
||
// Registered by hand, with no branch: refused, saying why.
|
||
byHand := registered
|
||
byHand.Module = "byhand"
|
||
if err := inv.RegisterModule(ctx, byHand, Source{}); err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
aheadByHand := ahead
|
||
aheadByHand.Module = "byhand"
|
||
if raw, err = json.Marshal(aheadByHand); err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
b := aBuild("onmain", "byhand", "")
|
||
b.Ref, b.Manifest = "main", raw
|
||
if err := inv.RecordBuild(ctx, b); err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
if err := inv.JudgeSettings(ctx, "ace", "byhand", placing); err == nil ||
|
||
!strings.Contains(err.Error(), "follows no branch") {
|
||
t.Fatalf("a module with no branch recorded: %v", err)
|
||
}
|
||
}
|