STY: use pytest.raises context manager (frame) (#25516)

pandas/tests/frame/test_alter_axes.py

@@ -633,7 +633,8 @@ def test_rename(self, float_frame):
         tm.assert_index_equal(renamed.index, Index(['BAR', 'FOO']))
 
         # have to pass something
-        pytest.raises(TypeError, float_frame.rename)
+        with pytest.raises(TypeError, match="must pass an index to rename"):
+            float_frame.rename()
 
         # partial columns
         renamed = float_frame.rename(columns={'C': 'foo', 'D': 'bar'})

pandas/tests/frame/test_analytics.py

@@ -898,6 +898,7 @@ def test_var_std(self, datetime_frame):
             result = nanops.nanvar(arr, axis=0)
             assert not (result < 0).any()
 
+    @pytest.mark.skipif(PY2, reason="pytest.raises match regex fails")
     @pytest.mark.parametrize(
         "meth", ['sem', 'var', 'std'])
     def test_numeric_only_flag(self, meth):
@@ -919,10 +920,12 @@ def test_numeric_only_flag(self, meth):
         tm.assert_series_equal(expected, result)
 
         # df1 has all numbers, df2 has a letter inside
-        pytest.raises(TypeError, lambda: getattr(df1, meth)(
-            axis=1, numeric_only=False))
-        pytest.raises(TypeError, lambda: getattr(df2, meth)(
-            axis=1, numeric_only=False))
+        msg = r"unsupported operand type\(s\) for -: 'float' and 'str'"
+        with pytest.raises(TypeError, match=msg):
+            getattr(df1, meth)(axis=1, numeric_only=False)
+        msg = "could not convert string to float: 'a'"
+        with pytest.raises(TypeError, match=msg):
+            getattr(df2, meth)(axis=1, numeric_only=False)
 
     def test_sem(self, datetime_frame):
         result = datetime_frame.sem(ddof=4)
@@ -1369,6 +1372,7 @@ def test_pct_change(self):
     # ----------------------------------------------------------------------
     # Index of max / min
 
+    @pytest.mark.skipif(PY2, reason="pytest.raises match regex fails")
     def test_idxmin(self, float_frame, int_frame):
         frame = float_frame
         frame.loc[5:10] = np.nan
@@ -1381,8 +1385,11 @@ def test_idxmin(self, float_frame, int_frame):
                                         skipna=skipna)
                     tm.assert_series_equal(result, expected)
 
-        pytest.raises(ValueError, frame.idxmin, axis=2)
+        msg = "No axis named 2 for object type <class 'type'>"
+        with pytest.raises(ValueError, match=msg):
+            frame.idxmin(axis=2)
 
+    @pytest.mark.skipif(PY2, reason="pytest.raises match regex fails")
     def test_idxmax(self, float_frame, int_frame):
         frame = float_frame
         frame.loc[5:10] = np.nan
@@ -1395,7 +1402,9 @@ def test_idxmax(self, float_frame, int_frame):
                                         skipna=skipna)
                     tm.assert_series_equal(result, expected)
 
-        pytest.raises(ValueError, frame.idxmax, axis=2)
+        msg = "No axis named 2 for object type <class 'type'>"
+        with pytest.raises(ValueError, match=msg):
+            frame.idxmax(axis=2)
 
     # ----------------------------------------------------------------------
     # Logical reductions
@@ -1881,7 +1890,9 @@ def test_round_issue(self):
         tm.assert_index_equal(rounded.index, dfs.index)
 
         decimals = pd.Series([1, 0, 2], index=['A', 'B', 'A'])
-        pytest.raises(ValueError, df.round, decimals)
+        msg = "Index of decimals must be unique"
+        with pytest.raises(ValueError, match=msg):
+            df.round(decimals)
 
     def test_built_in_round(self):
         if not compat.PY3:

pandas/tests/frame/test_api.py

@@ -9,7 +9,7 @@
 import numpy as np
 import pytest
 
