jschoubben
934c736fcf
take ends its preview with a digest and --yes names it, as the flip does; a changed preview or an account older than the flip allows is refused. A module the machine holds nothing for has nothing to compare, and --yes suffices. A published port's reach is said as the machine reported it. Every secret the module holds on the machine is listed with where it came from, and one the mesh minted for a service whose data was found refuses unless --mint names it. One judgement of a module's settings against its definition, in the catalogue: settings set refuses what cannot compose or reaches nothing, naming node, module, layer and key; Compose leaves out a module whose definition moved under a stored setting, the envelope says so (left_out), plan and push say it by name, and the machine is told everything else. A stray setting no longer refuses the whole machine where it is read (issue 096). The per-machine setting networks keeps a found network for a taken container, on an adopted machine only; the container's declaration carries it and the preview names it (rule 4).
182 lines
7.7 KiB
Go
182 lines
7.7 KiB
Go
package catalogue
|
|
|
|
import (
|
|
"strings"
|
|
"testing"
|
|
)
|
|
|
|
// The case novox/hq issue 153 records: an adopted machine keeps its data where the predecessor put
|
|
// it — a library on its own pool that must never move, a configuration on a second disk owned by
|
|
// whoever the predecessor ran as. A definition may name none of that (ADR 0112); the assignment
|
|
// says it, by the ids the definition declared, and the machine receives concrete paths as always.
|
|
func placeable() Manifest {
|
|
m := mod("arr", nil, nil, nil)
|
|
m.Resources = []map[string]any{
|
|
{"id": "state", "type": "directory", "place": ".", "mode": "0700"},
|
|
{"id": "config", "type": "directory", "mode": "0755", "owner": "1000:1000"},
|
|
{"id": "server", "type": "container", "name": "arr", "image": "arr:1",
|
|
"volumes": []any{"${dir:config}:/config", "${access:series}:/series", "${access:spool}:/downloads:ro"},
|
|
"env": map[string]any{"SPOOL": "${access:spool}"}},
|
|
}
|
|
m.Accesses = []Access{{ID: "series", Mode: AccessReadWrite}, {ID: "spool"}}
|
|
return m
|
|
}
|
|
|
|
func placedBy(values map[string]any) Rendering {
|
|
return Rendering{Settings: SettingsBy{"arr": {{From: "node anchor", Values: values}}}}
|
|
}
|
|
|
|
func TestAnAssignmentPlacesDirectoriesAndAccesses(t *testing.T) {
|
|
got, err := Resolve(shelf(placeable()), []string{"arr"}, workstation(), World{})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
out, err := got.Declaration(placedBy(map[string]any{
|
|
PlacesSetting: map[string]any{
|
|
"config": map[string]any{"path": "/services/arr/config/", "owner": "1001:2000"},
|
|
},
|
|
AccessesSetting: map[string]any{
|
|
"series": "/storage/media/series",
|
|
"spool": "/storage/downloads",
|
|
},
|
|
}))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
seen := map[string]map[string]any{}
|
|
for _, r := range out {
|
|
seen[r["id"].(string)] = r
|
|
}
|
|
config := seen["arr.config"]
|
|
if config["path"] != "/services/arr/config" || config["owner"] != "1001:2000" {
|
|
t.Fatalf("the placed directory is %v %v; want the assignment's path and owner", config["path"], config["owner"])
|
|
}
|
|
if seen["arr.state"]["path"] != "/var/lib/arr" {
|
|
t.Fatalf("an unplaced directory left the default layout: %v", seen["arr.state"]["path"])
|
|
}
|
|
var accesses []string
|
|
for _, r := range out {
|
|
if r["type"] == "access" {
|
|
accesses = append(accesses, r["path"].(string)+" "+r["mode"].(string))
|
|
}
|
|
}
|
|
if strings.Join(accesses, ",") != "/storage/media/series read-write,/storage/downloads read" {
|
|
t.Fatalf("the accesses reached the machine as %v", accesses)
|
|
}
|
|
server := seen["arr.server"]
|
|
mounts := server["volumes"].([]any)
|
|
if mounts[0] != "/services/arr/config:/config" || mounts[1] != "/storage/media/series:/series" ||
|
|
mounts[2] != "/storage/downloads:/downloads:ro" {
|
|
t.Fatalf("the mounts were not filled with the placed paths: %v", mounts)
|
|
}
|
|
if server["env"].(map[string]any)["SPOOL"] != "/storage/downloads" {
|
|
t.Fatalf("the environment was not filled: %v", server["env"])
|
|
}
|
|
}
|
|
|
|
// An access declared by id and placed by nobody resolves to nowhere, and that is refused with the
|
|
// setting to write — not mounted as the literal, not skipped. The refusal costs the module its
|
|
// place in the declaration, not the machine its declaration (novox/hq ADR 0163, rule 6).
|
|
func TestAnUnplacedAccessIsRefusedByName(t *testing.T) {
|
|
got, err := Resolve(shelf(placeable()), []string{"arr"}, workstation(), World{})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
with := placedBy(map[string]any{
|
|
AccessesSetting: map[string]any{"series": "/storage/media/series"},
|
|
})
|
|
composed, err := got.Compose(with)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
why := composed.LeftOut["arr"]
|
|
if why == "" || !strings.Contains(why, `"spool"`) || !strings.Contains(why, AccessesSetting) {
|
|
t.Fatalf("an access nobody placed was not refused by name: %v", composed.LeftOut)
|
|
}
|
|
if _, declared := byID(composed.Resources)["arr.server"]; declared {
|
|
t.Fatal("the module with the unplaced access was declared anyway")
|
|
}
|
|
}
|
|
|
|
// Validated like endpoints: an id the module does not declare reaches nothing, and the refusal
|
|
// says what it does declare; a relative path and a non-numeric owner are refused too.
|
|
func TestPlacementsAreValidated(t *testing.T) {
|
|
m := placeable()
|
|
layers := func(values map[string]any) []Layer { return placedBy(values).Settings["arr"] }
|
|
|
|
_, err := Places(m, layers(map[string]any{PlacesSetting: map[string]any{"data": "/mnt/data"}}))
|
|
if err == nil || !strings.Contains(err.Error(), "does not declare") || !strings.Contains(err.Error(), `"config"`) {
|
|
t.Fatalf("placing an undeclared directory was accepted: %v", err)
|
|
}
|
|
_, err = Places(m, layers(map[string]any{PlacesSetting: map[string]any{"config": "services/arr"}}))
|
|
if err == nil || !strings.Contains(err.Error(), "absolute") {
|
|
t.Fatalf("a relative placement was accepted: %v", err)
|
|
}
|
|
_, err = Places(m, layers(map[string]any{PlacesSetting: map[string]any{
|
|
"config": map[string]any{"path": "/services/arr", "owner": "media"}}}))
|
|
if err == nil || !strings.Contains(err.Error(), "uid:gid") {
|
|
t.Fatalf("a non-numeric owner was accepted: %v", err)
|
|
}
|
|
_, err = AccessPlaces(m, layers(map[string]any{AccessesSetting: map[string]any{"movies": "/storage/media/movies"}}))
|
|
if err == nil || !strings.Contains(err.Error(), "does not declare") || !strings.Contains(err.Error(), `"series"`) {
|
|
t.Fatalf("placing an undeclared access was accepted: %v", err)
|
|
}
|
|
_, err = AccessPlaces(m, layers(map[string]any{AccessesSetting: map[string]any{"series": "media/series"}}))
|
|
if err == nil || !strings.Contains(err.Error(), "absolute") {
|
|
t.Fatalf("a relative access was accepted: %v", err)
|
|
}
|
|
// And the two keys are never stray: they are validated here, not merged into a file.
|
|
if stray := UnusedSettings(m, layers(map[string]any{
|
|
PlacesSetting: map[string]any{"config": "/services/arr/config"},
|
|
AccessesSetting: map[string]any{"series": "/storage/media/series"},
|
|
})); len(stray) != 0 {
|
|
t.Fatalf("the placement keys were reported as unused: %v", stray)
|
|
}
|
|
}
|
|
|
|
// A definition that carries a path still works, as the default the assignment may replace — and
|
|
// the assignment's placement wins where both say.
|
|
func TestADefinitionsPathIsTheDefaultTheAssignmentReplaces(t *testing.T) {
|
|
m := placeable()
|
|
m.Accesses = []Access{{ID: "series", Path: "/services/media/series", Mode: AccessReadWrite}, {ID: "spool", Path: "/services/media/downloads"}}
|
|
got, err := Resolve(shelf(m), []string{"arr"}, workstation(), World{})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
out, err := got.Declaration(placedBy(map[string]any{
|
|
PlacesSetting: map[string]any{"config": "/services/arr/config"},
|
|
AccessesSetting: map[string]any{"series": "/storage/media/series"},
|
|
}))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
var paths []string
|
|
for _, r := range out {
|
|
if r["type"] == "access" {
|
|
paths = append(paths, r["path"].(string))
|
|
}
|
|
}
|
|
if strings.Join(paths, ",") != "/storage/media/series,/services/media/downloads" {
|
|
t.Fatalf("placed one, defaulted the other: got %v", paths)
|
|
}
|
|
}
|
|
|
|
// A reference to an access the definition does not declare is refused where the author is.
|
|
func TestAnUnknownAccessReferenceIsRefusedAtParse(t *testing.T) {
|
|
_, err := ParseManifest([]byte(`{
|
|
"module": "arr", "version": "1",
|
|
"accesses": [{"id": "series", "mode": "read-write"}],
|
|
"resources": [
|
|
{"id": "state", "type": "directory", "place": ".", "mode": "0700"},
|
|
{"id": "server", "type": "container", "name": "arr", "image": "arr:1",
|
|
"volumes": ["${access:movies}:/movies"]}
|
|
]}`))
|
|
if err == nil || !strings.Contains(err.Error(), "${access:movies}") {
|
|
t.Fatalf("a reference to an undeclared access was accepted: %v", err)
|
|
}
|
|
_, err = ParseManifest([]byte(`{"module": "arr", "version": "1", "accesses": [{"mode": "read"}]}`))
|
|
if err == nil || !strings.Contains(err.Error(), "neither an id nor a path") {
|
|
t.Fatalf("an access with no id and no path was accepted: %v", err)
|
|
}
|
|
}
|