STY: use pytest.raises context manager (indexes/period) (pandas-dev#25199)

Author: simonjayhawkins

pandas/tests/indexes/period/test_asfreq.py

@@ -67,7 +67,9 @@ def test_asfreq(self):
         assert pi7.asfreq('H', 'S') == pi5
         assert pi7.asfreq('Min', 'S') == pi6
 
-        pytest.raises(ValueError, pi7.asfreq, 'T', 'foo')
+        msg = "How must be one of S or E"
+        with pytest.raises(ValueError, match=msg):
+            pi7.asfreq('T', 'foo')
         result1 = pi1.asfreq('3M')
         result2 = pi1.asfreq('M')
         expected = period_range(freq='M', start='2001-12', end='2001-12')

pandas/tests/indexes/period/test_construction.py

@@ -1,6 +1,7 @@
 import numpy as np
 import pytest
 
+from pandas._libs.tslibs.period import IncompatibleFrequency
 from pandas.compat import PY3, lmap, lrange, text_type
 
 from pandas.core.dtypes.dtypes import PeriodDtype
@@ -66,12 +67,17 @@ def test_constructor_field_arrays(self):
 
         years = [2007, 2007, 2007]
         months = [1, 2]
-        pytest.raises(ValueError, PeriodIndex, year=years, month=months,
-                      freq='M')
-        pytest.raises(ValueError, PeriodIndex, year=years, month=months,
-                      freq='2M')
-        pytest.raises(ValueError, PeriodIndex, year=years, month=months,
-                      freq='M', start=Period('2007-01', freq='M'))
+
+        msg = "Mismatched Period array lengths"
+        with pytest.raises(ValueError, match=msg):
+            PeriodIndex(year=years, month=months, freq='M')
+        with pytest.raises(ValueError, match=msg):
+            PeriodIndex(year=years, month=months, freq='2M')
+
+        msg = "Can either instantiate from fields or endpoints, but not both"
+        with pytest.raises(ValueError, match=msg):
+            PeriodIndex(year=years, month=months, freq='M',
+                        start=Period('2007-01', freq='M'))
 
         years = [2007, 2007, 2007]
         months = [1, 2, 3]
@@ -81,8 +87,8 @@ def test_constructor_field_arrays(self):
 
     def test_constructor_U(self):
         # U was used as undefined period
-        pytest.raises(ValueError, period_range, '2007-1-1', periods=500,
-                      freq='X')
+        with pytest.raises(ValueError, match="Invalid frequency: X"):
+            period_range('2007-1-1', periods=500, freq='X')
 
     def test_constructor_nano(self):
         idx = period_range(start=Period(ordinal=1, freq='N'),
@@ -103,17 +109,29 @@ def test_constructor_arrays_negative_year(self):
         tm.assert_index_equal(pindex.quarter, pd.Index(quarters))
 
     def test_constructor_invalid_quarters(self):
-        pytest.raises(ValueError, PeriodIndex, year=lrange(2000, 2004),
-                      quarter=lrange(4), freq='Q-DEC')
+        msg = "Quarter must be 1 <= q <= 4"
+        with pytest.raises(ValueError, match=msg):
+            PeriodIndex(year=lrange(2000, 2004), quarter=lrange(4),
+                        freq='Q-DEC')
 
     def test_constructor_corner(self):
-        pytest.raises(ValueError, PeriodIndex, periods=10, freq='A')
+        msg = "Not enough parameters to construct Period range"
+        with pytest.raises(ValueError, match=msg):
+            PeriodIndex(periods=10, freq='A')
 
         start = Period('2007', freq='A-JUN')
         end = Period('2010', freq='A-DEC')
-        pytest.raises(ValueError, PeriodIndex, start=start, end=end)
-        pytest.raises(ValueError, PeriodIndex, start=start)
-        pytest.raises(ValueError, PeriodIndex, end=end)
+
+        msg = "start and end must have same freq"
+        with pytest.raises(ValueError, match=msg):
+            PeriodIndex(start=start, end=end)
+
+        msg = ("Of the three parameters: start, end, and periods, exactly two"
+               " must be specified")
+        with pytest.raises(ValueError, match=msg):
+            PeriodIndex(start=start)
+        with pytest.raises(ValueError, match=msg):
+            PeriodIndex(end=end)
 
         result = period_range('2007-01', periods=10.5, freq='M')
         exp = period_range('2007-01', periods=10, freq='M')
@@ -126,10 +144,15 @@ def test_constructor_fromarraylike(self):
         tm.assert_index_equal(PeriodIndex(idx.values), idx)
         tm.assert_index_equal(PeriodIndex(list(idx.values)), idx)
 
-        pytest.raises(ValueError, PeriodIndex, idx._ndarray_values)
-        pytest.raises(ValueError, PeriodIndex, list(idx._ndarray_values))
-        pytest.raises(TypeError, PeriodIndex,
-                      data=Period('2007', freq='A'))
+        msg = "freq not specified and cannot be inferred"
+        with pytest.raises(ValueError, match=msg):
+            PeriodIndex(idx._ndarray_values)
+        with pytest.raises(ValueError, match=msg):
+            PeriodIndex(list(idx._ndarray_values))
+
+        msg = "'Period' object is not iterable"
+        with pytest.raises(TypeError, match=msg):
+            PeriodIndex(data=Period('2007', freq='A'))
 
         result = PeriodIndex(iter(idx))
         tm.assert_index_equal(result, idx)
@@ -160,7 +183,9 @@ def test_constructor_datetime64arr(self):
         vals = np.arange(100000, 100000 + 10000, 100, dtype=np.int64)
         vals = vals.view(np.dtype('M8[us]'))
 
-        pytest.raises(ValueError, PeriodIndex, vals, freq='D')
+        msg = r"Wrong dtype: datetime64\[us\]"
+        with pytest.raises(ValueError, match=msg):
+            PeriodIndex(vals, freq='D')
 
     @pytest.mark.parametrize('box', [None, 'series', 'index'])
     def test_constructor_datetime64arr_ok(self, box):
@@ -300,17 +325,20 @@ def test_constructor_simple_new_empty(self):
 
     @pytest.mark.parametrize('floats', [[1.1, 2.1], np.array([1.1, 2.1])])
     def test_constructor_floats(self, floats):
-        with pytest.raises(TypeError):
+        msg = r"PeriodIndex\._simple_new does not accept floats"
+        with pytest.raises(TypeError, match=msg):
             pd.PeriodIndex._simple_new(floats, freq='M')
 
-        with pytest.raises(TypeError):
+        msg = "PeriodIndex does not allow floating point in construction"
+        with pytest.raises(TypeError, match=msg):
             pd.PeriodIndex(floats, freq='M')
 
     def test_constructor_nat(self):
-        pytest.raises(ValueError, period_range, start='NaT',
-                      end='2011-01-01', freq='M')
-        pytest.raises(ValueError, period_range, start='2011-01-01',
-                      end='NaT', freq='M')
+        msg = "start and end must not be NaT"
+        with pytest.raises(ValueError, match=msg):
+            period_range(start='NaT', end='2011-01-01', freq='M')
+        with pytest.raises(ValueError, match=msg):
+            period_range(start='2011-01-01', end='NaT', freq='M')
 
     def test_constructor_year_and_quarter(self):
         year = pd.Series([2001, 2002, 2003])
@@ -455,9 +483,12 @@ def test_constructor(self):
 
         # Mixed freq should fail
         vals = [end_intv, Period('2006-12-31', 'w')]
-        pytest.raises(ValueError, PeriodIndex, vals)
+        msg = r"Input has different freq=W-SUN from PeriodIndex\(freq=B\)"
+        with pytest.raises(IncompatibleFrequency, match=msg):
+            PeriodIndex(vals)
         vals = np.array(vals)
-        pytest.raises(ValueError, PeriodIndex, vals)
+        with pytest.raises(IncompatibleFrequency, match=msg):
+            PeriodIndex(vals)
 
     def test_constructor_error(self):
         start = Period('02-Apr-2005', 'B')
@@ -508,7 +539,8 @@ def setup_method(self, method):
         self.series = Series(period_range('2000-01-01', periods=10, freq='D'))
 
     def test_constructor_cant_cast_period(self):
-        with pytest.raises(TypeError):
+        msg = "Cannot cast PeriodArray to dtype float64"
+        with pytest.raises(TypeError, match=msg):
             Series(period_range('2000-01-01', periods=10, freq='D'),
                    dtype=float)
 

pandas/tests/indexes/period/test_indexing.py

@@ -84,7 +84,8 @@ def test_getitem_partial(self):
         rng = period_range('2007-01', periods=50, freq='M')
         ts = Series(np.random.randn(len(rng)), rng)
 
-        pytest.raises(KeyError, ts.__getitem__, '2006')
+        with pytest.raises(KeyError, match=r"^'2006'$"):
+            ts['2006']
 
         result = ts['2008']
         assert (result.index.year == 2008).all()
@@ -326,7 +327,8 @@ def test_take_fill_value(self):
         with pytest.raises(ValueError, match=msg):
             idx.take(np.array([1, 0, -5]), fill_value=True)
 
-        with pytest.raises(IndexError):
+        msg = "index -5 is out of bounds for size 3"
+        with pytest.raises(IndexError, match=msg):
             idx.take(np.array([1, -5]))
 
 
@@ -335,7 +337,8 @@ class TestIndexing(object):
     def test_get_loc_msg(self):
         idx = period_range('2000-1-1', freq='A', periods=10)
         bad_period = Period('2012', 'A')
-        pytest.raises(KeyError, idx.get_loc, bad_period)
+        with pytest.raises(KeyError, match=r"^Period\('2012', 'A-DEC'\)$"):
+            idx.get_loc(bad_period)
 
         try:
             idx.get_loc(bad_period)
@@ -373,8 +376,13 @@ def test_get_loc(self):
         msg = "Cannot interpret 'foo' as period"
         with pytest.raises(KeyError, match=msg):
             idx0.get_loc('foo')
-        pytest.raises(KeyError, idx0.get_loc, 1.1)
-        pytest.raises(TypeError, idx0.get_loc, idx0)
+        with pytest.raises(KeyError, match=r"^1\.1$"):
+            idx0.get_loc(1.1)
+
+        msg = (r"'PeriodIndex\(\['2017-09-01', '2017-09-02', '2017-09-03'\],"
+               r" dtype='period\[D\]', freq='D'\)' is an invalid key")
+        with pytest.raises(TypeError, match=msg):
+            idx0.get_loc(idx0)
 
         # get the location of p1/p2 from
         # monotonic increasing PeriodIndex with duplicate
@@ -391,8 +399,13 @@ def test_get_loc(self):
         with pytest.raises(KeyError, match=msg):
             idx1.get_loc('foo')
 
-        pytest.raises(KeyError, idx1.get_loc, 1.1)
-        pytest.raises(TypeError, idx1.get_loc, idx1)
+        with pytest.raises(KeyError, match=r"^1\.1$"):
+            idx1.get_loc(1.1)
+
+        msg = (r"'PeriodIndex\(\['2017-09-02', '2017-09-02', '2017-09-03'\],"
+               r" dtype='period\[D\]', freq='D'\)' is an invalid key")
+        with pytest.raises(TypeError, match=msg):
+            idx1.get_loc(idx1)
 
         # get the location of p1/p2 from
         # non-monotonic increasing/decreasing PeriodIndex with duplicate
@@ -569,7 +582,7 @@ def test_get_loc2(self):
         msg = 'Input has different freq=None from PeriodArray\\(freq=D\\)'
         with pytest.raises(ValueError, match=msg):
             idx.get_loc('2000-01-10', method='nearest', tolerance='1 hour')
-        with pytest.raises(KeyError):
+        with pytest.raises(KeyError, match=r"^Period\('2000-01-10', 'D'\)$"):
             idx.get_loc('2000-01-10', method='nearest', tolerance='1 day')
         with pytest.raises(
                 ValueError,

pandas/tests/indexes/period/test_period.py

@@ -71,10 +71,12 @@ def test_fillna_period(self):
             pd.Period('2011-01-01', freq='D')), exp)
 
     def test_no_millisecond_field(self):
-        with pytest.raises(AttributeError):
+        msg = "type object 'DatetimeIndex' has no attribute 'millisecond'"
+        with pytest.raises(AttributeError, match=msg):
             DatetimeIndex.millisecond
 
-        with pytest.raises(AttributeError):
+        msg = "'DatetimeIndex' object has no attribute 'millisecond'"
+        with pytest.raises(AttributeError, match=msg):
             DatetimeIndex([]).millisecond
 
     @pytest.mark.parametrize("sort", [None, False])
@@ -98,8 +100,8 @@ def test_difference_freq(self, sort):
 
     def test_hash_error(self):
         index = period_range('20010101', periods=10)
-        with pytest.raises(TypeError, match=("unhashable type: %r" %
-                                             type(index).__name__)):
+        msg = "unhashable type: '{}'".format(type(index).__name__)
+        with pytest.raises(TypeError, match=msg):
             hash(index)
 
     def test_make_time_series(self):
@@ -124,7 +126,8 @@ def test_shallow_copy_i8(self):
 
     def test_shallow_copy_changing_freq_raises(self):
         pi = period_range("2018-01-01", periods=3, freq="2D")
-        with pytest.raises(IncompatibleFrequency, match="are different"):
+        msg = "specified freq and dtype are different"
+        with pytest.raises(IncompatibleFrequency, match=msg):
             pi._shallow_copy(pi, freq="H")
 
     def test_dtype_str(self):
@@ -214,21 +217,17 @@ def test_period_index_length(self):
         assert (i1 == i2).all()
         assert i1.freq == i2.freq
 
-        try:
+        msg = "start and end must have same freq"
+        with pytest.raises(ValueError, match=msg):
             period_range(start=start, end=end_intv)
-            raise AssertionError('Cannot allow mixed freq for start and end')
-        except ValueError:
-            pass
 
         end_intv = Period('2005-05-01', 'B')
         i1 = period_range(start=start, end=end_intv)
 
-        try:
+        msg = ("Of the three parameters: start, end, and periods, exactly two"
+               " must be specified")
+        with pytest.raises(ValueError, match=msg):
             period_range(start=start)
-            raise AssertionError(
-                'Must specify periods if missing start or end')
-        except ValueError:
-            pass
 
         # infer freq from first element
         i2 = PeriodIndex([end_intv, Period('2005-05-05', 'B')])
@@ -241,9 +240,12 @@ def test_period_index_length(self):
 
         # Mixed freq should fail
         vals = [end_intv, Period('2006-12-31', 'w')]
-        pytest.raises(ValueError, PeriodIndex, vals)
+        msg = r"Input has different freq=W-SUN from PeriodIndex\(freq=B\)"
+        with pytest.raises(IncompatibleFrequency, match=msg):
+            PeriodIndex(vals)
         vals = np.array(vals)
-        pytest.raises(ValueError, PeriodIndex, vals)
+        with pytest.raises(ValueError, match=msg):
+            PeriodIndex(vals)
 
     def test_fields(self):
         # year, month, day, hour, minute
@@ -381,7 +383,9 @@ def test_contains_nat(self):
         assert np.nan in idx
 
     def test_periods_number_check(self):
-        with pytest.raises(ValueError):
+        msg = ("Of the three parameters: start, end, and periods, exactly two"
+               " must be specified")
+        with pytest.raises(ValueError, match=msg):
             period_range('2011-1-1', '2012-1-1', 'B')
 
     def test_start_time(self):
@@ -500,7 +504,8 @@ def test_is_full(self):
         assert index.is_full
 
         index = PeriodIndex([2006, 2005, 2005], freq='A')
-        pytest.raises(ValueError, getattr, index, 'is_full')
+        with pytest.raises(ValueError, match="Index is not monotonic"):
+            index.is_full
 
         assert index[:0].is_full
 
@@ -574,5 +579,6 @@ def test_maybe_convert_timedelta():
     assert pi._maybe_convert_timedelta(2) == 2
 
     offset = offsets.BusinessDay()
-    with pytest.raises(ValueError, match='freq'):
+    msg = r"Input has different freq=B from PeriodIndex\(freq=D\)"
+    with pytest.raises(ValueError, match=msg):
         pi._maybe_convert_timedelta(offset)