pytest migration of unit.common.metadata.test_metadata_manager_factory

lib/iris/tests/unit/common/metadata/test_metadata_manager_factory.py

@@ -4,14 +4,10 @@
 # See LICENSE in the root of the repository for full licensing details.
 """Unit tests for the :func:`iris.common.metadata.metadata_manager_factory`."""
 
-# Import iris.tests first so that some things can be initialised before
-# importing anything else.
-import iris.tests as tests  # isort:skip
-
 import pickle
-import unittest.mock as mock
 
 from cf_units import Unit
+import pytest
 
 from iris.common.metadata import (
     AncillaryVariableMetadata,
@@ -33,15 +29,16 @@
 ]
 
 
-class Test_factory(tests.IrisTest):
+class Test_factory:
     def test__kwargs_invalid(self):
         emsg = "Invalid 'BaseMetadata' field parameters, got 'wibble'."
-        with self.assertRaisesRegex(ValueError, emsg):
-            metadata_manager_factory(BaseMetadata, wibble="nope")
+        with pytest.raises(ValueError, match=emsg):
+            _ = metadata_manager_factory(BaseMetadata, wibble="nope")
 
 
-class Test_instance(tests.IrisTest):
-    def setUp(self):
+class Test_instance:
+    @pytest.fixture(autouse=True)
+    def _setup(self):
         self.bases = BASES
 
     def test__namespace(self):
@@ -62,70 +59,72 @@ def test__namespace(self):
         for base in self.bases:
             metadata = metadata_manager_factory(base)
             for name in namespace:
-                self.assertTrue(hasattr(metadata, name))
+                assert hasattr(metadata, name)
             if base is CubeMetadata:
-                self.assertTrue(hasattr(metadata, "_names"))
-            self.assertIs(metadata.cls, base)
+                assert hasattr(metadata, "_names")
+            assert metadata.cls is base
 
     def test__kwargs_default(self):
         for base in self.bases:
             kwargs = dict(zip(base._fields, [None] * len(base._fields)))
             metadata = metadata_manager_factory(base)
-            self.assertEqual(metadata.values._asdict(), kwargs)
+            assert metadata.values._asdict() == kwargs
 
     def test__kwargs(self):
         for base in self.bases:
             kwargs = dict(zip(base._fields, range(len(base._fields))))
             metadata = metadata_manager_factory(base, **kwargs)
-            self.assertEqual(metadata.values._asdict(), kwargs)
+            assert metadata.values._asdict() == kwargs
 
 
-class Test_instance___eq__(tests.IrisTest):
-    def setUp(self):
+class Test_instance___eq__:
+    @pytest.fixture(autouse=True)
+    def _setup(self):
         self.metadata = metadata_manager_factory(BaseMetadata)
 
     def test__not_implemented(self):
-        self.assertNotEqual(self.metadata, 1)
+        assert self.metadata != 1
 
     def test__not_is_cls(self):
         base = BaseMetadata
         other = metadata_manager_factory(base)
-        self.assertIs(other.cls, base)
+        assert other.cls is base
         other.cls = CoordMetadata
-        self.assertNotEqual(self.metadata, other)
+        assert other != self.metadata
 
-    def test__not_values(self):
-        standard_name = mock.sentinel.standard_name
+    def test__not_values(self, mocker):
+        standard_name = mocker.sentinel.standard_name
         other = metadata_manager_factory(BaseMetadata, standard_name=standard_name)
-        self.assertEqual(other.standard_name, standard_name)
-        self.assertIsNone(other.long_name)
-        self.assertIsNone(other.var_name)
-        self.assertIsNone(other.units)
-        self.assertIsNone(other.attributes)
-        self.assertNotEqual(self.metadata, other)
+        assert other.standard_name == standard_name
+        assert other.long_name is None
+        assert other.var_name is None
+        assert other.units is None
+        assert other.attributes is None
+        assert other != self.metadata
 
     def test__same_default(self):
         other = metadata_manager_factory(BaseMetadata)
