Skip to content

PostgreSQL backup tool with Point-In-Time-Recovery and restore verification

DOCS (openspec): Specify the sharded backend test groups and the parallel filesystem case groups, so the CI specs match the pipeline

Rostislav Dugina12a8e07e596
diff --git a/openspec/changes/archive/2026-10-24-split-ci-test-suites-into-shards/.openspec.yaml b/openspec/changes/archive/2026-10-24-split-ci-test-suites-into-shards/.openspec.yaml
new file mode 100644
index 00000000..1f5d2804
--- /dev/null
+++ b/openspec/changes/archive/2026-10-24-split-ci-test-suites-into-shards/.openspec.yaml
@@ -0,0 +1,2 @@
+schema: spec-driven
+created: 2026-10-24
diff --git a/openspec/changes/archive/2026-10-24-split-ci-test-suites-into-shards/design.md b/openspec/changes/archive/2026-10-24-split-ci-test-suites-into-shards/design.md
new file mode 100644
index 00000000..2e574109
--- /dev/null
+++ b/openspec/changes/archive/2026-10-24-split-ci-test-suites-into-shards/design.md
@@ -0,0 +1,61 @@
+## Context
+
+See proposal.md, Why. The backend groups come from `test-group-packages` in `backend/Justfile:23`, and the CI test step passes its output to `go test -p=8` (`.github/workflows/ci-release.yml:423`). Sharding adds `test-group-tests` (`backend/Justfile:42`), which prints a `-run` pattern for the same step. The filesystem cases are grouped in `e2e/docker-storage/run.sh:1289`, and CI builds the candidate in `build-storage-image` (`.github/workflows/ci-release.yml:429`) for the `test-filesystems` matrix (`.github/workflows/ci-release.yml:491`).
+
+The approach follows the root `AGENTS.md`, including its Security rules for workflows: every action stays pinned to a full SHA, and no new secret or permission is added. It also follows `backend/AGENTS.md` for the test recipes. The tests themselves do not change, so the shared test database rules of ADR-0013 keep applying to each shard as they did to each group.
+
+## Goals / Non-Goals
+
+**Goals:**
+
+- No backend check is bounded by a whole slow package any more.
+- Coverage stays provable locally: every package in one group, and every top-level test of a sharded group in one shard.
+
+**Non-Goals:**
+
+- Balancing shards exactly. A shard can be uneven when the weights are stale.
+
+## Decisions
+
+### Shard by top-level test name inside the group's packages
+
+A shard runs its group's packages with `-run` limited to its share of the top-level test names. Names that are not in a package match nothing there, so one pattern serves several packages, for example `pg17` and `pg18`, which share most names.
+
+Rejected alternatives:
+- More whole-package groups. A group cannot be faster than its slowest package, and that package took most of the group's time.
+- `t.Parallel()` inside the slow packages. Their tests share physical PostgreSQL instances and replication slots, so each test would need its isolation checked one by one.
+- `go test -shuffle` or test sharding by a test binary flag. Go has no built-in sharding flag, and shuffling changes order, not the set of tests per runner.
+
+### Read test names from the sources, not from `go test -list`
+
+`go test -list` runs the test binary, and these packages' `TestMain` starts their database containers before listing anything. A grep for top-level `func Test`, `func Example` and `func Fuzz` in `_test.go` files needs no build and no Docker. `TestMain` is excluded by name.
+
+Rejected alternative: `go test -list` with a dummy environment. It still compiles each package and depends on `TestMain` failing harmlessly.
+
+### Deal the slowest tests first by recorded weights
+
+Tests are sorted by their weight in `backend/test-shard-weights.txt`, heaviest first, then by name, and each goes to the least-loaded shard. A test missing from the file weighs one second. Measured locally, round-robin by sorted name put the two slowest WAL tests in the same shard, which gave shard loads of 58, 79 and 298 s. The weighted deal gave 164, 137 and 134 s. For `physical` it gave 109, 105 and 105 s instead of 89, 170 and 61 s.
+
+Rejected alternatives:
+- Round-robin or hashing by name. Five tests carry most of the time, so the result depends on where their names happen to sort.
+- Weights pulled from CI timings at run time. That needs a store for the timings and adds a moving part to every run. A hand-refreshed file is enough while a handful of tests dominate.
+
+### Run the small groups on 4 vCPU runners
+
+Only `other` runs many packages at once. `logical` runs four packages, and every shard runs one or two. On 8 vCPU runners the eight legs and the lint jobs together exceeded the Namespace concurrency limit and queued. Measured Go test times in the earlier benchmark were about the same on 4 and 8 vCPU for single-package work.
+
+Rejected alternative: every leg on 8 vCPU. It holds twice the share of the concurrency limit for no measured gain.
+
+### Build the filesystem candidate once and pass it as an artifact
+
+`build-storage-image` builds the amd64 candidate on the Remote Builder and uploads it as a compressed `docker save` archive with one-day retention. Each case group downloads it and loads it locally. Uploads and downloads retry up to three times with a per-attempt timeout.
+
+Rejected alternatives:
+- Each group builds its own candidate. Four builds instead of one, and the groups would test four builds rather than one.
+- Pushing the candidate to a registry. It needs registry credentials in pull request jobs and publishes an untested image.
+
+## Risks / Trade-offs
+
+- [Weights go stale as tests change] → A stale weight only unbalances shards. Refresh the file from a local `go test -json` run when a shard becomes the slowest check.
+- [The grep misses a top-level test] → That test would run in no shard. Go runs only functions named `Test…`, `Example…` and `Fuzz…`, and the formatter the backend lint enforces puts every top-level `func` at the start of a line, which is the form the grep matches.
+- [More checks per run] → Each run uses five more backend runners and three more filesystem runners, and each repeats its setup. On Namespace that setup is under a minute.
diff --git a/openspec/changes/archive/2026-10-24-split-ci-test-suites-into-shards/proposal.md b/openspec/changes/archive/2026-10-24-split-ci-test-suites-into-shards/proposal.md
new file mode 100644
index 00000000..c59cd745
--- /dev/null
+++ b/openspec/changes/archive/2026-10-24-split-ci-test-suites-into-shards/proposal.md
@@ -0,0 +1,41 @@
+## Why
+
+On Namespace runners a backend test group starts in under a minute, so the remaining CI time is bounded by single slow packages. The `other` group took about 400 s of test time, and 359 s of it was one package, `backups/usecases/physical/postgresql`. The `physical` group took about 300 s, and that was its `pg17` package. A few tests dominate both: one of 150 s and one of 93 s in the WAL usecases package, and one of 109 s in `pg17`. Spreading packages across more groups cannot get below such a package, so the groups have to split the tests inside it. The Docker filesystem suite had the same shape. One job built the candidate image and then ran 23 cases one after another.
+
+## Governing docs
+
+This change answers to [`AGENTS.md`](../../../AGENTS.md), including its Security rules for workflows, and to [`backend/AGENTS.md`](../../../backend/AGENTS.md) for the backend test recipes. It changes `.github/workflows/ci-release.yml`, `backend/Justfile`, the new `backend/test-shard-weights.txt` and `e2e/docker-storage/run.sh`. It changes no Go code, migrations or tests.
+
+## What Changes
+
+- The backend suite runs as eight checks instead of three. `logical` and `other` stay whole. `physical` runs as three shards, and the WAL usecases package `internal/features/backups/backups/usecases/physical/postgresql` leaves `other` for its own group, `wal-usecases`, which also runs as three shards.
+- A shard group is named `<group>-<shard>-of-<count>`. A new `test-group-tests` recipe in `backend/Justfile` prints the `-run` pattern of one shard. It reads the top-level test names from the test sources, then deals the slowest first, each to the least-loaded shard by the weights in `backend/test-shard-weights.txt`. Every test lands in exactly one shard. A test missing from the weights file counts as one second. A stale weight makes a shard slower but never skips a test.
+- `test-group-packages` accepts the shard names and the new `wal-usecases` group, and `other` drops the WAL usecases package.
+- **BREAKING** for anything that matches check names: the backend checks are now `test-backend (other)`, `test-backend (logical)`, `test-backend (physical-1-of-3)` through `(physical-3-of-3)` and `test-backend (wal-usecases-1-of-3)` through `(wal-usecases-3-of-3)`. No branch protection or active ruleset requires the old names.
+- The Docker filesystem suite runs as four parallel checks, one per case group: `permissions`, `network`, `upgrades` and `lifecycle`. A separate `build-storage-image` job builds the amd64 candidate once and hands it to the four checks as a workflow artifact, so no check builds its own. `run.sh` accepts `CASE_GROUP` to run one group, and `CASE=<case>` still runs a single case.
+
+## Capabilities
+
+### New Capabilities
+
+None.
+
+### Modified Capabilities
+
+- `ci-pipeline`: the backend suite is split into whole groups and sharded groups instead of exactly three groups, and the check names, coverage rule and release gate follow.
+- `docker-storage-compatibility`: CI runs the filesystem suite as parallel case groups from one candidate image that is built once and transferred between jobs as an artifact, instead of one job that builds its own candidate and never transfers it.
+
+## Impact
+
+- `.github/workflows/ci-release.yml`: `test-backend` becomes a matrix of eight legs. `other` runs on an 8 vCPU runner, and the seven legs that run one to four packages run on 4 vCPU runners. The test step passes the shard's `-run` pattern to `go test`. `test-filesystems` becomes a matrix of four case groups behind the new `build-storage-image` job.
+- `backend/Justfile`: `test-group-packages` changes, and `test-group-tests` is new.
+- `backend/test-shard-weights.txt`: a new file of test durations from one local run.
+- `e2e/docker-storage/run.sh`: case groups and `CASE_GROUP`.
+- Each CI run uses five more backend runners and four filesystem runners instead of one.
+
+## Out of scope
+
+- Making the slow tests themselves faster, and `t.Parallel()` inside the sharded packages.
+- Refreshing the weights file automatically from CI timings.
+- Sharding `logical` or `other`.
+- The choice of runners and caches on Namespace, which the specs do not describe.
diff --git a/openspec/changes/archive/2026-10-24-split-ci-test-suites-into-shards/specs/ci-pipeline/spec.md b/openspec/changes/archive/2026-10-24-split-ci-test-suites-into-shards/specs/ci-pipeline/spec.md
new file mode 100644
index 00000000..22e22302
--- /dev/null
+++ b/openspec/changes/archive/2026-10-24-split-ci-test-suites-into-shards/specs/ci-pipeline/spec.md
@@ -0,0 +1,51 @@
+## RENAMED Requirements
+
+- FROM: `### Requirement: The backend suite runs as three groups that cover every package once`
+- TO: `### Requirement: The backend suite runs as whole and sharded groups that cover every test once`
+
+## MODIFIED Requirements
+
+### Requirement: The backend suite runs as whole and sharded groups that cover every test once
+
+CI SHALL run the backend test suite as separate checks on separate runners, and the checks SHALL run at the same time. The `physical` group SHALL run the end-to-end physical backup tests, and the `logical` group SHALL run the end-to-end logical backup tests. The `wal-usecases` group SHALL run the package of the physical backup and WAL streaming use cases. The `other` group SHALL run every remaining backend package. Each backend package SHALL belong to exactly one group. A backend package added outside these named groups SHALL run in the `other` group without any change to the CI configuration.
+
+A group MAY run as several shards. Each shard SHALL run the tests of its group's packages that fall into that shard, and every top-level test of those packages SHALL run in exactly one shard. A test added to a sharded group SHALL run in one of its shards without any change to the CI configuration. How tests are assigned to shards MAY use recorded test durations, and a missing or outdated duration SHALL only change which shard runs a test, never whether it runs. `physical` and `wal-usecases` SHALL run as three shards each, and `logical` and `other` SHALL each run whole.
+
+#### Scenario: The groups cover the suite
+
+- **WHEN** the package lists of the groups are combined
+- **THEN** they contain every backend package exactly once
+
+#### Scenario: The shards cover their group
+
+- **WHEN** the tests of all shards of one group are combined
+- **THEN** they contain every top-level test of that group's packages exactly once
+
+#### Scenario: A new package is added
+
+- **WHEN** a developer adds a backend package outside the named groups
+- **THEN** CI runs its tests in the `other` group
+
+#### Scenario: A new test is added to a sharded group
+
+- **WHEN** a developer adds a top-level test to a package of a sharded group and records no duration for it
+- **THEN** CI runs that test in exactly one shard of the group
+
+#### Scenario: Checks are reported per group
+
+- **WHEN** CI runs the backend tests
+- **THEN** each whole group and each shard reports its own check, named `test-backend (other)`, `test-backend (logical)`, `test-backend (physical-1-of-3)` through `test-backend (physical-3-of-3)` and `test-backend (wal-usecases-1-of-3)` through `test-backend (wal-usecases-3-of-3)`
+
+### Requirement: Publishing and release require the lint and every test group
+
+CI SHALL publish an image or create a release only when the backend lint and every backend test check, each whole group and each shard, have passed for that commit. Running the lint and the tests in parallel SHALL NOT let a commit with a failed lint, a failed group or a failed shard reach publishing or release.
+
+#### Scenario: Lint fails on main
+
+- **WHEN** the backend lint fails on a push to `main` while every backend test check passes
+- **THEN** CI publishes no image and creates no release for that commit
+
+#### Scenario: One group fails on main
+
+- **WHEN** the lint and every other backend test check pass on a push to `main` but one shard fails
+- **THEN** CI publishes no image and creates no release for that commit
diff --git a/openspec/changes/archive/2026-10-24-split-ci-test-suites-into-shards/specs/docker-storage-compatibility/spec.md b/openspec/changes/archive/2026-10-24-split-ci-test-suites-into-shards/specs/docker-storage-compatibility/spec.md
new file mode 100644
index 00000000..b148223e
--- /dev/null
+++ b/openspec/changes/archive/2026-10-24-split-ci-test-suites-into-shards/specs/docker-storage-compatibility/spec.md
@@ -0,0 +1,34 @@
+## MODIFIED Requirements
+
+### Requirement: One filesystem suite runs locally and in CI
+
+The repository SHALL provide `just test-filesystem` as the single entry point for the Docker filesystem suite. It SHALL build or accept a local candidate image and run the same cases locally and in CI. The suite SHALL sort every case into exactly one case group: `permissions`, `network`, `upgrades` or `lifecycle`. It SHALL run every group when no group or case is selected, the cases of one group when a group is selected, and a single case when a case is selected. An unknown group SHALL fail the run before any case starts.
+
+CI SHALL build the candidate once and run each case group as its own check from that same candidate. The candidate SHALL pass between CI jobs only as a short-lived workflow artifact and SHALL NOT be pushed to or pulled from an image registry.
+
+Each positive case SHALL start the real container and invoke `databasus --test-storage`, which uses the public local-storage save and delete methods. Each negative case SHALL assert the startup failure and its actionable error. Every case SHALL clean its containers, volumes, networks, mounts, and temporary files.
+
+#### Scenario: Developer runs the complete suite
+
+- **WHEN** a developer runs `just test-filesystem` without an image reference, a group or a case
+- **THEN** the recipe builds a local candidate and runs every case group against it
+
+#### Scenario: Developer runs one group
+
+- **WHEN** a developer runs `just test-filesystem` with the `network` group selected
+- **THEN** only the cases of the `network` group run
+
+#### Scenario: An unknown group is selected
+
+- **WHEN** a developer selects a case group that does not exist
+- **THEN** the run fails with an error that names the group, and no case starts
+
+#### Scenario: CI tests its candidate
+
+- **WHEN** CI tests a commit
+- **THEN** one job builds the candidate, each case group runs as its own check against that candidate, and no candidate image is pushed to or pulled from a registry
+
+#### Scenario: A case allocates Docker resources
+
+- **WHEN** the case succeeds or fails after resource allocation
+- **THEN** the harness removes every resource created by that case
diff --git a/openspec/changes/archive/2026-10-24-split-ci-test-suites-into-shards/tasks.md b/openspec/changes/archive/2026-10-24-split-ci-test-suites-into-shards/tasks.md
new file mode 100644
index 00000000..e61a6496
--- /dev/null
+++ b/openspec/changes/archive/2026-10-24-split-ci-test-suites-into-shards/tasks.md
@@ -0,0 +1,10 @@
+## 1. Backend groups and shards
+
+- [x] 1.1 In `backend/Justfile`, make `test-group-packages` accept `<group>-<shard>-of-<count>` names and the new `wal-usecases` group, and drop the WAL usecases package from `other`. Verify in `backend/` under bash that `diff <(go list ./internal/... | sort) <(for g in physical-1-of-3 logical wal-usecases-1-of-3 other; do just test-group-packages "$g"; done | sort)` prints nothing and that `just test-group-packages bogus` exits non-zero.
+- [x] 1.2 Add `test-group-tests` to `backend/Justfile` and `backend/test-shard-weights.txt`, as design.md describes. Verify that the patterns of `wal-usecases-1-of-3` through `-3-of-3` together list every top-level test of that package exactly once, that the same holds for `physical`, that `just test-group-tests logical` prints nothing, that `just test-group-tests physical-3-of-2` exits non-zero, and that `just --fmt --check --unstable` passes in `backend/`.
+- [x] 1.3 In `.github/workflows/ci-release.yml`, turn `test-backend` into the eight-leg matrix with `other` on the 8 vCPU profile and the other legs on the 4 vCPU profile, and pass the shard pattern to `go test` through `${run_pattern:+-run "$run_pattern"}`. Verify that `actionlint .github/workflows/ci-release.yml` reports nothing but runner-label warnings, and that running the step's commands for `physical-1-of-3` under bash passes its one test in `pg17` and reports no tests to run in `pg18`.
+
+## 2. Filesystem suite groups
+
+- [x] 2.1 In `e2e/docker-storage/run.sh`, sort the cases into the `permissions`, `network`, `upgrades` and `lifecycle` groups and accept `CASE_GROUP`, keeping `CASE=<case>` for one case. Verify that the four groups together list the same 23 cases as before with no duplicates, and that an unknown `CASE_GROUP` exits with status 2.
+- [x] 2.2 In `.github/workflows/ci-release.yml`, add `build-storage-image`, which builds the candidate once and uploads it as an artifact, and turn `test-filesystems` into a matrix of the four groups that downloads and loads it. Verify that `actionlint .github/workflows/ci-release.yml` reports nothing but runner-label warnings.
diff --git a/openspec/specs/ci-pipeline/spec.md b/openspec/specs/ci-pipeline/spec.md
index 9c71a046..8335233f 100644
--- a/openspec/specs/ci-pipeline/spec.md
+++ b/openspec/specs/ci-pipeline/spec.md
@@ -20,24 +20,36 @@ When CI runs the backend lint and the backend tests for a commit, the backend te
- **WHEN** the backend lint check fails while the backend tests run
- **THEN** the backend test checks run to completion and report their own results
-### Requirement: The backend suite runs as three groups that cover every package once
+### Requirement: The backend suite runs as whole and sharded groups that cover every test once
-CI SHALL run the backend test suite as three checks on separate runners, and the checks SHALL run at the same time. The `physical` group SHALL run the end-to-end physical backup tests, and the `logical` group SHALL run the end-to-end logical backup tests. The `other` group SHALL run every remaining backend package. Each backend package SHALL run in exactly one group. A backend package added outside the end-to-end physical and logical backup tests SHALL run in the `other` group without any change to the CI configuration.
+CI SHALL run the backend test suite as separate checks on separate runners, and the checks SHALL run at the same time. The `physical` group SHALL run the end-to-end physical backup tests, and the `logical` group SHALL run the end-to-end logical backup tests. The `wal-usecases` group SHALL run the package of the physical backup and WAL streaming use cases. The `other` group SHALL run every remaining backend package. Each backend package SHALL belong to exactly one group. A backend package added outside these named groups SHALL run in the `other` group without any change to the CI configuration.
+
+A group MAY run as several shards. Each shard SHALL run the tests of its group's packages that fall into that shard, and every top-level test of those packages SHALL run in exactly one shard. A test added to a sharded group SHALL run in one of its shards without any change to the CI configuration. How tests are assigned to shards MAY use recorded test durations, and a missing or outdated duration SHALL only change which shard runs a test, never whether it runs. `physical` and `wal-usecases` SHALL run as three shards each, and `logical` and `other` SHALL each run whole.
#### Scenario: The groups cover the suite
-- **WHEN** the package lists of the three groups are combined
+- **WHEN** the package lists of the groups are combined
- **THEN** they contain every backend package exactly once
+#### Scenario: The shards cover their group
+
+- **WHEN** the tests of all shards of one group are combined
+- **THEN** they contain every top-level test of that group's packages exactly once
+
#### Scenario: A new package is added
-- **WHEN** a developer adds a backend package outside the end-to-end physical and logical backup tests
+- **WHEN** a developer adds a backend package outside the named groups
- **THEN** CI runs its tests in the `other` group
+#### Scenario: A new test is added to a sharded group
+
+- **WHEN** a developer adds a top-level test to a package of a sharded group and records no duration for it
+- **THEN** CI runs that test in exactly one shard of the group
+
#### Scenario: Checks are reported per group
- **WHEN** CI runs the backend tests
-- **THEN** each group reports its own check, named `test-backend (physical)`, `test-backend (logical)` and `test-backend (other)`
+- **THEN** each whole group and each shard reports its own check, named `test-backend (other)`, `test-backend (logical)`, `test-backend (physical-1-of-3)` through `test-backend (physical-3-of-3)` and `test-backend (wal-usecases-1-of-3)` through `test-backend (wal-usecases-3-of-3)`
### Requirement: A failed group neither cancels nor hides the others
@@ -55,14 +67,14 @@ When one backend test group fails, the other groups SHALL run to completion and
### Requirement: Publishing and release require the lint and every test group
-CI SHALL publish an image or create a release only when the backend lint and all three backend test groups have passed for that commit. Running the lint and the tests in parallel SHALL NOT let a commit with a failed lint or a failed group reach publishing or release.
+CI SHALL publish an image or create a release only when the backend lint and every backend test check, each whole group and each shard, have passed for that commit. Running the lint and the tests in parallel SHALL NOT let a commit with a failed lint, a failed group or a failed shard reach publishing or release.
#### Scenario: Lint fails on main
-- **WHEN** the backend lint fails on a push to `main` while all three test groups pass
+- **WHEN** the backend lint fails on a push to `main` while every backend test check passes
- **THEN** CI publishes no image and creates no release for that commit
#### Scenario: One group fails on main
-- **WHEN** the lint and two test groups pass on a push to `main` but the third group fails
+- **WHEN** the lint and every other backend test check pass on a push to `main` but one shard fails
- **THEN** CI publishes no image and creates no release for that commit
diff --git a/openspec/specs/docker-storage-compatibility/spec.md b/openspec/specs/docker-storage-compatibility/spec.md
index eeb5764a..5ef58e47 100644
--- a/openspec/specs/docker-storage-compatibility/spec.md
+++ b/openspec/specs/docker-storage-compatibility/spec.md
@@ -105,19 +105,31 @@ The container SHALL refuse startup when it detects data at the deprecated Postgr
### Requirement: One filesystem suite runs locally and in CI
-The repository SHALL provide `just test-filesystem` as the single entry point for the Docker filesystem suite. It SHALL build or accept a local candidate image and run the same cases locally and in a dedicated GitHub Actions job. The job SHALL build and load its own candidate without publishing or transferring it.
+The repository SHALL provide `just test-filesystem` as the single entry point for the Docker filesystem suite. It SHALL build or accept a local candidate image and run the same cases locally and in CI. The suite SHALL sort every case into exactly one case group: `permissions`, `network`, `upgrades` or `lifecycle`. It SHALL run every group when no group or case is selected, the cases of one group when a group is selected, and a single case when a case is selected. An unknown group SHALL fail the run before any case starts.
+
+CI SHALL build the candidate once and run each case group as its own check from that same candidate. The candidate SHALL pass between CI jobs only as a short-lived workflow artifact and SHALL NOT be pushed to or pulled from an image registry.
Each positive case SHALL start the real container and invoke `databasus --test-storage`, which uses the public local-storage save and delete methods. Each negative case SHALL assert the startup failure and its actionable error. Every case SHALL clean its containers, volumes, networks, mounts, and temporary files.
#### Scenario: Developer runs the complete suite
-- **WHEN** a developer runs `just test-filesystem` without an image reference
-- **THEN** the recipe builds a local candidate and tests it
+- **WHEN** a developer runs `just test-filesystem` without an image reference, a group or a case
+- **THEN** the recipe builds a local candidate and runs every case group against it
+
+#### Scenario: Developer runs one group
+
+- **WHEN** a developer runs `just test-filesystem` with the `network` group selected
+- **THEN** only the cases of the `network` group run
+
+#### Scenario: An unknown group is selected
+
+- **WHEN** a developer selects a case group that does not exist
+- **THEN** the run fails with an error that names the group, and no case starts
#### Scenario: CI tests its candidate
-- **WHEN** the filesystem job builds and loads its candidate
-- **THEN** the suite tests that local image without pushing or pulling a candidate image
+- **WHEN** CI tests a commit
+- **THEN** one job builds the candidate, each case group runs as its own check against that candidate, and no candidate image is pushed to or pulled from a registry
#### Scenario: A case allocates Docker resources