Convert to pytest.

lib/iris/tests/unit/fileformats/name_loaders/test__build_cell_methods.py

@@ -3,42 +3,37 @@
 # This file is part of Iris and is released under the BSD license.
 # See LICENSE in the root of the repository for full licensing details.
 """Unit tests for :func:`iris.fileformats.name_loaders._build_cell_methods`."""
-
-# 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 pytest
 
 import iris.coords
 from iris.fileformats.name_loaders import _build_cell_methods
 from iris.warnings import IrisLoadWarning
 
 
-class Tests(tests.IrisTest):
-    def test_nameII_average(self):
+class Tests:
+    def test_name_ii_average(self):
         av_or_int = ["something average ob bla"]
         coord_name = "foo"
         res = _build_cell_methods(av_or_int, coord_name)
-        self.assertEqual(res, [iris.coords.CellMethod("mean", "foo")])
+        assert res == [iris.coords.CellMethod("mean", "foo")]
 
-    def test_nameIII_averaged(self):
+    def test_name_iii_averaged(self):
         av_or_int = ["something averaged ob bla"]
         coord_name = "bar"
         res = _build_cell_methods(av_or_int, coord_name)
-        self.assertEqual(res, [iris.coords.CellMethod("mean", "bar")])
+        assert res == [iris.coords.CellMethod("mean", "bar")]
 
-    def test_nameII_integral(self):
+    def test_name_ii_integral(self):
         av_or_int = ["something integral ob bla"]
         coord_name = "ensemble"
         res = _build_cell_methods(av_or_int, coord_name)
-        self.assertEqual(res, [iris.coords.CellMethod("sum", "ensemble")])
+        assert res == [iris.coords.CellMethod("sum", "ensemble")]
 
-    def test_nameIII_integrated(self):
+    def test_name_iii_integrated(self):
         av_or_int = ["something integrated ob bla"]
         coord_name = "time"
         res = _build_cell_methods(av_or_int, coord_name)
-        self.assertEqual(res, [iris.coords.CellMethod("sum", "time")])
+        assert res == [iris.coords.CellMethod("sum", "time")]
 
     def test_no_averaging(self):
         av_or_int = [
@@ -51,41 +46,35 @@ def test_no_averaging(self):
         ]
         coord_name = "time"
         res = _build_cell_methods(av_or_int, coord_name)
-        self.assertEqual(res, [None] * len(av_or_int))
+        assert res == [None] * len(av_or_int)
 
-    def test_nameII_mixed(self):
+    def test_name_ii_mixed(self):
         av_or_int = [
             "something integral ob bla",
             "no averaging",
             "other average",
         ]
         coord_name = "ensemble"
         res = _build_cell_methods(av_or_int, coord_name)
-        self.assertEqual(
-            res,
-            [
-                iris.coords.CellMethod("sum", "ensemble"),
-                None,
-                iris.coords.CellMethod("mean", "ensemble"),
-            ],
-        )
+        assert res == [
+            iris.coords.CellMethod("sum", "ensemble"),
+            None,
+            iris.coords.CellMethod("mean", "ensemble"),
+        ]
 
-    def test_nameIII_mixed(self):
+    def test_name_iii_mixed(self):
         av_or_int = [
             "something integrated ob bla",
             "no averaging",
             "other averaged",
         ]
         coord_name = "ensemble"
         res = _build_cell_methods(av_or_int, coord_name)
-        self.assertEqual(
-            res,
-            [
-                iris.coords.CellMethod("sum", "ensemble"),
-                None,
-                iris.coords.CellMethod("mean", "ensemble"),
-            ],
-        )
+        assert res == [
+            iris.coords.CellMethod("sum", "ensemble"),
+            None,
+            iris.coords.CellMethod("mean", "ensemble"),
+        ]
 
     def test_unrecognised(self):
         unrecognised_heading = "bla else"
@@ -95,14 +84,13 @@ def test_unrecognised(self):
             "something integral",
         ]
         coord_name = "foo"
-        with mock.patch("warnings.warn") as warn:
-            _ = _build_cell_methods(av_or_int, coord_name)
         expected_msg = (
             "Unknown {} statistic: {!r}. Unable to create cell method.".format(
                 coord_name, unrecognised_heading
             )
         )
-        warn.assert_called_with(expected_msg, category=IrisLoadWarning)
+        with pytest.warns(IrisLoadWarning, match=expected_msg):
+            _ = _build_cell_methods(av_or_int, coord_name)
 
     def test_unrecognised_similar_to_no_averaging(self):
         unrecognised_headings = [
@@ -121,15 +109,10 @@ def test_unrecognised_similar_to_no_averaging(self):
                 "something integral",
             ]
             coord_name = "foo"
-            with mock.patch("warnings.warn") as warn:
-                _ = _build_cell_methods(av_or_int, coord_name)
             expected_msg = (
                 "Unknown {} statistic: {!r}. Unable to create cell method.".format(
                     coord_name, unrecognised_heading
                 )
             )
-            warn.assert_called_with(expected_msg, category=IrisLoadWarning)
-
-
-if __name__ == "__main__":
-    tests.main()
+            with pytest.warns(IrisLoadWarning, match=expected_msg):
+                _ = _build_cell_methods(av_or_int, coord_name)

lib/iris/tests/unit/fileformats/name_loaders/test__build_lat_lon_for_NAME_timeseries.py

@@ -3,43 +3,39 @@
 # This file is part of Iris and is released under the BSD license.
 # See LICENSE in the root of the repository for full licensing details.
 """Unit tests for :func:`iris.analysis.name_loaders._build_lat_lon_for_NAME_timeseries`."""
