Add async E2E coverage

Author: kvz

tests/test_async_client.py

@@ -274,6 +274,7 @@ async def test_async_client_methods_and_context_manager(self):
             self.assertEqual(response.data["ok"], "ASSEMBLY_COMPLETED")
             self.assertEqual(response.data["assembly_id"], "abc123")
             self.assertEqual(response.status_code, 200)
+            self.assertIs(type(response.headers), dict)
             self.assertEqual(response.headers["X-Async-Route"], "get_assembly")
 
             response = await client.list_assemblies()
@@ -383,6 +384,18 @@ async def test_async_client_close_reopens_owned_session(self):
 
         await client.close()
 
+    async def test_async_request_owned_sessions_trust_environment(self):
+        session = _NeverOwnedSession()
+        client = AsyncTransloadit("key", "secret", service=self.server.base_url)
+
+        with mock.patch("aiohttp.ClientSession", return_value=session) as session_mock:
+            ensured_session = await client.request._ensure_session()
+
+        self.assertIs(ensured_session, session)
+        session_mock.assert_called_once_with(trust_env=True)
+
+        await client.close()
+
     async def test_async_client_reopens_owned_session_when_session_is_closed(self):
         client = AsyncTransloadit("key", "secret", service=self.server.base_url)
 
@@ -521,7 +534,7 @@ async def test_async_assembly_wait_returns_plain_text_poll_response(self):
     def test_async_signed_smart_cdn_url_matches_sync_and_rejects_bad_types(self):
         async_client = AsyncTransloadit("test-key", "test-secret")
         sync_client = Transloadit("test-key", "test-secret")
