Files
VDI-Linux/debian/test/run-tests.sh
T
Mistercoolertyper 6ddb1d251a Add Debian 13 (trixie) support alongside Fedora
The provisioning path now runs on both package families. Fedora behaviour is
unchanged: the Fedora publishing code issues the same ten operations in the
same order as before, verified by recording the call sequence from both
implementations against a stubbed environment.

update_local_repo.py
  Detects the family from /etc/os-release and dispatches to sync_fedora() or
  sync_debian(). Release assets are filtered by extension, so neither family
  sees the other's packages. The Debian path builds a flat apt-ftparchive
  repository at the same /var/local/citrix-repo, publishes
  local-citrix-repo.list, and runs apt-get update.

  Fixes found while testing:
  - tqdm is now an optional dependency. A stock Debian 13 image has no pip and
    no tqdm, and dying at import would take down provisioning over a progress
    bar.
  - sync_debian prunes stale *.deb files before repopulating. The Fedora path
    gets this for free by writing fixed filenames; Debian filenames carry the
    version, so without pruning every old version stayed indexed and apt always
    picked the highest, making rollback impossible.
  - The apt source file is resolved next to the script rather than from the
    working directory, with a hardcoded canonical fallback, so a foreign cwd or
    a missing file cannot break the 10-minute cron job.

local-citrix-repo.list
  The apt counterpart of local-citrix-repo.repo, which stays as-is for dnf.
  Uses trusted=yes rather than a signature: the repository is generated on the
  machine from packages this script downloaded itself, so a signature would only
  prove the machine signed its own work, and it would add a gpg dependency that
  Debian 13 does not ship by default. Index integrity is still enforced through
  the hashes in Release.

debian/preseed.cfg
  The debian-installer equivalent of ks.cfg. Same locale, keyboard, timezone,
  passwords, inventory-derived hostname/user/password, disk auto-detection,
  Firefox managed bookmarks, Citrix and TeamViewer installs, auto-update script,
  cron jobs and disable-sleep unit. Every directive was checked against the
  templates in the real trixie udebs. Documented gaps, all inherent to preseed
  vs kickstart: uppercase usernames are rejected by user-setup and so are
  created in late_command; d-i has no lsblk, openssl, chvt or openvt, so disk
  detection reads /sys/block and the inventory prompt goes to /dev/console with
  a kernel-cmdline override and a timeout; pip install tqdm becomes
  python3-tqdm from apt because of PEP 668.

debian/test/
  Harness covering the Debian path on a real Debian 13 machine: repo build,
  sources.list validity, apt visibility after purging the list cache, install
  resolution, idempotency, stale-package pruning, corrupt-index rejection, and
  Fedora non-regression. 52 pass, 3 skip (each skip states why).

Known limitations are listed in README.md under "What the tests do NOT prove":
no real d-i install has been run, and the generated post-install script is
verified as well-formed rather than executed against a target root.
2026-11-04 09:24:57 +01:00

1003 lines
37 KiB
Bash

#!/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
# 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
}
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'
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
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
fail "T07 apt-get install --simulate -y icaclient did not resolve"
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
# ---------------------------------------------------------------------------
# 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
# 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"
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