Merge pull request #182 from autoscrape-labs/fix/issue-181

Add fetch domain commands to `Tab` class

Author: thalissonvs

pydoll/browser/chromium/base.py

@@ -24,6 +24,7 @@
     DownloadBehavior,
     NetworkErrorReason,
     PermissionType,
+    RequestMethod,
     ResourceType,
 )
 from pydoll.exceptions import BrowserNotRunning, FailedToStartBrowser, NoValidTabFound
@@ -425,11 +426,28 @@ async def disable_runtime_events(self):
         """Disable runtime events."""
         return await self._connection_handler.execute_command(RuntimeCommands.disable())
 
-    async def continue_request(self, request_id: str):
+    async def continue_request(  # noqa: PLR0913, PLR0917
+        self,
+        request_id: str,
+        url: Optional[str] = None,
+        method: Optional[RequestMethod] = None,
+        post_data: Optional[str] = None,
+        headers: Optional[list[HeaderEntry]] = None,
+        intercept_response: Optional[bool] = None,
+    ):
         """
         Continue paused request without modifications.
         """
-        return await self._execute_command(FetchCommands.continue_request(request_id))
+        return await self._execute_command(
+            FetchCommands.continue_request(
+                request_id=request_id,
+                url=url,
+                method=method,
+                post_data=post_data,
+                headers=headers,
+                intercept_response=intercept_response,
+            )
+        )
 
     async def fail_request(self, request_id: str, error_reason: NetworkErrorReason):
         """Fail request with error code."""
@@ -439,16 +457,18 @@ async def fulfill_request(
         self,
         request_id: str,
         response_code: int,
-        response_headers: list[HeaderEntry],
-        response_body: dict[Any, Any],
+        response_headers: Optional[list[HeaderEntry]] = None,
+        body: Optional[str] = None,
+        response_phrase: Optional[str] = None,
     ):
         """Fulfill request with response data."""
         return await self._execute_command(
             FetchCommands.fulfill_request(
-                request_id,
-                response_code,
-                response_headers,
-                response_body,
+                request_id=request_id,
+                response_code=response_code,
+                response_headers=response_headers,
+                body=body,
+                response_phrase=response_phrase,
             )
         )
 

pydoll/browser/tab.py

@@ -26,7 +26,14 @@
     StorageCommands,
 )
 from pydoll.connection import ConnectionHandler
-from pydoll.constants import By, RequestStage, ResourceType, ScreenshotFormat
+from pydoll.constants import (
+    By,
+    NetworkErrorReason,
+    RequestMethod,
+    RequestStage,
+    ResourceType,
+    ScreenshotFormat,
+)
 from pydoll.elements.mixins import FindElementsMixin
 from pydoll.elements.web_element import WebElement
 from pydoll.exceptions import (
@@ -42,6 +49,7 @@
 )
 from pydoll.protocol.base import Response
 from pydoll.protocol.dom.types import EventFileChooserOpened
+from pydoll.protocol.fetch.types import HeaderEntry
 from pydoll.protocol.network.responses import GetResponseBodyResponse
 from pydoll.protocol.network.types import Cookie, CookieParam, NetworkLog
 from pydoll.protocol.page.events import PageEvent
