diff --git a/.gitignore b/.gitignore index 800a94b..2b68b1b 100644 --- a/.gitignore +++ b/.gitignore @@ -93,4 +93,4 @@ node_modules/ .pypirc # Data -data/ +/data/ diff --git a/tests/data/test_pvlive_data.py b/tests/data/test_pvlive_data.py deleted file mode 100644 index 7a2265e..0000000 --- a/tests/data/test_pvlive_data.py +++ /dev/null @@ -1,64 +0,0 @@ -import pytest -from unittest.mock import MagicMock -from datetime import datetime -import pytz -from open_data_pvnet.scripts.fetch_pvlive_data import PVLiveData - - -@pytest.fixture -def pvlive_mock(): - """ - Fixture to create a PVLiveData instance with mocked PVLive methods. - """ - pvlive = PVLiveData() - pvlive.pvl.latest = MagicMock() - pvlive.pvl.between = MagicMock() - pvlive.pvl.at_time = MagicMock() - return pvlive - - -def test_get_latest_data(pvlive_mock): - """ - Test the get_latest_data method. - """ - mock_data = {"column1": [1, 2], "column2": [3, 4]} - pvlive_mock.pvl.latest.return_value = mock_data - - result = pvlive_mock.get_latest_data(period=30) - pvlive_mock.pvl.latest.assert_called_once_with( - entity_type="gsp", entity_id=0, extra_fields="", period=30, dataframe=True - ) - assert result == mock_data - - -def test_get_data_between(pvlive_mock): - """ - Test the get_data_between method. - """ - mock_data = {"column1": [5, 6], "column2": [7, 8]} - pvlive_mock.pvl.between.return_value = mock_data - - start = datetime(2021, 1, 1, 12, 0, tzinfo=pytz.utc) - end = datetime(2021, 1, 2, 12, 0, tzinfo=pytz.utc) - - result = pvlive_mock.get_data_between(start, end) - pvlive_mock.pvl.between.assert_called_once_with( - start=start, end=end, entity_type="gsp", entity_id=0, extra_fields="", dataframe=True - ) - assert result == mock_data - - -def test_get_data_at_time(pvlive_mock): - """ - Test the get_data_at_time method. - """ - mock_data = {"column1": [9, 10], "column2": [11, 12]} - pvlive_mock.pvl.at_time.return_value = mock_data - - dt = datetime(2021, 1, 1, 12, 0, tzinfo=pytz.utc) - - result = pvlive_mock.get_data_at_time(dt) - pvlive_mock.pvl.at_time.assert_called_once_with( - dt, entity_type="gsp", entity_id=0, extra_fields="", period=30, dataframe=True - ) - assert result == mock_data diff --git a/tests/test_metadata.py b/tests/test_metadata.py index 9e781a4..e13eff6 100644 --- a/tests/test_metadata.py +++ b/tests/test_metadata.py @@ -1,4 +1,7 @@ -import tomllib +try: + import tomllib +except ImportError: + import tomli as tomllib import open_data_pvnet diff --git a/tests/test_pvlive.py b/tests/test_pvlive.py new file mode 100644 index 0000000..013f9ad --- /dev/null +++ b/tests/test_pvlive.py @@ -0,0 +1,163 @@ +import pytest +from unittest.mock import MagicMock, patch +from datetime import datetime +import pytz +import requests +import pandas as pd +from pvlive_api.pvlive import PVLiveException +from open_data_pvnet.scripts.fetch_pvlive_data import PVLiveData + + +class MockResponse: + def __init__(self, json_data, status_code=200): + self.json_data = json_data + self.status_code = status_code + self.text = "" + + def json(self): + return self.json_data + + def raise_for_status(self): + if self.status_code != 200: + raise requests.exceptions.HTTPError() + + +@pytest.fixture(autouse=True) +def mock_requests(): + """ + Mock requests.get to prevent actual API calls. + """ + with patch('requests.get') as mock_get: + # Mock the GSP list response + mock_get.return_value = MockResponse({ + "data": [ + {"gsp_id": 0, "gsp_name": "National", "pes_id": 0}, + {"gsp_id": 1, "gsp_name": "Region 1", "pes_id": 1} + ], + "meta": ["gsp_id", "gsp_name", "pes_id"] + }) + yield mock_get + + +@pytest.fixture +def pvlive_data(): + """ + Fixture to create a PVLiveData instance with mocked PVLive methods. + """ + with patch('pvlive_api.pvlive.PVLive._fetch_url', autospec=True) as mock_fetch: + mock_fetch.return_value = { + "data": [{"gsp_id": 0, "gsp_name": "National", "pes_id": 0}], + "meta": ["gsp_id", "gsp_name", "pes_id"] + } + instance = PVLiveData() + # Mock the methods after initialization + instance.pvl.latest = MagicMock() + instance.pvl.between = MagicMock() + instance.pvl.at_time = MagicMock() + return instance + + +def test_get_latest_data(pvlive_data): + """ + Test the get_latest_data method. + """ + # Create a DataFrame with the required columns + mock_data = pd.DataFrame({ + "generation_mw": [100], + "datetime_gmt": [datetime(2021, 1, 1, 12, 0, tzinfo=pytz.UTC)], + "pes_id": [0], + "gsp_id": [0], + "gsp_name": ["National"] + }) + pvlive_data.pvl.latest.return_value = mock_data + + result = pvlive_data.get_latest_data(period=30) + pvlive_data.pvl.latest.assert_called_once_with( + entity_type="gsp", entity_id=0, extra_fields="", period=30, dataframe=True + ) + assert result.equals(mock_data) + + +def test_get_latest_data_error(pvlive_data): + """ + Test error handling in get_latest_data method. + """ + pvlive_data.pvl.latest.side_effect = PVLiveException("Test error") + + result = pvlive_data.get_latest_data(period=30) + assert result is None + + +def test_get_data_between(pvlive_data): + """ + Test the get_data_between method. + """ + # Create a DataFrame with the required columns + mock_data = pd.DataFrame({ + "generation_mw": [100, 200], + "datetime_gmt": [ + datetime(2021, 1, 1, 12, 0, tzinfo=pytz.UTC), + datetime(2021, 1, 1, 12, 30, tzinfo=pytz.UTC) + ], + "pes_id": [0, 0], + "gsp_id": [0, 0], + "gsp_name": ["National", "National"] + }) + pvlive_data.pvl.between.return_value = mock_data + + start = datetime(2021, 1, 1, 12, 0, tzinfo=pytz.utc) + end = datetime(2021, 1, 2, 12, 0, tzinfo=pytz.utc) + + result = pvlive_data.get_data_between(start, end) + pvlive_data.pvl.between.assert_called_once_with( + start=start, end=end, entity_type="gsp", entity_id=0, extra_fields="", dataframe=True + ) + assert result.equals(mock_data) + + +def test_get_data_between_error(pvlive_data): + """ + Test error handling in get_data_between method. + """ + pvlive_data.pvl.between.side_effect = PVLiveException("Test error") + + result = pvlive_data.get_data_between( + start=datetime(2021, 1, 1, 12, 0, tzinfo=pytz.utc), + end=datetime(2021, 1, 2, 12, 0, tzinfo=pytz.utc) + ) + assert result is None + + +def test_get_data_at_time(pvlive_data): + """ + Test the get_data_at_time method. + """ + # Create a DataFrame with the required columns + mock_data = pd.DataFrame({ + "generation_mw": [100], + "datetime_gmt": [datetime(2021, 1, 1, 12, 0, tzinfo=pytz.UTC)], + "pes_id": [0], + "gsp_id": [0], + "gsp_name": ["National"] + }) + pvlive_data.pvl.at_time.return_value = mock_data + + dt = datetime(2021, 1, 1, 12, 0, tzinfo=pytz.utc) + + result = pvlive_data.get_data_at_time(dt) + pvlive_data.pvl.at_time.assert_called_once_with( + dt, entity_type="gsp", entity_id=0, extra_fields="", period=30, dataframe=True + ) + assert result.equals(mock_data) + + +def test_get_data_at_time_error(pvlive_data): + """ + Test error handling in get_data_at_time method. + """ + pvlive_data.pvl.at_time.side_effect = PVLiveException("Test error") + + result = pvlive_data.get_data_at_time( + datetime(2021, 1, 1, 12, 0, tzinfo=pytz.utc) + ) + assert result is None \ No newline at end of file