STY: use pytest.raises context manager (indexes)

pandas/tests/indexes/interval/test_interval.py

@@ -403,13 +403,16 @@ def test_get_item(self, closed):
 
     # To be removed, replaced by test_interval_new.py (see #16316, #16386)
     def test_get_loc_value(self):
-        pytest.raises(KeyError, self.index.get_loc, 0)
+        with pytest.raises(KeyError, match="^0$"):
+            self.index.get_loc(0)
         assert self.index.get_loc(0.5) == 0
         assert self.index.get_loc(1) == 0
         assert self.index.get_loc(1.5) == 1
         assert self.index.get_loc(2) == 1
-        pytest.raises(KeyError, self.index.get_loc, -1)
-        pytest.raises(KeyError, self.index.get_loc, 3)
+        with pytest.raises(KeyError, match="^-1$"):
+            self.index.get_loc(-1)
+        with pytest.raises(KeyError, match="^3$"):
+            self.index.get_loc(3)
 
         idx = IntervalIndex.from_tuples([(0, 2), (1, 3)])
         assert idx.get_loc(0.5) == 0
@@ -419,10 +422,12 @@ def test_get_loc_value(self):
         tm.assert_numpy_array_equal(np.sort(idx.get_loc(2)),
                                     np.array([0, 1], dtype='intp'))
         assert idx.get_loc(3) == 1
-        pytest.raises(KeyError, idx.get_loc, 3.5)
+        with pytest.raises(KeyError, match=r"^3\.5$"):
+            idx.get_loc(3.5)
 
         idx = IntervalIndex.from_arrays([0, 2], [1, 3])
-        pytest.raises(KeyError, idx.get_loc, 1.5)
+        with pytest.raises(KeyError, match=r"^1\.5$"):
+            idx.get_loc(1.5)
 
     # To be removed, replaced by test_interval_new.py (see #16316, #16386)
     def slice_locs_cases(self, breaks):
@@ -486,17 +491,22 @@ def test_slice_locs_decreasing_float64(self):
     # To be removed, replaced by test_interval_new.py (see #16316, #16386)
     def test_slice_locs_fails(self):
         index = IntervalIndex.from_tuples([(1, 2), (0, 1), (2, 3)])
-        with pytest.raises(KeyError):
+        msg = ("'can only get slices from an IntervalIndex if bounds are"
+               " non-overlapping and all monotonic increasing or decreasing'")
+        with pytest.raises(KeyError, match=msg):
             index.slice_locs(1, 2)
 
     # To be removed, replaced by test_interval_new.py (see #16316, #16386)
     def test_get_loc_interval(self):
         assert self.index.get_loc(Interval(0, 1)) == 0
         assert self.index.get_loc(Interval(0, 0.5)) == 0
         assert self.index.get_loc(Interval(0, 1, 'left')) == 0
-        pytest.raises(KeyError, self.index.get_loc, Interval(2, 3))
-        pytest.raises(KeyError, self.index.get_loc,
-                      Interval(-1, 0, 'left'))
+        msg = r"Interval\(2, 3, closed='right'\)"
+        with pytest.raises(KeyError, match=msg):
+            self.index.get_loc(Interval(2, 3))
+        msg = r"Interval\(-1, 0, closed='left'\)"
+        with pytest.raises(KeyError, match=msg):
+            self.index.get_loc(Interval(-1, 0, 'left'))
 
     # Make consistent with test_interval_new.py (see #16316, #16386)
     @pytest.mark.parametrize('item', [3, Interval(1, 4)])
@@ -981,9 +991,11 @@ def test_comparison(self):
             self.index > 0
         with pytest.raises(TypeError, match='unorderable types'):
             self.index <= 0
-        with pytest.raises(TypeError):
+        msg = r"unorderable types: Interval\(\) > int\(\)"
+        with pytest.raises(TypeError, match=msg):
             self.index > np.arange(2)
-        with pytest.raises(ValueError):
+        msg = "Lengths must match to compare"
+        with pytest.raises(ValueError, match=msg):
             self.index > np.arange(3)
 
     def test_missing_values(self, closed):
@@ -993,7 +1005,9 @@ def test_missing_values(self, closed):
             [np.nan, 0, 1], [np.nan, 1, 2], closed=closed)
         assert idx.equals(idx2)
 