-from pandas.compat import long, lrange, range
+from pandas.compat import PY2, long, lrange, range
 
 import pandas as pd
 from pandas import (
@@ -146,8 +146,12 @@ def test_not_hashable(self):
         empty_frame = DataFrame()
 
         df = self.klass([1])
-        pytest.raises(TypeError, hash, df)
-        pytest.raises(TypeError, hash, empty_frame)
+        msg = ("'(Sparse)?DataFrame' objects are mutable, thus they cannot be"
+               " hashed")
+        with pytest.raises(TypeError, match=msg):
+            hash(df)
+        with pytest.raises(TypeError, match=msg):
+            hash(empty_frame)
 
     def test_new_empty_index(self):
         df1 = self.klass(np.random.randn(0, 3))
@@ -171,7 +175,9 @@ def test_get_agg_axis(self, float_frame):
         idx = float_frame._get_agg_axis(1)
         assert idx is float_frame.index
 
-        pytest.raises(ValueError, float_frame._get_agg_axis, 2)
+        msg = r"Axis must be 0 or 1 \(got 2\)"
+        with pytest.raises(ValueError, match=msg):
+            float_frame._get_agg_axis(2)
 
     def test_nonzero(self, float_frame, float_string_frame):
         empty_frame = DataFrame()
@@ -354,12 +360,15 @@ def test_transpose(self, float_frame):
         for col, s in compat.iteritems(mixed_T):
             assert s.dtype == np.object_
 
+    @pytest.mark.skipif(PY2, reason="pytest.raises match regex fails")
     def test_swapaxes(self):
         df = self.klass(np.random.randn(10, 5))
         self._assert_frame_equal(df.T, df.swapaxes(0, 1))
         self._assert_frame_equal(df.T, df.swapaxes(1, 0))
         self._assert_frame_equal(df, df.swapaxes(0, 0))
-        pytest.raises(ValueError, df.swapaxes, 2, 5)
+        msg = "No axis named 2 for object type <class 'type'>"
+        with pytest.raises(ValueError, match=msg):
+            df.swapaxes(2, 5)
 
     def test_axis_aliases(self, float_frame):
         f = float_frame

pandas/tests/frame/test_axis_select_reindex.py

@@ -7,7 +7,7 @@
 import numpy as np
 import pytest
 
-from pandas.compat import lrange, lzip, u
+from pandas.compat import PY2, lrange, lzip, u
 from pandas.errors import PerformanceWarning
 
 import pandas as pd
@@ -38,8 +38,11 @@ def test_drop_names(self):
             assert obj.columns.name == 'second'
         assert list(df.columns) == ['d', 'e', 'f']
 
-        pytest.raises(KeyError, df.drop, ['g'])
-        pytest.raises(KeyError, df.drop, ['g'], 1)
+        msg = r"\['g'\] not found in axis"
+        with pytest.raises(KeyError, match=msg):
+            df.drop(['g'])
+        with pytest.raises(KeyError, match=msg):
+            df.drop(['g'], 1)
 
         # errors = 'ignore'
         dropped = df.drop(['g'], errors='ignore')
@@ -84,10 +87,14 @@ def test_drop(self):
         assert_frame_equal(simple.drop(
             [0, 3], axis='index'), simple.loc[[1, 2], :])
 
-        pytest.raises(KeyError, simple.drop, 5)
-        pytest.raises(KeyError, simple.drop, 'C', 1)
-        pytest.raises(KeyError, simple.drop, [1, 5])
-        pytest.raises(KeyError, simple.drop, ['A', 'C'], 1)
+        with pytest.raises(KeyError, match=r"\[5\] not found in axis"):
+            simple.drop(5)
+        with pytest.raises(KeyError, match=r"\['C'\] not found in axis"):
+            simple.drop('C', 1)
+        with pytest.raises(KeyError, match=r"\[5\] not found in axis"):
+            simple.drop([1, 5])
+        with pytest.raises(KeyError, match=r"\['C'\] not found in axis"):
+            simple.drop(['A', 'C'], 1)
 
         # errors = 'ignore'
         assert_frame_equal(simple.drop(5, errors='ignore'), simple)
@@ -444,7 +451,9 @@ def test_reindex_dups(self):
         assert_frame_equal(result, expected)
 
         # reindex fails
-        pytest.raises(ValueError, df.reindex, index=list(range(len(df))))
+        msg = "cannot reindex from a duplicate axis"
+        with pytest.raises(ValueError, match=msg):
+            df.reindex(index=list(range(len(df))))
 
     def test_reindex_axis_style(self):
         # https://github.com/pandas-dev/pandas/issues/12392
@@ -963,10 +972,15 @@ def test_take(self):
             assert_frame_equal(result, expected, check_names=False)
 
         # illegal indices
-        pytest.raises(IndexError, df.take, [3, 1, 2, 30], axis=0)
-        pytest.raises(IndexError, df.take, [3, 1, 2, -31], axis=0)
-        pytest.raises(IndexError, df.take, [3, 1, 2, 5], axis=1)
-        pytest.raises(IndexError, df.take, [3, 1, 2, -5], axis=1)
+        msg = "indices are out-of-bounds"
+        with pytest.raises(IndexError, match=msg):
+            df.take([3, 1, 2, 30], axis=0)
+        with pytest.raises(IndexError, match=msg):
+            df.take([3, 1, 2, -31], axis=0)
+        with pytest.raises(IndexError, match=msg):
+            df.take([3, 1, 2, 5], axis=1)
+        with pytest.raises(IndexError, match=msg):
+            df.take([3, 1, 2, -5], axis=1)
 
         # mixed-dtype
         order = [4, 1, 2, 0, 3]
@@ -1037,6 +1051,7 @@ def test_reindex_corner(self):
         smaller = self.intframe.reindex(columns=['A', 'B', 'E'])
         assert smaller['E'].dtype == np.float64
 
+    @pytest.mark.skipif(PY2, reason="pytest.raises match regex fails")
     def test_reindex_axis(self):
         cols = ['A', 'B', 'E']
         with tm.assert_produces_warning(FutureWarning) as m:
@@ -1052,7 +1067,9 @@ def test_reindex_axis(self):
         reindexed2 = self.intframe.reindex(index=rows)
         assert_frame_equal(reindexed1, reindexed2)
 
-        pytest.raises(ValueError, self.intframe.reindex_axis, rows, axis=2)
+        msg = "No axis named 2 for object type <class 'type'>"
+        with pytest.raises(ValueError, match=msg):
+            self.intframe.reindex_axis(rows, axis=2)
 
         # no-op case
         cols = self.frame.columns.copy()

pandas/tests/frame/test_block_internals.py

@@ -274,10 +274,12 @@ def f(dtype):
                              columns=["A", "B", "C"],
                              dtype=dtype)
 
