163 lines
7.3 KiB
Python
163 lines
7.3 KiB
Python
#!/usr/bin/env python3
|
|
"""Non-destructive checks for the live ISO owner form and target handoff."""
|
|
import os
|
|
from pathlib import Path
|
|
import subprocess
|
|
import tempfile
|
|
import unittest
|
|
|
|
|
|
HELPER = Path(__file__).resolve().parents[1] / "lib" / "installer-owner.sh"
|
|
|
|
|
|
def bash(script: str, *, input_text: str = "", env: dict | None = None):
|
|
return subprocess.run(
|
|
["bash", "-c", f'source "{HELPER}"\n{script}'],
|
|
input=input_text,
|
|
text=True,
|
|
capture_output=True,
|
|
env={**os.environ, **(env or {})},
|
|
check=False,
|
|
)
|
|
|
|
|
|
class InstallerOwnerTests(unittest.TestCase):
|
|
def test_no_wifi_card_can_be_skipped_after_yes(self):
|
|
result = bash(
|
|
"""
|
|
installer_wired_link() { return 1; }
|
|
systemctl() { return 0; }
|
|
nmcli() {
|
|
case "$*" in
|
|
'radio wifi on') return 0 ;;
|
|
'-t -f DEVICE,TYPE device status') printf 'eth0:ethernet\\n' ;;
|
|
esac
|
|
}
|
|
installer_collect_wifi && printf 'CONTINUED\\n'
|
|
""",
|
|
input_text="y\n",
|
|
)
|
|
self.assertEqual(result.returncode, 0, result.stderr)
|
|
self.assertIn("No supported Wi-Fi adapter", result.stderr)
|
|
self.assertIn("CONTINUED", result.stdout)
|
|
|
|
def test_wifi_scan_selection_and_failed_connection_skip(self):
|
|
result = bash(
|
|
"""
|
|
installer_wired_link() { return 1; }
|
|
systemctl() { return 0; }
|
|
nmcli() {
|
|
case "$*" in
|
|
'radio wifi on'|'device wifi rescan ifname wlan0') return 0 ;;
|
|
'-t -f DEVICE,TYPE device status') printf 'wlan0:wifi\\n' ;;
|
|
'-t --escape no -f SSID device wifi list ifname wlan0')
|
|
printf 'Home Network\\nGuest\\n' ;;
|
|
'--ask device wifi connect Home Network ifname wlan0 name archipelago-install-'*)
|
|
printf 'SELECTED=Home Network\\n' >&2; return 1 ;;
|
|
'connection delete '*) return 0 ;;
|
|
*) return 1 ;;
|
|
esac
|
|
}
|
|
installer_collect_wifi && printf 'CONTINUED\\n'
|
|
""",
|
|
input_text="y\n1\ns\n",
|
|
)
|
|
self.assertEqual(result.returncode, 0, result.stderr)
|
|
self.assertIn("1. Home Network", result.stdout)
|
|
self.assertIn("SELECTED=Home Network", result.stderr)
|
|
self.assertIn("Wi-Fi connection failed", result.stderr)
|
|
self.assertIn("Continuing without Wi-Fi", result.stdout)
|
|
self.assertIn("CONTINUED", result.stdout)
|
|
|
|
def test_account_and_hostname_reject_defaults_and_unsafe_names(self):
|
|
result = bash(
|
|
"""
|
|
for name in alice owner-2; do installer_valid_user "$name" || exit 1; done
|
|
for name in root archipelago nobody a 'A-laptop' 'a;touch /tmp/no' ''; do
|
|
installer_valid_user "$name" && exit 2
|
|
done
|
|
for name in alice-node archipelago-a1b2c3; do
|
|
installer_valid_hostname "$name" || exit 3
|
|
done
|
|
for name in archipelago localhost '-bad' 'bad-' 'bad.name' ''; do
|
|
installer_valid_hostname "$name" && exit 4
|
|
done
|
|
true
|
|
"""
|
|
)
|
|
self.assertEqual(result.returncode, 0, result.stderr)
|
|
|
|
def test_form_keeps_password_off_screen_and_fails_closed_on_eof(self):
|
|
script = """
|
|
clear() { :; }
|
|
installer_collect_wifi() { :; }
|
|
installer_collect_owner || exit 1
|
|
printf 'OWNER=%s HOST=%s\\n' "$INSTALLER_OWNER_USER" "$INSTALLER_OWNER_HOSTNAME"
|
|
"""
|
|
secret = "synthetic-Secret-123!"
|
|
result = bash(script, input_text=f"alice\nalice-node\n{secret}\n{secret}\ny\n")
|
|
self.assertEqual(result.returncode, 0, result.stderr)
|
|
self.assertIn("OWNER=alice HOST=alice-node", result.stdout)
|
|
self.assertNotIn(secret, result.stdout + result.stderr)
|
|
result = bash(script, input_text="alice\n")
|
|
self.assertNotEqual(result.returncode, 0)
|
|
result = bash(script, input_text=f"alice\nalice-node\nweakpassword\nweakpassword\n{secret}\n{secret}\ny\n")
|
|
self.assertEqual(result.returncode, 0, result.stderr)
|
|
self.assertIn("strength requirements", result.stdout)
|
|
|
|
def test_target_gets_owner_hostname_and_private_wifi_profile(self):
|
|
with tempfile.TemporaryDirectory() as directory:
|
|
root = Path(directory)
|
|
target = root / "target"
|
|
(target / "etc").mkdir(parents=True)
|
|
profile = root / "wifi.nmconnection"
|
|
profile.write_text("[connection]\nid=test\nuuid=12345678-1234-1234-1234-123456789abc\n")
|
|
result = bash(
|
|
"""
|
|
chroot() {
|
|
if [ "$2" = useradd ]; then printf '%s\\n' "$*" >> "$CAPTURE"; return 0; fi
|
|
if [ "$2" = chpasswd ]; then IFS= read -r line; printf '%s' "$line" > "$SECRET_CAPTURE"; return 0; fi
|
|
if [ "$2" = /usr/local/bin/archipelago ]; then
|
|
IFS= read -r line
|
|
printf '%s' "$line" > "$DASHBOARD_INPUT"
|
|
[ "$4" = /var/lib/archipelago ] || return 1
|
|
mkdir -p "$TARGET/var/lib/archipelago"
|
|
: > "$TARGET/var/lib/archipelago/installer-password.json"
|
|
return 0
|
|
fi
|
|
return 1
|
|
}
|
|
chown() { :; }
|
|
INSTALLER_OWNER_USER=alice
|
|
INSTALLER_OWNER_HOSTNAME=alice-node
|
|
INSTALLER_OWNER_PASSWORD=synthetic-Secret-123!
|
|
INSTALLER_WIFI_UUID=12345678-1234-1234-1234-123456789abc
|
|
INSTALLER_WIFI_PROFILE="$PROFILE"
|
|
installer_install_owner "$TARGET"
|
|
[ -z "$INSTALLER_OWNER_PASSWORD" ]
|
|
""",
|
|
env={
|
|
"TARGET": str(target),
|
|
"PROFILE": str(profile),
|
|
"CAPTURE": str(root / "calls"),
|
|
"SECRET_CAPTURE": str(root / "secret-input"),
|
|
"DASHBOARD_INPUT": str(root / "dashboard-input"),
|
|
},
|
|
)
|
|
self.assertEqual(result.returncode, 0, result.stderr)
|
|
self.assertEqual((target / "etc/hostname").read_text(), "alice-node\n")
|
|
self.assertIn("127.0.1.1 alice-node", (target / "etc/hosts").read_text())
|
|
self.assertIn("useradd -m -s /bin/bash -G sudo -- alice", (root / "calls").read_text())
|
|
self.assertEqual((root / "secret-input").read_text(), "alice:synthetic-Secret-123!")
|
|
self.assertEqual((root / "dashboard-input").read_text(), "synthetic-Secret-123!")
|
|
self.assertEqual((target / "etc/archipelago/owner-account").read_text(), "alice\n")
|
|
self.assertTrue((target / "var/lib/archipelago/installer-password.json").is_file())
|
|
self.assertNotIn("synthetic-Secret-123!", result.stdout + result.stderr)
|
|
installed = target / "etc/NetworkManager/system-connections/archipelago-wifi.nmconnection"
|
|
self.assertEqual(installed.read_text(), profile.read_text())
|
|
self.assertEqual(installed.stat().st_mode & 0o777, 0o600)
|
|
|
|
|
|
if __name__ == "__main__":
|
|
unittest.main()
|