Convert tests in unit/util to pytest (#5853)

* pytestify, and test__coord_regular

* search and replace

* ruff

* fixed most failures

* renamed result dir

* fixed review comments

* whoops, incorrectly called assert_original_metadata with request after removing it

* corrected assert

Author: ESadek-MO

lib/iris/tests/_shared_utils.py

@@ -536,8 +536,8 @@ def assert_string(request: pytest.FixtureRequest, string, reference_filename=Non
     _check_same(string, reference_path, type_comparison_name="Strings")
 
 
-def assert_repr(obj, reference_filename):
-    assert_string(repr(obj), reference_filename)
+def assert_repr(request: pytest.FixtureRequest, obj, reference_filename):
+    assert_string(request, repr(obj), reference_filename)
 
 
 def _check_same(item, reference_path, type_comparison_name="CML"):

lib/iris/tests/results/unit/util/mask_cube/TestCubeMask/mask_cube_2d_create_new_dim.cml renamed to lib/iris/tests/results/unit/util/mask_cube/CubeMask/mask_cube_2d_create_new_dim.cml

@@ -12,99 +12,92 @@
 
 """
 
-# import iris tests first so that some things can be initialised before
-# importing anything else
-import iris.tests as tests  # isort:skip
-
 import numpy as np
+import pytest
 
 from iris.coords import AuxCoord, DimCoord
 from iris.exceptions import CoordinateMultiDimError, CoordinateNotRegularError
 from iris.util import is_regular, points_step, regular_step
 
 
-class Test_is_regular(tests.IrisTest):
+class Test_is_regular:
     def test_coord_with_regular_step(self):
         coord = DimCoord(np.arange(5))
         result = is_regular(coord)
-        self.assertTrue(result)
+        assert result
 
     def test_coord_with_irregular_step(self):
         # Check that a `CoordinateNotRegularError` is captured.
         coord = AuxCoord(np.array([2, 5, 1, 4]))
         result = is_regular(coord)
-        self.assertFalse(result)
+        assert not result
 
     def test_scalar_coord(self):
         # Check that a `ValueError` is captured.
         coord = DimCoord(5)
         result = is_regular(coord)
-        self.assertFalse(result)
+        assert not result
 
     def test_coord_with_string_points(self):
         # Check that a `TypeError` is captured.
         coord = AuxCoord(["a", "b", "c"])
         result = is_regular(coord)
-        self.assertFalse(result)
+        assert not result
 
 
-class Test_regular_step(tests.IrisTest):
+class Test_regular_step:
     def test_basic(self):
         dtype = np.float64
         points = np.arange(5, dtype=dtype)
         coord = DimCoord(points)
         expected = np.mean(np.diff(points))
         result = regular_step(coord)
-        self.assertEqual(expected, result)
-        self.assertEqual(result.dtype, dtype)
+        assert expected == result
+        assert result.dtype == dtype
 
     def test_2d_coord(self):
         coord = AuxCoord(np.arange(8).reshape(2, 4))
         exp_emsg = "Expected 1D coord"
-        with self.assertRaisesRegex(CoordinateMultiDimError, exp_emsg):
+        with pytest.raises(CoordinateMultiDimError, match=exp_emsg):
             regular_step(coord)
 
     def test_scalar_coord(self):
         coord = DimCoord(5)
         exp_emsg = "non-scalar coord"
-        with self.assertRaisesRegex(ValueError, exp_emsg):
+        with pytest.raises(ValueError, match=exp_emsg):
             regular_step(coord)
 
     def test_coord_with_irregular_step(self):
         name = "latitude"
         coord = AuxCoord(np.array([2, 5, 1, 4]), standard_name=name)
         exp_emsg = "{} is not regular".format(name)
-        with self.assertRaisesRegex(CoordinateNotRegularError, exp_emsg):
+        with pytest.raises(CoordinateNotRegularError, match=exp_emsg):
             regular_step(coord)
 
 
-class Test_points_step(tests.IrisTest):
+class Test_points_step:
     def test_regular_points(self):
         regular_points = np.arange(5)
         exp_avdiff = np.mean(np.diff(regular_points))
         result_avdiff, result = points_step(regular_points)
-        self.assertEqual(exp_avdiff, result_avdiff)
-        self.assertTrue(result)
+        assert exp_avdiff == result_avdiff
+        assert result
 
     def test_irregular_points(self):
         irregular_points = np.array([2, 5, 1, 4])
         exp_avdiff = np.mean(np.diff(irregular_points))
         result_avdiff, result = points_step(irregular_points)
-        self.assertEqual(exp_avdiff, result_avdiff)
-        self.assertFalse(result)
+        assert exp_avdiff == result_avdiff
+        assert not result
 
     def test_single_point(self):
         lone_point = np.array([4])
         result_avdiff, result = points_step(lone_point)
-        self.assertTrue(np.isnan(result_avdiff))
-        self.assertTrue(result)
+        assert np.isnan(result_avdiff)
+        assert result
 
     def test_no_points(self):
         no_points = np.array([])
         result_avdiff, result = points_step(no_points)
-        self.assertTrue(np.isnan(result_avdiff))
-        self.assertTrue(result)
-
-
-if __name__ == "__main__":
-    tests.main()
+        assert np.isnan(result_avdiff)
+        assert result

lib/iris/tests/unit/util/test__coord_regular.py

@@ -4,24 +4,16 @@
 # See LICENSE in the root of the repository for full licensing details.
 """Test function :func:`iris.util._is_circular`."""
 
-# import iris tests first so that some things can be initialised before
-# importing anything else
-import iris.tests as tests  # isort:skip
-
 import numpy as np
 
 from iris.util import _is_circular
 
 
-class Test(tests.IrisTest):
+class Test:
     def test_simple(self):
         data = np.arange(12) * 30
-        self.assertTrue(_is_circular(data, 360))
+        assert _is_circular(data, 360)
 
     def test_negative_diff(self):
         data = (np.arange(96) * -3.749998) + 3.56249908e02
-        self.assertTrue(_is_circular(data, 360))
-
-
-if __name__ == "__main__":
-    tests.main()
+        assert _is_circular(data, 360)

lib/iris/tests/unit/util/test__is_circular.py

@@ -34,7 +34,7 @@
 )
 @pytest.mark.parametrize("lazy_mask", [False, True], ids=["real", "lazy"])
 @pytest.mark.parametrize(
-    "array, expected", array_choices, ids=["plain-array", "masked-array"]
+    ("array", "expected"), array_choices, ids=["plain-array", "masked-array"]
 )
 @pytest.mark.parametrize("lazy_array", [False, True], ids=["real", "lazy"])
 def test_1d_not_in_place(array, mask, expected, lazy_array, lazy_mask):

lib/iris/tests/unit/util/test__mask_array.py

@@ -11,14 +11,11 @@
 in combination.
 
 """
-
-# import iris tests first so that some things can be initialised before
-# importing anything else
-import iris.tests as tests  # isort:skip
-
 import numpy as np
+import pytest
 
 from iris._lazy_data import as_concrete_data, as_lazy_data
+from iris.tests import _shared_utils
 from iris.util import _slice_data_with_keys
 
 
@@ -77,15 +74,12 @@ def showkeys(keys_list):
                 msg += "\n]"
                 return msg
 
-            self.assertTrue(
-                equal,
-                errmsg.format(showkeys(calls_got), showkeys(expect_call_keys)),
-            )
+            assert equal, errmsg.format(showkeys(calls_got), showkeys(expect_call_keys))
         if expect_map is not None:
-            self.assertEqual(dim_map, expect_map)
+            assert dim_map == expect_map
 
 
-class Test_indexing(MixinIndexingTest, tests.IrisTest):
+class Test_indexing(MixinIndexingTest):
     # Check the indexing operations performed for various requested keys.
 
     def test_0d_nokeys(self):
@@ -105,12 +99,12 @@ def test_1d_tuple(self):
 
     def test_fail_1d_2keys(self):
         msg = "More slices .* than dimensions"
-        with self.assertRaisesRegex(IndexError, msg):
+        with pytest.raises(IndexError, match=msg):
             self.check((3,), Index[1, 2])
 
     def test_fail_empty_slice(self):
         msg = "Cannot index with zero length slice"
-        with self.assertRaisesRegex(IndexError, msg):
+        with pytest.raises(IndexError, match=msg):
             self.check((3,), Index[1:1])
 
     def test_2d_tuple(self):
@@ -192,7 +186,7 @@ def test_3d_multiple_tuples(self):
         # That's just what it does at present.
 
 
-class Test_dimensions_mapping(MixinIndexingTest, tests.IrisTest):
+class Test_dimensions_mapping(MixinIndexingTest):
     # Check the dimensions map returned for various requested keys.
 
     def test_1d_nochange(self):
@@ -236,7 +230,7 @@ def test_3d_losedim1(self):
         )
 
 
-class TestResults(tests.IrisTest):
+class TestResults:
     # Integration-style test, exercising (mostly) the same cases as above,
     # but checking actual results, for both real and lazy array inputs.
 
@@ -246,10 +240,10 @@ def check(self, real_data, keys, expect_result, expect_map):
         real_dim_map, real_result = _slice_data_with_keys(real_data, keys)
         lazy_dim_map, lazy_result = _slice_data_with_keys(lazy_data, keys)
         lazy_result = as_concrete_data(lazy_result)
-        self.assertArrayEqual(real_result, expect_result)
-        self.assertArrayEqual(lazy_result, expect_result)
-        self.assertEqual(real_dim_map, expect_map)
-        self.assertEqual(lazy_dim_map, expect_map)
+        _shared_utils.assert_array_equal(real_result, expect_result)
+        _shared_utils.assert_array_equal(lazy_result, expect_result)
+        assert real_dim_map == expect_map
+        assert lazy_dim_map == expect_map
 
     def test_1d_int(self):
         self.check([1, 2, 3, 4], Index[2], [3], {None: None, 0: None})
@@ -262,12 +256,12 @@ def test_1d_tuple(self):
 
     def test_fail_1d_2keys(self):
         msg = "More slices .* than dimensions"
-        with self.assertRaisesRegex(IndexError, msg):
+        with pytest.raises(IndexError, match=msg):
             self.check([1, 2, 3], Index[1, 2], None, None)
 
     def test_fail_empty_slice(self):
         msg = "Cannot index with zero length slice"
-        with self.assertRaisesRegex(IndexError, msg):
+        with pytest.raises(IndexError, match=msg):
             self.check([1, 2, 3], Index[1:1], None, None)
 
     def test_2d_tuple(self):
@@ -418,7 +412,3 @@ def test_3d_multiple_tuples(self):
         )
         # NOTE: there seem to be an extra initial [:, :, :].
         # That's just what it does at present.
-
-
-if __name__ == "__main__":
-    tests.main()