-
-# Import iris.tests first so that some things can be initialised before
-# importing anything else.
-import iris.tests as tests  # isort:skip
-
 from iris.fileformats.name_loaders import NAMECoord, _build_lat_lon_for_NAME_timeseries
+from iris.tests._shared_utils import assert_array_equal
 
 
-class TestCellMethods(tests.IrisTest):
+class TestCellMethods:
     def test_float(self):
         column_headings = {
             "X": ["X = -.100 Lat-Long", "X = -1.600 Lat-Long"],
             "Y": ["Y = 52.450 Lat-Long", "Y = 51. Lat-Long"],
         }
         lat, lon = _build_lat_lon_for_NAME_timeseries(column_headings)
-        self.assertIsInstance(lat, NAMECoord)
-        self.assertIsInstance(lon, NAMECoord)
-        self.assertEqual(lat.name, "latitude")
-        self.assertEqual(lon.name, "longitude")
-        self.assertIsNone(lat.dimension)
-        self.assertIsNone(lon.dimension)
-        self.assertArrayEqual(lat.values, [52.45, 51.0])
-        self.assertArrayEqual(lon.values, [-0.1, -1.6])
+        assert isinstance(lat, NAMECoord)
+        assert isinstance(lon, NAMECoord)
+        assert lat.name == "latitude"
+        assert lon.name == "longitude"
+        assert lat.dimension is None
+        assert lon.dimension is None
+        assert_array_equal(lat.values, [52.45, 51.0])
+        assert_array_equal(lon.values, [-0.1, -1.6])
 
     def test_int(self):
         column_headings = {
             "X": ["X = -1 Lat-Long", "X = -2 Lat-Long"],
             "Y": ["Y = 52 Lat-Long", "Y = 51 Lat-Long"],
         }
         lat, lon = _build_lat_lon_for_NAME_timeseries(column_headings)
-        self.assertIsInstance(lat, NAMECoord)
-        self.assertIsInstance(lon, NAMECoord)
-        self.assertEqual(lat.name, "latitude")
-        self.assertEqual(lon.name, "longitude")
-        self.assertIsNone(lat.dimension)
-        self.assertIsNone(lon.dimension)
-        self.assertArrayEqual(lat.values, [52.0, 51.0])
-        self.assertArrayEqual(lon.values, [-1.0, -2.0])
-        self.assertIsInstance(lat.values[0], float)
-        self.assertIsInstance(lon.values[0], float)
+        assert isinstance(lat, NAMECoord)
+        assert isinstance(lon, NAMECoord)
+        assert lat.name == "latitude"
+        assert lon.name == "longitude"
+        assert lat.dimension is None
+        assert lon.dimension is None
+        assert_array_equal(lat.values, [52.0, 51.0])
+        assert_array_equal(lon.values, [-1.0, -2.0])
+        assert isinstance(lat.values[0], float)
+        assert isinstance(lon.values[0], float)

lib/iris/tests/unit/fileformats/name_loaders/test__calc_integration_period.py

@@ -3,59 +3,50 @@
 # This file is part of Iris and is released under the BSD license.
 # See LICENSE in the root of the repository for full licensing details.
 """Unit tests for :func:`iris.fileformats.name_loaders.__calc_integration_period`."""
-
-# Import iris.tests first so that some things can be initialised before
-# importing anything else.
-import iris.tests as tests  # isort:skip
-
 import datetime
 
 from iris.fileformats.name_loaders import _calc_integration_period
 
 
-class Test(tests.IrisTest):
+class Test:
     def test_30_min_av(self):
         time_avgs = ["             30min average"]
         result = _calc_integration_period(time_avgs)
         expected = [datetime.timedelta(0, (30 * 60))]
-        self.assertEqual(result, expected)
+        assert result == expected
 
     def test_30_min_av_rspace(self):
         time_avgs = ["             30min average  "]
         result = _calc_integration_period(time_avgs)
         expected = [datetime.timedelta(0, (30 * 60))]
-        self.assertEqual(result, expected)
+        assert result == expected
 
     def test_30_min_av_lstrip(self):
         time_avgs = ["             30min average".lstrip()]
         result = _calc_integration_period(time_avgs)
         expected = [datetime.timedelta(0, (30 * 60))]
-        self.assertEqual(result, expected)
+        assert result == expected
 
     def test_3_hour_av(self):
         time_avgs = ["          3hr 0min average"]
         result = _calc_integration_period(time_avgs)
         expected = [datetime.timedelta(0, (3 * 60 * 60))]
-        self.assertEqual(result, expected)
+        assert result == expected
 
     def test_3_hour_int(self):
         time_avgs = ["         3hr 0min integral"]
         result = _calc_integration_period(time_avgs)
         expected = [datetime.timedelta(0, (3 * 60 * 60))]
-        self.assertEqual(result, expected)
+        assert result == expected
 
     def test_12_hour_av(self):
         time_avgs = ["         12hr 0min average"]
         result = _calc_integration_period(time_avgs)
         expected = [datetime.timedelta(0, (12 * 60 * 60))]
-        self.assertEqual(result, expected)
+        assert result == expected
 
     def test_5_day_av(self):
         time_avgs = ["    5day 0hr 0min integral"]
         result = _calc_integration_period(time_avgs)
         expected = [datetime.timedelta(0, (5 * 24 * 60 * 60))]
-        self.assertEqual(result, expected)
-
-
-if __name__ == "__main__":
-    tests.main()
+        assert result == expected