Fix virtual sleep determinism detection

Packages/Shared/CmuxIrohTransport/Tests/CmuxIrohTransportTests/CmxIrohRelayCredentialCoordinatorTests+Refresh.swift

@@ -15,8 +15,6 @@ extension CmxIrohRelayCredentialCoordinatorTests {
         let initialRefresh = initialExpiry.addingTimeInterval(-60)
         let replacementExpiry = fixture.now.addingTimeInterval(13 * 60)
         let replacementRefresh = replacementExpiry.addingTimeInterval(-60)
-        let expectedInitialClockEvent = TestRelayClock.Event.sleep(initialRefresh)
-        let expectedReplacementClockEvent = TestRelayClock.Event.sleep(replacementRefresh)
         let broker = TestRelayTokenBroker(steps: [
             .response(try fixture.response(
                 tokens: ["ghi234", "jkl234"],
@@ -42,10 +40,10 @@ extension CmxIrohRelayCredentialCoordinatorTests {
                 expiresAt: initialExpiry
             )
         )
-        #expect(await clockEvents.next() == expectedInitialClockEvent)
+        #expect(await clockEvents.next() == .sleep(initialRefresh))
 
         clock.advance(to: initialRefresh)
-        #expect(await clockEvents.next() == expectedReplacementClockEvent)
+        #expect(await clockEvents.next() == .sleep(replacementRefresh))
 
         #expect(await broker.observedEndpointIDs() == [fixture.identity])
         #expect(await endpoint.observedRelayUpdates().count == 2)

scripts/check-test-determinism.py

@@ -193,7 +193,7 @@ def to_dict(self) -> dict[str, object]:
 _SLEEP_CALL = re.compile(
     r"""(?x)
     \btime\.sleep\s*\(
-  | \bsleep\s*\(                            # sleep(...) call (C/shell function form)
+  | \bsleep\s*\(                            # qualified or unqualified sleep(...) call
   | \busleep\s*\(
   | \bnanosleep\s*\(
   | Thread\.sleep\s*\(
@@ -204,6 +204,12 @@ def to_dict(self) -> dict[str, object]:
     """
 )
 
+# Swift implicit-member values such as `.sleep(deadline)` can represent enum
+# data in an assertion. A receiver (`clock.sleep`, `clock?.sleep`,
+# `ContinuousClock().sleep`) prevents this match, so real qualified calls
+# remain candidates.
+_IMPLICIT_MEMBER_SLEEP_VALUE = re.compile(r"(?<![\w)\]?!>])\.sleep\s*\(")
+
 # The shell BARE-COMMAND sleep form (`sleep 0.3`) has no parentheses, so it can
 # only be recognized positionally. It is matched ONLY in shell files: in Swift /
 # Python / TS the same character sequence is almost always a quoted string
@@ -446,7 +452,13 @@ def _sleep_in_loop(lines: list[str], idx: int) -> bool:
 def detect_sleep_then_assert(lines: list[str], idx: int, path_suffix: str) -> bool:
     """Sleep on lines[idx] followed by an assertion within 3 non-blank lines."""
     line = lines[idx]
-    is_sleep = bool(_SLEEP_CALL.search(line))
+    candidate_line = line
+    # Ignore only bare Swift implicit-member data inside an assertion. Explicit
+    # APIs such as Task.sleep, asyncio.sleep, and clock.sleep remain detectable
+    # even when the sleep itself is nested in an assertion expression.
+    if _is_assertion_line(line):
+        candidate_line = _IMPLICIT_MEMBER_SLEEP_VALUE.sub("", line)
+    is_sleep = bool(_SLEEP_CALL.search(candidate_line))
     if not is_sleep and path_suffix == ".sh":
         is_sleep = bool(_SHELL_BARE_SLEEP.search(line))
     if not is_sleep:
@@ -641,6 +653,29 @@ def _self_test() -> int:
             "time.sleep(0.3)\nassert widget.is_rendered()\n",
             {RULE_SLEEP_THEN_ASSERT},
         ),
+        (
+            "tests/free_sleep.py",
+            "sleep(0.3)\nassert widget.is_rendered()\n",
+            {RULE_SLEEP_THEN_ASSERT},
+        ),
+        (
+            "Tests/QualifiedClockTests.swift",
+            "try await ContinuousClock().sleep(for: .milliseconds(300))\n"
+            "#expect(widget.isRendered)\n",
+            {RULE_SLEEP_THEN_ASSERT},
+        ),
+        (
+            "tests/assert_sleep.py",
+            "assert await asyncio.sleep(0.3) is None\n"
+            "assert widget.is_rendered()\n",
+            {RULE_SLEEP_THEN_ASSERT},
+        ),
+        (
+            "Tests/OptionalClockTests.swift",
+            "#expect(await clock?.sleep(for: .milliseconds(300)) == nil)\n"
+            "#expect(widget.isRendered)\n",
+            {RULE_SLEEP_THEN_ASSERT},
+        ),
         (
             "cmuxUITests/f.swift",
             "try await Task.sleep(nanoseconds: 300_000_000)\nXCTAssertTrue(view.exists)\n",
@@ -783,6 +818,15 @@ def _self_test() -> int:
             "            time.sleep(0.3)\n"
             "        _must('ok' in body, body)\n",
         ),
+        # A fake-clock event named `.sleep` is data, not a real delay. The
+        # following assertions consume causal AsyncStream signals directly.
+        (
+            "Packages/CmuxClock/Tests/VirtualClockTests.swift",
+            "#expect(await clockEvents.next() == .sleep(initialRefresh))\n"
+            "clock.advance(to: initialRefresh)\n"
+            "#expect(await clockEvents.next() == .sleep(replacementRefresh))\n"
+            "#expect(await broker.requests() == 1)\n",
+        ),
     ]
 
     failures: list[str] = []