REF/TST: collect Index join tests (pandas-dev#32171)

Author: jbrockmendel

pandas/tests/indexes/datetimes/test_date_range.py

@@ -759,17 +759,6 @@ def test_constructor(self):
         with pytest.raises(TypeError, match=msg):
             bdate_range(START, END, periods=10, freq=None)
 
-    def test_naive_aware_conflicts(self):
-        naive = bdate_range(START, END, freq=BDay(), tz=None)
-        aware = bdate_range(START, END, freq=BDay(), tz="Asia/Hong_Kong")
-
-        msg = "tz-naive.*tz-aware"
-        with pytest.raises(TypeError, match=msg):
-            naive.join(aware)
-
-        with pytest.raises(TypeError, match=msg):
-            aware.join(naive)
-
     def test_misc(self):
         end = datetime(2009, 5, 13)
         dr = bdate_range(end=end, periods=20)

pandas/tests/indexes/datetimes/test_datetime.py

@@ -100,16 +100,13 @@ def test_stringified_slice_with_tz(self):
         df = DataFrame(np.arange(10), index=idx)
         df["2013-01-14 23:44:34.437768-05:00":]  # no exception here
 
-    def test_append_join_nondatetimeindex(self):
+    def test_append_nondatetimeindex(self):
         rng = date_range("1/1/2000", periods=10)
         idx = Index(["a", "b", "c", "d"])
 
         result = rng.append(idx)
         assert isinstance(result[0], Timestamp)
 
-        # it works
-        rng.join(idx, how="outer")
-
     def test_map(self):
         rng = date_range("1/1/2000", periods=10)
 
@@ -246,25 +243,6 @@ def test_isin(self):
             index.isin([index[2], 5]), np.array([False, False, True, False])
         )
 
-    def test_does_not_convert_mixed_integer(self):
-        df = tm.makeCustomDataframe(
-            10,
-            10,
-            data_gen_f=lambda *args, **kwargs: randn(),
-            r_idx_type="i",
-            c_idx_type="dt",
-        )
-        cols = df.columns.join(df.index, how="outer")
-        joined = cols.join(df.columns)
-        assert cols.dtype == np.dtype("O")
-        assert cols.dtype == joined.dtype
-        tm.assert_numpy_array_equal(cols.values, joined.values)
-
-    def test_join_self(self, join_type):
-        index = date_range("1/1/2000", periods=10)
-        joined = index.join(index, how=join_type)
-        assert index is joined
-
     def assert_index_parameters(self, index):
         assert index.freq == "40960N"
         assert index.inferred_freq == "40960N"
@@ -282,20 +260,6 @@ def test_ns_index(self):
         new_index = pd.date_range(start=index[0], end=index[-1], freq=index.freq)
         self.assert_index_parameters(new_index)
 
