self_assert from unittest2pytest

Author: max-sixty

xarray/tests/test_accessors.py

@@ -75,10 +75,10 @@ def test_dask_field_access(self):
 
         # Double check that outcome chunksize is unchanged
         dask_chunks = dask_times_2d.chunks
-        self.assertEqual(dask_year.data.chunks, dask_chunks)
-        self.assertEqual(dask_month.data.chunks, dask_chunks)
-        self.assertEqual(dask_day.data.chunks, dask_chunks)
-        self.assertEqual(dask_hour.data.chunks, dask_chunks)
+        assert dask_year.data.chunks == dask_chunks
+        assert dask_month.data.chunks == dask_chunks
+        assert dask_day.data.chunks == dask_chunks
+        assert dask_hour.data.chunks == dask_chunks
 
         # Check the actual output from the accessors
         self.assertDataArrayEqual(years, dask_year.compute())

xarray/tests/test_backends.py

@@ -9,6 +9,7 @@
 
 from xarray import Variable, coding
 from . import TestCase, requires_netCDF4
+import pytest
 
 
 @np.vectorize
@@ -99,7 +100,7 @@ def test_decode_cf_datetime_overflow(self):
 
         for i, day in enumerate(days):
             result = coding.times.decode_cf_datetime(day, units)
-            self.assertEqual(result, expected[i])
+            assert result == expected[i]
 
     def test_decode_cf_datetime_non_standard_units(self):
         expected = pd.date_range(periods=100, start='1970-01-01', freq='h')
@@ -137,12 +138,12 @@ def test_decode_non_standard_calendar(self):
                 warnings.filterwarnings('ignore', 'Unable to decode time axis')
                 actual = coding.times.decode_cf_datetime(noleap_time, units,
                                                          calendar=calendar)
-            self.assertEqual(actual.dtype, np.dtype('M8[ns]'))
+            assert actual.dtype == np.dtype('M8[ns]')
             abs_diff = abs(actual - expected)
             # once we no longer support versions of netCDF4 older than 1.1.5,
             # we could do this check with near microsecond accuracy:
             # https://github.com/Unidata/netcdf4-python/issues/355
-            self.assertTrue((abs_diff <= np.timedelta64(1, 's')).all())
+            assert (abs_diff <= np.timedelta64(1, 's')).all()
 
     @requires_netCDF4
     def test_decode_non_standard_calendar_single_element(self):
@@ -155,7 +156,7 @@ def test_decode_non_standard_calendar_single_element(self):
                                             'Unable to decode time axis')
                     actual = coding.times.decode_cf_datetime(num_time, units,
                                                              calendar=calendar)
-                self.assertEqual(actual.dtype, np.dtype('M8[ns]'))
+                assert actual.dtype == np.dtype('M8[ns]')
 
     @requires_netCDF4
     def test_decode_non_standard_calendar_single_element_fallback(self):
@@ -165,13 +166,13 @@ def test_decode_non_standard_calendar_single_element_fallback(self):
         dt = nc4.netcdftime.datetime(2001, 2, 29)
         for calendar in ['360_day', 'all_leap', '366_day']:
             num_time = nc4.date2num(dt, units, calendar)
-            with self.assertWarns('Unable to decode time axis'):
+            with pytest.warns('Unable to decode time axis'):
                 actual = coding.times.decode_cf_datetime(num_time, units,
                                                          calendar=calendar)
             expected = np.asarray(nc4.num2date(num_time, units, calendar))
             print(num_time, calendar, actual, expected)
-            self.assertEqual(actual.dtype, np.dtype('O'))
-            self.assertEqual(expected, actual)
+            assert actual.dtype == np.dtype('O')
+            assert expected == actual
 
     @requires_netCDF4
     def test_decode_non_standard_calendar_multidim_time(self):
@@ -195,7 +196,7 @@ def test_decode_non_standard_calendar_multidim_time(self):
             warnings.filterwarnings('ignore', 'Unable to decode time axis')
             actual = coding.times.decode_cf_datetime(mdim_time, units,
                                                      calendar=calendar)
