def test_is_negative():
assert_that(-1).is_negative()
def test_is_none():
assert_that(None).is_none()
def test_is_not_none_failure():
try:
assert_that(None).is_not_none()
fail('should have raised error')
except AssertionError as ex:
assert_that(str(ex)).is_equal_to('Expected not <None>, but was.')
def test_check_dict_like_empty_dict():
ab = assert_that(None)
assert_that(ab._check_dict_like({}))
def test_is_equal():
assert_that('foo').is_equal_to('foo')
assert_that(123).is_equal_to(123)
assert_that(0.11).is_equal_to(0.11)
assert_that(['a', 'b']).is_equal_to(['a', 'b'])
assert_that((1, 2, 3)).is_equal_to((1, 2, 3))
assert_that(1 == 1).is_equal_to(True)
assert_that(1 == 2).is_equal_to(False)
assert_that(set(['a', 'b'])).is_equal_to(set(['b', 'a']))
assert_that({'a': 1, 'b': 2}).is_equal_to({'b': 2, 'a': 1})
def test_fmt_args_kwargs_single_arg():
ab = assert_that(None)
assert_that(ab._fmt_args_kwargs(1)).is_equal_to('1')
assert_that(ab._fmt_args_kwargs('foo')).is_equal_to("'foo'")
def test_fmt_args_kwargs_single_kwarg():
ab = assert_that(None)
assert_that(ab._fmt_args_kwargs(a=1)).is_equal_to("'a': 1")
assert_that(ab._fmt_args_kwargs(f='foo')).is_equal_to("'f': 'foo'")
def test_is_not_close_to_bad_value_type_failure():
try:
assert_that('foo').is_not_close_to(123, 1)
fail('should have raised error')
except TypeError as ex:
assert_that(str(ex)).is_equal_to('val is not numeric or datetime')
def test_is_not_close_to_bad_tolerance_arg_type_failure():
try:
assert_that(123.01).is_not_close_to(0, 'foo')
fail('should have raised error')
except TypeError as ex:
assert_that(str(ex)).is_equal_to('given tolerance arg must be numeric')
def test_is_not_zero():
assert_that(1).is_not_zero()
# assert_that(1L).is_not_zero()
assert_that(0.001).is_not_zero()
assert_that(0 + 1j).is_not_zero()
def test_is_not_close_to():
assert_that(123.01).is_not_close_to(122, 1)
assert_that(0.01).is_not_close_to(0, 0.001)
assert_that(-123.01).is_not_close_to(-122, 1)
def test_is_close_to():
assert_that(123.01).is_close_to(123, 1)
assert_that(0.01).is_close_to(0, 1)
assert_that(-123.01).is_close_to(-123, 1)
def test_is_not_between():
assert_that(123).is_not_between(124, 125)
assert_that(123).is_not_between(1e5, 1e6)
assert_that(-123).is_not_between(-1000, -150)
assert_that(123).is_not_between(122.999, 122.9999)
def test_is_between():
assert_that(123).is_between(120, 125)
assert_that(123).is_between(0, 1e6)
assert_that(-123).is_between(-150, -100)
assert_that(123).is_between(122.999, 123.001)
def test_fmt_items_multiple():
ab = assert_that(None)
assert_that(ab._fmt_items([1, 2, 3])).is_equal_to('<1, 2, 3>')
assert_that(ab._fmt_items(['a', 'b', 'c'])).is_equal_to("<'a', 'b', 'c'>")
def test_chaining():
assert_that(123).is_greater_than(100).is_less_than(1000).is_between(
120, 125).is_close_to(100, 25)
def test_fmt_args_kwargs_empty():
ab = assert_that(None)
assert_that(ab._fmt_args_kwargs()).is_equal_to('')
def test_is_nan():
assert_that(float('NaN')).is_nan()
assert_that(float('Inf') - float('Inf')).is_nan()
def test_fmt_args_kwargs_multiple_args():
ab = assert_that(None)
assert_that(ab._fmt_args_kwargs(1, 2, 3)).is_equal_to('1, 2, 3')
assert_that(ab._fmt_args_kwargs('a', 'b',
'c')).is_equal_to("'a', 'b', 'c'")
def test_is_nan_bad_type_failure():
try:
assert_that('foo').is_nan()
fail('should have raised error')
except TypeError as ex:
assert_that(str(ex)).is_equal_to('val is not numeric')
def test_fmt_args_kwargs_multiple_kwargs():
ab = assert_that(None)
assert_that(ab._fmt_args_kwargs(a=1, b=2,
c=3)).is_equal_to("'a': 1, 'b': 2, 'c': 3")
assert_that(ab._fmt_args_kwargs(
a='a', b='b', c='c')).is_equal_to("'a': 'a', 'b': 'b', 'c': 'c'")
def test_check_dict_like_missing_keys():
ab = assert_that(None)
assert_that(ab._check_dict_like).raises(TypeError).when_called_with('foo')\
.is_equal_to('val <str> is not dict-like: missing keys()')
def test_check_dict_like_not_iterable():
ab = assert_that(None)
assert_that(ab._check_dict_like).raises(TypeError).when_called_with(123)\
.is_equal_to('val <int> is not dict-like: not iterable')
def test_check_dict_like_bool():
ab = assert_that(None)
assert_that(ab._check_dict_like({}, return_as_bool=True)).is_true()
assert_that(ab._check_dict_like(123, return_as_bool=True)).is_false()
assert_that(ab._check_dict_like('foo', return_as_bool=True)).is_false()
def test_is_not_equal():
assert_that('foo').is_not_equal_to('bar')
assert_that(123).is_not_equal_to(234)
assert_that(0.11).is_not_equal_to(0.12)
assert_that(['a', 'b']).is_not_equal_to(['a', 'x'])
assert_that(['a', 'b']).is_not_equal_to(['a'])
assert_that(['a', 'b']).is_not_equal_to(['a', 'b', 'c'])
assert_that((1, 2, 3)).is_not_equal_to((1, 2))
assert_that(1 == 1).is_not_equal_to(False)
assert_that(1 == 2).is_not_equal_to(True)
assert_that(set(['a', 'b'])).is_not_equal_to(set(['a']))
assert_that({'a': 1, 'b': 2}).is_not_equal_to({'a': 1, 'b': 3})
assert_that({'a': 1, 'b': 2}).is_not_equal_to({'a': 1, 'c': 2})
def test_fmt_items_empty():
ab = assert_that(None)
assert_that(ab._fmt_items([])).is_equal_to('<>')
def test_is_not_none():
assert_that('foo').is_not_none()
assert_that(123).is_not_none()
assert_that(False).is_not_none()
assert_that([]).is_not_none()
assert_that({}).is_not_none()
def test_fmt_items_single():
ab = assert_that(None)
assert_that(ab._fmt_items([1])).is_equal_to('<1>')
assert_that(ab._fmt_items(['foo'])).is_equal_to('<foo>')
def test_is_instance_of_bad_arg_failure():
try:
assert_that('foo').is_instance_of('bad')
fail('should have raised error')
except TypeError as ex:
assert_that(str(ex)).is_equal_to('given arg must be a class')
def test_is_positive():
assert_that(1).is_positive()
