Reuse shared endpoint request helpers for computer actions

Co-authored-by: Shri Sukhani <shrisukhani@users.noreply.github.com>

Author: cursoragent

CONTRIBUTING.md

@@ -94,6 +94,7 @@ This runs lint, format checks, compile checks, tests, and package build.
   - `tests/test_computer_action_operation_metadata_usage.py` (computer-action manager operation-metadata usage enforcement),
   - `tests/test_computer_action_payload_helper_usage.py` (computer-action payload helper usage enforcement),
   - `tests/test_computer_action_request_helper_usage.py` (computer-action manager request-helper usage enforcement),
+  - `tests/test_computer_action_request_internal_reuse.py` (computer-action request-helper internal reuse of shared model request endpoint helpers),
   - `tests/test_contributing_architecture_guard_listing.py` (`CONTRIBUTING.md` architecture-guard inventory completeness enforcement),
   - `tests/test_core_type_helper_usage.py` (core transport/config/header/file/polling/session/error/parsing manager+tool module enforcement of shared plain-type helper usage),
   - `tests/test_default_serialization_helper_usage.py` (default optional-query serialization helper usage enforcement),

hyperbrowser/client/managers/computer_action_request_utils.py

@@ -2,7 +2,10 @@
 
 from hyperbrowser.models import ComputerActionResponse
 
