Pytest conversion of test_AreaWeightedRegridder.py (#6662)

ukmo-ccbunney · web-flow · commit 01837e96e726 · 2025-08-15T14:39:54.000+01:00
diff --git a/lib/iris/tests/unit/analysis/area_weighted/test_AreaWeightedRegridder.py b/lib/iris/tests/unit/analysis/area_weighted/test_AreaWeightedRegridder.py
@@ -4,12 +4,8 @@
 # See LICENSE in the root of the repository for full licensing details.
 """Unit tests for :class:`iris.analysis._area_weighted.AreaWeightedRegridder`."""
 
-# Import iris.tests first so that some things can be initialised before
-# importing anything else.
-import iris.tests as tests  # isort:skip
-from unittest import mock
-
 import numpy as np
+import pytest
 
 from iris import load_cube
 from iris.analysis._area_weighted import (
@@ -19,9 +15,10 @@
 from iris.coord_systems import GeogCS
 from iris.coords import DimCoord
 from iris.cube import Cube
+from iris.tests import _shared_utils
 
 
-class Test(tests.IrisTest):
+class Test:
     def cube(self, x, y):
         data = np.arange(len(x) * len(y)).reshape(len(y), len(x))
         cube = Cube(data)
@@ -41,96 +38,96 @@ def grids(self):
     def extract_grid(self, cube):
         return cube.coord("latitude"), cube.coord("longitude")
 
-    def check_mdtol(self, mdtol=None):
+    def check_mdtol(self, mocker, mdtol=None):
         src_grid, target_grid = self.grids()
         # Get _regrid_info result
         _regrid_info = _regrid_area_weighted_rectilinear_src_and_grid__prepare(
             src_grid, target_grid
         )
-        self.assertEqual(len(_regrid_info), 9)
-        with mock.patch(
+        assert len(_regrid_info) == 9
+        prepare = mocker.patch(
             "iris.analysis._area_weighted."
             "_regrid_area_weighted_rectilinear_src_and_grid__prepare",
             return_value=_regrid_info,
-        ) as prepare:
-            with mock.patch(
-                "iris.analysis._area_weighted."
-                "_regrid_area_weighted_rectilinear_src_and_grid__perform",
-                return_value=mock.sentinel.result,
-            ) as perform:
-                # Setup the regridder
-                if mdtol is None:
-                    regridder = AreaWeightedRegridder(src_grid, target_grid)
-                    mdtol = 1
-                else:
-                    regridder = AreaWeightedRegridder(
-                        src_grid, target_grid, mdtol=mdtol
-                    )
-                # Now regrid the source cube
-                src = src_grid
-                result = regridder(src)
+        )
+        perform = mocker.patch(
+            "iris.analysis._area_weighted."
+            "_regrid_area_weighted_rectilinear_src_and_grid__perform",
+            return_value=mocker.sentinel.result,
+        )
 
-                # Make a new cube to regrid with different data so we can
-                # distinguish between regridding the original src grid
-                # definition cube and the cube passed to the regridder.
-                src = src_grid.copy()
-                src.data += 10
-                result = regridder(src)
+        # Setup the regridder
+        if mdtol is None:
+            regridder = AreaWeightedRegridder(src_grid, target_grid)
+            mdtol = 1
+        else:
+            regridder = AreaWeightedRegridder(src_grid, target_grid, mdtol=mdtol)
+        # Now regrid the source cube
+        src = src_grid
+        result = regridder(src)
+
+        # Make a new cube to regrid with different data so we can
+        # distinguish between regridding the original src grid
+        # definition cube and the cube passed to the regridder.
+        src = src_grid.copy()
+        src.data += 10
+        result = regridder(src)
 
         # Prepare:
-        self.assertEqual(prepare.call_count, 1)
+        assert prepare.call_count == 1
         _, args, kwargs = prepare.mock_calls[0]
-        self.assertEqual(self.extract_grid(args[1]), self.extract_grid(target_grid))
+        assert self.extract_grid(args[1]) == self.extract_grid(target_grid)
 
         # Perform:
-        self.assertEqual(perform.call_count, 2)
+        assert perform.call_count == 2
         _, args, kwargs = perform.mock_calls[1]
-        self.assertEqual(args[0], src)
-        self.assertEqual(kwargs, {"mdtol": mdtol})
-        self.assertIs(result, mock.sentinel.result)
+        assert args[0] == src
+        assert kwargs == {"mdtol": mdtol}
+        assert result is mocker.sentinel.result
 
-    def test_default(self):
-        self.check_mdtol()
+    def test_default(self, mocker):
+        self.check_mdtol(mocker)
 
-    def test_specified_mdtol(self):
-        self.check_mdtol(0.5)
+    def test_specified_mdtol(self, mocker):
+        self.check_mdtol(mocker, mdtol=0.5)
 
     def test_invalid_high_mdtol(self):
         src, target = self.grids()
         msg = "mdtol must be in range 0 - 1"
-        with self.assertRaisesRegex(ValueError, msg):
+        with pytest.raises(ValueError, match=msg):
             AreaWeightedRegridder(src, target, mdtol=1.2)
 
     def test_invalid_low_mdtol(self):
         src, target = self.grids()
         msg = "mdtol must be in range 0 - 1"
-        with self.assertRaisesRegex(ValueError, msg):
+        with pytest.raises(ValueError, match=msg):
             AreaWeightedRegridder(src, target, mdtol=-0.2)
 
-    def test_mismatched_src_coord_systems(self):
+    def test_mismatched_src_coord_systems(self, mocker):
         src = Cube(np.zeros((3, 4)))
         cs = GeogCS(6543210)
         lat = DimCoord(np.arange(3), "latitude", coord_system=cs)
         lon = DimCoord(np.arange(4), "longitude")
         src.add_dim_coord(lat, 0)
         src.add_dim_coord(lon, 1)
-        target = mock.Mock()
-        with self.assertRaises(ValueError):
+        target = mocker.Mock()
+        emsg = "coordinates must have the same coordinate system"
+        with pytest.raises(ValueError, match=emsg):
             AreaWeightedRegridder(src, target)
 
     def test_src_and_target_are_the_same(self):
         src = self.cube(np.linspace(20, 30, 3), np.linspace(10, 25, 4))
         target = self.cube(np.linspace(20, 30, 3), np.linspace(10, 25, 4))
         regridder = AreaWeightedRegridder(src, target)
         result = regridder(src)
-        self.assertArrayAllClose(result.data, target.data)
+        _shared_utils.assert_array_all_close(result.data, target.data)
 
     def test_multiple_src_on_same_grid(self):
         coord_names = ["latitude", "longitude"]
         src1 = self.cube(np.linspace(20, 32, 4), np.linspace(10, 22, 4))
         src2 = self.cube(np.linspace(20, 32, 4), np.linspace(10, 22, 4))
         src2.data *= 4
-        self.assertArrayEqual(src1.data * 4, src2.data)
+        _shared_utils.assert_array_equal(src1.data * 4, src2.data)
         for name in coord_names:
             # Remove coords system and units so it is no longer spherical.
             src1.coord(name).coord_system = None
@@ -192,15 +189,17 @@ def test_multiple_src_on_same_grid(self):
             reference2.coord(name).units = None
 
         # Compare the cubes rather than just the data.
-        self.assertEqual(result1, reference1)
-        self.assertEqual(result2, reference2)
+        assert result1 == reference1
+        assert result2 == reference2
 
     def test_src_data_different_dims(self):
         src, target = self.grids()
         regridder = AreaWeightedRegridder(src, target)
         result = regridder(src)
         expected_mean, expected_std = 4.772097735195653, 2.211698479817678
-        self.assertArrayShapeStats(result, (9, 8), expected_mean, expected_std)
+        _shared_utils.assert_array_shape_stats(
+            result, (9, 8), expected_mean, expected_std
+        )
         # New source cube with additional "levels" dimension
         # Each level has identical x-y data so the mean and std stats remain
         # identical when x, y and z dims are reordered
@@ -213,7 +212,9 @@ def test_src_data_different_dims(self):
         src.add_dim_coord(lat, 1)
         src.add_dim_coord(lon, 2)
         result = regridder(src)
-        self.assertArrayShapeStats(result, (5, 9, 8), expected_mean, expected_std)
+        _shared_utils.assert_array_shape_stats(
+            result, (5, 9, 8), expected_mean, expected_std
+        )
         # Check data with dims in different order
         # Reshape src so that the coords are ordered [x, z, y],
         # the mean and std statistics should be the same
@@ -223,7 +224,9 @@ def test_src_data_different_dims(self):
         src.add_dim_coord(levels, 1)
         src.add_dim_coord(lat, 2)
         result = regridder(src)
-        self.assertArrayShapeStats(result, (8, 5, 9), expected_mean, expected_std)
+        _shared_utils.assert_array_shape_stats(
+            result, (8, 5, 9), expected_mean, expected_std
+        )
         # Check data with dims in different order
         # Reshape src so that the coords are ordered [y, x, z],
         # the mean and std statistics should be the same
@@ -233,18 +236,23 @@ def test_src_data_different_dims(self):
         src.add_dim_coord(lon, 1)
         src.add_dim_coord(levels, 2)
         result = regridder(src)
-        self.assertArrayShapeStats(result, (9, 8, 5), expected_mean, expected_std)
+        _shared_utils.assert_array_shape_stats(
+            result, (9, 8, 5), expected_mean, expected_std
+        )
 
 
-@tests.skip_data
-class TestLazy(tests.IrisTest):
+@_shared_utils.skip_data
+class TestLazy:
+    @pytest.fixture(autouse=True)
     # Setup
-    def setUp(self) -> None:
+    def _setup(self) -> None:
         # Prepare a cube and a template
-        cube_file_path = tests.get_data_path(["NetCDF", "regrid", "regrid_xyt.nc"])
+        cube_file_path = _shared_utils.get_data_path(
+            ["NetCDF", "regrid", "regrid_xyt.nc"]
+        )
         self.cube = load_cube(cube_file_path)
 
-        template_file_path = tests.get_data_path(
+        template_file_path = _shared_utils.get_data_path(
             ["NetCDF", "regrid", "regrid_template_global_latlon.nc"]
         )
         self.template_cube = load_cube(template_file_path)
@@ -258,16 +266,12 @@ def test_src_stays_lazy(self) -> None:
         regridder = AreaWeightedRegridder(cube, self.template_cube)
         regridder(cube)
         # Base cube stays lazy
-        self.assertTrue(cube.has_lazy_data())
+        assert cube.has_lazy_data()
 
     def test_output_lazy(self) -> None:
         cube = self.cube.copy()
         # Regrid the cube onto the template.
         regridder = AreaWeightedRegridder(cube, self.template_cube)
         out = regridder(cube)
         # Lazy base cube means lazy output
-        self.assertTrue(out.has_lazy_data())
-
-
-if __name__ == "__main__":
-    tests.main()
+        assert out.has_lazy_data()