-    def test_join_with_period_index(self, join_type):
-        df = tm.makeCustomDataframe(
-            10,
-            10,
-            data_gen_f=lambda *args: np.random.randint(2),
-            c_idx_type="p",
-            r_idx_type="dt",
-        )
-        s = df.iloc[:5, 0]
-
-        expected = df.columns.astype("O").join(s.index, how=join_type)
-        result = df.columns.join(s.index, how=join_type)
-        tm.assert_index_equal(expected, result)
-
     def test_factorize(self):
         idx1 = DatetimeIndex(
             ["2014-01", "2014-01", "2014-02", "2014-02", "2014-03", "2014-03"]

pandas/tests/indexes/datetimes/test_join.py

@@ -0,0 +1,131 @@
+from datetime import datetime
+
+import numpy as np
+import pytest
+
+from pandas import DatetimeIndex, Index, Timestamp, date_range, to_datetime
+import pandas._testing as tm
+
+from pandas.tseries.offsets import BDay, BMonthEnd
+
+
+class TestJoin:
+    def test_does_not_convert_mixed_integer(self):
+        df = tm.makeCustomDataframe(
+            10,
+            10,
+            data_gen_f=lambda *args, **kwargs: np.random.randn(),
+            r_idx_type="i",
+            c_idx_type="dt",
+        )
+        cols = df.columns.join(df.index, how="outer")
+        joined = cols.join(df.columns)
+        assert cols.dtype == np.dtype("O")
+        assert cols.dtype == joined.dtype
+        tm.assert_numpy_array_equal(cols.values, joined.values)
+
+    def test_join_self(self, join_type):
+        index = date_range("1/1/2000", periods=10)
+        joined = index.join(index, how=join_type)
+        assert index is joined
+
+    def test_join_with_period_index(self, join_type):
+        df = tm.makeCustomDataframe(
+            10,
+            10,
+            data_gen_f=lambda *args: np.random.randint(2),
+            c_idx_type="p",
+            r_idx_type="dt",
+        )
+        s = df.iloc[:5, 0]
+
+        expected = df.columns.astype("O").join(s.index, how=join_type)
+        result = df.columns.join(s.index, how=join_type)
+        tm.assert_index_equal(expected, result)
+
+    def test_join_object_index(self):
+        rng = date_range("1/1/2000", periods=10)
+        idx = Index(["a", "b", "c", "d"])
+
+        result = rng.join(idx, how="outer")
+        assert isinstance(result[0], Timestamp)
+
+    def test_join_utc_convert(self, join_type):
+        rng = date_range("1/1/2011", periods=100, freq="H", tz="utc")
+
+        left = rng.tz_convert("US/Eastern")
+        right = rng.tz_convert("Europe/Berlin")
+
+        result = left.join(left[:-5], how=join_type)
+        assert isinstance(result, DatetimeIndex)
+        assert result.tz == left.tz
+
+        result = left.join(right[:-5], how=join_type)
+        assert isinstance(result, DatetimeIndex)
+        assert result.tz.zone == "UTC"
+
+    @pytest.mark.parametrize("sort", [None, False])
+    def test_datetimeindex_union_join_empty(self, sort):
+        dti = date_range(start="1/1/2001", end="2/1/2001", freq="D")
+        empty = Index([])
+
+        result = dti.union(empty, sort=sort)
+        expected = dti.astype("O")
+        tm.assert_index_equal(result, expected)
+
+        result = dti.join(empty)
+        assert isinstance(result, DatetimeIndex)
+        tm.assert_index_equal(result, dti)
+
+    def test_join_nonunique(self):
+        idx1 = to_datetime(["2012-11-06 16:00:11.477563", "2012-11-06 16:00:11.477563"])
+        idx2 = to_datetime(["2012-11-06 15:11:09.006507", "2012-11-06 15:11:09.006507"])
+        rs = idx1.join(idx2, how="outer")
+        assert rs.is_monotonic
+
+    @pytest.mark.parametrize("freq", ["B", "C"])
+    def test_outer_join(self, freq):
+        # should just behave as union
+        start, end = datetime(2009, 1, 1), datetime(2010, 1, 1)
+        rng = date_range(start=start, end=end, freq=freq)
+
+        # overlapping
+        left = rng[:10]
+        right = rng[5:10]
+
+        the_join = left.join(right, how="outer")
+        assert isinstance(the_join, DatetimeIndex)
+
+        # non-overlapping, gap in middle
+        left = rng[:5]
+        right = rng[10:]
+
+        the_join = left.join(right, how="outer")
+        assert isinstance(the_join, DatetimeIndex)
+        assert the_join.freq is None
+
+        # non-overlapping, no gap
+        left = rng[:5]
+        right = rng[5:10]
+
+        the_join = left.join(right, how="outer")
+        assert isinstance(the_join, DatetimeIndex)
+
+        # overlapping, but different offset
+        other = date_range(start, end, freq=BMonthEnd())
+
+        the_join = rng.join(other, how="outer")
+        assert isinstance(the_join, DatetimeIndex)
+        assert the_join.freq is None
+
+    def test_naive_aware_conflicts(self):
+        start, end = datetime(2009, 1, 1), datetime(2010, 1, 1)
+        naive = date_range(start, end, freq=BDay(), tz=None)
+        aware = date_range(start, end, freq=BDay(), tz="Asia/Hong_Kong")
+
+        msg = "tz-naive.*tz-aware"
+        with pytest.raises(TypeError, match=msg):
+            naive.join(aware)
+
+        with pytest.raises(TypeError, match=msg):
+            aware.join(naive)

pandas/tests/indexes/datetimes/test_setops.py

@@ -14,7 +14,6 @@
     Series,
     bdate_range,
     date_range,
-    to_datetime,
 )
 import pandas._testing as tm
 
@@ -348,25 +347,6 @@ def test_datetimeindex_diff(self, sort):
         dti2 = date_range(freq="Q-JAN", start=datetime(1997, 12, 31), periods=98)
         assert len(dti1.difference(dti2, sort)) == 2
 
