TST: clean up series/frame api tests inheritance a bit

Author: jreback

pandas/tests/frame/common.py

@@ -104,6 +104,49 @@ def simple(self):
         return pd.DataFrame(arr, columns=['one', 'two', 'three'],
                             index=['a', 'b', 'c'])
 
+
+class SharedWithSparse(TestData):
+
+    def test_copy_index_name_checking(self):
+        # don't want to be able to modify the index stored elsewhere after
+        # making a copy
+        for attr in ('index', 'columns'):
+            ind = getattr(self.frame, attr)
+            ind.name = None
+            cp = self.frame.copy()
+            getattr(cp, attr).name = 'foo'
+            self.assertIsNone(getattr(self.frame, attr).name)
+
+    def test_getitem_pop_assign_name(self):
+        s = self.frame['A']
+        self.assertEqual(s.name, 'A')
+
+        s = self.frame.pop('A')
+        self.assertEqual(s.name, 'A')
+
+        s = self.frame.loc[:, 'B']
+        self.assertEqual(s.name, 'B')
+
+        s2 = s.loc[:]
+        self.assertEqual(s2.name, 'B')
+
+    def test_get_value(self):
+        for idx in self.frame.index:
+            for col in self.frame.columns:
+                result = self.frame.get_value(idx, col)
+                expected = self.frame[col][idx]
+                tm.assert_almost_equal(result, expected)
+
+    def test_add_prefix_suffix(self):
+        with_prefix = self.frame.add_prefix('foo#')
+        expected = pd.Index(['foo#%s' % c for c in self.frame.columns])
+        self.assert_index_equal(with_prefix.columns, expected)
+
+        with_suffix = self.frame.add_suffix('#foo')
+        expected = pd.Index(['%s#foo' % c for c in self.frame.columns])
+        self.assert_index_equal(with_suffix.columns, expected)
+
+
 # self.ts3 = tm.makeTimeSeries()[-5:]
 # self.ts4 = tm.makeTimeSeries()[1:-1]
 

pandas/tests/frame/test_misc_api.py renamed to pandas/tests/frame/test_api.py

@@ -22,52 +22,10 @@
 
 import pandas.util.testing as tm
 
-from pandas.tests.frame.common import TestData
+from pandas.tests.frame.common import SharedWithSparse
 
 
-class SharedWithSparse(object):
-
-    def test_copy_index_name_checking(self):
-        # don't want to be able to modify the index stored elsewhere after
-        # making a copy
-        for attr in ('index', 'columns'):
-            ind = getattr(self.frame, attr)
-            ind.name = None
-            cp = self.frame.copy()
-            getattr(cp, attr).name = 'foo'
-            self.assertIsNone(getattr(self.frame, attr).name)
-
-    def test_getitem_pop_assign_name(self):
-        s = self.frame['A']
-        self.assertEqual(s.name, 'A')
-
-        s = self.frame.pop('A')
-        self.assertEqual(s.name, 'A')
-
-        s = self.frame.loc[:, 'B']
-        self.assertEqual(s.name, 'B')
-
-        s2 = s.loc[:]
-        self.assertEqual(s2.name, 'B')
-
-    def test_get_value(self):
-        for idx in self.frame.index:
-            for col in self.frame.columns:
-                result = self.frame.get_value(idx, col)
-                expected = self.frame[col][idx]
-                tm.assert_almost_equal(result, expected)
-
-    def test_add_prefix_suffix(self):
-        with_prefix = self.frame.add_prefix('foo#')
-        expected = pd.Index(['foo#%s' % c for c in self.frame.columns])
-        self.assert_index_equal(with_prefix.columns, expected)
-
-        with_suffix = self.frame.add_suffix('#foo')
-        expected = pd.Index(['%s#foo' % c for c in self.frame.columns])
-        self.assert_index_equal(with_suffix.columns, expected)
-
-
-class TestDataFrameMisc(tm.TestCase, SharedWithSparse, TestData):
+class TestDataFrameMisc(tm.TestCase, SharedWithSparse):
 
     klass = DataFrame
 

