async def handle_async_request( self, method: bytes, url: typing.Tuple[bytes, bytes, typing.Optional[int], bytes], headers: typing.List[typing.Tuple[bytes, bytes]], stream: AsyncByteStream, extensions: dict, ) -> typing.Tuple[int, typing.List[typing.Tuple[bytes, bytes]], AsyncByteStream, dict]: with map_httpcore_exceptions(): ( status_code, headers, byte_stream, extensions, ) = await self._pool.handle_async_request( method=method, url=url, headers=headers, stream=httpcore.AsyncIteratorByteStream(stream.__aiter__()), extensions=extensions, ) stream = AsyncResponseStream(byte_stream) return status_code, headers, stream, extensions
async def handle_async_request( self, method: bytes, url: typing.Tuple[bytes, bytes, typing.Optional[int], bytes], headers: typing.List[typing.Tuple[bytes, bytes]], stream: typing.AsyncIterable[bytes], extensions: dict, ) -> typing.Tuple[int, typing.List[typing.Tuple[bytes, bytes]], typing.AsyncIterable[bytes], dict]: with map_httpcore_exceptions(): status_code, headers, byte_stream, extensions = await self._pool.arequest( method=method, url=url, headers=headers, stream=httpcore.AsyncIteratorByteStream(stream.__aiter__()), ext=extensions, ) async def response_stream() -> typing.AsyncIterator[bytes]: with map_httpcore_exceptions(): async for part in byte_stream: yield part async def aclose() -> None: with map_httpcore_exceptions(): await byte_stream.aclose() ensure_http_version_reason_phrase_as_bytes(extensions) extensions["aclose"] = aclose return status_code, headers, response_stream(), extensions
async def arequest( self, method: bytes, url: Tuple[bytes, bytes, Optional[int], bytes], headers: Headers = None, stream: httpcore.AsyncByteStream = None, ext: dict = None, ) -> Tuple[int, Headers, httpcore.AsyncByteStream, dict]: stream_id = self._quic.get_next_available_stream_id() self._read_queue[stream_id] = deque() self._read_ready[stream_id] = asyncio.Event() # prepare request self._http.send_headers( stream_id=stream_id, headers=[ (b":method", method), (b":scheme", url[0]), (b":authority", url[1]), (b":path", url[3]), ] + [(k.lower(), v) for (k, v) in headers if k.lower() not in (b"connection", b"host")], ) async for data in stream: self._http.send_data(stream_id=stream_id, data=data, end_stream=False) self._http.send_data(stream_id=stream_id, data=b"", end_stream=True) # transmit request self.transmit() # process response status_code, headers, stream_ended = await self._receive_response( stream_id) response_stream = httpcore.AsyncIteratorByteStream( aiterator=self._receive_response_data(stream_id, stream_ended)) return ( status_code, headers, response_stream, { "http_version": "HTTP/3", }, )
async def test(respx_mock): assert respx.calls.call_count == 0 async def raw_stream(): yield b"foo" yield b"bar" stream = httpcore.AsyncIteratorByteStream(raw_stream()) request = respx_mock.get("https://foo.bar/").mock( return_value=httpx.Response(202, stream=stream)) response = await client.get("https://foo.bar/") assert request.called is True assert response.status_code == 202 assert response.content == b"foobar" assert respx.calls.call_count == 0 assert respx_mock.calls.call_count == 1 with pytest.raises(AssertionError, match="not mocked"): httpx.post("https://foo.bar/")
async def arequest( self, method: bytes, url: URL, headers: Headers = None, stream: httpcore.AsyncByteStream = None, ext: dict = None, ) -> Tuple[int, Headers, httpcore.AsyncByteStream, dict]: self.state = ConnectionState.ACTIVE self.stream_count += 1 async def on_close(): self.stream_count -= 1 if self.stream_count == 0: self.state = ConnectionState.IDLE async def aiterator() -> AsyncIterator[bytes]: yield b"" stream = httpcore.AsyncIteratorByteStream(aiterator=aiterator(), aclose_func=on_close) return 200, [], stream, {}