-        params = {"width": 100, "tags": ["a", "b"], "enabled": True, "skip": None}
+        params = {"width": 100, "tags": ["a", "b"], "enabled": True, "flags": [True, False], "skip": None}
 
         with mock.patch("time.time", return_value=1732550672.867):
             async_url = async_client.get_signed_smart_cdn_url(
@@ -569,6 +582,9 @@ def test_async_signed_smart_cdn_url_matches_sync_and_rejects_bad_types(self):
         self.assertIn("width=100", async_url)
         self.assertIn("tags=a", async_url)
         self.assertIn("tags=b", async_url)
+        self.assertIn("enabled=true", async_url)
+        self.assertIn("flags=true", async_url)
+        self.assertIn("flags=false", async_url)
         self.assertIn("exp=1732550672867", explicit_async_url)
         self.assertNotIn("width=", bare_async_url)
         self.assertNotIn("skip=", async_url)
@@ -908,7 +924,7 @@ def uploader(self, **kwargs):
         post_mock.assert_awaited_once()
         self.assertEqual(calls, [])
 
-    async def test_async_assembly_resumable_response_without_upload_urls_skips_tus_upload(self):
+    async def test_async_assembly_resumable_response_without_upload_urls_raises_before_tus_upload(self):
         calls = []
 
         class _TusClient:
@@ -930,9 +946,9 @@ def uploader(self, **kwargs):
 
             with mock.patch.object(client.request, "post", new=mock.AsyncMock(return_value=incomplete_response)) as post_mock:
                 with mock.patch("transloadit.async_assembly.tus.TusClient", new=_TusClient):
-                    response = await assembly.create(resumable=True)
+                    with self.assertRaises(RuntimeError):
+                        await assembly.create(resumable=True)
 
-        self.assertIs(response, incomplete_response)
         post_mock.assert_awaited_once()
         self.assertEqual(calls, [])
 
@@ -988,7 +1004,12 @@ def uploader(self, **kwargs):
                     response = await assembly.create(resumable=True)
 
         self.assertEqual(response.data["ok"], "ASSEMBLY_COMPLETED")
-        self.assertEqual(to_thread_mock.await_count, 1)
+        tus_upload_calls = [
+            call
+            for call in to_thread_mock.await_args_list
+            if getattr(call.args[0], "__name__", "") == "_do_tus_upload"
+        ]
+        self.assertEqual(len(tus_upload_calls), 1)
 
         create_request = next(
             entry for entry in self.server.requests if entry["path"] == "/assemblies" and entry["method"] == "POST"
@@ -1232,6 +1253,25 @@ async def test_async_request_uses_connect_and_read_timeouts_for_uploads(self):
         self.assertIsNone(timeout.sock_read)
         self.assertEqual(session.calls[0][1]["data"]._fields[2][1]["Content-Type"], "image/jpeg")
 
+    async def test_async_request_payload_preserves_custom_auth_constraints(self):
+        client = AsyncTransloadit("key", "secret", service=self.server.base_url)
+
+        payload = client.request._to_payload(
+            {
+                "auth": {
+                    "max_size": 1024,
+                    "referer": "https://example.com",
+                },
+                "foo": "bar",
+            }
+        )
+
+        params = json.loads(payload["params"])
+        self.assertEqual(params["auth"]["key"], "key")
+        self.assertIn("expires", params["auth"])
+        self.assertEqual(params["auth"]["max_size"], 1024)
+        self.assertEqual(params["auth"]["referer"], "https://example.com")
+
     async def test_async_request_filters_none_and_lowercases_booleans_in_extra_data(self):
         session = _RecordingSession({"ok": "ASSEMBLY_COMPLETED"})
         client = AsyncTransloadit("key", "secret", service=self.server.base_url, session=session)

tests/test_e2e_upload.py

@@ -1,8 +1,10 @@
 import os
 from pathlib import Path
+from unittest import IsolatedAsyncioTestCase
 
 import pytest
 
+from transloadit.async_client import AsyncTransloadit
 from transloadit.client import Transloadit
 
 
@@ -17,38 +19,39 @@ def _is_enabled():
 ]
 
 
-def test_e2e_image_resize():
+def _get_e2e_credentials():
     key = os.getenv("TRANSLOADIT_KEY")
     secret = os.getenv("TRANSLOADIT_SECRET")
 
     if not key or not secret:
         pytest.skip("TRANSLOADIT_KEY and TRANSLOADIT_SECRET must be set to run E2E tests")
 
+    return key, secret
+
+
+def _get_fixture_path():
     fixture_path = Path(__file__).resolve().parents[1] / "chameleon.jpg"
     if not fixture_path.exists():
         pytest.skip("chameleon.jpg fixture missing; run from repository root")
 
-    client = Transloadit(key, secret)
+    return fixture_path
 
-    assembly = client.new_assembly()
 
-    with fixture_path.open("rb") as upload:
-        assembly.add_file(upload)
-        assembly.add_step(
-            "resize",
-            "/image/resize",
-            {
-                "use": ":original",
-                "width": 128,
-                "height": 128,
-                "resize_strategy": "fit",
-                "format": "png",
-            },
-        )
+def _add_resize_step(assembly):
+    assembly.add_step(
+        "resize",
+        "/image/resize",
+        {
+            "use": ":original",
+            "width": 128,
+            "height": 128,
+            "resize_strategy": "fit",
+            "format": "png",
+        },
+    )
 
-        response = assembly.create(wait=True, resumable=False)
 
-    data = response.data
+def _assert_e2e_image_resize(data, fixture_path):
     assembly_ssl_url = data.get("assembly_ssl_url") or data.get("assembly_url")
     assembly_id = data.get("assembly_id")
     print(f"[python-sdk][e2e] Assembly URL: {assembly_ssl_url} (id={assembly_id})")
@@ -85,3 +88,34 @@ def test_e2e_image_resize():
         f"{width}x{height}, ssl_url={ssl_url}, basename={upload_info.get('basename')}, "
         f"filename={upload_info.get('name')}"
     )
+
+
+def test_e2e_image_resize():
+    key, secret = _get_e2e_credentials()
+    fixture_path = _get_fixture_path()
+    client = Transloadit(key, secret)
+
+    assembly = client.new_assembly()
+
+    with fixture_path.open("rb") as upload:
+        assembly.add_file(upload)
+        _add_resize_step(assembly)
+        response = assembly.create(wait=True, resumable=False)
+
+    _assert_e2e_image_resize(response.data, fixture_path)
+
+
+class TestAsyncE2EUpload(IsolatedAsyncioTestCase):
+    async def test_e2e_image_resize(self):
+        key, secret = _get_e2e_credentials()
+        fixture_path = _get_fixture_path()
+
+        async with AsyncTransloadit(key, secret) as client:
+            assembly = client.new_assembly()
+
+            with fixture_path.open("rb") as upload:
+                assembly.add_file(upload)
+                _add_resize_step(assembly)
+                response = await assembly.create(wait=True, resumable=False)
+
+        _assert_e2e_image_resize(response.data, fixture_path)

tests/test_request.py

@@ -1,3 +1,4 @@
+import json
 import unittest
 import urllib.parse
 
@@ -38,6 +39,23 @@ def test_post(self, mock):
         response = self.request.post("/foo", data={"foo": "bar"})
         self.assertEqual(response.data["ok"], "it works")
 
+    def test_payload_preserves_custom_auth_constraints(self):
+        payload = self.request._to_payload(
+            {
+                "auth": {
+                    "max_size": 1024,
+                    "referer": "https://example.com",
+                },
+                "foo": "bar",
+            }
+        )
+
+        params = json.loads(payload["params"])
+        self.assertEqual(params["auth"]["key"], "key")
+        self.assertIn("expires", params["auth"])
+        self.assertEqual(params["auth"]["max_size"], 1024)
+        self.assertEqual(params["auth"]["referer"], "https://example.com")
+
     @requests_mock.Mocker()
     def test_put(self, mock):
         url = f"{self.transloadit.service}/foo"

transloadit/async_assembly.py

@@ -130,7 +130,7 @@ async def create(self, wait=False, resumable=True, retries=3):
 
             if resumable and self.files:
                 if not assembly_url or not tus_url:
-                    return response
+                    raise RuntimeError("Resumable assembly response is missing upload URLs.")
                 await self._do_tus_upload_async(assembly_url, tus_url, tus_retries)
 
             if wait:

transloadit/async_client.py

@@ -7,6 +7,12 @@
 from . import async_assembly, async_request, async_template
 
 
+def _stringify_url_param(value: Union[str, int, float, bool]) -> str:
+    if isinstance(value, bool):
+        return "true" if value else "false"
+    return str(value)
+
+
 class AsyncTransloadit:
     """
     Asynchronous client interface to the Transloadit API.
@@ -133,9 +139,9 @@ def get_signed_smart_cdn_url(
                 if v is None:
                     continue
                 elif isinstance(v, (str, int, float, bool)):
-                    params.append((k, str(v)))
+                    params.append((k, _stringify_url_param(v)))
                 elif isinstance(v, (list, tuple)):
-                    params.append((k, [str(vv) for vv in v]))
+                    params.append((k, [_stringify_url_param(vv) for vv in v]))
                 else:
                     raise ValueError(
                         f"URL parameter values must be strings, numbers, booleans, arrays, or None. Got {type(v)} for {k}"

transloadit/async_request.py

@@ -59,11 +59,11 @@ async def _ensure_session(self):
             return self._session
         async with self._get_session_lock():
             if self._session is None:
-                self._session = aiohttp.ClientSession()
+                self._session = aiohttp.ClientSession(trust_env=True)
                 self._owns_session = True
             elif self._session.closed:
                 if self._owns_session:
-                    self._session = aiohttp.ClientSession()
+                    self._session = aiohttp.ClientSession(trust_env=True)
                 else:
                     raise RuntimeError("Injected aiohttp session is closed.")
             return self._session
@@ -75,10 +75,12 @@ async def aclose(self):
                 self._session = None
 
     def _timeout(self, files=False):
+        # Large uploads can legitimately wait longer than TIMEOUT for the first response byte.
+        sock_read = None if files else TIMEOUT
         return aiohttp.ClientTimeout(
             total=None,
             sock_connect=TIMEOUT,
-            sock_read=None if files else TIMEOUT,
+            sock_read=sock_read,
         )
 
     def _normalize_payload(self, data):
@@ -115,7 +117,7 @@ async def get(self, path, params=None):
             return Response(
                 data=await self._read_response_data(response),
                 status_code=response.status,
-                headers=response.headers,
+                headers=dict(response.headers),
             )
 
     async def post(self, path, data=None, extra_data=None, files=None):
@@ -149,7 +151,7 @@ async def post(self, path, data=None, extra_data=None, files=None):
             return Response(
                 data=await self._read_response_data(response),
                 status_code=response.status,
-                headers=response.headers,
+                headers=dict(response.headers),
             )
 
     async def put(self, path, data=None):
@@ -167,7 +169,7 @@ async def put(self, path, data=None):
             return Response(
                 data=await self._read_response_data(response),
                 status_code=response.status,
-                headers=response.headers,
+                headers=dict(response.headers),
             )
 
     async def delete(self, path, data=None):
@@ -185,16 +187,18 @@ async def delete(self, path, data=None):
             return Response(
                 data=await self._read_response_data(response),
                 status_code=response.status,
-                headers=response.headers,
+                headers=dict(response.headers),
             )
 
     def _to_payload(self, data):
         data = copy.deepcopy(data or {})
         expiry = datetime.now(timezone.utc) + timedelta(seconds=self.transloadit.duration)
-        data["auth"] = {
+        auth = data.get("auth") if isinstance(data.get("auth"), dict) else {}
+        auth.update({
             "key": self.transloadit.auth_key,
             "expires": expiry.strftime("%Y/%m/%d %H:%M:%S+00:00"),
-        }
+        })
+        data["auth"] = auth
         json_data = json.dumps(data)
         return {"params": json_data, "signature": self._sign_data(json_data)}
 

transloadit/client.py

@@ -12,6 +12,12 @@
     from requests import Response
 
 
+def _stringify_url_param(value: Union[str, int, float, bool]) -> str:
+    if isinstance(value, bool):
+        return "true" if value else "false"
+    return str(value)
+
+
 class Transloadit:
     """
     This class serves as a client interface to the Transloadit API.
@@ -210,9 +216,9 @@ def get_signed_smart_cdn_url(
                 if v is None:
                     continue  # Skip None values
                 elif isinstance(v, (str, int, float, bool)):
-                    params.append((k, str(v)))
+                    params.append((k, _stringify_url_param(v)))
                 elif isinstance(v, (list, tuple)):
-                    params.append((k, [str(vv) for vv in v]))
+                    params.append((k, [_stringify_url_param(vv) for vv in v]))
                 else:
                     raise ValueError(f"URL parameter values must be strings, numbers, booleans, arrays, or None. Got {type(v)} for {k}")
 

transloadit/request.py

@@ -114,10 +114,12 @@ def delete(self, path, data=None):
     def _to_payload(self, data):
         data = copy.deepcopy(data or {})
         expiry = datetime.now(timezone.utc) + timedelta(seconds=self.transloadit.duration)
-        data["auth"] = {
+        auth = data.get("auth") if isinstance(data.get("auth"), dict) else {}
+        auth.update({
             "key": self.transloadit.auth_key,
             "expires": expiry.strftime("%Y/%m/%d %H:%M:%S+00:00"),
-        }
+        })
+        data["auth"] = auth
         json_data = json.dumps(data)
         return {"params": json_data, "signature": self._sign_data(json_data)}