-        pytest.raises(NotImplementedError, f,
-                      [("A", "datetime64[h]"),
-                       ("B", "str"),
-                       ("C", "int32")])
+        msg = ("compound dtypes are not implemented in the DataFrame"
+               " constructor")
+        with pytest.raises(NotImplementedError, match=msg):
+            f([("A", "datetime64[h]"),
+               ("B", "str"),
+               ("C", "int32")])
 
         # these work (though results may be unexpected)
         f('int64')

pandas/tests/frame/test_constructors.py

@@ -12,7 +12,8 @@
 import pytest
 
 from pandas.compat import (
-    PY3, PY36, is_platform_little_endian, lmap, long, lrange, lzip, range, zip)
+    PY2, PY3, PY36, is_platform_little_endian, lmap, long, lrange, lzip, range,
+    zip)
 
 from pandas.core.dtypes.cast import construct_1d_object_array_from_listlike
 from pandas.core.dtypes.common import is_integer_dtype
@@ -58,8 +59,9 @@ def test_constructor_cast_failure(self):
         df['foo'] = np.ones((4, 2)).tolist()
 
         # this is not ok
-        pytest.raises(ValueError, df.__setitem__, tuple(['test']),
-                      np.ones((4, 2)))
+        msg = "Wrong number of items passed 2, placement implies 1"
+        with pytest.raises(ValueError, match=msg):
+            df['test'] = np.ones((4, 2))
 
         # this is ok
         df['foo2'] = np.ones((4, 2)).tolist()
@@ -1259,7 +1261,9 @@ def test_constructor_Series_named(self):
         expected = DataFrame({0: s})
         tm.assert_frame_equal(df, expected)
 
-        pytest.raises(ValueError, DataFrame, s, columns=[1, 2])
+        msg = r"Shape of passed values is \(10, 1\), indices imply \(10, 2\)"
+        with pytest.raises(ValueError, match=msg):
+            DataFrame(s, columns=[1, 2])
 
         # #2234
         a = Series([], name='x')
@@ -1433,8 +1437,10 @@ def test_constructor_column_duplicates(self):
 
         tm.assert_frame_equal(idf, edf)
 
-        pytest.raises(ValueError, DataFrame.from_dict,
-                      OrderedDict([('b', 8), ('a', 5), ('a', 6)]))
+        msg = "If using all scalar values, you must pass an index"
+        with pytest.raises(ValueError, match=msg):
+            DataFrame.from_dict(
+                OrderedDict([('b', 8), ('a', 5), ('a', 6)]))
 
     def test_constructor_empty_with_string_dtype(self):
         # GH 9428
