def test_invalid_urls():
with pytest.raises(httpcore.InvalidURL):
httpcore.Request("GET", "example.org")
with pytest.raises(httpcore.InvalidURL):
httpcore.Request("GET", "invalid://example.org")
with pytest.raises(httpcore.InvalidURL):
httpcore.Request("GET", "http:///foo")
def test_url():
request = httpcore.Request("GET", "http://example.org")
assert request.url.scheme == "http"
assert request.url.port == 80
assert request.url.full_path == "/"
request = httpcore.Request("GET", "https://example.org/abc?foo=bar")
assert request.url.scheme == "https"
assert request.url.port == 443
assert request.url.full_path == "/abc?foo=bar"
async def handle_async_request(
self,
request: Request,
) -> Response:
assert isinstance(request.stream, AsyncByteStream)
req = httpcore.Request(
method=request.method,
url=httpcore.URL(
scheme=request.url.raw_scheme,
host=request.url.raw_host,
port=request.url.port,
target=request.url.raw_path,
),
headers=request.headers.raw,
content=request.stream,
extensions=request.extensions,
)
with map_httpcore_exceptions():
resp = await self._pool.handle_async_request(req)
assert isinstance(resp.stream, typing.AsyncIterable)
return Response(
status_code=resp.status,
headers=resp.headers,
stream=AsyncResponseStream(resp.stream),
extensions=resp.extensions,
)
async def request(
self,
method,
url,
headers=(),
body=b"",
stream=False,
ssl=None,
timeout=None,
):
if ssl is None:
ssl = self.ssl_config
if timeout is None:
timeout = self.timeout
parsed_url = httpcore.URL(url)
request = httpcore.Request(
method, parsed_url, headers=headers, body=body
)
connection = await self.acquire_connection(
parsed_url, ssl=ssl, timeout=timeout
)
if self._request_delay:
print(f"\t>> Sleeping ({self._request_delay})")
await asyncio.sleep(self._request_delay)
response = await connection.send(request)
if not stream:
try:
await response.read()
finally:
await response.close()
return response
def test_request_with_invalid_headers():
with pytest.raises(TypeError) as exc_info:
httpcore.Request("GET", "https://www.example.com/",
headers=123) # type: ignore
assert (str(
exc_info.value
) == "headers must be a mapping or sequence of two-tuples, but got int.")
def test_override_accept_encoding_header():
headers = [(b"accept-encoding", b"identity")]
request = httpcore.Request("GET", "http://example.org", headers=headers)
request.prepare()
assert request.headers == httpcore.Headers([(b"host", b"example.org"),
(b"accept-encoding",
b"identity")])
def test_override_host_header():
headers = [(b"host", b"1.2.3.4:80")]
request = httpcore.Request("GET", "http://example.org", headers=headers)
request.prepare()
assert request.headers == httpcore.Headers([(b"accept-encoding",
b"deflate, gzip, br"),
(b"host", b"1.2.3.4:80")])
def test_content_length_header():
request = httpcore.Request("POST", "http://example.org", data=b"test 123")
request.prepare()
assert request.headers == httpcore.Headers([
(b"host", b"example.org"),
(b"content-length", b"8"),
(b"accept-encoding", b"deflate, gzip, br"),
])
def test_request():
request = httpcore.Request("GET", "https://www.example.com/")
assert request.method == b"GET"
assert request.url == httpcore.URL("https://www.example.com/")
assert request.headers == []
assert request.extensions == {}
assert repr(request) == "<Request [b'GET']>"
assert (
repr(request.url) ==
"URL(scheme=b'https', host=b'www.example.com', port=None, target=b'/')"
)
assert repr(request.stream) == "<ByteStream [0 bytes]>"
def test_url_encoded_data():
request = httpcore.Request("POST",
"http://example.org",
data={"test": "123"})
request.prepare()
assert request.headers == httpcore.Headers([
(b"host", b"example.org"),
(b"content-length", b"8"),
(b"accept-encoding", b"deflate, gzip, br"),
(b"content-type", b"application/x-www-form-urlencoded"),
])
assert request.content == b"test=123"
def test_transfer_encoding_header():
async def streaming_body(data):
yield data # pragma: nocover
data = streaming_body(b"test 123")
request = httpcore.Request("POST", "http://example.org", data=data)
request.prepare()
assert request.headers == httpcore.Headers([
(b"host", b"example.org"),
(b"transfer-encoding", b"chunked"),
(b"accept-encoding", b"deflate, gzip, br"),
])
def test_override_content_length_header():
async def streaming_body(data):
yield data # pragma: nocover
data = streaming_body(b"test 123")
headers = [(b"content-length", b"8")]
request = httpcore.Request("POST",
"http://example.org",
data=data,
headers=headers)
request.prepare()
assert request.headers == httpcore.Headers([
(b"host", b"example.org"),
(b"accept-encoding", b"deflate, gzip, br"),
(b"content-length", b"8"),
])
async def test_httpcore_request(url, port):
async with MockRouter(using="httpcore") as router:
router.get(url) % dict(text="foobar")
request = httpcore.Request(
b"GET",
httpcore.URL(scheme=b"https", host=b"foo.bar", port=port, target=b"/"),
)
with httpcore.ConnectionPool() as http:
response = http.handle_request(request)
body = response.read()
assert body == b"foobar"
async with httpcore.AsyncConnectionPool() as http:
response = await http.handle_async_request(request)
body = await response.aread()
assert body == b"foobar"
def test_request_repr():
request = httpcore.Request("GET", "http://example.org")
assert repr(request) == "<Request('GET', 'http://example.org')>"
def test_request_with_invalid_method():
with pytest.raises(TypeError) as exc_info:
httpcore.Request(123, "https://www.example.com/") # type: ignore
assert str(exc_info.value) == "method must be bytes or str, but got int."
def test_host_header():
request = httpcore.Request("GET", "http://example.org")
request.prepare()
assert request.headers == httpcore.Headers([(b"host", b"example.org"),
(b"accept-encoding",
b"deflate, gzip, br")])
def test_request_with_invalid_url():
with pytest.raises(TypeError) as exc_info:
httpcore.Request("GET", 123) # type: ignore
assert str(
exc_info.value) == "url must be a URL, bytes, or str, but got int."
