def test_and_predicate_and_query_strings(mock_server):
imposter = Imposter(
Stub(
Predicate(query={"foo": "bar"})
& Predicate(query={"dinner": "chips"}),
Response(body="black pudding"),
))
with mock_server(imposter) as s:
logger.debug("server: %s", s)
r1 = requests.get(f"{imposter.url}/",
params={
"dinner": "chips",
"foo": "bar"
})
r2 = requests.get(f"{imposter.url}/", params={"dinner": "chips"})
assert_that(
r1,
is_response().with_status_code(200).and_body("black pudding"))
assert_that(
r2,
not_(
is_response().with_status_code(200).and_body("black pudding")))
def test_response_matcher_cookies():
# Given
response = MOCK_RESPONSE
# When
# Then
assert_that(response, is_response().with_cookies({"name": "value"}))
assert_that(response, not_(is_response().with_cookies({"name": "nope"})))
assert_that(
str(is_response().with_cookies({"name": "value"})),
contains_string("response with cookies: <{'name': 'value'}"),
)
assert_that(
is_response().with_cookies({"name": "nope"}),
mismatches_with(
response,
contains_string(
"was response with cookies: was <{'name': 'value'}")),
)
assert_that(
is_response().with_cookies({"name": "value"}),
matches_with(
response,
contains_string(
"was response with cookies: was <{'name': 'value'}")),
)
def test_response_matcher_elapsed():
# Given
response = MOCK_RESPONSE
# When
# Then
assert_that(response, is_response().with_elapsed(timedelta(seconds=1)))
assert_that(response,
not_(is_response().with_elapsed(timedelta(seconds=60))))
assert_that(
str(is_response().with_elapsed(timedelta(seconds=1))),
contains_string("response with elapsed: <0:00:01>"),
)
assert_that(
is_response().with_elapsed(timedelta(seconds=60)),
mismatches_with(
response,
contains_string("was response with elapsed: was <0:00:01>")),
)
assert_that(
is_response().with_elapsed(timedelta(seconds=1)),
matches_with(
response,
contains_string("was response with elapsed: was <0:00:01>")),
)
def test_response_matcher_content():
# Given
stub_response = MOCK_RESPONSE
# When
# Then
assert_that(stub_response, is_response().with_content(b"content"))
assert_that(stub_response, not_(is_response().with_content(b"chips")))
assert_that(
str(is_response().with_content(b"content")),
contains_string("response with content: <b'content'>"),
)
assert_that(
is_response().with_content(b"chips"),
mismatches_with(
stub_response,
contains_string("was response with content: was <b'content'>")),
)
assert_that(
is_response().with_content(b"content"),
matches_with(
stub_response,
contains_string("was response with content: was <b'content'>")),
)
def test_response_matcher_url():
# Given
response = MOCK_RESPONSE
# When
# Then
assert_that(response, is_response().with_url(is_url().with_path("/path0")))
assert_that(response,
not_(is_response().with_url(is_url().with_path("/nope"))))
assert_that(
str(is_response().with_url(is_url().with_path("/path0"))),
contains_string("response with url: URL with path: '/path0'"),
)
assert_that(
is_response().with_url(is_url().with_path("/nope")),
mismatches_with(
response,
contains_string(
"was response with url: was URL with path: was </path0>")),
)
assert_that(
is_response().with_url(is_url().with_path("/path0")),
matches_with(
response,
contains_string(
"was response with url: was URL with path: was </path0>")),
)
def test_proxy_uses_path_predicate_generator(mock_server):
proxy_imposter = Imposter(
Stub(responses=Proxy(
to="https://httpbin.org",
mode=Proxy.Mode.ONCE,
predicate_generators=[PredicateGenerator(path=True)],
)))
with mock_server(proxy_imposter):
response = requests.get(proxy_imposter.url / "status/418")
assert_that(
response,
is_response().with_status_code(418).and_body(
contains_string("teapot")))
response = requests.get(proxy_imposter.url / "status/200")
assert_that(response, is_response().with_status_code(200))
recorded_stubs = proxy_imposter.playback()
playback_impostor = Imposter(recorded_stubs)
with mock_server(playback_impostor):
response = requests.get(playback_impostor.url / "status/418")
assert_that(
response,
is_response().with_status_code(418).and_body(
contains_string("teapot")))
response = requests.get(playback_impostor.url / "status/200")
assert_that(response, is_response().with_status_code(200))
def test_response_matcher_json():
# Given
stub_response = MOCK_RESPONSE
# When
# Then
assert_that(stub_response, is_response().with_json({"a": "b"}))
assert_that(stub_response, not_(is_response().with_json({"a": "c"})))
assert_that(
str(is_response().with_json({"a": "b"})),
contains_string("response with json: <{'a': 'b'}>"),
)
assert_that(
is_response().with_json([1, 2, 4]),
mismatches_with(
stub_response,
contains_string("was response with json: was <{'a': 'b'}>")),
)
assert_that(
is_response().with_json({"a": "b"}),
matches_with(
stub_response,
contains_string("was response with json: was <{'a': 'b'}>")),
)
def test_proxy_uses_query_predicate_generator_with_key(mock_server):
proxy_imposter = Imposter(
Stub(responses=Proxy(
to="https://httpbin.org",
mode=Proxy.Mode.ONCE,
predicate_generators=[
PredicateGenerator(query={"foo": "whatever"})
],
)))
with mock_server(proxy_imposter):
response = requests.get(proxy_imposter.url / "get",
params={
"foo": "bar",
"quxx": "buzz"
})
assert_that(
response,
is_response().with_body(
json_matching(
has_entries(args=has_entries(foo="bar", quxx="buzz")))),
)
response = requests.get(proxy_imposter.url / "get",
params={
"foo": "baz",
"quxx": "buxx"
})
assert_that(
response,
is_response().with_body(
json_matching(has_entries(args=has_entries(foo="baz")))),
)
recorded_stubs = proxy_imposter.playback()
playback_impostor = Imposter(recorded_stubs)
with mock_server(playback_impostor):
response = requests.get(playback_impostor.url / "get",
params={
"foo": "bar",
"quxx": "whatever"
})
assert_that(
response,
is_response().with_body(
json_matching(
has_entries(args=has_entries(foo="bar", quxx="buzz")))),
)
response = requests.get(playback_impostor.url / "get",
params={
"foo": "baz",
"quxx": "anything"
})
assert_that(
response,
is_response().with_body(
json_matching(
has_entries(args=has_entries(foo="baz", quxx="buxx")))),
)
def test_response_json():
# Given
# When
actual = requests.get("https://httpbin.org/json")
# Then
assert_that(actual, is_response().with_json(has_key("slideshow")))
assert_that(actual, not_(is_response().with_json(has_key("shitshow"))))
def test_response_encoding():
# Given
# When
actual = requests.get("https://httpbin.org/encoding/utf8")
# Then
assert_that(actual, is_response().with_encoding("utf-8"))
assert_that(actual, not_(is_response().with_encoding("ISO-8859-1")))
def test_response_matcher_builder():
# Given
stub_response = MOCK_RESPONSE
matcher = (is_response().with_status_code(200).and_body(
"sausages").and_content(b"content").and_json(has_entries(
a="b")).and_headers(has_entries(key="value")).and_cookies(
has_entries(name="value")).and_elapsed(
between(timedelta(seconds=1),
timedelta(minutes=1))).and_history(
contains_exactly(
is_response().with_url(
is_url().with_path("/path1")),
is_response().with_url(
is_url().with_path("/path2")),
)).and_url(is_url().with_path(
"/path0")).and_encoding("utf-8"))
mismatcher = is_response().with_body("kale").and_status_code(404)
# When
# Then
assert_that(stub_response, matcher)
assert_that(stub_response, not_(mismatcher))
assert_that(
matcher,
has_string(
"response with "
"status_code: <200> "
"body: 'sausages' "
"content: <b'content'> "
"json: a dictionary containing {'a': 'b'} "
"headers: a dictionary containing {'key': 'value'} "
"cookies: a dictionary containing {'name': 'value'} "
"elapsed: (a value greater than or equal to <0:00:01> and a value less than or equal to <0:01:00>) "
"history: a sequence containing "
"[response with url: URL with path: '/path1', response with url: URL with path: '/path2'] "
"url: URL with path: '/path0' "
"encoding: 'utf-8'"),
)
assert_that(
mismatcher,
mismatches_with(
stub_response,
contains_string(
"was response with status code: was <200> body: was 'sausages'"
),
),
)
assert_that(
matcher,
matches_with(
stub_response,
contains_string(
"was response with status code: was <200> body: was 'sausages'"
),
),
)
def test_multiple_responses(mock_server):
imposter = Imposter(Stub(responses=[Response(body="sausages"), Response(body="egg")]))
with mock_server(imposter):
r1 = requests.get(imposter.url)
r2 = requests.get(imposter.url)
r3 = requests.get(imposter.url)
assert_that(r1, is_response().with_body("sausages"))
assert_that(r2, is_response().with_body("egg"))
assert_that(r3, is_response().with_body("sausages"))
def test_not_predicate(mock_server):
imposter = Imposter(
Stub(~Predicate(query={"foo": "bar"}), Response(body="black pudding")))
with mock_server(imposter) as s:
logger.debug("server: %s", s)
r1 = requests.get(f"{imposter.url}/", params={"foo": "baz"})
r2 = requests.get(f"{imposter.url}/", params={"foo": "bar"})
assert_that(r1, is_response().with_body("black pudding"))
assert_that(r2, not_(is_response().with_body("black pudding")))
def test_default_response(mock_server):
imposter = Imposter(
Stub(Predicate(path="/test1"), Response(body="sausages")),
default_response=HttpResponse("chips", status_code=201),
)
with mock_server(imposter):
r1 = requests.get(f"{imposter.url}/test1")
r2 = requests.get(f"{imposter.url}/test2")
assert_that(r1, is_response().with_status_code(200).and_body("sausages"))
assert_that(r2, is_response().with_status_code(201).and_body("chips"))
def test_multiple_imposters(mock_server):
imposters = [
Imposter(Stub(Predicate(path="/test1"), Response("sausages"))),
Imposter([Stub([Predicate(path="/test2")], [Response("chips", status_code=201)])]),
]
with mock_server(imposters):
r1 = requests.get("{0}/test1".format(imposters[0].url))
r2 = requests.get("{0}/test2".format(imposters[1].url))
assert_that(r1, is_response().with_status_code(200).and_body("sausages"))
assert_that(r2, is_response().with_status_code(201).and_body("chips"))
def test_response_content():
# Given
# When
actual = requests.get("https://httpbin.org/anything?foo=bar",
headers={"X-Clacks-Overhead": "Sir Terry Pratchett"})
# Then
assert_that(actual, is_response().with_status_code(200))
assert_that(
actual,
is_response().with_status_code(200).and_content(
contains_bytestring(b"foo")))
assert_that(actual, not_(is_response().with_content(b"seems unlikely")))
def test_json_payload(mock_server):
# Given
imposter = Imposter(
Stub(Predicate(body={"foo": ["bar", "baz"]}),
Response(body="sausages")))
with mock_server(imposter):
# When
r1 = requests.post(imposter.url, json={"foo": ["bar", "baz"]})
r2 = requests.post(imposter.url, json={"baz": ["bar", "foo"]})
# Then
assert_that(r1, is_response().with_body("sausages"))
assert_that(r2, not_(is_response().with_body("sausages")))
def test_response_history():
# Given
# When
actual = requests.get("https://httpbin.org/cookies/set?foo=bar")
# Then
assert_that(
actual,
is_response().with_status_code(200).and_url(
is_url().with_path("/cookies")).and_history(
contains_exactly(is_response().with_url(
is_url().with_path("/cookies/set")))),
)
def test_response_status_code():
# Given
# When
actual = requests.get("https://httpbin.org/status/345")
# Then
assert_that(actual, is_response().with_status_code(345))
assert_that(actual, not_(is_response().with_status_code(201)))
assert_that(
is_response().with_status_code(201),
mismatches_with(
actual,
contains_string("was response with status code: was <345>")),
)
def test_default_imposter(mock_server):
imposter = Imposter(Stub())
with mock_server(imposter):
r = requests.get("{0}/".format(imposter.url))
assert_that(r, is_response().with_status_code(200).and_body(""))
def test_lookup_with_Path_type(mock_server):
datasource_path = Path("tests") / "integration" / "behaviors" / "test_data" / "values.csv"
imposter = Imposter(
Stub(
responses=Response(
status_code="${row}['code']",
body="Hello ${row}['Name'], have you done your ${row}['jobs'] today?",
headers={"X-Tree": "${row}['tree']"},
lookup=Lookup(
Key("path", UsingRegex("/(.*)$"), 1), datasource_path, "Name", "${row}"
),
)
)
)
with mock_server(imposter):
response = requests.get(imposter.url / "liquid")
assert_that(
response,
is_response()
.with_status_code(400)
.with_body("Hello liquid, have you done your farmer today?")
.with_headers(has_entry("X-Tree", "mango")),
)
def test_binary_mode(mock_server):
imposter = Imposter(Stub(responses=Response(mode=Response.Mode.BINARY, body=b"c2F1c2FnZXM=")))
with mock_server(imposter):
response = requests.get(imposter.url)
assert_that(response, is_response().with_content(b"sausages"))
def test_status(mock_server):
imposter = Imposter(Stub(responses=Response(status_code=204)))
with mock_server(imposter):
response = requests.get(imposter.url)
assert_that(response, is_response().with_status_code(204))
def test_body(mock_server):
imposter = Imposter(Stub(responses=Response(body="sausages")))
with mock_server(imposter):
response = requests.get(imposter.url)
assert_that(response, is_response().with_body("sausages"))
def test_regex_copy(mock_server):
imposter = Imposter(
Stub(responses=Response(
status_code="${code}",
headers={"X-Test": "${header}"},
body="Hello, ${name}!",
copy=[
Copy("path", "${code}", UsingRegex("\\d+")),
Copy({"headers": "X-Request"}, "${header}", UsingRegex(".+")),
Copy({"query": "name"}, "${name}",
UsingRegex("AL\\w+", ignore_case=True)),
],
)))
with mock_server(imposter):
response = requests.get(imposter.url / str(456),
params={"name": "Alice"},
headers={"X-REQUEST": "Header value"})
assert_that(
response,
is_response().with_status_code(456).with_body(
"Hello, Alice!").with_headers(
has_entry("X-Test", "Header value")),
)
def test_jsonpath_copy(mock_server):
imposter = Imposter(
Stub(responses=Response(body="Have you read BOOK?",
copy=Copy("body", "BOOK",
UsingJsonpath("$..title")))))
with mock_server(imposter):
response = requests.post(
imposter.url,
json={
"books": [
{
"book": {
"title": "Game of Thrones",
"summary": "Dragons and political intrigue",
}
},
{
"book": {
"title": "Harry Potter",
"summary": "Dragons and a boy wizard"
}
},
{
"book": {
"title": "The Hobbit",
"summary": "A dragon and short people"
}
},
]
},
)
assert_that(response,
is_response().with_body("Have you read Game of Thrones?"))
def test_decorate_response(mock_server):
imposter = Imposter(Stub(responses=Response(body="Hello ${NAME}.", decorate=JS)))
with mock_server(imposter):
response = requests.get(imposter.url)
assert_that(response, is_response().with_body("Hello World."))
def test_xml_payload(mock_server):
# Given
imposter = Imposter(
Stub(
Predicate(xpath="//foo", body="bar", operator=Predicate.Operator.EQUALS),
Response(body="sausages"),
)
)
with mock_server(imposter):
# When
r1 = requests.get(imposter.url, data=et2string(data2xml({"foo": "bar"})))
r2 = requests.get(imposter.url, data=et2string(data2xml({"foo": "baz"})))
# Then
assert_that(r1, is_response().with_body("sausages"))
assert_that(r2, is_response().with_body(not_("sausages")))
def test_response_matcher_invalid_json():
# Given
stub_response = mock.MagicMock(status_code=200,
text="body",
content=b"content",
headers={"key": "value"})
type(stub_response).json = mock.PropertyMock(side_effect=ValueError)
# When
# Then
assert_that(stub_response, not_(is_response().with_json([1, 2, 4])))
assert_that(
is_response().with_json([1, 2, 4]),
mismatches_with(stub_response,
contains_string("was response with json: was <None>")),
)
def test_attach_to_existing(mock_server):
imposter = Imposter(
Stub(Predicate(path="/test"), Response(body="sausages")))
with MountebankServer(port=mock_server.server_port)(imposter):
response = requests.get("{0}/test".format(imposter.url))
assert_that(response,
is_response().with_status_code(200).and_body("sausages"))
