Files
Mistercoolertyper be6379107f tests: strengthen T17's over-grant check, add T21 modes, cross-file contract in T19
T17's package-remove assertion could not fire: it used a sleeper that had already
exited, so pkcheck returned 127 and the check printed 'info' rather than a
verdict. A negative assertion that cannot fail is worse than none. It now owns a
sleeper (setsid + exec -a, pid confirmed via /proc before pkcheck is trusted),
and 127 or any unexpected code is a FAIL rather than a pass. Verified capable of
failing by injecting package-remove into the rule: pkcheck went rc=2 -> rc=0 and
the assertion went red; the rule was then restored (sha256 unchanged).

T21 asserts both scripts are recorded as 100755 in the index. core.fileMode=false
means a Windows checkout silently drops the executable bit, so a fresh Linux
clone got non-executable files.

T19 now reads update_local_repo.OFFLINE_UPDATE_SCRIPT and asserts the preseed
names the same path. Both files hard-code it, and nothing tied them together, so
a rename would leave auto_update.sh printing 'not installed yet' with everything
else green.

Final: 107 passed, 0 failed, 2 skipped. The skips stay honest (T12 needs gpg;
T13's ks.cfg assertion is vacuous because the file is not in the repo).
2026-11-04 10:38:17 +01:00

1998 lines
79 KiB
Bash
Executable File

#!/usr/bin/env bash
#
# run-tests.sh - Debian port test harness for the VDI-Linux provisioning repo.
#
# Proves the Debian side of the port works and that the Fedora side is
# unregressed. Run as root on a Debian 13 (trixie) machine:
#
# sudo bash debian/test/run-tests.sh
#
# Exit status: 0 if no test FAILED, 1 otherwise. SKIPped tests do not fail the
# run, but every SKIP prints why it skipped and what it would have checked.
#
# The harness is self-cleaning. It never writes to /var/local/citrix-repo,
# never installs a package (apt-get install is only ever --simulate), and
# removes every apt source file and cached index it adds. See README.md.
set -uo pipefail
# ---------------------------------------------------------------------------
# Configuration
# ---------------------------------------------------------------------------
SCRIPT_DIR=$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)
REPO_ROOT=$(cd "$SCRIPT_DIR/../.." && pwd)
# The two real Citrix .deb files live next to the repo, not inside it.
DEB_DIR="${DEB_DIR:-$(dirname "$REPO_ROOT")}"
ICACLIENT_DEB="icaclient_26.08.0.225_amd64.deb"
CTXUSB_DEB="ctxusb_26.08.0.225_amd64.deb"
EXPECTED_VERSION="26.08.0.225"
# The production apt source file the Debian path installs.
PROD_SOURCE_FILE="$REPO_ROOT/local-citrix-repo.list"
PROD_REPO_DIR="/var/local/citrix-repo"
TMP_DIR=$(mktemp -d "${TMPDIR:-/tmp}/vdi-debian-test.XXXXXX")
REPO_DIR="$TMP_DIR/repo"
TAMPER_DIR="$TMP_DIR/tamper"
SANDBOX_DIR="$TMP_DIR/sandbox"
LIST_FILE="/etc/apt/sources.list.d/zz-vdi-test-$$.list"
KEYRING_DIR=/etc/apt/keyrings
# Two concurrent runs share /var/lib/apt/lists and /etc/apt/sources.list.d.
# Measured: with two runs in flight, one run's teardown deleted the other's
# temp repo while apt was reading it, and `apt-get install --simulate` failed
# with "Could not open file /var/lib/apt/lists/_tmp_vdi-debian-test.<other>"
# - a failure that looks like a port bug but is a collision. Serialise instead.
LOCK_FILE="/var/lock/vdi-debian-test.lock"
if ! exec 9>"$LOCK_FILE"; then
printf 'Cannot open lock file %s\n' "$LOCK_FILE"
exit 1
fi
if ! flock -n 9; then
printf 'Another run of this harness is already in progress (lock: %s).\n' "$LOCK_FILE"
printf 'They share apt state; run them one at a time.\n'
exit 1
fi
# Never let Python write __pycache__ into the repo: py_compile would otherwise
# leave an untracked directory behind and dirty the working tree.
export PYTHONPYCACHEPREFIX="$TMP_DIR/pycache"
export PYTHONDONTWRITEBYTECODE=1
PASSED=0
FAILED=0
SKIPPED=0
FAILED_NAMES=""
# /var/local/citrix-repo must not be touched; record its state up front.
PROD_REPO_MTIME_BEFORE=""
if [ -d "$PROD_REPO_DIR" ]; then
PROD_REPO_MTIME_BEFORE=$(stat -c '%Y' "$PROD_REPO_DIR" 2>/dev/null || echo "")
fi
# T15 asserts nothing was installed; record the baseline now.
INSTALLED_BEFORE=""
if command -v dpkg-query >/dev/null 2>&1; then
INSTALLED_BEFORE=$(dpkg-query -W -f='${Package}\n' 2>/dev/null | wc -l)
fi
# ---------------------------------------------------------------------------
# Reporting helpers
# ---------------------------------------------------------------------------
pass() { printf 'PASS %s\n' "$1"; PASSED=$((PASSED + 1)); }
# Keep failure messages readable: a Python traceback inside a FAIL line buries
# the summary. The caller prints the full detail above the FAIL line.
fail() {
local msg="$1"
if [ "${#msg}" -gt 240 ]; then
msg="$(printf '%s' "$msg" | cut -c1-240)... (truncated; see output above)"
fi
printf 'FAIL %s\n' "$msg"
FAILED=$((FAILED + 1))
FAILED_NAMES="$FAILED_NAMES
- $msg"
}
skip() { printf 'SKIP %s\n' "$1"; SKIPPED=$((SKIPPED + 1)); }
info() { printf ' %s\n' "$1"; }
head2() { printf '\n== %s\n' "$1"; }
# apt encodes a source path into a list filename by replacing '/' with '_',
# e.g. file:/root/x/repo -> _root_x_repo_._Packages
list_fragment() { printf '%s' "$1" | sed 's|/|_|g'; }
purge_apt_lists_for() {
local dir="$1" frag
frag=$(list_fragment "$dir")
rm -f /var/lib/apt/lists/*"$frag"* 2>/dev/null
rm -f /var/lib/apt/lists/partial/*"$frag"* 2>/dev/null
return 0
}
# Also clear indexes left by any earlier run of this harness, including ones
# whose temp directory no longer exists. A stale index pointing at a deleted
# repo makes `apt-get install --simulate` fail for a reason unrelated to the
# code under test.
purge_all_harness_lists() {
rm -f /var/lib/apt/lists/*vdi-debian-test* 2>/dev/null
rm -f /var/lib/apt/lists/partial/*vdi-debian-test* 2>/dev/null
return 0
}
# Paths installed by update_local_repo.install_debian_update_policy(). These
# are REAL system paths, so the tests that touch them back up whatever is
# already there and restore it at teardown rather than deleting blindly.
POLKIT_RULE_PATH="/etc/polkit-1/rules.d/60-vdi-no-password-updates.rules"
OFFLINE_SCRIPT="/usr/local/sbin/vdi-offline-update"
OFFLINE_SERVICE="/etc/systemd/system/vdi-offline-update.service"
OFFLINE_TIMER="/etc/systemd/system/vdi-offline-update.timer"
OFFLINE_STAMP="/var/lib/vdi-offline-update.last"
SYSTEM_UPDATE_LINK="/system-update"
BACKUP_DIR="$TMP_DIR/backup"
mkdir -p "$BACKUP_DIR"
# Save the current state of a path so teardown can put it back exactly.
# Records "present" or "absent" in a marker file, so "it did not exist before"
# is distinguishable from "the backup failed".
backup_path() {
local path="$1" name
name=$(printf '%s' "$path" | tr '/' '_')
if [ -L "$path" ]; then
printf 'symlink\n' > "$BACKUP_DIR/$name.state"
readlink "$path" > "$BACKUP_DIR/$name.target"
elif [ -e "$path" ]; then
printf 'present\n' > "$BACKUP_DIR/$name.state"
cp -a "$path" "$BACKUP_DIR/$name" 2>/dev/null
else
printf 'absent\n' > "$BACKUP_DIR/$name.state"
fi
}
restore_path() {
local path="$1" name state
name=$(printf '%s' "$path" | tr '/' '_')
state=$(cat "$BACKUP_DIR/$name.state" 2>/dev/null || echo absent)
case "$state" in
symlink)
# Never rm -rf a symlink target; only unlink the link itself.
[ -L "$path" ] && rm -f "$path"
ln -s "$(cat "$BACKUP_DIR/$name.target")" "$path" 2>/dev/null
;;
present)
cp -a "$BACKUP_DIR/$name" "$path" 2>/dev/null
;;
*)
# It did not exist before this run: remove it, but only if it is a
# regular file or symlink - never recurse into a directory.
if [ -L "$path" ]; then
rm -f "$path"
elif [ -f "$path" ]; then
rm -f "$path"
fi
;;
esac
}
cleanup() {
local status=$?
# T15 already tore everything down and verified it, then printed the
# summary. Running the teardown again here would only risk disturbing it.
if [ "${CLEANED:-0}" = "1" ]; then
exit $status
fi
printf '\n== cleanup\n'
# Undo the machine mutations from T16-T19 first: a polkit rule or a systemd
# unit left behind is more consequential than a temp directory.
for mutating_path in "$POLKIT_RULE_PATH" "$OFFLINE_STAMP" "$SYSTEM_UPDATE_LINK" \
"$OFFLINE_SCRIPT" "$OFFLINE_SERVICE" "$OFFLINE_TIMER"; do
restore_path "$mutating_path" 2>/dev/null
done
command -v systemctl >/dev/null 2>&1 && systemctl daemon-reload >/dev/null 2>&1
pkill -f 'vdi-test-sleeper' >/dev/null 2>&1
rm -f "$LIST_FILE" 2>/dev/null
# Remove any keyring this run installed, by its unique name.
rm -f "$KEYRING_DIR"/zz-vdi-test-* 2>/dev/null
rmdir "$KEYRING_DIR" 2>/dev/null
purge_apt_lists_for "$REPO_DIR"
purge_apt_lists_for "$TAMPER_DIR"
purge_apt_lists_for "$SANDBOX_DIR"
# Refresh so apt forgets the source we just removed.
apt-get update -qq >/dev/null 2>&1
rm -rf "$TMP_DIR" 2>/dev/null
printf 'removed %s, %s and cached indexes\n' "$TMP_DIR" "$LIST_FILE"
exit $status
}
trap cleanup EXIT INT TERM
CLEANED=0
# ---------------------------------------------------------------------------
# T00: environment sanity
# ---------------------------------------------------------------------------
head2 "T00 environment"
if [ "$(id -u)" -ne 0 ]; then
printf 'This harness must run as root (it adds and removes an apt source).\n'
exit 1
fi
for tool in apt-ftparchive apt-get apt-cache dpkg-deb python3 gzip; do
if ! command -v "$tool" >/dev/null 2>&1; then
printf 'Missing required tool: %s\n' "$tool"
exit 1
fi
done
# Clear indexes from any earlier run before doing anything else.
#
# A run that was killed (SIGKILL, a cancelled turn, a closed terminal) never
# reaches its EXIT trap, so its /etc/apt/sources.list.d/zz-vdi-test-<pid>.list
# survives pointing at a temp directory that no longer exists. Every later
# `apt-get update` then fails with "Failed to fetch ... File not found" and
# T06/T07 blame the port for the wreckage - measured: exactly that happened
# with a leftover zz-vdi-test-250.list from another run.
#
# This is safe to sweep because flock above guarantees no other run is alive,
# so any zz-vdi-test-* source file at this point is residue, not a peer.
for stale_list in /etc/apt/sources.list.d/zz-vdi-test-*.list; do
[ -e "$stale_list" ] || continue
stale_dir=$(sed -n 's|.*file:\([^ ]*\).*|\1|p' "$stale_list" 2>/dev/null)
if [ -z "$stale_dir" ] || [ ! -d "$stale_dir" ]; then
rm -f "$stale_list"
printf ' removed stale apt source from a killed run: %s\n' \
"$(basename "$stale_list")"
fi
done
purge_all_harness_lists
CODENAME=""
if [ -r /etc/os-release ]; then
# shellcheck disable=SC1091
. /etc/os-release
CODENAME="${VERSION_CODENAME:-}"
fi
info "distribution: ${PRETTY_NAME:-unknown} (codename=${CODENAME:-unknown})"
if [ "$CODENAME" != "trixie" ]; then
info "WARNING: expected trixie; package dependency resolution is only proven there"
fi
if [ ! -f "$DEB_DIR/$ICACLIENT_DEB" ] || [ ! -f "$DEB_DIR/$CTXUSB_DEB" ]; then
printf 'Missing fixture .deb files in %s\n' "$DEB_DIR"
printf 'Expected:\n %s\n %s\n' "$ICACLIENT_DEB" "$CTXUSB_DEB"
printf 'Override the directory with DEB_DIR=/path/to/debs\n'
exit 1
fi
info "fixtures: $DEB_DIR"
# ---------------------------------------------------------------------------
# T01: the .deb fixtures are what we think they are
# ---------------------------------------------------------------------------
# Without this, every later version assertion could be checking a stale file.
head2 "T01 fixture .deb identity"
for pkg in "$ICACLIENT_DEB" "$CTXUSB_DEB"; do
got=$(dpkg-deb -f "$DEB_DIR/$pkg" Version 2>/dev/null)
name=$(dpkg-deb -f "$DEB_DIR/$pkg" Package 2>/dev/null)
if [ "$got" = "$EXPECTED_VERSION" ]; then
pass "T01 $pkg declares Version $got (package $name)"
else
fail "T01 $pkg declares Version '$got', expected $EXPECTED_VERSION"
fi
done
# ---------------------------------------------------------------------------
# T02: Python syntax and import safety on Debian
# ---------------------------------------------------------------------------
head2 "T02 python3 -m py_compile"
for py in update_local_repo.py configure_kde.py; do
if [ ! -f "$REPO_ROOT/$py" ]; then
fail "T02 $py is missing from the repo"
continue
fi
if out=$(cd "$TMP_DIR" && python3 -m py_compile "$REPO_ROOT/$py" 2>&1); then
pass "T02 $py compiles"
else
fail "T02 $py failed to compile: $out"
fi
done
if [ -d "$REPO_ROOT/__pycache__" ]; then
fail "T02 py_compile left __pycache__ inside the repo (working tree dirtied)"
else
pass "T02 no __pycache__ written into the repo"
fi
head2 "T03 import safety (module import must not explode or act)"
# Importing must be side-effect free: run from a scratch cwd so a relative path
# in module-level code cannot accidentally work, and compare state afterwards.
import_probe() {
local module="$1"
cd "$TMP_DIR" || return 1
python3 - "$REPO_ROOT" "$module" <<'PYEOF' 2>&1
import sys, os
repo, module = sys.argv[1], sys.argv[2]
sys.path.insert(0, repo)
os.chdir(os.environ["PYTHONPYCACHEPREFIX"])
try:
__import__(module)
except Exception as exc:
print("IMPORT-FAILED: %s: %s" % (type(exc).__name__, exc))
raise SystemExit(1)
print("IMPORT-OK")
PYEOF
}
for module in configure_kde update_local_repo; do
if out=$(import_probe "$module"); then
if printf '%s' "$out" | grep -q 'IMPORT-OK'; then
pass "T03 import $module succeeds on Debian"
else
fail "T03 import $module produced no confirmation: $out"
fi
else
fail "T03 import $module raised: $(printf '%s' "$out" | tr '\n' ' ')"
fi
done
# The tqdm fallback: a stock trixie has no tqdm and no pip. The import above
# already covers the absent case. This asserts the fallback is a *working*
# no-op, not merely an importable name.
head2 "T04 tqdm fallback is functional, not just importable"
if out=$(cd "$TMP_DIR" && python3 - "$REPO_ROOT" <<'PYEOF' 2>&1
import sys, os, importlib.util
repo = sys.argv[1]
sys.path.insert(0, repo)
os.chdir(os.environ["PYTHONPYCACHEPREFIX"])
real_tqdm = importlib.util.find_spec("tqdm") is not None
print("real tqdm installed:", real_tqdm)
import update_local_repo as u
bar = u.tqdm(total=10, unit="B", desc="probe", mininterval=0.1)
bar.update(5)
bar.update(5)
bar.close()
print("tqdm object constructed, updated and closed OK")
print("is fallback class:", getattr(u.tqdm, "__module__", "") == "update_local_repo")
PYEOF
); then
pass "T04 tqdm object usable with tqdm absent (fallback exercised)"
info "$(printf '%s' "$out" | tr '\n' ' ')"
else
fail "T04 tqdm fallback is broken: $(printf '%s' "$out" | tr '\n' ' ')"
fi
# ---------------------------------------------------------------------------
# T05: the flat apt repository builds from the real .deb files
# ---------------------------------------------------------------------------
head2 "T05 flat repo build (apt-ftparchive)"
mkdir -p "$REPO_DIR"
chmod 755 "$REPO_DIR" "$TMP_DIR"
cp "$DEB_DIR/$ICACLIENT_DEB" "$DEB_DIR/$CTXUSB_DEB" "$REPO_DIR"/ || fail "T05 could not copy fixtures"
build_repo() {
local dir="$1"
(
cd "$dir" || exit 1
apt-ftparchive packages . > Packages || exit 1
gzip -c Packages > Packages.gz || exit 1
apt-ftparchive release . > Release || exit 1
)
local rc=$?
chmod 644 "$dir"/Packages "$dir"/Packages.gz "$dir"/Release 2>/dev/null
return $rc
}
if build_repo "$REPO_DIR"; then
pass "T05 repo build command sequence succeeded"
else
fail "T05 repo build command sequence failed"
fi
stanzas=$(grep -c '^Package:' "$REPO_DIR/Packages" 2>/dev/null || echo 0)
if [ "$stanzas" = "2" ]; then
pass "T05 Packages contains exactly 2 stanzas"
else
fail "T05 Packages contains $stanzas stanzas, expected 2"
info "stanzas: $(grep '^Package:' "$REPO_DIR/Packages" 2>/dev/null | tr '\n' ' ')"
fi
for pkg in icaclient ctxusb; do
got=$(awk -v p="$pkg" '
/^Package:/ { in_pkg = ($2 == p) }
in_pkg && /^Version:/ { print $2; exit }
' "$REPO_DIR/Packages")
if [ "$got" = "$EXPECTED_VERSION" ]; then
pass "T05 Packages declares $pkg $got"
else
fail "T05 Packages declares $pkg '${got:-nothing}', expected $EXPECTED_VERSION"
fi
done
for f in Packages Packages.gz Release; do
if [ -s "$REPO_DIR/$f" ]; then
pass "T05 $f is present and non-empty"
else
fail "T05 $f is missing or empty"
fi
done
# ---------------------------------------------------------------------------
# T06/T07: apt can see and resolve the package from that repo
# ---------------------------------------------------------------------------
head2 "T06 sources.list entry and apt-get update"
# The exact production form: flat repo, suite "./", trusted=yes.
printf 'deb [trusted=yes] file:%s ./\n' "$REPO_DIR" > "$LIST_FILE"
info "source: $(cat "$LIST_FILE")"
purge_apt_lists_for "$REPO_DIR"
update_out=$(apt-get update 2>&1)
update_rc=$?
# The spec'd check: exit 0 and no E: lines.
if [ "$update_rc" -eq 0 ]; then
pass "T06 apt-get update exits 0"
else
fail "T06 apt-get update exits $update_rc"
fi
e_count=$(printf '%s\n' "$update_out" | grep -c '^E:' || true)
if [ "$e_count" -eq 0 ]; then
pass "T06 apt-get update emitted no E: lines"
else
fail "T06 apt-get update emitted $e_count E: line(s)"
printf '%s\n' "$update_out" | grep '^E:' | sed 's/^/ /'
fi
# The strong check. Measured on trixie: a repo whose Packages is unreadable
# still yields exit 0 and no E: lines, but does emit "Err:" - so the weak form
# above can pass on a broken repo. These lines are what actually catch it.
err_count=$(printf '%s\n' "$update_out" | grep -c '^Err:' || true)
if [ "$err_count" -eq 0 ]; then
pass "T06 apt-get update emitted no Err: lines (stronger than the spec)"
else
fail "T06 apt-get update emitted $err_count Err: line(s) - the source is not readable"
printf '%s\n' "$update_out" | grep '^Err:' | sed 's/^/ /'
fi
src_warn=$(printf '%s\n' "$update_out" | grep '^W:' | grep -F "$REPO_DIR" | grep -vc 'is not signed' || true)
if [ "$src_warn" -eq 0 ]; then
pass "T06 no unexpected W: lines for this source"
else
fail "T06 apt-get update warned $src_warn time(s) about this source"
printf '%s\n' "$update_out" | grep '^W:' | grep -F "$REPO_DIR" | sed 's/^/ /'
fi
head2 "T07 apt can see the package (after purging the index cache)"
# Purging matters: with a stale cached index a WRONG source still looks good.
policy=$(apt-cache policy icaclient 2>&1)
cand=$(printf '%s\n' "$policy" | awk '/Candidate:/ { print $2; exit }')
if [ "$cand" = "$EXPECTED_VERSION" ]; then
pass "T07 apt-cache policy icaclient -> Candidate $cand"
else
fail "T07 apt-cache policy icaclient -> Candidate '${cand:-none}', expected $EXPECTED_VERSION"
printf '%s\n' "$policy" | sed 's/^/ /'
fi
if printf '%s\n' "$policy" | grep -qF "file:$REPO_DIR"; then
pass "T07 the version comes from this local repo, not somewhere else"
else
fail "T07 apt-cache policy does not attribute icaclient to $REPO_DIR"
fi
show_version=$(apt-cache show icaclient 2>/dev/null | awk '/^Version:/ { print $2; exit }')
if [ "$show_version" = "$EXPECTED_VERSION" ]; then
pass "T07 apt-cache show icaclient -> Version $show_version"
else
fail "T07 apt-cache show icaclient -> Version '${show_version:-none}', expected $EXPECTED_VERSION"
fi
if apt-get install --simulate -y icaclient >"$TMP_DIR/simulate.log" 2>&1; then
pass "T07 apt-get install --simulate -y icaclient resolves (no missing deps)"
else
# Distinguish "the repo is broken" from "something else touched apt".
# A stale or vanished index for ANOTHER harness run produces a path we
# never created, and blaming the port for that would be wrong.
if grep -q 'vdi-debian-test' "$TMP_DIR/simulate.log" \
&& ! grep -qF "$(list_fragment "$REPO_DIR")" "$TMP_DIR/simulate.log"; then
fail "T07 simulation failed because another harness run's index vanished (concurrency, not the port)"
else
fail "T07 apt-get install --simulate -y icaclient did not resolve"
fi
tail -15 "$TMP_DIR/simulate.log" | sed 's/^/ /'
fi
if grep -q '^Inst icaclient' "$TMP_DIR/simulate.log"; then
pass "T07 the simulated install actually selects icaclient"
else
fail "T07 simulation did not select icaclient (it may be already installed)"
fi
# ---------------------------------------------------------------------------
# T08: idempotency
# ---------------------------------------------------------------------------
head2 "T08 rebuild is idempotent"
cp "$REPO_DIR/Packages" "$TMP_DIR/Packages.first"
build_repo "$REPO_DIR" >/dev/null 2>&1
stanzas2=$(grep -c '^Package:' "$REPO_DIR/Packages" 2>/dev/null || echo 0)
if cmp -s "$TMP_DIR/Packages.first" "$REPO_DIR/Packages"; then
pass "T08 Packages is byte-identical after a second build"
else
fail "T08 Packages changed on rebuild"
fi
if [ "$stanzas2" = "2" ]; then
pass "T08 still exactly 2 stanzas after rebuild (no duplicates)"
else
fail "T08 rebuild produced $stanzas2 stanzas, expected 2"
grep '^Package:' "$REPO_DIR/Packages" | sed 's/^/ /'
fi
# A duplicate stanza is what a naive "copy new, leave old" implementation
# produces. Assert the count is exact, not merely non-zero.
dup=$(grep '^Package:' "$REPO_DIR/Packages" 2>/dev/null | sort | uniq -d)
if [ -z "$dup" ]; then
pass "T08 no duplicated Package stanzas"
else
fail "T08 duplicated stanzas: $dup"
fi
# ---------------------------------------------------------------------------
# T09: stale package pruning in sync_debian
# ---------------------------------------------------------------------------
# Debian .deb filenames embed the version, so copying without deleting would
# leave every previous version in the repo and apt would always prefer the
# highest - making a rollback impossible. This reproduces that scenario.
head2 "T09 stale .deb is pruned by sync_debian"
mkdir -p "$SANDBOX_DIR/repo" "$SANDBOX_DIR/staging" "$SANDBOX_DIR/src"
cp "$DEB_DIR/$ICACLIENT_DEB" "$DEB_DIR/$CTXUSB_DEB" "$SANDBOX_DIR/src"/
# Pretend an older ctxusb is already published.
cp "$DEB_DIR/$CTXUSB_DEB" "$SANDBOX_DIR/repo/ctxusb_26.07.0.100_amd64.deb"
if out=$(python3 - "$REPO_ROOT" "$SANDBOX_DIR" <<'PYEOF' 2>&1
import sys, os, shutil, re, subprocess
repo_root, work = sys.argv[1], sys.argv[2]
sys.path.insert(0, repo_root)
os.chdir(os.environ["PYTHONPYCACHEPREFIX"])
import update_local_repo as u
repo_dir = os.path.join(work, "repo")
stage = os.path.join(work, "staging")
src = os.path.join(work, "src")
# Redirect all module-level paths into the sandbox.
u.LOCAL_REPO_DIR = repo_dir
u.STAGING_DIR = stage
u.DEBIAN_FALLBACK_DIR = src
u.save_last_release = lambda rd: None
# Never write to /etc and never run apt-get from inside a test.
real_copyfile = shutil.copyfile
def guarded_copyfile(s, d, *a, **k):
if str(d).startswith("/etc/"):
d = os.path.join(work, "etc-redirect", os.path.basename(str(d)))
os.makedirs(os.path.dirname(d), exist_ok=True)
return real_copyfile(s, d, *a, **k)
u.shutil.copyfile = guarded_copyfile
real_run = subprocess.run
calls = []
def guarded_run(args, *a, **k):
if isinstance(args, (list, tuple)) and args and args[0] == "apt-get":
calls.append(list(args))
return subprocess.CompletedProcess(args, 0, b"", b"")
return real_run(args, *a, **k)
u.subprocess.run = guarded_run
before = sorted(f for f in os.listdir(repo_dir) if f.endswith(".deb"))
release = {"tag_name": "v26.08", "published_at": "2026-01-01T00:00:00Z", "assets": {}}
u.sync_debian(True, release)
after = sorted(f for f in os.listdir(repo_dir) if f.endswith(".deb"))
pk = open(os.path.join(repo_dir, "Packages")).read()
print("BEFORE:", before)
print("AFTER:", after)
print("APT-GET-CALLS:", calls)
print("STANZAS:", len(re.findall(r"^Package: ", pk, re.M)))
for m in re.finditer(r"^Package: (\S+)$\n(?:.*\n)*?^Version: (\S+)$", pk, re.M):
print("VERSION: %s=%s" % (m.group(1), m.group(2)))
PYEOF
); then
printf '%s\n' "$out" | sed 's/^/ /'
# Check the AFTER line specifically. Grepping the whole output would match
# the BEFORE line, which deliberately contains the stale filename - the
# test would then fail on its own evidence and could never pass.
after_line=$(printf '%s\n' "$out" | grep '^AFTER:' || true)
if printf '%s' "$after_line" | grep -q 'ctxusb_26\.07\.0\.100'; then
fail "T09 the stale ctxusb_26.07.0.100 was not removed from the repo dir"
else
pass "T09 stale ctxusb_26.07.0.100 was pruned"
fi
# Stronger than a file count: a prune that deleted everything would also
# give "2 stanzas" if the index were rebuilt from nothing. Assert both
# current packages are actually present after the sync.
for expected_deb in "$ICACLIENT_DEB" "$CTXUSB_DEB"; do
if printf '%s' "$after_line" | grep -qF "$expected_deb"; then
pass "T09 $expected_deb present after sync"
else
fail "T09 $expected_deb missing after sync (prune removed too much)"
fi
done
if printf '%s\n' "$out" | grep -q 'STANZAS: 2'; then
pass "T09 Packages holds exactly 2 stanzas after sync"
else
fail "T09 Packages does not hold exactly 2 stanzas after sync"
fi
if printf '%s\n' "$out" | grep -q "VERSION: ctxusb=$EXPECTED_VERSION"; then
pass "T09 ctxusb resolves to $EXPECTED_VERSION"
else
fail "T09 ctxusb does not resolve to $EXPECTED_VERSION"
fi
else
fail "T09 sandboxed sync_debian raised: $(printf '%s' "$out" | tr '\n' ' ')"
fi
if [ -e "$SANDBOX_DIR/etc-redirect/local-citrix-repo.list" ]; then
pass "T09 sync_debian writes the apt source file (redirected to the sandbox)"
else
fail "T09 sync_debian did not write the apt source file"
fi
# ---------------------------------------------------------------------------
# T10: trusted=yes still verifies the index (negative control)
# ---------------------------------------------------------------------------
# This is the control for T06/T07: it proves apt would actually fail on a
# corrupt repo, so a PASS above is meaningful rather than vacuous.
head2 "T10 corrupt index is rejected even with trusted=yes"
mkdir -p "$TAMPER_DIR"
cp "$REPO_DIR"/*.deb "$TAMPER_DIR"/
build_repo "$TAMPER_DIR" >/dev/null 2>&1
printf 'deb [trusted=yes] file:%s ./\n' "$TAMPER_DIR" > "$LIST_FILE"
purge_apt_lists_for "$TAMPER_DIR"
apt-get update -qq >/dev/null 2>&1
# Baseline: the package is visible from the untampered repo.
base=$(apt-cache policy icaclient 2>/dev/null | grep -c "$EXPECTED_VERSION" || true)
if [ "$base" -ge 1 ]; then
pass "T10 baseline: icaclient visible before tampering"
else
fail "T10 baseline: icaclient not visible even before tampering"
fi
# Now corrupt Packages after Release recorded its hash.
printf '\nPackage: evilpkg\nVersion: 6.6.6\nArchitecture: amd64\nFilename: ./evilpkg.deb\nSize: 1\n' \
>> "$TAMPER_DIR/Packages"
purge_apt_lists_for "$TAMPER_DIR"
tamper_out=$(apt-get update 2>&1)
tamper_rc=$?
if [ "$tamper_rc" -ne 0 ]; then
pass "T10 apt-get update FAILS on a hash mismatch (exit $tamper_rc)"
else
fail "T10 apt-get update accepted a corrupted Packages file (exit 0)"
fi
if printf '%s\n' "$tamper_out" | grep -qi 'hash sum mismatch'; then
pass "T10 failure is reported as a Hash Sum mismatch"
else
fail "T10 no Hash Sum mismatch reported"
printf '%s\n' "$tamper_out" | grep -E '^(E:|W:|Err:)' | head -5 | sed 's/^/ /'
fi
if [ "$(apt-cache policy evilpkg 2>/dev/null | grep -c '6.6.6' || true)" -eq 0 ]; then
pass "T10 the injected package is not available to apt"
else
fail "T10 the injected package became available - the index was trusted blindly"
fi
# Restore the good source for the remaining tests.
printf 'deb [trusted=yes] file:%s ./\n' "$REPO_DIR" > "$LIST_FILE"
purge_apt_lists_for "$REPO_DIR"
apt-get update -qq >/dev/null 2>&1
# ---------------------------------------------------------------------------
# T11: the production source file matches what the harness verified
# ---------------------------------------------------------------------------
head2 "T11 production sources.list shape"
if [ -f "$PROD_SOURCE_FILE" ]; then
active=$(grep -E '^[^#]*deb ' "$PROD_SOURCE_FILE" | head -1)
if printf '%s' "$active" | grep -q 'trusted=yes'; then
pass "T11 production source uses trusted=yes"
else
fail "T11 production source does not use trusted=yes: $active"
fi
if printf '%s' "$active" | grep -q 'file:/var/local/citrix-repo \./$'; then
pass "T11 production source is the flat form (file:/var/local/citrix-repo ./)"
else
fail "T11 production source is not the flat form: $active"
fi
# The harness proved the same shape works, only with a different path.
if printf '%s' "$active" | sed 's|/var/local/citrix-repo|REPO|' \
| grep -qx 'deb \[trusted=yes\] file:REPO ./'; then
pass "T11 production source has the same shape the harness verified"
else
fail "T11 production source shape differs from what the harness tested"
fi
else
skip "T11 production source file $PROD_SOURCE_FILE does not exist (owned by another change)"
fi
# ---------------------------------------------------------------------------
# T12: GPG signing path
# ---------------------------------------------------------------------------
# Production deliberately does not sign (trusted=yes). This test exists to
# check the decision, not to gate the port. It needs a signing tool; a stock
# trixie ships only the sqv verifier, so without gpg or sq this SKIPs loudly.
head2 "T12 GPG signed-by path (design check)"
SIGNER=""
if command -v gpg >/dev/null 2>&1; then
SIGNER="gpg"
fi
if [ -z "$SIGNER" ]; then
skip "T12 no gpg on this machine - signing untested here"
if command -v sq >/dev/null 2>&1; then
info "sq is present but this test is written against gpg; not attempted"
fi
info "would have checked: throwaway key -> Release.gpg -> apt with signed-by= ->"
info "positive case succeeds, wrong-key case fails, and whether either is"
info "more fragile than trusted=yes. Measured out-of-band; see README.md."
else
GNUPGHOME_T="$TMP_DIR/gnupg"
mkdir -p "$GNUPGHOME_T"; chmod 700 "$GNUPGHOME_T"
cat > "$TMP_DIR/keyparams" <<'KEYEOF'
%echo generating test key
Key-Type: RSA
Key-Length: 2048
Name-Real: VDI Test Key
Name-Email: vdi-test@example.invalid
Expire-Date: 1
%no-protection
%commit
KEYEOF
if gpg --batch --homedir "$GNUPGHOME_T" --gen-key "$TMP_DIR/keyparams" >/dev/null 2>&1; then
gpg --batch --homedir "$GNUPGHOME_T" --armor --export > "$TMP_DIR/signer.asc" 2>/dev/null
gpg --batch --homedir "$GNUPGHOME_T" --armor --detach-sign \
--output "$REPO_DIR/Release.gpg" "$REPO_DIR/Release" >/dev/null 2>&1
mkdir -p "$KEYRING_DIR"
cp "$TMP_DIR/signer.asc" "$KEYRING_DIR/zz-vdi-test-signer.asc"
chmod 644 "$KEYRING_DIR/zz-vdi-test-signer.asc"
printf 'deb [signed-by=%s/zz-vdi-test-signer.asc] file:%s ./\n' \
"$KEYRING_DIR" "$REPO_DIR" > "$LIST_FILE"
purge_apt_lists_for "$REPO_DIR"
if apt-get update >/dev/null 2>&1; then
pass "T12 signed-by with the correct key verifies"
else
fail "T12 signed-by with the correct key failed"
fi
# Control: sign with a key apt does not trust.
rm -f "$KEYRING_DIR/zz-vdi-test-signer.asc"
printf 'deb [signed-by=%s/zz-vdi-test-absent.asc] file:%s ./\n' \
"$KEYRING_DIR" "$REPO_DIR" > "$LIST_FILE"
purge_apt_lists_for "$REPO_DIR"
if apt-get update >/dev/null 2>&1; then
fail "T12 apt accepted the repo without the signing key (signing is ineffective)"
else
pass "T12 apt rejects the repo when the signing key is absent"
fi
printf 'deb [trusted=yes] file:%s ./\n' "$REPO_DIR" > "$LIST_FILE"
purge_apt_lists_for "$REPO_DIR"
apt-get update -qq >/dev/null 2>&1
else
skip "T12 throwaway key generation failed (gpg entropy/timeout); signing untested here"
fi
fi
# ---------------------------------------------------------------------------
# T13: Fedora regression
# ---------------------------------------------------------------------------
head2 "T13 Fedora path unregressed"
if ! command -v git >/dev/null 2>&1; then
skip "T13 git is not installed - cannot compare against main"
info "would have checked: ks.cfg absent from main (vacuous), tracked Fedora"
info "files identical to main modulo line endings, parent ks.cfg hash."
info "Install git, or run the checks from a machine that has it."
else
GIT="git -C $REPO_ROOT -c safe.directory=*"
# The spec'd check. Reported honestly: ks.cfg is not in the repo at all, so
# this diff exits 0 without comparing anything.
ks_diff=$($GIT diff main -- ks.cfg 2>&1)
ks_rc=$?
if [ "$ks_rc" -eq 0 ] && [ -z "$ks_diff" ]; then
if $GIT cat-file -e main:ks.cfg >/dev/null 2>&1; then
pass "T13 git diff main -- ks.cfg is empty and the path exists (real check)"
else
skip "T13 'git diff main -- ks.cfg' is empty but VACUOUS: ks.cfg is not in main"
info "the spec'd assertion cannot fail; ks.cfg lives outside the repo"
fi
else
fail "T13 git diff main -- ks.cfg is not empty (ks.cfg changed or appeared)"
printf '%s\n' "$ks_diff" | head -10 | sed 's/^/ /'
fi
# The meaningful check: the tracked Fedora-side files must be unchanged.
# Compared modulo CRLF, because this repo is checked out on Windows and the
# blobs in git are LF - a raw diff reports every line as changed.
for f in configure_kde.py local-citrix-repo.repo RPM-GPG-KEY-citrix-local; do
if $GIT show "main:$f" > "$TMP_DIR/main_blob" 2>/dev/null; then
if tr -d '\r' < "$REPO_ROOT/$f" | cmp -s - "$TMP_DIR/main_blob"; then
pass "T13 $f is identical to main (ignoring line endings)"
else
fail "T13 $f differs from main beyond line endings"
fi
else
fail "T13 could not read main:$f"
fi
done
# update_local_repo.py is expected to differ: the Debian path lives inside
# it behind a family dispatch. Assert the Fedora behaviour instead of the
# file bytes - the .rpm asset names and the exact command sequence.
if out=$(python3 - "$REPO_ROOT" <<'PYEOF' 2>&1
import ast, subprocess, sys, os
repo = sys.argv[1]
def load(text):
return ast.parse(text)
main_src = subprocess.run(["git", "-C", repo, "show", "main:update_local_repo.py"],
capture_output=True, text=True)
if main_src.returncode != 0:
print("CANNOT-READ-MAIN")
raise SystemExit(1)
new_src = open(os.path.join(repo, "update_local_repo.py")).read()
main = load(main_src.stdout)
new = load(new_src)
def system_cmds(tree, scope=None):
"""Return the os.system() command strings, in source order.
Both plain strings and f-strings are collected. The Debian port rewrote
"createrepo_c /var/local/citrix-repo" as f"createrepo_c {LOCAL_REPO_DIR}",
and an extractor that only accepted ast.Constant would silently drop those
commands and then report the resulting short list as a regression. That is
a false negative, not evidence.
"""
body = tree.body
if scope:
body = []
for n in tree.body:
if isinstance(n, ast.FunctionDef) and n.name == scope:
body = n.body
out = []
for node in ast.walk(ast.Module(body=body, type_ignores=[])):
if not isinstance(node, ast.Call):
continue
f = node.func
if not (isinstance(f, ast.Attribute) and f.attr == "system"):
continue
if not node.args:
continue
arg = node.args[0]
if isinstance(arg, ast.Constant) and isinstance(arg.value, str):
out.append(arg.value)
elif isinstance(arg, ast.JoinedStr):
parts = []
for v in arg.values:
if isinstance(v, ast.Constant):
parts.append(str(v.value))
elif isinstance(v, ast.FormattedValue):
inner = v.value
if isinstance(inner, ast.Name):
parts.append("{VAR:%s}" % inner.id)
else:
parts.append("{EXPR}")
out.append("".join(parts))
return out
main_cmds = system_cmds(main)
new_cmds = system_cmds(new, "sync_fedora")
# Normalise BOTH sides: main hard-codes the path, the branch uses a constant.
def norm(cmd):
return (cmd.replace("/var/local/citrix-repo", "<REPO>")
.replace("{VAR:LOCAL_REPO_DIR}", "<REPO>"))
normed_main = [norm(c) for c in main_cmds]
normed_new = [norm(c) for c in new_cmds]
print("MAIN-CMDS:", normed_main)
print("FEDORA-CMDS:", normed_new)
print("SAME-SEQUENCE:", normed_new == normed_main)
if normed_new != normed_main:
print("MISSING-FROM-FEDORA:", [c for c in normed_main if c not in normed_new])
print("EXTRA-IN-FEDORA:", [c for c in normed_new if c not in normed_main])
# The Fedora asset names must still be matched exactly.
names = set()
for node in ast.walk(new):
if isinstance(node, ast.Constant) and isinstance(node.value, str):
if node.value.endswith(".rpm"):
names.add(node.value)
required = {"ctxusb.rpm", "ICAClient.rpm"}
print("RPM-NAMES-PRESENT:", required.issubset(names))
PYEOF
); then
printf '%s\n' "$out" | sed 's/^/ /'
if printf '%s\n' "$out" | grep -q 'SAME-SEQUENCE: True'; then
pass "T13 sync_fedora issues the same commands in the same order as main"
else
fail "T13 sync_fedora command sequence differs from main"
fi
if printf '%s\n' "$out" | grep -q 'RPM-NAMES-PRESENT: True'; then
pass "T13 Fedora .rpm asset names still matched exactly"
else
fail "T13 Fedora .rpm asset names changed"
fi
else
fail "T13 could not compare the Fedora code path: $(printf '%s' "$out" | tr '\n' ' ')"
fi
# ks.cfg lives outside the repo; assert the file the user actually has.
OUTER_KS="$(dirname "$REPO_ROOT")/ks.cfg"
if [ -f "$OUTER_KS" ]; then
if $GIT cat-file -e main:ks.cfg >/dev/null 2>&1; then
if $GIT show main:ks.cfg | tr -d '\r' | cmp -s - <(tr -d '\r' < "$OUTER_KS"); then
pass "T13 out-of-tree ks.cfg matches main:ks.cfg"
else
fail "T13 out-of-tree ks.cfg differs from main:ks.cfg"
fi
else
info "T13 out-of-tree ks.cfg sha256: $(sha256sum "$OUTER_KS" | cut -d' ' -f1)"
info "no main:ks.cfg to compare against; the file was never committed"
fi
else
skip "T13 no ks.cfg found at $OUTER_KS"
fi
# Record what the branch actually changes, so a future reader can see the
# scope rather than trusting a summary.
info "files changed vs main (ignoring line endings):"
$GIT diff --ignore-cr-at-eol main --stat 2>/dev/null | sed 's/^/ /'
fi
# ---------------------------------------------------------------------------
# T14: shell lint
# ---------------------------------------------------------------------------
head2 "T14 bash -n on shell scripts added by the port"
found_any=0
while IFS= read -r script; do
# This harness lints itself below; do not lint it twice.
[ "$script" = "$SCRIPT_DIR/run-tests.sh" ] && continue
found_any=1
if bash -n "$script" 2>"$TMP_DIR/basherr"; then
pass "T14 bash -n $(printf '%s' "$script" | sed "s|$REPO_ROOT/||")"
else
fail "T14 bash -n failed for $script: $(cat "$TMP_DIR/basherr" | tr '\n' ' ')"
fi
done < <(find "$REPO_ROOT" -name '*.sh' -type f 2>/dev/null | grep -v '/\.git/' | sort)
if [ "$found_any" -eq 0 ]; then
skip "T14 the port adds no other shell scripts (only this harness exists)"
info "when the port adds scripts, this test lints them automatically"
fi
# Always lint this harness, so the check is not vacuous while the port has no
# scripts of its own.
if bash -n "$SCRIPT_DIR/run-tests.sh" 2>"$TMP_DIR/basherr"; then
pass "T14 bash -n debian/test/run-tests.sh"
else
fail "T14 bash -n failed for run-tests.sh: $(cat "$TMP_DIR/basherr" | tr '\n' ' ')"
fi
# ---------------------------------------------------------------------------
# T16: polkit rule installed and correct
# ---------------------------------------------------------------------------
# These tests MUTATE the machine: they install a polkit rule and systemd units.
# Everything is backed up first and restored at teardown, and T15 verifies it.
head2 "T16 polkit rule for passwordless updates"
POLKIT_OK=0
if ! command -v pkcheck >/dev/null 2>&1; then
skip "T16 pkcheck not installed (no polkit) - cannot test authorisation"
elif [ ! -d /usr/share/polkit-1 ] && [ ! -d /etc/polkit-1 ]; then
skip "T16 polkit is not installed on this machine"
else
POLKIT_OK=1
backup_path "$POLKIT_RULE_PATH"
# Start from a known-clean slate: if the rule is already installed we still
# want to prove install_debian_update_policy() produces it.
rm -f "$POLKIT_RULE_PATH"
# Drive the real function, not a copy of its text.
if out=$(cd "$REPO_ROOT" && python3 - "$REPO_ROOT" <<'PYEOF' 2>&1
import sys, os
sys.path.insert(0, sys.argv[1])
os.chdir(sys.argv[1])
import update_local_repo as u
u.install_debian_update_policy()
print("CALLED")
PYEOF
); then
if printf '%s' "$out" | grep -q 'CALLED'; then
pass "T16 install_debian_update_policy() ran"
else
fail "T16 install_debian_update_policy() did not complete: $(printf '%s' "$out" | tail -3 | tr '\n' ' ')"
fi
else
fail "T16 install_debian_update_policy() raised: $(printf '%s' "$out" | tail -3 | tr '\n' ' ')"
fi
if [ -f "$POLKIT_RULE_PATH" ]; then
pass "T16 rule file created at $POLKIT_RULE_PATH"
else
fail "T16 rule file was not created"
fi
rule_mode=$(stat -c '%a' "$POLKIT_RULE_PATH" 2>/dev/null || echo missing)
if [ "$rule_mode" = "644" ]; then
pass "T16 rule mode is 644"
else
fail "T16 rule mode is '$rule_mode', expected 644"
fi
for action in system-sources-refresh system-update; do
if grep -q "org.freedesktop.packagekit.$action" "$POLKIT_RULE_PATH" 2>/dev/null; then
pass "T16 rule covers org.freedesktop.packagekit.$action"
else
fail "T16 rule does not mention $action"
fi
done
# The rule must not over-grant. package-remove is the one that matters:
# a user who can remove packages without a password can break the machine.
for action in package-remove package-reinstall package-install-untrusted; do
if grep -q "org.freedesktop.packagekit.$action" "$POLKIT_RULE_PATH" 2>/dev/null; then
fail "T16 rule over-grants: mentions $action"
else
pass "T16 rule does not grant $action"
fi
done
# Structural check: the JS must be balanced. `node` is not installed, so
# this is a counting check, not a parse - it catches truncation and the
# common copy/paste damage, not every syntax error.
if python3 - "$POLKIT_RULE_PATH" <<'PYEOF' 2>&1
import sys
src = open(sys.argv[1], encoding="utf-8").read()
# Strip // comments and string literals so braces inside them do not count.
out, i, n = [], 0, len(src)
while i < n:
if src.startswith("//", i):
while i < n and src[i] != "\n":
i += 1
elif src[i] in "\"'":
q = src[i]; i += 1
while i < n and src[i] != q:
i += 2 if src[i] == "\\" else 1
i += 1
else:
out.append(src[i]); i += 1
code = "".join(out)
pairs = {"}": "{", "]": "[", ")": "("}
stack = []
for ch in code:
if ch in "{[(":
stack.append(ch)
elif ch in pairs:
if not stack or stack.pop() != pairs[ch]:
print("UNBALANCED at %r" % ch); raise SystemExit(1)
print("BALANCED" if not stack else "UNCLOSED: %r" % stack)
raise SystemExit(0 if not stack else 1)
PYEOF
then
pass "T16 rule has balanced braces and parens"
else
fail "T16 rule is structurally unbalanced"
fi
if grep -q 'polkit.addRule' "$POLKIT_RULE_PATH" 2>/dev/null; then
pass "T16 rule registers via polkit.addRule"
else
fail "T16 rule does not call polkit.addRule - it would have no effect"
fi
# REGRESSION GUARD. An earlier version of the rule included
# `subject.local == true`, intending to restrict it to a seat physically in
# front of the machine. It never matches: pkcheck returns 2 with the clause
# and 0 without it, for the same sudo-group user. If it comes back, the
# passwordless update silently stops working while every other assertion in
# this test still passes - which is exactly why it is asserted here.
if grep -q 'subject\.local' "$POLKIT_RULE_PATH" 2>/dev/null; then
fail "T16 rule contains subject.local, which never matches (regression)"
else
pass "T16 rule does not contain the non-matching subject.local clause"
fi
# Idempotency: a second call must not rewrite the file.
first_hash=$(sha256sum "$POLKIT_RULE_PATH" 2>/dev/null | cut -d' ' -f1)
first_mtime=$(stat -c '%Y' "$POLKIT_RULE_PATH" 2>/dev/null)
sleep 1
( cd "$REPO_ROOT" && python3 -c "
import sys; sys.path.insert(0, '$REPO_ROOT'); import update_local_repo as u
u.install_debian_update_policy()" ) >/dev/null 2>&1
second_hash=$(sha256sum "$POLKIT_RULE_PATH" 2>/dev/null | cut -d' ' -f1)
if [ "$first_hash" = "$second_hash" ] && [ -n "$first_hash" ]; then
pass "T16 rule is byte-identical after a second call (idempotent)"
else
fail "T16 rule changed on a second call"
fi
fi
# ---------------------------------------------------------------------------
# T17: a sudo-group user is authorised WITHOUT a password
# ---------------------------------------------------------------------------
# This is the actual requirement. Testing the file's contents proves nothing
# about whether polkit acts on it, so this asks polkit itself, about a real
# process owned by a real sudo-group user. The control (rule removed -> rc=2)
# is what stops the test from passing on a machine where pkcheck is simply
# permissive.
head2 "T17 sudo-group user authorised without a password"
POLKIT_ACTION="org.freedesktop.packagekit.system-sources-refresh"
restart_polkit() {
if command -v systemctl >/dev/null 2>&1; then
systemctl restart polkit >/dev/null 2>&1 || systemctl restart polkitd >/dev/null 2>&1
# polkitd caches rules; give it a moment to re-read them.
sleep 1
fi
}
pkcheck_for_user() {
# Run pkcheck as root against a process owned by $1. Echoes the rc.
local user="$1" pid rc
pkill -u "$user" -f 'vdi-test-sleeper' >/dev/null 2>&1
setsid runuser -u "$user" -- bash -c 'exec -a vdi-test-sleeper sleep 120' >/dev/null 2>&1 &
sleep 1
pid=$(pgrep -u "$user" -f 'vdi-test-sleeper' | head -1)
if [ -z "$pid" ]; then
echo "NOPROC"
return
fi
pkcheck --action-id "$POLKIT_ACTION" --process "$pid" >/dev/null 2>&1
rc=$?
pkill -u "$user" -f 'vdi-test-sleeper' >/dev/null 2>&1
echo "$rc"
}
# Start a detached process owned by $1 and ECHO ITS PID (empty on failure).
# Detached with setsid and all three streams redirected so nothing can block on
# a pipe and the process outlives the read from it. A negative pkcheck assertion
# is worthless without a real pid to read, so this is a separate, explicit step
# rather than a reuse of a pid from earlier in the test.
start_sleeper() {
local user="$1" pid
pkill -u "$user" -f 'vdi-test-sleeper' >/dev/null 2>&1
setsid runuser -u "$user" -- bash -c 'exec -a vdi-test-sleeper sleep 180' \
</dev/null >/dev/null 2>&1 &
sleep 1
pid=$(pgrep -u "$user" -f 'vdi-test-sleeper' | head -1)
printf '%s' "${pid:-}"
}
stop_sleeper() {
[ -n "${1:-}" ] || return 0
kill "$1" >/dev/null 2>&1
[ -n "${2:-}" ] && pkill -u "$2" -f 'vdi-test-sleeper' >/dev/null 2>&1
return 0
}
TEST_USER=""
if [ "$POLKIT_OK" != "1" ]; then
skip "T17 skipped with T16: no polkit on this machine"
elif ! systemctl is-system-running >/dev/null 2>&1 && ! systemctl is-active polkit >/dev/null 2>&1; then
skip "T17 polkit is not running and cannot be started (no systemd?) - authorisation untestable"
else
# Find a real, non-root user in the sudo group. A machine with none cannot
# answer the question the test is asking.
# NOTE: `getent group sudo` is "name:passwd:gid:members" - FOUR fields.
# Reading five would put the member list in the wrong variable and find
# nobody, which looks exactly like "no sudo user exists".
while IFS=: read -r _grp _pw _gid members; do
for member in $(printf '%s' "${members:-}" | tr ',' ' '); do
[ "$member" = "root" ] && continue
if id "$member" >/dev/null 2>&1; then
TEST_USER="$member"
break 2
fi
done
done < <(getent group sudo 2>/dev/null)
if [ -z "$TEST_USER" ]; then
skip "T17 no non-root user in group 'sudo' - cannot test the authorisation"
info "would have checked: pkcheck --process <pid of sudo-group user> -> rc=0"
info "with the rule installed, and rc=2 with the rule removed (control)."
else
info "test user: $TEST_USER (in group sudo)"
# Make sure the rule is installed before the positive case.
if [ ! -f "$POLKIT_RULE_PATH" ]; then
( cd "$REPO_ROOT" && python3 -c "
import sys; sys.path.insert(0, '$REPO_ROOT'); import update_local_repo as u
u.install_debian_update_policy()" ) >/dev/null 2>&1
fi
restart_polkit
with_rule=$(pkcheck_for_user "$TEST_USER")
case "$with_rule" in
0)
pass "T17 $TEST_USER is authorised without a password (pkcheck rc=0)"
;;
NOPROC)
fail "T17 could not start a process as $TEST_USER"
;;
*)
fail "T17 $TEST_USER still requires authentication (pkcheck rc=$with_rule, expected 0)"
;;
esac
# THE CONTROL. Without this the positive case proves nothing: a polkit
# that answers YES to everything would also produce rc=0.
mv "$POLKIT_RULE_PATH" "$TMP_DIR/rule.parked" 2>/dev/null
restart_polkit
without_rule=$(pkcheck_for_user "$TEST_USER")
mv "$TMP_DIR/rule.parked" "$POLKIT_RULE_PATH" 2>/dev/null
restart_polkit
case "$without_rule" in
2)
pass "T17 control: without the rule, authentication IS required (rc=2)"
;;
0)
fail "T17 control failed: authorised even without the rule - the test proves nothing"
;;
NOPROC)
fail "T17 control could not start a process as $TEST_USER"
;;
*)
fail "T17 control returned unexpected rc=$without_rule (expected 2)"
;;
esac
# The action the rule must NOT grant. This needs its OWN live process:
# pkcheck --process wants a pid it can read, and reusing a pid from
# earlier in the test is how a negative assertion silently becomes a
# 127-and-a-shrug. So start one here, prove it exists and is owned by
# the right user, and only then ask polkit.
#
# The assertion means "our rule does not accidentally grant passwordless
# package removal", so a 127 must NEVER become a pass.
deny_pid=$(start_sleeper "$TEST_USER")
if [ -z "$deny_pid" ]; then
fail "T17 could not start a sleeper for the package-remove check"
elif [ "$(stat -c '%U' "/proc/$deny_pid" 2>/dev/null)" != "$TEST_USER" ]; then
fail "T17 sleeper pid $deny_pid is not owned by $TEST_USER - cannot trust pkcheck"
stop_sleeper "$deny_pid" "$TEST_USER"
else
denied=0
pkcheck --action-id org.freedesktop.packagekit.package-remove \
--process "$deny_pid" >/dev/null 2>&1 || denied=$?
stop_sleeper "$deny_pid" "$TEST_USER"
case "$denied" in
0)
fail "T17 package-remove is authorised without a password - the rule over-grants"
;;
2)
pass "T17 package-remove still requires authentication (rc=2, not over-granted)"
;;
3)
pass "T17 package-remove is not authorised for this subject (rc=3)"
;;
*)
# 127, 1, anything else: the check did not actually run.
# Saying PASS here is the vacuous-test failure mode.
fail "T17 package-remove check did not run (pkcheck rc=$denied); not evidence either way"
;;
esac
fi
fi
fi
# ---------------------------------------------------------------------------
# T18: offline-update script and systemd units
# ---------------------------------------------------------------------------
head2 "T18 offline-update script and units"
if [ ! -f "$OFFLINE_SCRIPT" ]; then
skip "T18 $OFFLINE_SCRIPT is not installed (update_local_repo.py has not run here)"
info "would have checked: mode 755, bash -n, systemd-analyze verify on both"
info "units, timer enabled, stamp written, throttle on a second run, and that"
info "any /system-update symlink points at something that exists."
else
mode=$(stat -c '%a' "$OFFLINE_SCRIPT" 2>/dev/null)
if [ "$mode" = "755" ]; then
pass "T18 $OFFLINE_SCRIPT is mode 755"
else
fail "T18 $OFFLINE_SCRIPT is mode '$mode', expected 755"
fi
if bash -n "$OFFLINE_SCRIPT" 2>"$TMP_DIR/offerr"; then
pass "T18 offline-update script passes bash -n"
else
fail "T18 offline-update script fails bash -n: $(cat "$TMP_DIR/offerr" | tr '\n' ' ')"
fi
if command -v systemd-analyze >/dev/null 2>&1; then
for unit in "$OFFLINE_SERVICE" "$OFFLINE_TIMER"; do
if [ ! -f "$unit" ]; then
fail "T18 $unit is missing"
continue
fi
if verr=$(systemd-analyze verify "$unit" 2>&1) && [ -z "$verr" ]; then
pass "T18 systemd-analyze verify is clean for $(basename "$unit")"
else
fail "T18 systemd-analyze verify complained about $(basename "$unit"): $(printf '%s' "$verr" | head -3 | tr '\n' ' ')"
fi
done
# The Documentation=man:pkcon(1) trap: verify runs the man binary.
if grep -q 'Documentation=man:' "$OFFLINE_SERVICE" "$OFFLINE_TIMER" 2>/dev/null; then
fail "T18 a unit has Documentation=man: which systemd-analyze verify tries to execute"
else
pass "T18 no Documentation=man: lines (they break verify)"
fi
# Enabling is done by `systemctl enable vdi-offline-update.timer` inside
# install_debian_update_policy(). That only persists when systemd is the
# running init - in a d-i chroot or a container it silently does nothing.
# So: assert it is enabled AFTER driving the installer function, and skip
# the assertion outright when systemd is not PID 1 rather than failing on
# an environment that cannot express the answer.
if [ "$(cat /proc/1/comm 2>/dev/null)" != "systemd" ]; then
skip "T18 timer-enabled assertion skipped: systemd is not PID 1 here"
info "would have checked: systemctl is-enabled vdi-offline-update.timer"
info "after install_debian_update_policy() ran."
else
( cd "$REPO_ROOT" && python3 -c "
import sys; sys.path.insert(0, '$REPO_ROOT'); import update_local_repo as u
u.install_debian_update_policy()" ) >/dev/null 2>&1
if systemctl is-enabled vdi-offline-update.timer >/dev/null 2>&1; then
pass "T18 vdi-offline-update.timer is enabled after install_debian_update_policy()"
else
fail "T18 vdi-offline-update.timer is not enabled after install_debian_update_policy()"
fi
fi
else
skip "T18 systemd-analyze not available; unit files not verified"
fi
# Behavioural: the stamp, the throttle, and the /system-update safety rule.
backup_path "$OFFLINE_STAMP"
backup_path "$SYSTEM_UPDATE_LINK"
rm -f "$OFFLINE_STAMP"
run1=$(timeout 300 "$OFFLINE_SCRIPT" 2>&1); rc1=$?
if [ -s "$OFFLINE_STAMP" ]; then
pass "T18 running the script writes the throttle stamp"
else
fail "T18 running the script did not write $OFFLINE_STAMP"
fi
# Exit 5 from pkcon means "no packages to update" and must not be reported
# as a download failure. This box is up to date, so that is the case here.
if printf '%s' "$run1" | grep -qi 'download failed'; then
fail "T18 script reported a download failure on an up-to-date box (pkcon exit 5 misclassified)"
printf '%s' "$run1" | grep -i 'download failed' | head -2 | sed 's/^/ /'
else
pass "T18 no spurious 'download failed' on an up-to-date box"
fi
if printf '%s' "$run1" | grep -qi 'no updates available'; then
pass "T18 pkcon exit 5 is reported as 'no updates available'"
else
info "T18 (this box may have had real updates; exit-5 path not exercised)"
fi
# THE DANGEROUS ONE: a dangling /system-update fails the next boot.
if [ -L "$SYSTEM_UPDATE_LINK" ]; then
target=$(readlink -f "$SYSTEM_UPDATE_LINK" 2>/dev/null)
if [ -n "$target" ] && [ -e "$target" ]; then
pass "T18 /system-update symlink target exists ($target)"
else
fail "T18 /system-update is DANGLING (-> '$target') - the next boot would fail"
fi
elif [ -e "$SYSTEM_UPDATE_LINK" ]; then
info "T18 /system-update exists but is not a symlink - left alone"
else
pass "T18 no /system-update armed (nothing was prepared)"
fi
# Throttle: a second run immediately after must not re-run pkcon.
run2=$(timeout 60 "$OFFLINE_SCRIPT" 2>&1)
if printf '%s' "$run2" | grep -qi 'skipping'; then
pass "T18 a second run immediately is throttled ('skipping')"
else
fail "T18 a second run was not throttled: $(printf '%s' "$run2" | head -2 | tr '\n' ' ')"
fi
# Stamp of 0 must defeat the throttle, proving the throttle is time-based
# and not a permanent latch.
printf '0\n' > "$OFFLINE_STAMP"
run3=$(timeout 300 "$OFFLINE_SCRIPT" 2>&1)
if printf '%s' "$run3" | grep -qi 'skipping'; then
fail "T18 a stamp of 0 did not defeat the throttle"
else
pass "T18 a stamp of 0 makes the script run again"
fi
# Re-check the symlink after the forced run, since this is the run that may
# have armed it.
if [ -L "$SYSTEM_UPDATE_LINK" ]; then
target=$(readlink -f "$SYSTEM_UPDATE_LINK" 2>/dev/null)
if [ -n "$target" ] && [ -e "$target" ]; then
pass "T18 after the forced run, /system-update target still exists"
else
fail "T18 after the forced run, /system-update is DANGLING"
fi
fi
fi
# ---------------------------------------------------------------------------
# T19: the preseed still generates a working post-install script
# ---------------------------------------------------------------------------
# Runs the preseed's own printf in a sandbox to regenerate /root/vdi-post.sh,
# then checks the result. It never executes the script: it writes /etc/hostname,
# /etc/crontab and systemd units by absolute path and would reconfigure the
# machine running the test.
head2 "T19 preseed generates a working post-install script"
PRESEED="$REPO_ROOT/debian/preseed.cfg"
if [ ! -f "$PRESEED" ]; then
skip "T19 no debian/preseed.cfg in this repo (owned by another change)"
else
if out=$(python3 - "$PRESEED" "$TMP_DIR" <<'PYEOF' 2>&1
import os, re, subprocess, sys
preseed, work = sys.argv[1], sys.argv[2]
lines = open(preseed, encoding="utf-8").read().splitlines()
# The late_command is one logical line continued with trailing backslashes.
start = None
for i, ln in enumerate(lines):
if ln.startswith("d-i preseed/late_command"):
start = i
break
if start is None:
print("NO-LATE-COMMAND")
raise SystemExit(1)
block, i = [], start
while i < len(lines):
block.append(lines[i])
if not lines[i].rstrip().endswith("\\"):
break
i += 1
cmd = "\n".join(block)
# Anchor on the vdi-post.sh redirect. A non-greedy match that is allowed to
# cross a ';' would also capture the firefox printf before it - which then
# tries to write /target/etc/firefox and fails. Anchor from the previous
# statement boundary instead.
# The late_command is a chain of statements, and the payload it writes itself
# contains ';' and '>' inside quoted arguments, so neither splitting on ';' nor
# a bare backwards search is safe. Anchor on the two unambiguous markers: the
# payload's own first argument ('#!/bin/bash') and the redirect target. The
# earlier firefox printf is excluded by construction, because it does not start
# with '#!/bin/bash'.
marker = "> /target/root/vdi-post.sh"
pos = cmd.find(marker)
if pos < 0:
print("NO-REDIRECT")
raise SystemExit(1)
anchor = 'printf "%s\\n" \'#!/bin/bash\''
start = cmd.find(anchor)
if start < 0:
print("NO-PRINTF-ANCHOR")
raise SystemExit(1)
if start > pos:
print("ANCHOR-AFTER-REDIRECT")
raise SystemExit(1)
args = cmd[start + len('printf "%s\\n" '):pos].strip()
if not args:
print("EMPTY-ARGS")
raise SystemExit(1)
# Sanity: the captured argument list must contain the script's first line and
# must not contain the firefox policy payload.
if "#!/bin/bash" not in args:
print("CAPTURED-WRONG-ARGUMENT")
raise SystemExit(1)
if "ManagedBookmarks" in args:
print("CAPTURED-FIREFOX-BLOCK")
raise SystemExit(1)
# Run the printf exactly as the preseed does, but write into our sandbox.
dest = os.path.join(work, "vdi-post.sh")
script = 'printf "%s\\n" ' + args + ' > ' + dest
proc = subprocess.run(["bash", "-c", script], capture_output=True, text=True)
if proc.returncode != 0:
print("PRINTF-FAILED: " + proc.stderr.strip()[:200])
raise SystemExit(1)
if not os.path.exists(dest) or os.path.getsize(dest) == 0:
print("EMPTY-OUTPUT")
raise SystemExit(1)
print("GENERATED " + dest)
PYEOF
); then
printf '%s\n' "$out" | sed 's/^/ /'
GEN="$TMP_DIR/vdi-post.sh"
pass "T19 preseed regenerates /root/vdi-post.sh"
if bash -n "$GEN" 2>"$TMP_DIR/err"; then
pass "T19 generated script passes bash -n"
else
fail "T19 generated script fails bash -n: $(cat "$TMP_DIR/err" | tr '\n' ' ')"
fi
# It must delegate, not duplicate, the pkcon sequence. Comments are
# stripped first: the generated script explains the delegation in a
# comment, and matching that would be a false positive.
if grep -v '^[[:space:]]*#' "$GEN" | grep -qE 'pkcon[[:space:]]+(refresh|offline-trigger|update)'; then
fail "T19 generated script still runs pkcon inline instead of delegating"
grep -v '^[[:space:]]*#' "$GEN" | grep -nE 'pkcon' | head -3 | sed 's/^/ /'
else
pass "T19 generated script delegates to vdi-offline-update (no inline pkcon)"
fi
if grep -q '/usr/local/sbin/vdi-offline-update' "$GEN"; then
pass "T19 generated script references /usr/local/sbin/vdi-offline-update"
else
fail "T19 generated script does not reference the offline-update script"
fi
# Cross-check the path the preseed hard-codes against the path
# update_local_repo.py actually installs. These are two independent
# files, and nothing else ties them together: if the installer's path
# ever changes, auto_update.sh keeps pointing at the old one and
# degenerates to printing "not installed yet" - gracefully, silently,
# and with every other assertion here still green.
installed_path=$(cd "$REPO_ROOT" && python3 -c "
import sys; sys.path.insert(0, '$REPO_ROOT'); import update_local_repo as u
print(u.OFFLINE_UPDATE_SCRIPT)" 2>/dev/null)
if [ -n "$installed_path" ] && grep -qF "$installed_path" "$GEN"; then
pass "T19 preseed delegates to the same path update_local_repo.py installs ($installed_path)"
elif [ -z "$installed_path" ]; then
skip "T19 update_local_repo has no OFFLINE_UPDATE_SCRIPT constant to cross-check"
else
fail "T19 preseed delegates to a different path than update_local_repo.py installs"
info "preseed references /usr/local/sbin/vdi-offline-update;"
info "update_local_repo.OFFLINE_UPDATE_SCRIPT is $installed_path"
fi
if grep -qE 'systemctl enable cron' "$GEN"; then
pass "T19 generated script enables cron"
else
fail "T19 generated script does not enable cron"
fi
if grep -qE 'systemctl enable vdi-offline-update\.timer' "$GEN"; then
pass "T19 generated script enables vdi-offline-update.timer"
else
fail "T19 generated script does not enable vdi-offline-update.timer"
fi
else
fail "T19 could not extract the post-install script from preseed.cfg: $(printf '%s' "$out" | tail -3 | tr '\n' ' ')"
fi
fi
# ---------------------------------------------------------------------------
# T20: make-iso.sh produces a bootable, correctly-preseeded ISO
# ---------------------------------------------------------------------------
# Needs a real Debian netinst ISO. It is NOT downloaded here: a test that
# fetches 792 MB from the network is a test nobody runs. Without the ISO this
# skips and says what it would have checked.
head2 "T20 make-iso.sh builds a preseeded bootable ISO"
MAKE_ISO="$REPO_ROOT/debian/make-iso.sh"
NETINST=""
for candidate in "${NETINST_ISO:-}" /root/trixie-netinst.iso /root/debian-netinst.iso; do
[ -n "$candidate" ] && [ -f "$candidate" ] && { NETINST="$candidate"; break; }
done
if [ ! -f "$MAKE_ISO" ]; then
skip "T20 no debian/make-iso.sh in this repo (owned by another change)"
elif ! command -v xorriso >/dev/null 2>&1; then
skip "T20 xorriso is not installed - make-iso.sh cannot run"
info "apt-get install xorriso"
elif [ -z "$NETINST" ]; then
skip "T20 no Debian netinst ISO found (looked for /root/trixie-netinst.iso)"
info "would have checked: preseed on the image is byte-identical, every kernel"
info "line carries preseed/file=, gtk.cfg is patched, both El Torito images"
info "exist, no source file is missing, size is within a few MB of the source."
info "Point NETINST_ISO=/path/to/netinst.iso at one to run it."
else
info "source ISO: $NETINST ($(du -h "$NETINST" | cut -f1))"
if bash -n "$MAKE_ISO" 2>"$TMP_DIR/isoerr"; then
pass "T20 make-iso.sh passes bash -n"
else
fail "T20 make-iso.sh fails bash -n: $(cat "$TMP_DIR/isoerr" | tr '\n' ' ')"
fi
ISOWORK="$TMP_DIR/iso"
mkdir -p "$ISOWORK"
OUT_ISO="$ISOWORK/out.iso"
# Guard: it must refuse to overwrite an existing output, and refuse to
# write over its own input. Both are destructive if they get it wrong.
: > "$OUT_ISO"
if bash "$MAKE_ISO" "$NETINST" "$OUT_ISO" >/dev/null 2>&1; then
fail "T20 make-iso.sh overwrote an existing output file (should refuse)"
else
pass "T20 make-iso.sh refuses to overwrite an existing output"
fi
rm -f "$OUT_ISO"
if bash "$MAKE_ISO" "$NETINST" "$NETINST" >/dev/null 2>&1; then
fail "T20 make-iso.sh accepted output == input (would destroy the source)"
else
pass "T20 make-iso.sh refuses to write over its input ISO"
fi
# The real build.
build_start=$(date +%s)
if build_out=$(bash "$MAKE_ISO" "$NETINST" "$OUT_ISO" 2>&1); then
build_rc=0
else
build_rc=$?
fi
build_secs=$(( $(date +%s) - build_start ))
if [ "$build_rc" -eq 0 ] && [ -s "$OUT_ISO" ]; then
pass "T20 make-iso.sh built an ISO (${build_secs}s, $(du -h "$OUT_ISO" | cut -f1))"
else
fail "T20 make-iso.sh failed (rc=$build_rc)"
printf '%s\n' "$build_out" | tail -12 | sed 's/^/ /'
fi
if [ -s "$OUT_ISO" ]; then
# ---- preseed is on the image and byte-identical ----
# Note: `-extract /preseed.cfg /dev/stdout` does not work; extract to a
# real file.
if xorriso -osirrox on -indev "$OUT_ISO" -extract /preseed.cfg \
"$ISOWORK/preseed.on.iso" >/dev/null 2>&1; then
if cmp -s "$ISOWORK/preseed.on.iso" "$REPO_ROOT/debian/preseed.cfg"; then
pass "T20 /preseed.cfg on the ISO is byte-identical to debian/preseed.cfg"
else
fail "T20 /preseed.cfg on the ISO differs from debian/preseed.cfg"
fi
else
fail "T20 /preseed.cfg is not present on the output ISO"
fi
# ---- every kernel line is patched, counted not sampled ----
menu_list=$( for dir in /isolinux /boot/grub; do
xorriso -indev "$NETINST" -find "$dir" -name '*.cfg' 2>/dev/null
done | tr -d "'" | grep -v '^$' | sort -u )
total_k=0; patched_k=0; unpatched_list=""; dup_list=""
for menu in $menu_list; do
local_file="$ISOWORK/menu_$(printf '%s' "$menu" | tr '/' '_')"
xorriso -osirrox on -indev "$OUT_ISO" -extract "/$menu" "$local_file" \
>/dev/null 2>&1 || continue
# grep -c prints 0 AND exits 1 when there are no matches, so
# `|| echo 0` would append a second zero. Swallow the status only.
k=$(grep -cE '^[[:space:]]*(append|linux)[[:space:]]' "$local_file" 2>/dev/null || true)
case "$k" in ''|*[!0-9]*) k=0 ;; esac
p=$(grep -E '^[[:space:]]*(append|linux)[[:space:]]' "$local_file" 2>/dev/null \
| grep -cF 'preseed/file=/cdrom/preseed.cfg' || true)
case "$p" in ''|*[!0-9]*) p=0 ;; esac
total_k=$((total_k + k))
patched_k=$((patched_k + p))
[ "$k" -gt 0 ] && [ "$p" -ne "$k" ] && unpatched_list="$unpatched_list $menu($p/$k)"
# The parameter must appear at most once per kernel line.
dups=$(grep -E '^[[:space:]]*(append|linux)[[:space:]]' "$local_file" 2>/dev/null \
| awk '{n=gsub(/preseed\/file=/,"&"); if (n>1) print}' | wc -l)
[ "$dups" -gt 0 ] && dup_list="$dup_list $menu"
done
if [ "$total_k" -gt 0 ] && [ "$patched_k" -eq "$total_k" ]; then
pass "T20 all $total_k kernel lines carry preseed/file= ($patched_k patched)"
else
fail "T20 only $patched_k of $total_k kernel lines are patched"
[ -n "$unpatched_list" ] && info "unpatched:$unpatched_list"
fi
# The BIOS *default* entry lives in gtk.cfg, not isolinux.cfg. Patching
# only the obvious files leaves the machine prompting, which is the bug
# this test exists to catch.
gtk_file="$ISOWORK/menu__isolinux_gtk.cfg"
if [ -f "$gtk_file" ]; then
gtk_k=$(grep -cE '^[[:space:]]*(append|linux)[[:space:]]' "$gtk_file" 2>/dev/null || true)
case "$gtk_k" in ''|*[!0-9]*) gtk_k=0 ;; esac
if [ "$gtk_k" -gt 0 ] && grep -qE '^[[:space:]]*(append|linux)[[:space:]].*preseed/file=' "$gtk_file"; then
pass "T20 isolinux/gtk.cfg is patched (the BIOS default entry)"
else
fail "T20 isolinux/gtk.cfg is NOT patched - the BIOS default would still prompt"
fi
else
info "T20 isolinux/gtk.cfg not present on this ISO (layout differs)"
fi
if [ -z "$dup_list" ]; then
pass "T20 no kernel line carries the parameter twice"
else
fail "T20 duplicated parameter in:$dup_list"
fi
# ---- both El Torito images survive ----
torito=$(xorriso -indev "$OUT_ISO" -report_el_torito plain 2>&1)
if printf '%s' "$torito" | grep -q 'El Torito'; then
pass "T20 output ISO has an El Torito boot record"
else
fail "T20 output ISO has no El Torito boot record"
fi
if printf '%s' "$torito" | grep -q 'BIOS' && printf '%s' "$torito" | grep -q 'UEFI'; then
pass "T20 both BIOS and UEFI boot images are present"
else
fail "T20 only one firmware type is bootable in the output ISO"
fi
# ---- no source file is missing ----
xorriso -indev "$NETINST" -find / -type f -exec lsdl 2>/dev/null \
| awk '{print $NF}' | sort > "$ISOWORK/src.list"
xorriso -indev "$OUT_ISO" -find / -type f -exec lsdl 2>/dev/null \
| awk '{print $NF}' | sort > "$ISOWORK/out.list"
missing_n=$(comm -23 "$ISOWORK/src.list" "$ISOWORK/out.list" | wc -l)
src_n=$(wc -l < "$ISOWORK/src.list")
if [ "$src_n" -gt 0 ] && [ "$missing_n" -eq 0 ]; then
pass "T20 all $src_n source files are present in the output"
else
fail "T20 $missing_n of $src_n source files are missing from the output"
comm -23 "$ISOWORK/src.list" "$ISOWORK/out.list" | head -5 | sed 's/^/ /'
fi
# ---- size guard: the extract-and-rebuild approach bloated 792->988 MB ----
src_bytes=$(stat -c '%s' "$NETINST")
out_bytes=$(stat -c '%s' "$OUT_ISO")
delta=$(( out_bytes - src_bytes ))
if [ "$delta" -lt 0 ]; then abs_delta=$(( -delta )); else abs_delta=$delta; fi
if [ "$abs_delta" -le 16777216 ]; then
pass "T20 output size is within 16 MB of the source (delta ${delta} bytes)"
else
fail "T20 output size differs by $delta bytes - the extent-dedup regression is back"
fi
fi
fi
# ---------------------------------------------------------------------------
# T21: the files that must be executable are executable IN GIT
# ---------------------------------------------------------------------------
# Being executable on the current filesystem is not the property that matters:
# a fresh clone is what a user gets. This repo is developed on a Windows
# checkout where core.fileMode=false, so git silently records 100644 no matter
# what the file mode is on disk - a fresh Linux clone then gets a
# non-executable harness and `./run-tests.sh` fails with "Permission denied".
# That happened once already; this test is why it cannot happen quietly again.
head2 "T21 executable bit is recorded in git"
if ! command -v git >/dev/null 2>&1; then
skip "T21 git is not installed - cannot check the recorded file modes"
info "would have checked: git ls-files -s reports mode 100755 for the"
info "scripts the port requires to be executable."
elif ! git -C "$REPO_ROOT" rev-parse --git-dir >/dev/null 2>&1; then
skip "T21 $REPO_ROOT is not a git checkout - nothing to compare"
else
for must_exec in debian/test/run-tests.sh debian/make-iso.sh; do
# Only assert for files that exist in the repo at all; make-iso.sh is
# owned by another change and may not be present.
entry=$(git -C "$REPO_ROOT" ls-files -s -- "$must_exec" 2>/dev/null)
if [ -z "$entry" ]; then
if [ -f "$REPO_ROOT/$must_exec" ]; then
skip "T21 $must_exec exists but is not tracked by git"
else
info "T21 $must_exec not present in this checkout"
fi
continue
fi
mode=$(printf '%s' "$entry" | awk '{print $1}')
if [ "$mode" = "100755" ]; then
pass "T21 $must_exec is recorded as 100755 in git"
else
fail "T21 $must_exec is recorded as $mode in git, expected 100755"
info "fix: git update-index --chmod=+x $must_exec"
fi
done
fi
# ---------------------------------------------------------------------------
# T15: the harness left nothing behind
# ---------------------------------------------------------------------------
# The residue half of this test must run AFTER the cleanup, not before it, or it
# can never pass - and a permanently-red test trains people to ignore the
# summary. So: check what can be checked now, then tear down, then verify the
# teardown actually happened, then print the summary.
head2 "T15 no collateral damage"
if [ -d "$PROD_REPO_DIR" ]; then
now=$(stat -c '%Y' "$PROD_REPO_DIR" 2>/dev/null || echo "")
if [ "$now" = "$PROD_REPO_MTIME_BEFORE" ]; then
pass "T15 $PROD_REPO_DIR was not modified"
else
fail "T15 $PROD_REPO_DIR changed during the run"
fi
else
pass "T15 $PROD_REPO_DIR does not exist and was not created"
fi
if [ -d "$REPO_ROOT/__pycache__" ]; then
fail "T15 __pycache__ was written into the repo"
else
pass "T15 the repo working tree was not dirtied by Python"
fi
# T16-T19 install a polkit rule and systemd units and arm /system-update.
# Assert that none of that survives: restore each path to its pre-run state and
# then check it took. This is what makes "self-cleaning" a claim rather than
# an intention.
for mutating_path in "$POLKIT_RULE_PATH" "$OFFLINE_STAMP" "$SYSTEM_UPDATE_LINK"; do
restore_path "$mutating_path"
done
# The units and script are only removed if this run created them.
for created_path in "$OFFLINE_SCRIPT" "$OFFLINE_SERVICE" "$OFFLINE_TIMER"; do
restore_path "$created_path"
done
# systemd cached the units; make it re-read whatever is there now.
if command -v systemctl >/dev/null 2>&1; then
systemctl daemon-reload >/dev/null 2>&1
fi
for mutating_path in "$POLKIT_RULE_PATH" "$OFFLINE_STAMP" "$SYSTEM_UPDATE_LINK" \
"$OFFLINE_SCRIPT" "$OFFLINE_SERVICE" "$OFFLINE_TIMER"; do
name=$(printf '%s' "$mutating_path" | tr '/' '_')
was=$(cat "$BACKUP_DIR/$name.state" 2>/dev/null || echo absent)
if [ "$was" = "absent" ]; then
if [ -e "$mutating_path" ] || [ -L "$mutating_path" ]; then
fail "T15 $mutating_path was created by this run and not removed"
else
pass "T15 $mutating_path restored to its pre-run state (absent)"
fi
else
if [ -e "$mutating_path" ] || [ -L "$mutating_path" ]; then
pass "T15 $mutating_path restored (existed before the run)"
else
fail "T15 $mutating_path existed before the run and was not restored"
fi
fi
done
# A dangling /system-update is the dangerous residue: it fails the next boot.
if [ -L "$SYSTEM_UPDATE_LINK" ]; then
target=$(readlink -f "$SYSTEM_UPDATE_LINK" 2>/dev/null)
if [ -n "$target" ] && [ -e "$target" ]; then
pass "T15 any /system-update left behind points at an existing target"
else
fail "T15 /system-update is left DANGLING - the next boot would fail"
fi
fi
# Did anything get installed? Every apt-get install this harness issues is
# --simulate, so the set of installed packages must be unchanged.
if command -v dpkg-query >/dev/null 2>&1; then
installed_now=$(dpkg-query -W -f='${Package}\n' 2>/dev/null | wc -l)
if [ -n "${INSTALLED_BEFORE:-}" ]; then
if [ "$installed_now" = "$INSTALLED_BEFORE" ]; then
pass "T15 installed package count unchanged ($installed_now)"
else
fail "T15 installed package count changed: $INSTALLED_BEFORE -> $installed_now"
fi
fi
fi
# ---- teardown, then verify the teardown ----
printf '\n removing temporary source, keyring, caches and %s\n' "$TMP_DIR"
rm -f "$LIST_FILE" 2>/dev/null
rm -f "$KEYRING_DIR"/zz-vdi-test-* 2>/dev/null
rmdir "$KEYRING_DIR" 2>/dev/null
purge_apt_lists_for "$REPO_DIR"
purge_apt_lists_for "$TAMPER_DIR"
purge_apt_lists_for "$SANDBOX_DIR"
purge_all_harness_lists
rm -rf "$TMP_DIR" 2>/dev/null
apt-get update -qq >/dev/null 2>&1
if [ -f "$LIST_FILE" ]; then
fail "T15 the temporary apt source $LIST_FILE survived teardown"
else
pass "T15 temporary apt source removed from /etc/apt/sources.list.d"
fi
leftover=$(ls /var/lib/apt/lists/*"$(list_fragment "$REPO_DIR")"* 2>/dev/null | wc -l)
if [ "$leftover" -eq 0 ]; then
pass "T15 no cached apt indexes left behind"
else
fail "T15 $leftover cached apt index file(s) left behind"
fi
if [ -e "$TMP_DIR" ]; then
fail "T15 temporary directory $TMP_DIR survived teardown"
else
pass "T15 temporary directory removed"
fi
# From here on the EXIT trap has nothing left to do; make sure it cannot undo
# the summary by re-running apt-get update and removing things again.
CLEANED=1
# ---------------------------------------------------------------------------
# Summary
# ---------------------------------------------------------------------------
printf '\n%s\n' "----------------------------------------------------------------"
printf 'SUMMARY: %d passed, %d failed, %d skipped\n' "$PASSED" "$FAILED" "$SKIPPED"
if [ "$FAILED" -ne 0 ]; then
printf 'FAILED tests:%s\n' "$FAILED_NAMES"
printf 'RESULT: FAIL\n'
exit 1
fi
printf 'RESULT: PASS\n'
if [ "$SKIPPED" -ne 0 ]; then
printf '(%d test(s) skipped - read the SKIP lines above; a skip is not a pass)\n' "$SKIPPED"
fi
exit 0