def test_has_id_tag():
# Given
should_match = has_id_tag("fish", has_class("banana"))
should_not_match_1 = has_id_tag("fish", has_class("foo"))
should_not_match_2 = has_id_tag("grrgug", anything())
assert_that(HTML, should_match)
assert_that(HTML, not_(should_not_match_1))
assert_that(HTML, not_(should_not_match_2))
assert_that(
should_match,
has_string(
matches_regexp(
r"HTML with tag id=['<]fish['>] matching tag with class matching 'banana'"
)),
)
assert_that(
should_not_match_1,
mismatches_with(
HTML,
matches_regexp(
r"""got HTML with tag id=['<]fish['>] values """
r"""\['<div class="banana grapes" id="fish"><p>Some text.</p></div>'\]"""
),
),
)
assert_that(
should_not_match_2,
mismatches_with(
HTML,
matches_regexp(
r"got HTML with tag id=['<]grrgug['>] values \[\]")),
)
def test_call_has_positional_arg():
# Given
m = mock.MagicMock()
# When
m("first", "second", "third")
call = m.mock_calls[0]
# Then
assert_that(call, call_has_arg(1, "second"))
assert_that(call, call_has_arg(2, "third"))
assert_that(call, not_(call_has_arg(4, "nope")))
assert_that(call, call_has_arg(1, contains_string("eco")))
assert_that(
call_has_arg(1, contains_string("eco")),
has_string(
"mock.call with argument index <1> matching a string containing 'eco'"
),
)
assert_that(
call_has_arg(1, "fifth"),
mismatches_with(
call, "got mock.call with argument index <1> with value 'second'"),
)
assert_that(
call_has_arg(4, "nope"),
mismatches_with(call, "got mock.call with without argument index <4>"),
)
def test_call_has_keyword_arg():
# Given
m = mock.MagicMock()
# When
m(f="first", s="second", t="third")
call = m.mock_calls[0]
# Then
assert_that(call, call_has_arg("s", "second"))
assert_that(call, not_(call_has_arg("s", "nope")))
assert_that(call, not_(call_has_arg("w", "nope")))
assert_that(call, call_has_arg("s", contains_string("eco")))
assert_that(
call_has_arg("s", contains_string("eco")),
has_string(
"mock.call with keyword argument 's' matching a string containing 'eco'"
),
)
assert_that(
call_has_arg("s", "fifth"),
mismatches_with(
call,
"got mock.call with keyword argument 's' with value 'second'"),
)
assert_that(
call_has_arg("n", "nope"),
mismatches_with(call,
"got mock.call with without keyword argument 'n'"),
)
def test_has_rows(db):
assert_that(
db,
has_table_with_rows(
"sausages",
contains_inanyorder(
has_properties(kind="cumberland"),
has_properties(kind="lincolnshire"),
has_properties(kind="vegetarian"),
),
),
)
assert_that(
db,
not_(
has_table_with_rows("sausages",
has_item(has_properties(kind="vegan")))))
assert_that(
db,
not_(
has_table_with_rows(
"bacon",
contains_exactly(has_properties(kind="smoked"),
has_properties(kind="unsmoked")),
)),
)
assert_that(
has_table_with_rows(
"sausages",
contains_exactly(has_properties(kind="cumberland"),
has_properties(kind="lincolnshire")),
),
has_string(
matches_regexp(
r"DB connection with table 'sausages' with rows matching a sequence containing \["
r"\(?an object with a property 'kind' matching 'cumberland'\)?, "
r"\(?an object with a property 'kind' matching 'lincolnshire'\)?"
r"\]")),
)
assert_that(
has_table_with_rows("sausages",
has_item(has_properties(kind="vegan"))),
mismatches_with(
db,
all_of(contains_string("was <["),
contains_string("RowTuple(kind='vegetarian', rating=0)")),
),
)
assert_that(
has_table_with_rows(
"bacon",
contains_exactly(has_properties(kind="smoked"),
has_properties(kind="unsmoked")),
),
mismatches_with(
db,
"SQL statement 'SELECT * FROM bacon;' gives 'OperationalError' <no such table: bacon>",
),
)
def test_url_with_host():
should_match = is_url().with_host("brunni.ng")
should_not_match = is_url().with_host("example.com")
assert_that(URL, should_match)
assert_that(URL, not_(should_not_match))
assert_that(should_match, has_string("URL with host: 'brunni.ng'"))
assert_that(should_not_match,
mismatches_with(URL, "was URL with host: was 'brunni.ng'"))
assert_that(should_not_match,
mismatches_with(URL, "was URL with host: was 'brunni.ng'"))
def test_matcher_mismatches_with():
# Given
banana_matcher = contains_string("Banana")
# When
# Then
assert_that(banana_matcher, mismatches("Apple"))
assert_that(banana_matcher, mismatches_with("Apple", "was 'Apple'"))
assert_that(
mismatches_with("Apple", "was 'Apple'"),
has_string("a matcher which mismatches the value 'Apple'\ngiving message \"was 'Apple'\""),
)
def test_url_with_query():
should_match = is_url().with_query(
has_entries(key1="value1", key2="value2"))
should_not_match = is_url().with_query(
has_entries(key1="value1", key2="nope"))
assert_that(URL, should_match)
assert_that(URL, not_(should_not_match))
assert_that(
should_match,
has_string(
"URL with query: a dictionary containing {'key1': 'value1', 'key2': 'value2'}"
),
)
assert_that(
should_not_match,
mismatches_with(URL,
"was URL with query: value for 'key2' was 'value2'"))
assert_that(
should_match,
matches_with(
URL,
"was URL with query: was <{'key1': 'value1', 'key2': 'value2'}>"),
)
def test_url_with_path_segments():
should_match = is_url().with_path_segments(
contains_exactly("path1", "path2", "path3"))
should_not_match = is_url().with_path_segments(empty())
assert_that(URL, should_match)
assert_that(URL, not_(should_not_match))
assert_that(
should_match,
has_string(
"URL with path segments: a sequence containing ['path1', 'path2', 'path3']"
),
)
assert_that(
should_not_match,
mismatches_with(
URL,
"was URL with path segments: was <['path1', 'path2', 'path3']>"),
)
assert_that(
should_match,
matches_with(
URL,
"was URL with path segments: was <['path1', 'path2', 'path3']>"),
)
def test_request_matcher():
# Given
server = MagicMock()
request = HttpRequestBuilder().with_path("/test").and_method("GET").build()
server.get_actual_requests.return_value = [request, request]
# When
# Then
assert_that(server, had_request().with_path("/test").and_method("GET"))
assert_that(server, had_request().with_times(2).and_path("/test").and_method("GET"))
assert_that(server, not_(had_request().with_path("/somewhereelse").and_method("GET")))
assert_that(
had_request().with_path("/sausages").and_method("PUT"),
has_string("call with method: 'PUT' path: '/sausages'"),
)
assert_that(
had_request().with_times(4).and_query(has_entries(a="b")).and_body("chips"),
has_string(
"<4> call(s) with query parameters: a dictionary containing {'a': 'b'} body: 'chips'"
),
)
assert_that(
had_request().with_path("/sausages").and_method("PUT").and_times(99),
mismatches_with(
server,
all_of(
contains_string(
"found <0> matching requests: <[]>. All requests: <[mbtest.imposters.imposters.HttpRequest"
),
contains_string("path='/test'"),
contains_string("method='GET'"),
),
),
)
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_request_matcher():
# Given
server = MagicMock()
request = {"path": "/test", "method": "GET"}
server.get_actual_requests.return_value = {"someport": [request, request]}
# When
# Then
assert_that(server, had_request(path="/test", method="GET"))
assert_that(server, had_request(path="/test", method="GET", times=2))
assert_that(server, not_(had_request(path="/somewhereelse", method="GET")))
assert_that(
had_request(path="/sausages", method="PUT"),
has_string("call with method: 'PUT' path: '/sausages'"),
)
assert_that(
had_request(path="/sausages", times=4), has_string("<4> call(s) with path: '/sausages'")
)
assert_that(
had_request(path="/sausages", method="PUT"),
mismatches_with(
server,
all_of(
contains_string("found <0> matching requests: <[]>. All requests: <[{"),
contains_string("'path': '/test'"),
contains_string("'method': 'GET'"),
),
),
)
def test_identical_properties():
# Given
class SomeClass(ReprFromDict):
def __init__(self, a, b):
self.a = a
self.b = b
class OtherClass(ReprFromDict):
def __init__(self, a, b):
self.a = a
self._b = b
@property
def b(self):
return self._b
class YetAnotherClass(ReprFromDict):
def __init__(self, a, b):
self.a = a
self.b = b
a = SomeClass(1, 2)
b = OtherClass(1, 2)
c = YetAnotherClass(1, 3)
# Then
assert_that(a, has_identical_properties_to(b))
assert_that(a, not_(has_identical_properties_to(c)))
assert_that(
has_identical_properties_to(a),
has_string(f"object with identical properties to object <{a}>"),
)
assert_that(has_identical_properties_to(a),
mismatches_with(c, f"was <{c}>"))
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_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_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_nested_identical_properties():
# Given
class SomeClass(object):
def __init__(self, a, b, c):
self.a = a
self.b = b
self._c = c
@property
def c(self):
return self._c
def some_method(self):
pass
a = SomeClass(1, SomeClass(2, 3, 4), 4)
b = SomeClass(1, SomeClass(2, 3, 4), 4)
c = SomeClass(1, SomeClass(2, 4, 5), 6)
# Then
assert_that(a, has_identical_properties_to(b))
assert_that(a, not_(has_identical_properties_to(c)))
assert_that(
has_identical_properties_to(a),
has_string(f"object with identical properties to object {a}"),
)
assert_that(has_identical_properties_to(a), mismatches_with(c, f"was {c}"))
def test_has_row():
# Given
soup = BeautifulSoup(HTML, "html.parser")
table = soup.table
should_match = has_row(
index_matches=2,
row_matches=has_class("bazz"),
cells_match=contains_exactly(tag_has_string("fizz"),
tag_has_string("buzz")),
)
should_not_match_1 = has_row(
index_matches=2,
row_matches=has_class("bazz"),
cells_match=contains_exactly(tag_has_string("egg"),
tag_has_string("chips")),
)
should_not_match_2 = has_row(
index_matches=3,
row_matches=has_class("bazz"),
cells_match=contains_exactly(tag_has_string("fizz"),
tag_has_string("buzz")),
)
should_not_match_3 = has_row(
index_matches=2,
row_matches=has_class("eden"),
cells_match=contains_exactly(tag_has_string("fizz"),
tag_has_string("buzz")),
)
# Then
assert_that(table, should_match)
assert_that(table, not_(should_not_match_1))
assert_that(table, not_(should_not_match_2))
assert_that(table, not_(should_not_match_3))
assert_that(
should_match,
has_string(
"table with row "
"cells matching a sequence containing [tag with string matching 'fizz', tag with string matching 'buzz'] "
"row matching tag with class matching 'bazz' "
"index matching <2>"),
)
assert_that(
has_row(row_matches=has_class("banana")),
has_string(
"table with row row matching tag with class matching 'banana'"),
)
assert_that(
should_not_match_1,
mismatches_with(
table,
all_of(
starts_with(f"was {table}"),
contains_string("found rows:"),
contains_string("<tr><td>baz</td><td>qux</td></tr>"),
),
),
)
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_contains_bytestring():
should_match = contains_bytestring(b"foo")
should_not_match = contains_bytestring(b"bar")
assert_that(b"a foo b", should_match)
assert_that(b"a foo b", not_(should_not_match))
assert_that(should_match, has_string("bytestring containing <b'foo'>"))
assert_that(should_not_match, mismatches_with(b" a foo b", "was <b' a foo b'>"))
def test_is_weekday():
assert_that(datetime.date(1968, 7, 19), is_weekday())
assert_that(datetime.date(1968, 7, 21), not_(is_weekday()))
assert_that(is_weekday(), has_string("A weekday"))
assert_that(
is_weekday(),
mismatches_with(datetime.date(1968, 7, 21),
"was <1968-07-21> with weekday <6>, a Sunday"),
)
def test_json_matching():
# Given
j = json.dumps([1, 2, 3])
# When
# Then
assert_that(j, json_matching([1, 2, 3]))
assert_that(j, json_matching(contains_exactly(1, 2, 3)))
assert_that(j, not_(json_matching([1, 2, 5])))
assert_that(json_matching([1, 2, 3]),
has_string("JSON structure matching <[1, 2, 3]>"))
assert_that(
json_matching([]),
mismatches_with(
"WTF is this?",
matches_regexp(r"Got invalid JSON ['<]WTF is this\?['>]")),
)
assert_that(json_matching([]), mismatches_with("[1]", "was <[1]>"))
def test_HasWeekday():
assert_that(datetime.date(1968, 7, 21), HasWeekday(6))
assert_that(datetime.date(1968, 7, 21), not_(HasWeekday(2)))
assert_that(HasWeekday(2), has_string("Date with weekday matching <2>"))
assert_that(
HasWeekday(2),
mismatches_with(datetime.date(1968, 7, 21),
"was <1968-07-21> with weekday <6>, a Sunday"),
)
def test_mdash():
assert_that(HTML, has_named_tag("h2", "what is — this"))
assert_that(
has_named_tag("h2", "what is this"),
mismatches_with(
HTML,
matches_regexp(
r"got HTML with tag name=['<]h2['>] values \['<h2>what is (\\u2014|—) this</h2>'\]"
),
),
)
def test_has_table(db):
assert_that(db, has_table("sausages"))
assert_that(db, not_(has_table("bacon")))
assert_that(has_table("sausages"),
has_string("DB connection has table named 'sausages'"))
assert_that(
has_table("bacon"),
mismatches_with(
db,
"SQL statement 'SELECT * FROM bacon;' gives 'OperationalError' <no such table: bacon>",
),
)
def test_has_repr():
# Given
r = [1, "2"]
# When
# Then
assert_that(r, has_repr(contains_string("[1, '2']")))
assert_that(r, has_repr(contains_string("[1")))
assert_that(has_repr("a"),
has_string("an object with repr() matching 'a'"))
assert_that(has_repr("a"), mismatches_with("b", "was 'b'"))
def test_url_with_port():
should_match = is_url().with_port(1234)
should_not_match = is_url().with_port(5678)
assert_that(URL, should_match)
assert_that(URL, not_(should_not_match))
assert_that(should_match, has_string("URL with port: <1234>"))
assert_that(should_not_match,
mismatches_with(URL, "was URL with port: was <1234>"))
assert_that(should_match, matches_with(URL,
"was URL with port: was <1234>"))
def test_url_with_fragment():
should_match = is_url().with_fragment("fragment")
should_not_match = is_url().with_fragment("banana")
assert_that(URL, should_match)
assert_that(URL, not_(should_not_match))
assert_that(should_match, has_string("URL with fragment: 'fragment'"))
assert_that(should_not_match,
mismatches_with(URL, "was URL with fragment: was <fragment>"))
assert_that(should_match,
matches_with(URL, "was URL with fragment: was <fragment>"))
def test_url_with_username():
should_match = is_url().with_username("username")
should_not_match = is_url().with_username("nope")
assert_that(URL, should_match)
assert_that(URL, not_(should_not_match))
assert_that(should_match, has_string("URL with username: '******'"))
assert_that(should_not_match,
mismatches_with(URL, "was URL with username: was 'username'"))
assert_that(should_match,
matches_with(URL, "was URL with username: was 'username'"))
def test_url_with_password():
should_match = is_url().with_password("password")
should_not_match = is_url().with_password("nope")
assert_that(URL, should_match)
assert_that(URL, not_(should_not_match))
assert_that(should_match, has_string("URL with password: '******'"))
assert_that(should_not_match,
mismatches_with(URL, "was URL with password: was 'password'"))
assert_that(should_match,
matches_with(URL, "was URL with password: was 'password'"))