-from .response_utils import parse_response_model
+from .model_request_utils import (
+    post_model_request_to_endpoint,
+    post_model_request_to_endpoint_async,
+)
 
 
 def execute_computer_action_request(
@@ -12,12 +15,10 @@ def execute_computer_action_request(
     payload: dict[str, Any],
     operation_name: str,
 ) -> ComputerActionResponse:
-    response = client.transport.post(
-        endpoint,
+    return post_model_request_to_endpoint(
+        client=client,
+        endpoint=endpoint,
         data=payload,
-    )
-    return parse_response_model(
-        response.data,
         model=ComputerActionResponse,
         operation_name=operation_name,
     )
@@ -30,12 +31,10 @@ async def execute_computer_action_request_async(
     payload: dict[str, Any],
     operation_name: str,
 ) -> ComputerActionResponse:
-    response = await client.transport.post(
-        endpoint,
+    return await post_model_request_to_endpoint_async(
+        client=client,
+        endpoint=endpoint,
         data=payload,
-    )
-    return parse_response_model(
-        response.data,
         model=ComputerActionResponse,
         operation_name=operation_name,
     )

hyperbrowser/client/managers/model_request_utils.py

@@ -167,3 +167,41 @@ async def put_model_request_async(
         model=model,
         operation_name=operation_name,
     )
+
+
+def post_model_request_to_endpoint(
+    *,
+    client: Any,
+    endpoint: str,
+    data: Dict[str, Any],
+    model: Type[T],
+    operation_name: str,
+) -> T:
+    response = client.transport.post(
+        endpoint,
+        data=data,
+    )
+    return parse_response_model(
+        response.data,
+        model=model,
+        operation_name=operation_name,
+    )
+
+
+async def post_model_request_to_endpoint_async(
+    *,
+    client: Any,
+    endpoint: str,
+    data: Dict[str, Any],
+    model: Type[T],
+    operation_name: str,
+) -> T:
+    response = await client.transport.post(
+        endpoint,
+        data=data,
+    )
+    return parse_response_model(
+        response.data,
+        model=model,
+        operation_name=operation_name,
+    )

tests/test_architecture_marker_usage.py

@@ -78,6 +78,7 @@
     "tests/test_computer_action_operation_metadata_usage.py",
     "tests/test_computer_action_payload_helper_usage.py",
     "tests/test_computer_action_request_helper_usage.py",
+    "tests/test_computer_action_request_internal_reuse.py",
     "tests/test_schema_injection_helper_usage.py",
     "tests/test_session_operation_metadata_usage.py",
     "tests/test_session_route_constants_usage.py",

tests/test_computer_action_request_internal_reuse.py

@@ -0,0 +1,16 @@
+from pathlib import Path
+
+import pytest
+
+pytestmark = pytest.mark.architecture
+
+
+def test_computer_action_request_utils_reuse_model_request_endpoint_helpers():
+    module_text = Path(
+        "hyperbrowser/client/managers/computer_action_request_utils.py"
+    ).read_text(encoding="utf-8")
+    assert "model_request_utils import" in module_text
+    assert "post_model_request_to_endpoint(" in module_text
+    assert "post_model_request_to_endpoint_async(" in module_text
+    assert "client.transport.post(" not in module_text
+    assert "parse_response_model(" not in module_text

tests/test_computer_action_request_utils.py

@@ -1,78 +1,57 @@
 import asyncio
-from types import SimpleNamespace
 
 import hyperbrowser.client.managers.computer_action_request_utils as request_utils
 
 
-def test_execute_computer_action_request_posts_and_parses_response():
+def test_execute_computer_action_request_delegates_to_endpoint_post_helper():
     captured = {}
 
-    class _SyncTransport:
-        def post(self, endpoint, data=None):
-            captured["endpoint"] = endpoint
-            captured["data"] = data
-            return SimpleNamespace(data={"success": True})
-
-    class _Client:
-        transport = _SyncTransport()
-
-    def _fake_parse_response_model(data, **kwargs):
-        captured["parse_data"] = data
-        captured["parse_kwargs"] = kwargs
+    def _fake_post_model_request_to_endpoint(**kwargs):
+        captured.update(kwargs)
         return {"parsed": True}
 
-    original_parse = request_utils.parse_response_model
-    request_utils.parse_response_model = _fake_parse_response_model
+    original = request_utils.post_model_request_to_endpoint
+    request_utils.post_model_request_to_endpoint = _fake_post_model_request_to_endpoint
     try:
         result = request_utils.execute_computer_action_request(
-            client=_Client(),
+            client=object(),
             endpoint="https://example.com/cua",
             payload={"action": {"type": "screenshot"}},
             operation_name="computer action",
         )
     finally:
-        request_utils.parse_response_model = original_parse
+        request_utils.post_model_request_to_endpoint = original
 
     assert result == {"parsed": True}
     assert captured["endpoint"] == "https://example.com/cua"
     assert captured["data"] == {"action": {"type": "screenshot"}}
-    assert captured["parse_data"] == {"success": True}
-    assert captured["parse_kwargs"]["operation_name"] == "computer action"
+    assert captured["operation_name"] == "computer action"
 
 
-def test_execute_computer_action_request_async_posts_and_parses_response():
+def test_execute_computer_action_request_async_delegates_to_endpoint_post_helper():
     captured = {}
 
-    class _AsyncTransport:
-        async def post(self, endpoint, data=None):
-            captured["endpoint"] = endpoint
-            captured["data"] = data
-            return SimpleNamespace(data={"success": True})
-
-    class _Client:
-        transport = _AsyncTransport()
-
-    def _fake_parse_response_model(data, **kwargs):
-        captured["parse_data"] = data
-        captured["parse_kwargs"] = kwargs
+    async def _fake_post_model_request_to_endpoint_async(**kwargs):
+        captured.update(kwargs)
         return {"parsed": True}
 
-    original_parse = request_utils.parse_response_model
-    request_utils.parse_response_model = _fake_parse_response_model
+    original = request_utils.post_model_request_to_endpoint_async
+    request_utils.post_model_request_to_endpoint_async = (
+        _fake_post_model_request_to_endpoint_async
+    )
     try:
         result = asyncio.run(
             request_utils.execute_computer_action_request_async(
-                client=_Client(),
+                client=object(),
                 endpoint="https://example.com/cua",
                 payload={"action": {"type": "screenshot"}},
                 operation_name="computer action",
             )
         )
     finally:
-        request_utils.parse_response_model = original_parse
+        request_utils.post_model_request_to_endpoint_async = original
 
     assert result == {"parsed": True}
     assert captured["endpoint"] == "https://example.com/cua"
     assert captured["data"] == {"action": {"type": "screenshot"}}
-    assert captured["parse_data"] == {"success": True}
-    assert captured["parse_kwargs"]["operation_name"] == "computer action"
+    assert captured["operation_name"] == "computer action"

tests/test_model_request_utils.py

@@ -334,3 +334,79 @@ def _fake_parse_response_model(data, **kwargs):
     assert captured["url"] == "https://api.example.test/resource/6"
     assert captured["parse_data"] == {"success": True}
     assert captured["parse_kwargs"]["operation_name"] == "delete resource"
+
+
+def test_post_model_request_to_endpoint_posts_and_parses_response():
+    captured = {}
+
+    class _SyncTransport:
+        def post(self, endpoint, data):
+            captured["endpoint"] = endpoint
+            captured["data"] = data
+            return SimpleNamespace(data={"id": "endpoint-resource"})
+
+    class _Client:
+        transport = _SyncTransport()
+
+    def _fake_parse_response_model(data, **kwargs):
+        captured["parse_data"] = data
+        captured["parse_kwargs"] = kwargs
+        return {"parsed": True}
+
+    original_parse = model_request_utils.parse_response_model
+    model_request_utils.parse_response_model = _fake_parse_response_model
+    try:
+        result = model_request_utils.post_model_request_to_endpoint(
+            client=_Client(),
+            endpoint="https://api.example.test/resource",
+            data={"name": "value"},
+            model=object,
+            operation_name="endpoint create",
+        )
+    finally:
+        model_request_utils.parse_response_model = original_parse
+
+    assert result == {"parsed": True}
+    assert captured["endpoint"] == "https://api.example.test/resource"
+    assert captured["data"] == {"name": "value"}
+    assert captured["parse_data"] == {"id": "endpoint-resource"}
+    assert captured["parse_kwargs"]["operation_name"] == "endpoint create"
+
+
+def test_post_model_request_to_endpoint_async_posts_and_parses_response():
+    captured = {}
+
+    class _AsyncTransport:
+        async def post(self, endpoint, data):
+            captured["endpoint"] = endpoint
+            captured["data"] = data
+            return SimpleNamespace(data={"id": "endpoint-resource-async"})
+
+    class _Client:
+        transport = _AsyncTransport()
+
+    def _fake_parse_response_model(data, **kwargs):
+        captured["parse_data"] = data
+        captured["parse_kwargs"] = kwargs
+        return {"parsed": True}
+
+    original_parse = model_request_utils.parse_response_model
+    model_request_utils.parse_response_model = _fake_parse_response_model
+    try:
+        result = asyncio.run(
+            model_request_utils.post_model_request_to_endpoint_async(
+                client=_Client(),
+                endpoint="https://api.example.test/resource",
+                data={"name": "value"},
+                model=object,
+                operation_name="endpoint create",
+            )
+        )
+    finally:
+        model_request_utils.parse_response_model = original_parse
+
+    assert result == {"parsed": True}
+    assert captured["endpoint"] == "https://api.example.test/resource"
+    assert captured["data"] == {"name": "value"}
+    assert captured["parse_data"] == {"id": "endpoint-resource-async"}
+    assert captured["parse_kwargs"]["operation_name"] == "endpoint create"