test: de-flake HAR in-flight/pending tests via deterministic units

Two HAR tests raced the recorder's own event processing: they left the record()
context the instant a *separate* listener saw loadingFinished/requestWillBeSent,
but the recorder's handler for that same event may not have run yet — so stop()
removed the callbacks and flushed the request as a status-0 pending entry
(observed on Windows CI: the in-flight-body test got None for status=200).

Reframe the large-body test to poll the live recording until the entry is
finalized (observable outcome, no race), and move the stop-time guarantees —
awaiting in-flight body tasks and flushing still-pending requests as status 0 —
to deterministic unit tests (tests/unit/test_har_recorder.py) that drive
HarRecorder with synthetic events. Remove the now-unused event-waiter helpers.

Author: thalissonvs

tests/integration/test_har_recording_integration.py

@@ -16,10 +16,9 @@
 
 from pydoll.browser.chromium import Chrome
 from pydoll.browser.requests.har_recorder import HarCapture
-from pydoll.protocol.network.events import NetworkEvent
 from pydoll.protocol.network.types import ResourceType
 
-from _waits import wait_for_element_text, wait_until
+from _waits import wait_until
 
 
 def _find_free_port():
@@ -546,81 +545,6 @@ async def _coro(value):
     return value
 
 
-class _RequestSentWaiter:
-    """Arm a listener for a ``Network.requestWillBeSent`` event before navigating.
-
-    In-flight requests never appear in ``performance.getEntriesByType('resource')``
-    (those entries materialize only after the resource finishes), and the in-page
-    ``fetch`` fires at parse time, so the listener must be registered *before*
-    navigation to avoid missing the event.
-    """
-
-    def __init__(self, tab, needle):
-        self._tab = tab
-        self._needle = needle
-        self._sent = asyncio.Event()
-        self._callback_id = None
-
-    async def arm(self):
-        def _on_sent(event):
-            if self._needle in event['params']['request']['url']:
-                self._sent.set()
-
-        self._callback_id = await self._tab.on(NetworkEvent.REQUEST_WILL_BE_SENT, _on_sent)
-
-    async def wait(self, timeout=10):
-        try:
-            await wait_until(
-                lambda: _coro(self._sent.is_set()),
-                timeout=timeout,
-                message=f'request {self._needle!r} not dispatched',
-            )
-        finally:
-            if self._callback_id is not None:
-                await self._tab.remove_callback(self._callback_id)
-
-
-class _LoadingFinishedWaiter:
-    """Arm a listener for the ``Network.loadingFinished`` of a specific request.
-
-    Used to leave the recorder's context manager the instant a body becomes
-    fetchable, so its asynchronous ``getResponseBody`` task is still in flight
-    when ``stop()`` awaits the pending body tasks.
-    """
-
-    def __init__(self, tab, needle):
-        self._tab = tab
-        self._needle = needle
-        self._request_ids = set()
-        self._finished = asyncio.Event()
-        self._sent_cb = None
-        self._finished_cb = None
-
-    async def arm(self):
-        def _on_sent(event):
-            if self._needle in event['params']['request']['url']:
-                self._request_ids.add(event['params']['requestId'])
-
-        def _on_finished(event):
-            if event['params']['requestId'] in self._request_ids:
-                self._finished.set()
-
-        self._sent_cb = await self._tab.on(NetworkEvent.REQUEST_WILL_BE_SENT, _on_sent)
-        self._finished_cb = await self._tab.on(NetworkEvent.LOADING_FINISHED, _on_finished)
-
-    async def wait(self, timeout=10):
-        try:
-            await wait_until(
-                lambda: _coro(self._finished.is_set()),
-                timeout=timeout,
-                message=f'loadingFinished for {self._needle!r} not observed',
-            )
-        finally:
-            for callback_id in (self._sent_cb, self._finished_cb):
-                if callback_id is not None:
-                    await self._tab.remove_callback(callback_id)
-
-
 class TestHarRedirectIntegration:
     """Recording captures redirect entries and the final destination."""
 
