Merge pull request #30 from bjlittle/more-tests

more test coverage

Author: bjlittle

agg_regrid/__init__.py

@@ -98,12 +98,17 @@ def __init__(self, src_grid_cube, tgt_grid_cube):
 
         # Snapshot the state of the grid cubes to ensure that the regridder
         # is impervious to external changes to the original cubes.
-        self._src_grid = snapshot_grid(src_grid_cube)
+        self._sx, self._sy = snapshot_grid(src_grid_cube)
         self._gx, self._gy = snapshot_grid(tgt_grid_cube)
 
-        # Check the grid cube coordinate system.
+        # Check the source grid cube coordinate system.
+        if self._sx.coord_system is None or self._sy.coord_system is None:
+            emsg = 'The source grid cube requires a native coordinate system.'
+            raise ValueError(emsg)
+
+        # Check the target grid cube coordinate system.
         if self._gx.coord_system is None or self._gy.coord_system is None:
-            emsg = 'The grid cube requires a native coordinate system.'
+            emsg = 'The target grid cube requires a native coordinate system.'
             raise ValueError(emsg)
 
         # Cache the grid bounds converted to the source crs.
@@ -138,17 +143,16 @@ def __call__(self, src_cube):
         """
         # Sanity check the supplied source cube.
         if not isinstance(src_cube, iris.cube.Cube):
-            raise TypeError('The source must be a cube.')
+            emsg = 'The source must be a cube, got {}.'
+            raise TypeError(emsg.format(type(src_cube)))
 
         # Get the source cube x and y coordinates.
         sx, sy = get_xy_dim_coords(src_cube)
-        if (sx, sy) != self._src_grid:
+
+        if (sx, sy) != (self._sx, self._sy):
             emsg = 'The source cube is not defined on the same source grid ' \
                 'as this regridder.'
             raise ValueError(emsg)
-        if sx.coord_system is None:
-            msg = 'The source cube requires a native coordinate system.'
-            raise ValueError(msg)
 
         # Convert the contiguous bounds of the grid to the source crs.
         gxx, gyy = np.meshgrid(self._gx.contiguous_bounds(),
@@ -182,7 +186,6 @@ def __call__(self, src_cube):
         #
         result_cube = iris.cube.Cube(result)
         result_cube.metadata = copy.deepcopy(src_cube.metadata)
-        coord_mapping = {}
 
         def copy_coords(coords, add_coord):
             for coord in coords:
@@ -195,7 +198,6 @@ def copy_coords(coords, add_coord):
                     continue
                 result_coord = coord.copy()
                 add_coord(result_coord, dims)
-                coord_mapping[id(coord)] = result_coord
 
         copy_coords(src_cube.dim_coords, result_cube.add_dim_coord)
         copy_coords(src_cube.aux_coords, result_cube.add_aux_coord)

agg_regrid/tests/test__AreadWeightedRegridder.py

@@ -35,6 +35,16 @@ class Test(unittest.TestCase):
     def setUp(self):
         self.src_cube = mock.Mock(spec=iris.cube.Cube)
         self.tgt_cube = mock.Mock(spec=iris.cube.Cube)
+        scs = mock.sentinel.srs
+        self.sx = mock.Mock(coord_system=scs)
+        self.sy = mock.Mock(coord_system=scs)
+        tcs = mock.sentinel.tcs
+        self.gx = mock.Mock(coord_system=tcs)
+        self.gy = mock.Mock(coord_system=tcs)
+        self.src_grid = (self.sx, self.sy)
+        self.tgt_grid = (self.gx, self.gy)
+        self.side_effect = (self.src_grid, self.tgt_grid)
+        self.snapshot_grid = 'agg_regrid.snapshot_grid'
 
     def test_bad_src_grid_cube(self):
         emsg = 'source grid must be a cube'
@@ -46,51 +56,143 @@ def test_bad_tgt_grid_cube(self):
         with assertRaisesRegex(self, TypeError, emsg):
             Regridder(self.src_cube, 'dummy')
 
-    def test_snapshot_grid(self):
-        snapshot = 'agg_regrid.snapshot_grid'
-        src_grid = mock.sentinel.src_grid
-        gx = mock.Mock(coord_system=True)
-        gy = mock.Mock(coord_system=True)
-        tgt_grid = (gx, gy)
-        side_effect = [src_grid, tgt_grid]
-
-        with mock.patch(snapshot, side_effect=side_effect):
+    def test_src_grid_tgt_grid(self):
+        with mock.patch(self.snapshot_grid, side_effect=self.side_effect):
             regridder = Regridder(self.src_cube, self.tgt_cube)
 
-        self.assertEqual(regridder._src_grid, src_grid)
-        self.assertEqual(regridder._gx, gx)
-        self.assertEqual(regridder._gy, gy)
+        self.assertEqual(regridder._sx, self.sx)
+        self.assertEqual(regridder._sy, self.sy)
+        self.assertEqual(regridder._gx, self.gx)
+        self.assertEqual(regridder._gy, self.gy)
         self.assertIsNone(regridder._gx_bounds)
         self.assertIsNone(regridder._gy_bounds)
         self.assertIsNone(regridder._sx_bounds)
         self.assertIsNone(regridder._sy_bounds)
 
+    def test_snapshot_grid__no_sx_coord_system(self):
+        sx = mock.Mock(coord_system=None)
+        src_grid = (sx, self.sy)
+        side_effect = (src_grid, self.tgt_grid)
+
+        with mock.patch(self.snapshot_grid, side_effect=side_effect):
+            emsg = 'source grid cube requires a native coordinate system'
+            with assertRaisesRegex(self, ValueError, emsg):
+                Regridder(self.src_cube, self.tgt_cube)
+
+    def test_snapshot_grid__no_sy_coord_system(self):
+        sy = mock.Mock(coord_system=None)
+        src_grid = (self.sx, sy)
+        side_effect = (src_grid, self.tgt_grid)
+
+        with mock.patch(self.snapshot_grid, side_effect=side_effect):
+            emsg = 'source grid cube requires a native coordinate system'
+            with assertRaisesRegex(self, ValueError, emsg):
+                Regridder(self.src_cube, self.tgt_cube)
+
     def test_snapshot_grid__no_gx_coord_system(self):
-        snapshot = 'agg_regrid.snapshot_grid'
-        src_grid = mock.sentinel.src_grid
         gx = mock.Mock(coord_system=None)
-        gy = mock.Mock(coord_system=True)
-        tgt_grid = (gx, gy)
-        side_effect = [src_grid, tgt_grid]
+        tgt_grid = (gx, self.gy)
+        side_effect = (self.src_grid, tgt_grid)
 
-        with mock.patch(snapshot, side_effect=side_effect):
-            emsg = 'grid cube requires a native coordinate system'
+        with mock.patch(self.snapshot_grid, side_effect=side_effect):
+            emsg = 'target grid cube requires a native coordinate system'
             with assertRaisesRegex(self, ValueError, emsg):
                 Regridder(self.src_cube, self.tgt_cube)
 
     def test_snapshot_grid__no_gy_coord_system(self):
-        snapshot = 'agg_regrid.snapshot_grid'
-        src_grid = mock.sentinel.src_grid
-        gx = mock.Mock(coord_system=True)
         gy = mock.Mock(coord_system=None)
-        tgt_grid = (gx, gy)
-        side_effect = [src_grid, tgt_grid]
+        tgt_grid = (self.gx, gy)
+        side_effect = (self.src_grid, tgt_grid)
 
-        with mock.patch(snapshot, side_effect=side_effect):
-            emsg = 'grid cube requires a native coordinate system'
+        with mock.patch(self.snapshot_grid, side_effect=side_effect):
+            emsg = 'target grid cube requires a native coordinate system'
             with assertRaisesRegex(self, ValueError, emsg):
                 Regridder(self.src_cube, self.tgt_cube)
 
 
+class Test___call__(unittest.TestCase):
+    def setUp(self):
+        self.src_cube = mock.Mock(spec=iris.cube.Cube)
+        self.tgt_cube = mock.Mock(spec=iris.cube.Cube)
+        self.sx_dim = mock.sentinel.sx_dim
+        self.sy_dim = mock.sentinel.sy_dim
+        coord_dims = mock.Mock(side_effect=([self.sx_dim], [self.sy_dim]))
+        self.metadata = dict(standard_name='air_pressure',
+                             long_name='long_name', var_name='var_name',
+                             units='Pa', attributes={}, cell_methods=())
+        self.data = mock.sentinel.data
+        self.cube = mock.Mock(spec=iris.cube.Cube, coord_dims=coord_dims,
+                              metadata=self.metadata, dim_coords=(),
+                              aux_coords=(), data=self.data)
+        scrs = mock.sentinel.scrs
+        self.sxp = mock.sentinel.sx_points
+        self.sxb = mock.sentinel.sx_contiguous_bounds
+        self.syp = mock.sentinel.sy_points
+        self.syb = mock.sentinel.sy_contiguous_bounds
+        self.sx = mock.Mock(coord_system=scrs,
+                            points=self.sxp,
+                            contiguous_bounds=mock.Mock(return_value=self.sxb))
+        self.sy = mock.Mock(coord_system=scrs,
+                            points=self.syp,
+                            contiguous_bounds=mock.Mock(return_value=self.syb))
+        tcrs = mock.sentinel.tcrs
+        gx = mock.Mock(coord_system=tcrs)
+        gy = mock.Mock(coord_system=tcrs)
+        self.src_grid = (self.sx, self.sy)
+        tgt_grid = (gx, gy)
+        self.side_effect = (self.src_grid, tgt_grid)
+        self.snapshot_grid = 'agg_regrid.snapshot_grid'
+        self.get_xy_dim_coords = 'agg_regrid.get_xy_dim_coords'
+
+    def test_bad_src_cube(self):
+        with mock.patch(self.snapshot_grid, side_effect=self.side_effect):
+            emsg = 'source must be a cube'
+            with assertRaisesRegex(self, TypeError, emsg):
+                regridder = Regridder(self.src_cube, self.tgt_cube)
+                regridder('dummy')
+
+    def test_bad_src_cube__sx_different_grid(self):
+        with mock.patch(self.snapshot_grid, side_effect=self.side_effect):
+            return_value = (False, self.sy)
+            with mock.patch(self.get_xy_dim_coords, return_value=return_value):
+                emsg = 'source cube is not defined on the same source grid'
+                with assertRaisesRegex(self, ValueError, emsg):
+                    regridder = Regridder(self.src_cube, self.tgt_cube)
+                    regridder(self.cube)
+
+    def test_bad_src_cube__sy_different_grid(self):
+        with mock.patch(self.snapshot_grid, side_effect=self.side_effect):
+            return_value = (self.sx, False)
+            with mock.patch(self.get_xy_dim_coords, return_value=return_value):
+                emsg = 'source cube is not defined on the same source grid'
+                with assertRaisesRegex(self, ValueError, emsg):
+                    regridder = Regridder(self.src_cube, self.tgt_cube)
+                    regridder(self.cube)
+
+    def test_same_crs(self):
+        side_effect = (self.src_grid, self.src_grid)
+        with mock.patch(self.snapshot_grid, side_effect=side_effect):
+            with mock.patch(self.get_xy_dim_coords,
+                            return_value=self.src_grid):
+                gxx, gyy = (mock.sentinel.gxx, mock.sentinel.gyy)
+                with mock.patch('numpy.meshgrid', return_value=(gxx, gyy)):
+                    data = 1
+                    with mock.patch('agg_regrid.agg',
+                                    return_value=data) as magg:
+                        regridder = Regridder(self.src_cube, self.tgt_cube)
+                        result = regridder(self.cube)
+
+        self.assertEqual(regridder._sx_bounds, self.sxb)
+        self.assertEqual(regridder._sy_bounds, self.syb)
+        self.assertEqual(regridder._gx_bounds, gxx)
+        self.assertEqual(regridder._gy_bounds, gyy)
+        expected = [mock.call(self.data, self.sxp, self.sxb, self.syp,
+                              self.syb, self.sx_dim, self.sy_dim, gxx, gyy)]
+        self.assertEqual(magg.call_args_list, expected)
+        cube = iris.cube.Cube(data)
+        cube.metadata = self.metadata
+        self.assertEqual(result, cube)
+
+
 if __name__ == '__main__':
     unittest.main()