Improved speed of tests down to ~145 seconds

Author: franporcel

modules/01-operating-room/tests/conftest.py

@@ -87,7 +87,7 @@ def proc_manager_secure(dds_env_secure):
     pm.shutdown_all()
 
 
-@pytest.fixture()
+@pytest.fixture(scope="session")
 def dds_participant(dds_env):
     """Create a lightweight DDS DomainParticipant for test observation."""
     import rti.connextdds as dds

modules/01-operating-room/tests/module01_test_support.py

@@ -135,8 +135,8 @@ def shutdown_all(self):
                     os.killpg(p.pid, signal.SIGTERM)
                 except (ProcessLookupError, PermissionError):
                     p.terminate()
-        # Give processes 3 seconds to exit gracefully
-        deadline = time.monotonic() + 3
+        # Give processes 1 second to exit gracefully
+        deadline = time.monotonic() + 1
         for p in self._children:
             remaining = max(0, deadline - time.monotonic())
             try:
@@ -272,18 +272,35 @@ def wait_for_data(reader, timeout_sec: float = 5.0, min_count: int = 1):
 
 
 def wait_for_process_ready(proc, timeout_sec: float = 5.0):
-    """Wait until *proc* survives for *timeout_sec* or exits early.
+    """Wait until *proc* produces stdout output, exits, or *timeout_sec* expires.
 
-    Polls ``proc.poll()`` every 250ms.  Returns as soon as either:
+    Returns as soon as any of these conditions is met:
+    - The process writes to stdout (indicates successful startup).
     - The process exits (caller should check ``proc.returncode``).
