From 9ab2ecfd85acccb492f383e3fb99fbfeff6f2f6f Mon Sep 17 00:00:00 2001 From: Mark Campanelli Date: Mon, 23 Dec 2024 19:32:03 -0700 Subject: [PATCH] Don't parameterize repetitive tests --- pvlib/tests/test_tools.py | 290 ++++++++++++++------------------------ 1 file changed, 103 insertions(+), 187 deletions(-) diff --git a/pvlib/tests/test_tools.py b/pvlib/tests/test_tools.py index 1b5eb63c5..013716549 100644 --- a/pvlib/tests/test_tools.py +++ b/pvlib/tests/test_tools.py @@ -149,190 +149,106 @@ def test_normalize_max2one(data_in, expected): assert_allclose(result, expected) -@pytest.mark.parametrize( - 'input,expected', - [ - ( - { - "time": datetime( - 1974, 6, 22, 18, 30, 15, tzinfo=ZoneInfo("Etc/GMT+5"), - ), - "location": location.Location( - 43.19262774396091, -77.58782907414867, tz="Etc/GMT+5" - ) - }, - datetime(1974, 6, 22, 23, 30, 15, tzinfo=ZoneInfo("UTC")), - ), - ( - { - "time": datetime(1974, 6, 22, 18, 30, 15), - "location": location.Location( - 43.19262774396091, -77.58782907414867, tz="Etc/GMT+5" - ) - }, - datetime(1974, 6, 22, 23, 30, 15, tzinfo=ZoneInfo("UTC")), - ), - ( - { - "time": pd.DatetimeIndex( - ["1974-06-22T18:30:15"], - tz=ZoneInfo("Etc/GMT+5"), - ), - "location": location.Location( - 43.19262774396091, -77.58782907414867, tz="Etc/GMT+5" - ) - }, - pd.DatetimeIndex(["1974-06-22T23:30:15"], tz=ZoneInfo("UTC")), - ), - ( - { - "time": pd.DatetimeIndex(["1974-06-22T18:30:15"]), - "location": location.Location( - 43.19262774396091, -77.58782907414867, tz="Etc/GMT+5" - ) - }, - pd.DatetimeIndex(["1974-06-22T23:30:15"], tz=ZoneInfo("UTC")), - ), - ( - { - "time": pd.Series( - [24.42], - index=pd.DatetimeIndex( - ["1974-06-22T18:30:15"], - tz=ZoneInfo("Etc/GMT+5"), - ), - ), - "location": location.Location( - 43.19262774396091, -77.58782907414867, tz="Etc/GMT+5" - ) - }, - pd.Series( - [24.42], - pd.DatetimeIndex(["1974-06-22T23:30:15"], tz=ZoneInfo("UTC")), - ), - ), - ( - { - "time": pd.Series( - [24.42], - index=pd.DatetimeIndex(["1974-06-22T18:30:15"]), - ), - "location": location.Location( - 43.19262774396091, -77.58782907414867, tz="Etc/GMT+5" - ) - }, - pd.Series( - [24.42], - pd.DatetimeIndex(["1974-06-22T23:30:15"], tz=ZoneInfo("UTC")), - ), - ), - ( - { - "time": pd.DataFrame( - [[24.42]], - index=pd.DatetimeIndex( - ["1974-06-22T18:30:15"], - tz=ZoneInfo("Etc/GMT+5"), - ), - ), - "location": location.Location( - 43.19262774396091, -77.58782907414867, tz="Etc/GMT+5" - ) - }, - pd.DataFrame( - [[24.42]], - pd.DatetimeIndex(["1974-06-22T23:30:15"], tz=ZoneInfo("UTC")), - ), - ), - ( - { - "time": pd.DataFrame( - [[24.42]], - index=pd.DatetimeIndex(["1974-06-22T18:30:15"]), - ), - "location": location.Location( - 43.19262774396091, -77.58782907414867, tz="Etc/GMT+5" - ) - }, - pd.DataFrame( - [[24.42]], - pd.DatetimeIndex(["1974-06-22T23:30:15"], tz=ZoneInfo("UTC")), - ), - ), - ], - ids=[ - "datetime.datetime with tzinfo", - "datetime.datetime", - "pandas.DatetimeIndex with tzinfo", - "pandas.DatetimeIndex", - "pandas.Series with tzinfo", - "pandas.Series", - "pandas.DataFrame with tzinfo", - "pandas.DataFrame", - ], -) -def test_localize_to_utc(input, expected): - got = tools.localize_to_utc(**input) - - if isinstance(got, (pd.Series, pd.DataFrame)): - # Older pandas versions have wonky dtype equality check on timestamp - # index, so check the values as numpy.ndarray and indices one by one. - np.testing.assert_array_equal(got.to_numpy(), expected.to_numpy()) - - for index_got, index_expected in zip(got.index, expected.index): - assert index_got == index_expected - else: - assert got == expected - - -@pytest.mark.parametrize( - 'input,expected', - [ - ( - { - "time": datetime( - 1974, 6, 22, 18, 30, 15, tzinfo=ZoneInfo("Etc/GMT+5") - ) - }, - 27201.47934027778, - ), - ( - { - "time": datetime(1974, 6, 22, 23, 30, 15) - }, - 27201.47934027778, - ), - ], - ids=["datetime.datetime with tzinfo", "datetime.datetime"], -) -def test_datetime_to_djd(input, expected): - assert tools.datetime_to_djd(input["time"]) == expected - - -@pytest.mark.parametrize( - 'input,expected', - [ - ( - { - "djd": 27201.47934027778, - "tz": "Etc/GMT+5", - }, - datetime(1974, 6, 22, 18, 30, 15, tzinfo=ZoneInfo("Etc/GMT+5")), - ), - ( - { - "djd": 27201.47934027778, - "tz": None, - }, - datetime(1974, 6, 22, 23, 30, 15, tzinfo=ZoneInfo("UTC")), - ), - ], - ids=["djd with tzinfo", "djd"], -) -def test_djd_to_datetime(input, expected): - if input["tz"] is not None: - got = tools.djd_to_datetime(input["djd"]) - else: - got = tools.djd_to_datetime(input["djd"], tz="Etc/GMT+5") - - assert got == expected +def test_localize_to_utc(): + lat, lon = 43.2, -77.6 + tz = "Etc/GMT+5" + loc = location.Location(lat, lon, tz=tz) + year, month, day, hour, minute, second = 1974, 6, 22, 18, 30, 15 + hour_utc = hour + 5 + + # Test all combinations of supported inputs. + dt_time_aware_utc = datetime( + year, month, day, hour_utc, minute, second, tzinfo=ZoneInfo("UTC") + ) + dt_time_aware = datetime( + year, month, day, hour, minute, second, tzinfo=ZoneInfo(tz) + ) + assert tools.localize_to_utc(dt_time_aware, None) == dt_time_aware_utc + dt_time_naive = datetime(year, month, day, hour, minute, second) + assert tools.localize_to_utc(dt_time_naive, loc) == dt_time_aware_utc + + # FIXME Derive timestamp strings from above variables. + dt_index_aware_utc = pd.DatetimeIndex( + [dt_time_aware_utc.strftime("%Y-%m-%dT%H:%M:%S")], tz=ZoneInfo("UTC") + ) + dt_index_aware = pd.DatetimeIndex( + [dt_time_aware.strftime("%Y-%m-%dT%H:%M:%S")], tz=ZoneInfo(tz) + ) + assert tools.localize_to_utc(dt_index_aware, None) == dt_index_aware_utc + dt_index_naive = pd.DatetimeIndex( + [dt_time_naive.strftime("%Y-%m-%dT%H:%M:%S")] + ) + assert tools.localize_to_utc(dt_index_naive, loc) == dt_index_aware_utc + + # Older pandas versions have wonky dtype equality check on timestamp + # index, so check the values as numpy.ndarray and indices one by one. + series_time_aware_utc_expected = pd.Series([24.42], dt_index_aware_utc) + series_time_aware = pd.Series([24.42], index=dt_index_aware) + series_time_aware_utc_got = tools.localize_to_utc(series_time_aware, None) + np.testing.assert_array_equal( + series_time_aware_utc_got.to_numpy(), + series_time_aware_utc_expected.to_numpy(), + ) + + for index_got, index_expected in zip( + series_time_aware_utc_got.index, series_time_aware_utc_expected.index + ): + assert index_got == index_expected + + series_time_naive = pd.Series([24.42], index=dt_index_naive) + series_time_naive_utc_got = tools.localize_to_utc(series_time_naive, loc) + np.testing.assert_array_equal( + series_time_naive_utc_got.to_numpy(), + series_time_aware_utc_expected.to_numpy(), + ) + + for index_got, index_expected in zip( + series_time_naive_utc_got.index, series_time_aware_utc_expected.index + ): + assert index_got == index_expected + + # Older pandas versions have wonky dtype equality check on timestamp + # index, so check the values as numpy.ndarray and indices one by one. + df_time_aware_utc_expected = pd.DataFrame([[24.42]], dt_index_aware) + df_time_naive = pd.DataFrame([[24.42]], index=dt_index_naive) + df_time_naive_utc_got = tools.localize_to_utc(df_time_naive, loc) + np.testing.assert_array_equal( + df_time_naive_utc_got.to_numpy(), + df_time_aware_utc_expected.to_numpy(), + ) + + for index_got, index_expected in zip( + df_time_naive_utc_got.index, df_time_aware_utc_expected.index + ): + assert index_got == index_expected + + df_time_aware = pd.DataFrame([[24.42]], index=dt_index_aware) + df_time_aware_utc_got = tools.localize_to_utc(df_time_aware, None) + np.testing.assert_array_equal( + df_time_aware_utc_got.to_numpy(), + df_time_aware_utc_expected.to_numpy(), + ) + + for index_got, index_expected in zip( + df_time_aware_utc_got.index, df_time_aware_utc_expected.index + ): + assert index_got == index_expected + + +def test_datetime_to_djd(): + expected = 27201.47934027778 + dt_aware = datetime(1974, 6, 22, 18, 30, 15, tzinfo=ZoneInfo("Etc/GMT+5")) + assert tools.datetime_to_djd(dt_aware) == expected + dt_naive_utc = datetime(1974, 6, 22, 23, 30, 15) + assert tools.datetime_to_djd(dt_naive_utc) == expected + + +def test_djd_to_datetime(): + djd = 27201.47934027778 + tz = "Etc/GMT+5" + + expected = datetime(1974, 6, 22, 18, 30, 15, tzinfo=ZoneInfo(tz)) + assert tools.djd_to_datetime(djd, tz) == expected + + expected = datetime(1974, 6, 22, 23, 30, 15, tzinfo=ZoneInfo("UTC")) + assert tools.djd_to_datetime(djd) == expected