230 lines
9.0 KiB
Go
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)
|
|
}
|
|
}
|