Files
mesh-catalog/modules/mesh-build-go/cmd/mesh-build-go/preview_integration_test.go
T

230 lines
9.0 KiB
Go

//go:build integration
package main
// The fetch step's merge and siblings on real git repositories and the real go (issues 1675 and 1677): they start
// processes, so they carry the tag; preview_test.go proves the commands with a fake runner.
import (
"encoding/json"
"os"
"os/exec"
"path/filepath"
"strings"
"testing"
"time"
"git.novox.be/novox/mesh-catalog/modules/mesh-build-go/buildstep"
sdkstep "git.novox.be/novox/mesh-delivery/sdk/buildstep"
)
func git(t *testing.T, dir string, args ...string) string {
t.Helper()
cmd := exec.Command("git", append([]string{"-C", dir, "-c", "user.name=t", "-c", "user.email=t@example.invalid", "-c", "commit.gpgsign=false"}, args...)...)
out, err := cmd.CombinedOutput()
if err != nil {
t.Fatalf("git %v: %v\n%s", args, err, out)
}
return strings.TrimSpace(string(out))
}
func put(t *testing.T, dir, name, body string) {
t.Helper()
p := filepath.Join(dir, name)
if err := os.MkdirAll(filepath.Dir(p), 0o755); err != nil {
t.Fatal(err)
}
if err := os.WriteFile(p, []byte(body), 0o644); err != nil {
t.Fatal(err)
}
}
// forge is a directory of bare repositories <owner>/<name>.git standing in for the forge, and a module fetching from it.
type forge struct {
t *testing.T
root string
}
func newForge(t *testing.T) *forge { return &forge{t: t, root: t.TempDir()} }
// repo makes the repository owner/name with the files on main and answers its work directory and the commit.
func (f *forge) repo(name string, files map[string]string) (work, commit string) {
bare := filepath.Join(f.root, "forge", name+".git")
work = filepath.Join(f.root, "work", name)
os.MkdirAll(bare, 0o755)
os.MkdirAll(work, 0o755)
git(f.t, bare, "init", "-q", "--bare")
git(f.t, work, "init", "-q", "-b", "main")
for n, c := range files {
put(f.t, work, n, c)
}
git(f.t, work, "add", ".")
git(f.t, work, "commit", "-q", "-m", "one")
git(f.t, work, "push", "-q", bare, "HEAD:refs/heads/main")
return work, git(f.t, work, "rev-parse", "HEAD")
}
// commit makes a commit off `from` in the repository's work directory and publishes it as the pull request's head.
func (f *forge) commit(name, work, from string, files map[string]string, ref string) string {
git(f.t, work, "checkout", "-q", "-B", "b"+ref[len(ref)-3:], from)
for n, c := range files {
put(f.t, work, n, c)
}
git(f.t, work, "add", ".")
git(f.t, work, "commit", "-q", "-m", "change")
sha := git(f.t, work, "rev-parse", "HEAD")
git(f.t, work, "push", "-q", "-f", filepath.Join(f.root, "forge", name+".git"), "HEAD:"+ref)
return sha
}
func (f *forge) module(t *testing.T) (*Module, *keptStates) {
m, states := fetchModule(t, &fakeStep{})
m.Run = StepRunner(m.Home)
m.RemoteBase = "file://" + filepath.Join(f.root, "forge") + "/"
m.FetchOptions = []buildstep.Option{buildstep.AllowFileRemote()}
return m, states
}
// waitLong is waitEnd for a step that runs the real go, whose first build in a cold cache takes longer than 3 s.
func waitLong(t *testing.T, s *keptStates) sdkstep.Step {
t.Helper()
select {
case key := <-s.ended:
s.mu.Lock()
defer s.mu.Unlock()
v := s.steps[key]
return v[len(v)-1]
case <-time.After(2 * time.Minute):
t.Fatal("the step never ended on its key")
return sdkstep.Step{}
}
}
func fetched(t *testing.T, m *Module, states *keptStates, args map[string]any) (FetchResult, sdkstep.Step) {
t.Helper()
if _, err := fetchTool(t, m)(args); err != nil {
t.Fatal(err)
}
st := states.waitEnd(t)
var res FetchResult
if st.State == sdkstep.StepPassed {
if err := json.Unmarshal(st.Result, &res); err != nil {
t.Fatal(err)
}
}
return res, st
}
var baseFiles = map[string]string{
"go.mod": "module fixture/m\n\ngo 1.26\n",
"a.txt": "one\ntwo\nthree\n",
"modules/m/module.json": "{\"name\":\"m\"}\n",
"modules/m/go.sum": "",
"modules/m/m.txt": "m\n",
"modules/other/other.txt": "o\n",
}
// 1675/AC1 and AC2 on real git: a clean merge answers the merge commit, the changed paths (the trunk's change is not
// among them) and the tree of each module directory, which equals git's own; a conflict is a passed step naming the files,
// leaving the workspace at the trunk commit; and no base is today's fetch.
func TestRealFetchMergesConflictsAndPlainlyFetches(t *testing.T) {
f := newForge(t)
work, fork := f.repo("o/r", baseFiles)
trunk := f.commit("o/r", work, fork, map[string]string{"modules/other/other.txt": "trunk\n", "a.txt": "one\ntwo\nTRUNK\n"}, "refs/heads/main")
clean := f.commit("o/r", work, fork, map[string]string{"modules/m/m.txt": "head\n"}, "refs/pull/1/head")
clash := f.commit("o/r", work, fork, map[string]string{"a.txt": "one\ntwo\nHEAD\n"}, "refs/pull/2/head")
m, states := f.module(t)
res, st := fetched(t, m, states, map[string]any{"repository": "o/r", "commit": clean, "ref": "refs/pull/1/head", "base": trunk})
if st.State != sdkstep.StepPassed || res.Merge == "" || res.Base != trunk || res.Commit != clean || len(res.Conflicts) != 0 {
t.Fatalf("clean: %s %s", st.State, st.Result)
}
if strings.Join(res.Changed, ",") != "modules/m/m.txt" {
t.Errorf("changed = %v, want the head's own change alone", res.Changed)
}
tree := res.Trees["modules/m"]
if want := git(t, filepath.Join(m.Work, res.Workspace, "tree"), "rev-parse", res.Merge+":modules/m"); tree.Tree != want {
t.Errorf("tree = %s, want %s", tree.Tree, want)
}
if tree.Manifest != sha256Hex([]byte("{\"name\":\"m\"}\n")) || tree.Locks["go.sum"] != sha256Hex(nil) {
t.Errorf("manifest and locks = %+v", tree)
}
if got := git(t, filepath.Join(m.Work, res.Workspace, "tree"), "rev-parse", "HEAD"); got != res.Merge {
t.Errorf("the workspace is at %s, want the merge %s", got, res.Merge)
}
res, st = fetched(t, m, states, map[string]any{"repository": "o/r", "commit": clash, "ref": "refs/pull/2/head", "base": trunk})
if st.State != sdkstep.StepPassed || res.Merge != "" || strings.Join(res.Conflicts, ",") != "a.txt" {
t.Fatalf("conflict: %s %s", st.State, st.Result)
}
if got := git(t, filepath.Join(m.Work, res.Workspace, "tree"), "rev-parse", "HEAD"); got != trunk {
t.Errorf("after a conflict the workspace is at %s, want the trunk %s", got, trunk)
}
res, st = fetched(t, m, states, map[string]any{"repository": "o/r", "commit": clean, "ref": "refs/pull/1/head"})
if st.State != sdkstep.StepPassed || res.Merge != "" || res.Base != "" || res.Trees != nil || len(res.Modules) != 1 {
t.Errorf("no base: %s %s", st.State, st.Result)
}
}
// 1677/AC1 on the real go: the unit level of a repository whose test reads MESH_CHECK_BESIDE fails loudly without the
// sibling and passes with it; the sibling is a plain directory with no symlink in it; and a sibling that holds a
// symlink fails the fetch naming it.
func TestRealTestsReadTheSiblingBesideTheTree(t *testing.T) {
needTools(t, "the shut-off unit level", "go", "git", "bwrap") // the tests run in bubblewrap (1309)
f := newForge(t)
files := map[string]string{}
for _, n := range []string{"go.mod", "beside.go", "beside_test.go"} {
raw, err := os.ReadFile(filepath.Join("testdata", "repos", "beside", n))
if err != nil {
t.Fatal(err)
}
files[n] = string(raw)
}
_, head := f.repo("o/r", files)
_, sibling := f.repo("o/sibling", map[string]string{"data.txt": "from the sibling\n"})
m, states := f.module(t)
without, _ := fetched(t, m, states, map[string]any{"repository": "o/r", "commit": head})
if _, err := m.testToolRun(t, without.Workspace); err != nil {
t.Fatal(err)
}
var res TestResult
st := waitLong(t, states)
json.Unmarshal(st.Result, &res)
if st.State != sdkstep.StepPassed || res.Passed || len(res.Failed) != 1 || !strings.Contains(res.Failed[0].Output, "MESH_CHECK_BESIDE is not set") {
t.Fatalf("without the sibling: %s %s", st.State, st.Result)
}
with, st2 := fetched(t, m, states, map[string]any{"repository": "o/r", "commit": head,
"beside": []any{map[string]any{"repository": "o/sibling", "commit": sibling}}})
if st2.State != sdkstep.StepPassed || len(with.Beside) != 1 {
t.Fatalf("with the sibling: %s %s", st2.State, st2.Result)
}
m.testToolRun(t, with.Workspace)
res = TestResult{}
st = waitLong(t, states)
json.Unmarshal(st.Result, &res)
if !res.Passed {
t.Errorf("with the sibling the level failed: %s", st.Result)
}
if link := firstSymlink(filepath.Join(m.Work, with.Workspace, "beside")); link != "" {
t.Errorf("the placed tree holds a symlink, %s", link)
}
_, bad := f.repo("o/linked", map[string]string{"data.txt": "x\n"})
work := filepath.Join(f.root, "work", "o/linked")
if err := os.Symlink("/etc", filepath.Join(work, "etc-link")); err != nil {
t.Fatal(err)
}
git(t, work, "add", ".")
git(t, work, "commit", "-q", "-m", "link")
bad = git(t, work, "rev-parse", "HEAD")
git(t, work, "push", "-q", "-f", filepath.Join(f.root, "forge", "o/linked.git"), "HEAD:refs/heads/main")
_, st3 := fetched(t, m, states, map[string]any{"repository": "o/r", "commit": head,
"beside": []any{map[string]any{"repository": "o/linked", "commit": bad}}})
if st3.State != sdkstep.StepFailed || !strings.Contains(st3.Reason, "etc-link") {
t.Errorf("a sibling with a symlink: %s %s", st3.State, st3.Reason)
}
}