@@ -668,6 +676,53 @@ async def execute_script(
 
         return await self._execute_script_without_element(script)
 
+    # TODO: think about how to remove these duplications with the base class
+    async def continue_request(  # noqa: PLR0913, PLR0917
+        self,
+        request_id: str,
+        url: Optional[str] = None,
+        method: Optional[RequestMethod] = None,
+        post_data: Optional[str] = None,
+        headers: Optional[list[HeaderEntry]] = None,
+        intercept_response: Optional[bool] = None,
+    ):
+        """
+        Continue paused request without modifications.
+        """
+        return await self._execute_command(
+            FetchCommands.continue_request(
+                request_id=request_id,
+                url=url,
+                method=method,
+                post_data=post_data,
+                headers=headers,
+                intercept_response=intercept_response,
+            )
+        )
+
+    async def fail_request(self, request_id: str, error_reason: NetworkErrorReason):
+        """Fail request with error code."""
+        return await self._execute_command(FetchCommands.fail_request(request_id, error_reason))
+
+    async def fulfill_request(
+        self,
+        request_id: str,
+        response_code: int,
+        response_headers: Optional[list[HeaderEntry]] = None,
+        body: Optional[str] = None,
+        response_phrase: Optional[str] = None,
+    ):
+        """Fulfill request with response data."""
+        return await self._execute_command(
+            FetchCommands.fulfill_request(
+                request_id=request_id,
+                response_code=response_code,
+                response_headers=response_headers,
+                body=body,
+                response_phrase=response_phrase,
+            )
+        )
+
     @asynccontextmanager
     async def expect_file_chooser(
         self, files: Union[str, Path, list[Union[str, Path]]]

pydoll/commands/fetch_commands.py

@@ -200,7 +200,7 @@ def fulfill_request(  # noqa: PLR0913, PLR0917
         request_id: str,
         response_code: int,
         response_headers: Optional[list[HeaderEntry]] = None,
-        body: Optional[dict] = None,
+        body: Optional[str] = None,
         response_phrase: Optional[str] = None,
     ) -> Command[Response]:
         """

pydoll/protocol/fetch/params.py

@@ -39,7 +39,7 @@ class FulfillRequestParams(CommandParams):
     requestId: str
     responseCode: int
     responseHeaders: NotRequired[list[HeaderEntry]]
-    body: NotRequired[dict]
+    body: NotRequired[str]
     responsePhrase: NotRequired[str]
 
 

tests/test_browser/test_browser_base.py

@@ -1,3 +1,4 @@
+import base64
 from unittest.mock import ANY, AsyncMock, MagicMock, patch
 
 import pytest
@@ -18,7 +19,7 @@
 )
 from pydoll.protocol.fetch.events import FetchEvent
 from pydoll.connection.connection_handler import ConnectionHandler
-from pydoll.constants import DownloadBehavior, PermissionType, NetworkErrorReason
+from pydoll.constants import DownloadBehavior, PermissionType, NetworkErrorReason, RequestMethod
 
 
 class ConcreteBrowser(Browser):
@@ -612,7 +613,57 @@ async def test_disable_runtime_events(mock_browser):
     )
 
 
-# Tests for fail_request and fulfill_request
+# Tests for continue_request, fail_request and fulfill_request
+@pytest.mark.asyncio
+async def test_continue_request(mock_browser):
+    """Test continue_request with minimal parameters."""
+    request_id = 'test_request_123'
+    
+    await mock_browser.continue_request(request_id)
+    
+    mock_browser._connection_handler.execute_command.assert_called_with(
+        FetchCommands.continue_request(
+            request_id=request_id,
+            url=None,
+            method=None,
+            post_data=None,
+            headers=None,
+            intercept_response=None,
+        ), timeout=10
+    )
+
+
+@pytest.mark.asyncio
+async def test_continue_request_with_all_params(mock_browser):
+    """Test continue_request with all parameters."""
+    request_id = 'test_request_123'
+    url = 'https://modified-example.com'
+    method = RequestMethod.POST
+    post_data = 'modified_data=test'
+    headers = [{'name': 'Authorization', 'value': 'Bearer token123'}]
+    intercept_response = True
+    
+    await mock_browser.continue_request(
+        request_id=request_id,
+        url=url,
+        method=method,
+        post_data=post_data,
+        headers=headers,
+        intercept_response=intercept_response,
+    )
+    
+    mock_browser._connection_handler.execute_command.assert_called_with(
+        FetchCommands.continue_request(
+            request_id=request_id,
+            url=url,
+            method=method,
+            post_data=post_data,
+            headers=headers,
+            intercept_response=intercept_response,
+        ), timeout=10
+    )
+
+
 @pytest.mark.asyncio
 async def test_fail_request(mock_browser):
     """Test fail_request."""
@@ -628,19 +679,48 @@ async def test_fail_request(mock_browser):
 
 @pytest.mark.asyncio
 async def test_fulfill_request(mock_browser):
-    """Test fulfill_request."""
+    """Test fulfill_request with minimal parameters."""
+    request_id = 'test_request_123'
+    response_code = 200
+    
+    await mock_browser.fulfill_request(request_id, response_code)
+    
+    mock_browser._connection_handler.execute_command.assert_called_with(
+        FetchCommands.fulfill_request(
+            request_id=request_id,
+            response_code=response_code,
+            response_headers=None,
+            body=None,
+            response_phrase=None,
+        ), timeout=10
+    )
+
+
+@pytest.mark.asyncio
+async def test_fulfill_request_with_all_params(mock_browser):
+    """Test fulfill_request with all parameters."""
     request_id = 'test_request_123'
     response_code = 200
     response_headers = [{'name': 'Content-Type', 'value': 'application/json'}]
-    response_body = {'status': 'success', 'data': 'test'}
+    json_response = '{"status": "success", "data": "test"}'
+    body = base64.b64encode(json_response.encode('utf-8')).decode('utf-8')
+    response_phrase = 'OK'
 
     await mock_browser.fulfill_request(
-        request_id, response_code, response_headers, response_body
+        request_id=request_id,
+        response_code=response_code,
+        response_headers=response_headers,
+        body=body,
+        response_phrase=response_phrase,
     )
 
     mock_browser._connection_handler.execute_command.assert_called_with(
         FetchCommands.fulfill_request(
-            request_id, response_code, response_headers, response_body
+            request_id=request_id,
+            response_code=response_code,
+            response_headers=response_headers,
+            body=body,
+            response_phrase=response_phrase,
         ), timeout=10
     )