TST/REF: collect tests by method (pandas-dev#37315)

Author: jbrockmendel

pandas/tests/frame/methods/test_values.py

@@ -1,6 +1,6 @@
 import numpy as np
 
-from pandas import DataFrame, Timestamp, date_range
+from pandas import DataFrame, NaT, Timestamp, date_range
 import pandas._testing as tm
 
 
@@ -51,3 +51,54 @@ def test_frame_values_with_tz(self):
         expected = np.concatenate([expected, new], axis=1)
         result = df.values
         tm.assert_numpy_array_equal(result, expected)
+
+    def test_interleave_with_tzaware(self, timezone_frame):
+
+        # interleave with object
+        result = timezone_frame.assign(D="foo").values
+        expected = np.array(
+            [
+                [
+                    Timestamp("2013-01-01 00:00:00"),
+                    Timestamp("2013-01-02 00:00:00"),
+                    Timestamp("2013-01-03 00:00:00"),
+                ],
+                [
+                    Timestamp("2013-01-01 00:00:00-0500", tz="US/Eastern"),
+                    NaT,
+                    Timestamp("2013-01-03 00:00:00-0500", tz="US/Eastern"),
+                ],
+                [
+                    Timestamp("2013-01-01 00:00:00+0100", tz="CET"),
+                    NaT,
+                    Timestamp("2013-01-03 00:00:00+0100", tz="CET"),
+                ],
+                ["foo", "foo", "foo"],
+            ],
+            dtype=object,
+        ).T
+        tm.assert_numpy_array_equal(result, expected)
+
+        # interleave with only datetime64[ns]
+        result = timezone_frame.values
+        expected = np.array(
+            [
+                [
+                    Timestamp("2013-01-01 00:00:00"),
+                    Timestamp("2013-01-02 00:00:00"),
+                    Timestamp("2013-01-03 00:00:00"),
+                ],
+                [
+                    Timestamp("2013-01-01 00:00:00-0500", tz="US/Eastern"),
+                    NaT,
+                    Timestamp("2013-01-03 00:00:00-0500", tz="US/Eastern"),
+                ],
+                [
+                    Timestamp("2013-01-01 00:00:00+0100", tz="CET"),
+                    NaT,
+                    Timestamp("2013-01-03 00:00:00+0100", tz="CET"),
+                ],
+            ],
+            dtype=object,
+        ).T
+        tm.assert_numpy_array_equal(result, expected)

pandas/tests/frame/test_dtypes.py

@@ -6,7 +6,7 @@
 from pandas.core.dtypes.dtypes import DatetimeTZDtype
 
 import pandas as pd
-from pandas import DataFrame, Series, Timestamp, date_range, option_context
+from pandas import DataFrame, Series, date_range, option_context
 import pandas._testing as tm
 
 
@@ -18,22 +18,6 @@ def _check_cast(df, v):
 
 
 class TestDataFrameDataTypes:
-    def test_concat_empty_dataframe_dtypes(self):
-        df = DataFrame(columns=list("abc"))
-        df["a"] = df["a"].astype(np.bool_)
-        df["b"] = df["b"].astype(np.int32)
-        df["c"] = df["c"].astype(np.float64)
-
-        result = pd.concat([df, df])
-        assert result["a"].dtype == np.bool_
-        assert result["b"].dtype == np.int32
-        assert result["c"].dtype == np.float64
-
-        result = pd.concat([df, df.astype(np.float64)])
-        assert result["a"].dtype == np.object_
-        assert result["b"].dtype == np.float64
-        assert result["c"].dtype == np.float64
-
     def test_empty_frame_dtypes(self):
         empty_df = DataFrame()
         tm.assert_series_equal(empty_df.dtypes, Series(dtype=object))
@@ -244,56 +228,3 @@ def test_str_to_small_float_conversion_type(self):
         result.loc[result.index, "A"] = [float(x) for x in col_data]
         expected = DataFrame(col_data, columns=["A"], dtype=float)
         tm.assert_frame_equal(result, expected)
-
-
-class TestDataFrameDatetimeWithTZ:
-    def test_interleave(self, timezone_frame):
-
-        # interleave with object
-        result = timezone_frame.assign(D="foo").values
-        expected = np.array(
-            [
-                [
-                    Timestamp("2013-01-01 00:00:00"),
-                    Timestamp("2013-01-02 00:00:00"),
-                    Timestamp("2013-01-03 00:00:00"),
-                ],
-                [
-                    Timestamp("2013-01-01 00:00:00-0500", tz="US/Eastern"),
-                    pd.NaT,
-                    Timestamp("2013-01-03 00:00:00-0500", tz="US/Eastern"),
-                ],
-                [
-                    Timestamp("2013-01-01 00:00:00+0100", tz="CET"),
-                    pd.NaT,
-                    Timestamp("2013-01-03 00:00:00+0100", tz="CET"),
-                ],
-                ["foo", "foo", "foo"],
-            ],
-            dtype=object,
-        ).T
-        tm.assert_numpy_array_equal(result, expected)
-
-        # interleave with only datetime64[ns]
-        result = timezone_frame.values
-        expected = np.array(
-            [
-                [
-                    Timestamp("2013-01-01 00:00:00"),
-                    Timestamp("2013-01-02 00:00:00"),
-                    Timestamp("2013-01-03 00:00:00"),
-                ],
-                [
-                    Timestamp("2013-01-01 00:00:00-0500", tz="US/Eastern"),
-                    pd.NaT,
-                    Timestamp("2013-01-03 00:00:00-0500", tz="US/Eastern"),
-                ],
-                [
-                    Timestamp("2013-01-01 00:00:00+0100", tz="CET"),
-                    pd.NaT,
-                    Timestamp("2013-01-03 00:00:00+0100", tz="CET"),
-                ],
-            ],
-            dtype=object,
-        ).T
-        tm.assert_numpy_array_equal(result, expected)

pandas/tests/reshape/test_concat.py

@@ -2604,6 +2604,22 @@ def test_concat_odered_dict(self):
         )
         tm.assert_series_equal(result, expected)
 