@@ -707,24 +631,6 @@ async def test_record_304_has_zero_body_size(self, ci_chrome_options, api_server
 class TestHarPendingAndFailedIntegration:
     """Recording finalizes in-flight and failed requests at stop time."""
 
-    @pytest.mark.asyncio
-    async def test_record_flushes_pending_request(self, ci_chrome_options, api_server):
-        """A request still in flight at stop becomes an entry with status 0."""
-        async with Chrome(options=ci_chrome_options) as browser:
-            tab = await browser.start()
-
-            async with tab.request.record() as recording:
-                slow_waiter = _RequestSentWaiter(tab, '/slow')
-                await slow_waiter.arm()
-                await tab.go_to(f'{api_server}/pending-page')
-                status_el = await tab.find(id='status', timeout=5)
-                await wait_for_element_text(status_el, 'started')
-                await slow_waiter.wait()
-
-            slow_entry = _origin_entry(recording, '/slow', status=0)
-            assert slow_entry is not None
-            assert slow_entry['response']['statusText'] == '(pending)'
-
     @pytest.mark.asyncio
     async def test_record_captures_failed_request(self, ci_chrome_options, api_server):
         """A request that fails (blocked port) is recorded with status 0."""
@@ -741,30 +647,28 @@ async def test_record_captures_failed_request(self, ci_chrome_options, api_serve
             assert failed_entry['response']['status'] == 0
 
     @pytest.mark.asyncio
-    async def test_record_awaits_in_flight_body_fetch_on_stop(
-        self, ci_chrome_options, api_server
-    ):
-        """A body fetch still in flight at stop is awaited so its entry survives.
+    async def test_record_captures_large_response_body(self, ci_chrome_options, api_server):
+        """A large response body is fetched asynchronously and captured in the HAR.
 
-        Leaving the context the instant loadingFinished fires guarantees the
-        asynchronous getResponseBody task has not completed (it needs a CDP
-        round-trip), so stop() must await the pending body task. The entry only
-        appears in the capture because _finalize_entry ran to completion during
-        that await; otherwise it would be lost.
+        The body arrives via an async getResponseBody round-trip after
+        loadingFinished, so the entry only appears once that task completes. Poll
+        the live recording until it does — racing context exit against the
+        internal finalize is inherently flaky across environments.
         """
         async with Chrome(options=ci_chrome_options) as browser:
             tab = await browser.start()
 
             async with tab.request.record() as recording:
-                body_waiter = _LoadingFinishedWaiter(tab, '/large')
-                await body_waiter.arm()
                 await tab.go_to(f'{api_server}/large-page')
-                await body_waiter.wait()
+                await wait_until(
+                    lambda: _coro(_origin_entry(recording, '/large', status=200) is not None),
+                    message='/large entry not finalized in HAR',
+                )
 
             large_entry = _origin_entry(recording, '/large', status=200)
             assert large_entry is not None
             assert large_entry['response']['status'] == 200
-            assert 'content' in large_entry['response']
+            assert large_entry['response']['content']['size'] > 0
 
 
 class TestHarToDictIntegration:

tests/unit/test_har_recorder.py

@@ -0,0 +1,74 @@
+"""Unit tests for HarRecorder.stop() lifecycle (deterministic, no browser).
+
+stop() must await any in-flight getResponseBody tasks before flushing, remove
+its CDP callbacks, and disable network events it turned on. This is exercised
+here with a fake tab so the body-await path runs deterministically instead of
+racing a real browser's internal finalize against context exit.
+"""
+
+from __future__ import annotations
+
+import asyncio
+
+import pytest
+
+from pydoll.browser.requests.har_recorder import HarRecorder
+
+
+class _FakeTab:
+    network_events_enabled = True
+
+    def __init__(self):
+        self.removed: list[int] = []
+        self.network_disabled = False
+
+    async def remove_callback(self, callback_id):
+        self.removed.append(callback_id)
+
+    async def disable_network_events(self):
+        self.network_disabled = True
+
+
+@pytest.mark.asyncio
+async def test_stop_awaits_in_flight_body_tasks_and_cleans_up():
+    fake_tab = _FakeTab()
+    recorder = HarRecorder(tab=fake_tab)
+    recorder._network_was_enabled = True
+    recorder._callback_ids = [1, 2, 3]
+
+    completed: list[bool] = []
+
+    async def slow_body_fetch():
+        await asyncio.sleep(0.02)
+        completed.append(True)
+
+    recorder._body_tasks = [asyncio.ensure_future(slow_body_fetch())]
+
+    await recorder.stop()
+
+    assert completed == [True]
+    assert recorder._body_tasks == []
+    assert fake_tab.removed == [1, 2, 3]
+    assert fake_tab.network_disabled is True
+
+
+@pytest.mark.asyncio
+async def test_stop_flushes_in_flight_request_as_pending_entry():
+    recorder = HarRecorder(tab=_FakeTab())
+    recorder._on_request_will_be_sent({
+        'params': {
+            'requestId': 'r1',
+            'request': {'url': 'http://x/slow', 'method': 'GET', 'headers': {}},
+            'type': 'Fetch',
+            'wallTime': 1000.0,
+            'timestamp': 1.0,
+        }
+    })
+
+    await recorder.stop()
+
+    assert len(recorder._entries) == 1
+    entry = recorder._entries[0]
+    assert entry['request']['url'] == 'http://x/slow'
+    assert entry['response']['status'] == 0
+    assert entry['response']['statusText'] == '(pending)'