-        self.assertEqual(actual.dtype, np.dtype('M8[ns]'))
+        assert actual.dtype == np.dtype('M8[ns]')
         self.assertArrayEqual(actual[:, 0], expected1)
         self.assertArrayEqual(actual[:, 1], expected2)
 
@@ -214,11 +215,11 @@ def test_decode_non_standard_calendar_fallback(self):
                     warnings.simplefilter('always')
                     actual = coding.times.decode_cf_datetime(num_times, units,
                                                              calendar=calendar)
-                    self.assertEqual(len(w), 1)
-                    self.assertIn('Unable to decode time axis',
-                                  str(w[0].message))
+                    assert len(w) == 1
+                    assert 'Unable to decode time axis' in \
+                                  str(w[0].message)
 
-                self.assertEqual(actual.dtype, np.dtype('O'))
+                assert actual.dtype == np.dtype('O')
                 self.assertArrayEqual(actual, expected)
 
     @requires_netCDF4
@@ -266,8 +267,7 @@ def test_infer_datetime_units(self):
                                 (pd.to_datetime(['NaT']),
                                  'days since 1970-01-01 00:00:00'),
                                 ]:
-            self.assertEqual(
-                expected, coding.times.infer_datetime_units(dates))
+            assert expected == coding.times.infer_datetime_units(dates)
 
     def test_cf_timedelta(self):
         examples = [
@@ -289,13 +289,13 @@ def test_cf_timedelta(self):
             expected = numbers
             actual, _ = coding.times.encode_cf_timedelta(timedeltas, units)
             self.assertArrayEqual(expected, actual)
-            self.assertEqual(expected.dtype, actual.dtype)
+            assert expected.dtype == actual.dtype
 
             if units is not None:
                 expected = timedeltas
                 actual = coding.times.decode_cf_timedelta(numbers, units)
                 self.assertArrayEqual(expected, actual)
-                self.assertEqual(expected.dtype, actual.dtype)
+                assert expected.dtype == actual.dtype
 
         expected = np.timedelta64('NaT', 'ns')
         actual = coding.times.decode_cf_timedelta(np.array(np.nan), 'days')
@@ -311,13 +311,12 @@ def test_cf_timedelta_2d(self):
 
         actual = coding.times.decode_cf_timedelta(numbers, units)
         self.assertArrayEqual(expected, actual)
-        self.assertEqual(expected.dtype, actual.dtype)
+        assert expected.dtype == actual.dtype
 
     def test_infer_timedelta_units(self):
         for deltas, expected in [
                 (pd.to_timedelta(['1 day', '2 days']), 'days'),
                 (pd.to_timedelta(['1h', '1 day 1 hour']), 'hours'),
                 (pd.to_timedelta(['1m', '2m', np.nan]), 'minutes'),
                 (pd.to_timedelta(['1m3s', '1m4s']), 'seconds')]:
-            self.assertEqual(
-                expected, coding.times.infer_timedelta_units(deltas))
+            assert expected == coding.times.infer_timedelta_units(deltas)

xarray/tests/test_coding_times.py

@@ -290,8 +290,8 @@ def test_concat_lazy(self):
             dims=['x', 'y']) for _ in range(2)]
         # should not raise
         combined = concat(arrays, dim='z')
-        self.assertEqual(combined.shape, (2, 3, 3))
-        self.assertEqual(combined.dims, ('z', 'x', 'y'))
+        assert combined.shape == (2, 3, 3)
+        assert combined.dims == ('z', 'x', 'y')
 
 
 class TestAutoCombine(TestCase):

xarray/tests/test_combine.py

@@ -30,11 +30,11 @@ def test_wrapper_class(self):
         array = np.array([[b'a', b'b', b'c'], [b'd', b'e', b'f']], dtype='S')
         actual = conventions.StackedBytesArray(array)
         expected = np.array([b'abc', b'def'], dtype='S')
