TST: Move some Series ctor tests to SharedWithSparse

Author: kernc

pandas/tests/series/test_api.py

@@ -1,12 +1,13 @@
 # coding=utf-8
 # pylint: disable-msg=E1101,W0612
+from collections import OrderedDict
 
 import pytest
 
 import numpy as np
 import pandas as pd
 
-from pandas import Index, Series, DataFrame, date_range
+from pandas import Index, Series, SparseSeries, DataFrame, date_range
 from pandas.core.indexes.datetimes import Timestamp
 
 from pandas.compat import range
@@ -21,6 +22,12 @@
 
 class SharedWithSparse(object):
 
+    def _assert_series_equal(self, left, right):
+        """Helper dispatching to series class dependent assertion"""
+        if isinstance(left, SparseSeries) or isinstance(right, SparseSeries):
+            return tm.assert_sp_series_equal(left, right)
+        return tm.assert_series_equal(left, right)
+
     def test_scalarop_preserve_name(self):
         result = self.ts * 2
         assert result.name == self.ts.name
@@ -117,9 +124,79 @@ def test_to_sparse_pass_name(self):
         result = self.ts.to_sparse()
         assert result.name == self.ts.name
 
+    def test_constructor_dict(self):
+        d = {'a': 0., 'b': 1., 'c': 2.}
+        result = self.series_klass(d)
+        expected = self.series_klass(d, index=sorted(d.keys()))
+        self._assert_series_equal(result, expected)
+
+        result = self.series_klass(d, index=['b', 'c', 'd', 'a'])
+        expected = self.series_klass([1, 2, np.nan, 0],
+                                     index=['b', 'c', 'd', 'a'])
+        self._assert_series_equal(result, expected)
+
+    def test_constructor_subclass_dict(self):
+        data = tm.TestSubDict((x, 10.0 * x) for x in range(10))
+        series = self.series_klass(data)
+        expected = self.series_klass(dict(compat.iteritems(data)))
+        self._assert_series_equal(series, expected)
+
+    def test_constructor_ordereddict(self):
+        # GH3283
+        data = OrderedDict(
+            ('col%s' % i, np.random.random()) for i in range(12))
+
+        series = self.series_klass(data)
+        expected = self.series_klass(list(data.values()), list(data.keys()))
+        self._assert_series_equal(series, expected)
+
+        # Test with subclass
+        class A(OrderedDict):
+            pass
+
+        series = self.series_klass(A(data))
+        self._assert_series_equal(series, expected)
+
+    def test_constructor_dict_multiindex(self):
+        d = {('a', 'a'): 0., ('b', 'a'): 1., ('b', 'c'): 2.}
+        _d = sorted(d.items())
+        result = self.series_klass(d)
+        expected = self.series_klass(
+            [x[1] for x in _d],
+            index=pd.MultiIndex.from_tuples([x[0] for x in _d]))
+        self._assert_series_equal(result, expected)
+
+        d['z'] = 111.
+        _d.insert(0, ('z', d['z']))
+        result = self.series_klass(d)
+        expected = self.series_klass([x[1] for x in _d],
+                                     index=pd.Index([x[0] for x in _d],
+                                                    tupleize_cols=False))
+        result = result.reindex(index=expected.index)
+        self._assert_series_equal(result, expected)
+
+    def test_constructor_dict_timedelta_index(self):
+        # GH #12169 : Resample category data with timedelta index
+        # construct Series from dict as data and TimedeltaIndex as index
+        # will result NaN in result Series data
+        expected = self.series_klass(
+            data=['A', 'B', 'C'],
+            index=pd.to_timedelta([0, 10, 20], unit='s')
+        )
+
+        result = self.series_klass(
+            data={pd.to_timedelta(0, unit='s'): 'A',
+                  pd.to_timedelta(10, unit='s'): 'B',
+                  pd.to_timedelta(20, unit='s'): 'C'},
+            index=pd.to_timedelta([0, 10, 20], unit='s')
+        )
+        self._assert_series_equal(result, expected)
+
 
 class TestSeriesMisc(TestData, SharedWithSparse):
 
+    series_klass = Series
+
     def test_tab_completion(self):
         # GH 9910
         s = Series(list('abcd'))

pandas/tests/series/test_constructors.py