+    def test_concat_empty_dataframe_dtypes(self):
+        df = DataFrame(columns=list("abc"))
+        df["a"] = df["a"].astype(np.bool_)
+        df["b"] = df["b"].astype(np.int32)
+        df["c"] = df["c"].astype(np.float64)
+
+        result = pd.concat([df, df])
+        assert result["a"].dtype == np.bool_
+        assert result["b"].dtype == np.int32
+        assert result["c"].dtype == np.float64
+
+        result = pd.concat([df, df.astype(np.float64)])
+        assert result["a"].dtype == np.object_
+        assert result["b"].dtype == np.float64
+        assert result["c"].dtype == np.float64
+
 
 @pytest.mark.parametrize("pdt", [Series, pd.DataFrame])
 @pytest.mark.parametrize("dt", np.sctypes["float"])

pandas/tests/series/indexing/test_setitem.py

@@ -1,7 +1,9 @@
+from datetime import date
+
 import numpy as np
 import pytest
 
-from pandas import MultiIndex, NaT, Series, date_range, period_range
+from pandas import MultiIndex, NaT, Series, Timestamp, date_range, period_range
 import pandas.testing as tm
 
 
@@ -28,6 +30,26 @@ def test_setitem_multiindex_empty_slice(self):
         result.loc[[]] = 0
         tm.assert_series_equal(result, expected)
 
+    def test_setitem_with_string_index(self):
+        # GH#23451
+        ser = Series([1, 2, 3], index=["Date", "b", "other"])
+        ser["Date"] = date.today()
+        assert ser.Date == date.today()
+        assert ser["Date"] == date.today()
+
+    def test_setitem_with_different_tz_casts_to_object(self):
+        # GH#24024
+        ser = Series(date_range("2000", periods=2, tz="US/Central"))
+        ser[0] = Timestamp("2000", tz="US/Eastern")
+        expected = Series(
+            [
+                Timestamp("2000-01-01 00:00:00-05:00", tz="US/Eastern"),
+                Timestamp("2000-01-02 00:00:00-06:00", tz="US/Central"),
+            ],
+            dtype=object,
+        )
+        tm.assert_series_equal(ser, expected)
+
 
 class TestSetitemPeriodDtype:
     @pytest.mark.parametrize("na_val", [None, np.nan])

pandas/tests/series/test_datetime_values.py renamed to pandas/tests/series/test_dt_accessor.py

@@ -655,26 +655,6 @@ def test_dt_timetz_accessor(self, tz_naive_fixture):
         result = s.dt.timetz
         tm.assert_series_equal(result, expected)
 
-    def test_setitem_with_string_index(self):
-        # GH 23451
-        x = Series([1, 2, 3], index=["Date", "b", "other"])
-        x["Date"] = date.today()
-        assert x.Date == date.today()
-        assert x["Date"] == date.today()
-
-    def test_setitem_with_different_tz(self):
-        # GH#24024
-        ser = Series(pd.date_range("2000", periods=2, tz="US/Central"))
-        ser[0] = pd.Timestamp("2000", tz="US/Eastern")
-        expected = Series(
-            [
-                pd.Timestamp("2000-01-01 00:00:00-05:00", tz="US/Eastern"),
-                pd.Timestamp("2000-01-02 00:00:00-06:00", tz="US/Central"),
-            ],
-            dtype=object,
-        )
-        tm.assert_series_equal(ser, expected)
-
     @pytest.mark.parametrize(
         "input_series, expected_output",
         [