pandas/tests/series/common.py

@@ -1,15 +1,16 @@
+""" common series tests routines """
 from pandas.util.decorators import cache_readonly
+
 import pandas.util.testing as tm
 import pandas as pd
-
-_ts = tm.makeTimeSeries()
+import pandas.formats.printing as printing
 
 
 class TestData(object):
 
     @cache_readonly
     def ts(self):
-        ts = _ts.copy()
+        ts = tm.makeTimeSeries()
         ts.name = 'ts'
         return ts
 
@@ -28,3 +29,103 @@ def objSeries(self):
     @cache_readonly
     def empty(self):
         return pd.Series([], index=[])
+
+
+class SharedWithSparse(TestData):
+
+    def test_scalarop_preserve_name(self):
+        result = self.ts * 2
+        assert result.name == self.ts.name
+
+    def test_copy_name(self):
+        result = self.ts.copy()
+        assert result.name == self.ts.name
+
+    def test_copy_index_name_checking(self):
+        # don't want to be able to modify the index stored elsewhere after
+        # making a copy
+
+        self.ts.index.name = None
+        assert self.ts.index.name is None
+        assert self.ts is self.ts
+
+        cp = self.ts.copy()
+        cp.index.name = 'foo'
+        printing.pprint_thing(self.ts.index.name)
+        assert self.ts.index.name is None
+
+    def test_append_preserve_name(self):
+        result = self.ts[:5].append(self.ts[5:])
+        assert result.name == self.ts.name
+
+    def test_binop_maybe_preserve_name(self):
+        # names match, preserve
+        result = self.ts * self.ts
+        assert result.name == self.ts.name
+        result = self.ts.mul(self.ts)
+        assert result.name == self.ts.name
+
+        result = self.ts * self.ts[:-2]
+        assert result.name == self.ts.name
+
+        # names don't match, don't preserve
+        cp = self.ts.copy()
+        cp.name = 'something else'
+        result = self.ts + cp
+        assert result.name is None
+
+        result = self.ts.add(cp)
+        assert result.name is None
+
+        ops = ['add', 'sub', 'mul', 'div', 'truediv', 'floordiv', 'mod', 'pow']
+        ops = ops + ['r' + op for op in ops]
+        for op in ops:
+            # names match, preserve
+            s = self.ts.copy()
+            result = getattr(s, op)(s)
+            assert result.name == self.ts.name
+
+            # names don't match, don't preserve
+            cp = self.ts.copy()
+            cp.name = 'changed'
+            result = getattr(s, op)(cp)
+            assert result.name is None
+
+    def test_combine_first_name(self):
+        result = self.ts.combine_first(self.ts[:5])
+        assert result.name == self.ts.name
+
+    def test_getitem_preserve_name(self):
+        result = self.ts[self.ts > 0]
+        assert result.name == self.ts.name
+
+        result = self.ts[[0, 2, 4]]
+        assert result.name == self.ts.name
+
+        result = self.ts[5:10]
+        assert result.name == self.ts.name
+
+    def test_pickle(self):
+        unp_series = self._pickle_roundtrip(self.series)
+        unp_ts = self._pickle_roundtrip(self.ts)
+        tm.assert_series_equal(unp_series, self.series)
+        tm.assert_series_equal(unp_ts, self.ts)
+
+    def _pickle_roundtrip(self, obj):
+
+        with tm.ensure_clean() as path:
+            obj.to_pickle(path)
+            unpickled = pd.read_pickle(path)
+            return unpickled
+
+    def test_argsort_preserve_name(self):
+        result = self.ts.argsort()
+        assert result.name == self.ts.name
+
+    def test_sort_index_name(self):
+        result = self.ts.sort_index(ascending=False)
+        assert result.name == self.ts.name
+
+    def test_to_sparse_pass_name(self):
+        result = self.ts.to_sparse()
+        assert result.name == self.ts.name