def __init__(
self,
status_code: Optional[int] = None,
*,
content: Optional[ContentDataTypes] = None,
text: Optional[str] = None,
html: Optional[str] = None,
json: Optional[JSONTypes] = None,
headers: Optional[HeaderTypes] = None,
content_type: Optional[str] = None,
http_version: Optional[str] = None,
context: Optional[Kwargs] = None,
) -> None:
self.http_version = http_version
self.status_code = status_code or 200
self.context = context if context is not None else {}
self.headers = httpx.Headers(headers) if headers else httpx.Headers()
if content_type:
self.headers["Content-Type"] = content_type
# Set body variants in reverse priority order
self.json = json
self.html = html
self.text = text
self.content = content
def test_headers():
h = httpx.Headers([("a", "123"), ("a", "456"), ("b", "789")])
assert "a" in h
assert "A" in h
assert "b" in h
assert "B" in h
assert "c" not in h
assert h["a"] == "123, 456"
assert h.get("a") == "123, 456"
assert h.get("nope", default=None) is None
assert h.getlist("a") == ["123", "456"]
assert h.keys() == ["a", "a", "b"]
assert h.values() == ["123", "456", "789"]
assert h.items() == [("a", "123"), ("a", "456"), ("b", "789")]
assert list(h) == ["a", "a", "b"]
assert dict(h) == {"a": "123, 456", "b": "789"}
assert repr(h) == "Headers([('a', '123'), ('a', '456'), ('b', '789')])"
assert h == httpx.Headers([("a", "123"), ("b", "789"), ("a", "456")])
assert h != [("a", "123"), ("A", "456"), ("b", "789")]
h = httpx.Headers({"a": "123", "b": "789"})
assert h["A"] == "123"
assert h["B"] == "789"
assert h.raw == [(b"a", b"123"), (b"b", b"789")]
assert repr(h) == "Headers({'a': '123', 'b': '789'})"
def test_multiple_headers():
"""
`Headers.get_list` should support both split_commas=False and split_commas=True.
"""
h = httpx.Headers([("set-cookie", "a, b"), ("set-cookie", "c")])
assert h.get_list("Set-Cookie") == ["a, b", "c"]
h = httpx.Headers([("vary", "a, b"), ("vary", "c")])
assert h.get_list("Vary", split_commas=True) == ["a", "b", "c"]
def test_multiple_headers():
"""
Most headers should split by commas for `getlist`, except 'Set-Cookie'.
"""
h = httpx.Headers([("set-cookie", "a, b"), ("set-cookie", "c")])
h.getlist("Set-Cookie") == ["a, b", "b"]
h = httpx.Headers([("vary", "a, b"), ("vary", "c")])
h.getlist("Vary") == ["a", "b", "c"]
async def test_json_content(client, content, headers, expected_headers):
async with MockRouter() as respx_mock:
url = "https://foo.bar/"
request = respx_mock.get(url) % dict(json=content, headers=headers)
async_response = await client.get(url)
assert request.called is True
assert async_response.headers == httpx.Headers(expected_headers)
assert async_response.json() == content
respx_mock.reset()
sync_response = httpx.get(url)
assert request.called is True
assert sync_response.headers == httpx.Headers(expected_headers)
assert sync_response.json() == content
async def test_json_content(client, content, headers, expected_headers):
async with respx.HTTPXMock() as httpx_mock:
url = "https://foo.bar/"
request = httpx_mock.get(url, content=content, headers=headers)
async_response = await client.get(url)
assert request.called is True
assert async_response.headers == httpx.Headers(expected_headers or headers)
assert async_response.json() == content
httpx_mock.reset()
sync_response = httpx.get(url)
assert request.called is True
assert sync_response.headers == httpx.Headers(expected_headers or headers)
assert sync_response.json() == content
async def test_headers(client, headers, content_type, expected):
async with respx.HTTPXMock() as httpx_mock:
url = "https://foo.bar/"
request = httpx_mock.get(url, content_type=content_type, headers=headers)
response = await client.get(url)
assert request.called is True
assert response.headers == httpx.Headers(expected)
def test_generator_with_content_length_header():
def content():
yield b"test 123" # pragma: nocover
headers = {"Content-Length": "8"}
response = httpx.Response(200, content=content(), headers=headers)
assert response.headers == httpx.Headers({"Content-Length": "8"})
def test_headers_list_repr():
"""
Headers should display with a list repr if they include multiple identical keys.
"""
headers = httpx.Headers([("custom", "example 1"), ("custom", "example 2")])
assert (repr(headers) ==
"Headers([('custom', 'example 1'), ('custom', 'example 2')])")
async def test_request_callback(client):
def callback(request, response):
request.read()
if request.url.host == "foo.bar" and request.content == b'{"foo": "bar"}':
response.headers["X-Foo"] = "bar"
response.content = lambda request, name: f"hello {name}"
response.context["name"] = "lundberg"
response.http_version = "HTTP/2"
return response
async with MockTransport(assert_all_called=False) as respx_mock:
request = respx_mock.add(callback,
status_code=202,
headers={"X-Ham": "spam"})
response = await client.post("https://foo.bar/", json={"foo": "bar"})
assert request.called is True
assert request.pass_through is None
assert response.status_code == 202
assert response.http_version == "HTTP/2"
assert response.headers == httpx.Headers({
"Content-Type": "text/plain; charset=utf-8",
"Content-Length": "14",
"X-Ham": "spam",
"X-Foo": "bar",
})
assert response.text == "hello lundberg"
with pytest.raises(ValueError):
respx_mock.add(lambda req, res: "invalid")
await client.get("https://ham.spam/")
def test_header_as_httpx_headers(httpx_mock: HTTPXMock):
httpx_mock.add_response(headers=httpx.Headers({"set-cookie": "key=value"}))
with httpx.Client() as client:
response = client.get("http://test_url")
assert dict(response.cookies) == {"key": "value"}
def test_headers_encoding_in_repr():
"""
Headers should display an encoding in the repr if required.
"""
headers = httpx.Headers({b"custom": "example ☃".encode("utf-8")})
assert repr(
headers) == "Headers({'custom': 'example ☃'}, encoding='utf-8')"
async def test_asgi(): # pragma: nocover
from respx.mocks import HTTPCoreMocker
try:
HTTPCoreMocker.add_targets(
"httpx._transports.asgi.ASGITransport",
"httpx._transports.wsgi.WSGITransport",
)
async with respx.mock:
async with httpx.AsyncClient(app="fake-asgi") as client:
url = "https://foo.bar/"
jzon = {"status": "ok"}
headers = {"X-Foo": "bar"}
request = respx.get(url) % dict(
status_code=202, headers=headers, json=jzon)
response = await client.get(url)
assert request.called is True
assert response.status_code == 202
assert response.headers == httpx.Headers({
"Content-Type": "application/json",
"Content-Length": "16",
**headers,
})
assert response.json() == {"status": "ok"}
finally:
HTTPCoreMocker.remove_targets(
"httpx._transports.asgi.ASGITransport",
"httpx._transports.wsgi.WSGITransport",
)
def test_sensitive_headers(header):
"""
Some headers should be obfuscated because they contain sensitive data.
"""
value = "s3kr3t"
h = httpx.Headers({header: value})
assert repr(h) == "Headers({'%s': '[secure]'})" % header
async def test_request_callback(client):
def callback(request, response):
if request.url.host == "foo.bar":
response.headers["X-Foo"] = "bar"
response.content = lambda request, name: f"hello {name}"
response.context["name"] = "lundberg"
return response
async with respx.HTTPXMock(assert_all_called=False) as httpx_mock:
request = httpx_mock.request(
callback, status_code=202, headers={"X-Ham": "spam"}
)
response = await client.get("https://foo.bar/")
assert request.called is True
assert request.pass_through is None
assert response.status_code == 202
assert response.headers == httpx.Headers(
{"Content-Type": "text/plain", "X-Ham": "spam", "X-Foo": "bar"}
)
assert response.text == "hello lundberg"
with pytest.raises(ValueError):
httpx_mock.request(lambda req, res: "invalid")
await client.get("https://ham.spam/")
async def test_headers(client, headers, content_type, expected):
async with MockRouter() as respx_mock:
url = "https://foo.bar/"
request = respx_mock.get(url).respond(headers=headers,
content_type=content_type)
response = await client.get(url)
assert request.called is True
assert response.headers == httpx.Headers(expected)
def test_headers_decode_iso_8859_1():
"""
Headers containing non-UTF-8 codepoints should default to decoding as iso-8859-1.
"""
raw_headers = [(b"Custom", "Code point: ÿ".encode("iso-8859-1"))]
headers = httpx.Headers(raw_headers)
assert dict(headers) == {"custom": "Code point: ÿ"}
assert headers.encoding == "iso-8859-1"
def test_headers_decode_utf_8():
"""
Headers containing non-ascii codepoints should default to decoding as utf-8.
"""
raw_headers = [(b"Custom", "Code point: ☃".encode("utf-8"))]
headers = httpx.Headers(raw_headers)
assert dict(headers) == {"custom": "Code point: ☃"}
assert headers.encoding == "utf-8"
def test_headers_decode_ascii():
"""
Headers should decode as ascii by default.
"""
raw_headers = [(b"Custom", b"Example")]
headers = httpx.Headers(raw_headers)
assert dict(headers) == {"custom": "Example"}
assert headers.encoding == "ascii"
def parse(self, request: RequestTypes) -> httpx.Headers:
if isinstance(request, httpx.Request):
headers = request.headers
else:
_, _, _headers, *_ = request
headers = httpx.Headers(_headers)
return headers
def test_headers():
request = httpx.Request("POST", "http://example.org", json={"test": 123})
assert request.headers == httpx.Headers({
"Host": "example.org",
"Content-Type": "application/json",
"Content-Length": "13",
})
def get_client(token):
return httpx.Client(
headers=httpx.Headers(
{
"User-Agent": "GitHubClassroomUtils/1.0",
"Authorization": f"token {token}",
}
)
)
def test_with_headers(httpx_mock: HTTPXMock):
httpx_mock.add_response(url="http://test_url",
data=b"test content 1",
headers={"X-Test": "Test value"})
with httpx.Client() as client:
response = client.get("http://test_url")
assert response.content == b"test content 1"
assert response.headers == httpx.Headers({"x-test": "Test value"})
def test_default_response(httpx_mock: HTTPXMock):
httpx_mock.add_response()
with httpx.Client() as client:
response = client.get("http://test_url")
assert response.content == b""
assert response.status_code == 200
assert response.headers == httpx.Headers({})
assert response.http_version == "HTTP/1.1"
def test_generator_with_transfer_encoding_header():
def content():
yield b"test 123" # pragma: nocover
request = httpx.Request("POST", "http://example.org", content=content())
assert request.headers == httpx.Headers({
"Host": "example.org",
"Transfer-Encoding": "chunked"
})
def auth_flow(self, request):
body_sha512 = b64encode(
hashlib.sha512(request.content).digest()).decode('ascii')
headers_to_sign = tuple(request.headers.items()) + (
('digest', f'SHA512={body_sha512}'), )
request.headers = httpx.Headers(
sign_headers(self.key_id, self.private_key.sign,
request.method, request.url.full_path,
headers_to_sign))
yield request
def test_iterable_content():
class Content:
def __iter__(self):
yield b"test 123" # pragma: nocover
request = httpx.Request("POST", "http://example.org", content=Content())
assert request.headers == httpx.Headers({
"Host": "example.org",
"Transfer-Encoding": "chunked"
})
def test_headers_decode_explicit_encoding():
"""
An explicit encoding may be set on headers in order to force a
particular decoding.
"""
raw_headers = [(b"Custom", "Code point: ☃".encode("utf-8"))]
headers = httpx.Headers(raw_headers)
headers.encoding = "iso-8859-1"
assert dict(headers) == {"custom": "Code point: â\x98\x83"}
assert headers.encoding == "iso-8859-1"
def test_get_file_status(event_loop):
headers = httpx.Headers({'Authorization': auth})
with httpx.Client() as s:
token = s.get(endpoint, headers=headers).json()['delegationToken']
client = WebHdfsAsyncClient(host='namenode.local',
port=8443,
user='******',
kerberos_token=token)
response = event_loop.run_until_complete(
client.get_file_status("/tmp/dos.txt"))
assert response['FileStatus']['type'] == 'FILE'
def ensure_gh_token(token: str):
"""
Raise token error if token is valid by requesting github
"""
httpx_headers = httpx.Headers({
"User-Agent": "GitHubClassroomUtils/1.0",
"Authorization": f"token {token}",
})
res = httpx.get("https://api.github.com/user", headers=httpx_headers)
if res.status_code != 200:
raise ERR_INVALID_GITHUB_TOKEN(token=token)
