MAINT: Remove assertIsNotNone from testing

pandas/tests/core/computation/test_eval.py

@@ -1308,16 +1308,17 @@ def test_column_in(self):
         assert_series_equal(result, expected)
 
     def assignment_not_inplace(self):
-        # GH 9297
+        # see gh-9297
         df = DataFrame(np.random.randn(5, 2), columns=list('ab'))
 
         actual = df.eval('c = a + b', inplace=False)
-        self.assertIsNotNone(actual)
+        assert actual is not None
+
         expected = df.copy()
         expected['c'] = expected['a'] + expected['b']
-        assert_frame_equal(df, expected)
+        tm.assert_frame_equal(df, expected)
 
-        # default for inplace will change
+        # Default for inplace will change
         with tm.assert_produces_warnings(FutureWarning):
             df.eval('c = a + b')
 

pandas/tests/frame/test_indexing.py

@@ -10,6 +10,8 @@
 
 from numpy import nan
 from numpy.random import randn
+
+import pytest
 import numpy as np
 
 import pandas.core.common as com
@@ -25,7 +27,6 @@
     is_integer,
     is_scalar)
 from pandas.util.testing import (assert_almost_equal,
-                                 assert_numpy_array_equal,
                                  assert_series_equal,
                                  assert_frame_equal,
                                  assertRaisesRegexp,
@@ -40,30 +41,33 @@
 class TestDataFrameIndexing(tm.TestCase, TestData):
 
     def test_getitem(self):
-        # slicing
+        # Slicing
         sl = self.frame[:20]
-        self.assertEqual(20, len(sl.index))
-
-        # column access
+        assert len(sl.index) == 20
 
+        # Column access
         for _, series in compat.iteritems(sl):
-            self.assertEqual(20, len(series.index))
-            self.assertTrue(tm.equalContents(series.index, sl.index))
+            assert len(series.index) == 20
+            assert tm.equalContents(series.index, sl.index)
 
         for key, _ in compat.iteritems(self.frame._series):
-            self.assertIsNotNone(self.frame[key])
+            assert self.frame[key] is not None
 
-        self.assertNotIn('random', self.frame)
+        assert 'random' not in self.frame
         with assertRaisesRegexp(KeyError, 'random'):
             self.frame['random']
 
         df = self.frame.copy()
         df['$10'] = randn(len(df))
+
         ad = randn(len(df))
         df['@awesome_domain'] = ad
-        self.assertRaises(KeyError, df.__getitem__, 'df["$10"]')
+
+        with pytest.raises(KeyError):
+            df.__getitem__('df["$10"]')
+
         res = df['@awesome_domain']
-        assert_numpy_array_equal(ad, res.values)
+        tm.assert_numpy_array_equal(ad, res.values)
 
     def test_getitem_dupe_cols(self):
         df = DataFrame([[1, 2, 3], [4, 5, 6]], columns=['a', 'a', 'b'])
@@ -648,28 +652,25 @@ def test_setitem_corner2(self):
         self.assertEqual(df.loc[1, 'cruft'], 0)
 
     def test_setitem_ambig(self):
-        # difficulties with mixed-type data
+        # Difficulties with mixed-type data
         from decimal import Decimal
 
-        # created as float type
+        # Created as float type
         dm = DataFrame(index=lrange(3), columns=lrange(3))
 
         coercable_series = Series([Decimal(1) for _ in range(3)],
                                   index=lrange(3))
         uncoercable_series = Series(['foo', 'bzr', 'baz'], index=lrange(3))
 
         dm[0] = np.ones(3)
-        self.assertEqual(len(dm.columns), 3)
-        # self.assertIsNone(dm.objects)
+        assert len(dm.columns) == 3
 
         dm[1] = coercable_series
-        self.assertEqual(len(dm.columns), 3)
-        # self.assertIsNone(dm.objects)
+        assert len(dm.columns) == 3
 
         dm[2] = uncoercable_series
-        self.assertEqual(len(dm.columns), 3)
-        # self.assertIsNotNone(dm.objects)
-        self.assertEqual(dm[2].dtype, np.object_)
+        assert len(dm.columns) == 3
+        assert dm[2].dtype == np.object_
 
     def test_setitem_clear_caches(self):
         # see gh-304

pandas/tests/indexes/datetimes/test_construction.py

@@ -53,15 +53,14 @@ def test_construction_with_alt(self):
             i.tz_localize(None).asi8, dtype=i.dtype, tz='US/Pacific'))
 
     def test_construction_index_with_mixed_timezones(self):
