diff --git a/modules/mesh-build-go/cmd/mesh-build-go/fetch.go b/modules/mesh-build-go/cmd/mesh-build-go/fetch.go index 47d6586fd..d330951ea 100644 --- a/modules/mesh-build-go/cmd/mesh-build-go/fetch.go +++ b/modules/mesh-build-go/cmd/mesh-build-go/fetch.go @@ -12,6 +12,7 @@ import ( "errors" "fmt" "os" + "path" "path/filepath" "regexp" "slices" @@ -157,7 +158,7 @@ func (m *Module) fetchInto(ctx context.Context, req sdkstep.FetchRequest, id str return nil, err } if (base == "" || res.Merge != "") && len(req.Paths) > 0 { - if err := steprun.Narrow(tree, req); err != nil { + if err := narrowTree(tree, repository, req); err != nil { // with what H-A-136 adds return nil, err } // Said beside the tree, so the steps that list the tree's go.mod files leave out those narrowed away. @@ -173,7 +174,7 @@ func (m *Module) fetchInto(ctx context.Context, req sdkstep.FetchRequest, id str // A fetch asked with a module's directory is of that Go module and what its go.mod replaces with a local path, // never another Go module of the tree (design 47 G, A-447). Said beside the tree, so every later step lists the // same modules. - if dirs, err = scopedDirs(tree, dir, dirs); err != nil { + if dirs, err = scopedDirs(tree, dir, req.Paths, dirs); err != nil { return nil, err } if err := os.WriteFile(filepath.Join(root, scopeMark), []byte(strings.Join(dirs, "\n")), 0o600); err != nil { @@ -687,7 +688,7 @@ func cleanDir(dir string) string { // go.mod replaces with a local path, followed through their own replaces (design 47 G, A-447), in order. A directory // the tree holds no go.mod for is left out. A directory holding no go.mod chooses every go.mod under it, and one that // chooses no Go module at all is an error naming it (A-447a). -func scopedDirs(tree, dir string, all []string) ([]string, error) { +func scopedDirs(tree, dir string, paths, all []string) ([]string, error) { have := map[string]bool{} for _, d := range all { have[d] = true @@ -696,11 +697,23 @@ func scopedDirs(tree, dir string, all []string) ([]string, error) { todo := []string{dir} if !have[dir] { // A directory with no go.mod of its own (a module whose Go code lies in go/, a contracts module with a go.mod per - // seat) is every go.mod under it; the tree is already narrowed to the module's paths (A-447a). + // seat) is every go.mod under it, in a narrowed tree under its named paths (A-447a): the narrowed tree also holds + // the module's generated-from directories and its repository's zero-version packages (H-A-136), which are not + // the artifact's own Go modules. + roots := []string{dir} + if len(paths) > 0 { + roots = nil + for _, p := range paths { + roots = append(roots, path.Join(dir, filepath.ToSlash(p))) + } + } todo = nil for _, d := range all { - if dir == "." || strings.HasPrefix(d, dir+"/") { - todo = append(todo, d) + for _, r := range roots { + if r == "." || d == r || strings.HasPrefix(d, r+"/") { + todo = append(todo, d) + break + } } } } diff --git a/modules/mesh-build-go/cmd/mesh-build-go/gomoddirs_test.go b/modules/mesh-build-go/cmd/mesh-build-go/gomoddirs_test.go index 1a7a8d429..1f1bafa43 100644 --- a/modules/mesh-build-go/cmd/mesh-build-go/gomoddirs_test.go +++ b/modules/mesh-build-go/cmd/mesh-build-go/gomoddirs_test.go @@ -69,7 +69,7 @@ func TestAFetchAskedWithADirectoryChoosesItsModuleAndWhatItReplacesAlone(t *test t.Fatal(err) } } - got, err := scopedDirs(tree, cleanDir(c.dir), all) + got, err := scopedDirs(tree, cleanDir(c.dir), nil, all) if c.want == nil { if err == nil || !strings.Contains(err.Error(), c.dir) { t.Errorf("dir %q chose %v, %v; want an error naming it", c.dir, got, err) diff --git a/modules/mesh-build-go/cmd/mesh-build-go/narrow.go b/modules/mesh-build-go/cmd/mesh-build-go/narrow.go new file mode 100644 index 000000000..06060903a --- /dev/null +++ b/modules/mesh-build-go/cmd/mesh-build-go/narrow.go @@ -0,0 +1,228 @@ +package main + +import ( + "io/fs" + "os" + "path" + "path/filepath" + "slices" + "strings" + + sdkstep "git.novox.be/novox/mesh-delivery/modules/mesh-delivery-sdk/buildstep" + "git.novox.be/novox/mesh-delivery/modules/mesh-delivery-sdk/steprun" + "git.novox.be/novox/mesh-sdk/go/catalogue" +) + +// narrowedKeptAtRoot are what steprun.Narrow keeps beside the named paths, read from the request's directory: the +// manifest and its lock files. A request narrowed from the repository's root (narrowTree) keeps them at the root too, +// where the asked module's build names none of them; they are removed again. +var narrowedKeptAtRoot = []string{"module.json", "go.sum", "package-lock.json"} + +// narrowTree narrows the fetched tree for a build of an artifact that names its paths (ADR 0499 clause 4, +// steprun.Narrow). Beside the artifact's paths and the module's manifest, the workspace holds every generated-from +// directory an artifact of the module names, and the directory (with its go.mod) of every package of the same repository +// the artifact's go.mod requires at the zero version, found by the manifests of that repository's modules; nothing else +// (design 47 H, lead answer H-A-136). A package of another repository comes published, as before (ADR 0573 §4). +func narrowTree(tree, repository string, req sdkstep.FetchRequest) error { + dir := cleanDir(req.Dir) + if dir == "" { + return steprun.Narrow(tree, req) // refused there: named paths without the module's directory + } + extra := generatedFromDirs(tree, dir) + extra = append(extra, ownZeroPackageDirs(tree, repository, dir, req.Paths)...) + var outside []string + inside := slices.Clone(req.Paths) + for _, e := range extra { + if rel, ok := under(dir, e); ok { + if !slices.Contains(inside, rel) { + inside = append(inside, rel) + } + } else if !slices.Contains(outside, e) { + outside = append(outside, e) + } + } + if len(outside) == 0 { + r := req + r.Paths = inside + return steprun.Narrow(tree, r) + } + // A directory outside the module's own: the request is narrowed from the root, with every path the module's + // narrowing keeps named by its path from the root (the manifest and lock files only where the module has them). + all := []string{} + for _, p := range inside { + all = append(all, path.Join(dir, p)) + } + for _, f := range narrowedKeptAtRoot { + if _, err := os.Lstat(filepath.Join(tree, filepath.FromSlash(path.Join(dir, f)))); err == nil { + all = append(all, path.Join(dir, f)) + } + } + all = append(all, outside...) + if err := steprun.Narrow(tree, sdkstep.FetchRequest{Repository: req.Repository, Commit: req.Commit, Paths: all}); err != nil { + return err + } + for _, f := range narrowedKeptAtRoot { + if !slices.Contains(all, f) { + if err := os.RemoveAll(filepath.Join(tree, f)); err != nil { + return err + } + } + } + return nil +} + +// under answers p's path relative to dir when p is dir or lies under it. +func under(dir, p string) (string, bool) { + if dir == "." { + return p, true + } + if p == dir { + return ".", true + } + if rel, ok := strings.CutPrefix(p, dir+"/"); ok { + return rel, true + } + return "", false +} + +// generatedFromDirs are the generated-from directories (from the tree's root) the artifacts of the module in dir name +// (H-A-136): the seat definitions a generated package is compared against. A module at the repository's root keeps not +// its generated-from directory, which would be the whole repository, but the generator's inputs and outputs: the seats/ +// directory of each generated-from directory and the paths of every artifact of the module naming generated-from, as +// the generator's check reads every generated package (H-A-137). A manifest that is absent or unreadable names none; +// the steps that read it say so. +func generatedFromDirs(tree, dir string) []string { + raw, err := os.ReadFile(filepath.Join(tree, filepath.FromSlash(dir), "module.json")) + if err != nil { + return nil + } + man, err := catalogue.Decode(raw) + if err != nil || man.Build == nil { + return nil + } + var out []string + add := func(p string) { + if p == ".." || strings.HasPrefix(p, "../") || slices.Contains(out, p) { + return + } + if _, err := os.Lstat(filepath.Join(tree, filepath.FromSlash(p))); err == nil { // steprun.Narrow refuses a path the tree lacks + out = append(out, p) + } + } + for _, a := range man.Build.Artifacts { + g := strings.TrimSpace(a.GeneratedFrom) + if g == "" { + continue + } + if dir != "." { + add(path.Join(dir, filepath.ToSlash(g))) + continue + } + add(path.Join(filepath.ToSlash(g), "seats")) + for _, p := range a.Paths { + add(path.Clean(filepath.ToSlash(p))) + } + } + return out +} + +// ownZeroPackageDirs are the directories (from the tree's root) of the packages of the checked repository that a go.mod +// under the artifact's named paths requires at the zero version (H-A-136; ADR 0573 §2). Each is found by the manifests +// of the repository's modules: a module's directory or the directory of one of its artifacts' paths whose go.mod declares +// the required module path. One no manifest leads to is left to the fetch's resolution, which fails naming it. +func ownZeroPackageDirs(tree, repository, dir string, paths []string) []string { + want := map[string]bool{} + for _, p := range paths { + root := filepath.Join(tree, filepath.FromSlash(path.Join(dir, p))) + filepath.WalkDir(root, func(file string, e fs.DirEntry, err error) error { + if err != nil { + return nil + } + if e.IsDir() { + if n := e.Name(); n == ".git" || n == "vendor" || n == "node_modules" || n == "testdata" { + return filepath.SkipDir + } + return nil + } + if e.Name() != "go.mod" { + return nil + } + raw, err := os.ReadFile(file) + if err != nil { + return nil + } + for _, pn := range forgePins(string(raw)) { + if pn.short == zeroShort && "novox/"+pn.repo == repository { + want[pn.module] = true + } + } + return nil + }) + } + if len(want) == 0 { + return nil + } + var out []string + for _, cand := range manifestDirs(tree) { + if mod := goModulePath(filepath.Join(tree, filepath.FromSlash(cand), "go.mod")); want[mod] && !slices.Contains(out, cand) { + out = append(out, cand) + } + } + slices.Sort(out) + return out +} + +// manifestDirs are the directories the manifests of the tree name, from its root: each module's directory and the +// directory of each of its artifacts' named paths. +func manifestDirs(tree string) []string { + var out []string + filepath.WalkDir(tree, func(file string, e fs.DirEntry, err error) error { + if err != nil { + return nil + } + if e.IsDir() { + if n := e.Name(); n == ".git" || n == "vendor" || n == "node_modules" || n == "testdata" { + return filepath.SkipDir + } + return nil + } + if e.Name() != "module.json" { + return nil + } + rel, err := filepath.Rel(tree, filepath.Dir(file)) + if err != nil { + return nil + } + mdir := filepath.ToSlash(rel) + out = append(out, mdir) + raw, err := os.ReadFile(file) + if err != nil { + return nil + } + man, err := catalogue.Decode(raw) + if err != nil || man.Build == nil { + return nil + } + for _, a := range man.Build.Artifacts { + for _, p := range a.Paths { + out = append(out, path.Join(mdir, filepath.ToSlash(p))) + } + } + return nil + }) + return out +} + +// goModulePath is the module path the go.mod file declares, "" when there is none. +func goModulePath(file string) string { + raw, err := os.ReadFile(file) + if err != nil { + return "" + } + for _, line := range strings.Split(string(raw), "\n") { + if f := strings.Fields(line); len(f) == 2 && f[0] == "module" { + return strings.Trim(f[1], `"`) + } + } + return "" +} diff --git a/modules/mesh-build-go/cmd/mesh-build-go/narrow_integration_test.go b/modules/mesh-build-go/cmd/mesh-build-go/narrow_integration_test.go index e7ef09577..a976ccc1a 100644 --- a/modules/mesh-build-go/cmd/mesh-build-go/narrow_integration_test.go +++ b/modules/mesh-build-go/cmd/mesh-build-go/narrow_integration_test.go @@ -45,6 +45,28 @@ func TestAFetchWithNamedPathsNarrowsTheWorkspace(t *testing.T) { if strings.Join(res.Modules, ",") != "lib" { t.Errorf("the fetch answered the modules %v, want lib alone", res.Modules) } + // A tree shaped like mesh-delivery's: the narrowed artifact requires another module of its repository at the zero + // version: the narrowed workspace keeps its directory, found by its manifest, and the fetch resolves it there (design + // 47 H, H-A-136; live 2026-11-20, pipeline main.3). + const sdk = "git.novox.be/novox/narrowown/modules/sdk" + _, ownHead := f.repo("novox/narrowown", map[string]string{ + "modules/sdk/go.mod": "module " + sdk + "\n\ngo 1.25.0\n", + "modules/sdk/module.json": `{"module":"sdk","version":"1"}`, + "modules/sdk/s.go": "package sdk\n\nconst S = 1\n", + "modules/c/module.json": `{"module":"c","version":"1"}`, + "modules/c/go/x/go.mod": "module git.novox.be/novox/narrowown/modules/c/go/x\n\ngo 1.25.0\n\nrequire " + sdk + " v0.0.0-00010101000000-000000000000\n", + "modules/c/go/x/x.go": "package x\n\nimport \"" + sdk + "\"\n\nconst X = sdk.S\n", + }) + res, st = fetched(t, m, states, map[string]any{"repository": "novox/narrowown", "commit": ownHead, "dir": "modules/c", "paths": []any{"go/x"}}) + if st.State != sdkstep.StepPassed { + t.Fatalf("the fetch of an artifact requiring its repository's other module ended %s: %s", st.State, st.Reason) + } + if _, err := os.Stat(filepath.Join(m.Work, res.Workspace, "tree", "modules", "sdk", "s.go")); err != nil { + t.Errorf("the narrowed workspace lacks the required package of its repository: %v", err) + } + if strings.Join(res.Modules, ",") != "modules/c/go/x" { + t.Errorf("the fetch answered the modules %v, want modules/c/go/x alone", res.Modules) + } _, st = fetched(t, m, states, map[string]any{"repository": "novox/narrow", "commit": head, "dir": "", "paths": []any{"cmd"}}) if st.State != sdkstep.StepFailed || !strings.Contains(st.Reason, "no module directory") { t.Errorf("paths without a directory: %s %q", st.State, st.Reason) diff --git a/modules/mesh-build-go/cmd/mesh-build-go/narrow_test.go b/modules/mesh-build-go/cmd/mesh-build-go/narrow_test.go new file mode 100644 index 000000000..b451fccd4 --- /dev/null +++ b/modules/mesh-build-go/cmd/mesh-build-go/narrow_test.go @@ -0,0 +1,161 @@ +package main + +import ( + "os" + "path/filepath" + "slices" + "strings" + "testing" + + sdkstep "git.novox.be/novox/mesh-delivery/modules/mesh-delivery-sdk/buildstep" + "git.novox.be/novox/mesh-delivery/modules/mesh-delivery-sdk/seatgen" + "git.novox.be/novox/mesh-delivery/modules/mesh-delivery-sdk/steprun" +) + +func writeFile(t *testing.T, file, body string) { + t.Helper() + if err := os.MkdirAll(filepath.Dir(file), 0o755); err != nil { + t.Fatal(err) + } + if err := os.WriteFile(file, []byte(body), 0o644); err != nil { + t.Fatal(err) + } +} + +// Design 47 H, lead answer H-A-136 (live 2026-11-20, the first pipeline main.3): a workspace narrowed to an artifact's +// named paths also holds every generated-from directory an artifact of its module names (the seat definitions the +// generated package is compared against) and the directory, with its go.mod, of every package of the same repository the +// artifact's go.mod requires at the zero version, found by that repository's manifests; nothing else. The fetch's Go +// modules stay the artifact's own (A-447a): neither the generated-from directory's nor the sibling package's. +func TestANarrowedWorkspaceHoldsTheGeneratedFromDirectoriesAndItsRepositorysZeroVersionPackages(t *testing.T) { + const sdk = "git.novox.be/novox/mesh-delivery/modules/mesh-delivery-sdk" + zero := " v0.0.0-00010101000000-" + zeroShort + for _, tc := range []struct { + name, dir string + paths []string + files map[string]string + kept, gone []string + modules []string + seats []string // generated into the tree by the seat generator, its out-of-step check then finding nothing + }{ + {name: "a generated-from directory", dir: "modules/c", paths: []string{"go/seats/a"}, + files: map[string]string{ + "modules/c/module.json": `{"module":"c","build":{"artifacts":[{"name":"go-a","kind":"package","language":"go","paths":["go/seats/a"],"generated-from":"seats"},{"name":"go-b","kind":"package","language":"go","paths":["go/seats/b"],"generated-from":"seats"}]}}`, + "modules/c/seats/a.json": "{}\n", + "modules/c/go/seats/a/go.mod": "module git.novox.be/novox/mesh-delivery/modules/c/go/seats/a\n\ngo 1.26\n", + "modules/c/go/seats/b/go.mod": "module git.novox.be/novox/mesh-delivery/modules/c/go/seats/b\n\ngo 1.26\n", + "modules/c/docs/x.md": "not named\n", + "modules/d/module.json": `{"module":"d"}`, + }, + kept: []string{"modules/c/module.json", "modules/c/seats/a.json", "modules/c/go/seats/a/go.mod"}, + gone: []string{"modules/c/go/seats/b", "modules/c/docs", "modules/d"}, + modules: []string{"modules/c/go/seats/a"}}, + {name: "the module's own directory as generated-from", dir: "modules/c", paths: []string{"go/seats/a"}, + files: map[string]string{ + "modules/c/module.json": `{"module":"c","build":{"artifacts":[{"name":"go-a","kind":"package","language":"go","paths":["go/seats/a"],"generated-from":"."}]}}`, + "modules/c/seats/a.json": "{}\n", + "modules/c/go/seats/a/go.mod": "module git.novox.be/novox/mesh-delivery/modules/c/go/seats/a\n\ngo 1.26\n", + "modules/c/go/seats/b/go.mod": "module git.novox.be/novox/mesh-delivery/modules/c/go/seats/b\n\ngo 1.26\n", + "modules/d/module.json": `{"module":"d"}`, + }, + kept: []string{"modules/c/seats/a.json", "modules/c/go/seats/b/go.mod"}, + gone: []string{"modules/d"}, + modules: []string{"modules/c/go/seats/a"}}, + {name: "a module at the repository's root with generated-from \".\"", dir: ".", paths: []string{"go/seats/onestore"}, + files: map[string]string{ + "module.json": `{"module":"mesh-contracts","build":{"artifacts":[{"name":"go-onestore","kind":"package","language":"go","paths":["go/seats/onestore"],"generated-from":"."},{"name":"go-twostore","kind":"package","language":"go","paths":["go/seats/twostore"],"generated-from":"."},{"name":"ts-onestore","kind":"package","language":"typescript","paths":["ts/seats/onestore"],"generated-from":"."},{"name":"ts-twostore","kind":"package","language":"typescript","paths":["ts/seats/twostore"],"generated-from":"."},{"name":"go-other","kind":"package","language":"go","paths":["go/other"]}]}}`, + "README.md": "the repository\n", + "docs/a.md": "not named\n", + "go/other/go.mod": "module git.novox.be/novox/mesh-contracts/go/other\n\ngo 1.26\n", + "modules/x/module.json": `{"module":"x"}`, + }, + seats: []string{"one-store", "two-store"}, + kept: []string{"module.json", "seats/one-store/seat.json", "seats/two-store/seat.json", "go/seats/onestore/go.mod", "go/seats/twostore/contract.go", "ts/seats/twostore/package.json"}, + gone: []string{"README.md", "docs", "go/other", "modules"}, + modules: []string{"go/seats/onestore"}}, + {name: "a package of the same repository at the zero version", dir: "modules/mesh-delivery-contracts", + paths: []string{"go/clients/meshcatalogclient"}, + files: map[string]string{ + "module.json": `{"module":"root"}`, + "go.sum": "root\n", + "modules/mesh-delivery-contracts/module.json": `{"module":"mesh-delivery-contracts","build":{"artifacts":[{"name":"go-meshcatalogclient","kind":"package","language":"go","paths":["go/clients/meshcatalogclient"]}]}}`, + "modules/mesh-delivery-contracts/go/clients/meshcatalogclient/go.mod": "module git.novox.be/novox/mesh-delivery/modules/mesh-delivery-contracts/go/clients/meshcatalogclient\n\ngo 1.26\n\nrequire (\n\t" + sdk + zero + "\n\tgit.novox.be/novox/mesh-sdk/go" + zero + "\n)\n", + "modules/mesh-delivery-contracts/go/clients/meshcatalogclient/c.go": "package meshcatalogclient\n", + "modules/mesh-delivery-contracts/go/clients/other/go.mod": "module git.novox.be/novox/mesh-delivery/modules/mesh-delivery-contracts/go/clients/other\n\ngo 1.26\n", + "modules/mesh-delivery-sdk/module.json": `{"module":"mesh-delivery-sdk","build":{"artifacts":[{"name":"go-sdk","kind":"package","language":"go"}]}}`, + "modules/mesh-delivery-sdk/go.mod": "module " + sdk + "\n\ngo 1.26\n", + "modules/mesh-delivery-sdk/steprun/s.go": "package steprun\n", + "modules/mesh-delivery-view/module.json": `{"module":"mesh-delivery-view"}`, + "modules/mesh-delivery-view/go.mod": "module git.novox.be/novox/mesh-delivery/modules/mesh-delivery-view\n\ngo 1.26\n", + }, + kept: []string{"modules/mesh-delivery-contracts/module.json", "modules/mesh-delivery-contracts/go/clients/meshcatalogclient/c.go", + "modules/mesh-delivery-sdk/go.mod", "modules/mesh-delivery-sdk/steprun/s.go"}, + gone: []string{"module.json", "go.sum", "modules/mesh-delivery-view", "modules/mesh-delivery-contracts/go/clients/other"}, + modules: []string{"modules/mesh-delivery-contracts/go/clients/meshcatalogclient"}}, + } { + t.Run(tc.name, func(t *testing.T) { + tree := t.TempDir() + var all []string + for f, body := range tc.files { + os.MkdirAll(filepath.Join(tree, filepath.Dir(f)), 0o755) + if err := os.WriteFile(filepath.Join(tree, f), []byte(body), 0o644); err != nil { + t.Fatal(err) + } + if filepath.Base(f) == "go.mod" { + all = append(all, filepath.Dir(f)) + } + } + if len(tc.seats) > 0 { + for _, seat := range tc.seats { + writeFile(t, filepath.Join(tree, "seats", seat, "seat.json"), `{"format":1,"seat":"`+seat+`","scope":"mesh","grain":"whole","domain":"Module","decision":"ADR 1","verbs":[{"name":"query","input":{"type":"object"},"answer":{"type":"object"}}]}`) + } + g, err := seatgen.Load(tree, "git.novox.be/novox/mesh-contracts/go", "@novox/mesh-contracts") + if err != nil { + t.Fatal(err) + } + files, err := seatgen.Generate(g) + if err != nil { + t.Fatal(err) + } + for f, b := range files { + writeFile(t, filepath.Join(tree, f), string(b)) + if filepath.Base(f) == "go.mod" { + all = append(all, filepath.Dir(f)) + } + } + } + req := sdkstep.FetchRequest{Repository: "novox/mesh-delivery", Commit: commitSHA, Dir: tc.dir, Paths: tc.paths} + if err := narrowTree(tree, req.Repository, req); err != nil { + t.Fatal(err) + } + for _, k := range tc.kept { + if _, err := os.Stat(filepath.Join(tree, k)); err != nil { + t.Errorf("%s was narrowed away: %v", k, err) + } + } + for _, g := range tc.gone { + if _, err := os.Stat(filepath.Join(tree, g)); err == nil { + t.Errorf("%s is still in the workspace", g) + } + } + if len(tc.seats) > 0 { + for _, root := range []string{steprun.GeneratedRootGo, steprun.GeneratedRootTS} { + if out, err := steprun.OutOfStep(filepath.Join(tree, tc.dir), root); err != nil || len(out) != 0 { + t.Errorf("the seat generator's check in the narrowed workspace, root %s: %v %v, want nothing out of step", root, out, err) + } + } + } + var left []string + for _, d := range all { + if _, err := os.Stat(filepath.Join(tree, d, "go.mod")); err == nil { + left = append(left, d) + } + } + slices.Sort(left) + got, err := scopedDirs(tree, tc.dir, tc.paths, left) + if err != nil || strings.Join(got, ",") != strings.Join(tc.modules, ",") { + t.Errorf("the fetch's Go modules = %v (%v), want %v", got, err, tc.modules) + } + }) + } +} diff --git a/modules/mesh-build-go/cmd/mesh-build-go/pins_test.go b/modules/mesh-build-go/cmd/mesh-build-go/pins_test.go index 8d16b996f..920da2bc4 100644 --- a/modules/mesh-build-go/cmd/mesh-build-go/pins_test.go +++ b/modules/mesh-build-go/cmd/mesh-build-go/pins_test.go @@ -6,6 +6,7 @@ import ( "os" "os/exec" "path/filepath" + "slices" "strings" "sync" "testing" @@ -400,39 +401,84 @@ func TestARequirementAtTheZeroVersionIsTakenFromTheAskOrTheTrunk(t *testing.T) { // A requirement at the zero version of a module of the checked repository itself (a nested module not yet published, which // another module of the repository requires) is built from the fetched tree, and never asked of Go or the forge (issue 1921). +// Narrowed: a fetch of one artifact of a tree shaped like mesh-delivery's (modules/mesh-delivery-contracts/go/clients/ +// requiring modules/mesh-delivery-sdk at the zero version), asked with the module's directory and the artifact's paths, +// keeps the sdk's directory, found by its manifest, and resolves it there (design 47 H, H-A-136; live 2026-11-20, +// pipeline main.3: "no module of that path is in the fetched tree of novox/mesh-delivery"). func TestARequirementAtTheZeroVersionOfTheCheckedRepositorysOwnModuleIsTakenFromItsTree(t *testing.T) { - const own = "git.novox.be/novox/mesh-delivery/nested/go" - zeroMod := "module fixture/member\n\ngo 1.26\n\nrequire (\n\t" + own + " v0.0.0-00010101000000-" + zeroShort + "\n)\n" - h, states := newPinHarness(t, zeroMod, false, pullList) - base := h.m.Run - h.m.Run = func(ctx context.Context, env []string, name string, args ...string) forgekey.Ran { - line := name + " " + strings.Join(args, " ") - if name == "go" && strings.Contains(line, " mod download") && !strings.Contains(strings.Join(env, " "), "-modfile=") { - trees, _ := filepath.Glob(filepath.Join(h.m.Work, "*", "tree")) - for _, tree := range trees { - os.MkdirAll(filepath.Join(tree, "nested", "go"), 0o755) - os.WriteFile(filepath.Join(tree, "nested", "go", "go.mod"), []byte("module "+own+"\n\ngo 1.26\n"), 0o644) + for _, tc := range []struct { + name, own, ownDir, gomods string + args map[string]any + narrowed bool + }{ + {name: "whole tree", own: "git.novox.be/novox/mesh-delivery/nested/go", ownDir: "nested/go", gomods: "go.mod\n", + args: map[string]any{"repository": "novox/mesh-delivery", "commit": commitSHA}}, + {name: "narrowed to an artifact's paths", own: "git.novox.be/novox/mesh-delivery/modules/mesh-delivery-sdk", + ownDir: "modules/mesh-delivery-sdk", gomods: "modules/mesh-delivery-contracts/go/clients/meshcatalogclient/go.mod\n", + args: map[string]any{"repository": "novox/mesh-delivery", "commit": commitSHA, "dir": "modules/mesh-delivery-contracts", + "paths": []any{"go/clients/meshcatalogclient"}}, narrowed: true}, + } { + t.Run(tc.name, func(t *testing.T) { + zeroMod := "module fixture/member\n\ngo 1.26\n\nrequire (\n\t" + tc.own + " v0.0.0-00010101000000-" + zeroShort + "\n)\n" + h, states := newPinHarness(t, zeroMod, false, pullList) + h.f.gomods = tc.gomods + base := h.m.Run + h.m.Run = func(ctx context.Context, env []string, name string, args ...string) forgekey.Ran { + line := name + " " + strings.Join(args, " ") + if name == "git" && strings.Contains(line, " checkout ") && tc.narrowed { + r := base(ctx, env, name, args...) + tree := args[slices.Index(args, "-C")+1] + for f, body := range map[string]string{ + "modules/mesh-delivery-sdk/go.mod": "module " + tc.own + "\n\ngo 1.26\n", + "modules/mesh-delivery-sdk/module.json": `{"module":"mesh-delivery-sdk","build":{"artifacts":[{"name":"go-sdk","kind":"package","language":"go"}]}}`, + "modules/mesh-delivery-contracts/module.json": `{"module":"mesh-delivery-contracts","build":{"artifacts":[{"name":"go-meshcatalogclient","kind":"package","language":"go","paths":["go/clients/meshcatalogclient"]}]}}`, + "modules/mesh-delivery-view/go.mod": "module git.novox.be/novox/mesh-delivery/modules/mesh-delivery-view\n\ngo 1.26\n", + } { + os.MkdirAll(filepath.Join(tree, filepath.Dir(f)), 0o755) + os.WriteFile(filepath.Join(tree, f), []byte(body), 0o644) + } + return r + } + if name == "go" && strings.Contains(line, " mod download") && !strings.Contains(strings.Join(env, " "), "-modfile=") { + if !tc.narrowed { + trees, _ := filepath.Glob(filepath.Join(h.m.Work, "*", "tree")) + for _, tree := range trees { + os.MkdirAll(filepath.Join(tree, tc.ownDir), 0o755) + os.WriteFile(filepath.Join(tree, tc.ownDir, "go.mod"), []byte("module "+tc.own+"\n\ngo 1.26\n"), 0o644) + } + } + return forgekey.Ran{Status: 1, Stderr: "go: " + tc.own + "@v0.0.0-00010101000000-" + zeroShort + ": invalid version: unknown revision " + zeroShort + "\n"} + } + return base(ctx, env, name, args...) } - return forgekey.Ran{Status: 1, Stderr: "go: " + own + "@v0.0.0-00010101000000-" + zeroShort + ": invalid version: unknown revision " + zeroShort + "\n"} - } - return base(ctx, env, name, args...) - } - if _, err := fetchTool(t, h.m)(map[string]any{"repository": "novox/mesh-delivery", "commit": commitSHA}); err != nil { - t.Fatal(err) - } - st := states.waitEnd(t) - if st.State != sdkstep.StepPassed { - t.Fatalf("the step ended %s: %s", st.State, st.Reason) - } - modfiles, _ := filepath.Glob(filepath.Join(h.m.Work, "*", "pins", "*", "go.mod")) - if len(modfiles) != 1 { - t.Fatalf("modfiles = %v", modfiles) - } - body, _ := os.ReadFile(modfiles[0]) - if !strings.Contains(string(body), "replace "+own+" => "+filepath.Join(filepath.Dir(filepath.Dir(filepath.Dir(modfiles[0]))), "tree", "nested", "go")) { - t.Errorf("the module of the tree was not replaced into the modfile:\n%s", body) - } - if h.ran(" mod download -json ") || h.ran("ls-remote") { - t.Error("a module of the checked repository was asked of Go or looked for among the pull request heads") + if _, err := fetchTool(t, h.m)(tc.args); err != nil { + t.Fatal(err) + } + st := states.waitEnd(t) + if st.State != sdkstep.StepPassed { + t.Fatalf("the step ended %s: %s", st.State, st.Reason) + } + modfiles, _ := filepath.Glob(filepath.Join(h.m.Work, "*", "pins", "*", "go.mod")) + if len(modfiles) != 1 { + t.Fatalf("modfiles = %v", modfiles) + } + root := filepath.Dir(filepath.Dir(filepath.Dir(modfiles[0]))) + where := filepath.Join(root, "tree", filepath.FromSlash(tc.ownDir)) + if tc.narrowed { + if _, err := os.Stat(filepath.Join(root, "tree", "modules", "mesh-delivery-view")); err == nil { + t.Error("the narrowed tree holds a module the artifact does not require") + } + } + body, _ := os.ReadFile(modfiles[0]) + if !strings.Contains(string(body), "replace "+tc.own+" => "+where+"\n") { + t.Errorf("the module of the repository was not replaced into the modfile by %s:\n%s", where, body) + } + if strings.Count(string(body), "replace ") != 1 { + t.Errorf("the modfile replaces more than the one other module (its own directory again?):\n%s", body) + } + if h.ran(" mod download -json ") || h.ran("ls-remote") { + t.Error("a module of the checked repository was asked of Go or looked for among the pull request heads") + } + }) } }