feat: improve scripts and write tests

This commit is contained in:
alexm committed 2026-10-11 07:22:13 -04:00
1 parent bc3091647e
commit cf4bd07a8e
32 files changed
+3817 -723

No files matched your search

+78
View File
@@ -0,0 +1,78 @@
# shellcheck shell=bash
# Minimal test harness. Source from a test file, define test_* functions, call run_all.
# Each test runs in its own subshell with a fresh $T (temp dir) and cwd = $T.
HARNESS_DIR="$(cd -- "$(dirname -- "${BASH_SOURCE[0]}")" && pwd -P)"
SCRIPTS="$(cd -- "$HARNESS_DIR/.." && pwd -P)"
SHIMS="$HARNESS_DIR/shims"
_PASS=0 _FAIL=0 _FAILED=()
_RM="$(command -v rm)"
_MKTEMP="$(command -v mktemp)" # resolved now: tests may shrink PATH later
_TMP_ROOT="$("$_MKTEMP" -d)"
trap '"$_RM" -rf -- "$_TMP_ROOT"' EXIT
_fail() { printf ' FAIL: %s\n' "$*" >&2; exit 1; }
# run CMD...: capture RC, OUT, ERR (stdin is /dev/null)
run() {
local o e
o="$("$_MKTEMP" -p "$_TMP_ROOT")" e="$("$_MKTEMP" -p "$_TMP_ROOT")"
RC=0
"$@" >"$o" 2>"$e" </dev/null || RC=$?
OUT="$(<"$o")" ERR="$(<"$e")"
"$_RM" -f -- "$o" "$e"
}
# run_in FILE CMD...: like run, but stdin comes from FILE.
run_in() {
local in="$1"; shift
local o e
o="$("$_MKTEMP" -p "$_TMP_ROOT")" e="$("$_MKTEMP" -p "$_TMP_ROOT")"
RC=0
"$@" >"$o" 2>"$e" <"$in" || RC=$?
OUT="$(<"$o")" ERR="$(<"$e")"
"$_RM" -f -- "$o" "$e"
}
# launch_like_terminal CMD...: start CMD in the background the way a terminal would:
# its own session/process group (so a signal reaches children too) with SIGINT at
# its default disposition (bash starts async jobs with SIGINT ignored). Sets LAUNCHED_PID.
launch_like_terminal() {
python3 -c 'import os,signal,sys; os.setsid(); signal.signal(signal.SIGINT, signal.SIG_DFL); os.execvp(sys.argv[1], sys.argv[1:])' "$@" >/dev/null 2>&1 &
LAUNCHED_PID=$!
}
# signal_group SIG: send SIG to the whole process group of LAUNCHED_PID, then reap it.
signal_group() { kill "-$1" -- "-$LAUNCHED_PID" 2>/dev/null; wait "$LAUNCHED_PID" 2>/dev/null; return 0; }
assert_rc() { [[ "$RC" == "$1" ]] || _fail "expected exit $1, got $RC${2:+ ($2)}
stdout: ${OUT:0:600}
stderr: ${ERR:0:1200}"; }
assert_eq() { [[ "$1" == "$2" ]] || _fail "${3:-values differ}
expected: $1
actual: $2"; }
assert_err_has() { [[ "$ERR" == *"$1"* ]] || _fail "stderr missing '$1'
stderr: ${ERR:0:1200}"; }
assert_out_has() { [[ "$OUT" == *"$1"* ]] || _fail "stdout missing '$1'
stdout: ${OUT:0:1200}"; }
assert_err_lacks() { [[ "$ERR" != *"$1"* ]] || _fail "stderr unexpectedly contains '$1'
stderr: ${ERR:0:1200}"; }
assert_file() { [[ -f "$1" ]] || _fail "expected file: $1"; }
assert_no_path() { [[ ! -e "$1" && ! -L "$1" ]] || _fail "unexpected path exists: $1"; }
assert_mode() { local m; m="$(stat -c %a -- "$1")"; [[ "$m" == "$2" ]] || _fail "mode of $1 is $m, expected $2"; }
assert_file_eq() { [[ "$(<"$1")" == "$2" ]] || _fail "contents of $1 differ
expected: $2
actual: $(<"$1")"; }
run_all() {
local filter="${1:-}" t
for t in $(declare -F | awk '{print $3}' | grep '^test_' || true); do
[[ -z "$filter" || "$t" == *"$filter"* ]] || continue
T="$("$_MKTEMP" -d -p "$_TMP_ROOT")"
if ( cd "$T" && export T && set +e && "$t" ) ; then
_PASS=$((_PASS + 1)); printf ' ok %s\n' "$t"
else
_FAIL=$((_FAIL + 1)); _FAILED+=("$t"); printf ' FAIL %s\n' "$t"
fi
done
printf '%s: %d passed, %d failed\n' "$(basename "$0")" "$_PASS" "$_FAIL"
((_FAIL == 0))
}
+96
View File
@@ -0,0 +1,96 @@
#!/usr/bin/env python3
"""
Tiny static file server for tests: supports `Range: bytes=N-` and can inject faults.
usage: range_server.py DIR PORT_FILE [FAULT_FILE]
FAULT_FILE holds one fault per line; each GET of a non-.sha256 file consumes the first line:
truncate N send only N body bytes, then drop the connection
status CODE reply with that HTTP status and no body
norange ignore the Range header and send the whole file with 200
Every request is appended to DIR/../requests.log as "<path> <range-header-or-->".
"""
import http.server
import sys
from pathlib import Path
root = Path(sys.argv[1]).resolve()
port_file = Path(sys.argv[2])
fault_file = Path(sys.argv[3]) if len(sys.argv) > 3 else None
log_file = root.parent / "requests.log"
def pop_fault():
if fault_file is None or not fault_file.exists():
return None
lines = [ln for ln in fault_file.read_text().splitlines() if ln.strip()]
if not lines:
return None
fault_file.write_text("\n".join(lines[1:]) + ("\n" if lines[1:] else ""))
return lines[0].split()
class Handler(http.server.BaseHTTPRequestHandler):
protocol_version = "HTTP/1.1"
def log_message(self, *a):
pass
def do_GET(self):
rng = self.headers.get("Range")
with log_file.open("a") as f:
f.write(f"{self.path} {rng or '-'}\n")
target = (root / self.path.lstrip("/")).resolve()
if root not in target.parents or not target.is_file():
self.send_response(404)
self.send_header("Content-Length", "0")
self.end_headers()
return
data = target.read_bytes()
fault = pop_fault() if not target.name.endswith(".sha256") else None
if fault and fault[0] == "status":
self.send_response(int(fault[1]))
self.send_header("Content-Length", "0")
self.end_headers()
return
start = 0
if rng and not (fault and fault[0] == "norange"):
start = int(rng.split("=")[1].split("-")[0])
if start >= len(data):
self.send_response(416)
self.send_header("Content-Range", f"bytes */{len(data)}")
self.send_header("Content-Length", "0")
self.end_headers()
return
self.send_response(206)
self.send_header(
"Content-Range", f"bytes {start}-{len(data) - 1}/{len(data)}"
)
else:
self.send_response(200)
body = data[start:]
self.send_header("Content-Length", str(len(body)))
self.send_header("Accept-Ranges", "bytes")
self.end_headers()
if fault and fault[0] == "truncate":
self.wfile.write(body[: int(fault[1])])
self.wfile.flush()
self.close_connection = True
self.connection.shutdown(2)
return
self.wfile.write(body)
class QuietServer(http.server.ThreadingHTTPServer):
def handle_error(
self, request, client_address
): # clients drop connections on purpose
pass
srv = QuietServer(("127.0.0.1", 0), Handler)
port_file.write_text(str(srv.server_address[1]))
srv.serve_forever()
+38
View File
@@ -0,0 +1,38 @@
#!/usr/bin/env bash
# Run every test suite for scripts/. No root, network, or real disks needed.
# scripts/tests/run.sh all suites
# scripts/tests/run.sh fetch only suites whose name contains "fetch"
set -u
cd -- "$(dirname -- "$(readlink -f -- "$0")")" || exit 1
filter="${1:-}"
failed=() skipped=() ran=0
need() { # need SUITE CMD...: skip the suite if a tool is missing
local suite="$1" c; shift
for c in "$@"; do
command -v "$c" >/dev/null 2>&1 || { skipped+=("$suite (needs $c)"); return 1; }
done
}
run_suite() {
local name="$1"; shift
[[ -z "$filter" || "$name" == *"$filter"* ]] || return 0
printf '\n== %s\n' "$name"
ran=$((ran + 1))
"$@" || failed+=("$name")
}
need python3 python3 && run_suite python python3 -m unittest -q test_python
need fetch curl python3 flock && run_suite shell/fetch-iso ./test_fetch_iso.sh
run_suite shell/gen-keys ./test_gen_keys.sh
run_suite shell/capture-hardware ./test_capture_hardware.sh
need docker gpg python3 && run_suite shell/docker-creds ./test_docker_creds.sh
need usb script cmp findmnt && run_suite shell/make-usb ./test_make_usb.sh
printf '\n'
((${#skipped[@]})) && printf 'SKIPPED: %s\n' "${skipped[@]}"
if ((${#failed[@]})); then
printf 'FAILED suites: %s\n' "${failed[*]}"
exit 1
fi
printf 'All %d suite(s) passed.\n' "$ran"
+6
View File
@@ -0,0 +1,6 @@
#!/usr/bin/env bash
echo "blockdev $*" >> "${FAKE_OPS_LOG:-/dev/null}"
case "$1" in
--getsize64) awk -F'\t' -v d="$2" '$1==d {print $3; f=1} END {exit !f}' "$FAKE_DISKS" ;;
*) exit 0 ;;
esac
+10
View File
@@ -0,0 +1,10 @@
#!/usr/bin/env bash
# Wrap real dd: drop oflag=direct (unsupported on tmpfs), log, inject faults.
echo "dd $*" >> "${FAKE_OPS_LOG:-/dev/null}"
[[ -z "${FAKE_DD_FAIL:-}" ]] || { echo "dd: error writing: Input/output error" >&2; exit 1; }
args=(); for a in "$@"; do [[ "$a" == oflag=direct ]] || args+=("$a"); done
/usr/bin/dd "${args[@]}" || exit $?
if [[ -n "${FAKE_DD_CORRUPT:-}" ]]; then
for a in "$@"; do [[ "$a" == of=* ]] && of="${a#of=}"; done
printf '\xff' | /usr/bin/dd of="$of" bs=1 seek=1000 conv=notrunc status=none
fi
+2
View File
@@ -0,0 +1,2 @@
#!/usr/bin/env bash
printf '%s\n' "${FAKE_DMESG:-}"
+16
View File
@@ -0,0 +1,16 @@
#!/usr/bin/env bash
# Fake findmnt driven by $FAKE_MOUNTS: lines of "SOURCE TARGET" (raw-escaped).
[[ -z "${FAKE_FINDMNT_FAIL:-}" ]] || { echo "findmnt: simulated failure" >&2; exit 1; }
touch "${FAKE_MOUNTS:?}"
if [[ "$*" == *"--target"* ]]; then
path="${@: -1}"; best="" src=""
while read -r s t; do
t="$(printf '%b' "$t")"
if [[ "$path" == "$t" || "$path" == "$t"/* || "$t" == / ]]; then
((${#t} >= ${#best})) && { best="$t"; src="$s"; }
fi
done < "$FAKE_MOUNTS"
[[ -n "$src" ]] && { echo "$src"; exit 0; }
exit 1
fi
cat "$FAKE_MOUNTS"
+43
View File
@@ -0,0 +1,43 @@
#!/usr/bin/env bash
# Fake lsblk driven by $FAKE_DISKS, a TSV: NAME TYPE SIZE_BYTES MODEL TRAN RM CHILDREN(comma-separated)
# Supports only the invocations make-usb.sh uses.
[[ -z "${FAKE_LSBLK_FAIL:-}" ]] || { echo "lsblk: simulated failure" >&2; exit 1; }
cols="" dev="" flags=""
while (($#)); do
case "$1" in
-o) cols="$2"; shift 2 ;;
/dev/*|/*) dev="$1"; shift ;;
-*) flags+="$1"; shift ;;
*) shift ;;
esac
done
row() { awk -F'\t' -v d="$1" '$1==d' "$FAKE_DISKS"; }
field() { # field ROW COLNAME
local IFS=$'\t' f; read -ra f <<<"$1"
local v
case "$2" in NAME) v="${f[0]}";; TYPE) v="${f[1]}";; SIZE) v="${f[2]}";; MODEL) v="${f[3]}";; TRAN) v="${f[4]}";; RM) v="${f[5]}";; esac
[[ "$v" == "-" ]] && v=""
printf '%s\n' "$v"
}
if [[ -z "$dev" ]]; then
if [[ "$cols" == NAME,TYPE ]]; then
while IFS=$'\t' read -r n t _; do printf '%s %s\n' "$n" "$t"; done < "$FAKE_DISKS"
exit 0
fi
exit 1
fi
r="$(row "$dev")"
if [[ -z "$r" ]]; then
# maybe a child device
if grep -q -F -e "$dev" "$FAKE_DISKS"; then
case "$cols" in NAME) echo "$dev"; exit 0;; TYPE) echo part; exit 0;; *) echo; exit 0;; esac
fi
echo "lsblk: $dev: not a block device" >&2; exit 32
fi
if [[ "$flags" == *l* && "$cols" == NAME ]]; then
echo "$dev"
IFS=',' read -ra kids <<<"$(awk -F'\t' -v d="$dev" '$1==d {print $7}' "$FAKE_DISKS")"
for k in "${kids[@]}"; do [[ -n "$k" ]] && echo "$k"; done
exit 0
fi
field "$r" "$cols"
+5
View File
@@ -0,0 +1,5 @@
#!/usr/bin/env bash
# Fake mountpoint: succeeds only for paths listed (colon-separated) in FAKE_MOUNTPOINTS.
[[ "$1" == "-q" ]] && shift
[[ "$1" == "--" ]] && shift
[[ ":${FAKE_MOUNTPOINTS:-}:" == *":$1:"* ]]
+19
View File
@@ -0,0 +1,19 @@
#!/usr/bin/env bash
# Fake nixos-generate-config. Env: FAKE_NGC_MODE = ok (default) | fail | empty | partial-then-fail | garbage
echo "$*" > "${FAKE_NGC_ARGS:-/dev/null}"
case "${FAKE_NGC_MODE:-ok}" in
ok)
cat <<'EOF'
# Do not modify this file! It was generated by nixos-generate-config
{ config, lib, pkgs, modulesPath, ... }:
{
fileSystems."/" = { device = "/dev/disk/by-uuid/1234"; fsType = "ext4"; };
nixpkgs.hostPlatform = lib.mkDefault "x86_64-linux";
}
EOF
;;
fail) echo "boom" >&2; exit 1 ;;
empty) exit 0 ;;
partial-then-fail) echo "{ half = of a file"; exit 1 ;;
garbage) echo "error: something went wrong but exit 0" ;;
esac
+7
View File
@@ -0,0 +1,7 @@
#!/usr/bin/env bash
# Fake `pass`. Supports only: pass init <gpg-id> Env: FAKE_PASS_FAIL=1, FAKE_PASS_LOG
echo "pass $*" >> "${FAKE_PASS_LOG:-/dev/null}"
[[ -z "${FAKE_PASS_FAIL:-}" ]] || { echo "pass: simulated failure" >&2; exit 1; }
[[ "$1" == init ]] || { echo "fake pass: unsupported: $*" >&2; exit 1; }
dir="${PASSWORD_STORE_DIR:-$HOME/.password-store}"
mkdir -p "$dir"; printf '%s\n' "$2" > "$dir/.gpg-id"
+20
View File
@@ -0,0 +1,20 @@
#!/usr/bin/env bash
# Fake ssh-keygen for tests. Env: FAKE_KEYGEN_LOG, FAKE_KEYGEN_FAIL (substring of path), FAKE_KEYGEN_HANG
file="" comment="" pass="<unset>"
while (($#)); do
case "$1" in
-f) file="$2"; shift 2 ;; -C) comment="$2"; shift 2 ;; -N) pass="$2"; shift 2 ;;
-t) shift 2 ;; -q) shift ;; *) shift ;;
esac
done
[[ -n "${FAKE_KEYGEN_LOG:-}" ]] && printf 'file=%s comment=%s pass=%s\n' "$file" "$comment" "$pass" >> "$FAKE_KEYGEN_LOG"
if [[ -n "${FAKE_KEYGEN_FAIL:-}" && "$file" == *"$FAKE_KEYGEN_FAIL"* ]]; then
echo "ssh-keygen: simulated failure" >&2
: > "$file" # leave debris, like a real mid-flight failure could
exit 1
fi
umask 077
printf 'PRIVATE %s\n' "$comment" > "$file"
if [[ -n "${FAKE_KEYGEN_HANG:-}" ]]; then sleep "$FAKE_KEYGEN_HANG"; fi
printf 'ssh-ed25519 AAAAFAKE %s\n' "$comment" > "$file.pub"
chmod 644 "$file.pub"
+3
View File
@@ -0,0 +1,3 @@
#!/usr/bin/env bash
echo "sudo $*" >> "${FAKE_SUDO_LOG:-/dev/null}"
exec "$@"
+5
View File
@@ -0,0 +1,5 @@
#!/usr/bin/env bash
[[ "$1" == "--" ]] && shift
echo "umount $*" >> "${FAKE_OPS_LOG:-/dev/null}"
[[ ":${FAKE_UMOUNT_FAIL:-}:" != *":$1:"* ]] || { echo "umount: $1: target is busy" >&2; exit 32; }
grep -v -F " $1" "$FAKE_MOUNTS" > "$FAKE_MOUNTS.new"; mv "$FAKE_MOUNTS.new" "$FAKE_MOUNTS"
+2
View File
@@ -0,0 +1,2 @@
#!/usr/bin/env bash
echo "wipefs $*" >> "${FAKE_OPS_LOG:-/dev/null}"
+170
View File
@@ -0,0 +1,170 @@
#!/usr/bin/env bash
set -u
# shellcheck source=harness.sh
source "$(dirname "$0")/harness.sh"
CH="$SCRIPTS/capture-hardware.sh"
PLACEHOLDER="# PLACEHOLDER hardware.nix for host \"willow\"."
setup() {
export PATH="$SHIMS:$PATH"
export FAKE_NGC_ARGS="$T/ngc.args"
REPO="$T/repo"; mkdir -p "$REPO/hosts/willow"; echo '{ }' > "$REPO/flake.nix"
echo "$PLACEHOLDER" > "$REPO/hosts/willow/hardware.nix"
cd "$REPO" || exit 1
}
hw() { cat "$REPO/hosts/willow/hardware.nix"; }
no_debris() { [[ -z "$(ls -A "$REPO/hosts/willow" | grep -v '^hardware.nix$' || true)" ]] || _fail "debris in hosts/willow: $(ls -A "$REPO/hosts/willow")"; }
test_replaces_placeholder() {
setup
run "$CH" willow
assert_rc 0
[[ "$(hw)" == *'nixpkgs.hostPlatform'* ]] || _fail "not replaced: $(hw)"
assert_mode "$REPO/hosts/willow/hardware.nix" 644
no_debris
}
test_generator_failure_preserves_existing_file() {
setup
echo "{ real = hand-edited; }" > hosts/willow/hardware.nix
FAKE_NGC_MODE=fail run "$CH" --force willow
assert_rc 3; assert_err_has "left untouched"
assert_eq "{ real = hand-edited; }" "$(hw)" "existing hardware.nix was damaged"
no_debris
}
test_partial_output_then_failure_preserves_file() {
setup
FAKE_NGC_MODE=partial-then-fail run "$CH" willow
assert_rc 3
assert_eq "$PLACEHOLDER" "$(hw)"
no_debris
}
test_empty_or_garbage_output_rejected() {
setup
local mode
for mode in empty garbage; do
FAKE_NGC_MODE=$mode run "$CH" willow
assert_rc 3 "mode $mode"
assert_eq "$PLACEHOLDER" "$(hw)"
done
no_debris
}
test_refuses_to_overwrite_real_file_non_interactively() {
setup
echo "{ real = 1; }" > hosts/willow/hardware.nix
run "$CH" willow
assert_rc 1; assert_err_has "refusing to overwrite"
assert_eq "{ real = 1; }" "$(hw)"
}
test_force_overwrites_real_file() {
setup
echo "{ real = 1; }" > hosts/willow/hardware.nix
run "$CH" -f willow
assert_rc 0
[[ "$(hw)" == *hostPlatform* ]] || _fail "not overwritten"
}
test_interactive_confirmation() {
setup
echo "{ real = 1; }" > hosts/willow/hardware.nix
# `read` needs a tty for the prompt branch; emulate one with script(1) if present.
command -v script >/dev/null 2>&1 || { echo " (skipped: no script(1))"; return 0; }
printf 'no\n' | script -qec "$CH willow" /dev/null >/dev/null 2>&1
assert_eq "{ real = 1; }" "$(hw)" "answering 'no' must keep the file"
printf 'yes\n' | script -qec "$CH willow" /dev/null >/dev/null 2>&1
[[ "$(hw)" == *hostPlatform* ]] || _fail "answering 'yes' should overwrite"
}
test_missing_host_dir_gives_actionable_message() {
setup
run "$CH" other
assert_rc 1; assert_err_has "just register-host other"
}
test_hostname_traversal_rejected() {
setup
local bad
for bad in '../x' 'a/b' 'Willow' '-x' '' 'a b' '..'; do
run "$CH" "$bad"
assert_rc 1 "name '$bad'"
done
assert_no_path "$T/hosts"
}
test_not_in_a_repo() {
setup
run "$CH" --repo-root "$T" willow
assert_rc 1; assert_err_has "no flake.nix"
run "$CH" --repo-root "$T/nope" willow
assert_rc 1; assert_err_has "repo root not found"
}
test_not_on_nixos() {
setup
local bin="$T/bin"; mkdir -p "$bin"
local c; for c in bash dirname readlink env grep mktemp rm mv chmod cat git; do ln -s "$(command -v $c)" "$bin/$c"; done
PATH="$bin" run "$CH" willow
assert_rc 2; assert_err_has "nixos-generate-config not found"
assert_eq "$PLACEHOLDER" "$(hw)"
}
test_installer_root_detected_only_when_target_has_etc() {
setup
mkdir -p "$T/mnt/etc"
FAKE_MOUNTPOINTS="$T/mnt" run "$CH" --install-root "$T/mnt" willow
assert_rc 0; assert_err_has "using --root $T/mnt"
[[ "$(<"$FAKE_NGC_ARGS")" == *"--root $T/mnt"* ]] || _fail "args: $(<"$FAKE_NGC_ARGS")"
rmdir "$T/mnt/etc"
echo "$PLACEHOLDER" > hosts/willow/hardware.nix
FAKE_MOUNTPOINTS="$T/mnt" run "$CH" --install-root "$T/mnt" willow
assert_rc 0; assert_err_has "doesn't look like a NixOS target"
[[ "$(<"$FAKE_NGC_ARGS")" != *"--root"* ]] || _fail "should not pass --root"
}
test_not_mounted_means_running_system() {
setup
run "$CH" --install-root "$T/mnt" willow
assert_rc 0
[[ "$(<"$FAKE_NGC_ARGS")" != *"--root"* ]] || _fail "should not pass --root"
}
test_uses_sudo_only_when_not_root() {
setup
export FAKE_SUDO_LOG="$T/sudo.log"
run "$CH" willow; assert_rc 0
if ((EUID == 0)); then
[[ ! -e "$FAKE_SUDO_LOG" ]] || _fail "sudo used even though we are root"
else
grep -q "nixos-generate-config" "$FAKE_SUDO_LOG" || _fail "sudo not used for a non-root user"
fi
}
test_relative_repo_root_and_git_diff() {
setup
git init -q . && git add -A && git -c user.email=a@b -c user.name=n commit -qm init
cd "$T" || exit 1
run "$CH" --repo-root repo willow
assert_rc 0; assert_err_has "git diff"; assert_err_has "git-tracked"
assert_out_has "hostPlatform" # the diff body
}
test_help_and_unknown_flags() {
setup
run "$CH" -h; assert_rc 0; assert_out_has "Usage:"
run "$CH" --nope willow; assert_rc 1
run "$CH" willow extra; assert_rc 1
run "$CH" ; assert_rc 1
run "$CH" --repo-root; assert_rc 2
}
test_leading_dash_name_via_double_dash_is_validated() {
setup
run "$CH" -- -rf
assert_rc 1; assert_err_has "invalid hostname"
}
run_all "${1:-}"
+186
View File
@@ -0,0 +1,186 @@
#!/usr/bin/env bash
set -u
# shellcheck source=harness.sh
source "$(dirname "$0")/harness.sh"
DC="$SCRIPTS/docker-creds.sh"
setup() {
export HOME="$T/home"; mkdir -p "$HOME"
export GNUPGHOME="$T/gnupg"; mkdir -p "$GNUPGHOME"; chmod 700 "$GNUPGHOME"
export PATH="$SHIMS:$PATH"
export FAKE_PASS_LOG="$T/pass.log"
unset DOCKER_CONFIG PASSWORD_STORE_DIR
CFG="$HOME/.docker/config.json"
}
jq_get() { python3 -c 'import json,sys; d=json.load(open(sys.argv[1])); print(json.dumps(d.get(sys.argv[2]), sort_keys=True))' "$CFG" "$1"; }
secret_key_count() { gpg --list-secret-keys --with-colons 2>/dev/null | grep -c '^sec:' || true; }
test_non_pass_store_only_edits_config() {
setup
run "$DC" secretservice
assert_rc 0
assert_eq '"secretservice"' "$(jq_get credsStore)"
assert_mode "$CFG" 600
assert_eq 0 "$(secret_key_count)" "must not create GPG keys for non-pass stores"
[[ ! -e "$FAKE_PASS_LOG" ]] || _fail "pass should not be invoked"
assert_err_has "skipping GPG/pass setup"
}
test_preserves_existing_config_keys() {
setup
mkdir -p "$HOME/.docker"
cat > "$CFG" <<'EOF'
{"auths": {"ghcr.io": {"auth": "c2VjcmV0"}}, "credHelpers": {"gcr.io": "gcloud"}, "currentContext": "colima", "credsStore": "old"}
EOF
run "$DC" secretservice
assert_rc 0
assert_eq '{"ghcr.io": {"auth": "c2VjcmV0"}}' "$(jq_get auths)"
assert_eq '{"gcr.io": "gcloud"}' "$(jq_get credHelpers)"
assert_eq '"colima"' "$(jq_get currentContext)"
assert_eq '"secretservice"' "$(jq_get credsStore)"
}
test_invalid_json_is_never_overwritten() {
setup
mkdir -p "$HOME/.docker"
printf '{"auths": {"ghcr.io": {"auth": "c2VjcmV0"},}}' > "$CFG" # trailing comma
local before; before="$(<"$CFG")"
run "$DC" secretservice
assert_rc 1; assert_err_has "not valid JSON"
assert_eq "$before" "$(<"$CFG")" "credentials file was clobbered"
no_temp_files
}
test_non_object_json_is_refused() {
setup
mkdir -p "$HOME/.docker"; echo '["not","an","object"]' > "$CFG"
run "$DC" secretservice
assert_rc 1; assert_err_has "JSON object"
assert_file_eq "$CFG" '["not","an","object"]'
}
test_empty_file_treated_as_empty_config() {
setup
mkdir -p "$HOME/.docker"; : > "$CFG"
run "$DC" secretservice
assert_rc 0
assert_eq '"secretservice"' "$(jq_get credsStore)"
}
no_temp_files() { [[ -z "$(find "$HOME/.docker" -name '*.tmp' 2>/dev/null)" ]] || _fail "temp files left behind"; }
test_already_set_does_not_rewrite() {
setup
mkdir -p "$HOME/.docker"; printf '{\n "credsStore": "secretservice"\n}' > "$CFG" # distinctive formatting
local before; before="$(<"$CFG")"
run "$DC" secretservice
assert_rc 0; assert_out_has "already"
assert_eq "$before" "$(<"$CFG")"
}
test_readonly_config_file_is_handled() {
setup
mkdir -p "$HOME/.docker"; echo '{"auths":{}}' > "$CFG"; chmod 444 "$CFG"
run "$DC" secretservice
assert_rc 0
assert_eq '"secretservice"' "$(jq_get credsStore)"
assert_mode "$CFG" 600
}
test_symlinked_config_is_replaced_not_written_through() {
setup
mkdir -p "$HOME/.docker" "$T/store"
echo '{"auths":{"x":{}}}' > "$T/store/config.json"; chmod 444 "$T/store/config.json"
ln -s "$T/store/config.json" "$CFG"
run "$DC" secretservice
assert_rc 0; assert_err_has "was a symlink"
[[ ! -L "$CFG" ]] || _fail "still a symlink"
assert_eq '"secretservice"' "$(jq_get credsStore)"
assert_eq '{"x": {}}' "$(jq_get auths)"
assert_file_eq "$T/store/config.json" '{"auths":{"x":{}}}' # original target untouched
}
test_docker_config_env_is_honored() {
setup
DOCKER_CONFIG="$T/alt" run "$DC" secretservice
assert_rc 0; assert_file "$T/alt/config.json"; assert_no_path "$HOME/.docker"
}
test_pass_flow_end_to_end_and_idempotent() {
setup
run "$DC" pass --no-passphrase
assert_rc 0
assert_err_has "UNPROTECTED"
assert_eq 1 "$(secret_key_count)"
local fpr; fpr="$(<"$HOME/.password-store/.gpg-id")"
[[ "$fpr" =~ ^[0-9A-F]{40}$ ]] || _fail "bad fingerprint in .gpg-id: $fpr"
gpg --list-secret-keys "$fpr" >/dev/null 2>&1 || _fail ".gpg-id does not name a real secret key"
assert_eq '"pass"' "$(jq_get credsStore)"
# second run: nothing new
run "$DC" pass --no-passphrase
assert_rc 0
assert_err_has "already exists"; assert_err_has "already initialized"
assert_eq 1 "$(secret_key_count)" "re-run created a second key"
assert_eq 1 "$(grep -c 'pass init' "$FAKE_PASS_LOG")" "pass init ran twice"
}
test_uid_is_stable_and_findable() {
setup
run "$DC" pass --no-passphrase; assert_rc 0
gpg --list-secret-keys --with-colons | grep '^uid:' | grep -q "Docker Credential Store <$(id -un)@" \
|| _fail "unexpected uid: $(gpg --list-secret-keys --with-colons | grep '^uid:')"
}
test_works_when_USER_is_unset() {
setup
env -u USER "$DC" secretservice 2>"$T/err" >/dev/null || _fail "failed without USER: $(<"$T/err")"
}
test_missing_tools_checked_before_any_change() {
setup
local bin="$T/bin"; mkdir -p "$bin"
local c; for c in bash dirname readlink env python3 mkdir id hostname uname tty cat; do ln -s "$(command -v $c)" "$bin/$c"; done
PATH="$bin" run "$DC" pass --no-passphrase
assert_rc 3; assert_err_has "gpg"
assert_no_path "$CFG" # nothing was modified
}
test_pass_init_failure_is_reported() {
setup
FAKE_PASS_FAIL=1 run "$DC" pass --no-passphrase
assert_rc 1; assert_err_has "pass init failed"
}
test_passphrase_mode_without_pinentry_fails_cleanly_not_hangs() {
setup
# No agent/pinentry/tty here: gpg must fail promptly and we must report it.
GNUPGHOME="$GNUPGHOME" timeout 60 "$DC" pass >"$T/o" 2>"$T/e" </dev/null; RC=$?
ERR="$(<"$T/e")"
[[ $RC == 124 ]] && _fail "hung waiting for a passphrase"
if ((RC != 0)); then
assert_err_has "GPG key generation failed"
assert_no_path "$HOME/.password-store/.gpg-id"
fi
}
test_argument_validation() {
setup
run "$DC" --bogus; assert_rc 2
run "$DC" pass extra; assert_rc 2
run "$DC" '../x'; assert_rc 2
run "$DC" 'a b'; assert_rc 2
run "$DC" -h; assert_rc 0; assert_out_has "Usage:"
assert_no_path "$CFG"
}
test_empty_string_args_from_just_are_ignored() {
setup
run "$DC" secretservice "" # `just docker-creds secretservice` passes flag=""
assert_rc 0
run "$DC" "" "" # defaults -> pass; needs gpg/pass -> use shims
# (defaults to store=pass: runs real gpg flow without --no-passphrase; just assert it parsed)
[[ "$ERR" != *"invalid credential store"* ]] || _fail "empty arg rejected"
}
run_all "${1:-}"
+217
View File
@@ -0,0 +1,217 @@
#!/usr/bin/env bash
set -u
# shellcheck source=harness.sh
source "$(dirname "$0")/harness.sh"
FI="$SCRIPTS/fetch-iso.sh"
REAL="nixos-graphical-26.05.1234.abcdef0-x86_64-linux.iso"
LATEST="latest-nixos-graphical-x86_64-linux.iso"
# Start the server in $T/www and point the script at it.
serve() {
mkdir -p "$T/www/nixos-26.05"
head -c 3000000 /dev/urandom > "$T/www/nixos-26.05/$LATEST"
local h; h="$(sha256sum "$T/www/nixos-26.05/$LATEST" | cut -d' ' -f1)"
echo "$h" > "$T/hash"
printf '%s %s\n' "$h" "$REAL" > "$T/www/nixos-26.05/$LATEST.sha256"
: > "$T/faults"
python3 "$HARNESS_DIR/range_server.py" "$T/www" "$T/port" "$T/faults" &
SERVER_PID=$!
local i; for i in {1..50}; do [[ -s "$T/port" ]] && break; sleep 0.1; done
export NIXOS_CHANNELS_URL="http://127.0.0.1:$(<"$T/port")"
trap 'kill $SERVER_PID 2>/dev/null' EXIT
}
iso_gets() { grep -c "^/nixos-26.05/$LATEST " "$T/requests.log" 2>/dev/null || true; }
test_fresh_download() {
serve
run "$FI" --dest "$T/iso"
assert_rc 0
assert_file "$T/iso/$REAL"
assert_eq "$(<"$T/hash")" "$(sha256sum "$T/iso/$REAL" | cut -d' ' -f1)"
assert_file_eq "$T/iso/$REAL.sha256" "$(<"$T/hash") $REAL"
assert_eq "$REAL" "$(readlink "$T/iso/$LATEST")"
assert_no_path "$T/iso/$REAL.part"
(cd "$T/iso" && sha256sum -c --status "$REAL.sha256") || _fail "sidecar doesn't verify"
assert_eq "" "$(ls -A "$T/iso" | grep '^\.' | grep -v lock || true)" "stray temp files left in dest"
}
test_second_run_is_a_noop_without_redownload() {
serve
run "$FI" --dest "$T/iso"; assert_rc 0
run "$FI" --dest "$T/iso"; assert_rc 0
assert_err_has "already present and verified"
assert_eq 1 "$(iso_gets)" "ISO should have been fetched exactly once"
}
test_interrupted_download_resumes_instead_of_restarting() {
serve
echo "truncate 1000000" > "$T/faults"
run "$FI" --dest "$T/iso"
assert_rc 2; assert_err_has "re-run to resume"
assert_eq 1000000 "$(stat -c %s "$T/iso/$REAL.part")"
assert_no_path "$T/iso/$REAL"
run "$FI" --dest "$T/iso"
assert_rc 0; assert_err_has "Resuming"
grep -q "bytes=1000000-" "$T/requests.log" || _fail "second run did not send a Range header: $(<"$T/requests.log")"
assert_eq "$(<"$T/hash")" "$(sha256sum "$T/iso/$REAL" | cut -d' ' -f1)"
assert_no_path "$T/iso/$REAL.part"
}
test_corrupt_final_iso_is_replaced() {
serve
mkdir -p "$T/iso"; echo "garbage" > "$T/iso/$REAL"
run "$FI" --dest "$T/iso"
assert_rc 0; assert_err_has "doesn't match upstream"
assert_eq "$(<"$T/hash")" "$(sha256sum "$T/iso/$REAL" | cut -d' ' -f1)"
}
test_complete_part_file_is_finalized_without_network_download() {
serve
mkdir -p "$T/iso"; cp "$T/www/nixos-26.05/$LATEST" "$T/iso/$REAL.part"
run "$FI" --dest "$T/iso"
assert_rc 0; assert_err_has "complete partial download"
assert_eq 0 "$(iso_gets)"
assert_file "$T/iso/$REAL"; assert_no_path "$T/iso/$REAL.part"
}
test_oversized_part_is_discarded_and_download_restarts() {
serve
mkdir -p "$T/iso"; head -c 4000000 /dev/urandom > "$T/iso/$REAL.part" # bigger than the 3 MB remote
run "$FI" --dest "$T/iso"
assert_rc 0; assert_err_has "starting over"
assert_eq "$(<"$T/hash")" "$(sha256sum "$T/iso/$REAL" | cut -d' ' -f1)"
assert_no_path "$T/iso/$REAL.part"
}
test_garbage_prefix_part_is_detected_and_redownloaded_automatically() {
serve
mkdir -p "$T/iso"; head -c 1000 /dev/urandom > "$T/iso/$REAL.part" # resume would yield garbage+tail
run "$FI" --dest "$T/iso"
assert_rc 0; assert_err_has "resumed download failed verification"
assert_eq "$(<"$T/hash")" "$(sha256sum "$T/iso/$REAL" | cut -d' ' -f1)"
}
test_persistently_bad_download_gives_up_after_one_retry() {
serve
printf '%064d %s\n' 0 "$REAL" > "$T/www/nixos-26.05/$LATEST.sha256" # nothing can ever verify
mkdir -p "$T/iso"; head -c 1000 /dev/urandom > "$T/iso/$REAL.part"
run "$FI" --dest "$T/iso"
assert_rc 3; assert_err_has "SHA-256 verification failed"
assert_no_path "$T/iso/$REAL"; assert_no_path "$T/iso/$REAL.part"; assert_no_path "$T/iso/$LATEST"
assert_eq 2 "$(iso_gets)" "exactly one retry expected"
}
test_server_that_ignores_range_restarts_from_scratch() {
serve
mkdir -p "$T/iso"; head -c 500000 "$T/www/nixos-26.05/$LATEST" > "$T/iso/$REAL.part"
echo "norange" > "$T/faults"
run "$FI" --dest "$T/iso"
assert_rc 0; assert_err_has "starting over"
assert_eq "$(<"$T/hash")" "$(sha256sum "$T/iso/$REAL" | cut -d' ' -f1)"
}
test_transient_server_error_keeps_partial_file() {
serve
mkdir -p "$T/iso"; head -c 500000 "$T/www/nixos-26.05/$LATEST" > "$T/iso/$REAL.part"
printf 'status 404\n' > "$T/faults"
run "$FI" --dest "$T/iso"
assert_rc 2
assert_eq 500000 "$(stat -c %s "$T/iso/$REAL.part")" "a 404 must not delete the user's partial download"
}
test_wrong_hash_on_fresh_download_is_rejected() {
serve
printf '%064d %s\n' 0 "$REAL" > "$T/www/nixos-26.05/$LATEST.sha256"
run "$FI" --dest "$T/iso"
assert_rc 3
assert_no_path "$T/iso/$REAL"; assert_no_path "$T/iso/$REAL.part"; assert_no_path "$T/iso/$LATEST"
}
test_hostile_upstream_checksum_files() {
serve
local h bad; h="$(<"$T/hash")"
local -a cases=(
"$h ../../evil.iso"
"$h /etc/passwd.iso"
"$h sub/dir.iso"
"$h notaniso.txt"
"$h name with spaces.iso"
"$h ..iso"
"$h a..b.iso"
"nothex $REAL"
"${h:0:63} $REAL"
"$h"
""
"<html>404</html>"
)
for bad in "${cases[@]}"; do
printf '%s\n' "$bad" > "$T/www/nixos-26.05/$LATEST.sha256"
run "$FI" --dest "$T/iso"
assert_rc 2 "case: $bad"
assert_no_path "$T/evil.iso"; assert_no_path "$T/../evil.iso"
[[ -z "$(find "$T/iso" -name '*.iso*' 2>/dev/null)" ]] || _fail "created files for hostile input '$bad'"
done
}
test_binary_marker_and_uppercase_hash_accepted() {
serve
local h; h="$(<"$T/hash")"
printf '%s *%s\n' "${h^^}" "$REAL" > "$T/www/nixos-26.05/$LATEST.sha256"
run "$FI" --dest "$T/iso"
assert_rc 0
assert_file_eq "$T/iso/$REAL.sha256" "$h $REAL" # normalized
}
test_sha_file_404() {
serve
rm "$T/www/nixos-26.05/$LATEST.sha256"
run "$FI" --dest "$T/iso"
assert_rc 2; assert_err_has "sha256 fetch failed"
}
test_unreachable_server() {
export NIXOS_CHANNELS_URL="http://127.0.0.1:1"
run "$FI" --dest "$T/iso"
assert_rc 2
}
test_newer_iso_updates_symlink_and_keeps_old() {
serve
run "$FI" --dest "$T/iso"; assert_rc 0
head -c 2000000 /dev/urandom > "$T/www/nixos-26.05/$LATEST"
local h2; h2="$(sha256sum "$T/www/nixos-26.05/$LATEST" | cut -d' ' -f1)"
local new="nixos-graphical-26.05.9999.ffffff0-x86_64-linux.iso"
printf '%s %s\n' "$h2" "$new" > "$T/www/nixos-26.05/$LATEST.sha256"
run "$FI" --dest "$T/iso"; assert_rc 0
assert_eq "$new" "$(readlink "$T/iso/$LATEST")"
assert_file "$T/iso/$REAL"; assert_file "$T/iso/$new"
}
test_option_validation() {
local bad
for bad in "--channel ../x" "--channel a/b" "--channel -x" "--edition ''" "--arch x;y" "--channel" "--dest" "--bogus"; do
# shellcheck disable=SC2086
run "$FI" $bad
[[ "$RC" == 1 || "$RC" == 2 ]] || _fail "'$bad' exited $RC"
done
run "$FI" --channel=; assert_rc 1
run "$FI" -h; assert_rc 0; assert_out_has "Usage:"
}
test_option_equals_form() {
serve
run "$FI" --dest="$T/iso" --channel=nixos-26.05 --edition=graphical --arch=x86_64-linux
assert_rc 0; assert_file "$T/iso/$REAL"
}
test_concurrent_run_is_refused() {
serve
mkdir -p "$T/iso"
flock "$T/iso/.fetch-iso.lock" sleep 5 &
local lp=$!; sleep 0.3
run "$FI" --dest "$T/iso"
kill "$lp" 2>/dev/null
assert_rc 1; assert_err_has "already running"
}
run_all "${1:-}"
+129
View File
@@ -0,0 +1,129 @@
#!/usr/bin/env bash
set -u
# shellcheck source=harness.sh
source "$(dirname "$0")/harness.sh"
GK="$SCRIPTS/gen-keys.sh"
setup() { export HOME="$T/home"; mkdir -p "$HOME"; export PATH="$SHIMS:$PATH"; export FAKE_KEYGEN_LOG="$T/keygen.log"; }
test_creates_keys_with_secure_perms() {
setup
run "$GK" github gitlab
assert_rc 0
assert_file "$HOME/.ssh/id_github"; assert_file "$HOME/.ssh/id_github.pub"; assert_file "$HOME/.ssh/id_gitlab"
assert_mode "$HOME/.ssh" 700
assert_mode "$HOME/.ssh/id_github" 600
assert_err_has "generating: $HOME/.ssh/id_github"
}
test_comment_and_empty_passphrase() {
setup
run "$GK" github
local line; line="$(<"$FAKE_KEYGEN_LOG")"
[[ "$line" == *"comment=github@"* ]] || _fail "bad comment: $line"
[[ "$line" == *"pass="* && "$line" != *"pass=<unset>"* ]] || _fail "expected -N \"\": $line"
}
test_is_idempotent_and_never_overwrites() {
setup
mkdir -p "$HOME/.ssh"; echo "MY PRECIOUS KEY" > "$HOME/.ssh/id_github"
run "$GK" github
assert_rc 0; assert_err_has "already exists"
assert_file_eq "$HOME/.ssh/id_github" "MY PRECIOUS KEY"
assert_no_path "$HOME/.ssh/id_github.pub"
[[ ! -e "$FAKE_KEYGEN_LOG" ]] || _fail "ssh-keygen should not have run"
}
test_dangling_symlink_counts_as_existing() {
setup
mkdir -p "$HOME/.ssh"; ln -s /nonexistent "$HOME/.ssh/id_github"
run "$GK" github
assert_rc 0; assert_err_has "already exists"
[[ ! -e "$FAKE_KEYGEN_LOG" ]] || _fail "ssh-keygen should not have run"
}
test_orphan_public_key_is_an_error_not_a_hang() {
setup
mkdir -p "$HOME/.ssh"; echo pub > "$HOME/.ssh/id_github.pub"
run "$GK" github gitlab
assert_rc 1; assert_err_has "without a matching private key"
assert_file "$HOME/.ssh/id_gitlab" # other services still processed
assert_file_eq "$HOME/.ssh/id_github.pub" "pub"
}
test_rejects_bad_names_before_creating_anything() {
setup
local bad
for bad in '../escape' 'a/b' '-rf' '.hidden' 'a b' '' 'x;rm' "$(printf 'a%.0s' {1..65})"; do
run "$GK" good "$bad"
assert_rc 2 "name '$bad'"
assert_no_path "$HOME/.ssh/id_good"
done
assert_no_path "$T/escape"
}
test_duplicates_on_cmdline_generate_once() {
setup
run "$GK" github github github
assert_rc 0
assert_eq 1 "$(wc -l < "$FAKE_KEYGEN_LOG")"
}
test_no_args_is_a_noop() {
setup
run "$GK"
assert_rc 0; assert_no_path "$HOME/.ssh"
}
test_keygen_failure_cleans_debris_and_continues() {
setup
FAKE_KEYGEN_FAIL=bad run "$GK" bad ok
assert_rc 1; assert_err_has "failed for 'bad'"
assert_no_path "$HOME/.ssh/id_bad"
assert_file "$HOME/.ssh/id_ok"
}
_interrupt_test() { # _interrupt_test SIGNAL
setup
FAKE_KEYGEN_HANG=30 launch_like_terminal "$GK" first second
local i; for i in {1..80}; do [[ -e "$HOME/.ssh/id_first" ]] && break; sleep 0.1; done
assert_file "$HOME/.ssh/id_first"
signal_group "$1"
assert_no_path "$HOME/.ssh/id_first"
assert_no_path "$HOME/.ssh/id_first.pub"
assert_no_path "$HOME/.ssh/id_second" # did not carry on to the next service
}
test_sigint_removes_half_written_pair_and_stops() { _interrupt_test INT; }
test_sigterm_removes_half_written_pair_and_stops() { _interrupt_test TERM; }
test_passphrase_flag_requires_tty() {
setup
run "$GK" --passphrase github
assert_rc 2; assert_err_has "interactive terminal"
}
test_unknown_option_and_help() {
setup
run "$GK" --bogus; assert_rc 2
run "$GK" -h; assert_rc 0; assert_out_has "Usage:"
run "$GK" -- -weird; assert_rc 2 # still validated after --
}
test_missing_ssh_keygen() {
setup
# a PATH with the basics but no ssh-keygen
local bin="$T/bin"; mkdir -p "$bin"
local c; for c in bash dirname readlink env mkdir chmod hostname uname rm cat; do ln -s "$(command -v $c)" "$bin/$c"; done
PATH="$bin" run "$GK" github
assert_rc 3; assert_err_has "ssh-keygen"
}
test_hostname_is_sanitized_in_comment() {
setup
local bin="$T/bin"; mkdir -p "$bin"
printf '#!/bin/sh\necho "evil host;name"\n' > "$bin/hostname"; chmod +x "$bin/hostname"
PATH="$bin:$PATH" run "$GK" github
[[ "$(<"$FAKE_KEYGEN_LOG")" == *"comment=github@evil_host_name"* ]] || _fail "$(<"$FAKE_KEYGEN_LOG")"
}
run_all "${1:-}"
+389
View File
@@ -0,0 +1,389 @@
#!/usr/bin/env bash
set -u
# shellcheck source=harness.sh
source "$(dirname "$0")/harness.sh"
export SCRIPTS
MU="$SCRIPTS/make-usb.sh"
DRIVER="$HARNESS_DIR/usb_driver.sh"
# ---- fixtures --------------------------------------------------------------
TAB=$'\t'
row() { printf '%s\t%s\t%s\t%s\t%s\t%s\t%s\n' "$@" >> "$FAKE_DISKS"; }
mkfix() {
export PATH="$SHIMS:$PATH"
export FAKE_DISKS="$T/disks.tsv" FAKE_MOUNTS="$T/mounts" FAKE_OPS_LOG="$T/ops.log" PROC_SWAPS="$T/swaps"
mkdir -p "$T/dev" "$T/iso"
: > "$FAKE_DISKS"; : > "$FAKE_MOUNTS"; : > "$FAKE_OPS_LOG"
printf 'Filename\tType\tSize\tUsed\tPriority\n' > "$PROC_SWAPS"
SDA="$T/dev/sda" SDB="$T/dev/sdb" SDC="$T/dev/sdc" SDD="$T/dev/sdd"
touch "$SDA" "$SDC" "$SDD"; truncate -s 16M "$SDB"
# name type size model tran rm children
row "$SDA" disk 500107862016 "Samsung SSD 860" sata 0 "${SDA}1,${SDA}2,${SDA}3"
row "$SDB" disk 16008609792 "SanDisk Ultra" usb 1 "${SDB}1"
row "$SDC" disk 1000204886016 "WD Elements" usb 0 "${SDC}1"
row "$SDD" disk 250059350016 "Data SSD" sata 0 "${SDD}1"
row "$T/dev/sr0" rom 1073741312 "DVD" sata 1 -
row "$T/dev/loop0" loop 1000000 - - 0 -
printf '%s /\n%s /boot/efi\n%s /run/media/alex/NIXOS\n' "${SDA}2" "${SDA}1" "${SDB}1" > "$FAKE_MOUNTS"
ISO="$T/iso/nixos.iso"; head -c 3145728 /dev/urandom > "$ISO"
(cd "$T/iso" && sha256sum nixos.iso > nixos.iso.sha256)
}
ops() { cat "$FAKE_OPS_LOG"; }
did() { grep -q -- "$1" "$FAKE_OPS_LOG"; }
usb() { run bash "$DRIVER" "$@"; } # non-interactive end-to-end
unit() { run bash -c 'source "$SCRIPTS/make-usb.sh"; is_block_device() { [[ -e "$1" ]]; }; set +e; '"$1"; }
# pty(): run the driver on a pseudo-terminal feeding $1 as keyboard input.
pty() { local input="$1"; shift; local cmd; cmd="$(printf '%q ' bash "$DRIVER" "$@")"
local o="$T/pty.out"; printf '%b' "$input" | script -qec "$cmd" /dev/null > "$o" 2>&1; RC=$?; OUT="$(<"$o")"; ERR="$OUT"; }
# ---- unit: device inspection ----------------------------------------------
test_model_strings_cannot_inject_commands() {
mkfix
# The old script ran `eval` on lsblk output, so a USB stick whose model is
# "$(touch PWNED)" executed arbitrary commands as root.
row "$T/dev/sde" disk 16008609792 "\$(touch $T/PWNED) \`touch $T/PWNED2\` \"; touch $T/PWNED3; \"" usb 1 -
touch "$T/dev/sde"
pty "0\n" ; unit 'select_device <<<"0" 2>&1; echo done'
pty "0\n"
assert_no_path "$T/PWNED"; assert_no_path "$T/PWNED2"; assert_no_path "$T/PWNED3"
[[ "$OUT" == *'touch'* ]] || _fail "malicious model should be displayed as inert text: $OUT"
}
test_original_script_was_exploitable_via_model_string() {
# Documents the vulnerability being fixed: this is the original parsing logic.
local line='NAME="/dev/sdx" MODEL="$(touch '"$T"'/PWNED)" TYPE="disk"'
[[ "$line" =~ ^([A-Z]+=\"[^\"]*\"[[:space:]]*)+$ ]] || _fail "original validation regex would have rejected it"
eval "$line"
assert_file "$T/PWNED"
}
test_blk_field_strips_control_characters() {
mkfix
row "$T/dev/sdf" disk 1 $'\e[31mEVIL\e[0m\a\r ' usb 1 -
unit "blk_field '$T/dev/sdf' MODEL | cat -v"
assert_eq '[31mEVIL[0m' "$OUT"
unit "blk_field '$SDB' MODEL"; assert_eq "SanDisk Ultra" "$OUT"
}
test_list_candidates_skips_optical_and_loop() {
mkfix
unit 'list_candidate_disks'
assert_eq "$SDA
$SDB
$SDC
$SDD" "$OUT"
}
test_protected_mounts_allowlist_not_blocklist() {
mkfix
# The old check only looked for exactly / and /boot, so these slipped through:
printf '%s /nix/store\n%s /home\n%s /var/lib/docker\n%s /boot/efi\n' "${SDD}1" "${SDD}1" "${SDD}1" "${SDD}1" > "$FAKE_MOUNTS"
unit "protected_mounts '$SDD'"
assert_eq "/nix/store
/home
/var/lib/docker
/boot/efi" "$OUT"
}
test_automount_points_are_not_protected() {
mkfix
printf '%s /run/media/alex/A B\n%s /media/usb\n%s /mnt/x\n' "${SDB}1" "${SDB}1" "${SDB}1" > "$FAKE_MOUNTS"
unit "protected_mounts '$SDB'; echo rc=\$?"
assert_eq "rc=0" "$OUT"
}
test_mount_point_with_spaces_decoded() {
mkfix
printf '%s /run/media/alex/My\\x20Stick\n' "${SDB}1" > "$FAKE_MOUNTS"
unit "mounts_of '$SDB'"
assert_eq "/run/media/alex/My Stick" "$OUT"
}
test_btrfs_subvolume_suffix_and_luks_holder() {
mkfix
row "$T/dev/sdg" disk 1000000000000 "NVMe" nvme 0 "$T/dev/sdg1,$T/dev/mapper/cryptroot"
printf '%s[/@] /\n%s /home\n' "$T/dev/mapper/cryptroot" "$T/dev/mapper/cryptroot" > "$FAKE_MOUNTS"
touch "$T/dev/sdg"
unit "protected_mounts '$T/dev/sdg'"
assert_eq "/
/home" "$OUT"
}
test_swap_protects_disk() {
mkfix
printf '%s\tpartition\t100\t0\t-2\n' "${SDD}1" >> "$PROC_SWAPS"
unit "protected_mounts '$SDD'"
assert_out_has "SWAP"
}
test_unreadable_swap_table_fails_closed() {
mkfix
PROC_SWAPS="$T/does-not-exist" unit "protected_mounts '$SDB'"
assert_out_has "SWAP"
}
test_unreadable_mount_table_fails_closed() {
mkfix
FAKE_FINDMNT_FAIL=1 unit "protected_mounts '$SDB'"
assert_out_has "mount table unreadable"
FAKE_FINDMNT_FAIL=1 unit "unsafe_reason '$SDB'; echo rc=\$?"
assert_out_has "rc=0" # 0 means "unsafe"
}
test_lsblk_failure_fails_closed() {
mkfix
FAKE_LSBLK_FAIL=1 unit "unsafe_reason '$SDB'; echo rc=\$?"
assert_out_has "cannot inspect"; assert_out_has "rc=0"
}
test_unsafe_reason_matrix() {
mkfix
local d expect
# device : expected verdict ("safe" or substring of the reason)
for pair in "$SDB:safe" "$SDC:safe" "$SDA:in-use system data" "$SDD:neither removable" \
"${SDB}1:not a whole disk" "$T/dev/nonexistent:not a block device"; do
d="${pair%%:*}"; expect="${pair#*:}"
# `${SDB}1` is a child and is not a node in the fixture: create it so is_block_device passes.
touch "$d" 2>/dev/null
unit "unsafe_reason '$d'; echo rc=\$?" ; [[ "$d" == *nonexistent ]] && rm -f "$d" && unit "unsafe_reason '$d'; echo rc=\$?"
if [[ "$expect" == safe ]]; then
assert_eq "rc=1" "$OUT" "$d should be acceptable"
else
[[ "$OUT" == *"$expect"* && "$OUT" == *rc=0 ]] || _fail "$d: wanted '$expect', got: $OUT"
fi
done
}
test_usb_hdd_reporting_removable_0_is_accepted_via_transport() {
mkfix
printf '' > "$FAKE_MOUNTS"
row "$T/dev/sdh" disk 1000204886016 "Passport" usb 0 -
touch "$T/dev/sdh"
unit "unsafe_reason '$T/dev/sdh'; echo rc=\$?"; assert_eq "rc=1" "$OUT"
}
test_allow_internal_does_not_override_system_disk() {
mkfix
unit "ALLOW_INTERNAL=1; unsafe_reason '$SDD'; echo rc=\$?"; assert_eq "rc=1" "$OUT" # data disk: now allowed
unit "ALLOW_INTERNAL=1; unsafe_reason '$SDA'; echo rc=\$?"; assert_out_has "in-use system data"
}
test_iso_on_target_device_detected() {
mkfix
printf '%s /run/media/alex/NIXOS\n' "${SDB}1" > "$FAKE_MOUNTS"
unit "iso_on_device /run/media/alex/NIXOS/nixos.iso '$SDB'; echo rc=\$?"; assert_eq "rc=0" "$OUT"
unit "iso_on_device /run/media/alex/NIXOS/nixos.iso '$SDD'; echo rc=\$?"; assert_eq "rc=1" "$OUT"
printf '%s /\n' "${SDA}2" > "$FAKE_MOUNTS"
unit "iso_on_device /home/alex/nixos.iso '$SDB'; echo rc=\$?"; assert_eq "rc=1" "$OUT"
}
# ---- end to end -------------------------------------------------------------
test_e2e_happy_path() {
mkfix
usb --iso "$ISO" --device "$SDB" --yes
assert_rc 0
assert_err_has "Read-back verified"
cmp -n 3145728 "$ISO" "$SDB" || _fail "device content differs from ISO"
did "umount /run/media/alex/NIXOS" || _fail "stick was not unmounted: $(ops)"
did "wipefs -a $SDB" || _fail "no wipefs"
# order matters: unmount -> wipe -> dd
local order; order="$(grep -o '^\(umount\|wipefs\|dd\)' "$FAKE_OPS_LOG" | tr '\n' ' ')"
assert_eq "umount wipefs dd " "$order"
}
test_e2e_resolves_symlinked_device_path() {
mkfix
mkdir -p "$T/dev/disk/by-id"; ln -s "$SDB" "$T/dev/disk/by-id/usb-SanDisk"
usb --iso "$ISO" --device "$T/dev/disk/by-id/usb-SanDisk" --yes
assert_rc 0
cmp -n 3145728 "$ISO" "$SDB" || _fail "wrote to wrong target"
}
test_e2e_refuses_system_disk_and_writes_nothing() {
mkfix
usb --iso "$ISO" --device "$SDA" --yes --allow-internal
assert_rc 4; assert_err_has "in-use system data"
! did "dd " && ! did wipefs && ! did umount || _fail "touched the system disk: $(ops)"
}
test_e2e_refuses_partition() {
mkfix; touch "${SDB}1"
usb --iso "$ISO" --device "${SDB}1" --yes
assert_rc 4
! did "dd " || _fail "wrote to a partition"
}
test_e2e_refuses_internal_without_flag() {
mkfix
usb --iso "$ISO" --device "$SDD" --yes
assert_rc 4; assert_err_has "--allow-internal"
usb --iso "$ISO" --device "$SDD" --yes --allow-internal
assert_rc 0
}
test_e2e_refuses_when_iso_is_on_target() {
mkfix
# A realistic desktop auto-mount: the stick is mounted under /run/media and
# the ISO sits on it. Wiping the stick would destroy the very file we are
# about to write.
local mnt="/run/media/mkusb-test-$$/NIXOS"
mkdir -p "$mnt" 2>/dev/null || { echo " (skipped: cannot create /run/media; needs root)"; return 0; }
cp "$ISO" "$mnt/nixos.iso"
printf '%s %s\n%s /\n' "${SDB}1" "$mnt" "${SDA}2" > "$FAKE_MOUNTS"
usb --iso "$mnt/nixos.iso" --device "$SDB" --yes
local rc=$RC err="$ERR"; rm -rf "/run/media/mkusb-test-$$"
RC=$rc ERR="$err"
assert_rc 4; assert_err_has "stored on"
! did "dd " && ! did wipefs && ! did umount || _fail "touched the disk holding the ISO: $(ops)"
}
test_e2e_iso_bigger_than_disk() {
mkfix
row "$T/dev/sdt" disk 1000 "Tiny" usb 1 -; touch "$T/dev/sdt"
usb --iso "$ISO" --device "$T/dev/sdt" --yes
assert_rc 4; assert_err_has "larger than the disk"
}
test_e2e_empty_or_missing_iso() {
mkfix
: > "$T/empty.iso"
usb --iso "$T/empty.iso" --device "$SDB" --yes; assert_rc 4; assert_err_has "empty"
usb --iso "$T/nope.iso" --device "$SDB" --yes; assert_rc 4; assert_err_has "not found"
! did "dd " || _fail "dd ran"
}
test_e2e_checksum_mismatch_blocks_write() {
mkfix
echo "$(printf '%064d' 0) nixos.iso" > "$T/iso/nixos.iso.sha256"
usb --iso "$ISO" --device "$SDB" --yes
assert_rc 5; assert_err_has "sha256 verification failed"
! did "dd " && ! did wipefs || _fail "wrote despite bad checksum"
}
test_e2e_checksum_sidecar_found_via_symlink() {
mkfix
ln -s "$ISO" "$T/iso/latest.iso"
echo "$(printf '%064d' 0) nixos.iso" > "$T/iso/nixos.iso.sha256"
usb --iso "$T/iso/latest.iso" --device "$SDB" --yes
assert_rc 5 # mismatch detected through the symlink
}
test_e2e_missing_sidecar_warns_but_proceeds() {
mkfix; rm "$T/iso/nixos.iso.sha256"
usb --iso "$ISO" --device "$SDB" --yes
assert_rc 0; assert_err_has "skipping checksum"
}
test_e2e_corrupted_write_detected() {
mkfix
FAKE_DD_CORRUPT=1 usb --iso "$ISO" --device "$SDB" --yes
assert_rc 6; assert_err_has "verification FAILED"
}
test_e2e_no_verify_flag_skips_readback() {
mkfix
FAKE_DD_CORRUPT=1 usb --iso "$ISO" --device "$SDB" --yes --no-verify
assert_rc 0; assert_err_has "skipping read-back"
}
test_e2e_dd_failure_reports_kernel_messages() {
mkfix
FAKE_DD_FAIL=1 FAKE_DMESG="[ 12.3] sdb: Medium Error, sector 42" usb --iso "$ISO" --device "$SDB" --yes
assert_rc 5; assert_err_has "dd failed"; assert_err_has "Medium Error"
assert_err_lacks "Read-back verified"
}
test_e2e_dd_failure_without_kernel_messages_hints_dmesg() {
mkfix
FAKE_DD_FAIL=1 usb --iso "$ISO" --device "$SDB" --yes
assert_rc 5; assert_err_has "dmesg"
}
test_e2e_unmount_failure_aborts_before_any_write() {
mkfix
FAKE_UMOUNT_FAIL="/run/media/alex/NIXOS" usb --iso "$ISO" --device "$SDB" --yes
assert_rc 4; assert_err_has "could not unmount"
! did "dd " && ! did wipefs || _fail "wrote to a busy device: $(ops)"
! did "umount -l" || _fail "used lazy unmount"
}
test_e2e_noninteractive_requires_all_args() {
mkfix
usb --iso "$ISO" --device "$SDB" # no --yes
assert_rc 2; assert_err_has "not a tty"
usb --device "$SDB" --yes
assert_rc 2
! did "dd " || _fail "dd ran"
}
test_e2e_argument_errors() {
mkfix
usb --bogus; assert_rc 2
usb --iso; assert_rc 2; assert_err_has "requires a value"
usb --device; assert_rc 2
usb -h; assert_rc 0; assert_out_has "Usage:"
}
test_e2e_equals_form() {
mkfix
usb --iso="$ISO" --device="$SDB" --yes
assert_rc 0
}
test_e2e_missing_tools() {
mkfix
local bin="$T/bin"; mkdir -p "$bin"
local c; for c in bash dirname readlink env cat sed grep tr awk stat dd sync blockdev umount wipefs findmnt; do ln -s "$(command -v "$c")" "$bin/$c" 2>/dev/null; done
# no lsblk
PATH="$bin" run bash "$DRIVER" --iso "$ISO" --device "$SDB" --yes
assert_rc 3; assert_err_has "lsblk"
}
# ---- interactive (pty) ------------------------------------------------------
test_pty_menu_marks_system_disk_and_rejects_bad_input() {
mkfix
# abc -> not a number; 99 -> out of range; 08 -> must not crash on octal; 1 (=sda, system) -> refused; 0 -> abort
pty 'abc\n99\n08\n1\n0\n' --iso "$ISO" --yes
assert_rc 1
[[ "$OUT" == *"not a number"* ]] || _fail "no 'not a number': $OUT"
[[ "$OUT" == *"out of range"* ]] || _fail "no 'out of range'"
[[ "$OUT" == *"value too great for base"* ]] && _fail "octal crash on '08'"
[[ "$OUT" == *"SYSTEM DISK"* ]] || _fail "system disk not flagged"
[[ "$OUT" == *"in-use system data"* ]] || _fail "selecting the system disk was not refused"
! did "dd " || _fail "dd ran"
}
test_pty_eof_in_menu_is_a_clean_error() {
mkfix
pty '' --iso "$ISO" --yes
assert_rc 1
}
test_pty_select_and_typed_confirmation() {
mkfix
printf '' > "$FAKE_MOUNTS" # nothing mounted: only the stick matters
# menu order: sda sdb sdc sdd -> 2 is the SanDisk
pty "2\n$SDB\n" --iso "$ISO"
assert_rc 0
cmp -n 3145728 "$ISO" "$SDB" || _fail "not written"
}
test_pty_wrong_confirmation_aborts_without_writing() {
mkfix
pty "2\n$SDC\n" --iso "$ISO"
assert_rc 1
[[ "$OUT" == *"confirmation didn't match"* ]] || _fail "$OUT"
! did "dd " && ! did wipefs && ! did umount || _fail "acted despite wrong confirmation"
}
test_pty_prompts_for_iso_and_expands_tilde() {
mkfix
printf '' > "$FAKE_MOUNTS"
export HOME="$T/home"; mkdir -p "$HOME"; cp "$ISO" "$HOME/my.iso"
pty "~/my.iso\n" --device "$SDB" --yes
assert_rc 0
cmp -n 3145728 "$ISO" "$SDB" || _fail "wrong ISO written"
}
run_all "${1:-}"
+623
View File
@@ -0,0 +1,623 @@
#!/usr/bin/env python3
"""Tests for nixflake.py, register-host.py and list-hosts.py. Run: python3 -m unittest -v"""
from __future__ import annotations
import importlib.util
import io
import os
import random
import re
import stat
import sys
import tempfile
import textwrap
import unittest
from contextlib import redirect_stderr, redirect_stdout
from pathlib import Path
from unittest import mock
SCRIPTS = Path(__file__).resolve().parent.parent
sys.path.insert(0, str(SCRIPTS))
import nixflake # noqa: E402
def load(filename: str, modname: str):
spec = importlib.util.spec_from_file_location(modname, SCRIPTS / filename)
mod = importlib.util.module_from_spec(spec)
sys.modules[modname] = mod # dataclasses (with deferred annotations) look themselves up here
spec.loader.exec_module(mod)
return mod
reg = load("register-host.py", "register_host")
lh = load("list-hosts.py", "list_hosts")
BASIC = textwrap.dedent("""\
{
inputs.nixpkgs.url = "github:NixOS/nixpkgs/nixos-unstable";
outputs = { self, nixpkgs, ... }@inputs:
let system = "x86_64-linux"; in {
nixosConfigurations = {
alpha = nixpkgs.lib.nixosSystem {
inherit system;
modules = [ ./hosts/alpha ];
};
beta = nixpkgs.lib.nixosSystem {
inherit system;
modules = [ ./hosts/beta ./hosts/beta-extras ];
};
};
};
}
""")
def names(src: str) -> list[str]:
return [h.name for h in nixflake.find_hosts(src)]
class MaskTests(unittest.TestCase):
def test_length_and_newlines_preserved(self):
src = 'a = "x\n{";\n# c {\n/* {\n} */ b = \'\'\n${y}\n\'\';\n'
m = nixflake.mask_non_code(src)
self.assertEqual(len(m), len(src))
self.assertEqual([i for i, c in enumerate(src) if c == "\n"], [i for i, c in enumerate(m) if c == "\n"])
def test_braces_in_non_code_ignored(self):
for src in (
'{ a = "}"; }',
"{ a = 1; # }\n}",
"{ a = 1; /* } */ }",
"{ a = ''}''; }",
"{ a = ''x'''}''; }",
'{ a = "\\"}"; }',
"{ a = ''x''${}''; }",
):
self.assertTrue(nixflake.braces_balanced(src), src)
m = nixflake.mask_non_code(src)
self.assertEqual(nixflake.find_matching_brace(m, 0), len(src) - 1, src)
def test_interpolation_is_code(self):
src = '{ a = "x ${ { b = 1; }.b } y"; c = "${"nested ${ "}" }"}"; }'
self.assertTrue(nixflake.braces_balanced(src))
m = nixflake.mask_non_code(src)
self.assertEqual(nixflake.find_matching_brace(m, 0), len(src) - 1)
def test_indented_string_escapes(self):
# ''$ and ''' and ''\n are escapes, not terminators.
src = "{ a = ''x ''${notinterp} ''' still ''\\n in ''; b = 1; }"
m = nixflake.mask_non_code(src)
self.assertEqual(nixflake.find_matching_brace(m, 0), len(src) - 1)
self.assertIn("b = 1", m)
def test_unterminated_constructs_do_not_crash(self):
for src in ('{ a = "oops', "{ a = ''oops", "{ /* oops", "{ # oops", '{ a = "${ x', "\\", "''", '"', "${"):
nixflake.mask_non_code(src) # must not raise
def test_fuzz_never_crashes_and_preserves_length(self):
rng = random.Random(1234)
alphabet = ['"', "'", "''", "$", "${", "}", "{", "#", "/*", "*/", "\\", "\n", " ", "a", "=", ";"]
for _ in range(3000):
src = "".join(rng.choice(alphabet) for _ in range(rng.randint(0, 40)))
m = nixflake.mask_non_code(src)
self.assertEqual(len(m), len(src), repr(src))
nixflake.braces_balanced(src)
class FindHostsTests(unittest.TestCase):
def test_basic(self):
self.assertEqual(names(BASIC), ["alpha", "beta"])
def test_ignores_commented_and_stringified_hosts(self):
src = textwrap.dedent("""\
{ outputs = { nixosConfigurations = {
# ghost = nixpkgs.lib.nixosSystem { };
/* ghost2 = nixpkgs.lib.nixosSystem { }; */
doc = "ghost3 = nixpkgs.lib.nixosSystem { };";
real = nixpkgs.lib.nixosSystem { };
}; }; }
""")
self.assertEqual(names(src), ["real"])
def test_brace_in_comment_does_not_end_block(self):
src = textwrap.dedent("""\
{ nixosConfigurations = {
a = nixpkgs.lib.nixosSystem { x = 1; }; # } closes nothing
b = nixpkgs.lib.nixosSystem { y = "}"; };
}; }
""")
self.assertEqual(names(src), ["a", "b"])
def test_nested_nixossystem_not_a_host(self):
src = textwrap.dedent("""\
{ nixosConfigurations = {
outer = nixpkgs.lib.nixosSystem {
modules = [ { inner = nixpkgs.lib.nixosSystem { }; } ];
other = let
deep = nixpkgs.lib.nixosSystem { };
in deep;
};
}; }
""")
self.assertEqual(names(src), ["outer"])
def test_function_path_variants(self):
src = textwrap.dedent("""\
{ nixosConfigurations = {
a = nixpkgs.lib.nixosSystem { };
b = inputs.nixpkgs.lib.nixosSystem { };
c = lib.nixosSystem { };
d = nixosSystem { };
e-f_g' = nixpkgs.lib.nixosSystem
{
};
not-a-host = somethingElse { };
}; }
""")
self.assertEqual(names(src), ["a", "b", "c", "d", "e-f_g'"])
def test_errors(self):
with self.assertRaises(nixflake.FlakeError):
names("{ outputs = { }; }")
with self.assertRaises(nixflake.FlakeError):
names("{ nixosConfigurations = { a = nixpkgs.lib.nixosSystem { };")
with self.assertRaises(nixflake.FlakeError): # entry missing its `;`
names("{ nixosConfigurations = { a = nixpkgs.lib.nixosSystem { } }; }")
def test_empty_block(self):
self.assertEqual(names("{ nixosConfigurations = { }; }"), [])
self.assertEqual(names("{ nixosConfigurations = {}; }"), [])
def test_crlf(self):
self.assertEqual(names(BASIC.replace("\n", "\r\n")), ["alpha", "beta"])
def test_dotted_prefix_still_found(self):
self.assertEqual(names("{ outputs.nixosConfigurations = { a = nixpkgs.lib.nixosSystem { }; }; }"), ["a"])
# but a lookalike attribute is not nixosConfigurations
with self.assertRaises(nixflake.FlakeError):
names("{ fakenixosConfigurations = { a = nixpkgs.lib.nixosSystem { }; }; }")
class PlanEditTests(unittest.TestCase):
def test_clone_renames_and_rewrites_paths(self):
e = reg.plan_flake_edit(BASIC, "gamma", "beta")
self.assertEqual(names(e.new_src), ["alpha", "beta", "gamma"])
self.assertIn("gamma = nixpkgs.lib.nixosSystem {", e.new_src)
self.assertIn("./hosts/gamma ./hosts/beta-extras", e.new_src.split("gamma = ")[1]) # -extras untouched
self.assertTrue(nixflake.braces_balanced(e.new_src))
self.assertEqual(e.template_used, "beta")
self.assertTrue(any("beta-extras" in ln for ln in e.stale_template_lines) is False)
def test_stale_mentions_reported(self):
src = BASIC.replace("modules = [ ./hosts/beta ", 'networking.hostName = "beta"; modules = [ ./hosts/beta ')
self.assertIn('hostName = "beta"', src)
e = reg.plan_flake_edit(src, "gamma", "beta")
self.assertTrue(any('"beta"' in ln for ln in e.stale_template_lines), e.stale_template_lines)
def test_default_entry_empty_blocks(self):
for src in (
"{ outputs = { nixosConfigurations = { }; }; }",
"{ outputs = { nixosConfigurations = {}; }; }",
"{\n nixosConfigurations = {\n };\n}\n",
"{\n nixosConfigurations = {\n };\n}",
):
e = reg.plan_flake_edit(src, "gamma", None)
self.assertEqual(names(e.new_src), ["gamma"], src)
self.assertTrue(nixflake.braces_balanced(e.new_src), src)
self.assertIn("./hosts/gamma", e.new_src)
def test_one_line_attrset_with_existing_host(self):
src = "{ nixosConfigurations = { a = nixpkgs.lib.nixosSystem { }; }; }"
e = reg.plan_flake_edit(src, "b", "a")
self.assertEqual(names(e.new_src), ["a", "b"])
self.assertTrue(nixflake.braces_balanced(e.new_src))
def test_crlf_is_preserved_everywhere(self):
src = BASIC.replace("\n", "\r\n")
for template in ("alpha", None):
e = reg.plan_flake_edit(src, "gamma", template)
self.assertNotRegex(e.new_src, r"(?<!\r)\n", f"bare LF introduced (template={template})")
self.assertEqual(names(e.new_src), ["alpha", "beta", "gamma"])
def test_tabs(self):
src = BASIC.replace(" ", "\t")
e = reg.plan_flake_edit(src, "gamma", "alpha")
self.assertEqual(names(e.new_src), ["alpha", "beta", "gamma"])
self.assertIn("\n\t\t\t\tgamma = ", e.new_src)
def test_duplicate_and_unknown_template(self):
with self.assertRaises(reg.RegisterError):
reg.plan_flake_edit(BASIC, "alpha", None)
with self.assertRaises(reg.RegisterError):
reg.plan_flake_edit(BASIC, "gamma", "nope")
def test_substring_name_is_not_a_duplicate(self):
# `alp` must not collide with `alpha`, nor `alpha-2`.
e = reg.plan_flake_edit(BASIC, "alp", "alpha")
self.assertEqual(names(e.new_src), ["alpha", "beta", "alp"])
def test_template_with_hostile_contents(self):
src = textwrap.dedent("""\
{ nixosConfigurations = {
a = nixpkgs.lib.nixosSystem {
# comment with } brace and a = nixpkgs.lib.nixosSystem {
modules = [ { x = "}${"{"}"; y = ''
} ${ "}" } ''${ ''' '';
} ];
};
}; }
""")
e = reg.plan_flake_edit(src, "b", "a")
self.assertEqual(names(e.new_src), ["a", "b"])
self.assertTrue(nixflake.braces_balanced(e.new_src))
def test_pure_insertion_invariant(self):
e = reg.plan_flake_edit(BASIC, "gamma", "alpha")
self.assertTrue(is_pure_insertion(BASIC, e.new_src))
def is_pure_insertion(old: str, new: str) -> bool:
"""True if `new` equals `old` with one contiguous chunk inserted."""
if len(new) < len(old):
return False
p = 0
while p < len(old) and old[p] == new[p]:
p += 1
s = 0
while s < len(old) - p and old[-1 - s] == new[-1 - s]:
s += 1
return p + s >= len(old)
def random_flake(rng: random.Random) -> tuple[str, list[str]]:
junk = [
'# } { comment\n', '/* } { */', '"}{"', "''}${\"{\"}{''", '"${ "}" }"', "x = \"a\\\"}\";",
"# x = nixpkgs.lib.nixosSystem { };\n",
]
shape = rng.choice([0, 1, 2])
if shape == 1: # newlines get collapsed below, so line comments would swallow code
junk = [j for j in junk if not j.startswith("#")]
nm = [f"h{i}" for i in range(rng.randint(0, 4))]
entries = []
for n in nm:
body = " ".join(rng.choice(junk) for _ in range(rng.randint(0, 3)))
entries.append(f" {n} = nixpkgs.lib.nixosSystem {{ modules = [ ./hosts/{n} ]; {body}\n }};\n")
sep = rng.choice(["\n", "\n\n", "\r\n"])
inner = sep.join(entries)
if shape == 0:
src = f"{{\n nixosConfigurations = {{\n{inner} }};\n}}\n"
elif shape == 1:
src = f"{{ nixosConfigurations = {{ {re.sub(chr(13) + '?' + chr(10), ' ', inner)} }}; }}"
else:
src = f"# {{\n{{ a = 1; outputs = {{ nixosConfigurations = {{\n{inner}}}; }}; }}"
return src, nm
class FuzzEditTests(unittest.TestCase):
def test_random_flakes(self):
rng = random.Random(42)
for i in range(800):
src, expected = random_flake(rng)
if nixflake.find_hosts(src) != [] or expected:
self.assertEqual(names(src), expected, repr(src))
template = rng.choice([None, *expected]) if expected else None
e = reg.plan_flake_edit(src, "newhost", template)
reg.verify_edit(src, e.new_src, "newhost")
ok = is_pure_insertion(src, e.new_src)
if not ok and "\n" not in src:
# One-line attrsets: the blank gap may be replaced by the new entry.
def squash(t):
return re.sub(r"\s+", "", t)
ok = is_pure_insertion(squash(src), squash(e.new_src))
self.assertTrue(ok, f"case {i}: {src!r} -> {e.new_src!r}")
class HostnameTests(unittest.TestCase):
def test_valid(self):
for n in ("a", "willow", "white-grizzly", "h1", "a" * 63):
reg.validate_hostname(n)
def test_invalid(self):
for n in ("", "-a", "a-", "1abc", "Willow", "a_b", "a.b", "../x", "a/b", "a b", "a" * 64, "in", "let", "rec", "é", "a\n", "--help"):
with self.assertRaises(reg.RegisterError, msg=repr(n)):
reg.validate_hostname(n)
class RenderTests(unittest.TestCase):
def test_braces_survive(self):
out = reg.render("@NAME@ = { a = [ \"@NAME@\" ]; };", name="x")
self.assertEqual(out, 'x = { a = [ "x" ]; };')
def test_leftover_token_is_a_bug(self):
with self.assertRaises(RuntimeError):
reg.render("@NAME@ @OTHER@", name="x")
def test_real_templates_render_and_are_brace_balanced(self):
# This is the exact regression for the reported KeyError.
for t in (reg.DEFAULT_NIX_TEMPLATE, reg.PLACEHOLDER_HARDWARE, reg.DEFAULT_FLAKE_ENTRY):
out = reg.render(t, name="willow", i=" ")
self.assertTrue(nixflake.braces_balanced(out))
self.assertNotRegex(out, r"@[A-Z_]+@")
self.assertIn('polkitPolicyOwners = [ "alex" ];', reg.render(reg.DEFAULT_NIX_TEMPLATE, name="willow"))
def test_hardware_placeholder_marker_matches_capture_script(self):
cap = (SCRIPTS / "capture-hardware.sh").read_text()
self.assertIn(reg.HARDWARE_PLACEHOLDER_MARKER, cap)
self.assertIn(reg.HARDWARE_PLACEHOLDER_MARKER, reg.render(reg.PLACEHOLDER_HARDWARE, name="x"))
class RepoCase(unittest.TestCase):
"""Runs register-host.main() against a throwaway repo."""
def setUp(self):
self._td = tempfile.TemporaryDirectory()
self.addCleanup(self._td.cleanup)
self.repo = Path(self._td.name)
(self.repo / "flake.nix").write_text(BASIC)
for m in ("core", "plasma", "security"):
(self.repo / "modules").mkdir(exist_ok=True)
(self.repo / "modules" / f"{m}.nix").write_text("{ }")
def run_reg(self, *argv: str) -> tuple[int, str]:
err = io.StringIO()
with redirect_stderr(err), redirect_stdout(io.StringIO()):
try:
code = reg.main([*argv, "--repo-root", str(self.repo)] if "--" not in argv else list(argv))
except SystemExit as e: # argparse
code = int(e.code or 0)
return code, err.getvalue()
@property
def flake(self) -> str:
return (self.repo / "flake.nix").read_text()
class RegisterEndToEnd(RepoCase):
def test_success(self):
code, err = self.run_reg("willow")
self.assertEqual(code, 0, err)
self.assertEqual(names(self.flake), ["alpha", "beta", "willow"])
d = self.repo / "hosts" / "willow"
self.assertIn('networking.hostName = "willow";', (d / "default.nix").read_text())
self.assertIn("PLACEHOLDER hardware.nix", (d / "hardware.nix").read_text())
self.assertNotIn("does not exist", err) # modules/ present in this fixture
def test_second_registration_of_same_host_refused_and_changes_nothing(self):
self.assertEqual(self.run_reg("willow")[0], 0)
before = self.flake
code, err = self.run_reg("willow")
self.assertEqual(code, 1)
self.assertEqual(self.flake, before)
def test_dry_run_writes_nothing(self):
before = self.flake
code, err = self.run_reg("willow", "--dry-run")
self.assertEqual(code, 0)
self.assertEqual(self.flake, before)
self.assertFalse((self.repo / "hosts").exists())
self.assertIn("dry-run", err)
def test_dry_run_still_validates(self):
code, err = self.run_reg("alpha", "--dry-run")
self.assertEqual(code, 1)
self.assertIn("already defined", err)
def test_invalid_names_rejected_without_touching_anything(self):
before = self.flake
for bad in ("../evil", "Willow", "1x", "a b", "if"):
code, err = self.run_reg(bad)
self.assertEqual(code, 1, bad)
self.assertEqual(self.flake, before)
self.assertFalse((self.repo / "hosts").exists())
self.assertFalse((self.repo.parent / "evil").exists())
def test_leading_dash_name_after_double_dash(self):
err = io.StringIO()
with redirect_stderr(err):
code = reg.main(["--repo-root", str(self.repo), "--", "-rf"])
self.assertEqual(code, 1)
self.assertIn("invalid hostname '-rf'", err.getvalue())
def test_reuses_empty_dir_but_refuses_nonempty(self):
(self.repo / "hosts" / "willow").mkdir(parents=True)
self.assertEqual(self.run_reg("willow")[0], 0)
(self.repo / "hosts" / "other").mkdir()
(self.repo / "hosts" / "other" / "keep.txt").write_text("precious")
before = self.flake
code, err = self.run_reg("other")
self.assertEqual(code, 1)
self.assertIn("not empty", err)
self.assertEqual(self.flake, before)
self.assertEqual((self.repo / "hosts" / "other" / "keep.txt").read_text(), "precious")
def test_hosts_path_is_a_file(self):
(self.repo / "hosts").mkdir()
(self.repo / "hosts" / "willow").write_text("i am a file")
self.assertEqual(self.run_reg("willow")[0], 1)
self.assertEqual((self.repo / "hosts" / "willow").read_text(), "i am a file")
def test_missing_flake(self):
(self.repo / "flake.nix").unlink()
code, err = self.run_reg("willow")
self.assertEqual(code, 1)
self.assertIn("flake.nix not found", err)
def test_flake_without_configurations(self):
(self.repo / "flake.nix").write_text("{ outputs = { }; }")
code, err = self.run_reg("willow")
self.assertEqual(code, 1)
self.assertIn("nixosConfigurations", err)
self.assertFalse((self.repo / "hosts").exists())
def test_invalid_utf8_flake(self):
(self.repo / "flake.nix").write_bytes(b"{ a = \xff\xfe; }")
code, err = self.run_reg("willow")
self.assertEqual(code, 1)
self.assertIn("UTF-8", err)
def test_template_options(self):
self.assertEqual(self.run_reg("g1", "--template", "beta")[0], 0)
self.assertEqual(self.run_reg("g2", "--no-template")[0], 0)
self.assertEqual(self.run_reg("g3", "--template", "nope")[0], 1)
self.assertEqual(self.run_reg("g4", "--template", "alpha", "--no-template")[0], 2)
self.assertEqual(names(self.flake), ["alpha", "beta", "g1", "g2"])
def test_crlf_flake_stays_crlf(self):
(self.repo / "flake.nix").write_bytes(BASIC.replace("\n", "\r\n").encode())
self.assertEqual(self.run_reg("willow")[0], 0)
raw = (self.repo / "flake.nix").read_bytes()
self.assertNotRegex(raw, rb"(?<!\r)\n")
def test_preserves_mode_and_symlink(self):
real = self.repo / "real-flake.nix"
(self.repo / "flake.nix").rename(real)
real.chmod(0o640)
(self.repo / "flake.nix").symlink_to(real)
self.assertEqual(self.run_reg("willow")[0], 0)
self.assertTrue((self.repo / "flake.nix").is_symlink(), "symlink was replaced by a regular file")
self.assertEqual(stat.S_IMODE(real.stat().st_mode), 0o640)
self.assertIn("willow", real.read_text())
def test_no_temp_files_left_behind(self):
self.run_reg("willow")
self.assertEqual([p.name for p in self.repo.iterdir() if p.name.endswith(".tmp")], [])
class RollbackTests(RepoCase):
def test_flake_write_failure_rolls_everything_back(self):
before = self.flake
with mock.patch.object(reg, "atomic_replace", side_effect=OSError(28, "No space left on device")):
code, err = self.run_reg("willow")
self.assertEqual(code, 1)
self.assertIn("No space left", err)
self.assertEqual(self.flake, before)
self.assertFalse((self.repo / "hosts" / "willow").exists(), "scaffold dir not cleaned up")
self.assertIn("rolled back", err)
def test_rollback_keeps_preexisting_empty_dir(self):
d = self.repo / "hosts" / "willow"
d.mkdir(parents=True)
with mock.patch.object(reg, "atomic_replace", side_effect=OSError("boom")):
self.assertEqual(self.run_reg("willow")[0], 1)
self.assertTrue(d.is_dir())
self.assertEqual(list(d.iterdir()), [])
def test_second_file_failure_removes_first(self):
real_create = reg.create_new_file
calls = {"n": 0}
def flaky(path, data):
calls["n"] += 1
if calls["n"] == 2:
raise OSError("disk on fire")
real_create(path, data)
before = self.flake
with mock.patch.object(reg, "create_new_file", side_effect=flaky):
self.assertEqual(self.run_reg("willow")[0], 1)
self.assertFalse((self.repo / "hosts" / "willow").exists())
self.assertEqual(self.flake, before)
def test_keyboard_interrupt_rolls_back_and_exits_130(self):
before = self.flake
with mock.patch.object(reg, "atomic_replace", side_effect=KeyboardInterrupt):
code, _ = self.run_reg("willow")
self.assertEqual(code, 130)
self.assertFalse((self.repo / "hosts" / "willow").exists())
self.assertEqual(self.flake, before)
def test_atomic_replace_cleans_its_temp_file_on_failure(self):
target = self.repo / "x.nix"
target.write_text("old")
with mock.patch.object(os, "replace", side_effect=OSError("nope")):
with self.assertRaises(OSError):
reg.atomic_replace(target, "new")
self.assertEqual(target.read_text(), "old")
self.assertEqual([p.name for p in self.repo.glob(".x.nix.*")], [])
class NixParseCheckTests(RepoCase):
def _fake_nix(self, exit_code: int, msg: str) -> str:
bindir = self.repo / "fakebin"
bindir.mkdir(exist_ok=True)
exe = bindir / "nix-instantiate"
exe.write_text(f"#!/bin/sh\necho '{msg}' >&2\nexit {exit_code}\n")
exe.chmod(0o755)
return str(bindir)
def test_parse_failure_blocks_all_writes(self):
before = self.flake
with mock.patch.dict(os.environ, {"PATH": self._fake_nix(1, "error: syntax error, unexpected '}'") + os.pathsep + os.environ["PATH"]}):
code, err = self.run_reg("willow")
self.assertEqual(code, 1)
self.assertIn("would not parse", err)
self.assertIn("syntax error", err)
self.assertEqual(self.flake, before)
self.assertFalse((self.repo / "hosts").exists())
def test_parse_success_allows_write(self):
with mock.patch.dict(os.environ, {"PATH": self._fake_nix(0, "") + os.pathsep + os.environ["PATH"]}):
self.assertEqual(self.run_reg("willow")[0], 0)
def test_absent_nix_is_fine(self):
with mock.patch.dict(os.environ, {"PATH": "/nonexistent"}):
reg.nix_parse_check("{ }") # must not raise
class ListHostsTests(RepoCase):
def test_lists_in_order(self):
out = io.StringIO()
with redirect_stdout(out):
self.assertEqual(lh.main([str(self.repo / "flake.nix")]), 0)
self.assertEqual(out.getvalue().split(), ["alpha", "beta"])
def test_errors(self):
with redirect_stderr(io.StringIO()) as err:
self.assertEqual(lh.main([str(self.repo / "nope.nix")]), 1)
(self.repo / "bad.nix").write_text("{ }")
self.assertEqual(lh.main([str(self.repo / "bad.nix")]), 1)
(self.repo / "bin.nix").write_bytes(b"\xff\xff")
self.assertEqual(lh.main([str(self.repo / "bin.nix")]), 1)
self.assertIn("nixosConfigurations", err.getvalue())
def test_empty_block_warns_but_succeeds(self):
(self.repo / "e.nix").write_text("{ nixosConfigurations = { }; }")
with redirect_stderr(io.StringIO()) as err, redirect_stdout(io.StringIO()) as out:
self.assertEqual(lh.main([str(self.repo / "e.nix")]), 0)
self.assertEqual(out.getvalue(), "")
self.assertIn("no hosts", err.getvalue())
class CliSubprocess(RepoCase):
"""Exercise the real executables the way `just` does."""
def test_executable_bits_and_shebangs(self):
for f in ("register-host.py", "list-hosts.py"):
p = SCRIPTS / f
self.assertTrue(os.access(p, os.X_OK), f)
self.assertEqual(p.read_text().splitlines()[0], "#!/usr/bin/env python3")
def test_run_from_another_cwd_via_symlink(self):
import subprocess
link = self.repo / "linked-list-hosts"
link.symlink_to(SCRIPTS / "list-hosts.py")
r = subprocess.run([str(link), str(self.repo / "flake.nix")], capture_output=True, text=True, cwd="/")
self.assertEqual(r.returncode, 0, r.stderr)
self.assertEqual(r.stdout.split(), ["alpha", "beta"])
def test_register_via_subprocess_reproduces_just_invocation(self):
import subprocess
r = subprocess.run(
[str(SCRIPTS / "register-host.py"), "--repo-root", str(self.repo), "--", "willow"],
capture_output=True, text=True,
)
self.assertEqual(r.returncode, 0, r.stderr)
self.assertNotIn("Traceback", r.stderr)
if __name__ == "__main__":
unittest.main(verbosity=2)
+9
View File
@@ -0,0 +1,9 @@
#!/usr/bin/env bash
# Test driver: load make-usb.sh as a library (its main is guarded), swap the
# two functions that need real privileges / a real /dev node, then run main
# exactly as a user would.
# shellcheck source=../make-usb.sh
source "${SCRIPTS:?}/make-usb.sh"
is_block_device() { [[ -e "$1" ]]; }
ensure_root() { :; } # tests never need (or want) a real sudo
main "$@"