jschoubben
953446cc8f
mesh/merge-gate out of date: judged against trunk f692fe7da89d, the trunk is now 238440d6f8c4; judged again on a recheck or when it is merged
mesh/repo-check out of date: judged against trunk f692fe7da89d, the trunk is now 238440d6f8c4; judged again on a recheck or when it is merged
mesh/delivery delivered
ADR 0433 §2, §3: the watchman writes what stopped moving and the controller's self-check raises it, so the key and value live in the SDK (ADR 0429 §2).
89 lines
3.1 KiB
Go
89 lines
3.1 KiB
Go
package delivery
|
|
|
|
import (
|
|
"encoding/json"
|
|
"errors"
|
|
"strings"
|
|
"testing"
|
|
"time"
|
|
)
|
|
|
|
// 1153/AC4: the watchman's module and its three buckets, each that module's state.
|
|
func TestWatchmanBuckets(t *testing.T) {
|
|
if WatchmanModule != "mesh-delivery-watchman" {
|
|
t.Fatalf("WatchmanModule = %q", WatchmanModule)
|
|
}
|
|
for name, bucket := range map[string]string{"presence": PresenceBucket, "pulse": PulseBucket, "stuck": StuckBucket} {
|
|
if bucket != WatchmanModule+"_"+name {
|
|
t.Errorf("the %s bucket is %q, not %s_%s", name, bucket, WatchmanModule, name)
|
|
}
|
|
}
|
|
}
|
|
|
|
// 1153/AC1: the stuck key is the stopped key's bucket and key, split at the first dot, refused as a pulse key is.
|
|
func TestStuckKey(t *testing.T) {
|
|
key, err := StuckKey(PresenceBucket, "ace")
|
|
if err != nil || key != "mesh-delivery-watchman_presence.ace" {
|
|
t.Fatalf("StuckKey = %q, %v", key, err)
|
|
}
|
|
key, err = StuckKey("mesh-controller_builds", "zsh.build.b-1")
|
|
if err != nil || key != "mesh-controller_builds.zsh.build.b-1" {
|
|
t.Fatalf("StuckKey = %q, %v", key, err)
|
|
}
|
|
bucket, rest, err := ParseStuckKey(key)
|
|
if err != nil || bucket != "mesh-controller_builds" || rest != "zsh.build.b-1" {
|
|
t.Fatalf("ParseStuckKey = %q %q %v", bucket, rest, err)
|
|
}
|
|
for _, c := range [][2]string{{"", "k"}, {"a.b", "k"}, {"b", ""}, {"b", "k x"}, {"b", ".k"}, {"b", "k."}, {"b", "k>"}} {
|
|
if _, err := StuckKey(c[0], c[1]); err == nil {
|
|
t.Errorf("StuckKey(%q, %q) accepted", c[0], c[1])
|
|
}
|
|
}
|
|
for _, bad := range []string{"", "nodot", ".k", "b."} {
|
|
if _, _, err := ParseStuckKey(bad); err == nil {
|
|
t.Errorf("ParseStuckKey(%q) accepted", bad)
|
|
}
|
|
}
|
|
}
|
|
|
|
// 1153/AC2: a stuck value round-trips with "v":1, and an unknown or missing version is refused loudly.
|
|
func TestStuckValue(t *testing.T) {
|
|
s := Stuck{Bucket: PresenceBucket, Key: "ace", Waited: "ace to come back online",
|
|
Since: time.Date(2026, 10, 18, 20, 0, 0, 0, time.UTC)}
|
|
raw, err := EncodeStuck(s)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
var probe map[string]any
|
|
if err := json.Unmarshal(raw, &probe); err != nil || probe["v"] != float64(1) {
|
|
t.Fatalf("encoded %s: v = %v (%v)", raw, probe["v"], err)
|
|
}
|
|
back, err := DecodeStuck(raw)
|
|
s.V = Version
|
|
if err != nil || !SameStuck(back, s) {
|
|
t.Fatalf("decoded %+v, %v; want %+v", back, err, s)
|
|
}
|
|
for _, bad := range []string{`{"v":2,"bucket":"b","key":"k"}`, `{"bucket":"b","key":"k"}`} {
|
|
_, err := DecodeStuck([]byte(bad))
|
|
if !errors.Is(err, ErrUnknownVersion) {
|
|
t.Errorf("DecodeStuck(%s) = %v, want ErrUnknownVersion", bad, err)
|
|
}
|
|
if strings.Contains(bad, `"v":2`) && (err == nil || !strings.Contains(err.Error(), "2") || !strings.Contains(err.Error(), "1")) {
|
|
t.Errorf("DecodeStuck(%s) = %v: does not name the version seen and the one read", bad, err)
|
|
}
|
|
}
|
|
}
|
|
|
|
// 1153/AC3: equal stuck values are the same; one moved is not.
|
|
func TestSameStuck(t *testing.T) {
|
|
a := Stuck{V: Version, Bucket: "b", Key: "k", Waited: "w", Since: time.Unix(100, 0).UTC()}
|
|
b := a
|
|
if !SameStuck(a, b) {
|
|
t.Fatal("equal values are not the same")
|
|
}
|
|
b.Moved = true
|
|
if SameStuck(a, b) {
|
|
t.Fatal("a moved value is the same as a stuck one")
|
|
}
|
|
}
|