289 lines
9.9 KiB
Go
289 lines
9.9 KiB
Go
package delivery
|
|
|
|
import (
|
|
"encoding/json"
|
|
"errors"
|
|
"strings"
|
|
"testing"
|
|
)
|
|
|
|
func TestSourceKeys(t *testing.T) { // 1200/AC1
|
|
if k, err := CandidatesKey("feat/delivery-source-keys"); err != nil || k != "feat/delivery-source-keys" {
|
|
t.Fatalf("candidates key = %q, %v", k, err)
|
|
}
|
|
if g, err := ParseCandidatesKey("feat/x"); err != nil || g != "feat/x" {
|
|
t.Fatalf("parse candidates = %q, %v", g, err)
|
|
}
|
|
if k, err := ModulesKey("mesh-mail"); err != nil || k != "mesh-mail" {
|
|
t.Fatalf("modules key = %q, %v", k, err)
|
|
}
|
|
if m, err := ParseModulesKey("mesh-mail"); err != nil || m != "mesh-mail" {
|
|
t.Fatalf("parse modules = %q, %v", m, err)
|
|
}
|
|
for _, bad := range []string{"", "a.b", "a*b", "a>b", "a b", "a\tb"} {
|
|
if _, err := CandidatesKey(bad); err == nil {
|
|
t.Errorf("candidates key %q accepted", bad)
|
|
}
|
|
if _, err := ModulesKey(bad); err == nil {
|
|
t.Errorf("modules key %q accepted", bad)
|
|
}
|
|
if _, err := ParseCandidatesKey(bad); err == nil {
|
|
t.Errorf("parse candidates %q accepted", bad)
|
|
}
|
|
if _, err := ParseModulesKey(bad); err == nil {
|
|
t.Errorf("parse modules %q accepted", bad)
|
|
}
|
|
}
|
|
ev, err := ForgeEvent("novox/mesh-sdk", ForgeMerged)
|
|
if err != nil || ev != "forge.novox.mesh-sdk.merged" {
|
|
t.Fatalf("forge event = %q, %v", ev, err)
|
|
}
|
|
repo, kind, err := ParseForgeEvent(ev)
|
|
if err != nil || repo != "novox/mesh-sdk" || kind != ForgeMerged {
|
|
t.Fatalf("parse forge event = %q %q %v", repo, kind, err)
|
|
}
|
|
for _, k := range []string{ForgePull, ForgeMerged, ForgeRefused} {
|
|
if _, err := ForgeEvent("a/b", k); err != nil {
|
|
t.Errorf("kind %s refused: %v", k, err)
|
|
}
|
|
}
|
|
for _, bad := range []struct{ repo, kind string }{
|
|
{"", "pull"}, {"novox", "pull"}, {"a/b/c", "pull"}, {"/b", "pull"}, {"a/", "pull"},
|
|
{"a.b/c", "pull"}, {"a/b c", "pull"}, {"a/b", "closed"}, {"a/b", ""},
|
|
} {
|
|
if _, err := ForgeEvent(bad.repo, bad.kind); err == nil {
|
|
t.Errorf("forge event %q %q accepted", bad.repo, bad.kind)
|
|
} else if bad.kind == "closed" && !strings.Contains(err.Error(), "closed") {
|
|
t.Errorf("error does not name the kind: %v", err)
|
|
}
|
|
}
|
|
for _, bad := range []string{"", "forge.a.b", "forge.a.b.closed", "x.a.b.pull", "forge.a.b.pull.x", "forge..b.pull"} {
|
|
if _, _, err := ParseForgeEvent(bad); err == nil {
|
|
t.Errorf("parse forge event %q accepted", bad)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestHeadsHash(t *testing.T) { // 1200/AC2
|
|
a := Head{Repository: "novox/mesh-sdk", Number: 36, Head: "aaaa"}
|
|
b := Head{Repository: "novox/mesh-control", Number: 7, Head: "bbbb"}
|
|
h1, err := HeadsHash([]Head{a, b})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
h2, _ := HeadsHash([]Head{b, a})
|
|
if h1 != h2 {
|
|
t.Errorf("order changes the hash: %s %s", h1, h2)
|
|
}
|
|
if len(h1) != 12 || strings.Trim(h1, "0123456789abcdef") != "" {
|
|
t.Errorf("hash %q is not 12 hex digits", h1)
|
|
}
|
|
for _, changed := range []Head{
|
|
{Repository: "novox/mesh-sdk", Number: 36, Head: "aaab"},
|
|
{Repository: "novox/mesh-sdk", Number: 37, Head: "aaaa"},
|
|
{Repository: "novox/other", Number: 36, Head: "aaaa"},
|
|
} {
|
|
h3, _ := HeadsHash([]Head{changed, b})
|
|
if h3 == h1 {
|
|
t.Errorf("changing %v keeps the hash", changed)
|
|
}
|
|
}
|
|
if _, err := HeadsHash(nil); err == nil {
|
|
t.Error("an empty list is accepted")
|
|
}
|
|
}
|
|
|
|
func sampleSource() Source {
|
|
return Source{Group: "feat/x", Heads: map[string]string{"novox/mesh-sdk": "abc123", "novox/mesh-control": "def456"}}
|
|
}
|
|
|
|
func sampleCandidate() Candidate {
|
|
pulls := []CandidatePull{
|
|
{Head: Head{Repository: "novox/mesh-sdk", Number: 36, Head: "aaaa"}, Modules: []string{"mesh-mail"}},
|
|
{Head: Head{Repository: "novox/mesh-control", Number: 7, Head: "bbbb"}, Modules: []string{"mesh-controller"}},
|
|
}
|
|
hh, _ := HeadsHash([]Head{pulls[0].Head, pulls[1].Head})
|
|
return Candidate{Group: "feat/x", Base: 12, HeadsHash: hh, Pulls: pulls}
|
|
}
|
|
|
|
func sampleForges() []Forge {
|
|
return []Forge{
|
|
{Kind: ForgePull, Repository: "novox/mesh-sdk", Branch: "feat/x", Number: 36, Head: "aaaa", Action: "opened"},
|
|
{Kind: ForgeMerged, Repository: "novox/mesh-sdk", Number: 36, Head: "aaaa", Merge: "cccc",
|
|
Trees: map[string]string{"modules/a": "t1"}, Root: "t0"},
|
|
{Kind: ForgeRefused, Repository: "novox/mesh-sdk", Act: "novox/mesh-sdk.36.aaaa.view", Words: "403 forbidden"},
|
|
}
|
|
}
|
|
|
|
func TestSourceValuesRoundTrip(t *testing.T) { // 1200/AC3
|
|
check := func(name string, data []byte, err error) {
|
|
t.Helper()
|
|
if err != nil {
|
|
t.Fatalf("%s: %v", name, err)
|
|
}
|
|
var probe map[string]any
|
|
if err := json.Unmarshal(data, &probe); err != nil || probe["v"] != float64(1) {
|
|
t.Fatalf("%s: json %s does not carry v:1", name, data)
|
|
}
|
|
}
|
|
s := sampleSource()
|
|
data, err := EncodeSource(s)
|
|
check("source", data, err)
|
|
s.V = Version
|
|
if got, err := DecodeSource(data); err != nil || !SameSource(got, s) {
|
|
t.Errorf("source round trip: %+v %v", got, err)
|
|
}
|
|
c := sampleCandidate()
|
|
data, err = EncodeCandidate(c)
|
|
check("candidate", data, err)
|
|
c.V = Version
|
|
if got, err := DecodeCandidate(data); err != nil || !SameCandidate(got, c) {
|
|
t.Errorf("candidate round trip: %+v %v", got, err)
|
|
}
|
|
for _, m := range []Module{
|
|
{FP: "src1:abc", Src: 5, Repository: "novox/mesh-sdk", Commit: "cccc"},
|
|
{None: "a build that resolves packages when built", Repository: "novox/mesh-sdk", Commit: "cccc"},
|
|
} {
|
|
data, err = EncodeModule(m)
|
|
check("module", data, err)
|
|
m.V = Version
|
|
if got, err := DecodeModule(data); err != nil || !SameModule(got, m) {
|
|
t.Errorf("module round trip: %+v %v", got, err)
|
|
}
|
|
}
|
|
for _, f := range sampleForges() {
|
|
data, err = EncodeForge(f)
|
|
check("forge "+f.Kind, data, err)
|
|
f.V = Version
|
|
if got, err := DecodeForge(data); err != nil || !SameForge(got, f) {
|
|
t.Errorf("forge %s round trip: %+v %v", f.Kind, got, err)
|
|
}
|
|
}
|
|
for name, dec := range map[string]func([]byte) error{
|
|
"source": func(b []byte) error { _, err := DecodeSource(b); return err },
|
|
"candidate": func(b []byte) error { _, err := DecodeCandidate(b); return err },
|
|
"module": func(b []byte) error { _, err := DecodeModule(b); return err },
|
|
"forge": func(b []byte) error { _, err := DecodeForge(b); return err },
|
|
} {
|
|
for _, in := range []string{`{"group":"g"}`, `{"v":2,"group":"g"}`} {
|
|
if err := dec([]byte(in)); !errors.Is(err, ErrUnknownVersion) {
|
|
t.Errorf("%s decode of %s = %v, want ErrUnknownVersion", name, in, err)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestSourceValuesRefused(t *testing.T) { // 1200/AC4
|
|
wantErr := func(name string, err error, words ...string) {
|
|
t.Helper()
|
|
if err == nil {
|
|
t.Errorf("%s accepted", name)
|
|
return
|
|
}
|
|
for _, w := range words {
|
|
if !strings.Contains(err.Error(), w) {
|
|
t.Errorf("%s: error %q does not name %q", name, err, w)
|
|
}
|
|
}
|
|
}
|
|
_, err := EncodeSource(Source{Group: "g"})
|
|
wantErr("source without repositories", err, "repositor")
|
|
_, err = EncodeSource(Source{Group: "g", Heads: map[string]string{"a/b": ""}})
|
|
wantErr("source with an empty head", err, "a/b")
|
|
_, err = EncodeSource(Source{Group: "g", Heads: map[string]string{"": "x"}})
|
|
wantErr("source with an empty repository", err, "repositor")
|
|
|
|
c := sampleCandidate()
|
|
c.HeadsHash = "000000000000"
|
|
_, err = EncodeCandidate(c)
|
|
wantErr("candidate with a stale hash", err, "heads hash")
|
|
c = sampleCandidate()
|
|
c.Pulls = nil
|
|
_, err = EncodeCandidate(c)
|
|
wantErr("candidate without pulls", err, "pull")
|
|
|
|
_, err = EncodeModule(Module{FP: "src1:x", None: "why", Repository: "a/b", Commit: "c"})
|
|
wantErr("module with both", err, "both")
|
|
_, err = EncodeModule(Module{Repository: "a/b", Commit: "c"})
|
|
wantErr("module with neither", err, "fingerprint", "none")
|
|
_, err = EncodeModule(Module{FP: "abc", Repository: "a/b", Commit: "c"})
|
|
wantErr("module with a bad fingerprint", err, "src1:")
|
|
|
|
f := sampleForges()[1]
|
|
f.Merge = ""
|
|
_, err = EncodeForge(f)
|
|
wantErr("merged without merge commit", err, "merge")
|
|
f = sampleForges()[1]
|
|
f.Root = ""
|
|
_, err = EncodeForge(f)
|
|
wantErr("merged without root", err, "root")
|
|
f = sampleForges()[1]
|
|
f.Trees = nil
|
|
_, err = EncodeForge(f)
|
|
wantErr("merged without trees", err, "tree")
|
|
f = sampleForges()[1]
|
|
f.Trees = map[string]string{"modules/a": ""}
|
|
_, err = EncodeForge(f)
|
|
wantErr("merged with an empty tree", err, "modules/a")
|
|
f = sampleForges()[0]
|
|
f.Action = "reopened"
|
|
_, err = EncodeForge(f)
|
|
wantErr("pull with an unknown action", err, "reopened")
|
|
f = sampleForges()[0]
|
|
f.Head = ""
|
|
_, err = EncodeForge(f)
|
|
wantErr("pull without head", err, "head")
|
|
f = sampleForges()[2]
|
|
f.Words = ""
|
|
_, err = EncodeForge(f)
|
|
wantErr("refused without words", err, "words")
|
|
f = sampleForges()[2]
|
|
f.Act = ""
|
|
_, err = EncodeForge(f)
|
|
wantErr("refused without act", err, "act")
|
|
_, err = EncodeForge(Forge{Kind: "closed", Repository: "a/b"})
|
|
wantErr("unknown kind", err, "closed")
|
|
_, err = EncodeForge(Forge{Kind: ForgePull, Repository: "nope", Number: 1, Head: "h", Action: "opened"})
|
|
wantErr("bad repository", err, "nope")
|
|
}
|
|
|
|
func TestSourceSame(t *testing.T) { // 1200/AC5
|
|
if !SameSource(sampleSource(), sampleSource()) {
|
|
t.Error("equal sources differ")
|
|
}
|
|
s := sampleSource()
|
|
s.Heads["novox/mesh-sdk"] = "zzz"
|
|
if SameSource(s, sampleSource()) {
|
|
t.Error("different sources are the same")
|
|
}
|
|
if !SameCandidate(sampleCandidate(), sampleCandidate()) {
|
|
t.Error("equal candidates differ")
|
|
}
|
|
c := sampleCandidate()
|
|
c.Pulls[0].Modules = []string{"other"}
|
|
if SameCandidate(c, sampleCandidate()) {
|
|
t.Error("different candidates are the same")
|
|
}
|
|
m := Module{FP: "src1:a", Repository: "a/b", Commit: "c"}
|
|
if !SameModule(m, m) || SameModule(m, Module{FP: "src1:b", Repository: "a/b", Commit: "c"}) {
|
|
t.Error("SameModule wrong")
|
|
}
|
|
f := sampleForges()[1]
|
|
g := sampleForges()[1]
|
|
if !SameForge(f, g) {
|
|
t.Error("equal forge messages differ")
|
|
}
|
|
g.Trees["modules/a"] = "other"
|
|
if SameForge(f, g) {
|
|
t.Error("different forge messages are the same")
|
|
}
|
|
}
|
|
|
|
func TestSourceBuckets(t *testing.T) {
|
|
if SourceBucket != "mesh-delivery-gate_source" || CandidatesBucket != "mesh-delivery-indexer_candidates" ||
|
|
ModulesBucket != "mesh-delivery-indexer_modules" || SourceMainKey != "main" ||
|
|
SourceHistory != 64 || CandidatesHistory != 10 || ModulesHistory != 20 {
|
|
t.Error("a bucket or history differs from the decided layout")
|
|
}
|
|
}
|