Compare commits
1 commit
main
...
ci/bazel-d
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
47eb06e66a |
15 changed files with 689 additions and 68 deletions
13
.bazelrc
13
.bazelrc
|
|
@ -1,6 +1,13 @@
|
|||
# Bazel configuration for beads (side-by-side with the Go toolchain; `go build`
|
||||
# and `go test` are unaffected). Bzlmod only; Bazel version is pinned in
|
||||
# .bazelversion.
|
||||
# Bazel configuration for beads. Bazel is beads' build and test system: CI
|
||||
# gates on the `bazel test` lanes in .github/workflows/bazel.yml, and
|
||||
# `make test`/`make check` run the same commands (engdocs/TESTING.md
|
||||
# "Building and Testing"). Plain `go build`/`go test` still work as an
|
||||
# inner-loop convenience but are not what CI enforces. Where actions run is
|
||||
# per machine, never committed here: contributors read the anonymous,
|
||||
# read-only cache with --config=fork-cache (defined below); maintainers with
|
||||
# an rbe-west client certificate execute remotely with --config=remote-exec.
|
||||
# Make either the default with a `build --config=...` line in the gitignored
|
||||
# .bazelrc.local. Bzlmod only; Bazel version is pinned in .bazelversion.
|
||||
common --enable_bzlmod
|
||||
common --color=no
|
||||
# C/C++ (and so cgo, -race and the Go stdlib) builds only with MODULE.bazel's
|
||||
|
|
|
|||
|
|
@ -1,8 +1,10 @@
|
|||
#!/usr/bin/env bash
|
||||
# Pre-push hook: when pushing a release tag (refs/tags/v*), refuse the push if
|
||||
# version constants disagree. This stops a release from being tagged/published
|
||||
# with drifted versions (the failure mode that left main red after the 1.0.5
|
||||
# release) before it ever reaches CI.
|
||||
# Pre-push hook: run the Bazel test suite for branch pushes that change Go or
|
||||
# Bazel inputs (scripts/pre-push-suite.sh), and when pushing a release tag
|
||||
# (refs/tags/v*), refuse the push if version constants disagree. The version
|
||||
# check stops a release from being tagged/published with drifted versions (the
|
||||
# failure mode that left main red after the 1.0.5 release) before it ever
|
||||
# reaches CI.
|
||||
#
|
||||
# Installed via: git config core.hooksPath .githooks
|
||||
# See also: make install (sets hooksPath automatically)
|
||||
|
|
@ -55,6 +57,36 @@ if [ "$pushing_version_tag" -eq 1 ]; then
|
|||
fi
|
||||
fi
|
||||
|
||||
# The push-time test suite (scripts/pre-push-suite.sh): bazel.yml's test lane,
|
||||
# `bazel test //... --config=ci`, for branch pushes whose new commits change
|
||||
# Go or Bazel inputs. A tag push, a deletion, or a docs-only push skips it.
|
||||
# BD_PREPUSH_SUITE=go runs plain go test instead, under a banner.
|
||||
zero_sha=0000000000000000000000000000000000000000
|
||||
suite_needed=0
|
||||
while read -r local_ref local_sha _remote_ref remote_sha; do
|
||||
case "$local_ref" in
|
||||
refs/heads/*) ;;
|
||||
*) continue ;;
|
||||
esac
|
||||
if [ "$local_sha" = "$zero_sha" ] || ! git cat-file -e "$local_sha^{commit}" 2>/dev/null; then
|
||||
continue
|
||||
fi
|
||||
base="$remote_sha"
|
||||
if [ "$base" = "$zero_sha" ] || ! git cat-file -e "$base^{commit}" 2>/dev/null; then
|
||||
# A new remote branch: compare against main's merge-base.
|
||||
base="$(git merge-base "$local_sha" origin/main 2>/dev/null || true)"
|
||||
fi
|
||||
if [ -z "$base" ] || git diff --name-only "$base" "$local_sha" -- \
|
||||
'*.go' 'go.mod' 'go.sum' '*.bazel' '*.bzl' '.bazelrc' '.bazelversion' 'MODULE.bazel.lock' | grep -q .; then
|
||||
suite_needed=1
|
||||
fi
|
||||
done <<< "$push_refs"
|
||||
|
||||
if [ "$suite_needed" -eq 1 ]; then
|
||||
repo_root="$(git rev-parse --show-toplevel)"
|
||||
"$repo_root/scripts/pre-push-suite.sh" </dev/null
|
||||
fi
|
||||
|
||||
exec < <(printf '%s\n' "$push_refs")
|
||||
|
||||
# --- BEGIN BEADS INTEGRATION v1.3.0 ---
|
||||
|
|
|
|||
2
.github/PULL_REQUEST_TEMPLATE.md
vendored
2
.github/PULL_REQUEST_TEMPLATE.md
vendored
|
|
@ -19,6 +19,6 @@ Closes #
|
|||
## Checklist
|
||||
|
||||
- [ ] The why is documented: in a linked issue (reproduction or motivation, impact, risk) or in this description.
|
||||
- [ ] Tests and lint selected per `engdocs/TESTING.md` pass locally.
|
||||
- [ ] `make test` (the Bazel test lane, nogo lint included) and any other lane `engdocs/TESTING.md` selects pass locally.
|
||||
- [ ] User-facing behavior changes are reflected in `docs/` or the generated CLI reference.
|
||||
- [ ] If an invariant or rule changed, the owning `AGENTS.md` is updated.
|
||||
|
|
|
|||
49
AGENTS.md
49
AGENTS.md
|
|
@ -102,33 +102,46 @@ spans layers. See
|
|||
|
||||
## Build, test, lint
|
||||
|
||||
Bazel is the build and test system: CI gates on the `bazel test` lanes in
|
||||
`.github/workflows/bazel.yml`, and nogo (lint + vet), gofmt and the repository
|
||||
guards exist only as Bazel targets. Install
|
||||
[Bazelisk](https://github.com/bazelbuild/bazelisk) as `bazel`; the pre-commit
|
||||
and pre-push hooks need it.
|
||||
|
||||
```bash
|
||||
make install # build and install bd to ~/.local/bin (canonical)
|
||||
make test # unit tests with the right build tags
|
||||
make ci-pr-lint # required zero-finding lint + vet contract (nogo under Bazel)
|
||||
make check-docs # doc flag, freshness, and docsync checks
|
||||
make test # bazel test //... --config=ci: the CI test lane (nogo, gofmt, guards, unit tests)
|
||||
make check # testing.Short policy + make ci-pr-lint + make test
|
||||
make ci-pr-lint # nogo lint + vet gate, native plus windows/darwin
|
||||
make check-docs # bazel docsync + doc freshness, then the CLI flag check
|
||||
make bazel-sync # after adding/removing/renaming Go files or changing imports/go.mod
|
||||
make install # build and install bd to ~/.local/bin (canonical)
|
||||
```
|
||||
|
||||
- Each other tier has its own lane (`--config=integration`, `doltserver`,
|
||||
`embedded`, ...); [engdocs/TESTING.md](engdocs/TESTING.md) lists the exact
|
||||
command per lane and is the canonical source for test selection, design,
|
||||
and PR-readiness gates.
|
||||
- Where actions run: contributors add `--config=fork-cache` (rbe-west's
|
||||
anonymous read-only cache; nothing is uploaded), maintainers with an rbe-west
|
||||
certificate `--config=remote-exec`, agent hosts whose `~/.bazelrc` names the
|
||||
executor neither. Make yours the default with a `build --config=...` line in
|
||||
the gitignored `.bazelrc.local`, or pass `BAZEL_FLAGS=...` to make.
|
||||
- `go test` (`./scripts/test.sh`, `make test-go`) is an inner-loop
|
||||
convenience only. CI does not enforce it, and it skips nogo, gofmt and the
|
||||
guards; finish with `make test`.
|
||||
- **Do NOT** use `go build -o bd ./cmd/bd`, `go install ./cmd/bd`, or raw
|
||||
`go run ./cmd/bd ...`: they bypass the canonical build path, leave stale
|
||||
binaries, and raw `go run` misses the `gms_pure_go` tag. Use `make install`,
|
||||
`./bd`, or `go run -tags gms_pure_go ./cmd/bd ...`.
|
||||
- All new features need tests. Choose them with
|
||||
[engdocs/TESTING.md](engdocs/TESTING.md); it is the canonical source for
|
||||
commands, test design, and PR-readiness gates.
|
||||
- All new features need tests.
|
||||
- **Never pollute a production database with test issues.** Use `t.TempDir()`
|
||||
in Go tests and a disposable working directory for manual `bd` experiments.
|
||||
- `make ci-pr-lint` must pass with zero issues; see
|
||||
[engdocs/LINTING.md](engdocs/LINTING.md).
|
||||
- **Optional shared Bazel cache (opt-in).** `--config=fork-cache` reads the
|
||||
project's anonymous, read-only cache, so results CI already computed are
|
||||
hits and nothing is uploaded. It is off by default; when setting up a dev
|
||||
environment, ask your human before adding `build --config=fork-cache` to
|
||||
`.bazelrc.local`.
|
||||
- Without Bazel, let CI sync BUILD files: on same-repo PRs the bazel-autofix
|
||||
workflow pushes the fix to your branch (pull before pushing again); fork PRs
|
||||
get a comment with an apply recipe.
|
||||
- If BUILD files are out of sync and you cannot run `make bazel-sync`, CI
|
||||
syncs them: on same-repo PRs the bazel-autofix workflow pushes the fix to
|
||||
your branch (pull before pushing again); fork PRs get a comment with an
|
||||
apply recipe.
|
||||
- If you changed behavior, update the user docs (`docs/`, via the
|
||||
`beads-docs` skill) or README in the same PR.
|
||||
|
||||
|
|
@ -151,9 +164,9 @@ make bazel-sync # after adding/removing/renaming Go files or changing imports
|
|||
|
||||
Do not push to `main`. Before handing off:
|
||||
|
||||
1. Run the quality gates your change needs (`make ci-pr-lint`, the tests
|
||||
[engdocs/TESTING.md](engdocs/TESTING.md) selects). If gates are broken on
|
||||
`main`, report it as a P0 issue.
|
||||
1. Run the quality gates your change needs (`make test`, `make ci-pr-lint`,
|
||||
and the other Bazel lanes [engdocs/TESTING.md](engdocs/TESTING.md)
|
||||
selects). If gates are broken on `main`, report it as a P0 issue.
|
||||
2. Record follow-up work as GitHub issues (or ledger beads, for maintainers).
|
||||
3. Commit, push, or open a PR only when the person you are working for asked
|
||||
you to. Report changed files, validation run, and anything left open.
|
||||
|
|
|
|||
|
|
@ -53,11 +53,14 @@ area is reviewed first.
|
|||
|
||||
### Prerequisites
|
||||
|
||||
- Go (see `go.mod` for the required version; currently 1.26+)
|
||||
- [Bazelisk](https://github.com/bazelbuild/bazelisk), installed as `bazel`
|
||||
(it reads `.bazelversion`). **Required:** Bazel is the build and test system
|
||||
CI gates on, and the pre-commit (nogo lint) and pre-push (test suite) hooks
|
||||
run it.
|
||||
- Go (see `go.mod` for the required version; currently 1.26+), for `make
|
||||
install` and the `go test` inner loop
|
||||
- Git
|
||||
- A C compiler (CGO is required for the embedded Dolt database)
|
||||
- [Bazelisk](https://github.com/bazelbuild/bazelisk) (installed as `bazel`) for
|
||||
the required lint and vet gate (`make ci-pr-lint`) and the pre-commit hook
|
||||
- ICU headers are **not required** for building -- see [engdocs/ICU-POLICY.md](engdocs/ICU-POLICY.md)
|
||||
|
||||
### Getting Started
|
||||
|
|
@ -67,21 +70,43 @@ area is reviewed first.
|
|||
git clone https://github.com/gastownhall/beads
|
||||
cd beads
|
||||
|
||||
# Build the project (uses gms_pure_go tag via Makefile)
|
||||
make build
|
||||
# Read rbe-west's anonymous, read-only cache: everything CI already built and
|
||||
# tested is a cache hit, and nothing you build is uploaded.
|
||||
echo 'build --config=fork-cache' >> .bazelrc.local
|
||||
|
||||
# Run tests (uses correct build tags automatically)
|
||||
# Run the test suite CI gates on (bazel test //... --config=ci)
|
||||
make test
|
||||
|
||||
# Build and install locally to ~/.local/bin
|
||||
# Build and install bd to ~/.local/bin (also enables the git hooks)
|
||||
make install
|
||||
```
|
||||
|
||||
Optional: if you use Bazel, opt in to the project's anonymous, read-only
|
||||
build cache by adding `build --config=fork-cache` to your gitignored
|
||||
`.bazelrc.local` (or pass `--config=fork-cache` per command). Results CI
|
||||
already computed become cache hits, and nothing you build is uploaded. It is
|
||||
off by default.
|
||||
### Building and Testing
|
||||
|
||||
Bazel is the gate: `.github/workflows/bazel.yml` runs every pull request's
|
||||
tests as `bazel test` lanes, and nogo (lint + vet), gofmt and the repository
|
||||
guards exist only as Bazel targets. The make targets run the same commands:
|
||||
|
||||
| Command | Runs |
|
||||
|---|---|
|
||||
| `make test` | `bazel test //... --config=ci`: the test lane (unit tests, nogo, gofmt, repository guards) |
|
||||
| `make check` | the testing.Short policy, `make ci-pr-lint` and `make test` |
|
||||
| `make ci-pr-lint` | nogo natively plus the windows/amd64 and darwin/arm64 passes |
|
||||
| `make check-docs` | the Bazel docsync and doc-freshness tests, then the CLI flag check |
|
||||
| `bazel test //... --config=integration` | the integration lane; [engdocs/TESTING.md](engdocs/TESTING.md) lists every other lane's command |
|
||||
|
||||
Where actions run is your choice, set in the gitignored `.bazelrc.local` (or
|
||||
per command with `make test BAZEL_FLAGS=--config=...`):
|
||||
|
||||
- `--config=fork-cache` (contributors): reads the anonymous cache, runs misses
|
||||
on your machine, uploads nothing.
|
||||
- `--config=remote-exec` (maintainers with an rbe-west client certificate):
|
||||
executes remotely; the executor and TLS lines stay in your `user.bazelrc` or
|
||||
`.bazelrc.local`.
|
||||
|
||||
`go test` (`./scripts/test.sh`, or `make test-go` / `make check-go` /
|
||||
`make check-docs-go`) still works as an inner-loop convenience, but CI does not
|
||||
enforce it and it skips nogo, gofmt and the guards. Finish with `make test`.
|
||||
|
||||
## Project Structure
|
||||
|
||||
|
|
@ -199,7 +224,8 @@ For test commands, test design, and PR-readiness gates, see the canonical
|
|||
|
||||
- Follow the proportional validation budget in
|
||||
[engdocs/TESTING.md](engdocs/TESTING.md): docs-only changes use docs checks;
|
||||
Go changes use focused and affected-package tests plus one final `make test`.
|
||||
Go changes use focused and affected-package tests plus one final `make test`
|
||||
(the Bazel test lane).
|
||||
- If you hit a test failure unrelated to your change, don't silently skip
|
||||
it -- check `.test-skip` and file an issue if it's not already tracked
|
||||
(see [engdocs/TESTING.md](engdocs/TESTING.md#failures-skips-and-review)).
|
||||
|
|
|
|||
57
Makefile
57
Makefile
|
|
@ -45,6 +45,7 @@ endif
|
|||
|
||||
.PHONY: all build doctor-build test test-icu-path test-full-cgo test-regression test-upgrade test-cross-version test-migration corpus-regen githooks-regen bench bench-quick clean clean-test-tmp install install-force help check-up-to-date fmt fmt-check check-testing-short
|
||||
.PHONY: lint lint-changed vet
|
||||
.PHONY: check check-go test-go check-docs-go
|
||||
.PHONY: ci-pr-core ci-pr-policy ci-pr-lint ci-complexity ci-complexity-diff ci-complexity-check ci-package-mcp ci-package-npm
|
||||
.PHONY: api-gen api-check
|
||||
.PHONY: bazel-sync bazel-sync-check
|
||||
|
|
@ -52,6 +53,23 @@ endif
|
|||
# Default target
|
||||
all: build
|
||||
|
||||
# Build and test engine. Bazel is what CI gates on: .github/workflows/bazel.yml
|
||||
# runs `bazel test` lanes on rbe-west, and nogo (lint + vet), formatting and
|
||||
# the repository guards are Bazel targets there. The primary targets (test,
|
||||
# check, check-docs) run the same `bazel test` commands as those lanes, so a
|
||||
# local run shares CI's action keys and its remote cache (engdocs/TESTING.md
|
||||
# "Building and testing"). Each keeps a plain go twin under an explicit -go
|
||||
# name (test-go, check-go, check-docs-go) for offline work and hosts Bazel does
|
||||
# not serve; that twin is an inner-loop convenience, not what CI enforces.
|
||||
# GitHub Actions jobs that still run Go-native suites call the -go names.
|
||||
BAZEL ?= bazel
|
||||
# Extra flags for every `bazel test` below: --config=fork-cache (contributors:
|
||||
# the anonymous read-only cache) or --config=remote-exec (maintainers with an
|
||||
# rbe-west client certificate). Hosts whose ~/.bazelrc names the executor need
|
||||
# neither. Better: put `build --config=...` in the gitignored .bazelrc.local.
|
||||
BAZEL_FLAGS ?=
|
||||
BAZEL_TEST = $(BAZEL) test $(BAZEL_FLAGS)
|
||||
|
||||
BUILD_DIR := .
|
||||
BD_BUILD_OUTPUT := $(BUILD_DIR)/bd$(if $(filter Windows_NT,$(OS)),.exe)
|
||||
GIT_BUILD := $(shell git rev-parse --short HEAD)
|
||||
|
|
@ -174,11 +192,27 @@ doctor-build:
|
|||
echo " CGO_ENABLED=1 go build -tags gms_pure_go ./cmd/bd" ;; \
|
||||
esac
|
||||
|
||||
# Run all tests (skips known broken tests listed in .test-skip)
|
||||
# bazel.yml's test lane (`bazel test //... --config=ci`): every untagged
|
||||
# go_test with PR Core's selection (race, -short, skips), plus nogo lint/vet,
|
||||
# formatting and the repository guards. The other lanes' commands are in
|
||||
# engdocs/TESTING.md "Building and testing".
|
||||
test:
|
||||
$(BAZEL_TEST) //... --config=ci
|
||||
|
||||
# Plain go test (skips known broken tests listed in .test-skip): an inner-loop
|
||||
# convenience without Bazel; CI does not run it.
|
||||
test-go:
|
||||
@echo "Running tests..."
|
||||
@TEST_COVER=1 ./scripts/test.sh
|
||||
|
||||
# Fast quality gates: the testing.Short policy, the full nogo lint gate
|
||||
# (native plus the windows/darwin passes) and `make test`.
|
||||
check: check-testing-short ci-pr-lint test
|
||||
|
||||
# The same gates without Bazel where they have a Go form: gofmt and go test.
|
||||
# nogo has no go twin, so this is a convenience CI does not enforce.
|
||||
check-go: fmt-check check-testing-short test-go
|
||||
|
||||
# Run the opt-in ICU regex path test suite (no skip list).
|
||||
# This is a local developer workflow for intentionally exercising the leftover
|
||||
# ICU path; it is not part of normal validation.
|
||||
|
|
@ -421,8 +455,15 @@ fmt:
|
|||
fmt-check:
|
||||
@./scripts/ci/fmt-check.sh
|
||||
|
||||
# Validate documentation references against actual CLI flags
|
||||
# Docs checks: docsync and doc freshness as bazel.yml's test lane runs them,
|
||||
# then the CLI flag check, which validates against bd built from the release in
|
||||
# docs/cli-docs.pin (so it stays a script, like pr.yml's check-doc-flags job).
|
||||
check-docs:
|
||||
$(BAZEL_TEST) //test/docsync:docsync_test //scripts/repochecks:doc_freshness_test --config=ci
|
||||
@./scripts/check-doc-flags.sh
|
||||
|
||||
# The same docs checks with plain go test and a go-built bd.
|
||||
check-docs-go:
|
||||
@echo "Building bd for docs checks..."
|
||||
@CGO_ENABLED=0 go build -tags "$(BUILD_TAGS)" -ldflags="-X main.Build=$(GIT_BUILD)" -o "$(BUILD_DIR)/bd" ./cmd/bd
|
||||
@./scripts/check-doc-flags.sh "$(BUILD_DIR)/bd"
|
||||
|
|
@ -457,12 +498,10 @@ diagrams-excalidraw:
|
|||
docs-dev:
|
||||
./mint.sh dev
|
||||
|
||||
# Bazel (side-by-side with the Go toolchain; `go build`/`go test` do not need
|
||||
# it). Regenerate BUILD.bazel files with gazelle and refresh the MODULE.bazel
|
||||
# Regenerate BUILD.bazel files with gazelle and refresh the MODULE.bazel
|
||||
# use_repo list + MODULE.bazel.lock, then refresh the go_srcs filegroups that
|
||||
# source-scanning tests declare as data (tools/bazel/go_srcs.py). Run after
|
||||
# changing Go imports, go.mod, or packages.
|
||||
BAZEL ?= bazel
|
||||
bazel-sync:
|
||||
$(BAZEL) run //:gazelle
|
||||
python3 tools/bazel/go_srcs.py
|
||||
|
|
@ -498,7 +537,10 @@ help:
|
|||
@echo "Beads Makefile targets:"
|
||||
@echo " make build - Build the bd binary"
|
||||
@echo " make doctor-build - Diagnose build env (GOFLAGS/CGO/CC) for the ICU build trap"
|
||||
@echo " make test - Run all tests"
|
||||
@echo " make test - bazel test //... --config=ci (bazel.yml's test lane; BAZEL_FLAGS adds flags)"
|
||||
@echo " make test-go - Plain go test via scripts/test.sh (inner loop; not what CI enforces)"
|
||||
@echo " make check - testing.Short policy + nogo lint gate + make test"
|
||||
@echo " make check-go - gofmt + testing.Short policy + make test-go (no Bazel)"
|
||||
@echo " make test-icu-path - Run opt-in ICU regex path tests (maintainer-only)"
|
||||
@echo " make test-full-cgo - Deprecated alias for make test-icu-path"
|
||||
@echo " make ci-pr-core - Run required PR core Go test wrapper"
|
||||
|
|
@ -521,7 +563,8 @@ help:
|
|||
@echo " make install-force - Install bd, skipping the origin/main update check"
|
||||
@echo " make fmt - Format all Go files with gofmt"
|
||||
@echo " make fmt-check - Check Go formatting (for CI)"
|
||||
@echo " make check-docs - Validate docs against CLI flags"
|
||||
@echo " make check-docs - Bazel docsync + doc freshness tests, then the CLI flag check"
|
||||
@echo " make check-docs-go - The same docs checks with plain go test"
|
||||
@echo " make api-gen - Regenerate HTTP API types from the OpenAPI spec"
|
||||
@echo " make api-check - OpenAPI drift gate (regenerate, diff-or-fail, spec tests)"
|
||||
@echo " make bazel-sync - Regenerate Bazel BUILD files and tidy MODULE.bazel (gazelle + mod tidy)"
|
||||
|
|
|
|||
|
|
@ -212,5 +212,5 @@ This is useful for:
|
|||
## 📝 Documentation
|
||||
|
||||
* [Documentation site](https://beads.gascity.com/) | [Installing](docs/getting-started/installation.md) | [Sync Concepts](docs/core-concepts/sync-concepts.md) | [Agent Setup](docs/getting-started/ide-setup.md) | [Copilot CLI Setup](docs/integrations/copilot-cli.md) | [Copilot VS Code MCP](docs/integrations/github-copilot.md) | [Articles](ARTICLES.md) | [Sync Branch Mode](docs/reference/protected-branches.md) | [Troubleshooting](docs/reference/troubleshooting.md) | [FAQ](docs/reference/faq.md)
|
||||
* Contributing: [CONTRIBUTING.md](CONTRIBUTING.md) | [Roadmap](ROADMAP.md) | [Contributor agent instructions](AGENTS.md)
|
||||
* Contributing: [CONTRIBUTING.md](CONTRIBUTING.md) (Bazel builds and tests beads: install [Bazelisk](https://github.com/bazelbuild/bazelisk), then `make test`) | [Roadmap](ROADMAP.md) | [Contributor agent instructions](AGENTS.md)
|
||||
* [](https://deepwiki.com/gastownhall/beads)
|
||||
|
|
|
|||
|
|
@ -138,7 +138,7 @@ Before starting a release:
|
|||
|
||||
- [ ] `release/x.y.z` branch cut from a SHA green on `Main` **and**
|
||||
`Nightly Full Tests` (see [Release Branches](#release-branches))
|
||||
- [ ] All tests passing (`go test ./...`)
|
||||
- [ ] All tests passing (`make test`, the Bazel test lane)
|
||||
- [ ] npm package tests passing (`cd npm-package && npm run test:all`)
|
||||
- [ ] **Upgrade smoke tests pass** (`make test-upgrade`) — see [Release Stability Gate](engdocs/RELEASE-STABILITY-GATE.md)
|
||||
- [ ] **Regression tests pass** (`make test-regression`)
|
||||
|
|
|
|||
|
|
@ -1,9 +1,60 @@
|
|||
# Testing Guide
|
||||
|
||||
`TESTING.md` is the single authority for test commands, test selection, and
|
||||
test design in this repository. Use the commands here for local work. For the
|
||||
exact command behind a current CI check, inspect its workflow and corresponding
|
||||
`Makefile` target; the CI audit and cleanup plan are dated maintainer context.
|
||||
test design in this repository. Use the commands here for local work.
|
||||
|
||||
## Building and Testing: Bazel Is the Gate
|
||||
|
||||
Bazel is beads' build and test system. CI gates every pull request on the
|
||||
`bazel test` lanes in `.github/workflows/bazel.yml`, and several checks exist
|
||||
only as Bazel targets: nogo (go test's vet checks plus the golangci-lint
|
||||
linters, `tools/nogo`), gofmt (`//scripts/repochecks:fmt_test`) and the
|
||||
repository guards under `scripts/repochecks`. A plain `go test` runs none of
|
||||
them, so it is an inner-loop convenience CI does not enforce; a change is
|
||||
ready when its Bazel lanes pass.
|
||||
|
||||
Install [Bazelisk](https://github.com/bazelbuild/bazelisk) as `bazel`; it
|
||||
reads `.bazelversion`. The pre-commit hook (nogo on staged packages) and the
|
||||
pre-push hook (the test lane) both need it.
|
||||
|
||||
Where actions run is per machine, never committed:
|
||||
|
||||
- **Contributors** read rbe-west's anonymous, read-only cache with
|
||||
`--config=fork-cache`: everything CI already executed is a cache hit, misses
|
||||
run on your machine, and nothing is uploaded. Make it the default with
|
||||
`build --config=fork-cache` in your gitignored `.bazelrc.local`, or pass it
|
||||
per command (`make test BAZEL_FLAGS=--config=fork-cache`).
|
||||
- **Maintainers** with an rbe-west client certificate execute remotely with
|
||||
`--config=remote-exec`; the executor endpoint and TLS lines go in the
|
||||
gitignored `user.bazelrc` or `.bazelrc.local` (see the `.bazelrc` comments).
|
||||
- **Agent hosts** whose `~/.bazelrc` names the executor need neither flag.
|
||||
|
||||
Each lane, as bazel.yml runs it (add your `--config=fork-cache` or
|
||||
`--config=remote-exec` when it is not your default):
|
||||
|
||||
| Lane (bazel.yml job) | Command | Notes |
|
||||
|---|---|---|
|
||||
| Test (`bazel-test`) | `make test`, i.e. `bazel test //... --config=ci` | PR Core's selection: race, `-short`, skips. Includes nogo, gofmt and the repository guards. The default gate for every Go change. |
|
||||
| Lint, all platforms | `make ci-pr-lint` | nogo natively plus the windows/amd64 and darwin/arm64 passes. `make lint-changed` covers only your changed packages. |
|
||||
| Pure-Go (`bazel-pure`) | `bazel build --config=pure //cmd/bd:bd //cmd/bd:bd_test` | cgo off. The job's cmd/bd test subset (`PURE_CMD_BD_TESTS`), release cross-compile and js/wasm step are in bazel.yml. |
|
||||
| Integration (`bazel-integration`) | `bazel test //... --config=integration` | The `integration`-tagged build. Runs with the read-only cache too. |
|
||||
| Dolt server (`bazel-doltserver`) | `bazel test //... --config=doltserver` | Starts its own `dolt sql-server` from the pinned binary; no docker. |
|
||||
| cmd/bd Dolt server (`bazel-cmd-dolt`) | `bazel test //cmd/bd:bd_dolt_server_test --config=doltserver-cmd` | 16 shards of the integration-tagged cmd/bd suite. |
|
||||
| Embedded Dolt (`bazel-embedded`) | `bazel test //... --config=embedded` | Remote execution only in CI; locally it is slow. |
|
||||
| Proxied server (`bazel-proxied`) | `bazel test //... --config=doltserver-proxied` | Remote execution only: 30 shards, each with a Dolt server. |
|
||||
| Server-Dolt storage (`bazel-server-storage`) | `bazel test //... --config=doltserver-integration` | Remote execution only. |
|
||||
| Docs | `make check-docs` | `//test/docsync:docsync_test` and `//scripts/repochecks:doc_freshness_test` in the test lane's configuration, then `scripts/check-doc-flags.sh` against the pinned release. |
|
||||
|
||||
`make check` runs the testing.Short policy, `make ci-pr-lint` and
|
||||
`make test`. After adding, removing or renaming Go files or changing imports
|
||||
or `go.mod`, run `make bazel-sync` (gazelle, the `go_srcs` filegroups and
|
||||
`MODULE.bazel`).
|
||||
|
||||
The Makefile keeps plain-Go twins under explicit `-go` names: `make test-go`
|
||||
(`./scripts/test.sh`), `make check-go` and `make check-docs-go`. They work
|
||||
offline and without Bazel, but they are not what CI enforces. GitHub Actions
|
||||
jobs that still run Go-native suites call the `-go` names, never `make test`
|
||||
(`TestWorkflowsNameTheirTestEngine`).
|
||||
|
||||
## Choose the Smallest Useful Test
|
||||
|
||||
|
|
@ -17,23 +68,37 @@ a unit test: use the real boundary when the defect could live there.
|
|||
|
||||
| Need | Run | When |
|
||||
|---|---|---|
|
||||
| Docs-only validation | `git diff --check`, `go test -tags=gms_pure_go ./test/docsync`, and `./scripts/check-doc-freshness.sh` | For prose-only changes; add any generated-doc or surface-specific link check the changed paths require. Do not run the full Go suite merely because a Markdown file changed. |
|
||||
| Focused red/green loop | `./scripts/test.sh -run '^TestExactName$' ./path/to/package/...` | While writing or fixing one behavior. |
|
||||
| Affected-package confidence | `./scripts/test.sh ./path/to/package/...` | After the focused test passes; include directly affected neighbors when their contract changed. |
|
||||
| Final Go baseline | `make test` | Once after focused work on Go code is green. It applies the normal local build flags, coverage, and local skip handling. |
|
||||
| Docs-only validation | `git diff --check` and `make check-docs` | For prose-only changes; add any generated-doc or surface-specific link check the changed paths require. Do not run the full suite merely because a Markdown file changed. |
|
||||
| Focused red/green loop | `bazel test //path/to/package:package_test --config=ci --test_filter='^TestExactName$'`, or the plain-Go `./scripts/test.sh -run '^TestExactName$' ./path/to/package/...` | While writing or fixing one behavior. The `go test` loop is fine here; the Bazel targets below are the gate. |
|
||||
| Affected-package confidence | `bazel test //path/to/package/... --config=ci` | After the focused test passes; include directly affected neighbors when their contract changed. |
|
||||
| Final gate | `make test` | Once after focused work on Go code is green: the whole test lane, mostly cache hits. |
|
||||
| Another lane's risk | that lane's command from the table above | When the change touches what that lane covers (integration-tagged files, the Dolt server path, embedded Dolt, pure-Go builds). |
|
||||
| Named CI wrapper | `make ci-pr-core`, `make ci-pr-policy`, or `make ci-pr-lint` | Run the wrapper whose risk or surface is affected, or use it to reproduce that CI check. Do not run all three routinely for every edit. |
|
||||
| Hook shims against real timeout implementations | `nix flake check -L` (or `nix build .#checks.<system>.hook-timeout-backends -L`) | After changing the hook generator in `cmd/bd/hooks.go` (then `make githooks-regen`) or anything under `.githooks/`. Runs the tracked managed sections against GNU coreutils, uutils, busybox and toybox `timeout` — the multicalls also installed as `gtimeout` alone — with and without Perl, under dash, bash and busybox ash. About one deadline of wall time; needs no Go build. |
|
||||
|
||||
Do not replace the focused loop with repeated full-suite runs. Run the final
|
||||
`make test` once the affected Go tests are green. For docs-only changes, use
|
||||
`make test` once the affected tests are green. For docs-only changes, use
|
||||
the docs, link, and diff checks instead.
|
||||
|
||||
## Commands and Local Environment
|
||||
### Git Hooks
|
||||
|
||||
`./scripts/test.sh` is the normal runner. It sources `.buildflags`, creates an
|
||||
isolated test environment, applies `.test-skip`, and defaults to a **25m
|
||||
per-package** Go-test timeout. The timeout is a hang backstop, not a target
|
||||
runtime. Override it only when diagnosing a legitimate slow path:
|
||||
`make install` points `core.hooksPath` at `.githooks`. The pre-commit hook
|
||||
formats staged Go files and runs nogo on their packages
|
||||
(`make lint-changed LINT_CHANGED_SCOPE=staged`). The pre-push hook runs
|
||||
`scripts/pre-push-suite.sh` for branch pushes whose commits change Go or
|
||||
Bazel inputs: `bazel test //... --config=ci`, with `--config=remote-exec`
|
||||
when some rc file names an executor and `--config=fork-cache` otherwise.
|
||||
`BD_PREPUSH_SUITE=rbe|cache|go` picks the mode; `go` (and the fallback when
|
||||
bazel is not installed) runs `make test-go` under a banner saying it is not
|
||||
the suite CI gates on.
|
||||
|
||||
## Plain `go test` (Inner Loop)
|
||||
|
||||
`./scripts/test.sh` is the plain-Go runner behind `make test-go`. It sources
|
||||
`.buildflags`, creates an isolated test environment, applies `.test-skip`, and
|
||||
defaults to a **25m per-package** Go-test timeout. The timeout is a hang
|
||||
backstop, not a target runtime. Override it only when diagnosing a legitimate
|
||||
slow path:
|
||||
|
||||
```bash
|
||||
TEST_TIMEOUT=30m ./scripts/test.sh ./cmd/bd/...
|
||||
|
|
@ -63,9 +128,9 @@ make test-cross-version
|
|||
make test-migration
|
||||
```
|
||||
|
||||
For a failing GitHub Actions check, follow the current workflow and its
|
||||
`Makefile` target when exact reproduction matters. The local runner and CI
|
||||
intentionally have different contracts in some cases.
|
||||
For a failing GitHub Actions check, run the command of its bazel.yml lane
|
||||
from the table above; for the jobs that are not Bazel lanes, follow the
|
||||
workflow and its `Makefile` target.
|
||||
|
||||
### Test Environment and Readiness
|
||||
|
||||
|
|
@ -339,9 +404,10 @@ underlying failure is fixed.
|
|||
Before opening a PR:
|
||||
|
||||
1. For docs-only changes, run the applicable docs, link, freshness, and diff
|
||||
checks; do not run the full Go suite by default.
|
||||
checks; do not run the full suite by default.
|
||||
2. For Go code, keep the focused and affected-package tests green, then run one
|
||||
final `make test`.
|
||||
final `make test` (the Bazel test lane), plus the lane of any other tier
|
||||
the change touches.
|
||||
3. Run only the named CI wrapper, specialized target, or risk gate required by
|
||||
the changed surface, or the one needed to reproduce a CI result.
|
||||
|
||||
|
|
|
|||
|
|
@ -41,7 +41,7 @@ primitives are wired, not just that fixtures parse.
|
|||
Run with `make test`, or in isolation:
|
||||
|
||||
```sh
|
||||
go test -tags gms_pure_go -run TestFormulaPrimitiveExamples ./cmd/bd/
|
||||
bazel test //cmd/bd:bd_test --config=ci --test_filter='^TestFormulaPrimitiveExamples$'
|
||||
```
|
||||
|
||||
## What's NOT here
|
||||
|
|
|
|||
|
|
@ -40,12 +40,14 @@ go_test(
|
|||
"embedded_shard_count_test.go",
|
||||
"host_tools_test.go",
|
||||
"install_dolt_test.go",
|
||||
"makefile_bazel_primary_test.go",
|
||||
"managed_local_lane_test.go",
|
||||
"migration_corpus_bazel_test.go",
|
||||
"nogo_lint_policy_test.go",
|
||||
"pr_lanes_bazel_coverage_test.go",
|
||||
"pr_preflight_test.go",
|
||||
"pr_risk_bazel_coverage_test.go",
|
||||
"pre_push_suite_test.go",
|
||||
"pull_dolt_image_test.go",
|
||||
"rbe_worker_env_test.go",
|
||||
"release_script_test.go",
|
||||
|
|
|
|||
|
|
@ -28,7 +28,7 @@ lint authority used by `bd preflight` in a Beads source checkout.
|
|||
Broad Go test wrappers also source `scripts/ci/lib/test-env.sh`, which creates a
|
||||
temporary HOME/XDG/Dolt root, isolates Git global/system config, clears runtime
|
||||
Beads/Dolt environment variables, and sets `BEADS_TEST_SKIP=dolt` before tests
|
||||
run. This keeps local `make test` and `make ci-pr-core` results comparable to
|
||||
run. This keeps local `make test-go` and `make ci-pr-core` results comparable to
|
||||
the fast PR-core contract even on shared agent hosts. Set
|
||||
`BEADS_TEST_ENV_RUN_DOLT=1` only when intentionally running the Dolt-dependent
|
||||
tests through these broad wrappers, or `BEADS_TEST_ENV_DISABLE=1` when debugging
|
||||
|
|
|
|||
135
scripts/makefile_bazel_primary_test.go
Normal file
135
scripts/makefile_bazel_primary_test.go
Normal file
|
|
@ -0,0 +1,135 @@
|
|||
package scripts_test
|
||||
|
||||
import (
|
||||
"os"
|
||||
"os/exec"
|
||||
"path/filepath"
|
||||
"regexp"
|
||||
"strings"
|
||||
"testing"
|
||||
)
|
||||
|
||||
// Bazel is beads' build and test system: bazel.yml's lanes gate every PR,
|
||||
// and nogo (lint + vet), formatting and the repository guards exist only as
|
||||
// Bazel targets. The primary make targets run the commands those lanes run,
|
||||
// everywhere (GitHub Actions included), and each keeps a plain go twin under
|
||||
// an explicit -go name. A workflow that runs a Go-native suite calls the -go
|
||||
// name, so its engine is written in the workflow, not sniffed from the
|
||||
// environment.
|
||||
|
||||
const fakeMakeBazel = "/fake/bazel"
|
||||
|
||||
// makeDryRun prints the recipe `make TARGET` would run, with BAZEL pointing
|
||||
// at a fake path so a bazel invocation is recognizable.
|
||||
func makeDryRun(t *testing.T, target string, env ...string) string {
|
||||
t.Helper()
|
||||
makeBin := requireHostTool(t, "make")
|
||||
root := sourceRepoRoot(t)
|
||||
cmd := exec.Command(makeBin, "--no-print-directory", "-n",
|
||||
"-f", filepath.Join(root, "Makefile"),
|
||||
"BAZEL="+fakeMakeBazel,
|
||||
target)
|
||||
cmd.Dir = root
|
||||
for _, entry := range os.Environ() {
|
||||
name, _, _ := strings.Cut(entry, "=")
|
||||
switch name {
|
||||
case "GITHUB_ACTIONS", "BAZEL_FLAGS", "MAKEFLAGS", "MAKELEVEL", "MFLAGS":
|
||||
continue
|
||||
}
|
||||
cmd.Env = append(cmd.Env, entry)
|
||||
}
|
||||
cmd.Env = append(cmd.Env, env...)
|
||||
out, err := cmd.CombinedOutput()
|
||||
if err != nil {
|
||||
t.Fatalf("make -n %s: %v\n%s", target, err, out)
|
||||
}
|
||||
return string(out)
|
||||
}
|
||||
|
||||
// goEngineRE matches a recipe line that tests with the Go toolchain.
|
||||
var goEngineRE = regexp.MustCompile(`(^|\s)go test\s|scripts/test\.sh`)
|
||||
|
||||
func TestMakePrimaryTargetsRunBazel(t *testing.T) {
|
||||
for target, wants := range map[string][]string{
|
||||
"test": {fakeMakeBazel + " test //... --config=ci"},
|
||||
"check": {
|
||||
"./scripts/check-testing-short.sh",
|
||||
"./scripts/ci/pr-lint.sh",
|
||||
fakeMakeBazel + " test //... --config=ci",
|
||||
},
|
||||
"check-docs": {
|
||||
fakeMakeBazel + " test //test/docsync:docsync_test //scripts/repochecks:doc_freshness_test --config=ci",
|
||||
"./scripts/check-doc-flags.sh",
|
||||
},
|
||||
} {
|
||||
for _, env := range [][]string{nil, {"GITHUB_ACTIONS=true"}} {
|
||||
t.Run(target+strings.Join(env, ","), func(t *testing.T) {
|
||||
out := makeDryRun(t, target, env...)
|
||||
for _, want := range wants {
|
||||
if !strings.Contains(out, want) {
|
||||
t.Errorf("make %s (env %v) does not run %q:\n%s", target, env, want, out)
|
||||
}
|
||||
}
|
||||
if goEngineRE.MatchString(out) {
|
||||
t.Errorf("make %s (env %v) runs go test instead of bazel:\n%s", target, env, out)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestMakeBazelFlagsReachEveryBazelTest(t *testing.T) {
|
||||
out := makeDryRun(t, "test", "BAZEL_FLAGS=--config=fork-cache")
|
||||
if want := fakeMakeBazel + " test --config=fork-cache //... --config=ci"; !strings.Contains(out, want) {
|
||||
t.Errorf("make test with BAZEL_FLAGS does not run %q:\n%s", want, out)
|
||||
}
|
||||
}
|
||||
|
||||
func TestMakeGoTwinsRunGoTest(t *testing.T) {
|
||||
for target, want := range map[string]string{
|
||||
"test-go": "./scripts/test.sh",
|
||||
"check-go": "./scripts/test.sh",
|
||||
"check-docs-go": "go test -tags=gms_pure_go ./test/docsync",
|
||||
} {
|
||||
t.Run(target, func(t *testing.T) {
|
||||
out := makeDryRun(t, target)
|
||||
if !strings.Contains(out, want) {
|
||||
t.Errorf("make %s does not run %q:\n%s", target, want, out)
|
||||
}
|
||||
if strings.Contains(out, fakeMakeBazel+" test") {
|
||||
t.Errorf("make %s runs bazel test:\n%s", target, out)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
// primaryMakeCallRE matches a call of a bazel-backed primary make target (not
|
||||
// its -go twin or another target sharing the prefix).
|
||||
var primaryMakeCallRE = regexp.MustCompile(`\bmake (test|check|check-docs)(\s|$|["'])`)
|
||||
|
||||
// TestWorkflowsNameTheirTestEngine: a workflow runs bazel directly, or a
|
||||
// Go-native suite through an explicit -go make target, never a primary name
|
||||
// whose engine a reader would have to look up in the Makefile.
|
||||
func TestWorkflowsNameTheirTestEngine(t *testing.T) {
|
||||
root := sourceRepoRoot(t)
|
||||
files, err := filepath.Glob(filepath.Join(root, ".github", "workflows", "*.y*ml"))
|
||||
if err != nil || len(files) == 0 {
|
||||
t.Fatalf("glob workflows: %v (%d files)", err, len(files))
|
||||
}
|
||||
for _, file := range files {
|
||||
body, err := os.ReadFile(file)
|
||||
if err != nil {
|
||||
t.Fatalf("read %s: %v", file, err)
|
||||
}
|
||||
for i, line := range strings.Split(string(body), "\n") {
|
||||
trimmed := strings.TrimSpace(strings.TrimPrefix(strings.TrimSpace(line), "- "))
|
||||
if strings.HasPrefix(trimmed, "#") || strings.HasPrefix(trimmed, "name:") {
|
||||
continue
|
||||
}
|
||||
if m := primaryMakeCallRE.FindStringSubmatch(line); m != nil {
|
||||
t.Errorf("%s:%d calls `make %s`, which runs bazel; call `make %s-go` for the Go-native suite or bazel directly",
|
||||
filepath.Base(file), i+1, m[1], m[1])
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
140
scripts/pre-push-suite.sh
Executable file
140
scripts/pre-push-suite.sh
Executable file
|
|
@ -0,0 +1,140 @@
|
|||
#!/usr/bin/env bash
|
||||
# The push-time test suite, run by .githooks/pre-push when a pushed branch
|
||||
# changes Go or Bazel inputs: bazel.yml's test lane, `bazel test //...
|
||||
# --config=ci`, with the action keys CI uses, so a push reuses what CI and
|
||||
# earlier pushes already computed.
|
||||
#
|
||||
# BD_PREPUSH_SUITE picks where it runs (default auto):
|
||||
# auto remote-exec when bazel's effective options name a remote executor
|
||||
# (a maintainer's .bazelrc.local, an agent host's ~/.bazelrc);
|
||||
# fork-cache when bazel is installed without one; go when bazel is
|
||||
# not installed.
|
||||
# rbe --config=remote-exec; fails when no rc file names an executor (the
|
||||
# suite would otherwise compile and run on this machine).
|
||||
# cache --config=fork-cache: the anonymous read-only cache; misses run on
|
||||
# this machine and nothing is uploaded.
|
||||
# go make test-go (plain go test through scripts/test.sh), under a
|
||||
# banner saying it is not what CI enforces.
|
||||
# BAZEL and MAKE override the binaries. Bypass the hook: git push --no-verify.
|
||||
set -euo pipefail
|
||||
|
||||
repo_root="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
|
||||
cd "$repo_root"
|
||||
|
||||
bazel_bin="${BAZEL:-bazel}"
|
||||
make_bin="${MAKE:-make}"
|
||||
mode="${BD_PREPUSH_SUITE:-auto}"
|
||||
executor=""
|
||||
# Why the push runs plain go test instead of bazel, and how to get bazel back.
|
||||
go_why="BD_PREPUSH_SUITE=go"
|
||||
go_fix="unset BD_PREPUSH_SUITE to run the bazel suite"
|
||||
|
||||
# The go suite is not what CI enforces: bazel.yml gates on bazel test, whose
|
||||
# nogo lint/vet, formatting and repository-guard targets have no go test
|
||||
# counterpart. Say so loudly, with the reason, so a green push is not read as
|
||||
# CI parity.
|
||||
announce_go_suite() {
|
||||
{
|
||||
echo "pre-push: ========================================================================"
|
||||
echo "pre-push: running make test-go (plain go test): NOT the bazel suite CI gates on."
|
||||
echo "pre-push: why: $go_why"
|
||||
echo "pre-push: CI runs bazel test //... --config=ci (.github/workflows/bazel.yml); a push"
|
||||
echo "pre-push: that passes here can still fail there (nogo lint/vet, formatting, guards)."
|
||||
echo "pre-push: fix: $go_fix"
|
||||
echo "pre-push: ========================================================================"
|
||||
} >&2
|
||||
}
|
||||
|
||||
# The remote executor some rc file names for this workspace, empty for none:
|
||||
# the last non-empty --remote_executor among the rc options Bazel reads
|
||||
# (system, workspace with .bazelrc.local and user.bazelrc, home) and the
|
||||
# remote-exec config's definitions, from `bazel info --announce_rc`. Bazel's
|
||||
# own reading of every rc, not a grep of one file, so an agent host's
|
||||
# ~/.bazelrc executor counts. Fails, printing Bazel's error, when Bazel cannot
|
||||
# read its options.
|
||||
effective_remote_executor() {
|
||||
local announced
|
||||
if ! announced="$("$bazel_bin" info --announce_rc --config=remote-exec release 2>&1 >/dev/null)"; then
|
||||
printf '%s\n' "$announced" >&2
|
||||
return 1
|
||||
fi
|
||||
printf '%s\n' "$announced" | awk '
|
||||
/^INFO: (Reading rc options|Options provided by the client)/ { section = 1; next }
|
||||
/^[^[:space:]]/ { section = 0 }
|
||||
!section && !/^INFO: Found applicable config definition [^ ]*:remote-exec / { next }
|
||||
{
|
||||
for (i = 1; i <= NF; i++) {
|
||||
value = ""
|
||||
if ($i ~ /^--remote_executor=/) {
|
||||
value = substr($i, length("--remote_executor=") + 1)
|
||||
} else if ($i == "--remote_executor" && i < NF) {
|
||||
value = $(i + 1)
|
||||
}
|
||||
if (value != "") {
|
||||
executor = value
|
||||
}
|
||||
}
|
||||
}
|
||||
END { print executor }'
|
||||
}
|
||||
|
||||
# Sets $executor, or fails the push: an unreadable option set is no evidence
|
||||
# for either mode.
|
||||
probe_executor() {
|
||||
if ! executor="$(effective_remote_executor)"; then
|
||||
echo "pre-push: bazel info could not read this workspace's options (above); fix the rc, or set BD_PREPUSH_SUITE=rbe|cache|go" >&2
|
||||
exit 2
|
||||
fi
|
||||
}
|
||||
|
||||
have_bazel() {
|
||||
command -v "$bazel_bin" >/dev/null 2>&1
|
||||
}
|
||||
|
||||
case "$mode" in
|
||||
auto)
|
||||
if ! have_bazel; then
|
||||
go_why="bazel is not installed"
|
||||
go_fix="install bazelisk as bazel (CONTRIBUTING.md \"Building and testing\")"
|
||||
mode=go
|
||||
else
|
||||
probe_executor
|
||||
if [ -n "$executor" ]; then
|
||||
mode=rbe
|
||||
else
|
||||
mode=cache
|
||||
fi
|
||||
fi
|
||||
;;
|
||||
go | cache) ;;
|
||||
rbe)
|
||||
if have_bazel; then
|
||||
probe_executor
|
||||
if [ -z "$executor" ]; then
|
||||
echo "pre-push: BD_PREPUSH_SUITE=rbe but no rc file names a --remote_executor; configure one (engdocs/TESTING.md \"Building and testing\") or use BD_PREPUSH_SUITE=cache|go" >&2
|
||||
exit 2
|
||||
fi
|
||||
fi
|
||||
;;
|
||||
*)
|
||||
echo "pre-push: BD_PREPUSH_SUITE=$mode is not one of auto, rbe, cache, go" >&2
|
||||
exit 2
|
||||
;;
|
||||
esac
|
||||
|
||||
case "$mode" in
|
||||
go)
|
||||
announce_go_suite
|
||||
exec "$make_bin" test-go
|
||||
;;
|
||||
rbe) config=remote-exec ;;
|
||||
cache) config=fork-cache ;;
|
||||
esac
|
||||
|
||||
if ! have_bazel; then
|
||||
echo "pre-push: BD_PREPUSH_SUITE=$mode needs bazel on PATH; install bazelisk or use BD_PREPUSH_SUITE=go" >&2
|
||||
exit 2
|
||||
fi
|
||||
|
||||
echo "pre-push: bazel test //... --config=ci --config=$config${executor:+ on $executor} (BD_PREPUSH_SUITE=go runs plain go test instead)" >&2
|
||||
exec "$bazel_bin" test //... --config=ci "--config=$config"
|
||||
157
scripts/pre_push_suite_test.go
Normal file
157
scripts/pre_push_suite_test.go
Normal file
|
|
@ -0,0 +1,157 @@
|
|||
package scripts_test
|
||||
|
||||
import (
|
||||
"os"
|
||||
"os/exec"
|
||||
"path/filepath"
|
||||
"strings"
|
||||
"testing"
|
||||
)
|
||||
|
||||
// scripts/pre-push-suite.sh is the push-time suite .githooks/pre-push runs
|
||||
// when a pushed branch changes Go or Bazel inputs: bazel.yml's test lane
|
||||
// (`bazel test //... --config=ci`), remotely when some rc names an executor,
|
||||
// else through the read-only fork cache. Plain go test runs only when bazel
|
||||
// cannot (or BD_PREPUSH_SUITE=go asks for it), and then under a banner, so
|
||||
// a green push is never read as CI parity.
|
||||
|
||||
type prePushSuiteRun struct {
|
||||
out string
|
||||
bazel string
|
||||
make string
|
||||
exitErr error
|
||||
}
|
||||
|
||||
// runPrePushSuite runs the suite with fake bazel and make that log their
|
||||
// arguments. announce is what the fake `bazel info --announce_rc` prints to
|
||||
// stderr; bazel "missing" points BAZEL at a path that does not exist.
|
||||
func runPrePushSuite(t *testing.T, bazel, announce string, env ...string) prePushSuiteRun {
|
||||
t.Helper()
|
||||
bash := requireHostTool(t, "bash")
|
||||
dir := t.TempDir()
|
||||
bazelLog := filepath.Join(dir, "bazel.log")
|
||||
makeLog := filepath.Join(dir, "make.log")
|
||||
writeExecutable := func(name, body string) string {
|
||||
path := filepath.Join(dir, name)
|
||||
if err := os.WriteFile(path, []byte("#!/usr/bin/env bash\n"+body), 0o755); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
return path
|
||||
}
|
||||
fakeBazel := writeExecutable("bazel", `if [ "$1" = info ]; then printf '%s\n' "$FAKE_ANNOUNCE" >&2; echo release 9; exit 0; fi
|
||||
printf '%s\n' "$*" >>"`+bazelLog+`"
|
||||
`)
|
||||
fakeMake := writeExecutable("make", `printf '%s\n' "$*" >>"`+makeLog+`"
|
||||
`)
|
||||
if bazel == "missing" {
|
||||
fakeBazel = filepath.Join(dir, "no-such-bazel")
|
||||
}
|
||||
|
||||
cmd := exec.Command(bash, filepath.Join(sourceRepoRoot(t), "scripts", "pre-push-suite.sh"))
|
||||
for _, entry := range os.Environ() {
|
||||
if name, _, _ := strings.Cut(entry, "="); name == "BD_PREPUSH_SUITE" {
|
||||
continue
|
||||
}
|
||||
cmd.Env = append(cmd.Env, entry)
|
||||
}
|
||||
cmd.Env = append(cmd.Env, "BAZEL="+fakeBazel, "MAKE="+fakeMake, "FAKE_ANNOUNCE="+announce)
|
||||
cmd.Env = append(cmd.Env, env...)
|
||||
out, err := cmd.CombinedOutput()
|
||||
read := func(path string) string {
|
||||
data, _ := os.ReadFile(path)
|
||||
return strings.TrimSpace(string(data))
|
||||
}
|
||||
return prePushSuiteRun{out: string(out), bazel: read(bazelLog), make: read(makeLog), exitErr: err}
|
||||
}
|
||||
|
||||
const announceWithExecutor = `INFO: Reading rc options for 'info' from /home/u/.bazelrc:
|
||||
Inherited 'build' options: --remote_executor=grpcs://rbe.example:443 --jobs=64`
|
||||
|
||||
const announceWithoutExecutor = `INFO: Reading rc options for 'info' from /w/.bazelrc:
|
||||
Inherited 'common' options: --enable_bzlmod`
|
||||
|
||||
func TestPrePushSuiteRunsBazelTestLane(t *testing.T) {
|
||||
for _, tc := range []struct {
|
||||
name, announce string
|
||||
env []string
|
||||
want string
|
||||
}{
|
||||
{"auto with an executor", announceWithExecutor, nil, "test //... --config=ci --config=remote-exec"},
|
||||
{"auto without an executor", announceWithoutExecutor, nil, "test //... --config=ci --config=fork-cache"},
|
||||
{"explicit cache", announceWithExecutor, []string{"BD_PREPUSH_SUITE=cache"}, "test //... --config=ci --config=fork-cache"},
|
||||
{"explicit rbe", announceWithExecutor, []string{"BD_PREPUSH_SUITE=rbe"}, "test //... --config=ci --config=remote-exec"},
|
||||
} {
|
||||
t.Run(tc.name, func(t *testing.T) {
|
||||
run := runPrePushSuite(t, "present", tc.announce, tc.env...)
|
||||
if run.exitErr != nil {
|
||||
t.Fatalf("suite failed: %v\n%s", run.exitErr, run.out)
|
||||
}
|
||||
if run.bazel != tc.want {
|
||||
t.Errorf("bazel ran %q, want %q\n%s", run.bazel, tc.want, run.out)
|
||||
}
|
||||
if run.make != "" {
|
||||
t.Errorf("make ran %q; the bazel suite needs no go fallback\n%s", run.make, run.out)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestPrePushSuiteRbeWithoutExecutorFails(t *testing.T) {
|
||||
run := runPrePushSuite(t, "present", announceWithoutExecutor, "BD_PREPUSH_SUITE=rbe")
|
||||
if run.exitErr == nil || run.bazel != "" {
|
||||
t.Fatalf("BD_PREPUSH_SUITE=rbe without an executor: err %v, bazel ran %q\n%s", run.exitErr, run.bazel, run.out)
|
||||
}
|
||||
}
|
||||
|
||||
func TestPrePushSuiteGoFallbackIsAnnounced(t *testing.T) {
|
||||
for _, tc := range []struct {
|
||||
name, bazel, why string
|
||||
env []string
|
||||
}{
|
||||
{"bazel missing", "missing", "bazel is not installed", nil},
|
||||
{"explicit go", "present", "BD_PREPUSH_SUITE=go", []string{"BD_PREPUSH_SUITE=go"}},
|
||||
} {
|
||||
t.Run(tc.name, func(t *testing.T) {
|
||||
run := runPrePushSuite(t, tc.bazel, announceWithExecutor, tc.env...)
|
||||
if run.exitErr != nil {
|
||||
t.Fatalf("suite failed: %v\n%s", run.exitErr, run.out)
|
||||
}
|
||||
if run.make != "test-go" || run.bazel != "" {
|
||||
t.Errorf("ran make %q, bazel %q; want make test-go only\n%s", run.make, run.bazel, run.out)
|
||||
}
|
||||
for _, want := range []string{"NOT the bazel suite CI gates on", "why: " + tc.why, "bazel test //... --config=ci"} {
|
||||
if !strings.Contains(run.out, want) {
|
||||
t.Errorf("go fallback banner lacks %q:\n%s", want, run.out)
|
||||
}
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestPrePushSuiteRejectsUnknownMode(t *testing.T) {
|
||||
run := runPrePushSuite(t, "present", announceWithExecutor, "BD_PREPUSH_SUITE=sometimes")
|
||||
if run.exitErr == nil || run.bazel != "" || run.make != "" {
|
||||
t.Fatalf("unknown mode: err %v, bazel %q, make %q\n%s", run.exitErr, run.bazel, run.make, run.out)
|
||||
}
|
||||
}
|
||||
|
||||
// The hook runs the suite only for branch pushes whose commits change Go or
|
||||
// Bazel inputs; a tag push, a deletion, or a docs-only push skips it.
|
||||
func TestPrePushHookRunsSuiteOnlyForGoChanges(t *testing.T) {
|
||||
body := readPolicyFile(t, sourceRepoRoot(t), ".githooks/pre-push")
|
||||
for _, want := range []string{
|
||||
`"$repo_root/scripts/pre-push-suite.sh" </dev/null`,
|
||||
"refs/heads/*)",
|
||||
"'*.go'",
|
||||
"'*.bazel'",
|
||||
} {
|
||||
if !strings.Contains(body, want) {
|
||||
t.Errorf(".githooks/pre-push lacks %q", want)
|
||||
}
|
||||
}
|
||||
managed := strings.Index(body, "# --- BEGIN BEADS INTEGRATION")
|
||||
suite := strings.Index(body, "pre-push-suite.sh")
|
||||
if managed < 0 || suite < 0 || suite > managed {
|
||||
t.Errorf(".githooks/pre-push must run the suite before the managed beads section")
|
||||
}
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue