Address async council review findings

Author: kvz

tests/test_async_client.py

@@ -215,6 +215,17 @@ async def text(self):
         return json.dumps(self.payload)
 
 
+class _UndecodableResponse:
+    async def json(self, **kwargs):
+        raise UnicodeDecodeError("utf-8", b"\xff", 0, 1, "invalid start byte")
+
+    async def text(self):
+        raise UnicodeDecodeError("utf-8", b"\xff", 0, 1, "invalid start byte")
+
+    async def read(self):
+        return b"\xff"
+
+
 class _RecordingSession:
     def __init__(self, payload):
         self.calls = []
@@ -406,6 +417,13 @@ async def test_async_client_delete_template_get_bill_and_plain_text_fallback(sel
         self.assertEqual(response.status_code, 200)
         self.assertEqual(response.headers["X-Async-Route"], "get_assembly_plain")
 
+    async def test_async_request_falls_back_to_bytes_when_text_decode_fails(self):
+        client = AsyncTransloadit("key", "secret", service=self.server.base_url)
+
+        data = await client.request._read_response_data(_UndecodableResponse())
+
+        self.assertEqual(data, b"\xff")
+
     async def test_async_assembly_create_raises_on_plain_text_error_response(self):
         plain_response = Response(
             data="plain assembly response",
@@ -670,6 +688,10 @@ def __init__(self, tus_url):
 
         self.assertEqual(response.data["ok"], "ASSEMBLY_COMPLETED")
         post_mock.assert_awaited_once()
+        self.assertEqual(
+            post_mock.await_args.kwargs["extra_data"],
+            {"tus_num_expected_upload_files": 0},
+        )
         get_mock.assert_awaited_once_with(
             assembly_url=f"{self.server.base_url}/assemblies/assembly-123"
         )
@@ -1040,6 +1062,55 @@ async def test_async_assembly_wait_retries_after_polling_rate_limit(self):
         )
         self.assertEqual(sleep_mock.await_args_list, [mock.call(0), mock.call(0)])
 
+    async def test_async_assembly_wait_does_not_follow_poll_response_assembly_url(self):
+        initial_url = f"{self.server.base_url}/assemblies/assembly-123"
+
+        async with AsyncTransloadit("key", "secret", service=self.server.base_url) as client:
+            assembly = client.new_assembly()
+
+            initial = Response(
+                data={
+                    "ok": "ASSEMBLY_PROCESSING",
+                    "info": {"retryIn": 0},
+                    "assembly_ssl_url": initial_url,
+                },
+                status_code=200,
+                headers={},
+            )
+            malicious_poll = Response(
+                data={
+                    "ok": "ASSEMBLY_PROCESSING",
+                    "error": "ASSEMBLY_STATUS_FETCHING_RATE_LIMIT_REACHED",
+                    "info": {"retryIn": 0},
+                    "assembly_ssl_url": "https://example.invalid/assemblies/evil",
+                },
+                status_code=200,
+                headers={},
+            )
+            completed = Response(
+                data={"ok": "ASSEMBLY_COMPLETED", "assembly_id": "assembly-123"},
+                status_code=200,
+                headers={},
+            )
+
+            with mock.patch.object(client.request, "post", new=mock.AsyncMock(return_value=initial)):
+                with mock.patch.object(
+                    client,
+                    "get_assembly",
+                    new=mock.AsyncMock(side_effect=[malicious_poll, completed]),
+                ) as get_mock:
+                    with mock.patch("asyncio.sleep", new_callable=mock.AsyncMock):
+                        response = await assembly.create(wait=True, resumable=False, retries=2)
+
+        self.assertEqual(response.data["ok"], "ASSEMBLY_COMPLETED")
+        self.assertEqual(
+            get_mock.await_args_list,
+            [
+                mock.call(assembly_url=initial_url),
+                mock.call(assembly_url=initial_url),
+            ],
+        )
+
     async def test_async_assembly_wait_returns_last_poll_response_when_budget_exhausted(self):
         async with AsyncTransloadit("key", "secret", service=self.server.base_url) as client:
             assembly = client.new_assembly()

transloadit/async_assembly.py

@@ -91,7 +91,7 @@ async def create(self, wait=False, resumable=True, retries=3):
 
         while True:
             if resumable:
-                extra_data = {"tus_num_expected_upload_files": len(self.files)} if self.files else None
+                extra_data = {"tus_num_expected_upload_files": len(self.files)}
                 response = await self.transloadit.request.post(
                     "/assemblies", extra_data=extra_data, data=data
                 )
@@ -148,14 +148,13 @@ async def create(self, wait=False, resumable=True, retries=3):
                     sleep_time = poll_data.get("info", {}).get("retryIn", 1)
                     await asyncio.sleep(sleep_time)
                     poll_response = await self.transloadit.get_assembly(
-                        assembly_url=assembly_url or poll_data.get("assembly_ssl_url")
+                        assembly_url=assembly_url
                     )
                     poll_data = self._response_data(poll_response)
                     if poll_data is None:
                         if poll_response.status_code >= 400:
                             raise RuntimeError(f"Unexpected non-JSON response ({poll_response.status_code}).")
                         return poll_response
-                    assembly_url = poll_data.get("assembly_ssl_url") or assembly_url
 
                 return poll_response
 

transloadit/async_request.py

@@ -96,7 +96,10 @@ async def _read_response_data(self, response):
         try:
             return await response.json(content_type=None)
         except (aiohttp.ContentTypeError, json.JSONDecodeError, UnicodeDecodeError):
-            return await response.text()
+            try:
+                return await response.text()
+            except UnicodeDecodeError:
+                return await response.read()
 
     async def get(self, path, params=None):
         """