forked from longtao.wu/droboticflow
89 lines
4.6 KiB
Python
89 lines
4.6 KiB
Python
import importlib.util
|
|
import contextlib
|
|
import hashlib
|
|
import io
|
|
import json
|
|
import os
|
|
import pathlib
|
|
import subprocess
|
|
import tempfile
|
|
import unittest
|
|
from unittest.mock import patch
|
|
|
|
|
|
ROOT = pathlib.Path(__file__).resolve().parent
|
|
spec = importlib.util.spec_from_file_location("node4_pilot", ROOT / "pilot.py")
|
|
pilot = importlib.util.module_from_spec(spec)
|
|
spec.loader.exec_module(pilot)
|
|
|
|
|
|
class SafetyTests(unittest.TestCase):
|
|
def test_query25_rejects_failed_small_recovery(self):
|
|
with tempfile.TemporaryDirectory() as directory:
|
|
evidence = pathlib.Path(directory) / "failed.json"
|
|
evidence.write_text(json.dumps({"result": "failed"}))
|
|
argv = ["pilot.py", "--kubeconfig", "not-used", "--output", str(pathlib.Path(directory) / "out"), "--query25", "--acceptance-file", str(evidence)]
|
|
with patch("sys.argv", argv), patch.object(pilot.subprocess, "run") as call:
|
|
with self.assertRaises(AssertionError):
|
|
pilot.main()
|
|
call.assert_not_called()
|
|
|
|
def test_query25_render_is_offline_and_uses_distinct_bounded_storage(self):
|
|
with tempfile.TemporaryDirectory() as directory:
|
|
evidence = pathlib.Path(directory) / "passed.json"
|
|
evidence.write_text(json.dumps({"result": "small-smoke-passed", "firstPodUID": "first", "secondPodUID": "second"}))
|
|
output = pathlib.Path(directory) / "out"
|
|
argv = ["pilot.py", "--kubeconfig", "not-used", "--output", str(output), "--query25", "--acceptance-file", str(evidence)]
|
|
with patch("sys.argv", argv), patch.object(pilot.subprocess, "run") as call, contextlib.redirect_stdout(io.StringIO()):
|
|
pilot.main()
|
|
call.assert_not_called()
|
|
plan = json.loads((output / "plan.json").read_text())
|
|
self.assertEqual(plan["bytes"], 25 * 1024 ** 3)
|
|
self.assertEqual(plan["acceptanceSha256"], hashlib.sha256(evidence.read_bytes()).hexdigest())
|
|
self.assertNotEqual(plan["hostPath"], pilot.PATH)
|
|
objects = json.loads((output / "objects.json").read_text())
|
|
self.assertFalse(any(obj["kind"] in ("Service", "Secret", "PersistentVolumeClaim") for obj in objects))
|
|
config = objects[-2]["data"]
|
|
self.assertIn("truncate -s 26843545600", config["init.sh"])
|
|
self.assertIn("umount /lab/data", config["init.sh"])
|
|
self.assertNotIn("umount -", config["init.sh"])
|
|
self.assertIn("--bind_ip 127.0.0.1", config["query25.sh"])
|
|
|
|
def test_boot_does_not_mark_ready_after_guard_failure(self):
|
|
command = pilot.pod()["spec"]["containers"][0]["command"][2]
|
|
with tempfile.TemporaryDirectory() as directory:
|
|
guard = pathlib.Path(directory) / "guard.sh"
|
|
guard.write_text("exit 77\n")
|
|
marker = pathlib.Path(directory) / "ready"
|
|
command = command.replace("/scripts/guard.sh", str(guard)).replace("/tmp/ready", str(marker))
|
|
p = subprocess.run(["bash", "-c", command], capture_output=True, timeout=3)
|
|
self.assertEqual(p.returncode, 77)
|
|
self.assertFalse(marker.exists())
|
|
|
|
def test_invalid_node_or_pod_identity_fails_before_host_access(self):
|
|
for node, uid in [("10.189.16.5", "00000000-0000-0000-0000-000000000000"),
|
|
("10.189.16.4", "../../kubepods.slice")]:
|
|
with self.subTest(node=node, uid=uid):
|
|
p = subprocess.run(["bash", str(ROOT / "init.sh")],
|
|
env={**os.environ, "NODE_NAME": node, "POD_UID": uid},
|
|
capture_output=True, timeout=3)
|
|
self.assertNotEqual(p.returncode, 0)
|
|
|
|
def test_rebuild_identity_uses_new_pod_and_guaranteed_qos(self):
|
|
obj = pilot.pod()
|
|
self.assertEqual(obj["spec"]["nodeName"], "10.189.16.4")
|
|
self.assertFalse(obj["spec"]["automountServiceAccountToken"])
|
|
for container in obj["spec"]["containers"] + obj["spec"]["initContainers"]:
|
|
self.assertEqual(container["resources"]["requests"], container["resources"]["limits"])
|
|
identity = next(e for e in container["env"] if e["name"] == "POD_UID")
|
|
self.assertEqual(identity["valueFrom"]["fieldRef"]["fieldPath"], "metadata.uid")
|
|
db = obj["spec"]["containers"][0]
|
|
self.assertTrue(db["securityContext"]["runAsNonRoot"])
|
|
self.assertFalse(db["securityContext"]["allowPrivilegeEscalation"])
|
|
self.assertEqual(db["securityContext"]["capabilities"]["drop"], ["ALL"])
|
|
self.assertTrue(next(v for v in db["volumeMounts"] if v["name"] == "cg")["readOnly"])
|
|
|
|
|
|
if __name__ == "__main__":
|
|
unittest.main()
|