95 lines
3.3 KiB
Go
95 lines
3.3 KiB
Go
package manifests
|
|
|
|
import (
|
|
"os"
|
|
"path/filepath"
|
|
"strings"
|
|
"testing"
|
|
|
|
"git.novox.be/novox/mesh-sdk/go/catalogue"
|
|
)
|
|
|
|
// The tree's manifests are ones a judge can read, and no module is named twice. A row is a catalogue of its own: a
|
|
// manifest that is no JSON and two manifests of one module are refused, naming the file; a manifest with a field this
|
|
// check does not know is not (it judges nothing: the checker does, ADR 0578 §2). The catalogue itself passes.
|
|
func TestEveryManifestDecodesAndNamesOneModule(t *testing.T) {
|
|
for _, row := range []struct {
|
|
name string
|
|
files map[string]string
|
|
refused string
|
|
}{
|
|
{name: "a manifest the judge can read", files: map[string]string{"a": `{"module":"a","version":"1"}`}},
|
|
{name: "a field no part knows is the judge's to refuse", files: map[string]string{"a": `{"module":"a","version":"1","unheard":true}`}},
|
|
{name: "bytes that are no manifest", files: map[string]string{"a": `{"module":`}, refused: "modules/a/module.json"},
|
|
{name: "two manifests of one module", files: map[string]string{"a": `{"module":"x","version":"1"}`, "b": `{"module":"x","version":"1"}`},
|
|
refused: "two manifests name one module"},
|
|
} {
|
|
root := t.TempDir()
|
|
for dir, manifest := range row.files {
|
|
if err := os.MkdirAll(filepath.Join(root, "modules", dir), 0o755); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := os.WriteFile(filepath.Join(root, "modules", dir, "module.json"), []byte(manifest), 0o644); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
got, err := Problems(root)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
joined := strings.Join(got, "\n")
|
|
if (row.refused == "") != (len(got) == 0) || !strings.Contains(joined, row.refused) {
|
|
t.Errorf("%s: refused %q, want %q", row.name, joined, row.refused)
|
|
}
|
|
}
|
|
real, err := Problems(filepath.Join("..", ".."))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if len(real) != 0 {
|
|
t.Fatalf("the catalogue holds manifests no judge can read:\n%s", strings.Join(real, "\n"))
|
|
}
|
|
}
|
|
|
|
// No manifest of this catalogue claims the seat mesh-catalog: the indexer of the delivery holds it, and the module that
|
|
// held it before has dropped its claim (ADR 0604 §6). A row is a tree of its own: a manifest claiming it is named.
|
|
func TestNoManifestClaimsTheSeatMeshCatalog(t *testing.T) {
|
|
claimants := func(root string) []string {
|
|
files, err := filepath.Glob(filepath.Join(root, "modules", "*", "module.json"))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
var out []string
|
|
for _, f := range files {
|
|
raw, err := os.ReadFile(f)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
m, err := catalogue.Decode(raw)
|
|
if err != nil {
|
|
continue // Problems names it
|
|
}
|
|
for _, c := range m.Claims {
|
|
if c.Name == "mesh-catalog" {
|
|
out = append(out, m.Module)
|
|
}
|
|
}
|
|
}
|
|
return out
|
|
}
|
|
row := t.TempDir()
|
|
if err := os.MkdirAll(filepath.Join(row, "modules", "a"), 0o755); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := os.WriteFile(filepath.Join(row, "modules", "a", "module.json"),
|
|
[]byte(`{"module":"a","version":"1","claims":[{"name":"mesh-catalog","scope":"mesh"}]}`), 0o644); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if got := claimants(row); len(got) != 1 || got[0] != "a" {
|
|
t.Fatalf("a manifest claiming the seat is named, got %v", got)
|
|
}
|
|
if got := claimants(filepath.Join("..", "..")); len(got) != 0 {
|
|
t.Errorf("the catalogue's manifests %v claim the seat mesh-catalog: the indexer of the delivery holds it", got)
|
|
}
|
|
}
|