-    - The full *timeout_sec* elapses with the process still running (success
-      for smoke tests — the process survived its startup window).
+    - The full *timeout_sec* elapses with the process still running.
     """
-    deadline = time.monotonic() + timeout_sec
-    while time.monotonic() < deadline:
-        if proc.poll() is not None:
-            return
-        time.sleep(0.25)
+    import selectors
+
+    if proc.poll() is not None:
+        return
+
+    sel = selectors.DefaultSelector()
+    try:
+        if proc.stdout and hasattr(proc.stdout, "fileno"):
+            sel.register(proc.stdout, selectors.EVENT_READ)
+        deadline = time.monotonic() + timeout_sec
+        while time.monotonic() < deadline:
+            if proc.poll() is not None:
+                return
+            remaining = max(0, deadline - time.monotonic())
+            if sel.get_map():
+                events = sel.select(timeout=min(remaining, 0.25))
+                if events:
+                    return  # stdout has data — process started successfully
+            else:
+                time.sleep(min(remaining, 0.25))
+    finally:
+        sel.close()
 
 
 def wait_for_device_status(

modules/01-operating-room/tests/test_dds_communication.py

@@ -249,7 +249,7 @@ def test_arm_receives_motor_control(self, proc_manager, dds_participant):
             direction=SurgicalRobot.MotorDirections.INCREMENT,
         )
         writer.write(cmd)
-        time.sleep(1)
+        time.sleep(0.5)
 
         assert proc.poll() is None, "Arm crashed after receiving MotorControl"
 
@@ -419,7 +419,7 @@ def test_patient_sensor_ignores_arm_command(self, proc_manager, dds_participant)
 
         # Give time for any reaction and drain vitals
         vitals_reader.take()
-        time.sleep(1.5)
+        time.sleep(0.5)
 
         # PatientSensor should still be publishing vitals (not paused)
         fresh = wait_for_data(vitals_reader, timeout_sec=3.0, min_count=1)

modules/01-operating-room/tests/test_demo_flow.py

@@ -177,7 +177,7 @@ def test_pause_stops_vitals_then_resume_restarts(self, proc_manager, dds_partici
 
         # Drain any remaining vitals and then check no new ones arrive
         vitals_reader.take()  # drain
-        time.sleep(2)
+        time.sleep(1)
         stale = vitals_reader.take()
         valid_stale = [s for s in stale if s.info.valid]
         assert len(valid_stale) <= 1, (
@@ -284,7 +284,7 @@ def test_vitals_flow_with_security(self, proc_manager_secure, dds_env_secure):
         ps = proc_manager_secure.start_app("PatientSensor")
 
         # Wait for security handshake and DDS initialization
-        wait_for_process_ready(ps, timeout_sec=15)
+        wait_for_process_ready(ps, timeout_sec=5)
 
         if ps.poll() is not None:
             stdout = ps.stdout.read().decode(errors="replace") if ps.stdout else ""

modules/02-record-playback/tests/module02_test_support.py

@@ -147,7 +147,7 @@ def shutdown_all(self):
                     os.killpg(p.pid, signal.SIGTERM)
                 except (ProcessLookupError, PermissionError):
                     p.terminate()
-        deadline = time.monotonic() + 5
+        deadline = time.monotonic() + 2
         for p in self._children:
             remaining = max(0, deadline - time.monotonic())
             try:
@@ -164,12 +164,29 @@ def shutdown_all(self):
 
 
 def wait_for_process_ready(proc, timeout_sec: float = 5.0):
-    """Wait until *proc* survives for *timeout_sec* or exits early."""
-    deadline = time.monotonic() + timeout_sec
-    while time.monotonic() < deadline:
-        if proc.poll() is not None:
-            return
-        time.sleep(0.25)
+    """Wait until *proc* produces stdout output, exits, or *timeout_sec* expires."""
+    import selectors
+
+    if proc.poll() is not None:
+        return
+
+    sel = selectors.DefaultSelector()
+    try:
+        if proc.stdout and hasattr(proc.stdout, "fileno"):
+            sel.register(proc.stdout, selectors.EVENT_READ)
+        deadline = time.monotonic() + timeout_sec
+        while time.monotonic() < deadline:
+            if proc.poll() is not None:
+                return
+            remaining = max(0, deadline - time.monotonic())
+            if sel.get_map():
+                events = sel.select(timeout=min(remaining, 0.25))
+                if events:
+                    return
+            else:
+                time.sleep(min(remaining, 0.25))
+    finally:
+        sel.close()
 
 
 RECORDING_DIR = MODULE_DIR / "or_recording"

modules/02-record-playback/tests/test_recording.py

@@ -50,8 +50,8 @@ def test_recording_creates_database(self, proc_manager, clean_recording_dir):
             ],
             cwd=MODULE_DIR,
         )
-        # Record for ~8 seconds
-        time.sleep(8)
+        # Record for ~3 seconds
+        time.sleep(3)
 
         # Verify Recording Service is still alive
         assert rec_proc.poll() is None, (

modules/02-record-playback/tests/test_replay.py

@@ -57,7 +57,7 @@ def test_replay_produces_vitals(self, proc_manager, dds_env_dict, clean_recordin
             ],
             cwd=MODULE_DIR,
         )
-        time.sleep(8)
+        time.sleep(3)
 
         rec_proc.terminate()
         try:

modules/04-security-threat/tests/module04_test_support.py

@@ -106,7 +106,7 @@ def shutdown_all(self):
                     os.killpg(p.pid, signal.SIGTERM)
                 except (ProcessLookupError, PermissionError):
                     p.terminate()
-        deadline = time.monotonic() + 5
+        deadline = time.monotonic() + 2
         for p in self._children:
             remaining = max(0, deadline - time.monotonic())
             try:
@@ -121,12 +121,29 @@ def shutdown_all(self):
 
 
 def wait_for_process_ready(proc, timeout_sec: float = 5.0):
-    """Wait until *proc* survives for *timeout_sec* or exits early."""
-    deadline = time.monotonic() + timeout_sec
-    while time.monotonic() < deadline:
-        if proc.poll() is not None:
-            return
-        time.sleep(0.25)
+    """Wait until *proc* produces stdout output, exits, or *timeout_sec* expires."""
+    import selectors
+
+    if proc.poll() is not None:
+        return
+
+    sel = selectors.DefaultSelector()
+    try:
+        if proc.stdout and hasattr(proc.stdout, "fileno"):
+            sel.register(proc.stdout, selectors.EVENT_READ)
+        deadline = time.monotonic() + timeout_sec
+        while time.monotonic() < deadline:
+            if proc.poll() is not None:
+                return
+            remaining = max(0, deadline - time.monotonic())
+            if sel.get_map():
+                events = sel.select(timeout=min(remaining, 0.25))
+                if events:
+                    return
+            else:
+                time.sleep(min(remaining, 0.25))
+    finally:
+        sel.close()
 
 
 # ---------------------------------------------------------------------------

modules/04-security-threat/tests/test_threat_exfiltrator.py

@@ -173,7 +173,7 @@ def test_unsecure_exfiltration_succeeds(self, or_pm_nonsecure, or_env_nonsecure,
         _assert_unsecure_exfiltrator_probe_launch(threat_env)
 
         ps = or_pm_nonsecure.start_app("PatientSensor")
-        wait_for_process_ready(ps, timeout_sec=10)
+        wait_for_process_ready(ps, timeout_sec=5)
         assert ps.poll() is None, f"PatientSensor exited early with code {ps.returncode}"
 
         result = _run_exfiltrator_probe(
@@ -204,7 +204,7 @@ def test_unsecure_exfiltrator_vs_secure_or(self, or_pm_secure, or_env_secure, th
         _assert_unsecure_exfiltrator_probe_launch(threat_env)
 
         ps = or_pm_secure.start_app("PatientSensor")
-        wait_for_process_ready(ps, timeout_sec=15)
+        wait_for_process_ready(ps, timeout_sec=5)
         assert ps.poll() is None, f"PatientSensor exited early with code {ps.returncode}"
 
         result = _run_exfiltrator_probe(
@@ -222,13 +222,13 @@ def test_unsecure_exfiltrator_vs_secure_or(self, or_pm_secure, or_env_secure, th
     def test_rogue_ca_exfiltrator_blocked(self, or_pm_secure, or_env_secure, threat_env):
         """Rogue CA exfiltrator should NOT receive vitals from secured OR apps."""
         ps = or_pm_secure.start_app("PatientSensor")
-        wait_for_process_ready(ps, timeout_sec=15)
+        wait_for_process_ready(ps, timeout_sec=5)
         assert ps.poll() is None, f"PatientSensor exited early with code {ps.returncode}"
 
         result = _run_exfiltrator_probe(
             threat_env[0],
             dp_name="ThreatParticipantLibrary::dp/ThreatExfiltrator/RogueCA",
-            timeout_sec=10,
+            timeout_sec=4,
         )
         assert result["received"] == 0, (
             "Rogue CA exfiltrator should NOT receive vitals from secured OR"
@@ -237,13 +237,13 @@ def test_rogue_ca_exfiltrator_blocked(self, or_pm_secure, or_env_secure, threat_
     def test_forged_perms_exfiltrator_blocked(self, or_pm_secure, or_env_secure, threat_env):
         """Forged permissions exfiltrator should NOT receive vitals from secured OR apps."""
         ps = or_pm_secure.start_app("PatientSensor")
-        wait_for_process_ready(ps, timeout_sec=15)
+        wait_for_process_ready(ps, timeout_sec=5)
         assert ps.poll() is None, f"PatientSensor exited early with code {ps.returncode}"
 
         result = _run_exfiltrator_probe(
             threat_env[0],
             dp_name="ThreatParticipantLibrary::dp/ThreatExfiltrator/ForgedPerms",
-            timeout_sec=10,
+            timeout_sec=4,
         )
         assert result["received"] == 0, (
             "Forged permissions exfiltrator should NOT receive vitals from secured OR"
@@ -252,13 +252,13 @@ def test_forged_perms_exfiltrator_blocked(self, or_pm_secure, or_env_secure, thr
     def test_expired_cert_exfiltrator_blocked(self, or_pm_secure, or_env_secure, threat_env):
         """Expired certificate exfiltrator should fail to create participant or receive data."""
         ps = or_pm_secure.start_app("PatientSensor")
-        wait_for_process_ready(ps, timeout_sec=15)
+        wait_for_process_ready(ps, timeout_sec=5)
         assert ps.poll() is None, f"PatientSensor exited early with code {ps.returncode}"
 
         result = _run_exfiltrator_probe(
             threat_env[0],
             dp_name="ThreatParticipantLibrary::dp/ThreatExfiltrator/ExpiredCert",
-            timeout_sec=10,
+            timeout_sec=4,
         )
         # Expired cert typically causes participant creation failure
         if result["created"]:

modules/04-security-threat/tests/test_threat_injector.py

@@ -118,7 +118,7 @@ class TestInjectorUnsecure:
     def test_unsecure_injection_succeeds(self, or_pm_nonsecure, or_env_nonsecure, threat_env):
         """Unsecured injector should match unsecured OR apps."""
         sensor = or_pm_nonsecure.start_app("PatientSensor")
-        wait_for_process_ready(sensor, timeout_sec=10)
+        wait_for_process_ready(sensor, timeout_sec=5)
         assert sensor.poll() is None, f"PatientSensor exited early with code {sensor.returncode}"
 
         result = _run_injector_probe(
@@ -141,37 +141,37 @@ class TestInjectorSecure:
     def test_rogue_ca_injection_blocked(self, or_pm_secure, or_env_secure, threat_env):
         """Injector with rogue CA identity should not match secured OR apps."""
         ps = or_pm_secure.start_app("PatientSensor")
-        wait_for_process_ready(ps, timeout_sec=15)
+        wait_for_process_ready(ps, timeout_sec=5)
 
         result = _run_injector_probe(
             threat_env[0],
             dp_name="ThreatParticipantLibrary::dp/ThreatInjector/RogueCA",
-            timeout_sec=10,
+            timeout_sec=4,
         )
         # The participant may be created but should NOT match
         assert not result["matched"], "Rogue CA injector should NOT match secured OR apps"
 
     def test_forged_perms_injection_blocked(self, or_pm_secure, or_env_secure, threat_env):
         """Injector with forged permissions should not match secured OR apps."""
         ps = or_pm_secure.start_app("PatientSensor")
-        wait_for_process_ready(ps, timeout_sec=15)
+        wait_for_process_ready(ps, timeout_sec=5)
 
         result = _run_injector_probe(
             threat_env[0],
             dp_name="ThreatParticipantLibrary::dp/ThreatInjector/ForgedPerms",
-            timeout_sec=10,
+            timeout_sec=4,
         )
         assert not result["matched"], "Forged permissions injector should NOT match secured OR apps"
 
     def test_expired_cert_injection_fails(self, or_pm_secure, or_env_secure, threat_env):
         """Injector with expired certificate should fail to create participant or match."""
         ps = or_pm_secure.start_app("PatientSensor")
-        wait_for_process_ready(ps, timeout_sec=15)
+        wait_for_process_ready(ps, timeout_sec=5)
 
         result = _run_injector_probe(
             threat_env[0],
             dp_name="ThreatParticipantLibrary::dp/ThreatInjector/ExpiredCert",
-            timeout_sec=10,
+            timeout_sec=4,
         )
         # Expired cert typically causes participant creation failure
         if result["created"]: