fix tests and doc

Author: TingDaoK

awscrt/aio/http_asyncio.py

@@ -26,7 +26,7 @@
 
 class HttpClientConnectionAsyncUnified(HttpClientConnectionBase):
     """
-    An async HTTP client connection.
+    An async unified HTTP client connection for either a HTTP/1 or HTTP/2 connection.
 
     Use `HttpClientConnectionAsync.new()` to establish a new connection.
     """
@@ -89,23 +89,24 @@ def request(self,
                 request: 'HttpRequest',
                 async_body: AsyncIterator[bytes] = None,
                 loop: Optional[asyncio.AbstractEventLoop] = None) -> 'HttpClientStreamAsyncUnified':
-        """Create `HttpClientStreamAsync` to carry out the request/response exchange.
+        """Create `HttpClientStreamAsyncUnified` to carry out the request/response exchange.
 
         Args:
             request (HttpRequest): Definition for outgoing request.
+            async_body (AsyncIterator[bytes], optional): Async iterator providing chunks of the request body.
+                If provided, the body will be sent incrementally as chunks become available.
             loop (Optional[asyncio.AbstractEventLoop]): Event loop to use for async operations.
                 If None, the current event loop is used.
 
         Returns:
-            HttpClientStreamAsync: Stream for the HTTP request/response exchange.
+            HttpClientStreamAsyncUnified: Stream for the HTTP request/response exchange.
         """
-        # return HttpClientStreamAsyncBase(self, request, loop)
-        pass
+        raise NotImplementedError("Subclasses must implement request")
 
 
 class HttpClientConnectionAsync(HttpClientConnectionAsyncUnified):
     """
-    An async HTTP/1.1 client connection.
+    An async HTTP/1.1 only client connection.
 
     Use `HttpClientConnectionAsync.new()` to establish a new connection.
     """
@@ -161,6 +162,8 @@ def request(self,
 
         Args:
             request (HttpRequest): Definition for outgoing request.
+            async_body (AsyncIterator[bytes], optional): Async iterator providing chunks of the request body.
+                Not supported for HTTP/1.1 connections yet, use the request's body_stream instead.
             loop (Optional[asyncio.AbstractEventLoop]): Event loop to use for async operations.
                 If None, the current event loop is used.
 
@@ -172,7 +175,7 @@ def request(self,
 
 class Http2ClientConnectionAsync(HttpClientConnectionAsyncUnified):
     """
-    An async HTTP/2 client connection.
+    An async HTTP/2 only client connection.
 
     Use `Http2ClientConnectionAsync.new()` to establish a new connection.
     """
@@ -224,7 +227,8 @@ def request(self,
 
         Args:
             request (HttpRequest): Definition for outgoing request.
-            manual_write (bool): If True, enables manual data writing on the stream.
+            async_body (AsyncIterator[bytes], optional): Async iterator providing chunks of the request body.
+                If provided, the body will be sent incrementally as chunks become available from the iterator.
             loop (Optional[asyncio.AbstractEventLoop]): Event loop to use for async operations.
                 If None, the current event loop is used.
 

test/test_http_asyncio.py

@@ -317,17 +317,22 @@ async def _test_h2_manual_write_exception(self):
 
         request = HttpRequest('GET', url.path)
         request.headers.add('host', url.hostname)
+
+        # Create stream without using async_body parameter
+        # (which would be needed to properly configure it for writing)
         stream = connection.request(request)
 
+        # The stream should have write_data attribute but using it should raise an exception
+        # since the stream isn't properly configured for manual writing
         exception = None
         try:
-            # If the stream is not configured to allow manual writes, this should throw an exception
-            await stream.write_data(BytesIO(b'hello'), False)
-        except RuntimeError as e:
+            # Attempt to access internal write_data method which should raise an exception
+            # since the stream wasn't created with async_body
+            await stream._write_data(BytesIO(b'hello'), False)
+        except (RuntimeError, AttributeError) as e:
             exception = e
 
         self.assertIsNotNone(exception)
-
         await connection.close()
 
     def test_connect_http(self):
@@ -563,13 +568,18 @@ async def _test_h2_mock_server_manual_write(self):
 
         request = HttpRequest('POST', self.mock_server_url.path)
         request.headers.add('host', self.mock_server_url.hostname)
-        stream = connection.request(request, manual_write=True)
 
-        # Write data in chunks
-        await stream.write_data(BytesIO(b'hello'), False)
-        await stream.write_data(BytesIO(b'he123123'), False)
-        await stream.write_data(None, False)
-        await stream.write_data(BytesIO(b'hello'), True)
+        # Create an async generator for the request body
+        body_chunks = [b'hello', b'he123123', b'', b'hello']
+        total_length = 0
+        for i in body_chunks:
+            total_length = total_length + len(i)
+
+        async def body_generator():
+            for i in body_chunks:
+                yield i
+
+        stream = connection.request(request, async_body=body_generator())
 
         # Collect response
         response = Response()
@@ -578,7 +588,8 @@ async def _test_h2_mock_server_manual_write(self):
         # Check result
         self.assertEqual(200, status_code)
         self.assertEqual(200, response.status_code)
-
+        # mock server response the total length received, check if it matches what we sent
+        self.assertEqual(total_length, int(response.body.decode()))
         await connection.close()
 
     class DelayStream:
@@ -598,60 +609,6 @@ def read(self, _len):
                 self._read = True
                 return b'hello'
 
-    async def _test_h2_mock_server_manual_write_read_exception(self):
-        connection = await self._new_mock_connection()
-        # check we set an h2 connection
-        self.assertEqual(connection.version, HttpVersion.Http2)
-
-        request = HttpRequest('POST', self.mock_server_url.path)
-        request.headers.add('host', self.mock_server_url.hostname)
-        stream = connection.request(request, manual_write=True)
-
-        # Try to write data with a bad stream that raises an exception
-        exception = None
-        data = self.DelayStream(bad_read=True)
-        try:
-            await stream.write_data(data, False)
-        except Exception as e:
-            exception = e
-        stream_completion_exception = None
-        try:
-            await stream.wait_for_completion()
-        except Exception as e:
-            stream_completion_exception = e
-
-        self.assertIsNotNone(exception)
-        self.assertIsNotNone(stream_completion_exception)
-        # assert that the exception is the same as the one we got from write_data.
-        self.assertEqual(str(exception), str(stream_completion_exception))
-        await connection.close()
-
-    async def _test_h2_mock_server_manual_write_lifetime(self):
-        connection = await self._new_mock_connection()
-        # check we set an h2 connection
-        self.assertEqual(connection.version, HttpVersion.Http2)
-
-        request = HttpRequest('POST', self.mock_server_url.path)
-        request.headers.add('host', self.mock_server_url.hostname)
-        stream = connection.request(request, manual_write=True)
-
-        # Create data stream and immediately delete the reference after writing
-        data = self.DelayStream(bad_read=False)
-        await stream.write_data(data, False)
-        del data
-
-        # Finish the request
-        await stream.write_data(None, True)
-
-        # Collect response
-        response = Response()
-        status_code = await response.collect_response(stream)
-
-        # Check result
-        self.assertEqual(200, status_code)
-
-        await connection.close()
-
     async def _test_h2_mock_server_settings(self):
         # Test with invalid settings - should throw an exception
         exception = None
@@ -669,9 +626,12 @@ async def _test_h2_mock_server_settings(self):
 
         request = HttpRequest('POST', self.mock_server_url.path)
         request.headers.add('host', self.mock_server_url.hostname)
-        stream = connection.request(request, manual_write=True)
 
-        await stream.write_data(BytesIO(b'hello'), True)
+        # Create an async generator for the request body
+        async def body_generator():
+            yield b'hello'
+
+        stream = connection.request(request, async_body=body_generator())
 
         response = Response()
         status_code = await response.collect_response(stream)
@@ -684,12 +644,6 @@ async def _test_h2_mock_server_settings(self):
     def test_h2_mock_server_manual_write(self):
         asyncio.run(self._test_h2_mock_server_manual_write())
 
-    def test_h2_mock_server_manual_write_read_exception(self):
-        asyncio.run(self._test_h2_mock_server_manual_write_read_exception())
-
-    def test_h2_mock_server_manual_write_lifetime(self):
-        asyncio.run(self._test_h2_mock_server_manual_write_lifetime())
-
     def test_h2_mock_server_settings(self):
         asyncio.run(self._test_h2_mock_server_settings())