File indexing completed on 2026-11-20 09:34:02
0001 """Offline tests of runner mechanics only; fake commands do not validate ROOT."""
0002 import json
0003 import os
0004 from pathlib import Path
0005 import subprocess
0006 import sys
0007 import tempfile
0008 import time
0009 import unittest
0010
0011 RUNNER = Path(__file__).resolve().with_name("run.py")
0012 VALIDATOR = Path(__file__).resolve().with_name("validate.sh")
0013 EXPECTED_REJECTION = "FAIL: ROOT write / calibration: exit 1; expected marker 'LFHCAL_SMOKE_OK: write'"
0014 STANDARD_EXECUTABLES = [
0015 "Convert", "DataPrep", "CalibrateData", "DataAna", "Display",
0016 "CompareCalib", "CompareAna", "CompareInjection", "HGCROCStudy",
0017 "CompareWaveform",
0018 ]
0019 DECODER_EXECUTABLES = [
0020 "HGCROC_Conversion", "ParseCalibSamples", "CompareHGCROCCalib",
0021 "EvaluateRecoEffi", "h2g_run",
0022 ]
0023
0024
0025 class RunnerTests(unittest.TestCase):
0026 def setUp(self):
0027 self.temp = tempfile.TemporaryDirectory(prefix="smoke runner tests ")
0028 self.addCleanup(self.temp.cleanup)
0029 self.directory = Path(self.temp.name)
0030 self.build = self.directory / "build artifacts"
0031 self.build.mkdir()
0032 self.calls = self.directory / "calls.jsonl"
0033 self.env = dict(os.environ, SMOKE_TEST_CALLS=str(self.calls))
0034 for name in ("libLFHCAL.so", "libLFHCAL_rdict.pcm", "libLFHCAL.rootmap"):
0035 (self.build / name).write_text("fixture artifact, not a real library\n")
0036 script = f"#!{sys.executable}\n" + '''import json, os, pathlib, subprocess, sys, time
0037 name = pathlib.Path(sys.argv[0]).name
0038 with open(os.environ["SMOKE_TEST_CALLS"], "a") as stream:
0039 stream.write(json.dumps({"name": name, "args": sys.argv[1:], "cwd": os.getcwd(),
0040 "mode": os.environ.get("LFHCAL_SMOKE_MODE")}) + "\\n")
0041 if name == os.environ.get("SMOKE_TEST_CHILD_HANG"):
0042 child_code = "import pathlib, time; time.sleep(0.8); pathlib.Path(" + repr(os.environ["SMOKE_TEST_CHILD_MARKER"]) + ").touch()"
0043 subprocess.Popen([sys.executable, "-c", child_code])
0044 time.sleep(5)
0045 if name == os.environ.get("SMOKE_TEST_HANG"):
0046 time.sleep(5)
0047 if name == os.environ.get("SMOKE_TEST_FAIL"):
0048 print("injected command failure")
0049 sys.exit(17)
0050 if name == os.environ.get("SMOKE_TEST_EMPTY"):
0051 sys.exit(0)
0052 if name in ''' + repr(STANDARD_EXECUTABLES + DECODER_EXECUTABLES) + ''':
0053 print("Usage: " + name)
0054 elif name == "root":
0055 print("LFHCAL_SMOKE_OK: " + os.environ["LFHCAL_SMOKE_MODE"])
0056 else:
0057 print("fixture-version")
0058 '''
0059 for name in (*STANDARD_EXECUTABLES, *DECODER_EXECUTABLES,
0060 "root", "root-config", "yall-run"):
0061 path = self.build / ("h2g_decode/h2g_run" if name == "h2g_run" else name)
0062 path.parent.mkdir(parents=True, exist_ok=True)
0063 path.write_text(script)
0064 path.chmod(0o755)
0065
0066 def run_suite(self, *extra, layout=None):
0067 return subprocess.run([sys.executable, str(RUNNER),
0068 *(layout or ["--build-dir", str(self.build)]),
0069 "--root", str(self.build / "root"),
0070 "--root-config", str(self.build / "root-config"), *extra],
0071 env=self.env, text=True, capture_output=True)
0072
0073 def recorded(self):
0074 return [json.loads(line) for line in self.calls.read_text().splitlines()]
0075
0076 def test_default_checks_are_bounded_and_do_not_run_yall(self):
0077 result = self.run_suite()
0078 self.assertEqual(result.returncode, 0, result.stdout + result.stderr)
0079 calls = self.recorded()
0080 self.assertEqual([row["name"] for row in calls],
0081 ["root-config", *STANDARD_EXECUTABLES, "root", "root"])
0082 self.assertEqual(calls[0]["args"], ["--version"])
0083 standard_calls = calls[1:1 + len(STANDARD_EXECUTABLES)]
0084 self.assertTrue(all(row["args"] == ["-h"] for row in standard_calls))
0085 self.assertEqual([row["mode"] for row in calls[-2:]], ["write", "read"])
0086 self.assertEqual(calls[-1]["args"][:4], ["-n", "-l", "-b", "-q"])
0087 self.assertEqual(len({row["cwd"] for row in calls}), 1)
0088 self.assertFalse(Path(calls[0]["cwd"]).exists(), "temporary fixture directory leaked")
0089 self.assertIn("NOT REQUESTED: decoder-enabled", result.stdout)
0090 self.assertIn("NOT REQUESTED: Yall", result.stdout)
0091
0092 def test_decoder_checks_are_explicit_and_bounded(self):
0093 result = self.run_suite("--decoder")
0094 self.assertEqual(result.returncode, 0, result.stdout + result.stderr)
0095 calls = self.recorded()
0096 self.assertEqual([row["name"] for row in calls],
0097 ["root-config", *STANDARD_EXECUTABLES,
0098 *DECODER_EXECUTABLES, "root", "root"])
0099 startup_calls = calls[1:1 + len(STANDARD_EXECUTABLES) + len(DECODER_EXECUTABLES)]
0100 self.assertTrue(all(row["args"] == ["-h"] for row in startup_calls))
0101 self.assertNotIn("NOT REQUESTED: decoder-enabled", result.stdout)
0102
0103 def test_requested_decoder_component_must_exist(self):
0104 (self.build / "ParseCalibSamples").unlink()
0105 result = self.run_suite("--decoder")
0106 self.assertEqual(result.returncode, 1)
0107 self.assertIn("ParseCalibSamples", result.stderr)
0108 self.assertFalse(self.calls.exists())
0109
0110 def test_yall_is_version_only(self):
0111 result = self.run_suite("--yall", str(self.build / "yall-run"))
0112 self.assertEqual(result.returncode, 0, result.stdout + result.stderr)
0113 self.assertEqual(self.recorded()[-1]["args"], ["--version"])
0114 self.assertEqual(self.recorded()[-1]["name"], "yall-run")
0115
0116 def test_nonzero_command_fails_and_stops(self):
0117 self.env["SMOKE_TEST_FAIL"] = "Convert"
0118 result = self.run_suite()
0119 self.assertEqual(result.returncode, 1)
0120 self.assertIn("exit 17", result.stderr)
0121 self.assertEqual([row["name"] for row in self.recorded()], ["root-config", "Convert"])
0122
0123 def test_zero_exit_without_help_text_fails_and_stops(self):
0124 self.env["SMOKE_TEST_EMPTY"] = "Display"
0125 result = self.run_suite()
0126 self.assertEqual(result.returncode, 1)
0127 self.assertIn("Display startup: exit 0; expected marker 'Usage:'", result.stderr)
0128 self.assertEqual([row["name"] for row in self.recorded()],
0129 ["root-config", *STANDARD_EXECUTABLES[:5]])
0130
0131 def test_zero_exit_without_root_success_marker_is_failure(self):
0132 self.env["SMOKE_TEST_EMPTY"] = "root"
0133 result = self.run_suite()
0134 self.assertEqual(result.returncode, 1)
0135 self.assertIn("expected marker", result.stderr)
0136
0137 def test_empty_version_fails(self):
0138 for name, extra in (("root-config", []), ("yall-run", ["--yall", str(self.build / "yall-run")])):
0139 with self.subTest(name=name):
0140 self.env["SMOKE_TEST_EMPTY"] = name
0141 result = self.run_suite(*extra)
0142 self.assertEqual(result.returncode, 1)
0143 self.assertIn("empty output", result.stderr)
0144
0145 def test_timeout_is_failure(self):
0146 self.env["SMOKE_TEST_HANG"] = "Convert"
0147 result = self.run_suite("--timeout", "0.3")
0148 self.assertEqual(result.returncode, 1)
0149 self.assertIn("timed out", result.stderr)
0150
0151 @unittest.skipUnless(os.name == "posix", "process-group cleanup is POSIX-specific")
0152 def test_timeout_terminates_command_descendants(self):
0153 marker = self.directory / "child-survived"
0154 self.env["SMOKE_TEST_CHILD_HANG"] = "root"
0155 self.env["SMOKE_TEST_CHILD_MARKER"] = str(marker)
0156 result = self.run_suite("--timeout", "0.3")
0157 self.assertEqual(result.returncode, 1)
0158 self.assertIn("timed out", result.stderr)
0159 time.sleep(0.9)
0160 self.assertFalse(marker.exists(), "timed-out command left its child running")
0161
0162 def test_missing_dictionary_fails_before_execution(self):
0163 (self.build / "libLFHCAL_rdict.pcm").unlink()
0164 result = self.run_suite()
0165 self.assertEqual(result.returncode, 1)
0166 self.assertIn("dictionary artifact", result.stderr)
0167 self.assertFalse(self.calls.exists())
0168
0169 def test_missing_executable_fails(self):
0170 (self.build / "DataPrep").unlink()
0171 result = self.run_suite()
0172 self.assertEqual(result.returncode, 1)
0173 self.assertIn("Executable not found", result.stderr)
0174
0175 def test_explicit_layout_does_not_guess_library(self):
0176 result = self.run_suite(layout=["--bin-dir", str(self.build)])
0177 self.assertEqual(result.returncode, 2)
0178 result = self.run_suite(layout=["--bin-dir", str(self.build),
0179 "--library", str(self.build / "libLFHCAL.so")])
0180 self.assertEqual(result.returncode, 0, result.stdout + result.stderr)
0181
0182 def test_invalid_timeout_rejected(self):
0183 for value in ("0", "-1", "nan", "inf"):
0184 with self.subTest(value=value):
0185 result = self.run_suite("--timeout", value)
0186 self.assertEqual(result.returncode, 2)
0187
0188
0189 class ValidationHelperTests(unittest.TestCase):
0190 def setUp(self):
0191 self.temp = tempfile.TemporaryDirectory(prefix="smoke validator tests ")
0192 self.addCleanup(self.temp.cleanup)
0193 self.directory = Path(self.temp.name)
0194 self.state = self.directory / "calls"
0195 python = self.directory / "python3"
0196 python.write_text("""#!/bin/sh
0197 if [ "$VALIDATE_EXPECT_DECODER" = 1 ]; then
0198 found=0
0199 for arg in "$@"; do
0200 if [ "$arg" = --decoder ]; then
0201 found=1
0202 fi
0203 done
0204 if [ "$found" -ne 1 ]; then
0205 echo "missing forwarded --decoder" >&2
0206 exit 9
0207 fi
0208 fi
0209 count=0
0210 if [ -f "$VALIDATE_TEST_STATE" ]; then
0211 count=$(cat "$VALIDATE_TEST_STATE")
0212 fi
0213 count=$((count + 1))
0214 echo "$count" >"$VALIDATE_TEST_STATE"
0215 if [ "$count" -eq 2 ] && [ "$VALIDATE_EXPECT_EXTERNAL_FALSE" = 1 ]; then
0216 root_command=
0217 next_is_root=0
0218 for arg in "$@"; do
0219 if [ "$next_is_root" -eq 1 ]; then
0220 root_command=$arg
0221 next_is_root=0
0222 elif [ "$arg" = --root ]; then
0223 next_is_root=1
0224 fi
0225 done
0226 case "$root_command" in
0227 /*) ;;
0228 *) echo "injected ROOT command is not an external path: $root_command" >&2; exit 8 ;;
0229 esac
0230 if [ ! -x "$root_command" ]; then
0231 echo "injected ROOT command is not executable: $root_command" >&2
0232 exit 8
0233 fi
0234 fi
0235 if [ "$count" -eq 1 ]; then
0236 echo "ordinary smoke output"
0237 if [ "$VALIDATE_TEST_CASE" = baseline_failure ]; then
0238 echo "genuine baseline failure" >&2
0239 exit 7
0240 fi
0241 exit 0
0242 fi
0243 case "$VALIDATE_TEST_CASE" in
0244 expected)
0245 echo "FAIL: ROOT write / calibration: exit 1; expected marker 'LFHCAL_SMOKE_OK: write'" >&2
0246 exit 1 ;;
0247 unexpected_success)
0248 echo "injected command unexpectedly passed"
0249 exit 0 ;;
0250 wrong_stage)
0251 echo "FAIL: Convert startup: exit 1; expected marker 'Usage:'" >&2
0252 exit 1 ;;
0253 wrong_exit)
0254 echo "FAIL: ROOT write / calibration: exit 1; expected marker 'LFHCAL_SMOKE_OK: write'" >&2
0255 exit 2 ;;
0256 timeout)
0257 echo "FAIL: ROOT write / calibration: timed out after 0.1 seconds" >&2
0258 exit 1 ;;
0259 esac
0260 """)
0261 python.chmod(0o755)
0262
0263 def run_helper(self, case, *extra, expect_external_false=False):
0264 env = dict(os.environ,
0265 PATH=f"{self.directory}{os.pathsep}{os.environ.get('PATH', '')}",
0266 VALIDATE_TEST_STATE=str(self.state),
0267 VALIDATE_TEST_CASE=case,
0268 VALIDATE_EXPECT_DECODER="1" if "--decoder" in extra else "0",
0269 VALIDATE_EXPECT_EXTERNAL_FALSE="1" if expect_external_false else "0")
0270 return subprocess.run([str(VALIDATOR), "--build-dir", "build", "--timeout", "60", *extra],
0271 env=env, text=True, capture_output=True)
0272
0273 def test_expected_rejection_is_accepted(self):
0274 result = self.run_helper("expected")
0275 self.assertEqual(result.returncode, 0, result.stdout + result.stderr)
0276 self.assertIn("NORMAL SMOKE TESTS", result.stdout)
0277 self.assertIn("ERROR-DETECTION TEST: deliberately forcing ROOT to fail", result.stdout)
0278 self.assertIn("PASS: expected error detected", result.stdout)
0279 self.assertNotIn(EXPECTED_REJECTION, result.stdout + result.stderr)
0280 self.assertEqual(self.state.read_text().strip(), "2")
0281
0282 def test_decoder_selection_is_forwarded_to_both_runs(self):
0283 result = self.run_helper("expected", "--decoder")
0284 self.assertEqual(result.returncode, 0, result.stdout + result.stderr)
0285 self.assertEqual(self.state.read_text().strip(), "2")
0286
0287 def test_external_false_executable_is_forwarded(self):
0288 result = self.run_helper("expected", expect_external_false=True)
0289 self.assertEqual(result.returncode, 0, result.stdout + result.stderr)
0290 self.assertEqual(self.state.read_text().strip(), "2")
0291
0292 def test_unexpected_success_is_rejected(self):
0293 result = self.run_helper("unexpected_success")
0294 self.assertEqual(result.returncode, 1)
0295 self.assertIn("got exit 0", result.stderr)
0296 self.assertIn("injected command unexpectedly passed", result.stderr)
0297
0298 def test_wrong_stage_is_rejected(self):
0299 result = self.run_helper("wrong_stage")
0300 self.assertEqual(result.returncode, 1)
0301 self.assertIn("Convert startup", result.stderr)
0302
0303 def test_wrong_exit_is_rejected(self):
0304 result = self.run_helper("wrong_exit")
0305 self.assertEqual(result.returncode, 1)
0306 self.assertIn("got exit 2", result.stderr)
0307 self.assertIn(EXPECTED_REJECTION, result.stderr)
0308
0309 def test_timeout_is_rejected(self):
0310 result = self.run_helper("timeout")
0311 self.assertEqual(result.returncode, 1)
0312 self.assertIn("timed out after 0.1 seconds", result.stderr)
0313
0314 def test_baseline_failure_stops_before_injection_and_stays_visible(self):
0315 result = self.run_helper("baseline_failure")
0316 self.assertEqual(result.returncode, 7)
0317 self.assertIn("ordinary smoke output", result.stdout)
0318 self.assertIn("genuine baseline failure", result.stderr)
0319 self.assertNotIn("ERROR-DETECTION TEST", result.stdout + result.stderr)
0320 self.assertEqual(self.state.read_text().strip(), "1")
0321
0322
0323 if __name__ == "__main__":
0324 unittest.main()