mesh-tools
97a2d841c7
The controller plans config, templates and moved providers' provisions, hands bus accounts to the vault and judges the new manifest words, on the feature's SDK and node-engine validator (feature 57, config and provisioning).
263 lines
12 KiB
Go
263 lines
12 KiB
Go
package builder
|
|
|
|
import (
|
|
"os"
|
|
"os/exec"
|
|
"path/filepath"
|
|
"strings"
|
|
"testing"
|
|
)
|
|
|
|
// **A merge check judges the merge, not the head** (novox/hq ADR 0323, issue 341): the head merged into the trunk
|
|
// commit in the check's own clone, never pushed; a head that does not merge cleanly fails, naming the files; the
|
|
// verdict names the head, the trunk commit and the commits of the repositories read beside it.
|
|
|
|
// aTrunkAndABranch is a repository whose main moved after the branch was cut: main holds trunkFiles over the
|
|
// common files, the branch headFiles. It answers the repository, the branch's head and main's head.
|
|
func aTrunkAndABranch(t *testing.T, common, trunkFiles, headFiles map[string]string) (string, string, string) {
|
|
t.Helper()
|
|
dir := t.TempDir()
|
|
git := func(args ...string) string {
|
|
t.Helper()
|
|
cmd := exec.Command("git", args...)
|
|
cmd.Dir = dir
|
|
cmd.Env = append(os.Environ(), "GIT_AUTHOR_NAME=t", "GIT_AUTHOR_EMAIL=t@example.org",
|
|
"GIT_COMMITTER_NAME=t", "GIT_COMMITTER_EMAIL=t@example.org")
|
|
out, err := cmd.CombinedOutput()
|
|
if err != nil {
|
|
t.Fatalf("git %v: %v\n%s", args, err, out)
|
|
}
|
|
return strings.TrimSpace(string(out))
|
|
}
|
|
write := func(files map[string]string) {
|
|
for name, body := range files {
|
|
if err := os.MkdirAll(filepath.Dir(filepath.Join(dir, name)), 0o755); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := os.WriteFile(filepath.Join(dir, name), []byte(body), 0o755); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
git("add", "-A")
|
|
}
|
|
git("init", "--quiet", "-b", "main")
|
|
write(common)
|
|
git("commit", "--quiet", "-m", "common")
|
|
git("checkout", "--quiet", "-b", "change")
|
|
write(headFiles)
|
|
git("commit", "--quiet", "-m", "the change")
|
|
head := git("rev-parse", "HEAD")
|
|
git("checkout", "--quiet", "main")
|
|
write(trunkFiles)
|
|
git("commit", "--quiet", "-m", "the trunk moved")
|
|
return dir, head, git("rev-parse", "HEAD")
|
|
}
|
|
|
|
func TestACheckJudgesTheHeadMergedIntoTheTrunk(t *testing.T) {
|
|
// main's script passes only in a tree holding both the trunk's file and the head's: the merge.
|
|
repo, head, trunk := aTrunkAndABranch(t,
|
|
map[string]string{CheckScript: "test -f trunk-only && test -f head-only || { echo 'FAIL: not the merge'; exit 1; }\n"},
|
|
map[string]string{"trunk-only": "t"}, map[string]string{"head-only": "h"})
|
|
beside, besideHead := aCheckedRepository(t, map[string]string{"README": "the catalogue"})
|
|
registry := aFactsRegistry(t)
|
|
aRuntimeOnThisMachine(t)
|
|
|
|
v, err := Check(t.Context(), Command, CheckSpec{ID: "check-341", Repository: repo, Ref: head, Owner: "novox",
|
|
Repo: "mesh-lab", Number: 1, Base: "main", Toolchain: "golang",
|
|
Beside: map[string]Beside{"mesh-catalog": {Repository: beside, Ref: besideHead}}}, t.TempDir(), registry,
|
|
GitCredential{}, nil)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if v.Repo == nil || v.Repo.Verdict != "pass" {
|
|
t.Fatalf("the check did not judge the head merged into the trunk: %+v\n%s", v.Repo, v.Report)
|
|
}
|
|
if v.Head != head[:12] || v.Trunk != trunk[:12] {
|
|
t.Fatalf("the verdict names head %q and trunk %q, not %s and %s", v.Head, v.Trunk, head[:12], trunk[:12])
|
|
}
|
|
if v.Beside["mesh-catalog"] != besideHead[:12] {
|
|
t.Fatalf("the verdict names the catalogue read beside it as %q, not %s: %v", v.Beside["mesh-catalog"],
|
|
besideHead[:12], v.Beside)
|
|
}
|
|
if v.Merge == "" || v.Merge == head || v.Merge == trunk {
|
|
t.Fatalf("no merge of the head into the trunk was made for the check: %q", v.Merge)
|
|
}
|
|
}
|
|
|
|
func TestAHeadThatDoesNotMergeCleanlyFailsNamingTheFiles(t *testing.T) {
|
|
repo, head, trunk := aTrunkAndABranch(t,
|
|
map[string]string{"store.go": "package store\n\nconst Declared = 1\n", "other.go": "package store\n"},
|
|
map[string]string{"store.go": "package store\n\nconst Declared = 2\n"},
|
|
map[string]string{"store.go": "package store\n\nconst Declared = 3\n"})
|
|
|
|
// No artifact store and no container runtime: a head that does not merge is judged before either is needed.
|
|
v, err := Check(t.Context(), Command, CheckSpec{ID: "check-341-conflict", Repository: repo, Ref: head,
|
|
Owner: "novox", Repo: "mesh-lab", Number: 2, Base: "main", Toolchain: "golang"}, t.TempDir(), "",
|
|
GitCredential{}, nil)
|
|
if err != nil {
|
|
t.Fatalf("a head that does not merge cleanly was not judged: %v", err)
|
|
}
|
|
want := "does not merge cleanly into trunk " + trunk[:12]
|
|
for name, l := range map[string]*Layer{"gate": v.Gate, "repository": v.Repo} {
|
|
if l == nil || l.Verdict != "fail" || !strings.Contains(l.Summary, want) || !strings.Contains(l.Summary, "store.go") {
|
|
t.Fatalf("its %s layer said %+v, not a failure saying %q and naming store.go", name, l, want)
|
|
}
|
|
}
|
|
if strings.Contains(v.Summary, "other.go") {
|
|
t.Fatalf("a file not in conflict is named: %s", v.Summary)
|
|
}
|
|
if v.Head != head[:12] || v.Trunk != trunk[:12] {
|
|
t.Fatalf("the failure names head %q and trunk %q", v.Head, v.Trunk)
|
|
}
|
|
}
|
|
|
|
// **The merge made for a check is only checked** (ADR 0323 §2): the forge never receives it.
|
|
func TestTheMergeMadeForACheckIsNeverPushed(t *testing.T) {
|
|
repo, head, trunk := aTrunkAndABranch(t, map[string]string{CheckScript: "true\n"},
|
|
map[string]string{"trunk-only": "t"}, map[string]string{"head-only": "h"})
|
|
registry := aFactsRegistry(t)
|
|
aRuntimeOnThisMachine(t)
|
|
refsBefore := gitOut(t, repo, "for-each-ref")
|
|
|
|
v, err := Check(t.Context(), Command, CheckSpec{ID: "check-341-push", Repository: repo, Ref: head, Owner: "novox",
|
|
Repo: "mesh-lab", Number: 3, Base: "main", Toolchain: "golang"}, t.TempDir(), registry, GitCredential{}, nil)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if v.Merge == "" {
|
|
t.Fatal("the check made no merge of the head into the trunk")
|
|
}
|
|
if err := exec.Command("git", "-C", repo, "cat-file", "-e", v.Merge+"^{commit}").Run(); err == nil {
|
|
t.Fatalf("the merge %s made for the check reached the forge's repository", v.Merge)
|
|
}
|
|
if after := gitOut(t, repo, "for-each-ref"); after != refsBefore {
|
|
t.Fatalf("the check moved a ref of the forge's repository:\nbefore %s\nafter %s", refsBefore, after)
|
|
}
|
|
if got := gitOut(t, repo, "rev-parse", "main"); got != trunk {
|
|
t.Fatalf("the trunk moved to %s", got)
|
|
}
|
|
}
|
|
|
|
// A delivery group's composed check merges each member's head into its own trunk's head (ADR 0323 §6), and names
|
|
// both for each; a member that does not merge cleanly fails the composed check, naming it.
|
|
func TestAGroupsComposedCheckMergesEachMemberIntoItsTrunk(t *testing.T) {
|
|
repo, head, trunk := aTrunkAndABranch(t, map[string]string{CheckScript: "true\n"},
|
|
map[string]string{"trunk-only": "t"}, map[string]string{"head-only": "h"})
|
|
member, memberHead, memberTrunk := aTrunkAndABranch(t, map[string]string{"a": "1"},
|
|
map[string]string{"b": "trunk"}, map[string]string{"c": "head"})
|
|
registry := aFactsRegistry(t)
|
|
aRuntimeOnThisMachine(t)
|
|
|
|
v, err := Check(t.Context(), Command, CheckSpec{ID: "check-341-group", Repository: repo, Ref: head, Owner: "novox",
|
|
Repo: "mesh-controller", Number: 4, Base: "main", Toolchain: "golang", Group: []GroupHead{{Owner: "novox",
|
|
Repo: "mesh-host", Repository: member, Ref: memberHead, Base: "main"}}}, t.TempDir(), registry,
|
|
GitCredential{}, nil)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if v.Head != head[:12] || v.Trunk != trunk[:12] {
|
|
t.Fatalf("the composed check names its first head %q into %q", v.Head, v.Trunk)
|
|
}
|
|
if len(v.Members) != 1 || v.Members[0].Head != memberHead[:12] || v.Members[0].Trunk != memberTrunk[:12] {
|
|
t.Fatalf("the composed check names its members %+v, not mesh-host %s into %s", v.Members, memberHead[:12],
|
|
memberTrunk[:12])
|
|
}
|
|
|
|
conflicting, conflictHead, _ := aTrunkAndABranch(t, map[string]string{"a": "1"}, map[string]string{"a": "2"},
|
|
map[string]string{"a": "3"})
|
|
v, err = Check(t.Context(), Command, CheckSpec{ID: "check-341-group-conflict", Repository: repo, Ref: head,
|
|
Owner: "novox", Repo: "mesh-controller", Number: 4, Base: "main", Toolchain: "golang", Group: []GroupHead{{
|
|
Owner: "novox", Repo: "mesh-host", Repository: conflicting, Ref: conflictHead, Base: "main"}}}, t.TempDir(),
|
|
registry, GitCredential{}, nil)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if v.Verdict != "fail" || !strings.Contains(v.Summary, "novox/mesh-host") ||
|
|
!strings.Contains(v.Summary, "does not merge cleanly") {
|
|
t.Fatalf("a member that does not merge cleanly was answered %s: %s", v.Verdict, v.Summary)
|
|
}
|
|
}
|
|
|
|
func gitOut(t *testing.T, dir string, args ...string) string {
|
|
t.Helper()
|
|
out, err := exec.Command("git", append([]string{"-C", dir}, args...)...).CombinedOutput()
|
|
if err != nil {
|
|
t.Fatalf("git %v: %v\n%s", args, err, out)
|
|
}
|
|
return strings.TrimSpace(string(out))
|
|
}
|
|
|
|
// No hook runs when a check makes its merge: not one in the clone, whatever the build machine's git configuration says.
|
|
func TestACheckMergeRunsNoHook(t *testing.T) {
|
|
repo, head, _ := aTrunkAndABranch(t, map[string]string{"a": "1"}, map[string]string{"b": "trunk"},
|
|
map[string]string{"c": "head"})
|
|
clone := filepath.Join(t.TempDir(), "clone")
|
|
if out, err := exec.Command("git", "clone", "--quiet", repo, clone).CombinedOutput(); err != nil {
|
|
t.Fatalf("%v\n%s", err, out)
|
|
}
|
|
ran := filepath.Join(t.TempDir(), "ran")
|
|
for _, hook := range []string{"pre-merge-commit", "commit-msg", "prepare-commit-msg", "post-merge"} {
|
|
if err := os.WriteFile(filepath.Join(clone, ".git", "hooks", hook),
|
|
[]byte("#!/bin/sh\necho "+hook+" >> "+ran+"\n"), 0o755); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
m, err := mergeIntoTrunk(t.Context(), Command, clone, "main", head)
|
|
if err != nil || m.Merge == "" {
|
|
t.Fatalf("the merge was not made: %+v, %v", m, err)
|
|
}
|
|
if said, err := os.ReadFile(ran); err == nil {
|
|
t.Fatalf("a hook ran when the check made its merge: %s", said)
|
|
}
|
|
}
|
|
|
|
// What a check's tests change in the workspace never reaches what it builds for the merge (novox/hq issue 703): the
|
|
// builds are made from a copy of the merge, outside the workspace, cloned before anything of the change runs.
|
|
func TestWhatTheTestsChangeInTheWorkspaceNeverReachesTheBuild(t *testing.T) {
|
|
repo, head, _ := aTrunkAndABranch(t, map[string]string{"main.go": "package main // the merge\n"},
|
|
map[string]string{"trunk-only": "t"}, map[string]string{"head-only": "h"})
|
|
workspace := t.TempDir()
|
|
tree := filepath.Join(workspace, "check", "checked")
|
|
if out, err := exec.Command("git", "clone", "--quiet", repo, tree).CombinedOutput(); err != nil {
|
|
t.Fatalf("%v\n%s", err, out)
|
|
}
|
|
dir, cloned, err := checkoutForTheBuilds(t.Context(), Command, tree, head, workspace)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defer os.RemoveAll(dir)
|
|
if withinDir(workspace, cloned) {
|
|
t.Fatalf("the builds' checkout %s is inside the workspace %s the tests mount", cloned, workspace)
|
|
}
|
|
|
|
// The tests rewrite the tree, its branch and every object it holds.
|
|
if err := os.WriteFile(filepath.Join(tree, "main.go"), []byte("package main // planted\n"), 0o644); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := filepath.WalkDir(filepath.Join(tree, ".git", "objects"), func(path string, d os.DirEntry, err error) error {
|
|
if err != nil || d.IsDir() {
|
|
return err
|
|
}
|
|
_ = os.Chmod(path, 0o644)
|
|
return os.WriteFile(path, []byte("planted"), 0o644)
|
|
}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
// The build clones the merge from its own checkout, as buildForTheMerge does, and reads what the merge holds.
|
|
build := filepath.Join(t.TempDir(), "source")
|
|
if out, err := exec.Command("git", "clone", "--quiet", cloned, build).CombinedOutput(); err != nil {
|
|
t.Fatalf("%v\n%s", err, out)
|
|
}
|
|
if out, err := exec.Command("git", "-C", build, "checkout", "--quiet", head).CombinedOutput(); err != nil {
|
|
t.Fatalf("%v\n%s", err, out)
|
|
}
|
|
body, err := os.ReadFile(filepath.Join(build, "main.go"))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if string(body) != "package main // the merge\n" {
|
|
t.Fatalf("the build read %q: what the tests wrote reached it", body)
|
|
}
|
|
}
|