feat: improve scripts and write tests
This commit is contained in:
32 files changed
+3817
-723
No files matched your search
@@ -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))
|
||||
}
|
||||
@@ -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()
|
||||
Executable
+38
@@ -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"
|
||||
Executable
+6
@@ -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
|
||||
Executable
+10
@@ -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
|
||||
Executable
+2
@@ -0,0 +1,2 @@
|
||||
#!/usr/bin/env bash
|
||||
printf '%s\n' "${FAKE_DMESG:-}"
|
||||
Executable
+16
@@ -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"
|
||||
Executable
+43
@@ -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"
|
||||
Executable
+5
@@ -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:"* ]]
|
||||
Executable
+19
@@ -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
|
||||
Executable
+7
@@ -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"
|
||||
Executable
+20
@@ -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"
|
||||
Executable
+3
@@ -0,0 +1,3 @@
|
||||
#!/usr/bin/env bash
|
||||
echo "sudo $*" >> "${FAKE_SUDO_LOG:-/dev/null}"
|
||||
exec "$@"
|
||||
Executable
+5
@@ -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"
|
||||
Executable
+2
@@ -0,0 +1,2 @@
|
||||
#!/usr/bin/env bash
|
||||
echo "wipefs $*" >> "${FAKE_OPS_LOG:-/dev/null}"
|
||||
Executable
+170
@@ -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:-}"
|
||||
Executable
+186
@@ -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:-}"
|
||||
Executable
+217
@@ -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:-}"
|
||||
Executable
+129
@@ -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:-}"
|
||||
Executable
+389
@@ -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:-}"
|
||||
@@ -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)
|
||||
Executable
+9
@@ -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 "$@"
|
||||
Reference in new issue
Block a user