package meshdeliverycheckerclient import ( "encoding/json" "strings" "testing" checker "git.novox.be/novox/mesh-delivery/contracts/go/seats/meshdeliverychecker" ) type verdict = checker.VerdictsByGroupHeadsValue func passing() verdict { return verdict{Group: "g", Heads: "0123456789ab", State: VerdictPass, Trunk: map[string]string{"novox/a": "c1"}, Levels: map[string]checker.VerdictsByGroupHeadsValueLevelsValue{LevelUnit: {Run: 3}, LevelIntegration: {Run: 1}}} } // The rules a verdict keeps to be written or read: each case edits a passing verdict and names what the refusal says. func TestAVerdictIsRefusedForWhatAReaderCouldNotPlace(t *testing.T) { if err := CheckVerdict(passing()); err != nil { t.Fatalf("a passing verdict is refused: %v", err) } for name, c := range map[string]struct { edit func(*verdict) says string }{ "no group": {func(v *verdict) { v.Group = "" }, "no group"}, "heads of 11 digits": {func(v *verdict) { v.Heads = "0123456789a" }, "12 lowercase hex"}, "an empty trunk head": {func(v *verdict) { v.Trunk["novox/a"] = "" }, "trunk head"}, "merged and read": {func(v *verdict) { v.Beside = map[string]string{"novox/a": "c2"} }, "trunk it merged and as a sibling"}, "nothing carried": {func(v *verdict) { v.CarriedFrom = map[string]string{"novox/a": "c1"} }, "nothing moved"}, "a running carry": {func(v *verdict) { v.State, v.CarriedFrom = VerdictRunning, map[string]string{"novox/a": "c0"} }, "carried from nothing"}, "a series to itself": {func(v *verdict) { v.Series = []checker.VerdictsByGroupHeadsValueSeriesItem{{Module: "m", Artifact: "a", From: "0.1", To: "0.1"}} }, "same series"}, "an unknown level": {func(v *verdict) { v.Levels["smoke"] = checker.VerdictsByGroupHeadsValueLevelsValue{} }, "smoke"}, "a negative count": {func(v *verdict) { v.Levels[LevelUnit] = checker.VerdictsByGroupHeadsValueLevelsValue{Run: -1} }, "negative"}, "a negative time": {func(v *verdict) { v.Took = &checker.VerdictsByGroupHeadsValueTook{Unit: -1} }, "negative"}, "a pass without a level": {func(v *verdict) { delete(v.Levels, LevelIntegration) }, "integration level"}, "a pass that failed": {func(v *verdict) { v.Failed = &checker.VerdictsByGroupHeadsValueFailed{Test: "T"} }, "names no failure"}, "failures of a pass": {func(v *verdict) { v.Failures = []checker.VerdictsByGroupHeadsValueFailuresItem{{Test: "T"}} }, "names no failures"}, "a fail naming nothing": {func(v *verdict) { v.State = VerdictFail }, "neither a test nor a machine"}, "an unknown state": {func(v *verdict) { v.State = "maybe" }, "maybe"}, "a composition passed without a commit": {func(v *verdict) { v.Composition = &checker.VerdictsByGroupHeadsValueComposition{State: CompositionPass} }, "mesh-sdk commit"}, "the same level over bound twice": {func(v *verdict) { v.OverBound = []string{LevelUnit, LevelUnit} }, "twice"}, // 1921 (B0, G): the checking program that judged it. "judged at no full commit": {func(v *verdict) { j := judgedBy(); j.Program.Commit = "0123456"; v.JudgedBy = &j }, "checking program built at no repository, full commit"}, "judged under no key": {func(v *verdict) { j := judgedBy(); j.Key = "composer-1"; v.JudgedBy = &j }, "composer-1"}, "judged over no head": {func(v *verdict) { j := judgedBy(); j.Heads = nil; v.JudgedBy = &j }, "no head"}, "judged over a branch": {func(v *verdict) { j := judgedBy(); j.Heads[0].Commit = "main"; v.JudgedBy = &j }, "novox/mesh-delivery"}, } { v := passing() c.edit(&v) if err := CheckVerdict(v); err == nil || !strings.Contains(err.Error(), c.says) { t.Errorf("%s: %v, want a refusal saying %q", name, err, c.says) } } judged := passing() j := judgedBy() judged.JudgedBy = &j if err := CheckVerdict(judged); err != nil { t.Errorf("a pass judged by a checking program is refused: %v", err) } failed := passing() failed.State, failed.Failed = VerdictFail, &checker.VerdictsByGroupHeadsValueFailed{Machine: "ace"} if err := CheckVerdict(failed); err != nil { t.Errorf("a fail naming a machine is refused: %v", err) } } func TestAKeptVerdictIsAPassOfAPackageAtALevel(t *testing.T) { t.Run("a preview is refused for what a reader of candidates could not place", previewIsRefused) ok := checker.KeptByLevelDigestValue{State: VerdictPass, Repository: "novox/mesh-sdk", Package: "./go/keys", Level: LevelUnit, Toolchain: "1.26.0", At: "2026-11-05T10:00:00Z"} if err := CheckKept(ok); err != nil { t.Fatalf("a kept pass is refused: %v", err) } for name, edit := range map[string]func(*checker.KeptByLevelDigestValue){ "a fail": func(k *checker.KeptByLevelDigestValue) { k.State = VerdictFail }, "no owner": func(k *checker.KeptByLevelDigestValue) { k.Repository = "mesh-sdk" }, "no package": func(k *checker.KeptByLevelDigestValue) { k.Package = "" }, "an unknown level": func(k *checker.KeptByLevelDigestValue) { k.Level = "smoke" }, "negative tests": func(k *checker.KeptByLevelDigestValue) { k.Tests = -1 }, "no toolchain": func(k *checker.KeptByLevelDigestValue) { k.Toolchain = "" }, "no time": func(k *checker.KeptByLevelDigestValue) { k.At = "" }, } { k := ok edit(&k) if CheckKept(k) == nil { t.Errorf("%s was taken", name) } } } // A preview is refused for what a reader of candidates could not place. func previewIsRefused(t *testing.T) { good := func() checker.PreviewsByRepositoryHeadTrunkValue { return checker.PreviewsByRepositoryHeadTrunkValue{Repository: "novox/a", Head: "h1", Trunk: "t1", Merge: "m1", Modules: map[string]checker.PreviewsByRepositoryHeadTrunkValueModulesValue{"mod": {Tree: "tr", Manifest: strings.Repeat("a", 64), Locks: map[string]string{"go.sum": "x"}, Paths: map[string]string{"src": "o1"}}}} } if err := CheckPreview(good()); err != nil { t.Fatalf("a good preview is refused: %v", err) } for name, c := range map[string]struct { edit func(*checker.PreviewsByRepositoryHeadTrunkValue) says string }{ "a repository with no owner": {func(p *checker.PreviewsByRepositoryHeadTrunkValue) { p.Repository = "a" }, "/"}, "a head with a dot": {func(p *checker.PreviewsByRepositoryHeadTrunkValue) { p.Head = "h.1" }, "head"}, "a conflict with a merge": {func(p *checker.PreviewsByRepositoryHeadTrunkValue) { p.Conflicts = []string{"f"} }, "in conflict"}, "no merge commit": {func(p *checker.PreviewsByRepositoryHeadTrunkValue) { p.Merge = "" }, "no merge commit"}, "a module with no tree": {func(p *checker.PreviewsByRepositoryHeadTrunkValue) { m := p.Modules["mod"] m.Tree = "" p.Modules["mod"] = m }, "no tree"}, "a short manifest digest": {func(p *checker.PreviewsByRepositoryHeadTrunkValue) { m := p.Modules["mod"] m.Manifest = "abc" p.Modules["mod"] = m }, "manifest digest"}, "a path outside the module": {func(p *checker.PreviewsByRepositoryHeadTrunkValue) { m := p.Modules["mod"] m.Paths = map[string]string{"../x": "o"} p.Modules["mod"] = m }, "clean path"}, } { p := good() c.edit(&p) if err := CheckPreview(p); err == nil || !strings.Contains(err.Error(), c.says) { t.Errorf("%s: CheckPreview = %v, want it to say %q", name, err, c.says) } } if err := CheckPreview(checker.PreviewsByRepositoryHeadTrunkValue{Repository: "novox/a", Head: "h", Trunk: "t", Conflicts: []string{"f"}}); err != nil { t.Errorf("a head in conflict is refused: %v", err) } } // A verdict's key as go/delivery's CheckerVerdictKey wrote it (golden): the group escaped, the heads hash after the // last dot. func TestVerdictKeyAsGoDeliveryWroteIt(t *testing.T) { key, err := VerdictKey("fix/1.2", "0123456789ab") if err != nil || key != "fix/1=2e2.0123456789ab" { t.Fatalf("%q %v", key, err) } group, heads, err := ParseVerdictKey(key) if err != nil || group != "fix/1.2" || heads != "0123456789ab" { t.Fatalf("%q %q %v", group, heads, err) } for _, bad := range []string{"nodot", "g.XYZ", ".0123456789ab", "a.b.0123456789ab", "g=zz.0123456789ab"} { if _, _, err := ParseVerdictKey(bad); err == nil { t.Errorf("%q parses", bad) } } if _, err := VerdictKey("", "0123456789ab"); err == nil { t.Error("an empty group keys") } if _, err := VerdictKey("g", "0123"); err == nil { t.Error("a short hash keys") } } // The codecs write a value at the kept values' version after its rules and read it back through them. func TestTheCodecsWriteAtTheVersionAndReadBackThroughTheRules(t *testing.T) { raw, err := EncodeVerdict(passing()) if err != nil { t.Fatal(err) } if got, err := DecodeVerdict(raw); err != nil || got.V == 0 || got.Group != "g" { t.Errorf("verdict read back = %+v, %v", got, err) } bad := passing() bad.Heads = "x" if _, err := EncodeVerdict(bad); err == nil { t.Error("a verdict whose heads are no hash is written") } if _, err := DecodeVerdict([]byte(`{"v":99,"group":"g","heads":"0123456789ab","state":"running"}`)); err == nil { t.Error("a verdict of an unknown version is read") } k := checker.KeptByLevelDigestValue{State: VerdictPass, Repository: "novox/mesh-sdk", Package: "./go/keys", Level: LevelUnit, Toolchain: "1.26.0", At: "2026-11-05T10:00:00Z"} raw, err = EncodeKept(k) if err != nil { t.Fatal(err) } if got, err := DecodeKept(raw); err != nil || got.Package != k.Package { t.Errorf("kept read back = %+v, %v", got, err) } k.State = VerdictFail if _, err := EncodeKept(k); err == nil { t.Error("a failure is kept") } p := checker.PreviewsByRepositoryHeadTrunkValue{Repository: "novox/a", Head: "h1", Trunk: "t1", Conflicts: []string{"f.go"}} raw, err = EncodePreview(p) if err != nil { t.Fatal(err) } if got, err := DecodePreview(raw); err != nil || got.Head != "h1" { t.Errorf("preview read back = %+v, %v", got, err) } p.Conflicts = nil if _, err := EncodePreview(p); err == nil { t.Error("a preview with no merge commit and no conflict is written") } // 1921 (B0, G): a checking program's input is asked of the seat's verb input by its digest, and an answer for // another digest, or bytes that are not the digest, is refused. body := []byte(`{"v":1}`) digest := DigestOf(body) for name, c := range map[string]struct { answer any says string }{ "its own bytes": {InputAnswerOf(body), ""}, "another digest": {checker.InputAnswer{Digest: DigestOf([]byte("x")), Input: InputAnswerOf(body).Input}, "answered the input"}, "bytes that are not it": {checker.InputAnswer{Digest: digest, Input: InputAnswerOf([]byte(`{"v":2}`)).Input}, "whose digest is"}, "bytes in no base64": {checker.InputAnswer{Digest: digest, Input: "%%"}, "no base64"}, "no answer of the layout": {"nothing", "answered no input"}, } { got, err := ReadInput(func(key string, b any) (json.RawMessage, error) { if key != "seat:mesh-delivery-checker.input" || b != (checker.InputInput{Digest: digest}) { t.Errorf("%s: asked %s %+v", name, key, b) } return json.Marshal(c.answer) }, digest) switch { case c.says == "" && (err != nil || string(got) != string(body)): t.Errorf("%s: %q, %v", name, got, err) case c.says != "" && (err == nil || !strings.Contains(err.Error(), c.says)): t.Errorf("%s: %v, want a refusal saying %q", name, err, c.says) } } } // The kept and preview keys: a key reads back to its parts, and a part that does not key is refused. func TestKeptAndPreviewKeysReadBack(t *testing.T) { digest := strings.Repeat("ab", 32) key, err := KeptKey(LevelUnit, digest) if err != nil || key != "unit."+digest { t.Fatalf("kept key = %q, %v", key, err) } if level, d, err := ParseKeptKey(key); err != nil || level != LevelUnit || d != digest { t.Errorf("kept key read back = %q %q, %v", level, d, err) } for _, bad := range []string{"fast." + digest, "unit.XY", "unit"} { if _, _, err := ParseKeptKey(bad); err == nil { t.Errorf("kept key %q is read", bad) } } key, err = PreviewKey("novox/mesh-sdk", "h1", "t1") if err != nil { t.Fatal(err) } if repo, h, tr, err := ParsePreviewKey(key); err != nil || repo != "novox/mesh-sdk" || h != "h1" || tr != "t1" { t.Errorf("preview key %q read back = %q %q %q, %v", key, repo, h, tr, err) } for _, bad := range []string{"novox.h1.t1", "a/b.h1", "a/b.h1.t1.x"} { if _, _, _, err := ParsePreviewKey(bad); err == nil { t.Errorf("preview key %q is read", bad) } } } func judgedBy() checker.VerdictsByGroupHeadsValueJudgedBy { const c = "0123456789abcdef0123456789abcdef01234567" return checker.VerdictsByGroupHeadsValueJudgedBy{ Program: checker.VerdictsByGroupHeadsValueJudgedByProgram{Repository: "novox/mesh-delivery", Commit: c, Dir: "modules/mesh-delivery-checker", Package: "p"}, Key: "program-0123456789abcdef", Built: true, Heads: []checker.VerdictsByGroupHeadsValueJudgedByHeadsItem{{Repository: "novox/mesh-delivery", Commit: c}}} }