-        self.assertEqual(self.metadata, other)
+        assert other == self.metadata
 
     def test__same(self):
         kwargs = dict(standard_name=1, long_name=2, var_name=3, units=4, attributes=5)
         metadata = metadata_manager_factory(BaseMetadata, **kwargs)
         other = metadata_manager_factory(BaseMetadata, **kwargs)
-        self.assertEqual(metadata.values._asdict(), kwargs)
-        self.assertEqual(metadata, other)
+        assert metadata.values._asdict() == kwargs
+        assert metadata == other
 
 
-class Test_instance____repr__(tests.IrisTest):
-    def setUp(self):
+class Test_instance____repr__:
+    @pytest.fixture(autouse=True)
+    def _setup(self):
         self.metadata = metadata_manager_factory(BaseMetadata)
 
-    def test(self):
-        standard_name = mock.sentinel.standard_name
-        long_name = mock.sentinel.long_name
-        var_name = mock.sentinel.var_name
-        units = mock.sentinel.units
-        attributes = mock.sentinel.attributes
+    def test(self, mocker):
+        standard_name = mocker.sentinel.standard_name
+        long_name = mocker.sentinel.long_name
+        var_name = mocker.sentinel.var_name
+        units = mocker.sentinel.units
+        attributes = mocker.sentinel.attributes
         values = (standard_name, long_name, var_name, units, attributes)
 
         for field, value in zip(self.metadata.fields, values):
@@ -136,11 +135,12 @@ def test(self):
             "MetadataManager(standard_name={!r}, long_name={!r}, var_name={!r}, "
             "units={!r}, attributes={!r})"
         )
-        self.assertEqual(result, expected.format(*values))
+        assert result == expected.format(*values)
 
 
-class Test_instance__pickle(tests.IrisTest):
-    def setUp(self):
+class Test_instance__pickle:
+    @pytest.fixture(autouse=True)
+    def _setup(self):
         self.standard_name = "standard_name"
         self.long_name = "long_name"
         self.var_name = "var_name"
@@ -156,40 +156,38 @@ def setUp(self):
         kwargs = dict(zip(BaseMetadata._fields, values))
         self.metadata = metadata_manager_factory(BaseMetadata, **kwargs)
 
-    def test_pickle(self):
+    def test_pickle(self, tmp_path):
         for protocol in range(pickle.HIGHEST_PROTOCOL + 1):
-            with self.temp_filename(suffix=".pkl") as fname:
-                with open(fname, "wb") as fout:
-                    pickle.dump(self.metadata, fout, protocol=protocol)
-                with open(fname, "rb") as fin:
-                    metadata = pickle.load(fin)
-                    self.assertEqual(metadata, self.metadata)
+            fname = tmp_path / f"pickle_{protocol}.pkl"
+            with open(fname, "wb") as fout:
+                pickle.dump(self.metadata, fout, protocol=protocol)
+            with open(fname, "rb") as fin:
+                metadata = pickle.load(fin)
+                assert metadata == self.metadata
 
 
-class Test_instance__fields(tests.IrisTest):
-    def setUp(self):
+class Test_instance__fields:
+    @pytest.fixture(autouse=True)
+    def _setup(self):
         self.bases = BASES
 
     def test(self):
         for base in self.bases:
             fields = base._fields
             metadata = metadata_manager_factory(base)
-            self.assertEqual(metadata.fields, fields)
+            assert metadata.fields == fields
             for field in fields:
                 hasattr(metadata, field)
 
 
-class Test_instance__values(tests.IrisTest):
-    def setUp(self):
+class Test_instance__values:
+    @pytest.fixture(autouse=True)
+    def _setup(self):
         self.bases = BASES
 
     def test(self):
         for base in self.bases:
             metadata = metadata_manager_factory(base)
             result = metadata.values
-            self.assertIsInstance(result, base)
-            self.assertEqual(result._fields, base._fields)
-
-
-if __name__ == "__main__":
-    tests.main()
+            assert isinstance(result, base)
+            assert result._fields == base._fields