//cmd/bd:bd_embedded_test sits at Bazel's 50-shard cap and was the embedded lane's floor (shards 62-250s). Measured on rbe-west, every shard's wall time was its single slowest top-level test, and most of a test's time was `bd init` (~20s under -race: one Dolt commit per schema migration) plus a fixed 1s per bd subprocess exit (the race runtime's atexit_sleep_ms). - bdInit seeds .beads/embeddeddolt/<db> from a per-process schema template (an empty database with every migration applied, made once per shard by a non-race build of internal/storage/embeddeddolt/cmd) before running the real `bd init`, which then skips the migration chain and does everything else itself (identity, prefix, config, hooks, agent files, git commit). Only for argument lists it understands (--prefix/--database plus --quiet/--skip-hooks/--skip-agents/--non-interactive), and it checks the result is the seeded embedded database. BEADS_TEST_FRESH_INIT=1 turns it off. The TestEmbeddedInit* tests run their own init and are unaffected. - GORACE=atexit_sleep_ms=0 on the target: the bd subprocesses no longer sleep 1s before exiting. A race they hit while running still fails the command as before. - TestEmbeddedInitSelectedExcludeRouting (serial, t.Setenv, 7 full inits, ~113s) is split into ...Stealth and ...Fork top-level functions; same cases, same assertions. - The generator packs with a model of the shard process (pack_concurrent): tests without a top-level t.Parallel run one after another, the rest share -test.parallel=4. The durations are re-measured on rbe-west. rbe-west, `bazel test //cmd/bd:bd_embedded_test --config=embedded --nocache_test_results`: test-seconds 20.2k -> ~10.3k, shard-seconds 8.0k -> ~4.2k, slowest shard 243s -> 138s / 163s (two runs, before the repack). Bead: ga-vnycm2.17 Co-authored-by: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
239 lines
7.5 KiB
Go
239 lines
7.5 KiB
Go
//go:build cgo
|
|
|
|
package main
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"io/fs"
|
|
"os"
|
|
"os/exec"
|
|
"path/filepath"
|
|
"sync"
|
|
"testing"
|
|
|
|
"github.com/steveyegge/beads/internal/configfile"
|
|
"github.com/steveyegge/beads/internal/storage/embeddeddolt"
|
|
"github.com/steveyegge/beads/internal/testutil/bazeltest"
|
|
)
|
|
|
|
// freshInitEnv makes bdInit leave every workspace's schema to its own
|
|
// `bd init` instead of seeding it from the per-process schema template
|
|
// (seedEmbeddedSchema), to check that a failure does not depend on the seed.
|
|
const freshInitEnv = "BEADS_TEST_FRESH_INIT"
|
|
|
|
// schemaTemplateDatabase is the template's database directory name; each
|
|
// seed is renamed to the workspace's own database name.
|
|
const schemaTemplateDatabase = "schematemplate"
|
|
|
|
var (
|
|
schemaTemplateOnce sync.Once
|
|
schemaTemplateDir string
|
|
schemaTemplateErr error
|
|
)
|
|
|
|
// schemaToolEnv names a non-race build of
|
|
// internal/storage/embeddeddolt/cmd (runfiles path) for embeddedSchemaTemplate
|
|
// to run instead of migrating in this process, which under -race takes ~20s.
|
|
const schemaToolEnv = "BEADS_TEST_EMBEDDED_SCHEMA_TOOL"
|
|
|
|
// embeddedSchemaTemplate creates one embedded Dolt database per test process
|
|
// with every schema migration applied and nothing else (embeddeddolt.Open on
|
|
// an empty directory, as bd init's own open does), under testTempRoot, and
|
|
// returns its database directory.
|
|
func embeddedSchemaTemplate() (string, error) {
|
|
schemaTemplateOnce.Do(func() {
|
|
beadsDir, err := testTempDir("bd-schema-template-*")
|
|
if err != nil {
|
|
schemaTemplateErr = fmt.Errorf("create schema template dir: %w", err)
|
|
return
|
|
}
|
|
if err := migrateSchemaTemplate(beadsDir); err != nil {
|
|
schemaTemplateErr = fmt.Errorf("migrate schema template in %s: %w", beadsDir, err)
|
|
return
|
|
}
|
|
schemaTemplateDir = filepath.Join(beadsDir, "embeddeddolt", schemaTemplateDatabase)
|
|
})
|
|
return schemaTemplateDir, schemaTemplateErr
|
|
}
|
|
|
|
func migrateSchemaTemplate(beadsDir string) error {
|
|
if os.Getenv(schemaToolEnv) == "" {
|
|
store, err := embeddeddolt.Open(context.Background(), beadsDir, schemaTemplateDatabase, "main")
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return store.Close()
|
|
}
|
|
tool, err := bazeltest.RunfileEnv(schemaToolEnv)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
out, err := exec.Command(tool, "--dir", beadsDir, "--database", schemaTemplateDatabase).CombinedOutput()
|
|
if err != nil {
|
|
return fmt.Errorf("%s: %w\n%s", tool, err, out)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// seededInitDatabase returns the embedded database name `bd init --quiet
|
|
// <extraArgs>` creates, and false when bdInit should not seed it: an argument
|
|
// it does not know (it may pick another mode or location), no --prefix (the
|
|
// name then comes from the directory), or BEADS_TEST_FRESH_INIT=1.
|
|
func seededInitDatabase(extraArgs []string) (string, bool) {
|
|
if os.Getenv(freshInitEnv) == "1" {
|
|
return "", false
|
|
}
|
|
var prefix, database string
|
|
for i := 0; i < len(extraArgs); i++ {
|
|
switch extraArgs[i] {
|
|
case "--prefix", "--database":
|
|
if i+1 == len(extraArgs) {
|
|
return "", false
|
|
}
|
|
if extraArgs[i] == "--prefix" {
|
|
prefix = extraArgs[i+1]
|
|
} else {
|
|
database = extraArgs[i+1]
|
|
}
|
|
i++
|
|
case "--quiet", "--skip-hooks", "--skip-agents", "--non-interactive":
|
|
default:
|
|
return "", false
|
|
}
|
|
}
|
|
if prefix == "" {
|
|
return "", false
|
|
}
|
|
if database != "" {
|
|
return database, true
|
|
}
|
|
return dbNameFromPrefix(normalizeIssuePrefix(prefix)), true
|
|
}
|
|
|
|
// seedEmbeddedSchema copies the schema template into dir's .beads as database
|
|
// before bd init runs there. bd init then opens a database whose migrations
|
|
// are all applied, so it skips the migration chain (one Dolt commit per
|
|
// migration: most of an init's cost under -race) and does everything else
|
|
// itself: identity, issue prefix, config, hooks, agent files, the git commit.
|
|
// Seeded workspaces share the template's migration commits as their history.
|
|
func seedEmbeddedSchema(t *testing.T, dir, database string) {
|
|
t.Helper()
|
|
tmpl, err := embeddedSchemaTemplate()
|
|
if err != nil {
|
|
t.Fatalf("%v", err)
|
|
}
|
|
dst := filepath.Join(dir, ".beads", "embeddeddolt", database)
|
|
if err := copyTree(tmpl, dst); err != nil {
|
|
t.Fatalf("seed embedded schema %s into %s: %v", tmpl, dst, err)
|
|
}
|
|
}
|
|
|
|
// requireSeededEmbeddedInit fails unless bd init kept the seeded database as
|
|
// the workspace's embedded database.
|
|
func requireSeededEmbeddedInit(t *testing.T, beadsDir, database string) {
|
|
t.Helper()
|
|
cfg, err := configfile.Load(beadsDir)
|
|
if err != nil || cfg == nil {
|
|
t.Fatalf("bd init on a seeded schema: load %s/metadata.json: cfg=%v err=%v", beadsDir, cfg, err)
|
|
}
|
|
if cfg.DoltMode != configfile.DoltModeEmbedded || cfg.DoltDatabase != database {
|
|
t.Fatalf("bd init on a seeded schema chose mode %q database %q, want embedded %q; teach seededInitDatabase this case or run with %s=1",
|
|
cfg.DoltMode, cfg.DoltDatabase, database, freshInitEnv)
|
|
}
|
|
}
|
|
|
|
// copyTree copies src's tree to dst, keeping file and directory modes.
|
|
func copyTree(src, dst string) error {
|
|
return filepath.WalkDir(src, func(path string, d fs.DirEntry, err error) error {
|
|
if err != nil {
|
|
return err
|
|
}
|
|
rel, err := filepath.Rel(src, path)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
target := filepath.Join(dst, rel)
|
|
info, err := d.Info()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
switch {
|
|
case d.IsDir():
|
|
if err := os.MkdirAll(target, 0o700); err != nil {
|
|
return err
|
|
}
|
|
return os.Chmod(target, info.Mode().Perm()|0o700)
|
|
case d.Type().IsRegular():
|
|
b, err := os.ReadFile(path)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if err := os.WriteFile(target, b, info.Mode().Perm()); err != nil {
|
|
return err
|
|
}
|
|
return os.Chmod(target, info.Mode().Perm())
|
|
default:
|
|
return fmt.Errorf("unexpected file type %s at %s", d.Type(), path)
|
|
}
|
|
})
|
|
}
|
|
|
|
func TestSeededInitDatabase(t *testing.T) {
|
|
t.Setenv(freshInitEnv, "")
|
|
for _, tt := range []struct {
|
|
args []string
|
|
want string
|
|
ok bool
|
|
}{
|
|
{[]string{"--prefix", "gc"}, "gc", true},
|
|
{[]string{"--prefix", "my-proj", "--skip-hooks", "--skip-agents"}, "my_proj", true},
|
|
{[]string{"--prefix", "a.b"}, "a_b", true},
|
|
{[]string{"--database", "shared_db", "--prefix", "alpha"}, "shared_db", true},
|
|
{nil, "", false},
|
|
{[]string{"--prefix"}, "", false},
|
|
{[]string{"--prefix", "gc", "--server"}, "", false},
|
|
{[]string{"--prefix", "gc", "--role", "contributor"}, "", false},
|
|
} {
|
|
got, ok := seededInitDatabase(tt.args)
|
|
if got != tt.want || ok != tt.ok {
|
|
t.Errorf("seededInitDatabase(%q) = %q, %v; want %q, %v", tt.args, got, ok, tt.want, tt.ok)
|
|
}
|
|
}
|
|
t.Setenv(freshInitEnv, "1")
|
|
if _, ok := seededInitDatabase([]string{"--prefix", "gc"}); ok {
|
|
t.Errorf("seededInitDatabase seeds with %s=1", freshInitEnv)
|
|
}
|
|
}
|
|
|
|
func TestCopyTreeKeepsModes(t *testing.T) {
|
|
src, dst := t.TempDir(), filepath.Join(t.TempDir(), "copy")
|
|
if err := os.MkdirAll(filepath.Join(src, "noms"), 0o750); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := os.WriteFile(filepath.Join(src, "noms", "manifest"), []byte("m"), 0o600); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := os.WriteFile(filepath.Join(src, "hook"), []byte("#!/bin/sh\n"), 0o755); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := copyTree(src, dst); err != nil {
|
|
t.Fatalf("copyTree: %v", err)
|
|
}
|
|
if b, err := os.ReadFile(filepath.Join(dst, "noms", "manifest")); err != nil || string(b) != "m" {
|
|
t.Fatalf("copied manifest = %q, %v", b, err)
|
|
}
|
|
for path, want := range map[string]os.FileMode{
|
|
filepath.Join(dst, "noms"): 0o750,
|
|
filepath.Join(dst, "noms", "manifest"): 0o600,
|
|
filepath.Join(dst, "hook"): 0o755,
|
|
} {
|
|
info, err := os.Stat(path)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if info.Mode().Perm() != want {
|
|
t.Errorf("%s mode = %v, want %v", path, info.Mode().Perm(), want)
|
|
}
|
|
}
|
|
}
|