-        self.assertEqual(actual.dtype, expected.dtype)
-        self.assertEqual(actual.shape, expected.shape)
-        self.assertEqual(actual.size, expected.size)
-        self.assertEqual(actual.ndim, expected.ndim)
-        self.assertEqual(len(actual), len(expected))
+        assert actual.dtype == expected.dtype
+        assert actual.shape == expected.shape
+        assert actual.size == expected.size
+        assert actual.ndim == expected.ndim
+        assert len(actual) == len(expected)
         self.assertArrayEqual(expected, actual)
         self.assertArrayEqual(expected[:1], actual[B[:1]])
         with pytest.raises(IndexError):
@@ -106,10 +106,10 @@ def test_encoding(self):
         actual = conventions.BytesToStringArray(raw_array, encoding=encoding)
         expected = np.array([u'abc', u'ß∂µ∆'], dtype=object)
 
-        self.assertEqual(actual.dtype, expected.dtype)
-        self.assertEqual(actual.shape, expected.shape)
-        self.assertEqual(actual.size, expected.size)
-        self.assertEqual(actual.ndim, expected.ndim)
+        assert actual.dtype == expected.dtype
+        assert actual.shape == expected.shape
+        assert actual.size == expected.size
+        assert actual.ndim == expected.ndim
         self.assertArrayEqual(expected, actual)
         self.assertArrayEqual(expected[0], actual[B[0]])
 
@@ -140,7 +140,7 @@ class TestBoolTypeArray(TestCase):
     def test_booltype_array(self):
         x = np.array([1, 0, 1, 1, 0], dtype='i1')
         bx = conventions.BoolTypeArray(x)
-        self.assertEqual(bx.dtype, np.bool)
+        assert bx.dtype == np.bool
         self.assertArrayEqual(bx, np.array([True, False, True, True, False],
                                            dtype=np.bool))
 
@@ -197,7 +197,7 @@ def test_incompatible_attributes(self):
     def test_missing_fillvalue(self):
         v = Variable(['x'], np.array([np.nan, 1, 2, 3]))
         v.encoding = {'dtype': 'int16'}
-        with self.assertWarns('floating point data as an integer'):
+        with pytest.warns('floating point data as an integer'):
             conventions.encode_cf_variable(v)
 
     def test_multidimensional_coordinates(self):
@@ -261,7 +261,7 @@ def test_decode_coordinates(self):
         original = Dataset({'foo': ('t', [1, 2], {'coordinates': 'x'}),
                             'x': ('t', [4, 5])})
         actual = conventions.decode_cf(original)
-        self.assertEqual(actual.foo.encoding['coordinates'], 'x')
+        assert actual.foo.encoding['coordinates'] == 'x'
 
     def test_0d_int32_encoding(self):
         original = Variable((), np.int32(0), encoding={'dtype': 'int64'})
@@ -276,7 +276,7 @@ def test_decode_cf_with_multiple_missing_values(self):
         with warnings.catch_warnings(record=True) as w:
             actual = conventions.decode_cf_variable('t', original)
             self.assertDatasetIdentical(expected, actual)
-            self.assertIn('has multiple fill', str(w[0].message))
+            assert 'has multiple fill' in str(w[0].message)
 
     def test_decode_cf_with_drop_variables(self):
         original = Dataset({
@@ -307,11 +307,11 @@ def test_dataset_repr_with_netcdf4_datetimes(self):
         with warnings.catch_warnings():
             warnings.filterwarnings('ignore', 'unable to decode time')
             ds = decode_cf(Dataset({'time': ('time', [0, 1], attrs)}))
-            self.assertIn('(time) object', repr(ds))
+            assert '(time) object' in repr(ds)
 
         attrs = {'units': 'days since 1900-01-01'}
         ds = decode_cf(Dataset({'time': ('time', [0, 1], attrs)}))
-        self.assertIn('(time) datetime64[ns]', repr(ds))
+        assert '(time) datetime64[ns]' in repr(ds)
 
     @requires_netCDF4
     def test_decode_cf_datetime_transition_to_invalid(self):