@@ -1465,8 +1471,11 @@ def test_constructor_single_value(self):
                                                      dtype=object),
                                             index=[1, 2], columns=['a', 'c']))
 
-        pytest.raises(ValueError, DataFrame, 'a', [1, 2])
-        pytest.raises(ValueError, DataFrame, 'a', columns=['a', 'c'])
+        msg = "DataFrame constructor not properly called!"
+        with pytest.raises(ValueError, match=msg):
+            DataFrame('a', [1, 2])
+        with pytest.raises(ValueError, match=msg):
+            DataFrame('a', columns=['a', 'c'])
 
         msg = 'incompatible data and dtype'
         with pytest.raises(TypeError, match=msg):
@@ -1692,6 +1701,7 @@ def test_constructor_series_copy(self):
 
         assert not (series['A'] == 5).all()
 
+    @pytest.mark.skipif(PY2, reason="pytest.raises match regex fails")
     def test_constructor_with_nas(self):
         # GH 5016
         # na's in indices
@@ -1704,9 +1714,11 @@ def check(df):
 
             # No NaN found -> error
             if len(indexer) == 0:
-                def f():
+                msg = ("cannot do label indexing on"
+                       r" <class 'pandas\.core\.indexes\.range\.RangeIndex'>"
+                       r" with these indexers \[nan\] of <class 'float'>")
+                with pytest.raises(TypeError, match=msg):
                     df.loc[:, np.nan]
-                pytest.raises(TypeError, f)
             # single nan should result in Series
             elif len(indexer) == 1:
                 tm.assert_series_equal(df.iloc[:, indexer[0]],
@@ -1782,13 +1794,15 @@ def test_constructor_categorical(self):
         tm.assert_frame_equal(df, expected)
 
         # invalid (shape)
-        pytest.raises(ValueError,
-                      lambda: DataFrame([Categorical(list('abc')),
-                                         Categorical(list('abdefg'))]))
+        msg = r"Shape of passed values is \(6, 2\), indices imply \(3, 2\)"
+        with pytest.raises(ValueError, match=msg):
+            DataFrame([Categorical(list('abc')),
+                       Categorical(list('abdefg'))])
 
         # ndim > 1
-        pytest.raises(NotImplementedError,
-                      lambda: Categorical(np.array([list('abcd')])))
+        msg = "> 1 ndim Categorical are not supported at this time"
+        with pytest.raises(NotImplementedError, match=msg):
+            Categorical(np.array([list('abcd')]))
 
     def test_constructor_categorical_series(self):
 
@@ -2164,8 +2178,11 @@ def test_from_records_bad_index_column(self):
         tm.assert_index_equal(df1.index, Index(df.C))
 
         # should fail
-        pytest.raises(ValueError, DataFrame.from_records, df, index=[2])
-        pytest.raises(KeyError, DataFrame.from_records, df, index=2)
+        msg = r"Shape of passed values is \(10, 3\), indices imply \(1, 3\)"
+        with pytest.raises(ValueError, match=msg):
+            DataFrame.from_records(df, index=[2])
+        with pytest.raises(KeyError, match=r"^2$"):
+            DataFrame.from_records(df, index=2)
 
     def test_from_records_non_tuple(self):
         class Record(object):

pandas/tests/frame/test_convert_to.py

@@ -75,11 +75,15 @@ def test_to_dict_index_not_unique_with_index_orient(self):
         # GH22801
         # Data loss when indexes are not unique. Raise ValueError.
         df = DataFrame({'a': [1, 2], 'b': [0.5, 0.75]}, index=['A', 'A'])
-        pytest.raises(ValueError, df.to_dict, orient='index')
+        msg = "DataFrame index must be unique for orient='index'"
+        with pytest.raises(ValueError, match=msg):
+            df.to_dict(orient='index')
 
     def test_to_dict_invalid_orient(self):
         df = DataFrame({'A': [0, 1]})
-        pytest.raises(ValueError, df.to_dict, orient='xinvalid')
+        msg = "orient 'xinvalid' not understood"
+        with pytest.raises(ValueError, match=msg):
+            df.to_dict(orient='xinvalid')
 
     def test_to_records_dt64(self):
         df = DataFrame([["one", "two", "three"],