Reuse model request helpers for extension create flow

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

Author: cursoragent

CONTRIBUTING.md

@@ -107,6 +107,7 @@ This runs lint, format checks, compile checks, tests, and package build.
   - `tests/test_extension_create_helper_usage.py` (extension create-input normalization helper usage enforcement),
   - `tests/test_extension_operation_metadata_usage.py` (extension manager operation-metadata usage enforcement),
   - `tests/test_extension_request_helper_usage.py` (extension manager request-helper usage enforcement),
+  - `tests/test_extension_request_internal_reuse.py` (extension request-helper internal reuse of shared model request helpers),
   - `tests/test_extension_route_constants_usage.py` (extension manager route-constant usage enforcement),
   - `tests/test_extract_payload_helper_usage.py` (extract start-payload helper usage enforcement),
   - `tests/test_guardrail_ast_utils.py` (shared AST guard utility contract),

hyperbrowser/client/managers/extension_request_utils.py

@@ -1,7 +1,7 @@
 from typing import Any, IO, List, Type, TypeVar
 
 from .extension_utils import parse_extension_list_response_data
-from .response_utils import parse_response_model
+from .model_request_utils import post_model_request, post_model_request_async
 from hyperbrowser.models.extension import ExtensionResponse
 
 T = TypeVar("T")
@@ -16,13 +16,11 @@ def create_extension_resource(
     model: Type[T],
     operation_name: str,
 ) -> T:
