Converted test_nocasedict.py from unittest to pytest

Signed-off-by: Andreas Maier <maiera@de.ibm.com>
pywbem · Apr 28, 2018 · 291e581 · 291e581
1 parent fa46263
commit 291e581
Showing 1 changed file with 210 additions and 74 deletions.
diff --git 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):