Build & test

There is no CI you push to and no test rig that runs your fork change for you. Getting a change from your working tree onto a running box, and proving it holds, is manual and box-shaped: you stage the change where the installer will fetch it, let a disposable box pull it the way production would, and then run the behaviour by hand.

This topic covers the two halves:

• how a change actually lands on a box (the prebuilt Ægir bundle vs the per-repo git clone the _DL_MODE fork selects, and the versioned Drush 8 tarball, with the different levers that make a box re-fetch each)
• how you verify a security-sensitive change once it is there, worked through end to end for the *.drush.inc backend filter.

The lint gates that run before any of this — bash -n + ShellCheck for the bash tree, phpNN -l and the PHP 5.6-through-8.5 span for the Ægir forks — live on Code style & conventions and are not repeated here; this topic starts where lint ends.

Delivery shapes and the _DL_MODE fork

Which mechanism carries your change onto a box decides how you make the box pick it up — and the mechanism is not fixed: it is gated by _DL_MODE, which ships BATCH (barracuda.sh.cnf:349, octopus.sh.cnf:210; the value is persisted to a box's control file, default BATCH at satellite.sh.inc:1185-1186). A default box therefore does not git-clone the Ægir tree per repo — it pulls a single prebuilt bundle.

Two levers follow from this, and they are different:

• The Ægir tree is bundle-borne on a default box. _gCb ${_gitHub}/… runs only in the else (non-BATCH) branch of _master_download_for_local_build (master.sh.inc:575-588) and its satellite twin — so pointing a default box at a branch that carries your Hostmaster/hosting/hosting_*/Provision commit and re-running the upgrade will not pick it up; the box rebuilds from make_local.tar.gz, which is staged on the mirror, not cloned from the branch. To exercise a source change the branch way you must set _DL_MODE=GIT on the test box (then the per-repo clone at 5.x-${_tRee} fetches your branch; _BRANCH_PRN ships the literal AUTO — set it to a real Provision branch such as 5.x-${_tRee} for that path). Otherwise the branch change reaches boxes only once it is folded into the published make_local.tar.gz bundle.
• The Drush 8 fork is pin-borne in every mode. _get_dev_ext fetches drush-<VRN>.tar.gz and a box that already has that version skips it, so a re-run at the same pin never sees your change. Shipping a Drush-fork change is a version bump — _DRUSH_EIGHT_VRN in BARRACUDA.sh.txt:50, _DRUSH_VERSION in OCTOPUS.sh.txt:56 (8.5.4 at HEAD) — plus staging the matching tarball. That is precisely how the drush-filter change moved from inert to shipped (effective and unconditional in 8.5.3, then backend-identity-gated in 8.5.4).

The tarball fetch is the same _get_dev_ext in every case — curl ${_crlGet} "${_urlDev}/${_tRee}/$1" (helper.sh.inc:264), a 10-attempt loop (helper.sh.inc:261) — so a local test build lives at dev/<tree>/<name>.tar.gz on whatever mirror the box resolves via _urlDev (barracuda.sh.cnf:1409).

How the whole box re-fetches BOA's own tool set on a tag — the _fetch_versioned stamp/serial machinery — is the Release model & SKYNET pipeline topic; this page is about the individual component your change lives in.

The disposable-VM test gate

The tree's own commit discipline states the standard plainly: changes land unit-tested and ShellCheck-clean but explicitly "not yet VM-tested at commit time", and operator docs for the riskier reapers advise "exercise in dry-run and on a disposable VM before enabling on production."

The gate is a real, throwaway box because the things that break are environmental — none of which a lint pass or a laptop php -l can see:

• a su without - that changes HOME
• a realpath that resolves differently under the real Drupal-root cwd
• an ICU/intl mismatch
• a permission bit

The BOA 5.6 floor makes this sharper still: there is no local php5.6, so a syntax-and-runtime claim about the 5.6 end of the span is only ever confirmed on a box that actually runs the 5.6 CLI.

A minimal test loop for a fork change:

1. stage the change where the box will actually fetch it:
   Aegir-tree change  -> either fold it into the published make_local.tar.gz
                         bundle, OR set _DL_MODE=GIT on the box and push the
                         commit to a branch the box's _tRee clones (5.x-<tRee>)
   Drush-8-fork change -> bump the pin + stage drush-<VRN>.tar.gz on the mirror
2. build a disposable box: full Barracuda install, then one Octopus instance
3. run the box's own upgrade path so it fetches your change the production way
   (BATCH default: re-pulls the bundle/pin; _DL_MODE=GIT: re-clones the branch)
4. exercise the behaviour by hand — for a task-path change, run the real
   Aegir task, not just the CLI it wraps
5. tear the box down

Step 4 is where the runbook below fits: for a change whose whole point is who is allowed to do something, you have to run it as each identity, on a real box, through the real discovery path — not reason about it from the diff.

Reference

• Variables and Commands — the consolidated _VAR and CLI tables, including the _DRUSH_*_VRN / _DRUSH_VERSION pins, _tRee / _BRANCH_PRN / _gCb, and the upgrade verbs a test box drives.
• Discontinued features — retired build/test mechanics land there; check it before documenting anything found only in old trees.