-        with pytest.raises(ValueError):
+        msg = ("missing values must be missing in the same location both left"
+               " and right sides")
+        with pytest.raises(ValueError, match=msg):
             IntervalIndex.from_arrays(
                 [np.nan, 0, 1], np.array([0, 1, 2]), closed=closed)
 

pandas/tests/indexes/test_base.py

@@ -4,14 +4,15 @@
 from datetime import datetime, timedelta
 import math
 import operator
+import re
 import sys
 
 import numpy as np
 import pytest
 
 from pandas._libs.tslib import Timestamp
 from pandas.compat import (
-    PY3, PY35, PY36, StringIO, lrange, lzip, range, text_type, u, zip)
+    PY2, PY3, PY35, PY36, StringIO, lrange, lzip, range, text_type, u, zip)
 from pandas.compat.numpy import np_datetime64_compat
 
 from pandas.core.dtypes.common import is_unsigned_integer_dtype
@@ -107,7 +108,10 @@ def test_constructor_copy(self):
 
     def test_constructor_corner(self):
         # corner case
-        pytest.raises(TypeError, Index, 0)
+        msg = (r"Index\(\.\.\.\) must be called with a collection of some"
+               " kind, 0 was passed")
+        with pytest.raises(TypeError, match=msg):
+            Index(0)
 
     @pytest.mark.parametrize("index_vals", [
         [('A', 1), 'B'], ['B', ('A', 1)]])
@@ -487,6 +491,7 @@ def test_constructor_cast(self):
         with pytest.raises(ValueError, match=msg):
             Index(["a", "b", "c"], dtype=float)
 
