def run():
responses.add(
responses.GET,
"http://example.com",
match=[matchers.fragment_identifier_matcher("test=1&foo=bar")],
body=b"test",
)
resp = requests.get("http://example.com#test=1&foo=bar")
assert_response(resp, "test")
def run():
url = "http://example.com?ab=xy&zed=qwe#test=1&foo=bar"
responses.add(
responses.GET,
url,
match_querystring=True,
match=[matchers.fragment_identifier_matcher("test=1&foo=bar")],
body=b"test",
)
# two requests to check reversed order of fragment identifier
resp = requests.get("http://example.com?ab=xy&zed=qwe#test=1&foo=bar")
assert_response(resp, "test")
resp = requests.get("http://example.com?zed=qwe&ab=xy#foo=bar&test=1")
assert_response(resp, "test")
def run():
url = "http://example.com/"
responses.add(
method=responses.GET,
url=url,
body="success",
match=[
matchers.header_matcher({"Accept": "text/plain"}, strict_match=True)
],
)
# requests will add some extra headers of its own, so we have to use prepared requests
session = requests.Session()
# make sure we send *just* the header we're expectin
prepped = session.prepare_request(
requests.Request(
method="GET",
url=url,
)
)
prepped.headers.clear()
prepped.headers["Accept"] = "text/plain"
resp = session.send(prepped)
assert_response(resp, body="success", content_type="text/plain")
# include the "Accept-Charset" header, which will fail to match
prepped = session.prepare_request(
requests.Request(
method="GET",
url=url,
)
)
prepped.headers.clear()
prepped.headers["Accept"] = "text/plain"
prepped.headers["Accept-Charset"] = "utf-8"
with pytest.raises(ConnectionError) as excinfo:
session.send(prepped)
msg = str(excinfo.value)
assert (
"Headers do not match: {Accept: text/plain, Accept-Charset: utf-8} "
"doesn't match {Accept: text/plain}"
) in msg
def run():
responses.add(
method=responses.POST,
url="http://example.com/",
body="three",
match=[
matchers.urlencoded_params_matcher(
{"page": "", "type": "urlencoded"}, allow_blank=True
)
],
)
resp = requests.request(
"POST",
"http://example.com/",
headers={"Content-Type": "x-www-form-urlencoded"},
data={"page": "", "type": "urlencoded"},
)
assert_response(resp, "three")
def run():
url = "http://example.com/"
responses.add(
method=responses.GET,
url=url,
json={"success": True},
match=[matchers.header_matcher({"Accept": "application/json"})],
)
responses.add(
method=responses.GET,
url=url,
body="success",
match=[matchers.header_matcher({"Accept": "text/plain"})],
)
# the actual request can contain extra headers (requests always adds some itself anyway)
resp = requests.get(
url, headers={"Accept": "application/json", "Accept-Charset": "utf-8"}
)
assert_response(resp, body='{"success": true}', content_type="application/json")
resp = requests.get(url, headers={"Accept": "text/plain"})
assert_response(resp, body="success", content_type="text/plain")
def run(deprecated):
if deprecated:
json_params_matcher = getattr(responses, "json_params_matcher")
urlencoded_params_matcher = getattr(responses, "urlencoded_params_matcher")
else:
json_params_matcher = matchers.json_params_matcher
urlencoded_params_matcher = matchers.urlencoded_params_matcher
responses.add(
method=responses.POST,
url="http://example.com/",
body="one",
match=[json_params_matcher({"page": {"name": "first", "type": "json"}})],
)
responses.add(
method=responses.POST,
url="http://example.com/",
body="two",
match=[urlencoded_params_matcher({"page": "second", "type": "urlencoded"})],
)
resp = requests.request(
"POST",
"http://example.com/",
headers={"Content-Type": "x-www-form-urlencoded"},
data={"page": "second", "type": "urlencoded"},
)
assert_response(resp, "two")
resp = requests.request(
"POST",
"http://example.com/",
headers={"Content-Type": "application/json"},
json={"page": {"name": "first", "type": "json"}},
)
assert_response(resp, "one")
def run():
url = "http://example.com?test=1&foo=bar"
responses.add(
responses.GET,
url,
body=b"test",
match=[matchers.query_string_matcher("test=1&foo=bar")],
)
resp = requests.get("http://example.com?test=1&foo=bar")
assert_response(resp, "test")
resp = requests.get("http://example.com?foo=bar&test=1")
assert_response(resp, "test")
resp = requests.get("http://example.com/?foo=bar&test=1")
assert_response(resp, "test")
def run():
with responses.RequestsMock(assert_all_requests_are_fired=True) as rsps:
# test that both json and urlencoded body are empty in matcher and in request
rsps.add(
method=responses.POST,
url="http://example.com/",
body="one",
match=[matchers.json_params_matcher(None)],
)
rsps.add(
method=responses.POST,
url="http://example.com/",
body="two",
match=[matchers.urlencoded_params_matcher(None)],
)
resp = requests.request("POST", "http://example.com/")
assert_response(resp, "one")
resp = requests.request(
"POST",
"http://example.com/",
headers={"Content-Type": "x-www-form-urlencoded"},
)
assert_response(resp, "two")
with responses.RequestsMock(assert_all_requests_are_fired=False) as rsps:
# test exception raise if matcher body is None but request data is not None
rsps.add(
method=responses.POST,
url="http://example.com/",
body="one",
match=[matchers.json_params_matcher(None)],
)
with pytest.raises(ConnectionError) as excinfo:
requests.request(
"POST",
"http://example.com/",
json={"my": "data"},
headers={"Content-Type": "application/json"},
)
msg = str(excinfo.value)
assert "request.body doesn't match: {my: data} doesn't match {}" in msg
with responses.RequestsMock(assert_all_requests_are_fired=False) as rsps:
rsps.add(
method=responses.POST,
url="http://example.com/",
body="two",
match=[matchers.urlencoded_params_matcher(None)],
)
with pytest.raises(ConnectionError) as excinfo:
requests.request(
"POST",
"http://example.com/",
headers={"Content-Type": "x-www-form-urlencoded"},
data={"page": "second", "type": "urlencoded"},
)
msg = str(excinfo.value)
assert (
"request.body doesn't match: {page: second, type: urlencoded} doesn't match {}"
in msg
)