-    @pytest.mark.parametrize("sort", [None, False])
-    def test_datetimeindex_union_join_empty(self, sort):
-        dti = date_range(start="1/1/2001", end="2/1/2001", freq="D")
-        empty = Index([])
-
-        result = dti.union(empty, sort=sort)
-        expected = dti.astype("O")
-        tm.assert_index_equal(result, expected)
-
-        result = dti.join(empty)
-        assert isinstance(result, DatetimeIndex)
-        tm.assert_index_equal(result, dti)
-
-    def test_join_nonunique(self):
-        idx1 = to_datetime(["2012-11-06 16:00:11.477563", "2012-11-06 16:00:11.477563"])
-        idx2 = to_datetime(["2012-11-06 15:11:09.006507", "2012-11-06 15:11:09.006507"])
-        rs = idx1.join(idx2, how="outer")
-        assert rs.is_monotonic
-
 
 class TestBusinessDatetimeIndex:
     def setup_method(self, method):
@@ -408,38 +388,6 @@ def test_union(self, sort):
         the_union = self.rng.union(rng, sort=sort)
         assert isinstance(the_union, DatetimeIndex)
 
-    def test_outer_join(self):
-        # should just behave as union
-
-        # overlapping
-        left = self.rng[:10]
-        right = self.rng[5:10]
-
-        the_join = left.join(right, how="outer")
-        assert isinstance(the_join, DatetimeIndex)
-
-        # non-overlapping, gap in middle
-        left = self.rng[:5]
-        right = self.rng[10:]
-
-        the_join = left.join(right, how="outer")
-        assert isinstance(the_join, DatetimeIndex)
-        assert the_join.freq is None
-
-        # non-overlapping, no gap
-        left = self.rng[:5]
-        right = self.rng[5:10]
-
-        the_join = left.join(right, how="outer")
-        assert isinstance(the_join, DatetimeIndex)
-
-        # overlapping, but different offset
-        rng = date_range(START, END, freq=BMonthEnd())
-
-        the_join = self.rng.join(rng, how="outer")
-        assert isinstance(the_join, DatetimeIndex)
-        assert the_join.freq is None
-
     @pytest.mark.parametrize("sort", [None, False])
     def test_union_not_cacheable(self, sort):
         rng = date_range("1/1/2000", periods=50, freq=Minute())
@@ -556,38 +504,6 @@ def test_union(self, sort):
         the_union = self.rng.union(rng, sort=sort)
         assert isinstance(the_union, DatetimeIndex)
 
-    def test_outer_join(self):
-        # should just behave as union
-
-        # overlapping
-        left = self.rng[:10]
-        right = self.rng[5:10]
-
-        the_join = left.join(right, how="outer")
-        assert isinstance(the_join, DatetimeIndex)
-
-        # non-overlapping, gap in middle
-        left = self.rng[:5]
-        right = self.rng[10:]
-
-        the_join = left.join(right, how="outer")
-        assert isinstance(the_join, DatetimeIndex)
-        assert the_join.freq is None
-
-        # non-overlapping, no gap
-        left = self.rng[:5]
-        right = self.rng[5:10]
-
-        the_join = left.join(right, how="outer")
-        assert isinstance(the_join, DatetimeIndex)
-
-        # overlapping, but different offset
-        rng = date_range(START, END, freq=BMonthEnd())
-
-        the_join = self.rng.join(rng, how="outer")
-        assert isinstance(the_join, DatetimeIndex)
-        assert the_join.freq is None
-
     def test_intersection_bug(self):
         # GH #771
         a = bdate_range("11/30/2011", "12/31/2011", freq="C")

pandas/tests/indexes/datetimes/test_timezones.py

@@ -804,20 +804,6 @@ def test_dti_tz_constructors(self, tzstr):
     # -------------------------------------------------------------
     # Unsorted
 
-    def test_join_utc_convert(self, join_type):
-        rng = date_range("1/1/2011", periods=100, freq="H", tz="utc")
-
-        left = rng.tz_convert("US/Eastern")
-        right = rng.tz_convert("Europe/Berlin")
-
-        result = left.join(left[:-5], how=join_type)
-        assert isinstance(result, DatetimeIndex)
-        assert result.tz == left.tz
-
-        result = left.join(right[:-5], how=join_type)
-        assert isinstance(result, DatetimeIndex)
-        assert result.tz.zone == "UTC"
-
     @pytest.mark.parametrize(
         "dtype",
         [None, "datetime64[ns, CET]", "datetime64[ns, EST]", "datetime64[ns, UTC]"],