+    @pytest.mark.skipif(PY2, reason="pytest.raises match regex fails")
     def test_view_with_args(self):
 
         restricted = ['unicodeIndex', 'strIndex', 'catIndex', 'boolIndex',
@@ -496,7 +501,12 @@ def test_view_with_args(self):
             ind = self.indices[i]
 
             # with arguments
-            pytest.raises(TypeError, lambda: ind.view('i8'))
+            if i == 'catIndex':
+                msg = r"view\(\) takes 1 positional argument but 2 were given"
+            else:
+                msg = "Cannot change data-type for object array"
+            with pytest.raises(TypeError, match=msg):
+                ind.view('i8')
 
         # these are ok
         for i in list(set(self.indices.keys()) - set(restricted)):
@@ -565,7 +575,8 @@ def test_delete(self, pos, expected):
 
     def test_delete_raises(self):
         index = Index(['a', 'b', 'c', 'd'], name='index')
-        with pytest.raises((IndexError, ValueError)):
+        msg = "index 5 is out of bounds for axis 0 with size 4"
+        with pytest.raises((IndexError, ValueError), match=msg):
             # either depending on numpy version
             index.delete(5)
 
@@ -683,7 +694,9 @@ def test_empty_fancy_raises(self, attr):
 
         assert index[[]].identical(empty_index)
         # np.ndarray only accepts ndarray of int & bool dtypes, so should Index
-        pytest.raises(IndexError, index.__getitem__, empty_farr)
+        msg = r"arrays used as indices must be of integer \(or boolean\) type"
+        with pytest.raises(IndexError, match=msg):
+            index[empty_farr]
 
     @pytest.mark.parametrize("sort", [None, False])
     def test_intersection(self, sort):
@@ -1426,13 +1439,14 @@ def test_get_indexer_strings(self, method, expected):
     def test_get_indexer_strings_raises(self):
         index = pd.Index(['b', 'c'])
 
-        with pytest.raises(TypeError):
+        msg = r"unsupported operand type\(s\) for -: 'str' and 'str'"
+        with pytest.raises(TypeError, match=msg):
             index.get_indexer(['a', 'b', 'c', 'd'], method='nearest')
 
-        with pytest.raises(TypeError):
+        with pytest.raises(TypeError, match=msg):
             index.get_indexer(['a', 'b', 'c', 'd'], method='pad', tolerance=2)
 
-        with pytest.raises(TypeError):
+        with pytest.raises(TypeError, match=msg):
             index.get_indexer(['a', 'b', 'c', 'd'], method='pad',
                               tolerance=[2, 2, 2, 2])
 
@@ -1685,8 +1699,11 @@ def test_drop_tuple(self, values, to_drop):
             tm.assert_index_equal(result, expected)
 
         removed = index.drop(to_drop[1])
+        msg = r"\"\[{}\] not found in axis\"".format(
+            re.escape(to_drop[1].__repr__()))
         for drop_me in to_drop[1], [to_drop[1]]:
-            pytest.raises(KeyError, removed.drop, drop_me)
+            with pytest.raises(KeyError, match=msg):
+                removed.drop(drop_me)
 
     @pytest.mark.parametrize("method,expected,sort", [
         ('intersection', np.array([(1, 'A'), (2, 'A'), (1, 'B'), (2, 'B')],

pandas/tests/indexes/test_category.py

@@ -181,18 +181,21 @@ def test_create_categorical(self):
         expected = Categorical(['a', 'b', 'c'])
         tm.assert_categorical_equal(result, expected)
 
-    def test_disallow_set_ops(self):
-
+    @pytest.mark.parametrize('func,op_name', [
+        (lambda idx: idx - idx, '__sub__'),
+        (lambda idx: idx + idx, '__add__'),
+        (lambda idx: idx - ['a', 'b'], '__sub__'),
+        (lambda idx: idx + ['a', 'b'], '__add__'),
+        (lambda idx: ['a', 'b'] - idx, '__rsub__'),
+        (lambda idx: ['a', 'b'] + idx, '__radd__'),
+    ])
+    def test_disallow_set_ops(self, func, op_name):
         # GH 10039
         # set ops (+/-) raise TypeError
         idx = pd.Index(pd.Categorical(['a', 'b']))
-
-        pytest.raises(TypeError, lambda: idx - idx)
-        pytest.raises(TypeError, lambda: idx + idx)
-        pytest.raises(TypeError, lambda: idx - ['a', 'b'])
-        pytest.raises(TypeError, lambda: idx + ['a', 'b'])
-        pytest.raises(TypeError, lambda: ['a', 'b'] - idx)
-        pytest.raises(TypeError, lambda: ['a', 'b'] + idx)
+        msg = "cannot perform {} with this index type: CategoricalIndex"
+        with pytest.raises(TypeError, match=msg.format(op_name)):
+            func(idx)
 
     def test_method_delegation(self):
 
@@ -231,8 +234,9 @@ def test_method_delegation(self):
             list('aabbca'), categories=list('cabdef'), ordered=True))
 
         # invalid
-        pytest.raises(ValueError, lambda: ci.set_categories(
-            list('cab'), inplace=True))
+        msg = "cannot use inplace with CategoricalIndex"
+        with pytest.raises(ValueError, match=msg):
+            ci.set_categories(list('cab'), inplace=True)
 
     def test_contains(self):
 
@@ -357,20 +361,21 @@ def test_append(self):
         tm.assert_index_equal(result, ci, exact=True)
 
         # appending with different categories or reordered is not ok
-        pytest.raises(
-            TypeError,
-            lambda: ci.append(ci.values.set_categories(list('abcd'))))
-        pytest.raises(
-            TypeError,
-            lambda: ci.append(ci.values.reorder_categories(list('abc'))))
+        msg = "all inputs must be Index"
+        with pytest.raises(TypeError, match=msg):
+            ci.append(ci.values.set_categories(list('abcd')))
+        with pytest.raises(TypeError, match=msg):
+            ci.append(ci.values.reorder_categories(list('abc')))
 
         # with objects
         result = ci.append(Index(['c', 'a']))
         expected = CategoricalIndex(list('aabbcaca'), categories=categories)
         tm.assert_index_equal(result, expected, exact=True)
 
         # invalid objects
-        pytest.raises(TypeError, lambda: ci.append(Index(['a', 'd'])))
+        msg = "cannot append a non-category item to a CategoricalIndex"
+        with pytest.raises(TypeError, match=msg):
+            ci.append(Index(['a', 'd']))
 
         # GH14298 - if base object is not categorical -> coerce to object
         result = Index(['c', 'a']).append(ci)
@@ -406,7 +411,10 @@ def test_insert(self):
         tm.assert_index_equal(result, expected, exact=True)
 
         # invalid
-        pytest.raises(TypeError, lambda: ci.insert(0, 'd'))
+        msg = ("cannot insert an item into a CategoricalIndex that is not"
+               " already an existing category")
+        with pytest.raises(TypeError, match=msg):
+            ci.insert(0, 'd')
 
         # GH 18295 (test missing)
         expected = CategoricalIndex(['a', np.nan, 'a', 'b', 'c', 'b'])
@@ -633,12 +641,16 @@ def test_get_indexer(self):
             r1 = idx1.get_indexer(idx2)
             assert_almost_equal(r1, np.array([0, 1, 2, -1], dtype=np.intp))
 
-        pytest.raises(NotImplementedError,
-                      lambda: idx2.get_indexer(idx1, method='pad'))
-        pytest.raises(NotImplementedError,
-                      lambda: idx2.get_indexer(idx1, method='backfill'))
-        pytest.raises(NotImplementedError,
-                      lambda: idx2.get_indexer(idx1, method='nearest'))
+        msg = ("method='pad' and method='backfill' not implemented yet for"
+               " CategoricalIndex")
+        with pytest.raises(NotImplementedError, match=msg):
+            idx2.get_indexer(idx1, method='pad')
+        with pytest.raises(NotImplementedError, match=msg):
+            idx2.get_indexer(idx1, method='backfill')
+
+        msg = "method='nearest' not implemented yet for CategoricalIndex"
+        with pytest.raises(NotImplementedError, match=msg):
+            idx2.get_indexer(idx1, method='nearest')
 
     def test_get_loc(self):
         # GH 12531
@@ -776,12 +788,15 @@ def test_equals_categorical(self):
         # invalid comparisons
         with pytest.raises(ValueError, match="Lengths must match"):
             ci1 == Index(['a', 'b', 'c'])
-        pytest.raises(TypeError, lambda: ci1 == ci2)
-        pytest.raises(
-            TypeError, lambda: ci1 == Categorical(ci1.values, ordered=False))
-        pytest.raises(
-            TypeError,
-            lambda: ci1 == Categorical(ci1.values, categories=list('abc')))
+
+        msg = ("categorical index comparisons must have the same categories"
+               " and ordered attributes")
+        with pytest.raises(TypeError, match=msg):
+            ci1 == ci2
+        with pytest.raises(TypeError, match=msg):
+            ci1 == Categorical(ci1.values, ordered=False)
+        with pytest.raises(TypeError, match=msg):
+            ci1 == Categorical(ci1.values, categories=list('abc'))
 
         # tests
         # make sure that we are testing for category inclusion properly

pandas/tests/indexes/test_common.py

@@ -3,6 +3,8 @@
 any index subclass. Makes use of the `indices` fixture defined
 in pandas/tests/indexes/conftest.py.
 """
+import re
+
 import numpy as np
 import pytest
 
@@ -189,8 +191,14 @@ def test_unique(self, indices):
             result = indices.unique(level=level)
             tm.assert_index_equal(result, expected)
 
-        for level in 3, 'wrong':
-            pytest.raises((IndexError, KeyError), indices.unique, level=level)
+        msg = "Too many levels: Index has only 1 level, not 4"
+        with pytest.raises(IndexError, match=msg):
+            indices.unique(level=3)
+
+        msg = r"Level wrong must be same as name \({}\)".format(
+            re.escape(indices.name.__repr__()))
+        with pytest.raises(KeyError, match=msg):
+            indices.unique(level='wrong')
 
     def test_get_unique_index(self, indices):
         # MultiIndex tested separately
@@ -239,12 +247,16 @@ def test_get_unique_index(self, indices):
                 tm.assert_index_equal(result, expected)
 
     def test_sort(self, indices):
-        pytest.raises(TypeError, indices.sort)
+        msg = "cannot sort an Index object in-place, use sort_values instead"
+        with pytest.raises(TypeError, match=msg):
+            indices.sort()
 
     def test_mutability(self, indices):
         if not len(indices):
             pytest.skip('Skip check for empty Index')
-        pytest.raises(TypeError, indices.__setitem__, 0, indices[0])
+        msg = "Index does not support mutable operations"
+        with pytest.raises(TypeError, match=msg):
+            indices[0] = indices[0]
 
     def test_view(self, indices):
         assert indices.view().name == indices.name