@@ -605,48 +605,6 @@ def test_constructor_dict(self):
         expected.iloc[1] = 1
         assert_series_equal(result, expected)
 
-    def test_constructor_dict_multiindex(self):
-        check = lambda result, expected: tm.assert_series_equal(
-            result, expected, check_dtype=True, check_series_type=True)
-        d = {('a', 'a'): 0., ('b', 'a'): 1., ('b', 'c'): 2.}
-        _d = sorted(d.items())
-        ser = Series(d)
-        expected = Series([x[1] for x in _d],
-                          index=MultiIndex.from_tuples([x[0] for x in _d]))
-        check(ser, expected)
-
-        d['z'] = 111.
-        _d.insert(0, ('z', d['z']))
-        ser = Series(d)
-        expected = Series([x[1] for x in _d], index=Index(
-            [x[0] for x in _d], tupleize_cols=False))
-        ser = ser.reindex(index=expected.index)
-        check(ser, expected)
-
-    def test_constructor_dict_timedelta_index(self):
-        # GH #12169 : Resample category data with timedelta index
-        # construct Series from dict as data and TimedeltaIndex as index
-        # will result NaN in result Series data
-        expected = Series(
-            data=['A', 'B', 'C'],
-            index=pd.to_timedelta([0, 10, 20], unit='s')
-        )
-
-        result = Series(
-            data={pd.to_timedelta(0, unit='s'): 'A',
-                  pd.to_timedelta(10, unit='s'): 'B',
-                  pd.to_timedelta(20, unit='s'): 'C'},
-            index=pd.to_timedelta([0, 10, 20], unit='s')
-        )
-        # this should work
-        assert_series_equal(result, expected)
-
-    def test_constructor_subclass_dict(self):
-        data = tm.TestSubDict((x, 10.0 * x) for x in range(10))
-        series = Series(data)
-        refseries = Series(dict(compat.iteritems(data)))
-        assert_series_equal(refseries, series)
-
     def test_constructor_dict_datetime64_index(self):
         # GH 9456
 
@@ -670,26 +628,6 @@ def create_data(constructor):
         assert_series_equal(result_datetime, expected)
         assert_series_equal(result_Timestamp, expected)
 
-    def test_orderedDict_ctor(self):
-        # GH3283
-        import pandas
-        import random
-        data = OrderedDict([('col%s' % i, random.random()) for i in range(12)])
-        s = pandas.Series(data)
-        assert all(s.values == list(data.values()))
-
-    def test_orderedDict_subclass_ctor(self):
-        # GH3283
-        import pandas
-        import random
-
-        class A(OrderedDict):
-            pass
-
-        data = A([('col%s' % i, random.random()) for i in range(12)])
-        s = pandas.Series(data)
-        assert all(s.values == list(data.values()))
-
     def test_constructor_list_of_tuples(self):
         data = [(1, 1), (2, 2), (2, 3)]
         s = Series(data)

pandas/tests/sparse/test_series.py

@@ -1,6 +1,8 @@
 # pylint: disable-msg=E1101,W0612
 
 import operator
+from datetime import datetime
+
 import pytest
 
 from numpy import nan
@@ -58,6 +60,8 @@ def _test_data2_zero():
 
 class TestSparseSeries(SharedWithSparse):
 
+    series_klass = SparseSeries
+
     def setup_method(self, method):
         arr, index = _test_data1()
 
@@ -1379,3 +1383,18 @@ def test_numpy_func_call(self):
         for func in funcs:
             for series in ('bseries', 'zbseries'):
                 getattr(np, func)(getattr(self, series))
+
+
+@pytest.mark.parametrize(
+    'datetime_type', (np.datetime64,
+                      pd.Timestamp,
+                      lambda x: datetime.strptime(x, '%Y-%m-%d')))
+def test_constructor_dict_datetime64_index(datetime_type):
+    # GH 9456
+    dates = ['1984-02-19', '1988-11-06', '1989-12-03', '1990-03-15']
+    values = [42544017.198965244, 1234565, 40512335.181958228, -1]
+
+    result = SparseSeries(dict(zip(map(datetime_type, dates), values)))
+    expected = SparseSeries(values, map(pd.Timestamp, dates))
+
+    tm.assert_sp_series_equal(result, expected)