Reuse raw helpers for model get and delete parsing wrappers

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

Author: cursoragent

hyperbrowser/client/managers/model_request_utils.py

@@ -56,12 +56,13 @@ def get_model_request(
     model: Type[T],
     operation_name: str,
 ) -> T:
-    response = client.transport.get(
-        client._build_url(route_path),
+    response_data = get_model_response_data(
+        client=client,
+        route_path=route_path,
         params=params,
     )
     return parse_response_model(
-        response.data,
+        response_data,
         model=model,
         operation_name=operation_name,
     )
@@ -95,16 +96,28 @@ def delete_model_request(
     model: Type[T],
     operation_name: str,
 ) -> T:
-    response = client.transport.delete(
-        client._build_url(route_path),
+    response_data = delete_model_response_data(
+        client=client,
+        route_path=route_path,
     )
     return parse_response_model(
-        response.data,
+        response_data,
         model=model,
         operation_name=operation_name,
     )
 
 
+def delete_model_response_data(
+    *,
+    client: Any,
+    route_path: str,
+) -> Any:
+    response = client.transport.delete(
+        client._build_url(route_path),
+    )
+    return response.data
+
+
 def put_model_request(
     *,
     client: Any,
@@ -189,12 +202,13 @@ async def get_model_request_async(
     model: Type[T],
     operation_name: str,
 ) -> T:
-    response = await client.transport.get(
-        client._build_url(route_path),
+    response_data = await get_model_response_data_async(
+        client=client,
+        route_path=route_path,
         params=params,
     )
     return parse_response_model(
-        response.data,
+        response_data,
         model=model,
         operation_name=operation_name,
     )
@@ -228,16 +242,28 @@ async def delete_model_request_async(
     model: Type[T],
     operation_name: str,
 ) -> T:
-    response = await client.transport.delete(
-        client._build_url(route_path),
+    response_data = await delete_model_response_data_async(
+        client=client,
+        route_path=route_path,
     )
     return parse_response_model(
-        response.data,
+        response_data,
         model=model,
         operation_name=operation_name,
     )
 
 
+async def delete_model_response_data_async(
+    *,
+    client: Any,
+    route_path: str,
+) -> Any:
+    response = await client.transport.delete(
+        client._build_url(route_path),
+    )
+    return response.data
+
+
 async def put_model_request_async(
     *,
     client: Any,

tests/test_model_request_utils.py

@@ -158,6 +158,40 @@ def _fake_parse_response_model(data, **kwargs):
     assert captured["parse_kwargs"]["operation_name"] == "read resource"
 
 
+def test_get_model_request_delegates_to_raw_data_helper():
+    captured = {}
+
+    def _fake_get_model_response_data(**kwargs):
+        captured["kwargs"] = kwargs
+        return {"id": "resource-2"}
+
+    def _fake_parse_response_model(data, **kwargs):
+        captured["parse_data"] = data
+        captured["parse_kwargs"] = kwargs
+        return {"parsed": True}
+
+    original_get = model_request_utils.get_model_response_data
+    original_parse = model_request_utils.parse_response_model
+    model_request_utils.get_model_response_data = _fake_get_model_response_data
+    model_request_utils.parse_response_model = _fake_parse_response_model
+    try:
+        result = model_request_utils.get_model_request(
+            client=object(),
+            route_path="/resource/2",
+            params={"page": 1},
+            model=object,
+            operation_name="read resource",
+        )
+    finally:
+        model_request_utils.get_model_response_data = original_get
+        model_request_utils.parse_response_model = original_parse
+
+    assert result == {"parsed": True}
+    assert captured["kwargs"]["route_path"] == "/resource/2"
+    assert captured["kwargs"]["params"] == {"page": 1}
+    assert captured["parse_data"] == {"id": "resource-2"}
+
+
 def test_get_model_response_data_gets_payload_without_parsing():
     captured = {}
 
@@ -188,6 +222,30 @@ def _build_url(path: str) -> str:
     assert captured["follow_redirects"] is True
 
 
+def test_delete_model_response_data_deletes_resource_and_returns_raw_data():
+    captured = {}
+
+    class _SyncTransport:
+        def delete(self, url):
+            captured["url"] = url
+            return SimpleNamespace(data={"success": True})
+
+    class _Client:
+        transport = _SyncTransport()
+
+        @staticmethod
+        def _build_url(path: str) -> str:
+            return f"https://api.example.test{path}"
+
+    result = model_request_utils.delete_model_response_data(
+        client=_Client(),
+        route_path="/resource/3",
+    )
+
+    assert result == {"success": True}
+    assert captured["url"] == "https://api.example.test/resource/3"
+
+
 def test_delete_model_request_deletes_resource_and_parses_response():
     captured = {}
 
@@ -226,6 +284,38 @@ def _fake_parse_response_model(data, **kwargs):
     assert captured["parse_kwargs"]["operation_name"] == "delete resource"
 
 
+def test_delete_model_request_delegates_to_raw_data_helper():
+    captured = {}
+
+    def _fake_delete_model_response_data(**kwargs):
+        captured["kwargs"] = kwargs
+        return {"success": True}
+
+    def _fake_parse_response_model(data, **kwargs):
+        captured["parse_data"] = data
+        captured["parse_kwargs"] = kwargs
+        return {"parsed": True}
+
+    original_delete = model_request_utils.delete_model_response_data
+    original_parse = model_request_utils.parse_response_model
+    model_request_utils.delete_model_response_data = _fake_delete_model_response_data
+    model_request_utils.parse_response_model = _fake_parse_response_model
+    try:
+        result = model_request_utils.delete_model_request(
+            client=object(),
+            route_path="/resource/3",
+            model=object,
+            operation_name="delete resource",
+        )
+    finally:
+        model_request_utils.delete_model_response_data = original_delete
+        model_request_utils.parse_response_model = original_parse
+
+    assert result == {"parsed": True}
+    assert captured["kwargs"]["route_path"] == "/resource/3"
+    assert captured["parse_data"] == {"success": True}
+
+
 def test_put_model_response_data_forwards_payload_and_returns_raw_data():
     captured = {}
 
@@ -415,6 +505,44 @@ def _fake_parse_response_model(data, **kwargs):
     assert captured["parse_kwargs"]["operation_name"] == "read resource"
 
 
+def test_get_model_request_async_delegates_to_raw_data_helper():
+    captured = {}
+
+    async def _fake_get_model_response_data_async(**kwargs):
+        captured["kwargs"] = kwargs
+        return {"id": "resource-5"}
+
+    def _fake_parse_response_model(data, **kwargs):
+        captured["parse_data"] = data
+        captured["parse_kwargs"] = kwargs
+        return {"parsed": True}
+
+    original_get = model_request_utils.get_model_response_data_async
+    original_parse = model_request_utils.parse_response_model
+    model_request_utils.get_model_response_data_async = (
+        _fake_get_model_response_data_async
+    )
+    model_request_utils.parse_response_model = _fake_parse_response_model
+    try:
+        result = asyncio.run(
+            model_request_utils.get_model_request_async(
+                client=object(),
+                route_path="/resource/5",
+                params={"page": 2},
+                model=object,
+                operation_name="read resource",
+            )
+        )
+    finally:
+        model_request_utils.get_model_response_data_async = original_get
+        model_request_utils.parse_response_model = original_parse
+
+    assert result == {"parsed": True}
+    assert captured["kwargs"]["route_path"] == "/resource/5"
+    assert captured["kwargs"]["params"] == {"page": 2}
+    assert captured["parse_data"] == {"id": "resource-5"}
+
+
 def test_get_model_response_data_async_gets_payload_without_parsing():
     captured = {}
 
@@ -447,6 +575,32 @@ def _build_url(path: str) -> str:
     assert captured["follow_redirects"] is True
 
 
+def test_delete_model_response_data_async_deletes_resource_and_returns_raw_data():
+    captured = {}
+
+    class _AsyncTransport:
+        async def delete(self, url):
+            captured["url"] = url
+            return SimpleNamespace(data={"success": True})
+
+    class _Client:
+        transport = _AsyncTransport()
+
+        @staticmethod
+        def _build_url(path: str) -> str:
+            return f"https://api.example.test{path}"
+
+    result = asyncio.run(
+        model_request_utils.delete_model_response_data_async(
+            client=_Client(),
+            route_path="/resource/6",
+        )
+    )
+
+    assert result == {"success": True}
+    assert captured["url"] == "https://api.example.test/resource/6"
+
+
 def test_delete_model_request_async_deletes_resource_and_parses_response():
     captured = {}
 
@@ -487,6 +641,42 @@ def _fake_parse_response_model(data, **kwargs):
     assert captured["parse_kwargs"]["operation_name"] == "delete resource"
 
 
+def test_delete_model_request_async_delegates_to_raw_data_helper():
+    captured = {}
+
+    async def _fake_delete_model_response_data_async(**kwargs):
+        captured["kwargs"] = kwargs
+        return {"success": True}
+
+    def _fake_parse_response_model(data, **kwargs):
+        captured["parse_data"] = data
+        captured["parse_kwargs"] = kwargs
+        return {"parsed": True}
+
+    original_delete = model_request_utils.delete_model_response_data_async
+    original_parse = model_request_utils.parse_response_model
+    model_request_utils.delete_model_response_data_async = (
+        _fake_delete_model_response_data_async
+    )
+    model_request_utils.parse_response_model = _fake_parse_response_model
+    try:
+        result = asyncio.run(
+            model_request_utils.delete_model_request_async(
+                client=object(),
+                route_path="/resource/6",
+                model=object,
+                operation_name="delete resource",
+            )
+        )
+    finally:
+        model_request_utils.delete_model_response_data_async = original_delete
+        model_request_utils.parse_response_model = original_parse
+
+    assert result == {"parsed": True}
+    assert captured["kwargs"]["route_path"] == "/resource/6"
+    assert captured["parse_data"] == {"success": True}
+
+
 def test_put_model_response_data_async_forwards_payload_and_returns_raw_data():
     captured = {}