adjust some tests

Author: MarcoGorelli

pandas/tests/apply/test_frame_apply.py

@@ -836,7 +836,8 @@ def test_with_dictlike_columns_with_datetime():
     df["author"] = ["X", "Y", "Z"]
     df["publisher"] = ["BBC", "NBC", "N24"]
     df["date"] = pd.to_datetime(
-        ["17-10-2010 07:15:30", "13-05-2011 08:20:35", "15-01-2013 09:09:09"]
+        ["17-10-2010 07:15:30", "13-05-2011 08:20:35", "15-01-2013 09:09:09"],
+        dayfirst=True,
     )
     result = df.apply(lambda x: {}, axis=1)
     expected = Series([{}, {}, {}])

pandas/tests/arrays/sparse/test_array.py

@@ -351,7 +351,7 @@ def test_nbytes_block(self):
         assert result == 24
 
     def test_asarray_datetime64(self):
-        s = SparseArray(pd.to_datetime(["2012", None, None, "2013"]))
+        s = SparseArray(pd.to_datetime(["2012-01-01", None, None, "2013-01-01"]))
         np.asarray(s)
 
     def test_density(self):

pandas/tests/frame/methods/test_drop.py

@@ -405,11 +405,11 @@ def test_drop_level_nonunique_datetime(self):
         idx = Index([2, 3, 4, 4, 5], name="id")
         idxdt = pd.to_datetime(
             [
-                "201603231400",
-                "201603231500",
-                "201603231600",
-                "201603231600",
-                "201603231700",
+                "2016-03-23 14:00",
+                "2016-03-23 15:00",
+                "2016-03-23 16:00",
+                "2016-03-23 16:00",
+                "2016-03-23 17:00",
             ]
         )
         df = DataFrame(np.arange(10).reshape(5, 2), columns=list("ab"), index=idx)

pandas/tests/frame/methods/test_to_csv.py

@@ -27,7 +27,7 @@
 
 class TestDataFrameToCSV:
     def read_csv(self, path, **kwargs):
-        params = {"index_col": 0, "parse_dates": True}
+        params = {"index_col": 0}
         params.update(**kwargs)
 
         return read_csv(path, **params)
@@ -46,17 +46,17 @@ def test_to_csv_from_csv1(self, float_frame, datetime_frame):
             # freq does not roundtrip
             datetime_frame.index = datetime_frame.index._with_freq(None)
             datetime_frame.to_csv(path)
-            recons = self.read_csv(path)
+            recons = self.read_csv(path, parse_dates=True)
             tm.assert_frame_equal(datetime_frame, recons)
 
             datetime_frame.to_csv(path, index_label="index")
-            recons = self.read_csv(path, index_col=None)
+            recons = self.read_csv(path, index_col=None, parse_dates=True)
 
             assert len(recons.columns) == len(datetime_frame.columns) + 1
 
             # no index
             datetime_frame.to_csv(path, index=False)
-            recons = self.read_csv(path, index_col=None)
+            recons = self.read_csv(path, index_col=None, parse_dates=True)
             tm.assert_almost_equal(datetime_frame.values, recons.values)
 
             # corner case
@@ -514,7 +514,10 @@ def test_to_csv_multiindex(self, float_frame, datetime_frame):
             tsframe.index = MultiIndex.from_arrays(new_index)
 
             tsframe.to_csv(path, index_label=["time", "foo"])
-            recons = self.read_csv(path, index_col=[0, 1])
+            with tm.assert_produces_warning(
+                UserWarning, match="Could not infer format"
+            ):
+                recons = self.read_csv(path, index_col=[0, 1], parse_dates=True)
 
             # TODO to_csv drops column name
             tm.assert_frame_equal(tsframe, recons, check_names=False)
@@ -1056,7 +1059,7 @@ def test_to_csv_date_format(self, datetime_frame):
 
             # test NaTs
             nat_index = to_datetime(
-                ["NaT"] * 10 + ["2000-01-01", "1/1/2000", "1-1-2000"]
+                ["NaT"] * 10 + ["2000-01-01", "2000-01-01", "2000-01-01"]
             )
             nat_frame = DataFrame({"A": nat_index}, index=nat_index)
             nat_frame.to_csv(path, date_format="%Y-%m-%d")

