def test_does_not_contain_single_item_failure():
try:
assert_that(['a', 'b', 'c']).does_not_contain('a')
fail('should have raised error')
except AssertionError as ex:
assert_that(str(ex)).is_equal_to(
"Expected <['a', 'b', 'c']> to not contain item <a>, but did.")
def test_traceback():
try:
assert_that('foo').is_equal_to('bar')
fail('should have raised error')
except AssertionError as ex:
assert_that(str(ex)).is_equal_to(
'Expected <foo> to be equal to <bar>, but was not.')
assert_that(ex).is_type_of(AssertionError)
# extract all stack frames from the traceback
_, _, tb = sys.exc_info()
assert_that(tb).is_not_none()
# walk_tb added in 3.5
if sys.version_info[0] == 3 and sys.version_info[1] >= 5:
frames = [(f.f_code.co_filename, f.f_code.co_name, lineno)
for f, lineno in traceback.walk_tb(tb)]
assert_that(frames).is_length(3)
assert_that(frames[0][0]).ends_with('test_traceback.py')
assert_that(frames[0][1]).is_equal_to('test_traceback')
assert_that(frames[0][2]).is_equal_to(36)
assert_that(frames[1][0]).ends_with('base.py')
assert_that(frames[1][1]).is_equal_to('is_equal_to')
assert_that(frames[1][2]).is_greater_than(40)
assert_that(frames[2][0]).ends_with('assertpy.py')
assert_that(frames[2][1]).is_equal_to('error')
assert_that(frames[2][2]).is_greater_than(100)
def test_extracting_bad_property_failure():
try:
assert_that(people).extracting('foo')
fail('should have raised error')
except ValueError as ex:
assert_that(str(ex)).is_equal_to(
'val does not have property or zero-arg method <foo>')
def test_snapshot_v2():
try:
assert_that(None).snapshot()
fail('should have raised error')
except NotImplementedError as ex:
assert_that(
str(ex)).is_equal_to('snapshot testing requires Python 3')
def test_is_not_in_failure():
try:
assert_that(1).is_not_in(1, 2, 3)
fail('should have raised error')
except AssertionError as ex:
assert_that(str(ex)).is_equal_to(
'Expected <1> to not be in <1, 2, 3>, but was.')
def test_check_iterable_no_getitem():
try:
ab = assert_that(None)
ab._check_iterable(set([1]), name='my-set')
fail('should have raised error')
except TypeError as e:
assert_that(str(e)).contains('my-set <set> does not have [] accessor')
def test_failure_very_deep_dict():
try:
assert_that({
'a': 1,
'b': {
'c': 2,
'd': {
'e': 3,
'f': {
'x': 4,
'y': 5
}
}
}
}).is_equal_to({
'a': 1,
'b': {
'c': 2,
'd': {
'e': 3,
'f': {
'x': 4,
'y': 6
}
}
}
})
fail('should have raised error')
except AssertionError as ex:
assert_that(str(ex)).is_equal_to(
"Expected <{.., 'b': {.., 'd': {.., 'f': {.., 'y': 5}}}}> to be equal to <{.., 'b': {.., 'd': {.., 'f': {.., 'y': 6}}}}>, but was not."
)
def test_contains_single_item_failure():
try:
assert_that(['a', 'b', 'c']).contains('x')
fail('should have raised error')
except AssertionError as ex:
assert_that(str(ex)).is_equal_to(
"Expected <['a', 'b', 'c']> to contain item <x>, but did not.")
def test_described_as():
try:
assert_that(1).described_as('extra msg').is_equal_to(2)
fail('should have raised error')
except AssertionError as ex:
assert_that(str(ex)).is_equal_to(
'[extra msg] Expected <1> to be equal to <2>, but was not.')
def test_ends_with_failure():
try:
assert_that(['a', 'b', 'c']).ends_with('d')
fail('should have raised error')
except AssertionError as ex:
assert_that(str(ex)).is_equal_to(
"Expected ['a', 'b', 'c'] to end with <d>, but did not.")
def test_is_length_failure():
try:
assert_that(['a', 'b', 'c']).is_length(4)
fail('should have raised error')
except AssertionError as ex:
assert_that(str(ex)).is_equal_to(
"Expected <['a', 'b', 'c']> to be of length <4>, but was <3>.")
def test_is_empty_failure():
try:
assert_that(['a', 'b']).is_empty()
fail('should have raised error')
except AssertionError as ex:
assert_that(str(ex)).is_equal_to(
"Expected <['a', 'b']> to be empty, but was not.")
def test_does_not_contain_duplicates_failure():
try:
assert_that([1, 2, 3, 3]).does_not_contain_duplicates()
fail('should have raised error')
except AssertionError as ex:
assert_that(str(ex)).is_equal_to(
'Expected <[1, 2, 3, 3]> to not contain duplicates, but did.')
def test_contains_sequence_failure():
try:
assert_that([1, 2, 3]).contains_sequence(4, 5)
fail('should have raised error')
except AssertionError as ex:
assert_that(str(ex)).is_equal_to(
'Expected <[1, 2, 3]> to contain sequence <4, 5>, but did not.')
def test_extracting_iterable_failure_set():
try:
assert_that([set([1])]).extracting(0).contains(1, 4, 7)
fail('should have raised error')
except TypeError as ex:
assert_that(
str(ex)).is_equal_to('item <set> does not have [] accessor')
def test_snapshot_custom_id_int():
try:
assert_that('foo').snapshot(id=123)
fail('should have raised error')
except ValueError as ex:
assert_that(
str(ex)).starts_with('failed to create snapshot filename')
def test_check_iterable_not_iterable():
try:
ab = assert_that(None)
ab._check_iterable(123, name='my-int')
fail('should have raised error')
except TypeError as e:
assert_that(str(e)).contains('my-int <int> is not iterable')
def test_snapshot_custom_path_none():
try:
assert_that('foo').snapshot(path=None)
fail('should have raised error')
except ValueError as ex:
assert_that(
str(ex)).starts_with('failed to create snapshot filename')
def test_failure_single_entry():
try:
assert_that({'a': 1}).is_equal_to({'a': 2})
fail('should have raised error')
except AssertionError as ex:
assert_that(str(ex)).is_equal_to(
"Expected <{'a': 1}> to be equal to <{'a': 2}>, but was not.")
def test_extracting_too_many_args_method_failure():
try:
assert_that(people).extracting('say_hello')
fail('should have raised error')
except ValueError as ex:
assert_that(str(ex)).is_equal_to(
'val method <say_hello()> exists, but is not zero-arg method')
def test_expected_exception_no_arg_missing_raises_failure():
try:
assert_that(func_noop).when_called_with()
fail('should have raised error')
except TypeError as ex:
assert_that(str(ex)).contains(
'expected exception not set, raises() must be called first')
def test_is_less_than_timedelta_bad_arg_type_failure():
try:
assert_that(t1).is_less_than(123)
fail('should have raised error')
except TypeError as ex:
assert_that(str(ex)).is_equal_to(
'given arg must be <timedelta>, but was <int>')
def test_is_not_close_to_bad_arg_type_failure():
try:
assert_that(d1).is_not_close_to(123, 456)
fail('should have raised error')
except TypeError as ex:
assert_that(
str(ex)).is_equal_to('given arg must be datetime, but was <int>')
def test_is_before_bad_val_type_failure():
try:
assert_that(123).is_before(123)
fail('should have raised error')
except TypeError as ex:
assert_that(
str(ex)).is_equal_to('val must be datetime, but was type <int>')
def test_is_not_between_bad_arg1_type_failure():
try:
assert_that(d1).is_not_between(123, 456)
fail('should have raised error')
except TypeError as ex:
assert_that(str(ex)).is_equal_to(
'given low arg must be <datetime>, but was <int>')
def test_is_greater_than_or_equal_to_bad_arg_type_failure():
try:
assert_that(d1).is_greater_than_or_equal_to(123)
fail('should have raised error')
except TypeError as ex:
assert_that(
str(ex)).is_equal_to('given arg must be <datetime>, but was <int>')
def test_is_equal_to_ignoring_time_bad_arg_type_failure():
try:
assert_that(d1).is_equal_to_ignoring_time(123)
fail('should have raised error')
except TypeError as ex:
assert_that(str(ex)).is_equal_to(
'given arg must be datetime, but was type <int>')
def test_soft_assertions():
try:
with soft_assertions():
assert_that('foo').is_length(4)
assert_that('foo').is_empty()
assert_that('foo').is_false()
assert_that('foo').is_digit()
assert_that('123').is_alpha()
assert_that('foo').is_upper()
assert_that('FOO').is_lower()
assert_that('foo').is_equal_to('bar')
assert_that('foo').is_not_equal_to('foo')
assert_that('foo').is_equal_to_ignoring_case('BAR')
fail('should have raised error')
except AssertionError as e:
assert_that(str(e)).contains(
'1. Expected <foo> to be of length <4>, but was <3>.')
assert_that(str(e)).contains(
'2. Expected <foo> to be empty string, but was not.')
assert_that(str(e)).contains('3. Expected <False>, but was not.')
assert_that(str(e)).contains(
'4. Expected <foo> to contain only digits, but did not.')
assert_that(str(e)).contains(
'5. Expected <123> to contain only alphabetic chars, but did not.')
assert_that(str(e)).contains(
'6. Expected <foo> to contain only uppercase chars, but did not.')
assert_that(str(e)).contains(
'7. Expected <FOO> to contain only lowercase chars, but did not.')
assert_that(str(e)).contains(
'8. Expected <foo> to be equal to <bar>, but was not.')
assert_that(str(e)).contains(
'9. Expected <foo> to be not equal to <foo>, but was.')
assert_that(str(e)).contains(
'10. Expected <foo> to be case-insensitive equal to <BAR>, but was not.'
)
def test_strings():
assert_that('').is_not_none()
assert_that('').is_empty()
assert_that('').is_false()
assert_that('').is_type_of(str)
assert_that('').is_instance_of(str)
assert_that('foo').is_length(3)
assert_that('foo').is_not_empty()
assert_that('foo').is_true()
assert_that('foo').is_alpha()
assert_that('123').is_digit()
assert_that('foo').is_lower()
assert_that('FOO').is_upper()
assert_that('foo').is_iterable()
assert_that('foo').is_equal_to('foo')
assert_that('foo').is_not_equal_to('bar')
assert_that('foo').is_equal_to_ignoring_case('FOO')
if sys.version_info[0] == 3:
assert_that('foo').is_unicode()
else:
assert_that(u'foo').is_unicode()
assert_that('foo').contains('f')
assert_that('foo').contains('f', 'oo')
assert_that('foo').contains_ignoring_case('F', 'oO')
assert_that('foo').does_not_contain('x')
assert_that('foo').contains_only('f', 'o')
assert_that('foo').contains_sequence('o', 'o')
assert_that('foo').contains_duplicates()
assert_that('fox').does_not_contain_duplicates()
assert_that('foo').is_in('foo', 'bar', 'baz')
assert_that('foo').is_not_in('boo', 'bar', 'baz')
assert_that('foo').is_subset_of('abcdefghijklmnopqrstuvwxyz')
assert_that('foo').starts_with('f')
assert_that('foo').ends_with('oo')
assert_that('foo').matches(r'\w')
assert_that('123-456-7890').matches(r'\d{3}-\d{3}-\d{4}')
assert_that('foo').does_not_match(r'\d+')
# partial matches, these all pass
assert_that('foo').matches(r'\w')
assert_that('foo').matches(r'oo')
assert_that('foo').matches(r'\w{2}')
# match the entire string with an anchored regex pattern, passes
assert_that('foo').matches(r'^\w{3}$')
# fails
try:
assert_that('foo').matches(r'^\w{2}$')
fail('should have raised error')
except AssertionError:
pass
def test_contains_multi_item_failure():
try:
assert_that({'a': 1, 'b': 2, 'c': 3}).contains('a', 'x', 'z')
fail('should have raised error')
except AssertionError as ex:
assert_that(str(ex)).contains(
"to contain keys <'a', 'x', 'z'>, but did not contain keys <'x', 'z'>."
)
