TST: split/collect/parametrize tests (#39663)

Author: jbrockmendel

pandas/conftest.py

@@ -19,7 +19,7 @@
 """
 
 from collections import abc
-from datetime import date, time, timedelta, timezone
+from datetime import date, datetime, time, timedelta, timezone
 from decimal import Decimal
 import operator
 import os
@@ -757,6 +757,27 @@ def mixed_type_frame():
     )
 
 
+@pytest.fixture
+def rand_series_with_duplicate_datetimeindex():
+    """
+    Fixture for Series with a DatetimeIndex that has duplicates.
+    """
+    dates = [
+        datetime(2000, 1, 2),
+        datetime(2000, 1, 2),
+        datetime(2000, 1, 2),
+        datetime(2000, 1, 3),
+        datetime(2000, 1, 3),
+        datetime(2000, 1, 3),
+        datetime(2000, 1, 4),
+        datetime(2000, 1, 4),
+        datetime(2000, 1, 4),
+        datetime(2000, 1, 5),
+    ]
+
+    return Series(np.random.randn(len(dates)), index=dates)
+
+
 # ----------------------------------------------------------------
 # Scalars
 # ----------------------------------------------------------------

pandas/tests/groupby/test_groupby.py

@@ -2143,3 +2143,10 @@ def test_groupby_numerical_stability_cumsum():
     )
     expected = DataFrame({"a": exp_data, "b": exp_data})
     tm.assert_frame_equal(result, expected, check_exact=True)
+
+
+def test_groupby_mean_duplicate_index(rand_series_with_duplicate_datetimeindex):
+    dups = rand_series_with_duplicate_datetimeindex
+    result = dups.groupby(level=0).mean()
+    expected = dups.groupby(dups.index).mean()
+    tm.assert_series_equal(result, expected)

pandas/tests/indexes/datetimes/test_datetime.py

@@ -198,23 +198,6 @@ def test_ns_index(self):
         new_index = date_range(start=index[0], end=index[-1], freq=index.freq)
         self.assert_index_parameters(new_index)
 
-    @pytest.mark.parametrize(
-        "arr, expected",
-        [
-            (DatetimeIndex(["2017", "2017"]), DatetimeIndex(["2017"])),
-            (
-                DatetimeIndex(["2017", "2017"], tz="US/Eastern"),
-                DatetimeIndex(["2017"], tz="US/Eastern"),
-            ),
-        ],
-    )
-    def test_unique(self, arr, expected):
-        result = arr.unique()
-        tm.assert_index_equal(result, expected)
-        # GH 21737
-        # Ensure the underlying data is consistent
-        assert result[0] == expected[0]
-
     def test_asarray_tz_naive(self):
         # This shouldn't produce a warning.
         idx = date_range("2000", periods=2)

pandas/tests/indexes/datetimes/test_unique.py

@@ -0,0 +1,74 @@
+from datetime import datetime, timedelta
+
+import pytest
+
+from pandas import DatetimeIndex, NaT, Timestamp
+import pandas._testing as tm
+
+
+@pytest.mark.parametrize(
+    "arr, expected",
+    [
+        (DatetimeIndex(["2017", "2017"]), DatetimeIndex(["2017"])),
+        (
+            DatetimeIndex(["2017", "2017"], tz="US/Eastern"),
+            DatetimeIndex(["2017"], tz="US/Eastern"),
+        ),
+    ],
+)
+def test_unique(arr, expected):
+    result = arr.unique()
+    tm.assert_index_equal(result, expected)
+    # GH#21737
+    # Ensure the underlying data is consistent
+    assert result[0] == expected[0]
+
+
+def test_index_unique(rand_series_with_duplicate_datetimeindex):
+    dups = rand_series_with_duplicate_datetimeindex
+    index = dups.index
+
+    uniques = index.unique()
+    expected = DatetimeIndex(
+        [
+            datetime(2000, 1, 2),
+            datetime(2000, 1, 3),
+            datetime(2000, 1, 4),
+            datetime(2000, 1, 5),
+        ]
+    )
+    assert uniques.dtype == "M8[ns]"  # sanity
+    tm.assert_index_equal(uniques, expected)
+    assert index.nunique() == 4
+
+    # GH#2563
+    assert isinstance(uniques, DatetimeIndex)
+
+    dups_local = index.tz_localize("US/Eastern")
+    dups_local.name = "foo"
+    result = dups_local.unique()
+    expected = DatetimeIndex(expected, name="foo")
+    expected = expected.tz_localize("US/Eastern")
+    assert result.tz is not None
+    assert result.name == "foo"
+    tm.assert_index_equal(result, expected)
+
+    # NaT, note this is excluded
+    arr = [1370745748 + t for t in range(20)] + [NaT.value]
+    idx = DatetimeIndex(arr * 3)
+    tm.assert_index_equal(idx.unique(), DatetimeIndex(arr))
+    assert idx.nunique() == 20
+    assert idx.nunique(dropna=False) == 21
+
+    arr = [
+        Timestamp("2013-06-09 02:42:28") + timedelta(seconds=t) for t in range(20)
+    ] + [NaT]
+    idx = DatetimeIndex(arr * 3)
+    tm.assert_index_equal(idx.unique(), DatetimeIndex(arr))
+    assert idx.nunique() == 20
+    assert idx.nunique(dropna=False) == 21
+
+
+def test_is_unique_monotonic(rand_series_with_duplicate_datetimeindex):
+    index = rand_series_with_duplicate_datetimeindex.index
+    assert not index.is_unique

pandas/tests/series/indexing/test_datetime.py

@@ -9,18 +9,10 @@
 import pytest
 import pytz
 
-from pandas._libs import iNaT, index as libindex
+from pandas._libs import index as libindex
 
 import pandas as pd
-from pandas import (
-    DataFrame,
-    DatetimeIndex,
-    NaT,
-    Series,
-    Timestamp,
-    date_range,
-    period_range,
-)
+from pandas import DataFrame, Series, Timestamp, date_range, period_range
 import pandas._testing as tm
 
 
@@ -347,77 +339,10 @@ def test_datetime_indexing():
 """
 
 
-@pytest.fixture
-def dups():
-    dates = [
-        datetime(2000, 1, 2),
-        datetime(2000, 1, 2),
-        datetime(2000, 1, 2),
-        datetime(2000, 1, 3),
-        datetime(2000, 1, 3),
-        datetime(2000, 1, 3),
-        datetime(2000, 1, 4),
-        datetime(2000, 1, 4),
-        datetime(2000, 1, 4),
-        datetime(2000, 1, 5),
-    ]
-
-    return Series(np.random.randn(len(dates)), index=dates)
-
-
-def test_constructor(dups):
-    assert isinstance(dups, Series)
-    assert isinstance(dups.index, DatetimeIndex)
-
-
-def test_is_unique_monotonic(dups):
-    assert not dups.index.is_unique
-
-
-def test_index_unique(dups):
-    uniques = dups.index.unique()
-    expected = DatetimeIndex(
-        [
-            datetime(2000, 1, 2),
-            datetime(2000, 1, 3),
-            datetime(2000, 1, 4),
-            datetime(2000, 1, 5),
-        ]
-    )
-    assert uniques.dtype == "M8[ns]"  # sanity
-    tm.assert_index_equal(uniques, expected)
-    assert dups.index.nunique() == 4
-
-    # #2563
-    assert isinstance(uniques, DatetimeIndex)
-
-    dups_local = dups.index.tz_localize("US/Eastern")
-    dups_local.name = "foo"
-    result = dups_local.unique()
-    expected = DatetimeIndex(expected, name="foo")
-    expected = expected.tz_localize("US/Eastern")
-    assert result.tz is not None
-    assert result.name == "foo"
-    tm.assert_index_equal(result, expected)
-
-    # NaT, note this is excluded
-    arr = [1370745748 + t for t in range(20)] + [iNaT]
-    idx = DatetimeIndex(arr * 3)
-    tm.assert_index_equal(idx.unique(), DatetimeIndex(arr))
-    assert idx.nunique() == 20
-    assert idx.nunique(dropna=False) == 21
-
-    arr = [
-        Timestamp("2013-06-09 02:42:28") + timedelta(seconds=t) for t in range(20)
-    ] + [NaT]
-    idx = DatetimeIndex(arr * 3)
-    tm.assert_index_equal(idx.unique(), DatetimeIndex(arr))
-    assert idx.nunique() == 20
-    assert idx.nunique(dropna=False) == 21
-
-
-def test_duplicate_dates_indexing(dups):
-    ts = dups
+def test_indexing_with_duplicate_datetimeindex(
+    rand_series_with_duplicate_datetimeindex,
+):
+    ts = rand_series_with_duplicate_datetimeindex
 
     uniques = ts.index.unique()
     for date in uniques:
@@ -445,12 +370,6 @@ def test_duplicate_dates_indexing(dups):
     assert ts[datetime(2000, 1, 6)] == 0
 
 
-def test_groupby_average_dup_values(dups):
-    result = dups.groupby(level=0).mean()
-    expected = dups.groupby(dups.index).mean()
-    tm.assert_series_equal(result, expected)
-
-
 def test_indexing_over_size_cutoff(monkeypatch):
     # #1821
 
@@ -579,6 +498,8 @@ def test_indexing():
         result = df["2001"]["A"]
     tm.assert_series_equal(expected, result)
 
+
+def test_getitem_str_month_with_datetimeindex():
     # GH3546 (not including times on the last day)
     idx = date_range(start="2013-05-31 00:00", end="2013-05-31 23:00", freq="H")
     ts = Series(range(len(idx)), index=idx)
@@ -590,6 +511,8 @@ def test_indexing():
     expected = ts["2013-05"]
     tm.assert_series_equal(expected, ts)
 
+
+def test_getitem_str_year_with_datetimeindex():
     idx = [
         Timestamp("2013-05-31 00:00"),
         Timestamp(datetime(2013, 5, 31, 23, 59, 59, 999999)),
@@ -598,17 +521,19 @@ def test_indexing():
     expected = ts["2013"]
     tm.assert_series_equal(expected, ts)
 
+
+def test_getitem_str_second_with_datetimeindex():
     # GH14826, indexing with a seconds resolution string / datetime object
     df = DataFrame(
         np.random.rand(5, 5),
         columns=["open", "high", "low", "close", "volume"],
         index=date_range("2012-01-02 18:01:00", periods=5, tz="US/Central", freq="s"),
     )
-    expected = df.loc[[df.index[2]]]
 
     # this is a single date, so will raise
     with pytest.raises(KeyError, match=r"^'2012-01-02 18:01:02'$"):
         df["2012-01-02 18:01:02"]
+
     msg = r"Timestamp\('2012-01-02 18:01:02-0600', tz='US/Central', freq='S'\)"
     with pytest.raises(KeyError, match=msg):
         df[df.index[2]]

pandas/tests/series/indexing/test_indexing.py

@@ -546,64 +546,52 @@ def test_timedelta_assignment():
 
 
 @pytest.mark.parametrize(
-    "nat_val,should_cast",
+    "nat_val",
     [
-        (pd.NaT, True),
-        (np.timedelta64("NaT", "ns"), False),
-        (np.datetime64("NaT", "ns"), True),
+        pd.NaT,
+        np.timedelta64("NaT", "ns"),
+        np.datetime64("NaT", "ns"),
     ],
 )
 @pytest.mark.parametrize("tz", [None, "UTC"])
-def test_dt64_series_assign_nat(nat_val, should_cast, tz):
+def test_dt64_series_assign_nat(nat_val, tz, indexer_sli):
     # some nat-like values should be cast to datetime64 when inserting
     #  into a datetime64 series.  Others should coerce to object
     #  and retain their dtypes.
     dti = pd.date_range("2016-01-01", periods=3, tz=tz)
     base = Series(dti)
     expected = Series([pd.NaT] + list(dti[1:]), dtype=dti.dtype)
+
+    should_cast = nat_val is pd.NaT or base.dtype.kind == nat_val.dtype.kind
     if not should_cast:
         expected = expected.astype(object)
 
     ser = base.copy(deep=True)
-    ser[0] = nat_val
-    tm.assert_series_equal(ser, expected)
-
-    ser = base.copy(deep=True)
-    ser.loc[0] = nat_val
-    tm.assert_series_equal(ser, expected)
-
-    ser = base.copy(deep=True)
-    ser.iloc[0] = nat_val
+    indexer_sli(ser)[0] = nat_val
     tm.assert_series_equal(ser, expected)
 
 
 @pytest.mark.parametrize(
-    "nat_val,should_cast",
+    "nat_val",
     [
-        (pd.NaT, True),
-        (np.timedelta64("NaT", "ns"), True),
-        (np.datetime64("NaT", "ns"), False),
+        pd.NaT,
+        np.timedelta64("NaT", "ns"),
+        np.datetime64("NaT", "ns"),
     ],
 )
-def test_td64_series_assign_nat(nat_val, should_cast):
+def test_td64_series_assign_nat(nat_val, indexer_sli):
     # some nat-like values should be cast to timedelta64 when inserting
     #  into a timedelta64 series.  Others should coerce to object
     #  and retain their dtypes.
     base = Series([0, 1, 2], dtype="m8[ns]")
     expected = Series([pd.NaT, 1, 2], dtype="m8[ns]")
+
+    should_cast = nat_val is pd.NaT or base.dtype == nat_val.dtype
     if not should_cast:
         expected = expected.astype(object)
 
     ser = base.copy(deep=True)
-    ser[0] = nat_val
-    tm.assert_series_equal(ser, expected)
-
-    ser = base.copy(deep=True)
-    ser.loc[0] = nat_val
-    tm.assert_series_equal(ser, expected)
-
-    ser = base.copy(deep=True)
-    ser.iloc[0] = nat_val
+    indexer_sli(ser)[0] = nat_val
     tm.assert_series_equal(ser, expected)
 
 

pandas/tests/series/test_constructors.py

@@ -1672,3 +1672,9 @@ def test_from_list_dtype(self):
 
         result = Series(["2015"], dtype="datetime64[ns]")
         assert result._mgr.blocks[0].is_extension is False
+
+
+def test_constructor(rand_series_with_duplicate_datetimeindex):
+    dups = rand_series_with_duplicate_datetimeindex
+    assert isinstance(dups, Series)
+    assert isinstance(dups.index, DatetimeIndex)