refactor: Simplify send_request enqueue strategy validation

Hoist origin URL parsing out of the per-call closure so it is computed
once per request, not on every send_request call. Drop a redundant type
annotation and collapse the three nearly-identical tests into one
parametrized case.

Author: vdusek

src/crawlee/crawlers/_basic/_basic_crawler.py

@@ -444,7 +444,7 @@ def __init__(
         self._max_session_rotations = max_session_rotations
         self._max_crawl_depth = max_crawl_depth
         self._respect_robots_txt_file = respect_robots_txt_file
-        self._send_request_enqueue_strategy: EnqueueStrategy = send_request_enqueue_strategy
+        self._send_request_enqueue_strategy = send_request_enqueue_strategy
 
         # Timeouts
         self._request_handler_timeout = request_handler_timeout
@@ -1290,24 +1290,26 @@ def _prepare_send_request_function(
         proxy_info: ProxyInfo | None,
         request: Request,
     ) -> SendRequestFunction:
+        strategy = self._send_request_enqueue_strategy
+        origin_url = request.loaded_url or request.url
+        origin_parsed = urlparse(origin_url) if strategy != 'all' else None
+
         async def send_request(
             url: str,
             *,
             method: HttpMethod = 'GET',
             payload: HttpPayload | None = None,
             headers: HttpHeaders | dict[str, str] | None = None,
         ) -> HttpResponse:
-            if self._send_request_enqueue_strategy != 'all':
-                origin_url = request.loaded_url or request.url
-                if not self._check_enqueue_strategy(
-                    self._send_request_enqueue_strategy,
-                    target_url=urlparse(url),
-                    origin_url=urlparse(origin_url),
-                ):
-                    raise ValueError(
-                        f'send_request() refusing to fetch {url!r}: does not match enqueue strategy '
-                        f'{self._send_request_enqueue_strategy!r} relative to {origin_url!r}.'
-                    )
+            if origin_parsed is not None and not self._check_enqueue_strategy(
+                strategy,
+                target_url=urlparse(url),
+                origin_url=origin_parsed,
+            ):
+                raise ValueError(
+                    f'send_request() refusing to fetch {url!r}: does not match enqueue strategy '
+                    f'{strategy!r} relative to {origin_url!r}.'
+                )
             return await self._http_client.send_request(
                 url=url,
                 method=method,

tests/unit/crawlers/_basic/test_basic_crawler.py

@@ -19,7 +19,7 @@
 
 import pytest
 
-from crawlee import ConcurrencySettings, Glob, service_locator
+from crawlee import ConcurrencySettings, EnqueueStrategy, Glob, service_locator
 from crawlee._request import Request, RequestState
 from crawlee._types import BasicCrawlingContext, EnqueueLinksKwargs, HttpMethod
 from crawlee._utils.robots import RobotsTxtFile
@@ -340,56 +340,41 @@ async def failed_request_handler(context: BasicCrawlingContext, error: Exception
         await crawler.run(['https://a.placeholder.com', 'https://b.placeholder.com', 'https://c.placeholder.com'])
 
 
-async def test_send_request_strategy_default_allows_cross_host(server_url: URL) -> None:
-    """The default `send_request_enqueue_strategy='all'` permits cross-host `send_request` calls."""
+@pytest.mark.parametrize(
+    ('strategy', 'target_path', 'should_succeed'),
+    [
+        pytest.param('all', 'get', True, id='default-all-allows-same-host'),
+        pytest.param('same-hostname', 'get', True, id='same-hostname-allows-same-host'),
+        pytest.param('same-hostname', 'http://attacker.evil/payload', False, id='same-hostname-rejects-cross-host'),
+    ],
+)
+async def test_send_request_enqueue_strategy(
+    server_url: URL, strategy: EnqueueStrategy, target_path: str, *, should_succeed: bool
+) -> None:
     bodies: list[bytes] = []
-
-    crawler = BasicCrawler(max_request_retries=1)
-
-    @crawler.router.default_handler
-    async def handler(context: BasicCrawlingContext) -> None:
-        response = await context.send_request(str(server_url / 'get'))
-        bodies.append(await response.read())
-
-    await crawler.run([str(server_url / 'a/page')])
-
-    assert bodies, 'expected the handler to receive at least one response'
-
-
-async def test_send_request_strategy_same_hostname_rejects_cross_host(server_url: URL) -> None:
-    """`send_request_enqueue_strategy='same-hostname'` raises when target URL is on a different host."""
     errors: list[Exception] = []
 
-    crawler = BasicCrawler(max_request_retries=1, send_request_enqueue_strategy='same-hostname')
+    crawler = BasicCrawler(max_request_retries=1, send_request_enqueue_strategy=strategy)
+    target_url = target_path if target_path.startswith('http') else str(server_url / target_path)
 
     @crawler.router.default_handler
     async def handler(context: BasicCrawlingContext) -> None:
         try:
-            await context.send_request('http://attacker.evil/payload')
+            response = await context.send_request(target_url)
         except ValueError as exc:
             errors.append(exc)
+        else:
+            bodies.append(await response.read())
 
     await crawler.run([str(server_url / 'a/page')])
 
-    assert errors, 'expected send_request to refuse the cross-host URL'
-    assert 'same-hostname' in str(errors[0])
-    assert 'attacker.evil/payload' in str(errors[0])
-
-
-async def test_send_request_strategy_same_hostname_allows_same_host(server_url: URL) -> None:
-    """`send_request_enqueue_strategy='same-hostname'` lets same-host targets through unchanged."""
-    bodies: list[bytes] = []
-
-    crawler = BasicCrawler(max_request_retries=1, send_request_enqueue_strategy='same-hostname')
-
-    @crawler.router.default_handler
-    async def handler(context: BasicCrawlingContext) -> None:
-        response = await context.send_request(str(server_url / 'get'))
-        bodies.append(await response.read())
-
-    await crawler.run([str(server_url / 'a/page')])
-
-    assert bodies, 'expected the handler to receive a response from the same host'
+    if should_succeed:
+        assert bodies, 'expected the handler to receive a response'
+        assert not errors
+    else:
+        assert errors, 'expected send_request to refuse the target URL'
+        assert strategy in str(errors[0])
+        assert target_url in str(errors[0])
 
 
 @pytest.mark.parametrize(