diff --git a/testsuite/test_nocasedict.py b/testsuite/test_nocasedict.py index ab116a94e..a7f996319 100755 --- a/testsuite/test_nocasedict.py +++ b/testsuite/test_nocasedict.py @@ -7,6 +7,11 @@ import unittest import warnings import six +try: + from collections import OrderedDict +except ImportError: + from ordereddict import OrderedDict + import pytest import pytest_extensions @@ -29,89 +34,220 @@ def __hash__(self): raise TypeError("Cannot hash %s" % type(self)) -class TestInit(unittest.TestCase): - """Test initialization""" - def test_all(self): - """Test all init options""" - # Empty - - dic = NocaseDict() - self.assertTrue(len(dic) == 0) - - dic = NocaseDict(None) - self.assertTrue(len(dic) == 0) - - dic = NocaseDict(list()) - self.assertTrue(len(dic) == 0) - - dic = NocaseDict(tuple()) - self.assertTrue(len(dic) == 0) - - dic = NocaseDict(dict()) - self.assertTrue(len(dic) == 0) - - dic = NocaseDict(dic) - self.assertTrue(len(dic) == 0) - - # Initialise from iterable - - dic = NocaseDict([('Dog', 'Cat'), ('Budgie', 'Fish')]) - self.assertTrue(len(dic) == 2) - self.assertTrue(dic['Dog'] == 'Cat' and dic['Budgie'] == 'Fish') - - dic = NocaseDict((('Dog', 'Cat'), ('Budgie', 'Fish'))) - self.assertTrue(len(dic) == 2) - self.assertTrue(dic['Dog'] == 'Cat' and dic['Budgie'] == 'Fish') - - # Initialise from dictionary - - with pytest.warns(UserWarning) as rec_warnings: - dic = NocaseDict({'Dog': 'Cat', 'Budgie': 'Fish'}) - assert len(rec_warnings) == 1 - self.assertTrue(len(dic) == 2) - self.assertTrue(dic['Dog'] == 'Cat' and dic['Budgie'] == 'Fish') - - # Initialise from kwargs +TESTCASES_NOCASEDICT_INIT = [ - with pytest.warns(UserWarning) as rec_warnings: - dic = NocaseDict(Dog='Cat', Budgie='Fish') - assert len(rec_warnings) == 1 - self.assertTrue(len(dic) == 2) - self.assertTrue(dic['Dog'] == 'Cat' and dic['Budgie'] == 'Fish') - - # Initialise from iterable and kwargs + # Testcases for NocaseDict.__init__(). + # + # Each list item is a testcase tuple with these items: + # * desc: Short testcase description. + # * kwargs: Keyword arguments for the test function: + # * init_args: Tuple of positional arguments to NocaseDict(). + # * init_kwargs: Dict of keyword arguments to NocaseDict(). + # * exp_dict: Expected resulting dictionary, as OrderedDict. + # * exp_exc_types: Expected exception type(s), or None. + # * exp_warn_types: Expected warning type(s), or None. + # * condition: Boolean condition for testcase to run, or 'pdb' for debugger - dic = NocaseDict([('Dog', 'Cat'), ], Budgie='Fish') - self.assertTrue(len(dic) == 2) - self.assertTrue(dic['Dog'] == 'Cat' and dic['Budgie'] == 'Fish') + # Empty NocaseDict + ( + "Empty dict from no args", + dict( + init_args=(), + init_kwargs={}, + exp_dict=OrderedDict(), + verify_order=True, + ), + None, None, True + ), + ( + "Empty dict from None as positional arg", + dict( + init_args=(None,), + init_kwargs={}, + exp_dict=OrderedDict(), + verify_order=True, + ), + None, None, True + ), + ( + "Empty dict from empty list as positional arg", + dict( + init_args=(list(),), + init_kwargs={}, + exp_dict=OrderedDict(), + verify_order=True, + ), + None, None, True + ), + ( + "Empty dict from empty tuple as positional arg", + dict( + init_args=(tuple(),), + init_kwargs={}, + exp_dict=OrderedDict(), + verify_order=True, + ), + None, None, True + ), + ( + "Empty dict from empty dict as positional arg", + dict( + init_args=(dict(),), + init_kwargs={}, + exp_dict=OrderedDict(), + verify_order=True, + ), + None, None, True + ), + ( + "Empty dict from empty NocaseDict as positional arg", + dict( + init_args=(NocaseDict(),), + init_kwargs={}, + exp_dict=OrderedDict(), + verify_order=True, + ), + None, None, True + ), - dic = NocaseDict((('Dog', 'Cat'),), Budgie='Fish') - self.assertTrue(len(dic) == 2) - self.assertTrue(dic['Dog'] == 'Cat' and dic['Budgie'] == 'Fish') + # Non-empty NocaseDict + ( + "Dict from list as positional arg", + dict( + init_args=([('Dog', 'Cat'), ('Budgie', 'Fish')],), + init_kwargs={}, + exp_dict=OrderedDict([('Dog', 'Cat'), ('Budgie', 'Fish')]), + verify_order=True, + ), + None, None, True + ), + ( + "Dict from tuple as positional arg", + dict( + init_args=((('Dog', 'Cat'), ('Budgie', 'Fish')),), + init_kwargs={}, + exp_dict=OrderedDict([('Dog', 'Cat'), ('Budgie', 'Fish')]), + verify_order=True, + ), + None, None, True + ), + ( + "Dict from dict as positional arg", + dict( + init_args=({'Dog': 'Cat', 'Budgie': 'Fish'},), + init_kwargs={}, + exp_dict=OrderedDict([('Dog', 'Cat'), ('Budgie', 'Fish')]), + verify_order=False, + ), + None, UserWarning, True + ), + ( + "Dict from keyword args", + dict( + init_args=(), + init_kwargs={'Dog': 'Cat', 'Budgie': 'Fish'}, + exp_dict=OrderedDict([('Dog', 'Cat'), ('Budgie', 'Fish')]), + verify_order=False, + ), + None, UserWarning, True + ), + ( + "Dict from list as positional arg and keyword args", + dict( + init_args=([('Dog', 'Cat')],), + init_kwargs={'Budgie': 'Fish'}, + exp_dict=OrderedDict([('Dog', 'Cat'), ('Budgie', 'Fish')]), + verify_order=True, + ), + None, None, True + ), + ( + "Dict from tuple as positional arg and keyword args", + dict( + init_args=((('Dog', 'Cat'),),), + init_kwargs={'Budgie': 'Fish'}, + exp_dict=OrderedDict([('Dog', 'Cat'), ('Budgie', 'Fish')]), + verify_order=True, + ), + None, None, True + ), + ( + "Dict from dict as positional arg and keyword args", + dict( + init_args=({'Dog': 'Cat'},), + init_kwargs={'Budgie': 'Fish'}, + exp_dict=OrderedDict([('Dog', 'Cat'), ('Budgie', 'Fish')]), + verify_order=True, + ), + None, None, True + ), - # Initialise from dictionary and kwargs + # Error cases + ( + "String type as positional arg", + dict( + init_args=('illegal',), + init_kwargs={}, + exp_dict=None, + verify_order=None, + ), + TypeError, None, True + ), + ( + "Two positional args", + dict( + init_args=(list(), list()), + init_kwargs={}, + exp_dict=None, + verify_order=None, + ), + TypeError, None, True + ), +] - dic = NocaseDict({'Dog': 'Cat'}, Budgie='Fish') - self.assertTrue(len(dic) == 2) - self.assertTrue(dic['Dog'] == 'Cat' and dic['Budgie'] == 'Fish') - # Initialise from unsupported object type +@pytest.mark.parametrize( + "desc, kwargs, exp_exc_types, exp_warn_types, condition", + TESTCASES_NOCASEDICT_INIT) +@pytest_extensions.test_function +def test_NocaseDict_init(testcase, + init_args, init_kwargs, exp_dict, verify_order): + """ + Test function for NocaseDict.__init__(). + """ - try: - dic = NocaseDict('illegal') - except TypeError: - pass - else: - self.fail("TypeError was unexpectedly not thrown.") + # The code to be tested + act_dict = NocaseDict(*init_args, **init_kwargs) - # Initialise with too many positional arguments + # Verify that an exception raised in this function is not mistaken + # to be the expected exception + assert testcase.exp_exc_types is None - try: - dic = NocaseDict(list(), list()) - except TypeError: - pass - else: - self.fail("TypeError was unexpectedly not thrown.") + # The verification below also uses some NocaseDict features, but that is + # unavoidable if we want to work through the public interface: + + act_items = [] + # Next line uses NocaseDict iteration: + for key in act_dict: + # Next line uses NocaseDict access by key: + act_value = act_dict[key] + assert key in exp_dict, "Unexpected extra key %r" % key + exp_value = exp_dict[key] + assert act_value == exp_value, "Unexpected value at key %r" % key + act_items.append((key, act_value)) + + exp_items = [] + for key in exp_dict: + exp_value = exp_dict[key] + # Next line uses NocaseDict containment test: + assert key in act_dict, "Unexpected missing key %r" % key + # Next line uses NocaseDict access by key: + act_value = act_dict[key] + assert act_value == exp_value, "Unexpected value at key %r" % key + exp_items.append((key, exp_value)) + + if verify_order: + assert act_items == exp_items, "Unexpected order of items" class BaseTest(unittest.TestCase):