tests_utils: Migrate to pytest tests

swh/deposit/tests/test_utils.py

@@ -48,127 +48,127 @@ def test_origin_url_from_ko():
             utils.origin_url_from(deposit)
 
 
-class UtilsTestCase(unittest.TestCase):
-    """Utils library
+def test_merge():
+    """Calling utils.merge on dicts should merge without losing information
 
     """
-    def test_merge(self):
-        """Calling utils.merge on dicts should merge without losing information
-
-        """
-        d0 = {
-            'author': 'someone',
-            'license': [['gpl2']],
-            'a': 1
+    d0 = {
+        'author': 'someone',
+        'license': [['gpl2']],
+        'a': 1
+    }
+
+    d1 = {
+        'author': ['author0', {'name': 'author1'}],
+        'license': [['gpl3']],
+        'b': {
+            '1': '2'
         }
+    }
 
-        d1 = {
-            'author': ['author0', {'name': 'author1'}],
-            'license': [['gpl3']],
-            'b': {
-                '1': '2'
-            }
+    d2 = {
+        'author': map(lambda x: x, ['else']),
+        'license': 'mit',
+        'b': {
+            '2': '3',
         }
-
-        d2 = {
-            'author': map(lambda x: x, ['else']),
-            'license': 'mit',
-            'b': {
-                '2': '3',
-            }
+    }
+
+    d3 = {
+        'author': (v for v in ['no one']),
+    }
+
+    actual_merge = utils.merge(d0, d1, d2, d3)
+
+    expected_merge = {
+        'a': 1,
+        'license': [['gpl2'], ['gpl3'], 'mit'],
+        'author': [
+            'someone', 'author0', {'name': 'author1'}, 'else', 'no one'],
+        'b': {
+            '1': '2',
+            '2': '3',
         }
+    }
+    assert actual_merge == expected_merge
 
-        d3 = {
-            'author': (v for v in ['no one']),
-        }
 
-        actual_merge = utils.merge(d0, d1, d2, d3)
-
-        expected_merge = {
-            'a': 1,
-            'license': [['gpl2'], ['gpl3'], 'mit'],
-            'author': [
-                'someone', 'author0', {'name': 'author1'}, 'else', 'no one'],
-            'b': {
-                '1': '2',
-                '2': '3',
-            }
+def test_merge_2():
+    d0 = {
+        'license': 'gpl2',
+        'runtime': {
+            'os': 'unix derivative'
         }
-        self.assertEqual(actual_merge, expected_merge)
+    }
 
-    def test_merge_2(self):
-        d0 = {
-            'license': 'gpl2',
-            'runtime': {
+    d1 = {
+        'license': 'gpl3',
+        'runtime': 'GNU/Linux'
+    }
+
+    expected = {
+        'license': ['gpl2', 'gpl3'],
+        'runtime': [
+            {
                 'os': 'unix derivative'
-            }
-        }
+            },
+            'GNU/Linux'
+        ],
+    }
 
-        d1 = {
-            'license': 'gpl3',
-            'runtime': 'GNU/Linux'
-        }
+    actual = utils.merge(d0, d1)
+    assert actual == expected
 
-        expected = {
-            'license': ['gpl2', 'gpl3'],
-            'runtime': [
-                {
-                    'os': 'unix derivative'
-                },
-                'GNU/Linux'
-            ],
-        }
 
-        actual = utils.merge(d0, d1)
-        self.assertEqual(actual, expected)
-
-    def test_merge_edge_cases(self):
-        input_dict = {
-            'license': ['gpl2', 'gpl3'],
-            'runtime': [
-                {
-                    'os': 'unix derivative'
-                },
-                'GNU/Linux'
-            ],
-        }
-        # against empty dict
-        actual = utils.merge(input_dict, {})
-        self.assertEqual(actual, input_dict)
+def test_merge_edge_cases():
+    input_dict = {
+        'license': ['gpl2', 'gpl3'],
+        'runtime': [
+            {
+                'os': 'unix derivative'
+            },
+            'GNU/Linux'
+        ],
+    }
+    # against empty dict
+    actual = utils.merge(input_dict, {})
+    assert actual == input_dict
 
-        # against oneself
-        actual = utils.merge(input_dict, input_dict, input_dict)
-        self.assertEqual(input_dict, input_dict)
+    # against oneself
+    actual = utils.merge(input_dict, input_dict, input_dict)
+    assert actual == input_dict
 
-    def test_merge_one_dict(self):
-        """Merge one dict should result in the same dict value
 
-        """
-        input_and_expected = {'anything': 'really'}
-        actual = utils.merge(input_and_expected)
-        self.assertEqual(actual, input_and_expected)
+def test_merge_one_dict():
+    """Merge one dict should result in the same dict value
 
-    def test_merge_raise(self):
-        """Calling utils.merge with any no dict argument should raise
+    """
+    input_and_expected = {'anything': 'really'}
+    actual = utils.merge(input_and_expected)
+    assert actual == input_and_expected
 
-        """
-        d0 = {
-            'author': 'someone',
-            'a': 1
-        }
 
-        d1 = ['not a dict']
+def test_merge_raise():
+    """Calling utils.merge with any no dict argument should raise
+
+    """
+    d0 = {
+        'author': 'someone',
+        'a': 1
+    }
+
+    d1 = ['not a dict']
 
-        with self.assertRaises(ValueError):
-            utils.merge(d0, d1)
+    with pytest.raises(ValueError):
+        utils.merge(d0, d1)
 
-        with self.assertRaises(ValueError):
-            utils.merge(d1, d0)
+    with pytest.raises(ValueError):
+        utils.merge(d1, d0)
 
-        with self.assertRaises(ValueError):
-            utils.merge(d1)
+    with pytest.raises(ValueError):
+        utils.merge(d1)
 
-        self.assertEqual(utils.merge(d0), d0)
+    assert utils.merge(d0) == d0
 
 
 @patch('swh.deposit.utils.normalize_timestamp', side_effect=lambda x: x)