test: cover bundle/general/decorator/temp-dir edge cases

Add pure-logic tests for the page-bundle helpers (resource filtering of
failed/canceled/data-uri/non-bundleable, filename derivation, CSS url() rewrite
and inline skipping data-uris and unknown refs), normalize_synthetic_xpath,
the retry decorator's callback re-raise branches, the temp-dir persistent-lock
swallow path, and page-level ws-address resolution from port + page_id.

Author: thalissonvs

tests/integration/test_connection_handler.py

@@ -356,6 +356,19 @@ async def flood_events():
     assert len(events) == 25
 
 
+@pytest.mark.asyncio
+async def test_resolves_page_level_address_from_port_and_page_id(cdp_server):
+    """A handler given a port + page_id connects via the page-level devtools path."""
+    cdp_server.set_result('Page.enable', {})
+    handler = ConnectionHandler(connection_port=cdp_server.port, page_id='abc')
+    try:
+        result = await handler.execute_command({'method': 'Page.enable'})
+        assert result['result'] == {}
+        assert cdp_server.total_connections >= 1
+    finally:
+        await handler.close()
+
+
 @pytest.mark.asyncio
 async def test_context_manager_runs_commands_and_has_repr(cdp_server):
     """The async context manager yields a usable handler and closes it on exit."""

tests/unit/test_bundle.py

@@ -0,0 +1,83 @@
+"""Pure-logic tests for the page-bundle helpers (no browser, no I/O).
+
+These functions transform the resource tree and rewrite asset URLs for the
+offline ``save_bundle`` zip. The end-to-end behaviour is covered by the
+real-Chrome suite; here we pin the branchy edge cases of the pure helpers:
+which resources are skipped, how filenames are derived, and how data-URI /
+unknown URLs are left untouched while known ones are rewritten or inlined.
+"""
+
+from __future__ import annotations
+
+from pydoll.protocol.network.types import ResourceType
+from pydoll.utils.bundle import (
+    build_asset_filename,
+    collect_frame_resources,
+    filter_fetchable_resources,
+    inline_css_urls,
+    rewrite_css_urls,
+)
+
+
+def _res(url, rtype=ResourceType.STYLESHEET, mime='text/css', **extra):
+    return {'url': url, 'type': rtype, 'mimeType': mime, **extra}
+
+
+def test_filter_skips_failed_canceled_data_uri_page_and_nonbundleable():
+    page_url = 'http://x/'
+    resources = [
+        ('f', _res('http://x/a.css')),
+        ('f', _res('http://x/b.css', failed=True)),
+        ('f', _res('http://x/c.css', canceled=True)),
+        ('f', _res('data:image/png;base64,AA', ResourceType.IMAGE, 'image/png')),
+        ('f', _res(page_url, ResourceType.DOCUMENT, 'text/html')),
+        ('f', _res('http://x/data.json', ResourceType.XHR, 'application/json')),
+    ]
+    kept = [res['url'] for _fid, res in filter_fetchable_resources(resources, page_url)]
+    assert kept == ['http://x/a.css']
+
+
+def test_collect_frame_resources_recurses_into_child_frames():
+    tree = {
+        'frame': {'id': 'root'},
+        'resources': [_res('http://x/a.css')],
+        'childFrames': [
+            {
+                'frame': {'id': 'child'},
+                'resources': [_res('http://x/b.js', ResourceType.SCRIPT, 'text/javascript')],
+            }
+        ],
+    }
+    assert sorted(fid for fid, _res_ in collect_frame_resources(tree)) == ['child', 'root']
+
+
+def test_build_asset_filename_derives_basename_and_extension():
+    assert build_asset_filename('http://x', 'text/css', 0).endswith('resource.css')
+    assert build_asset_filename('http://x/style', 'text/css', 1).endswith('style.css')
+    assert build_asset_filename('http://x/a.png', 'image/png', 2).endswith('a.png')
+
+
+def test_rewrite_css_urls_skips_data_uri_and_unknown_rewrites_known():
+    css = (
+        'a{background:url("data:image/png;base64,AA")}'
+        'b{background:url("http://x/unknown.png")}'
+        'c{background:url("http://x/known.png")}'
+    )
+    asset_map = {'http://x/known.png': ('0000_known.png', b'', 'image/png', ResourceType.IMAGE)}
+    result = rewrite_css_urls(css, 'http://x/style.css', asset_map)
+    assert 'data:image/png;base64,AA' in result
+    assert 'http://x/unknown.png' in result
+    assert 'url("0000_known.png")' in result
+
+
+def test_inline_css_urls_skips_data_uri_and_unknown_inlines_known():
+    css = (
+        'a{background:url("data:image/png;base64,AA")}'
+        'b{background:url("http://x/unknown.png")}'
+        'c{background:url("http://x/known.png")}'
+    )
+    asset_map = {'http://x/known.png': ('f', b'\x89PNG', 'image/png', ResourceType.IMAGE)}
+    result = inline_css_urls(css, 'http://x/style.css', asset_map)
+    assert 'data:image/png;base64,AA' in result
+    assert 'http://x/unknown.png' in result
+    assert 'url("data:image/png;base64,' in result

