mirror of
https://github.com/NousResearch/hermes-agent.git
synced 2026-11-17 03:12:19 +03:00
06192b894c
Remove the darwin-x64 build, receipt and smoke jobs from Desktop Bundled Release and the candidates/transitions/packaged-x64 jobs from Stable Release, with the release scripts that required them: the macos-intel lane, the darwin-x64 job group, the x64 macOS target in candidate/channel manifests and the two-leg macOS feed merge. The macOS updater feed is arm64-only. Pre-lanes claims still read: the published ones all carry includeMacosIntel:false; a claim with true is now refused.
460 lines
25 KiB
Python
460 lines
25 KiB
Python
"""The release workflow's dependency graph enforces publication ordering."""
|
|
import json
|
|
import os
|
|
import subprocess
|
|
from pathlib import Path
|
|
|
|
import pytest
|
|
from ruamel.yaml import YAML
|
|
|
|
from scripts.releases import lanes as lane_set
|
|
|
|
from tests.ci.desktop_release_roles import gate
|
|
from tests.ci.workflow_steps import is_checkout
|
|
|
|
ROOT = Path(__file__).resolve().parents[2]
|
|
|
|
|
|
def workflow(name):
|
|
return YAML(typ="base").load((ROOT / ".github/workflows" / name).read_text(encoding="utf-8"))
|
|
|
|
|
|
def direct_needs(jobs, name):
|
|
needs = jobs[name].get("needs", [])
|
|
return [needs] if isinstance(needs, str) else needs
|
|
|
|
|
|
def ancestors(jobs, name):
|
|
seen = set()
|
|
pending = [name]
|
|
while pending:
|
|
needs = jobs[pending.pop()].get("needs", [])
|
|
for item in [needs] if isinstance(needs, str) else needs:
|
|
if item not in seen:
|
|
seen.add(item)
|
|
pending.append(item)
|
|
return seen
|
|
|
|
|
|
def test_admit_can_read_the_claim_draft():
|
|
jobs = workflow("stable-release.yml")["jobs"]
|
|
assert jobs["admit"]["permissions"]["contents"] == "write"
|
|
|
|
|
|
def test_release_reuses_whole_ci_and_docker_before_publication():
|
|
jobs = workflow("stable-release.yml")["jobs"]
|
|
assert jobs["ci"]["uses"] == "./.github/workflows/ci.yaml"
|
|
assert jobs["ci"]["with"]["release"] == "true"
|
|
assert "secrets" not in jobs["ci"]
|
|
assert jobs["docker"]["uses"] == jobs["publish-docker"]["uses"]
|
|
assert jobs["docker"]["with"]["release-phase"] == "test"
|
|
# B7: every gate and every signed candidate starts straight after admit.
|
|
# The acceptance join requires CI, so a slow gate cannot delay a build.
|
|
for parallel in ("docker", "nix", "pm-bundle", "termux-checks", "windows-live", "install-e2e"):
|
|
assert direct_needs(jobs, parallel) == ["admit"], parallel
|
|
candidate_calls = ["candidates-darwin-arm64", "candidates-win32-arm64",
|
|
"candidates-win32-x64", "candidates-win32-bundle", "candidates-termux"]
|
|
# The Windows bundle group is the only candidate that waits on a peer.
|
|
for call in candidate_calls:
|
|
assert set(direct_needs(jobs, call)) <= {
|
|
"admit", "candidates-win32-arm64", "candidates-win32-x64"}, call
|
|
required = {"ci", "docker", "nix", "pm-bundle", "install-e2e", "windows-packaged",
|
|
"macos-packaged-arm64", "termux-checks", "windows-live",
|
|
"candidate-manifest", "transitions-darwin-arm64",
|
|
"transitions-win32", "bootstrap-version", *candidate_calls}
|
|
assert required <= ancestors(jobs, "acceptance")
|
|
# B3: stable calls one build group at a time; the bundle group waits for
|
|
# both Windows arches, and the Linux groups are not called at all.
|
|
assert "candidates" not in jobs
|
|
for name, group in zip(candidate_calls, ("darwin-arm64", "win32-arm64",
|
|
"win32-x64", "win32-bundle", "termux"), strict=True):
|
|
call = jobs[name]
|
|
assert call["uses"] == "./.github/workflows/desktop-bundled-release.yml"
|
|
assert call["with"]["release-phase"] == "candidate"
|
|
assert call["with"]["jobs"] == group
|
|
assert {"tag", "claim-tag", "claim-object"} <= set(call["with"])
|
|
assert {"candidates-win32-arm64", "candidates-win32-x64"} <= set(jobs["candidates-win32-bundle"]["needs"])
|
|
assert not any("linux" in name for name in jobs)
|
|
# B4: each install arm starts from its own receipt, and the manifest is
|
|
# written after every candidate call (so after every smoke).
|
|
for name in ("transitions", "macos-packaged"):
|
|
assert name not in jobs
|
|
assert set(jobs["candidate-manifest"]["needs"]) == \
|
|
{"admit", *candidate_calls}
|
|
for receipt, call, packaged, matrix in (
|
|
("transitions-darwin-arm64", "candidates-darwin-arm64", "macos-packaged-arm64", "macos"),
|
|
("transitions-win32", "candidates-win32-bundle", "windows-packaged", "windows")):
|
|
assert jobs[receipt]["needs"] == ["admit", call]
|
|
# The packaged leg names the claim commit, so it reads admit directly.
|
|
assert jobs[packaged]["needs"] == ["admit", receipt]
|
|
assert jobs[packaged]["strategy"]["matrix"] == \
|
|
"${{ fromJSON(needs." + receipt + ".outputs." + matrix + ") }}"
|
|
# B5: publish-docker starts when the docker tests pass; it does not wait
|
|
# for the acceptance join. publish-bundles still does.
|
|
assert jobs["publish-docker"]["needs"] == ["admit", "docker"]
|
|
assert {"admit", "docker"} <= ancestors(jobs, "publish-docker")
|
|
assert "acceptance" not in ancestors(jobs, "publish-docker")
|
|
assert required <= ancestors(jobs, "publish-bundles")
|
|
assert {"publish-docker", "publish-bundles", "publication"} <= ancestors(jobs, "complete")
|
|
assert "promote-docker" not in jobs and "promote-bundles" not in jobs
|
|
# The gates must run to judge a failed or skipped prerequisite, not skip with it.
|
|
for name in ("acceptance", "publication", "complete"):
|
|
failed = {need: {"result": "failure"} for need in ancestors(jobs, name)}
|
|
assert gate(jobs[name]["if"], {}, failed), name
|
|
|
|
|
|
LANE_SETS = {
|
|
"default": lane_set.DEFAULT,
|
|
"everything": frozenset(lane_set.NAMES),
|
|
"windows and docker, untested": lane_set.select(only=["windows", "docker"]),
|
|
"docker only": lane_set.select(only=["docker"]),
|
|
"no mac": lane_set.select(without=["macos-arm64"]),
|
|
"no tests": lane_set.select(without=lane_set.NAMES[5:]),
|
|
"nothing": frozenset(),
|
|
# Each lane alone and each lane missing, so no job's condition can borrow another lane's flag.
|
|
**{f"only {name}": frozenset({name}) for name in lane_set.NAMES},
|
|
**{f"everything but {name}": frozenset(lane_set.NAMES) - {name} for name in lane_set.NAMES},
|
|
}
|
|
|
|
|
|
@pytest.mark.parametrize("lanes", LANE_SETS.values(), ids=LANE_SETS)
|
|
def test_every_lane_controlled_job_runs_exactly_when_the_lane_table_says(lanes):
|
|
"""The workflow's `if` conditions and the gate's expectations describe the same graph."""
|
|
jobs = workflow("stable-release.yml")["jobs"]
|
|
runs = lane_set.jobs_to_run(lanes)
|
|
admit = {"result": "success", "outputs": {"lanes": json.dumps(lane_set.flags(lanes)),
|
|
"jobs": json.dumps(runs)}}
|
|
|
|
def result(name):
|
|
if name == "admit":
|
|
return admit
|
|
# What the job does under these lanes is what the table says (a job outside it never skips).
|
|
return {"result": "success" if runs.get(name, True) else "skipped",
|
|
"outputs": {"baseline": "published"}}
|
|
|
|
for name, wanted in runs.items():
|
|
assert name in jobs, name
|
|
needs = {need: result(need) for need in direct_needs(jobs, name)}
|
|
assert gate(jobs[name].get("if", "true"), {}, needs) == wanted, (name, sorted(lanes))
|
|
# A job that is not lane-controlled never skips with the lanes.
|
|
for name in set(jobs) - set(runs) - {"admit", "acceptance", "publication", "complete",
|
|
"candidate-manifest", "publish-bundles"}:
|
|
assert "outputs.jobs" not in str(jobs[name].get("if", "")), name
|
|
|
|
|
|
def test_lane_inputs_reach_the_workflows_they_configure():
|
|
jobs = workflow("stable-release.yml")["jobs"]
|
|
# Tests the image and the candidates run for themselves follow their own lane.
|
|
assert jobs["docker"]["with"]["skip-tests"] == "${{ !fromJSON(needs.admit.outputs.lanes)['docker-tests'] }}"
|
|
for name in ("candidates-darwin-arm64", "candidates-win32-arm64",
|
|
"candidates-win32-x64", "candidates-win32-bundle", "candidates-termux"):
|
|
assert jobs[name]["with"]["skip-tests"] == "${{ !fromJSON(needs.admit.outputs.lanes).smoke }}", name
|
|
# Which Windows packages the shared builds make follows the two Windows lanes, and the Store
|
|
# submission follows the Store lane.
|
|
store_off = "${{ !fromJSON(needs.admit.outputs.lanes)['windows-store'] }}"
|
|
for name in ("candidates-win32-arm64", "candidates-win32-x64", "candidates-win32-bundle"):
|
|
assert jobs[name]["with"]["skip-signed"] == "${{ !fromJSON(needs.admit.outputs.lanes).windows }}", name
|
|
assert jobs[name]["with"]["skip-store"] == store_off, name
|
|
# The MSIX smokes run in the bundle call, so the bundle never waits for them.
|
|
assert jobs[name]["with"]["windows-smokes-with-bundle"] == "true", name
|
|
assert jobs["publish-bundles"]["with"]["skip-store"] == store_off
|
|
desktop = workflow("desktop-bundled-release.yml")["jobs"]
|
|
assert "inputs.skip-store" in desktop["stable-store"]["if"]
|
|
assert {"lanes", "jobs"} <= set(jobs["admit"]["outputs"])
|
|
for name in ("acceptance", "publication", "complete"):
|
|
gate_step = next(step for step in jobs[name]["steps"]
|
|
if "scripts.releases.stable gate" in step.get("run", ""))
|
|
assert gate_step["env"] == {"RELEASE_NEEDS": "${{ toJSON(needs) }}",
|
|
"LANES": "${{ needs.admit.outputs.lanes }}"}
|
|
gated = gate_step["run"].split(" gate ", 1)[1].split()
|
|
assert set(gated) <= set(direct_needs(jobs, name)), name
|
|
|
|
|
|
def test_a_store_only_build_is_handed_no_signing_variables():
|
|
"""after-pack and electron-builder sign whenever AZURE_SIGN_* are set; the Azure login is skipped
|
|
with the signed lane, so the build step must see them empty."""
|
|
jobs = workflow("desktop-bundled-release.yml")["jobs"]
|
|
step = next(step for step in jobs["build-win32-x64-release"]["steps"] if step.get("name") == "Build and package")
|
|
azure = {key: value for key, value in step["env"].items() if key.startswith("AZURE_") and key != "AZURE_TOKEN_CREDENTIALS"}
|
|
assert set(azure) == {"AZURE_SIGN_ENDPOINT", "AZURE_SIGN_ACCOUNT", "AZURE_SIGN_PROFILE", "AZURE_SIGN_PUBLISHER",
|
|
"AZURE_CLIENT_ID", "AZURE_TENANT_ID"}
|
|
for key, value in azure.items():
|
|
assert value == f"${{{{ inputs.skip-signed != true && vars.{key} || '' }}}}", key
|
|
|
|
|
|
def test_admit_emits_the_same_lanes_and_jobs_the_gate_reads(tmp_path):
|
|
from scripts.releases import stable
|
|
|
|
output = tmp_path / "output"
|
|
summary = tmp_path / "summary"
|
|
admitted = {"claim_tag": "rc.1-v1.2.3", "claim_object": "a" * 40, "tag": "v1.2.3", "commit": "b" * 40,
|
|
"version": "1.2.3", "attempt": 1, "claim_epoch": 1, "autopublish": False,
|
|
"lanes": lane_set.select(only=["windows", "docker"])}
|
|
env = {"GITHUB_OUTPUT": str(output), "GITHUB_STEP_SUMMARY": str(summary), "GITHUB_REPOSITORY": "o/r"}
|
|
from unittest import mock
|
|
with mock.patch.object(stable, "check_claim", return_value=admitted), \
|
|
mock.patch.object(stable, "output", return_value=json.dumps(
|
|
{"tagName": "rc.1-v1.2.3", "isDraft": True, "isPrerelease": False, "databaseId": 7})):
|
|
stable.admit(env)
|
|
emitted = dict(line.split("=", 1) for line in output.read_text(encoding="utf-8").splitlines())
|
|
assert lane_set.from_flags(json.loads(emitted["lanes"])) == admitted["lanes"]
|
|
assert json.loads(emitted["jobs"]) == lane_set.jobs_to_run(admitted["lanes"])
|
|
assert "on: docker, windows" in summary.read_text(encoding="utf-8")
|
|
|
|
|
|
def test_a_skipped_upgrade_arm_never_skips_a_gated_publish_job():
|
|
"""The signed-package upgrade arms skip when there is no published baseline (the first bundled
|
|
release). A gated job downstream of one without a status function inherits that skip, and the
|
|
publication gate then refuses it: rc.11-v0.21.7 blocked on publish-bundles=skipped."""
|
|
from scripts.releases.stable import PACKAGED_BY
|
|
|
|
jobs = workflow("stable-release.yml")["jobs"]
|
|
|
|
for name, job in jobs.items():
|
|
if set(PACKAGED_BY) & ancestors(jobs, name):
|
|
condition = str(job.get("if", ""))
|
|
assert "always()" in condition or "!cancelled()" in condition, (
|
|
f"{name} skips whenever an upgrade arm skips")
|
|
|
|
|
|
def test_all_applicable_ci_jobs_are_aggregated_and_desktop_e2e_stays_deferred():
|
|
jobs = workflow("ci.yaml")["jobs"]
|
|
checks = {name for name, job in jobs.items() if "uses" in job}
|
|
assert checks <= set(jobs["all-checks-pass"]["needs"])
|
|
assert not gate(jobs["e2e-desktop"]["if"], {}, {})
|
|
assert "workflow_call" in workflow("ci.yaml")["on"]
|
|
|
|
|
|
def test_claim_custody_and_final_payload_identity_reach_every_privileged_phase():
|
|
release = workflow("stable-release.yml")
|
|
jobs = release["jobs"]
|
|
# The claim is the one record of the attempt's policy; a dispatch cannot override it.
|
|
inputs = set(release["on"]["workflow_dispatch"]["inputs"])
|
|
assert not {"autopublish", "lanes", "skip-bundles", "skip-tests"}.intersection(inputs)
|
|
assert {"claim-tag", "claim-object", "tag", "commit", "version", "release-id", "release-epoch"} <= \
|
|
set(jobs["admit"]["outputs"])
|
|
for name in ("publish-bundles", *("candidates-darwin-arm64",
|
|
"candidates-win32-arm64", "candidates-win32-x64",
|
|
"candidates-win32-bundle", "candidates-termux")):
|
|
call = jobs[name]["with"]
|
|
assert call["tag"] == "${{ needs.admit.outputs.tag }}"
|
|
assert call["claim-tag"] == "${{ needs.admit.outputs.claim-tag }}"
|
|
assert call["claim-object"] == "${{ needs.admit.outputs.claim-object }}"
|
|
desktop = workflow("desktop-bundled-release.yml")
|
|
assert "release-epoch" in desktop["jobs"]["validate"]["outputs"]
|
|
assert "HERMES_RELEASE_EPOCH" not in desktop["jobs"]["termux-deb"]["env"]
|
|
# B3: each build group stages its own receipt before its smoke, and the
|
|
# receipt URL and digest cross the call boundary as workflow outputs.
|
|
assert "manifest-url" not in desktop["on"]["workflow_call"]["outputs"]
|
|
assert "manifest-sha256" not in desktop["on"]["workflow_call"]["outputs"]
|
|
receipts = {"darwin-arm64": "stage-receipt-darwin-arm64", "win32-bundle": "assemble-win32-bundle"}
|
|
for group, job in receipts.items():
|
|
producer = desktop["jobs"][job]
|
|
assert producer["outputs"]["receipt-url"] == "${{ steps.receipt.outputs.receipt-url }}"
|
|
assert producer["outputs"]["receipt-sha256"] == "${{ steps.receipt.outputs.receipt-sha256 }}"
|
|
for suffix, output in (("url", "receipt-url"), ("sha256", "receipt-sha256")):
|
|
expected = "${{ jobs." + job + ".outputs." + output + " }}"
|
|
assert desktop["on"]["workflow_call"]["outputs"][f"{group}-receipt-{suffix}"]["value"] == expected
|
|
for name in ("smoke-darwin-arm64",):
|
|
assert f"stage-receipt-{name.removeprefix('smoke-')}" in desktop["jobs"][name]["needs"]
|
|
for call, key, output in (("candidates-darwin-arm64", "RECEIPT_URL", "darwin-arm64-receipt-url"),
|
|
("candidates-darwin-arm64", "RECEIPT_SHA256", "darwin-arm64-receipt-sha256"),
|
|
("candidates-win32-bundle", "RECEIPT_URL", "win32-bundle-receipt-url"),
|
|
("candidates-win32-bundle", "RECEIPT_SHA256", "win32-bundle-receipt-sha256")):
|
|
receipt_job = {"candidates-darwin-arm64": "transitions-darwin-arm64",
|
|
"candidates-win32-bundle": "transitions-win32"}[call]
|
|
expected = "${{ needs." + call + ".outputs." + output + " }}"
|
|
assert jobs[receipt_job]["steps"][-1]["env"][key] == expected
|
|
for name in ("docker", "nix"):
|
|
assert jobs[name]["with"]["version"] == "${{ needs.admit.outputs.version }}"
|
|
assert "version" not in jobs["pm-bundle"]["with"]
|
|
assert "release-epoch" not in jobs["docker"]["with"]
|
|
assert "release-epoch" not in jobs["nix"]["with"]
|
|
assert "release-epoch" not in jobs["pm-bundle"]["with"]
|
|
assert "release-epoch" not in jobs["publish-docker"]["with"]
|
|
complete = jobs["complete"]["steps"]
|
|
# A6: the green workflow validates the accepted candidate archive; the
|
|
# final tag and the retarget move to the publication pass.
|
|
validation = next(i for i, step in enumerate(complete)
|
|
if step.get("name", "").startswith("Validate the accepted candidate archive"))
|
|
assert "DOCKER_MANIFEST_DIGEST" not in complete[validation]["env"]
|
|
assert "RELEASE_ID" not in complete[validation]["env"]
|
|
# B4: complete and the render read the manifest that stable-release.yml's
|
|
# candidate-manifest job wrote.
|
|
assert complete[validation]["env"]["CANDIDATE_MANIFEST_SHA256"] == \
|
|
"${{ needs.candidate-manifest.outputs.manifest-sha256 }}"
|
|
assert jobs["publish-bundles"]["with"]["manifest-sha256"] == \
|
|
"${{ needs.candidate-manifest.outputs.manifest-sha256 }}"
|
|
render = next(i for i, step in enumerate(complete) if step.get("name", "").startswith("Render the admitted"))
|
|
reconcile = next(i for i, step in enumerate(complete) if step.get("name", "").startswith("Reconcile ordered"))
|
|
assert validation < render < reconcile
|
|
assert not any("Create the final tag" in step.get("name", "") for step in complete)
|
|
|
|
|
|
def test_docker_dev_stamp_checkout_has_release_history():
|
|
build = workflow("docker.yml")["jobs"]["build"]
|
|
checkout = next(step for step in build["steps"] if is_checkout(step))
|
|
|
|
assert checkout["with"]["fetch-depth"] == "0"
|
|
|
|
|
|
def test_release_gates_extract_consumer_facing_versions():
|
|
release_jobs = workflow("stable-release.yml")["jobs"]
|
|
bootstrap = next(
|
|
step["run"] for step in release_jobs["bootstrap-version"]["steps"]
|
|
if step.get("name") == "Stamp and verify the Cargo and Tauri release identity"
|
|
)
|
|
assert "cargo metadata" in bootstrap
|
|
assert "tauri.conf.json" in bootstrap
|
|
assert "uv build --wheel --sdist" not in bootstrap
|
|
|
|
docker = workflow("docker.yml")["jobs"]
|
|
image_check = next(
|
|
step["run"] for step in docker["build"]["steps"]
|
|
if step.get("name") == "Verify release image identity"
|
|
)
|
|
assert '["baseVersion"]' in image_check and "$RELEASE_VERSION" in image_check
|
|
|
|
nix = workflow("nix.yml")["jobs"]
|
|
nix_check = next(
|
|
step["run"] for step in nix["flake-check"]["steps"]
|
|
if step.get("name") == "Verify release package runtime identity"
|
|
)
|
|
assert '"$package/bin/hermes" --version' in nix_check
|
|
assert "actual != expected" in nix_check
|
|
# A path: flake has no git metadata; without ?rev= the stamp has no commit
|
|
# and the packaged CLI reports "unknown".
|
|
assert 'release-source?rev=$CANDIDATE_COMMIT' in nix_check
|
|
flake_check = next(step["run"] for step in nix["flake-check"]["steps"] if step.get("name") == "nix flake check")
|
|
assert "release-source?rev={1}" in flake_check and "env.CANDIDATE_COMMIT" in flake_check
|
|
|
|
|
|
def test_versioned_docker_images_belong_to_one_attempt():
|
|
# The final vX.Y.Z does not exist until publish; a second attempt pushing
|
|
# under it collides with the first attempt's immutable manifest list.
|
|
jobs = workflow("stable-release.yml")["jobs"]
|
|
for name in ("docker", "publish-docker"):
|
|
assert jobs[name]["with"]["tag"] == "${{ needs.admit.outputs.claim-tag }}"
|
|
|
|
|
|
def test_packaged_stamp_writers_receive_versions_without_rewriting_python_metadata():
|
|
docker_steps = workflow("docker.yml")["jobs"]["build"]["steps"]
|
|
assert not any(step.get("name") == "Stamp release build context" for step in docker_steps)
|
|
write = next(step["run"] for step in docker_steps if step.get("name") == "Write install stamp")
|
|
assert "--base-version" in write and "--display-version" in write
|
|
|
|
nix_steps = workflow("nix.yml")["jobs"]["flake-check"]["steps"]
|
|
prepare = next(step["run"] for step in nix_steps if step.get("name") == "Prepare isolated release source")
|
|
assert "scripts/releases/stamping.py" in prepare
|
|
|
|
|
|
def test_publication_reconciler_has_every_recovery_trigger_and_shared_lock():
|
|
stable = workflow("stable-release.yml")
|
|
publication = workflow("stable-release-publication.yml")
|
|
|
|
assert stable["concurrency"] == publication["concurrency"] == {
|
|
"group": "stable-release", "cancel-in-progress": "false",
|
|
}
|
|
assert {"workflow_dispatch", "workflow_run"} <= set(publication["on"])
|
|
assert publication["on"]["workflow_run"] == {
|
|
"workflows": ["Stable Release"], "types": ["completed"],
|
|
}
|
|
reconcile = publication["jobs"]["reconcile"]
|
|
assert reconcile["environment"] == "release-signing"
|
|
assert publication["permissions"] == {"contents": "write", "actions": "write"}
|
|
# Reconcile after a dispatched run of this repository that did not succeed;
|
|
# a manual dispatch of the reconciler always runs.
|
|
def run_of(**overrides):
|
|
workflow_run = {"conclusion": "failure", "event": "workflow_dispatch",
|
|
"head_repository": {"full_name": "o/r"}, **overrides}
|
|
return {"event_name": "workflow_run", "repository": "o/r", "event": {"workflow_run": workflow_run}}
|
|
|
|
assert gate(reconcile["if"], {}, {}, github=run_of())
|
|
assert gate(reconcile["if"], {}, {}, github={"event_name": "workflow_dispatch"})
|
|
for refused in ({"conclusion": "success"}, {"event": "push"}, {"head_repository": {"full_name": "fork/r"}}):
|
|
assert not gate(reconcile["if"], {}, {}, github=run_of(**refused)), refused
|
|
checkout = reconcile["steps"][0]
|
|
assert checkout["with"]["ref"] == "${{ github.event.repository.default_branch }}"
|
|
assert checkout["with"]["persist-credentials"] == "false"
|
|
assert not any(step.get("run", "").startswith("sleep ") for step in reconcile["steps"])
|
|
|
|
|
|
def test_docker_recovery_refuses_to_replace_a_divergent_version_tag(tmp_path):
|
|
publish = workflow("docker.yml")["jobs"]["release-publish-manifest"]
|
|
step = next(item for item in publish["steps"] if item.get("name") == "Create both immutable versioned manifest lists")
|
|
digest_dir = tmp_path / "digests"
|
|
digest_dir.mkdir()
|
|
for variant in ("slim", "desktop"):
|
|
for arch, digest in (("amd64", "a" * 64), ("arm64", "b" * 64)):
|
|
artifact = digest_dir / f"docker-publish-digest-{variant}-{arch}-0.21.5"
|
|
artifact.mkdir()
|
|
(artifact / f"{arch}.digest").write_text(f"sha256:{digest}\n", encoding="utf-8")
|
|
|
|
marker = tmp_path / "create-called"
|
|
bindir = tmp_path / "bin"
|
|
bindir.mkdir()
|
|
docker = bindir / "docker"
|
|
docker.write_text(
|
|
"#!/usr/bin/env python3\n"
|
|
"import json, os, pathlib, sys\n"
|
|
"if 'create' in sys.argv:\n"
|
|
" pathlib.Path(os.environ['CREATE_MARKER']).write_text('called')\n"
|
|
" raise SystemExit(0)\n"
|
|
"print(json.dumps({'manifests': [{'digest': 'sha256:' + 'c' * 64}]}))\n",
|
|
encoding="utf-8",
|
|
)
|
|
docker.chmod(0o755)
|
|
result = subprocess.run(
|
|
["bash", "-e", "-o", "pipefail", "-c",
|
|
step["run"].replace("/tmp/digests", str(digest_dir))], cwd=tmp_path,
|
|
env={**os.environ, "PATH": f"{bindir}:{os.environ['PATH']}",
|
|
"IMAGE_NAME": "owner/repo", "RELEASE_TAG": "0.21.5",
|
|
"CREATE_MARKER": str(marker)},
|
|
capture_output=True, text=True, encoding="utf-8",
|
|
check=False,
|
|
)
|
|
assert result.returncode != 0
|
|
assert "versioned Docker manifest differs" in result.stderr
|
|
assert not marker.exists()
|
|
|
|
|
|
def test_every_run_step_receives_the_variables_it_reads():
|
|
"""A run step reading $VAR it was never given gets an empty string: rc.14-v0.21.7 passed
|
|
every build and gate, then 'complete' died rendering the builds table without
|
|
CLOUDFLARE_R2_PUBLIC_URL or RELEASE_CLAIM_TAG."""
|
|
import re
|
|
|
|
runner = {"GITHUB_REPOSITORY", "GITHUB_OUTPUT", "GITHUB_STEP_SUMMARY", "GITHUB_ENV", "GITHUB_SHA",
|
|
"GITHUB_RUN_ID", "GITHUB_WORKSPACE", "RUNNER_TEMP", "HOME", "PATH"}
|
|
for name, job in workflow("stable-release.yml")["jobs"].items():
|
|
given = set(job.get("env") or {})
|
|
for step in job.get("steps", []):
|
|
used = set(re.findall(r"\$\{?([A-Z][A-Z0-9_]+)", step.get("run", ""))) - runner
|
|
missing = used - given - set(step.get("env") or {})
|
|
assert not missing, f"{name} / {step.get('name') or step['run'][:40]}: {sorted(missing)}"
|
|
|
|
|
|
def test_the_builds_table_render_cannot_block_the_release_and_has_its_r2_inputs():
|
|
"""The table is presentation: it never fails 'Stable release is green', and it gets the
|
|
R2 credentials its listing and page writes need."""
|
|
step = next(step for step in workflow("stable-release.yml")["jobs"]["complete"]["steps"]
|
|
if step.get("name") == "Render the admitted candidate smoke results")
|
|
assert str(step.get("continue-on-error")).lower() == "true" # base YAML loader: a string
|
|
assert {"CLOUDFLARE_R2_ACCOUNT_ID", "CLOUDFLARE_R2_ACCESS_KEY_ID", "CLOUDFLARE_R2_SECRET_ACCESS_KEY",
|
|
"CLOUDFLARE_R2_BUCKET", "CLOUDFLARE_R2_PUBLIC_URL", "RELEASE_CLAIM_TAG"} <= set(step["env"])
|
|
|
|
|
|
@pytest.mark.parametrize("arch", ["arm64"])
|
|
def test_macos_smoke_runs_without_a_receipt_outside_the_candidate_phase(arch):
|
|
"""Only a candidate stages a receipt; a canary's skipped stage-receipt must not skip the smoke,
|
|
or its publish gate (which needs every job to succeed) fails on every canary."""
|
|
smoke = workflow("desktop-bundled-release.yml")["jobs"][f"smoke-darwin-{arch}"]["if"]
|
|
base = {"validate": {"result": "success", "outputs": {"sha": "a" * 40, f"darwin-{arch}": "true"}},
|
|
f"build-darwin-{arch}": {"result": "success"}}
|
|
inputs = {"release-phase": "", "upload_release": True, "skip-tests": False}
|
|
skipped = {**base, f"stage-receipt-darwin-{arch}": {"result": "skipped"}}
|
|
staged = {**base, f"stage-receipt-darwin-{arch}": {"result": "success"}}
|
|
assert gate(smoke, inputs, skipped)
|
|
assert not gate(smoke, {**inputs, "release-phase": "candidate"}, skipped)
|
|
assert gate(smoke, {**inputs, "release-phase": "candidate"}, staged)
|