The running pre-G indexer publishes a repository's packages only when every package directory it published last is
still in the tree; G moved contracts/go and sdk to modules/, so mesh-delivery's packages, G's renamed paths among them,
are never published and nothing importing them builds (2026-11-13, indexer journal 'its packages are not published').
These are the trees of e70754ef, unchanged, without sdk/module.json (no second module). Nothing imports them; they go
once G's indexer runs and publishes without them.
Claude-Session: https://claude.ai/code/session_01NcbgfGKaxw984XyAPfLm4h
163 lines
6.2 KiB
Go
163 lines
6.2 KiB
Go
package meshwantsclient
|
|
|
|
import (
|
|
"encoding/json"
|
|
"errors"
|
|
"reflect"
|
|
"strings"
|
|
"testing"
|
|
|
|
"git.novox.be/novox/mesh-sdk/go/keys"
|
|
)
|
|
|
|
func rep(c string) string { return strings.Repeat(c, 64) }
|
|
|
|
// TestWantsAreWhatTheEarlierCodecWrote holds the values and keys equal to what go/delivery's codec wrote for the same
|
|
// values (the golden texts are its output; the field order is the contract's now, so values are compared decoded), and the
|
|
// refusals it made.
|
|
func TestWantsAreWhatTheEarlierCodecWrote(t *testing.T) {
|
|
a, b, c, d := "src2:"+rep("a"), "src2:"+rep("b"), "sha256:"+rep("c"), "sha256:"+rep("d")
|
|
sameJSON := func(t *testing.T, got []byte, want string) {
|
|
t.Helper()
|
|
var g, w any
|
|
if err := json.Unmarshal(got, &g); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := json.Unmarshal([]byte(want), &w); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if !reflect.DeepEqual(g, w) {
|
|
t.Fatalf("wrote %s, the earlier codec wrote %s", got, want)
|
|
}
|
|
}
|
|
t.Run("wants", func(t *testing.T) {
|
|
for name, row := range map[string]struct {
|
|
w Want
|
|
golden string
|
|
}{
|
|
"composed": {Want{Fp: a, Composed: c, Words: "w"}, `{"v":1,"fp":"` + a + `","composed":"` + c + `","words":"w"}`},
|
|
"held back": {Want{Fp: a, Self: true, Newest: b, Rule: RuleGrant, Backup: BackupAgain, Words: "held"}, `{"v":1,"fp":"` + a + `","newest":"` + b + `","rule":6,"backup":"again","words":"held","self":true}`},
|
|
"put": {Want{Fp: a, Self: true, Put: true, Hold: true, Yes: d, Release: "r1"}, `{"v":1,"fp":"` + a + `","put":true,"hold":true,"yes":"` + d + `","release":"r1","self":true}`},
|
|
"removed": {Want{Removed: true, Words: "gone"}, `{"v":1,"removed":true,"words":"gone"}`},
|
|
} {
|
|
t.Run(name, func(t *testing.T) {
|
|
raw, err := EncodeWant(row.w)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
sameJSON(t, raw, row.golden)
|
|
back, err := DecodeWant(raw)
|
|
if err != nil || !SameWant(back, func() Want { w := row.w; w.V = keys.Version; return w }()) {
|
|
t.Fatalf("read back %+v, %v", back, err)
|
|
}
|
|
})
|
|
}
|
|
})
|
|
t.Run("refused", func(t *testing.T) {
|
|
for name, w := range map[string]Want{
|
|
"old fingerprint": {Fp: "src1:abc", Composed: c},
|
|
"no composition": {Fp: a},
|
|
"self and composition": {Fp: a, Self: true, Composed: c},
|
|
"hold without put": {Fp: a, Self: true, Hold: true},
|
|
"put held back": {Fp: a, Self: true, Put: true, Newest: b, Rule: RuleStep},
|
|
"removed names a rule": {Removed: true, Rule: 1},
|
|
"release without yes": {Fp: a, Self: true, Release: "r"},
|
|
"backup answer unknown": {Fp: a, Self: true, Backup: "later"},
|
|
"newest equals fp": {Fp: a, Self: true, Newest: a, Rule: RuleStep},
|
|
"rule 11": {Fp: a, Self: true, Newest: b, Rule: 11},
|
|
"newest without a rule": {Fp: a, Self: true, Newest: b},
|
|
"composition not sha256": {Fp: a, Composed: "sha256:xyz"},
|
|
} {
|
|
if _, err := EncodeWant(w); err == nil {
|
|
t.Errorf("%s: written", name)
|
|
}
|
|
}
|
|
if _, err := EncodeWant(Want{Fp: a, Self: true, Newest: b, Rule: 10}); err != nil {
|
|
t.Errorf("rule 10 is read: %v", err)
|
|
}
|
|
if _, err := DecodeWant([]byte(`{"fp":"` + a + `","self":true}`)); !errors.Is(err, keys.ErrUnknownVersion) {
|
|
t.Errorf("no version: %v", err)
|
|
}
|
|
if _, err := DecodeWant([]byte(`{"v":1,"fp":"` + a + `","self":true,"extra":1}`)); err == nil {
|
|
t.Error("an unknown field is read")
|
|
}
|
|
})
|
|
t.Run("node want and hold", func(t *testing.T) {
|
|
raw, err := EncodeNodeWant(NodeWant{Composed: c, Words: "n"})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
sameJSON(t, raw, `{"v":1,"composed":"`+c+`","words":"n"}`)
|
|
raw, err = EncodeNodeWant(NodeWant{Self: true})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
sameJSON(t, raw, `{"v":1,"composed":"","self":true}`)
|
|
if back, err := DecodeNodeWant(raw); err != nil || !back.Self {
|
|
t.Fatalf("%+v %v", back, err)
|
|
}
|
|
for name, w := range map[string]NodeWant{"none": {}, "both": {Self: true, Composed: c}, "bad": {Composed: "x"}} {
|
|
if _, err := EncodeNodeWant(w); err == nil {
|
|
t.Errorf("%s: written", name)
|
|
}
|
|
}
|
|
if _, err := DecodeNodeWant([]byte(`{"v":1,"composed":"` + c + `","fp":"` + a + `"}`)); err == nil {
|
|
t.Error("a fingerprint in a node's own want is read")
|
|
}
|
|
raw, err = EncodeHeld(Held{Node: "ace", Words: "unhealthy"})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
sameJSON(t, raw, `{"v":1,"node":"ace","words":"unhealthy"}`)
|
|
if h, err := DecodeHeld(raw); err != nil || !SameHeld(h, Held{V: 1, Node: "ace", Words: "unhealthy"}) {
|
|
t.Fatalf("%+v %v", h, err)
|
|
}
|
|
if _, err := EncodeHeld(Held{Node: "a.b"}); err == nil {
|
|
t.Error("a node with a dot is held")
|
|
}
|
|
})
|
|
t.Run("keys", func(t *testing.T) {
|
|
for _, row := range []struct{ module, want string }{
|
|
{"mesh-delivery-assigner", "want.ace.mesh-delivery-assigner"},
|
|
{"novox.be", "want.ace.novox=2ebe"},
|
|
} {
|
|
k, err := WantKey("ace", row.module)
|
|
if err != nil || k != row.want {
|
|
t.Fatalf("WantKey %s = %q, %v", row.module, k, err)
|
|
}
|
|
if n, m, err := ParseWantKey(k); err != nil || n != "ace" || m != row.module {
|
|
t.Fatalf("ParseWantKey %q = %q %q %v", k, n, m, err)
|
|
}
|
|
}
|
|
if k, err := HeldKey("mesh-delivery-assigner", a); err != nil || k != "held.mesh-delivery-assigner."+rep("a") {
|
|
t.Fatalf("HeldKey = %q %v", k, err)
|
|
}
|
|
if m, fp, err := ParseHeldKey("held.mesh-delivery-assigner." + rep("a")); err != nil || m != "mesh-delivery-assigner" || fp != a {
|
|
t.Fatalf("ParseHeldKey = %q %q %v", m, fp, err)
|
|
}
|
|
if k, err := WantNodeKey("ace"); err != nil || k != "want.ace.node" {
|
|
t.Fatalf("WantNodeKey = %q %v", k, err)
|
|
}
|
|
if n, err := ParseWantNodeKey("want.ace.node"); err != nil || n != "ace" {
|
|
t.Fatalf("ParseWantNodeKey = %q %v", n, err)
|
|
}
|
|
if _, err := WantKey("ace", "node"); err == nil {
|
|
t.Error("a module named node has a want key")
|
|
}
|
|
if _, err := HeldKey("novox.be", a); err == nil {
|
|
t.Error("a module with a dot has a held key")
|
|
}
|
|
for _, key := range []string{"want.ace.node", "held.m." + rep("a"), "ace.m", "want.ace", "want..m"} {
|
|
if _, _, err := ParseWantKey(key); err == nil {
|
|
t.Errorf("%q is a want key", key)
|
|
}
|
|
}
|
|
if _, err := ParseWantNodeKey("want.ace.m"); err == nil {
|
|
t.Error("a module's want is a node's own")
|
|
}
|
|
if _, _, err := ParseHeldKey("want.ace.m"); err == nil {
|
|
t.Error("a want key is a held key")
|
|
}
|
|
})
|
|
}
|