pandas/tests/groupby/test_function.py

@@ -510,7 +510,7 @@ def test_idxmin_idxmax_returns_int_types(func, values, numeric_only):
             "name": ["A", "A", "B", "B"],
             "c_int": [1, 2, 3, 4],
             "c_float": [4.02, 3.03, 2.04, 1.05],
-            "c_date": ["2019", "2018", "2016", "2017"],
+            "c_date": ["2019-01-01", "2018-01-01", "2016-01-01", "2017-01-01"],
         }
     )
     df["c_date"] = pd.to_datetime(df["c_date"])
@@ -717,7 +717,7 @@ def test_max_nan_bug():
 -05-06,2013-05-06 00:00:00,,log.log
 -05-07,2013-05-07 00:00:00,OE,xlsx"""
 
-    df = pd.read_csv(StringIO(raw), parse_dates=[0])
+    df = pd.read_csv(StringIO(raw), parse_dates=[1])
     gb = df.groupby("Date")
     r = gb[["File"]].max()
     e = gb["File"].max().to_frame()
@@ -880,8 +880,8 @@ def test_cummin(dtypes_for_minmax):
     tm.assert_frame_equal(result, expected)
 
     # GH 15561
-    df = DataFrame({"a": [1], "b": pd.to_datetime(["2001"])})
-    expected = Series(pd.to_datetime("2001"), index=[0], name="b")
+    df = DataFrame({"a": [1], "b": pd.to_datetime(["2001-01-01"])})
+    expected = Series(pd.to_datetime("2001-01-01"), index=[0], name="b")
 
     result = df.groupby("a")["b"].cummin()
     tm.assert_series_equal(expected, result)

pandas/tests/groupby/transform/test_transform.py

@@ -1070,7 +1070,8 @@ def demean_rename(x):
 @pytest.mark.parametrize("func", [min, max, np.min, np.max, "first", "last"])
 def test_groupby_transform_timezone_column(func):
     # GH 24198
-    ts = pd.to_datetime("now", utc=True).tz_convert("Asia/Singapore")
+    with tm.assert_produces_warning(UserWarning, match="Could not infer format"):
+        ts = pd.to_datetime("now", utc=True).tz_convert("Asia/Singapore")
     result = DataFrame({"end_time": [ts], "id": [1]})
     result["max_end_time"] = result.groupby("id").end_time.transform(func)
     expected = DataFrame([[ts, 1, ts]], columns=["end_time", "id", "max_end_time"])

pandas/tests/io/json/test_json_table_schema.py

@@ -145,11 +145,11 @@ def test_as_json_table_type_bool_data(self, bool_type):
     @pytest.mark.parametrize(
         "date_data",
         [
-            pd.to_datetime(["2016"]),
-            pd.to_datetime(["2016"], utc=True),
-            pd.Series(pd.to_datetime(["2016"])),
-            pd.Series(pd.to_datetime(["2016"], utc=True)),
-            pd.period_range("2016", freq="A", periods=3),
+            pd.to_datetime(["2016-01-01"]),
+            pd.to_datetime(["2016-01-01"], utc=True),
+            pd.Series(pd.to_datetime(["2016-01-01"])),
+            pd.Series(pd.to_datetime(["2016-01-01"], utc=True)),
+            pd.period_range("2016-01-01", freq="A", periods=3),
         ],
     )
     def test_as_json_table_type_date_data(self, date_data):

pandas/tests/io/test_sql.py

@@ -1384,7 +1384,7 @@ def test_sqlalchemy_type_mapping(self):
 
         # Test Timestamp objects (no datetime64 because of timezone) (GH9085)
         df = DataFrame(
-            {"time": to_datetime(["201412120154", "201412110254"], utc=True)}
+            {"time": to_datetime(["2014-12-12 01:54", "2014:12:11 02:54"], utc=True)}
         )
         db = sql.SQLDatabase(self.conn)
         table = sql.SQLTable("test_type", db, frame=df)

pandas/tests/plotting/test_converter.py

@@ -161,8 +161,8 @@ def dtc(self):
         return converter.DatetimeConverter()
 
     def test_convert_accepts_unicode(self, dtc):
-        r1 = dtc.convert("12:22", None, None)
-        r2 = dtc.convert("12:22", None, None)
+        r1 = dtc.convert("2000-01-01 12:22", None, None)
+        r2 = dtc.convert("2000-01-01 12:22", None, None)
         assert r1 == r2, "DatetimeConverter.convert should accept unicode"
 
     def test_conversion(self, dtc):

pandas/tests/reductions/test_reductions.py

@@ -193,7 +193,7 @@ def test_same_tz_min_max_axis_1(self, op, expected_col):
     def test_numpy_reduction_with_tz_aware_dtype(self, tz_aware_fixture, func):
         # GH 15552
         tz = tz_aware_fixture
-        arg = pd.to_datetime(["2019"]).tz_localize(tz)
+        arg = pd.to_datetime(["2019-01-01"]).tz_localize(tz)
         expected = Series(arg)
         result = getattr(np, func)(expected, expected)
         tm.assert_series_equal(result, expected)

pandas/tests/reshape/merge/test_merge.py

@@ -2425,7 +2425,10 @@ def test_merge_datetime_upcast_dtype():
     # https://github.com/pandas-dev/pandas/issues/31208
     df1 = DataFrame({"x": ["a", "b", "c"], "y": ["1", "2", "4"]})
     df2 = DataFrame(
-        {"y": ["1", "2", "3"], "z": pd.to_datetime(["2000", "2001", "2002"])}
+        {
+            "y": ["1", "2", "3"],
+            "z": pd.to_datetime(["2000-01-01", "2001-01-01", "2002-01-01"]),
+        }
     )
     result = merge(df1, df2, how="left", on="y")
     expected = DataFrame(

pandas/tests/series/methods/test_nlargest.py

@@ -43,9 +43,11 @@ def s_main_dtypes():
     """
     df = pd.DataFrame(
         {
-            "datetime": pd.to_datetime(["2003", "2002", "2001", "2002", "2005"]),
+            "datetime": pd.to_datetime(
+                ["2003-01-01", "2002-01-01", "2001-01-01", "2002-01-01", "2005-01-01"]
+            ),
             "datetimetz": pd.to_datetime(
-                ["2003", "2002", "2001", "2002", "2005"]
+                ["2003-01-01", "2002-01-01", "2001-01-01", "2002-01-01", "2005-01-01"]
             ).tz_localize("US/Eastern"),
             "timedelta": pd.to_timedelta(["3d", "2d", "1d", "2d", "5d"]),
         }

pandas/tests/series/test_ufunc.py

@@ -257,9 +257,9 @@ def __add__(self, other):
         pd.array([1, 3, 2], dtype="Int64"),
         pd.array([1, 3, 2], dtype="Float32"),
         pd.array([1, 10, 2], dtype="Sparse[int]"),
-        pd.to_datetime(["2000", "2010", "2001"]),
-        pd.to_datetime(["2000", "2010", "2001"]).tz_localize("CET"),
-        pd.to_datetime(["2000", "2010", "2001"]).to_period(freq="D"),
+        pd.to_datetime(["2000-01-01", "2010-01-01", "2001-01-01"]),
+        pd.to_datetime(["2000-01-01", "2010-01-01", "2001-01-01"]).tz_localize("CET"),
+        pd.to_datetime(["2000-01-01", "2010-01-01", "2001-01-01"]).to_period(freq="D"),
         pd.to_timedelta(["1 Day", "3 Days", "2 Days"]),
         pd.IntervalIndex([pd.Interval(0, 1), pd.Interval(2, 3), pd.Interval(1, 2)]),
     ],