-        # GH 11488
-        # no tz results in DatetimeIndex
+        # gh-11488: no tz results in DatetimeIndex
         result = Index([Timestamp('2011-01-01'),
                         Timestamp('2011-01-02')], name='idx')
         exp = DatetimeIndex([Timestamp('2011-01-01'),
                              Timestamp('2011-01-02')], name='idx')
-        self.assert_index_equal(result, exp, exact=True)
-        self.assertTrue(isinstance(result, DatetimeIndex))
-        self.assertIsNone(result.tz)
+        tm.assert_index_equal(result, exp, exact=True)
+        assert isinstance(result, DatetimeIndex)
+        assert result.tz is None
 
         # same tz results in DatetimeIndex
         result = Index([Timestamp('2011-01-01 10:00', tz='Asia/Tokyo'),
@@ -70,10 +69,10 @@ def test_construction_index_with_mixed_timezones(self):
         exp = DatetimeIndex(
             [Timestamp('2011-01-01 10:00'), Timestamp('2011-01-02 10:00')
              ], tz='Asia/Tokyo', name='idx')
-        self.assert_index_equal(result, exp, exact=True)
-        self.assertTrue(isinstance(result, DatetimeIndex))
-        self.assertIsNotNone(result.tz)
-        self.assertEqual(result.tz, exp.tz)
+        tm.assert_index_equal(result, exp, exact=True)
+        assert isinstance(result, DatetimeIndex)
+        assert result.tz is not None
+        assert result.tz == exp.tz
 
         # same tz results in DatetimeIndex (DST)
         result = Index([Timestamp('2011-01-01 10:00', tz='US/Eastern'),
@@ -82,69 +81,69 @@ def test_construction_index_with_mixed_timezones(self):
         exp = DatetimeIndex([Timestamp('2011-01-01 10:00'),
                              Timestamp('2011-08-01 10:00')],
                             tz='US/Eastern', name='idx')
-        self.assert_index_equal(result, exp, exact=True)
-        self.assertTrue(isinstance(result, DatetimeIndex))
-        self.assertIsNotNone(result.tz)
-        self.assertEqual(result.tz, exp.tz)
+        tm.assert_index_equal(result, exp, exact=True)
+        assert isinstance(result, DatetimeIndex)
+        assert result.tz is not None
+        assert result.tz == exp.tz
 
-        # different tz results in Index(dtype=object)
+        # Different tz results in Index(dtype=object)
         result = Index([Timestamp('2011-01-01 10:00'),
                         Timestamp('2011-01-02 10:00', tz='US/Eastern')],
                        name='idx')
         exp = Index([Timestamp('2011-01-01 10:00'),
                      Timestamp('2011-01-02 10:00', tz='US/Eastern')],
                     dtype='object', name='idx')
-        self.assert_index_equal(result, exp, exact=True)
-        self.assertFalse(isinstance(result, DatetimeIndex))
+        tm.assert_index_equal(result, exp, exact=True)
+        assert not isinstance(result, DatetimeIndex)
 
         result = Index([Timestamp('2011-01-01 10:00', tz='Asia/Tokyo'),
                         Timestamp('2011-01-02 10:00', tz='US/Eastern')],
                        name='idx')
         exp = Index([Timestamp('2011-01-01 10:00', tz='Asia/Tokyo'),
                      Timestamp('2011-01-02 10:00', tz='US/Eastern')],
                     dtype='object', name='idx')
-        self.assert_index_equal(result, exp, exact=True)
-        self.assertFalse(isinstance(result, DatetimeIndex))
+        tm.assert_index_equal(result, exp, exact=True)
+        assert not isinstance(result, DatetimeIndex)
 
         # length = 1
         result = Index([Timestamp('2011-01-01')], name='idx')
         exp = DatetimeIndex([Timestamp('2011-01-01')], name='idx')
-        self.assert_index_equal(result, exp, exact=True)
-        self.assertTrue(isinstance(result, DatetimeIndex))
-        self.assertIsNone(result.tz)
+        tm.assert_index_equal(result, exp, exact=True)
+        assert isinstance(result, DatetimeIndex)
+        assert result.tz is None
 
         # length = 1 with tz
         result = Index(
             [Timestamp('2011-01-01 10:00', tz='Asia/Tokyo')], name='idx')
         exp = DatetimeIndex([Timestamp('2011-01-01 10:00')], tz='Asia/Tokyo',
                             name='idx')
-        self.assert_index_equal(result, exp, exact=True)
-        self.assertTrue(isinstance(result, DatetimeIndex))
-        self.assertIsNotNone(result.tz)
-        self.assertEqual(result.tz, exp.tz)
+        tm.assert_index_equal(result, exp, exact=True)
+        assert isinstance(result, DatetimeIndex)
+        assert result.tz is not None
+        assert result.tz == exp.tz
 
     def test_construction_index_with_mixed_timezones_with_NaT(self):
-        # GH 11488
+        # see gh-11488
         result = Index([pd.NaT, Timestamp('2011-01-01'),
                         pd.NaT, Timestamp('2011-01-02')], name='idx')
         exp = DatetimeIndex([pd.NaT, Timestamp('2011-01-01'),
                              pd.NaT, Timestamp('2011-01-02')], name='idx')
-        self.assert_index_equal(result, exp, exact=True)
-        self.assertTrue(isinstance(result, DatetimeIndex))
-        self.assertIsNone(result.tz)
+        tm.assert_index_equal(result, exp, exact=True)
+        assert isinstance(result, DatetimeIndex)
+        assert result.tz is None
 
-        # same tz results in DatetimeIndex
+        # Same tz results in DatetimeIndex
         result = Index([pd.NaT, Timestamp('2011-01-01 10:00', tz='Asia/Tokyo'),
                         pd.NaT, Timestamp('2011-01-02 10:00',
                                           tz='Asia/Tokyo')],
                        name='idx')
         exp = DatetimeIndex([pd.NaT, Timestamp('2011-01-01 10:00'),
                              pd.NaT, Timestamp('2011-01-02 10:00')],
                             tz='Asia/Tokyo', name='idx')
-        self.assert_index_equal(result, exp, exact=True)
-        self.assertTrue(isinstance(result, DatetimeIndex))
-        self.assertIsNotNone(result.tz)
-        self.assertEqual(result.tz, exp.tz)
+        tm.assert_index_equal(result, exp, exact=True)
+        assert isinstance(result, DatetimeIndex)
+        assert result.tz is not None
+        assert result.tz == exp.tz
 
         # same tz results in DatetimeIndex (DST)
         result = Index([Timestamp('2011-01-01 10:00', tz='US/Eastern'),
@@ -154,10 +153,10 @@ def test_construction_index_with_mixed_timezones_with_NaT(self):
         exp = DatetimeIndex([Timestamp('2011-01-01 10:00'), pd.NaT,
                              Timestamp('2011-08-01 10:00')],
                             tz='US/Eastern', name='idx')
-        self.assert_index_equal(result, exp, exact=True)
-        self.assertTrue(isinstance(result, DatetimeIndex))
-        self.assertIsNotNone(result.tz)
-        self.assertEqual(result.tz, exp.tz)
+        tm.assert_index_equal(result, exp, exact=True)
+        assert isinstance(result, DatetimeIndex)
+        assert result.tz is not None
+        assert result.tz == exp.tz
 
         # different tz results in Index(dtype=object)
         result = Index([pd.NaT, Timestamp('2011-01-01 10:00'),
@@ -167,32 +166,33 @@ def test_construction_index_with_mixed_timezones_with_NaT(self):
         exp = Index([pd.NaT, Timestamp('2011-01-01 10:00'),
                      pd.NaT, Timestamp('2011-01-02 10:00', tz='US/Eastern')],
                     dtype='object', name='idx')
-        self.assert_index_equal(result, exp, exact=True)
-        self.assertFalse(isinstance(result, DatetimeIndex))
+        tm.assert_index_equal(result, exp, exact=True)
+        assert not isinstance(result, DatetimeIndex)
 
         result = Index([pd.NaT, Timestamp('2011-01-01 10:00', tz='Asia/Tokyo'),
                         pd.NaT, Timestamp('2011-01-02 10:00',
                                           tz='US/Eastern')], name='idx')
         exp = Index([pd.NaT, Timestamp('2011-01-01 10:00', tz='Asia/Tokyo'),
                      pd.NaT, Timestamp('2011-01-02 10:00', tz='US/Eastern')],
                     dtype='object', name='idx')
-        self.assert_index_equal(result, exp, exact=True)
-        self.assertFalse(isinstance(result, DatetimeIndex))
+        tm.assert_index_equal(result, exp, exact=True)
+        assert not isinstance(result, DatetimeIndex)
 
         # all NaT
         result = Index([pd.NaT, pd.NaT], name='idx')
         exp = DatetimeIndex([pd.NaT, pd.NaT], name='idx')
-        self.assert_index_equal(result, exp, exact=True)
-        self.assertTrue(isinstance(result, DatetimeIndex))
-        self.assertIsNone(result.tz)
+        tm.assert_index_equal(result, exp, exact=True)
+        assert isinstance(result, DatetimeIndex)
+        assert result.tz is None
 
         # all NaT with tz
         result = Index([pd.NaT, pd.NaT], tz='Asia/Tokyo', name='idx')
         exp = DatetimeIndex([pd.NaT, pd.NaT], tz='Asia/Tokyo', name='idx')
-        self.assert_index_equal(result, exp, exact=True)
-        self.assertTrue(isinstance(result, DatetimeIndex))
-        self.assertIsNotNone(result.tz)
-        self.assertEqual(result.tz, exp.tz)
+
+        tm.assert_index_equal(result, exp, exact=True)
+        assert isinstance(result, DatetimeIndex)
+        assert result.tz is not None
+        assert result.tz == exp.tz
 
     def test_construction_dti_with_mixed_timezones(self):
         # GH 11488 (not changed, added explicit tests)

pandas/tests/indexes/datetimes/test_ops.py

@@ -1122,7 +1122,7 @@ def test_comparison(self):
 
     def test_pickle_unpickle(self):
         unpickled = tm.round_trip_pickle(self.rng)
-        self.assertIsNotNone(unpickled.offset)
+        assert unpickled.offset is not None
 
     def test_copy(self):
         cp = self.rng.copy()
@@ -1273,7 +1273,7 @@ def test_shift(self):
 
     def test_pickle_unpickle(self):
         unpickled = tm.round_trip_pickle(self.rng)
-        self.assertIsNotNone(unpickled.offset)
+        assert unpickled.offset is not None
 
     def test_summary(self):
         self.rng.summary()

pandas/tests/indexes/test_multi.py

@@ -393,39 +393,46 @@ def test_inplace_mutation_resets_values(self):
         levels = [['a', 'b', 'c'], [4]]
         levels2 = [[1, 2, 3], ['a']]
         labels = [[0, 1, 0, 2, 2, 0], [0, 0, 0, 0, 0, 0]]
+
         mi1 = MultiIndex(levels=levels, labels=labels)
         mi2 = MultiIndex(levels=levels2, labels=labels)
         vals = mi1.values.copy()
         vals2 = mi2.values.copy()
-        self.assertIsNotNone(mi1._tuples)
 
-        # make sure level setting works
+        assert mi1._tuples is not None
+
+        # Make sure level setting works
         new_vals = mi1.set_levels(levels2).values
-        assert_almost_equal(vals2, new_vals)
-        # non-inplace doesn't kill _tuples [implementation detail]
-        assert_almost_equal(mi1._tuples, vals)
-        # and values is still same too
-        assert_almost_equal(mi1.values, vals)
+        tm.assert_almost_equal(vals2, new_vals)
+
+        # Non-inplace doesn't kill _tuples [implementation detail]
+        tm.assert_almost_equal(mi1._tuples, vals)
+
+        # ...and values is still same too
+        tm.assert_almost_equal(mi1.values, vals)
 
-        # inplace should kill _tuples
+        # Inplace should kill _tuples
         mi1.set_levels(levels2, inplace=True)
-        assert_almost_equal(mi1.values, vals2)
+        tm.assert_almost_equal(mi1.values, vals2)
 
-        # make sure label setting works too
+        # Make sure label setting works too
         labels2 = [[0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0]]
         exp_values = np.empty((6, ), dtype=object)
         exp_values[:] = [(long(1), 'a')] * 6
-        # must be 1d array of tuples
-        self.assertEqual(exp_values.shape, (6, ))
+
+        # Must be 1d array of tuples
+        assert exp_values.shape == (6, )
         new_values = mi2.set_labels(labels2).values
-        # not inplace shouldn't change
-        assert_almost_equal(mi2._tuples, vals2)
-        # should have correct values
-        assert_almost_equal(exp_values, new_values)
 
-        # and again setting inplace should kill _tuples, etc
+        # Not inplace shouldn't change
+        tm.assert_almost_equal(mi2._tuples, vals2)
+
+        # Should have correct values
+        tm.assert_almost_equal(exp_values, new_values)
+
+        # ...and again setting inplace should kill _tuples, etc
         mi2.set_labels(labels2, inplace=True)
-        assert_almost_equal(mi2.values, new_values)
+        tm.assert_almost_equal(mi2.values, new_values)
 
     def test_copy_in_constructor(self):
         levels = np.array(["a", "b", "c"])