-    response = client.transport.post(
-        client._build_url(route_path),
+    return post_model_request(
+        client=client,
+        route_path=route_path,
         data=payload,
         files={"file": file_stream},
-    )
-    return parse_response_model(
-        response.data,
         model=model,
         operation_name=operation_name,
     )
@@ -48,13 +46,11 @@ async def create_extension_resource_async(
     model: Type[T],
     operation_name: str,
 ) -> T:
-    response = await client.transport.post(
-        client._build_url(route_path),
+    return await post_model_request_async(
+        client=client,
+        route_path=route_path,
         data=payload,
         files={"file": file_stream},
-    )
-    return parse_response_model(
-        response.data,
         model=model,
         operation_name=operation_name,
     )

hyperbrowser/client/managers/model_request_utils.py

@@ -10,13 +10,21 @@ def post_model_request(
     client: Any,
     route_path: str,
     data: Dict[str, Any],
+    files: Optional[Dict[str, Any]] = None,
     model: Type[T],
     operation_name: str,
 ) -> T:
-    response = client.transport.post(
-        client._build_url(route_path),
-        data=data,
-    )
+    if files is None:
+        response = client.transport.post(
+            client._build_url(route_path),
+            data=data,
+        )
+    else:
+        response = client.transport.post(
+            client._build_url(route_path),
+            data=data,
+            files=files,
+        )
     return parse_response_model(
         response.data,
         model=model,
@@ -84,13 +92,21 @@ async def post_model_request_async(
     client: Any,
     route_path: str,
     data: Dict[str, Any],
+    files: Optional[Dict[str, Any]] = None,
     model: Type[T],
     operation_name: str,
 ) -> T:
-    response = await client.transport.post(
-        client._build_url(route_path),
-        data=data,
-    )
+    if files is None:
+        response = await client.transport.post(
+            client._build_url(route_path),
+            data=data,
+        )
+    else:
+        response = await client.transport.post(
+            client._build_url(route_path),
+            data=data,
+            files=files,
+        )
     return parse_response_model(
         response.data,
         model=model,

tests/test_architecture_marker_usage.py

@@ -56,6 +56,7 @@
     "tests/test_examples_naming_convention.py",
     "tests/test_extension_operation_metadata_usage.py",
     "tests/test_extension_request_helper_usage.py",
+    "tests/test_extension_request_internal_reuse.py",
     "tests/test_extension_route_constants_usage.py",
     "tests/test_job_pagination_helper_usage.py",
     "tests/test_job_fetch_helper_boundary.py",

tests/test_extension_request_internal_reuse.py

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

tests/test_extension_request_utils.py

@@ -5,49 +5,33 @@
 import hyperbrowser.client.managers.extension_request_utils as extension_request_utils
 
 
-def test_create_extension_resource_uses_post_and_parses_response():
+def test_create_extension_resource_delegates_to_post_model_request():
     captured = {}
 
-    class _SyncTransport:
-        def post(self, url, data=None, files=None):
-            captured["url"] = url
-            captured["data"] = data
-            captured["files"] = files
-            return SimpleNamespace(data={"id": "ext_1"})
-
-    class _Client:
-        transport = _SyncTransport()
-
-        @staticmethod
-        def _build_url(path: str) -> str:
-            return f"https://api.example.test{path}"
-
-    def _fake_parse_response_model(data, **kwargs):
-        captured["parse_data"] = data
-        captured["parse_kwargs"] = kwargs
+    def _fake_post_model_request(**kwargs):
+        captured.update(kwargs)
         return {"parsed": True}
 
-    original_parse = extension_request_utils.parse_response_model
-    extension_request_utils.parse_response_model = _fake_parse_response_model
+    original = extension_request_utils.post_model_request
+    extension_request_utils.post_model_request = _fake_post_model_request
     try:
         file_stream = BytesIO(b"ext")
         result = extension_request_utils.create_extension_resource(
-            client=_Client(),
+            client=object(),
             route_path="/extensions/add",
             payload={"name": "ext"},
             file_stream=file_stream,
             model=object,
             operation_name="create extension",
         )
     finally:
-        extension_request_utils.parse_response_model = original_parse
+        extension_request_utils.post_model_request = original
 
     assert result == {"parsed": True}
-    assert captured["url"] == "https://api.example.test/extensions/add"
+    assert captured["route_path"] == "/extensions/add"
     assert captured["data"] == {"name": "ext"}
     assert captured["files"] == {"file": file_stream}
-    assert captured["parse_data"] == {"id": "ext_1"}
-    assert captured["parse_kwargs"]["operation_name"] == "create extension"
+    assert captured["operation_name"] == "create extension"
 
 
 def test_list_extension_resources_uses_get_and_extension_parser():
@@ -86,35 +70,20 @@ def _fake_parse_extension_list_response_data(data):
     assert captured["parse_data"] == {"extensions": []}
 
 
-def test_create_extension_resource_async_uses_post_and_parses_response():
+def test_create_extension_resource_async_delegates_to_post_model_request_async():
     captured = {}
 
-    class _AsyncTransport:
-        async def post(self, url, data=None, files=None):
-            captured["url"] = url
-            captured["data"] = data
-            captured["files"] = files
-            return SimpleNamespace(data={"id": "ext_2"})
-
-    class _Client:
-        transport = _AsyncTransport()
-
-        @staticmethod
-        def _build_url(path: str) -> str:
-            return f"https://api.example.test{path}"
-
-    def _fake_parse_response_model(data, **kwargs):
-        captured["parse_data"] = data
-        captured["parse_kwargs"] = kwargs
+    async def _fake_post_model_request_async(**kwargs):
+        captured.update(kwargs)
         return {"parsed": True}
 
-    original_parse = extension_request_utils.parse_response_model
-    extension_request_utils.parse_response_model = _fake_parse_response_model
+    original = extension_request_utils.post_model_request_async
+    extension_request_utils.post_model_request_async = _fake_post_model_request_async
     try:
         file_stream = BytesIO(b"ext")
         result = asyncio.run(
             extension_request_utils.create_extension_resource_async(
-                client=_Client(),
+                client=object(),
                 route_path="/extensions/add",
                 payload={"name": "ext"},
                 file_stream=file_stream,
@@ -123,14 +92,13 @@ def _fake_parse_response_model(data, **kwargs):
             )
         )
     finally:
-        extension_request_utils.parse_response_model = original_parse
+        extension_request_utils.post_model_request_async = original
 
     assert result == {"parsed": True}
-    assert captured["url"] == "https://api.example.test/extensions/add"
+    assert captured["route_path"] == "/extensions/add"
     assert captured["data"] == {"name": "ext"}
     assert captured["files"] == {"file": file_stream}
-    assert captured["parse_data"] == {"id": "ext_2"}
-    assert captured["parse_kwargs"]["operation_name"] == "create extension"
+    assert captured["operation_name"] == "create extension"
 
 
 def test_list_extension_resources_async_uses_get_and_extension_parser():

tests/test_model_request_utils.py

@@ -45,6 +45,48 @@ def _fake_parse_response_model(data, **kwargs):
     assert captured["parse_kwargs"]["operation_name"] == "create resource"
 
 
+def test_post_model_request_forwards_files_when_provided():
+    captured = {}
+
+    class _SyncTransport:
+        def post(self, url, data, files=None):
+            captured["url"] = url
+            captured["data"] = data
+            captured["files"] = files
+            return SimpleNamespace(data={"id": "resource-file"})
+
+    class _Client:
+        transport = _SyncTransport()
+
+        @staticmethod
+        def _build_url(path: str) -> str:
+            return f"https://api.example.test{path}"
+
+    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(
+            client=_Client(),
+            route_path="/resource",
+            data={"name": "value"},
+            files={"file": object()},
+            model=object,
+            operation_name="create resource",
+        )
+    finally:
+        model_request_utils.parse_response_model = original_parse
+
+    assert result == {"parsed": True}
+    assert captured["url"] == "https://api.example.test/resource"
+    assert captured["files"] is not None
+    assert captured["parse_data"] == {"id": "resource-file"}
+
+
 def test_get_model_request_gets_payload_and_parses_response():
     captured = {}
 
@@ -167,6 +209,50 @@ def _fake_parse_response_model(data, **kwargs):
     assert captured["parse_kwargs"]["operation_name"] == "create resource"
 
 
+def test_post_model_request_async_forwards_files_when_provided():
+    captured = {}
+
+    class _AsyncTransport:
+        async def post(self, url, data, files=None):
+            captured["url"] = url
+            captured["data"] = data
+            captured["files"] = files
+            return SimpleNamespace(data={"id": "resource-file-async"})
+
+    class _Client:
+        transport = _AsyncTransport()
+
+        @staticmethod
+        def _build_url(path: str) -> str:
+            return f"https://api.example.test{path}"
+
+    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_async(
+                client=_Client(),
+                route_path="/resource",
+                data={"name": "value"},
+                files={"file": object()},
+                model=object,
+                operation_name="create resource",
+            )
+        )
+    finally:
+        model_request_utils.parse_response_model = original_parse
+
+    assert result == {"parsed": True}
+    assert captured["url"] == "https://api.example.test/resource"
+    assert captured["files"] is not None
+    assert captured["parse_data"] == {"id": "resource-file-async"}
+
+
 def test_get_model_request_async_gets_payload_and_parses_response():
     captured = {}