tests/unit/test_decorators.py

@@ -118,16 +118,36 @@ async def test_callback_without_instance(self):
         """Test callback that doesn't accept instance argument."""
         # Callback that doesn't accept arguments
         callback_called = False
-        
+
         async def simple_callback():
             nonlocal callback_called
             callback_called = True
-        
+
         config = RetryConfig(on_retry=simple_callback)
         await config.call_callback(MagicMock())
-        
+
         assert callback_called
 
+    @pytest.mark.asyncio
+    async def test_callback_reraises_non_typeerror(self):
+        """A callback that fails with a non-TypeError propagates that error."""
+        async def boom(_instance):
+            raise ValueError('callback failed')
+
+        config = RetryConfig(on_retry=boom)
+        with pytest.raises(ValueError):
+            await config.call_callback(object())
+
+    @pytest.mark.asyncio
+    async def test_callback_reraises_inner_error_when_noarg_retry_also_fails(self):
+        """When the no-arg retry fallback itself fails, that inner error propagates."""
+        async def zero_arg_then_boom():
+            raise RuntimeError('inner failure')
+
+        config = RetryConfig(on_retry=zero_arg_then_boom)
+        with pytest.raises(RuntimeError):
+            await config.call_callback(object())
+
 
 class TestRetryDecoratorBasic:
     """Test basic retry decorator functionality."""

tests/unit/test_temp_dir_manager.py

@@ -73,3 +73,28 @@ def test_handle_cleanup_error_recovers_known_chrome_lock():
         (PermissionError, PermissionError(), None),
     )
     assert processed == ['/profile/CrashpadMetrics-active.pma']
+
+
+def test_handle_cleanup_error_recovers_safe_browsing_lock():
+    manager = TempDirectoryManager()
+    processed = []
+    manager.handle_cleanup_error(
+        processed.append,
+        '/profile/Safe Browsing/data',
+        (PermissionError, PermissionError(), None),
+    )
+    assert processed == ['/profile/Safe Browsing/data']
+
+
+def test_handle_cleanup_error_swallows_persistently_locked_chrome_file():
+    manager = TempDirectoryManager()
+
+    def always_locked(_path):
+        raise PermissionError()
+
+    # A known Chrome lock file that never unlocks is logged and ignored, not raised.
+    manager.handle_cleanup_error(
+        always_locked,
+        '/profile/CrashpadMetrics-active.pma',
+        (PermissionError, PermissionError(), None),
+    )

tests/unit/test_utils.py

@@ -13,11 +13,25 @@
     get_browser_ws_address,
     has_return_outside_function,
     is_script_already_function,
+    normalize_synthetic_xpath,
     validate_browser_paths,
     extract_text_from_html,
 )
 
 
+def test_normalize_synthetic_xpath_extracts_inner_xpath():
+    assert normalize_synthetic_xpath('//*[@xpath="//div[@id=\'x\']"]') == "//div[@id='x']"
+
+
+def test_normalize_synthetic_xpath_passes_through_plain_selector():
+    assert normalize_synthetic_xpath('//div[@id="x"]') == '//div[@id="x"]'
+
+
+def test_normalize_synthetic_xpath_returns_input_when_unparseable():
+    assert normalize_synthetic_xpath("//*[@xpath='x']") == "//*[@xpath='x']"
+    assert normalize_synthetic_xpath('//*[@xpath="abc') == '//*[@xpath="abc'
+
+
 class TestUtils:
     """
     Test class for utility functions in the pydoll.utils module.