organize DTI indexing tests (#31753)

pandas/tests/indexes/datetimes/test_constructors.py

@@ -950,3 +950,12 @@ def test_datetimeindex_constructor_misc(self):
         )
         assert len(idx1) == len(idx2)
         assert idx1.freq == idx2.freq
+
+    def test_pass_datetimeindex_to_index(self):
+        # Bugs in #1396
+        rng = date_range("1/1/2000", "3/1/2000")
+        idx = Index(rng, dtype=object)
+
+        expected = Index(rng.to_pydatetime(), dtype=object)
+
+        tm.assert_numpy_array_equal(idx.values, expected.values)

pandas/tests/indexes/datetimes/test_indexing.py

@@ -344,6 +344,115 @@ def test_take_fill_value_with_timezone(self):
             idx.take(np.array([1, -5]))
 
 
+class TestGetLoc:
+    @pytest.mark.parametrize("method", [None, "pad", "backfill", "nearest"])
+    def test_get_loc_method_exact_match(self, method):
+        idx = pd.date_range("2000-01-01", periods=3)
+        assert idx.get_loc(idx[1], method) == 1
+        assert idx.get_loc(idx[1].to_pydatetime(), method) == 1
+        assert idx.get_loc(str(idx[1]), method) == 1
+
+        if method is not None:
+            assert idx.get_loc(idx[1], method, tolerance=pd.Timedelta("0 days")) == 1
+
+    def test_get_loc(self):
+        idx = pd.date_range("2000-01-01", periods=3)
+
+        assert idx.get_loc("2000-01-01", method="nearest") == 0
+        assert idx.get_loc("2000-01-01T12", method="nearest") == 1
+
+        assert idx.get_loc("2000-01-01T12", method="nearest", tolerance="1 day") == 1
+        assert (
+            idx.get_loc("2000-01-01T12", method="nearest", tolerance=pd.Timedelta("1D"))
+            == 1
+        )
+        assert (
+            idx.get_loc(
+                "2000-01-01T12", method="nearest", tolerance=np.timedelta64(1, "D")
+            )
+            == 1
+        )
+        assert (
+            idx.get_loc("2000-01-01T12", method="nearest", tolerance=timedelta(1)) == 1
+        )
+        with pytest.raises(ValueError, match="unit abbreviation w/o a number"):
+            idx.get_loc("2000-01-01T12", method="nearest", tolerance="foo")
+        with pytest.raises(KeyError, match="'2000-01-01T03'"):
+            idx.get_loc("2000-01-01T03", method="nearest", tolerance="2 hours")
+        with pytest.raises(
+            ValueError, match="tolerance size must match target index size"
+        ):
+            idx.get_loc(
+                "2000-01-01",
+                method="nearest",
+                tolerance=[
+                    pd.Timedelta("1day").to_timedelta64(),
+                    pd.Timedelta("1day").to_timedelta64(),
+                ],
+            )
+
+        assert idx.get_loc("2000", method="nearest") == slice(0, 3)
+        assert idx.get_loc("2000-01", method="nearest") == slice(0, 3)
+
+        assert idx.get_loc("1999", method="nearest") == 0
+        assert idx.get_loc("2001", method="nearest") == 2
+
+        with pytest.raises(KeyError, match="'1999'"):
+            idx.get_loc("1999", method="pad")
+        with pytest.raises(KeyError, match="'2001'"):
+            idx.get_loc("2001", method="backfill")
+
+        with pytest.raises(KeyError, match="'foobar'"):
+            idx.get_loc("foobar")
+        with pytest.raises(InvalidIndexError, match=r"slice\(None, 2, None\)"):
+            idx.get_loc(slice(2))
+
+        idx = pd.to_datetime(["2000-01-01", "2000-01-04"])
+        assert idx.get_loc("2000-01-02", method="nearest") == 0
+        assert idx.get_loc("2000-01-03", method="nearest") == 1
+        assert idx.get_loc("2000-01", method="nearest") == slice(0, 2)
+
+        # time indexing
+        idx = pd.date_range("2000-01-01", periods=24, freq="H")
+        tm.assert_numpy_array_equal(
+            idx.get_loc(time(12)), np.array([12]), check_dtype=False
+        )
+        tm.assert_numpy_array_equal(
+            idx.get_loc(time(12, 30)), np.array([]), check_dtype=False
+        )
+        with pytest.raises(NotImplementedError):
+            idx.get_loc(time(12, 30), method="pad")
+
+    def test_get_loc_nat(self):
+        # GH#20464
+        index = DatetimeIndex(["1/3/2000", "NaT"])
+        assert index.get_loc(pd.NaT) == 1
+
+        assert index.get_loc(None) == 1
+
+        assert index.get_loc(np.nan) == 1
+
+        assert index.get_loc(pd.NA) == 1
+
+        assert index.get_loc(np.datetime64("NaT")) == 1
+
+        with pytest.raises(KeyError, match="NaT"):
+            index.get_loc(np.timedelta64("NaT"))
+
+    @pytest.mark.parametrize("key", [pd.Timedelta(0), pd.Timedelta(1), timedelta(0)])
+    def test_get_loc_timedelta_invalid_key(self, key):
+        # GH#20464
+        dti = pd.date_range("1970-01-01", periods=10)
+        with pytest.raises(TypeError):
+            dti.get_loc(key)
+
+    def test_get_loc_reasonable_key_error(self):
+        # GH#1062
+        index = DatetimeIndex(["1/3/2000"])
+        with pytest.raises(KeyError, match="2000"):
+            index.get_loc("1/1/2000")
+
+
 class TestDatetimeIndex:
     @pytest.mark.parametrize(
         "null", [None, np.nan, np.datetime64("NaT"), pd.NaT, pd.NA]
@@ -639,84 +748,6 @@ def test_get_value(self):
         result = dti.get_value(ser, key.to_datetime64())
         assert result == 7
 
-    def test_get_loc(self):
-        idx = pd.date_range("2000-01-01", periods=3)
-
-        for method in [None, "pad", "backfill", "nearest"]:
-            assert idx.get_loc(idx[1], method) == 1
-            assert idx.get_loc(idx[1].to_pydatetime(), method) == 1
-            assert idx.get_loc(str(idx[1]), method) == 1
-
-            if method is not None:
-                assert (
-                    idx.get_loc(idx[1], method, tolerance=pd.Timedelta("0 days")) == 1
-                )
-
-        assert idx.get_loc("2000-01-01", method="nearest") == 0
-        assert idx.get_loc("2000-01-01T12", method="nearest") == 1
-
-        assert idx.get_loc("2000-01-01T12", method="nearest", tolerance="1 day") == 1
-        assert (
-            idx.get_loc("2000-01-01T12", method="nearest", tolerance=pd.Timedelta("1D"))
-            == 1
-        )
-        assert (
-            idx.get_loc(
-                "2000-01-01T12", method="nearest", tolerance=np.timedelta64(1, "D")
-            )
-            == 1
-        )
-        assert (
-            idx.get_loc("2000-01-01T12", method="nearest", tolerance=timedelta(1)) == 1
-        )
-        with pytest.raises(ValueError, match="unit abbreviation w/o a number"):
-            idx.get_loc("2000-01-01T12", method="nearest", tolerance="foo")
-        with pytest.raises(KeyError, match="'2000-01-01T03'"):
-            idx.get_loc("2000-01-01T03", method="nearest", tolerance="2 hours")
-        with pytest.raises(
-            ValueError, match="tolerance size must match target index size"
-        ):
-            idx.get_loc(
-                "2000-01-01",
-                method="nearest",
-                tolerance=[
-                    pd.Timedelta("1day").to_timedelta64(),
-                    pd.Timedelta("1day").to_timedelta64(),
-                ],
-            )
-
-        assert idx.get_loc("2000", method="nearest") == slice(0, 3)
-        assert idx.get_loc("2000-01", method="nearest") == slice(0, 3)
-
-        assert idx.get_loc("1999", method="nearest") == 0
-        assert idx.get_loc("2001", method="nearest") == 2
-
-        with pytest.raises(KeyError, match="'1999'"):
-            idx.get_loc("1999", method="pad")
-        with pytest.raises(KeyError, match="'2001'"):
-            idx.get_loc("2001", method="backfill")
-
-        with pytest.raises(KeyError, match="'foobar'"):
-            idx.get_loc("foobar")
-        with pytest.raises(InvalidIndexError, match=r"slice\(None, 2, None\)"):
-            idx.get_loc(slice(2))
-
-        idx = pd.to_datetime(["2000-01-01", "2000-01-04"])
-        assert idx.get_loc("2000-01-02", method="nearest") == 0
-        assert idx.get_loc("2000-01-03", method="nearest") == 1
-        assert idx.get_loc("2000-01", method="nearest") == slice(0, 2)
-
-        # time indexing
-        idx = pd.date_range("2000-01-01", periods=24, freq="H")
-        tm.assert_numpy_array_equal(
-            idx.get_loc(time(12)), np.array([12]), check_dtype=False
-        )
-        tm.assert_numpy_array_equal(
-            idx.get_loc(time(12, 30)), np.array([]), check_dtype=False
-        )
-        with pytest.raises(NotImplementedError):
-            idx.get_loc(time(12, 30), method="pad")
-
     def test_get_indexer(self):
         idx = pd.date_range("2000-01-01", periods=3)
         exp = np.array([0, 1, 2], dtype=np.intp)
@@ -756,32 +787,3 @@ def test_get_indexer(self):
             idx.get_indexer(target, "nearest", tolerance=tol_bad)
         with pytest.raises(ValueError):
             idx.get_indexer(idx[[0]], method="nearest", tolerance="foo")
-
-    def test_reasonable_key_error(self):
-        # GH#1062
-        index = DatetimeIndex(["1/3/2000"])
-        with pytest.raises(KeyError, match="2000"):
-            index.get_loc("1/1/2000")
-
-    @pytest.mark.parametrize("key", [pd.Timedelta(0), pd.Timedelta(1), timedelta(0)])
-    def test_timedelta_invalid_key(self, key):
-        # GH#20464
-        dti = pd.date_range("1970-01-01", periods=10)
-        with pytest.raises(TypeError):
-            dti.get_loc(key)
-
-    def test_get_loc_nat(self):
-        # GH#20464
-        index = DatetimeIndex(["1/3/2000", "NaT"])
-        assert index.get_loc(pd.NaT) == 1
-
-        assert index.get_loc(None) == 1
-
-        assert index.get_loc(np.nan) == 1
-
-        assert index.get_loc(pd.NA) == 1
-
-        assert index.get_loc(np.datetime64("NaT")) == 1
-
-        with pytest.raises(KeyError, match="NaT"):
-            index.get_loc(np.timedelta64("NaT"))

pandas/tests/indexes/datetimes/test_misc.py

@@ -12,15 +12,6 @@
 
 
 class TestTimeSeries:
-    def test_pass_datetimeindex_to_index(self):
-        # Bugs in #1396
-        rng = date_range("1/1/2000", "3/1/2000")
-        idx = Index(rng, dtype=object)
-
-        expected = Index(rng.to_pydatetime(), dtype=object)
-
-        tm.assert_numpy_array_equal(idx.values, expected.values)
-
     def test_range_edges(self):
         # GH#13672
         idx = pd.date_range(