def check_simpack(simpack): '''Check that the problematic `simpack` raises the correct exception.''' _test_settings = simpack._test_settings PROBLEM = _test_settings.PROBLEM assert PROBLEM assert issubclass(PROBLEM, Exception) with cute_testing.RaiseAssertor(PROBLEM, assert_exact_type=True): SimpackGrokker(simpack)
def _check_helpful_warnings_for_old_protocols(pickle_module, cross_process_persistent, old_protocol): ''' Test that helpful errors are given when trying to pickle with old protocol. ''' assert old_protocol < 2 with cute_testing.RaiseAssertor(text=('protocol %s' % old_protocol)): pickle_module.dumps(cross_process_persistent, protocol=old_protocol)
def test_helpful_message_when_forgetting_parentheses(): '''Test user gets a helpful exception when when forgetting parentheses.''' def confusedly_forget_parentheses(): @monkeypatching_tools.monkeypatch_method def f(): pass with cute_testing.RaiseAssertor( TypeError, 'It seems that you forgot to add parentheses after ' '`@monkeypatch_method` when decorating the `f` function.'): confusedly_forget_parentheses()
def test_helpful_message_when_forgetting_parentheses(): '''Test user gets a helpful exception when when forgetting parentheses.''' def confusedly_forget_parentheses(): @cache def f(): pass with cute_testing.RaiseAssertor( TypeError, 'It seems that you forgot to add parentheses after `@cache` when ' 'decorating the `f` function.'): confusedly_forget_parentheses()
def test_defining_exit_and_manage_context(): ''' Test context manager class defining both `__exit__` and `manage_context`. ''' with cute_testing.RaiseAssertor(Exception, 'both an `__exit__` method and a'): class MyContextManager(ContextManager): def manage_context(self): yield self def __exit__(self, *exc): pass
def test_defining_exit_on_top_of_manage_context(): ''' Test an `__exit__`-definer inheriting from a `manage_context`-definer. ''' class MyBaseContextManager(ContextManager): def manage_context(self): yield self with cute_testing.RaiseAssertor( Exception, "defines an `__exit__` method, but not an `__enter__` method"): class MyContextManager(MyBaseContextManager): def __exit__(self, *exc): pass
def test_index(): '''Test the `OrderedDict.index` method.''' ordered_dict = OrderedDict(((1, 'a'), (2, 'b'), (3, 'c'))) assert ordered_dict.index(1) == 0 assert ordered_dict.index(3) == 2 assert ordered_dict.index(2) == 1 ordered_dict[2] = 'b' assert ordered_dict.index(1) == 0 assert ordered_dict.index(3) == 2 assert ordered_dict.index(2) == 1 ordered_dict['meow'] = 'frr' assert ordered_dict.index('meow') == 3 with cute_testing.RaiseAssertor(KeyError): ordered_dict.index('Non-existing key')
def test_only_defaultless(): ''' Test `ArgumentsProfile` on a function with defaultless arguments only. ''' def func(a, b, c): pass a1 = ArgumentsProfile(func, 1, 2, 3) assert a1.args == (1, 2, 3) assert not a1.kwargs a2 = ArgumentsProfile(func, 1, c=3, b=2) a3 = ArgumentsProfile(func, c=3, a=1, b=2) a4 = ArgumentsProfile(func, 1, **{'c': 3, 'b': 2}) a5 = ArgumentsProfile(func, **OrderedDict((('c', 3), ('b', 2), ('a', 1)))) assert a1 == a2 == a3 == a4 == a5 for arg_prof in [a1, a2, a3, a4, a5]: ### Testing `.iteritems`: ############################################# # # assert dict(arg_prof) == {'a': 1, 'b': 2, 'c': 3} assert OrderedDict(arg_prof) == \ OrderedDict((('a', 1), ('b', 2), ('c', 3))) # # ### Finished testing `.iteritems`. #################################### ### Testing `.__getitem__`: ########################################### # # assert (arg_prof['a'], arg_prof['b'], arg_prof['c']) == (1, 2, 3) with cute_testing.RaiseAssertor(KeyError): arg_prof['non_existing_key'] # # ### Finished testing `.__getitem__`. ################################## ### Testing `.get`: ################################################### # # assert arg_prof.get('a') == arg_prof.get('a', 'asdfasdf') == 1 assert arg_prof.get('non_existing_key', 7) == 7 assert arg_prof.get('non_existing_key') is None
def check_context_manager_type(context_manager_type, self_returning, error_catching): ''' Run checks on a context manager. `self_returning` is a flag saying whether the context manager's `__enter__` method returns itself. (For the `as` keyword after `with`.) `error_catching` says whether the context manager catches exceptions it gets and updates the `exception_type_caught` global. ''' global flag, exception_type_caught assert flag is None assert exception_type_caught is None ### Testing simple case: ################################################## # # with context_manager_type(7) as return_value: assert flag == 7 if self_returning: assert isinstance(return_value, context_manager_type) else: # self_returning is False assert return_value is None # # ### Finished testing simple case. ######################################### assert flag is None assert exception_type_caught is None ### Testing creating context manager before `with`: ####################### # # my_context_manager = context_manager_type(1.1) assert isinstance(my_context_manager, context_manager_type) with my_context_manager as return_value: assert flag == 1.1 if self_returning: assert return_value is my_context_manager else: # self_returning is False assert return_value is None # # ### Finished testing creating context manager before `with`. ############## assert flag is None assert exception_type_caught is None ### Testing decorated function: ########################################### # # @context_manager_type('meow') def f(): assert flag == 'meow' f() assert flag is None assert exception_type_caught is None # # ### Finished testing decorated function. ################################## ### Testing manually decorated function: ################################## # # def g(a, b=2, **kwargs): assert flag == 'meow' new_g = context_manager_type('meow')(g) with cute_testing.RaiseAssertor(AssertionError): g('whatever') assert flag is None assert exception_type_caught is None new_g('whatever') assert flag is None assert exception_type_caught is None cute_testing.assert_polite_wrapper(new_g, g) # # ### Finished testing manually decorated function. ######################### ### Testing deep nesting: ################################################# # # my_context_manager = context_manager_type(123) assert flag is None with my_context_manager: assert flag == 123 with my_context_manager: assert flag == 123 with my_context_manager: assert flag == 123 with my_context_manager: assert flag == 123 with my_context_manager: assert flag == 123 assert flag == 123 assert flag == 123 assert flag == 123 assert flag == 123 assert flag is None with context_manager_type(1) as return_value_1: assert flag == 1 with context_manager_type(2) as return_value_2: assert flag == 2 with return_value_1 or context_manager_type(1): assert flag == 1 assert flag == 2 assert flag == 1 assert flag is None # # ### Finished testing deep nesting. ######################################## ########################################################################### ########################################################################### ### Now while raising exceptions: ### Testing simple case: ################################################## # # try: with context_manager_type(7) as return_value: assert flag == 7 if self_returning: assert isinstance(return_value, context_manager_type) else: # self_returning is False assert return_value is None raise TypeError('ooga booga') except Exception, exception: assert not error_catching assert type(exception) is TypeError
assert error_catching assert exception_type_caught is ZeroDivisionError exception_type_caught = None # # ### Finished testing decorated function. ################################## assert flag is None exception_type_caught = None ### Testing manually decorated function: ################################## # # def g(a, b=2, **kwargs): assert flag == 'meow' eval('Ooga booga I am a syntax error.') with cute_testing.RaiseAssertor(AssertionError): g('whatever') assert flag is None assert exception_type_caught is None new_g = context_manager_type('meow')(g) assert flag is None assert exception_type_caught is None cute_testing.assert_polite_wrapper(new_g, g) try: new_g('whatever') except Exception, exception: assert not error_catching
def test_many_defaultfuls_and_star_args_and_star_kwargs(): ''' Test `ArgumentsProfile` with defaultful arguments, `*args` and `**kwargs`. ''' def func(a, b, c='three', d='four', e='five', f='six', *args, **kwargs): pass func(None, None) a1 = ArgumentsProfile(func, 'one', 'two', f='boomboomboom', __awesome=True, big=True) assert a1.args == ('one', 'two') assert a1.kwargs == OrderedDict( (('f', 'boomboomboom'), ('big', True), ('__awesome', True)) ) a2 = ArgumentsProfile(func, 'one', 'two', 'three', 'four', 'five', 'bombastic', 'meow_frr', __funky=None, zany=True, _wet=False, blue=True) assert a2.args == ('one', 'two', 'three', 'four', 'five', 'bombastic', 'meow_frr') assert a2.kwargs == OrderedDict( (('blue', True), ('zany', True), ('_wet', False), ('__funky', None)) ) a3 = ArgumentsProfile(func, 'one', 'two', 'three', 'four', 'five', 'bombastic', 'meow_frr', zany=True, __funky=None, blue=True, _wet=False, **OrderedDict()) assert a2 == a3 for arg_prof in [a2, a3]: # Testing `.iteritems`: assert OrderedDict(arg_prof) == OrderedDict( (('a', 'one'), ('b', 'two'), ('c', 'three'), ('d', 'four'), ('e', 'five'), ('f', 'bombastic'), ('*', ('meow_frr',)), ('blue', True), ('zany', True), ('_wet', False), ('__funky', None)) ) ### Testing `.__getitem__`: ########################################### # # assert (arg_prof['a'], arg_prof['b'], arg_prof['c'], arg_prof['d'], arg_prof['e'], arg_prof['f'], arg_prof['*'], arg_prof['blue'], arg_prof['zany'], arg_prof['_wet'], arg_prof['__funky']) == \ ('one', 'two', 'three', 'four', 'five', 'bombastic', ('meow_frr',), True, True, False, None) with cute_testing.RaiseAssertor(KeyError): arg_prof['non_existing_key'] # # ### Finished testing `.__getitem__`. ################################## ### Testing `.get`: ################################################### # # assert arg_prof.get('d') == arg_prof.get('d', 7) == 'four' assert arg_prof.get('non_existing_key', 7) == 7 assert arg_prof.get('non_existing_key') is None # # ### Finished testing `.get`. ########################################## ### Testing `.iterkeys`, `.keys` and `__iter__`: ###################### # # assert list(arg_prof.iterkeys()) == list(arg_prof.keys()) == \ list(arg_prof) == \ ['a', 'b', 'c', 'd', 'e', 'f', '*', 'blue', 'zany', '_wet', '__funky'] # # ### Finished testing `.iterkeys`, `.keys` and `__iter__`. ############# ### Testing `.itervalues` and `.values`: ############################## # # assert list(arg_prof.itervalues()) == list(arg_prof.values()) == \ ['one', 'two', 'three', 'four', 'five', 'bombastic', ('meow_frr',), True, True, False, None] # # ### Finished testing `.itervalues` and `.values`. ##################### ### Testing `.iteritems` and `.items`: ################################ # # items_1 = list(arg_prof.iteritems()) items_2 = arg_prof.items() assert items_1 == items_2 == zip(arg_prof.keys(), arg_prof.values()) # # ### Finished testing `.iteritems` and `.items`. ####################### ### Testing `.__contains__`: ########################################## # # for key in arg_prof: assert key in arg_prof
def test_defaultfuls_and_star_kwargs(): '''Test `ArgumentsProfile` with defaultful arguments and `**kwargs`.''' def func(a, b, c=3, d=4, **kwargs): pass a1 = ArgumentsProfile(func, 1, 2) assert a1.args == (1, 2) assert not a1.kwargs # Alphabetic ordering among the `**kwargs`, but `d` is first because it's a # non-star: a2 = ArgumentsProfile(func, 1, 2, d='bombastic', zany=True, blue=True) assert a2.args == (1, 2) assert a2.kwargs == OrderedDict( (('d', 'bombastic'), ('blue', True), ('zany', True)) ) a3 = ArgumentsProfile(func, 1, b=2, blue=True, d='bombastic', zany=True) a4 = ArgumentsProfile(func, zany=True, a=1, b=2, blue=True, d='bombastic') a5 = ArgumentsProfile(func, 1, 2, 3, 'bombastic', zany=True, blue=True) assert a2 == a3 == a4 == a5 for arg_prof in [a2, a3, a4, a5]: # Testing `.iteritems`: assert OrderedDict(arg_prof) == OrderedDict( (('a', 1), ('b', 2), ('c', 3), ('d', 'bombastic'), ('blue', True), ('zany', True)) ) ### Testing `.__getitem__`: ########################################### # # assert (arg_prof['a'], arg_prof['b'], arg_prof['c'], arg_prof['d'], arg_prof['blue'], arg_prof['zany']) == \ (1, 2, 3, 'bombastic', True, True) with cute_testing.RaiseAssertor(KeyError): arg_prof['non_existing_key'] # # ### Finished testing `.__getitem__`. ################################## ### Testing `.get`: ################################################### # # assert arg_prof.get('d') == arg_prof.get('d', 7) == 'bombastic' assert arg_prof.get('non_existing_key', 7) == 7 assert arg_prof.get('non_existing_key') is None # # ### Finished testing `.get`. ########################################## ### Testing `.iterkeys`, `.keys` and `__iter__`: ###################### # # assert list(arg_prof.iterkeys()) == list(arg_prof.keys()) == \ list(arg_prof) == ['a', 'b', 'c', 'd', 'blue', 'zany'] # # ### Finished testing `.iterkeys`, `.keys` and `__iter__`. ############# ### Testing `.itervalues` and `.values`: ############################## # # assert list(arg_prof.itervalues()) == list(arg_prof.values()) == \ [1, 2, 3, 'bombastic', True, True] # # ### Finished testing `.itervalues` and `.values`. ##################### ### Testing `.__contains__`: ########################################## # # for key in arg_prof: assert key in arg_prof assert 'agaofgnafgadf' not in arg_prof assert '**' not in arg_prof