e-data 1.3.1__py3-none-any.whl

tests/test_datadis_connector.py

@@ -0,0 +1,242 @@
+"""Tests for DatadisConnector (offline)."""
+
+import datetime
+import datetime
+from unittest.mock import patch, AsyncMock, MagicMock
+from ..connectors.datadis import DatadisConnector
+
+from ..connectors.datadis import DatadisConnector
+
+MOCK_USERNAME = "USERNAME"
+MOCK_PASSWORD = "PASSWORD"
+
+SUPPLIES_RESPONSE = [
+    {
+        "cups": "ESXXXXXXXXXXXXXXXXTEST",
+        "validDateFrom": "2022/03/09",
+        "validDateTo": "2022/10/28",
+        "address": "-",
+        "postalCode": "-",
+        "province": "-",
+        "municipality": "-",
+        "distributor": "-",
+        "pointType": 5,
+        "distributorCode": "2",
+    }
+]
+
+CONTRACTS_RESPONSE = [
+    {
+        "startDate": "2022/03/09",
+        "endDate": "2022/10/28",
+        "marketer": "MARKETER",
+        "distributorCode": "2",
+        "contractedPowerkW": [4.4, 4.4],
+    }
+]
+
+CONSUMPTIONS_RESPONSE = [
+    {
+        "date": "2022/10/22",
+        "time": "01:00",
+        "consumptionKWh": 0.203,
+        "surplusEnergyKWh": 0,
+        "obtainMethod": "Real",
+    },
+    {
+        "date": "2022/10/22",
+        "time": "02:00",
+        "consumptionKWh": 0.163,
+        "surplusEnergyKWh": 0,
+        "obtainMethod": "Real",
+    },
+]
+
+MAXIMETER_RESPONSE = [
+    {
+        "date": "2022/03/10",
+        "time": "14:15",
+        "maxPower": 2.436,
+    },
+    {
+        "date": "2022/03/14",
+        "time": "13:15",
+        "maxPower": 3.008,
+    },
+    {
+        "date": "2022/03/27",
+        "time": "10:30",
+        "maxPower": 3.288,
+    },
+]
+
+@patch("aiohttp.ClientSession.get")
+@patch.object(DatadisConnector, "_async_get_token", new_callable=AsyncMock, return_value=True)
+def test_get_supplies(mock_token, mock_get, snapshot):
+    """Test a successful 'get_supplies' query (syrupy snapshot)."""
+    mock_response = MagicMock()
+    mock_response.status = 200
+    mock_response.text = AsyncMock(return_value="text")
+    mock_response.json = AsyncMock(return_value=SUPPLIES_RESPONSE)
+    mock_get.return_value.__aenter__.return_value = mock_response
+    connector = DatadisConnector(MOCK_USERNAME, MOCK_PASSWORD)
+    assert connector.get_supplies() == snapshot
+
+
+
+@patch("aiohttp.ClientSession.get")
+@patch.object(DatadisConnector, "_async_get_token", new_callable=AsyncMock, return_value=True)
+def test_get_contract_detail(mock_token, mock_get, snapshot):
+    """Test a successful 'get_contract_detail' query (syrupy snapshot)."""
+    mock_response = MagicMock()
+    mock_response.status = 200
+    mock_response.text = AsyncMock(return_value="text")
+    mock_response.json = AsyncMock(return_value=CONTRACTS_RESPONSE)
+    mock_get.return_value.__aenter__.return_value = mock_response
+    connector = DatadisConnector(MOCK_USERNAME, MOCK_PASSWORD)
+    assert connector.get_contract_detail("ESXXXXXXXXXXXXXXXXTEST", "2") == snapshot
+
+
+
+@patch("aiohttp.ClientSession.get")
+@patch.object(DatadisConnector, "_async_get_token", new_callable=AsyncMock, return_value=True)
+def test_get_consumption_data(mock_token, mock_get, snapshot):
+    """Test a successful 'get_consumption_data' query (syrupy snapshot)."""
+    mock_response = MagicMock()
+    mock_response.status = 200
+    mock_response.text = AsyncMock(return_value="text")
+    mock_response.json = AsyncMock(return_value=CONSUMPTIONS_RESPONSE)
+    mock_get.return_value.__aenter__.return_value = mock_response
+    connector = DatadisConnector(MOCK_USERNAME, MOCK_PASSWORD)
+    assert connector.get_consumption_data(
+        "ESXXXXXXXXXXXXXXXXTEST",
+        "2",
+        datetime.datetime(2022, 10, 22, 0, 0, 0),
+        datetime.datetime(2022, 10, 22, 2, 0, 0),
+        "0",
+        5,
+    ) == snapshot
+
+
+
+@patch("aiohttp.ClientSession.get")
+@patch.object(DatadisConnector, "_async_get_token", new_callable=AsyncMock, return_value=True)
+def test_get_max_power(mock_token, mock_get, snapshot):
+    """Test a successful 'get_max_power' query (syrupy snapshot)."""
+    mock_response = MagicMock()
+    mock_response.status = 200
+    mock_response.text = AsyncMock(return_value="text")
+    mock_response.json = AsyncMock(return_value=MAXIMETER_RESPONSE)
+    mock_get.return_value.__aenter__.return_value = mock_response
+    connector = DatadisConnector(MOCK_USERNAME, MOCK_PASSWORD)
+    assert connector.get_max_power(
+        "ESXXXXXXXXXXXXXXXXTEST",
+        "2",
+        datetime.datetime(2022, 3, 1, 0, 0, 0),
+        datetime.datetime(2022, 4, 1, 0, 0, 0),
+        None,
+    ) == snapshot
+
+
+@patch("aiohttp.ClientSession.get")
+@patch.object(DatadisConnector, "_async_get_token", new_callable=AsyncMock, return_value=True)
+def test_get_supplies_empty_response(mock_token, mock_get, snapshot):
+    """Test get_supplies with empty response (syrupy snapshot)."""
+    mock_response = MagicMock()
+    mock_response.status = 200
+    mock_response.text = AsyncMock(return_value="text")
+    mock_response.json = AsyncMock(return_value=[])
+    mock_get.return_value.__aenter__.return_value = mock_response
+    connector = DatadisConnector(MOCK_USERNAME, MOCK_PASSWORD)
+    assert connector.get_supplies() == snapshot
+
+
+@patch("aiohttp.ClientSession.get")
+@patch.object(DatadisConnector, "_async_get_token", new_callable=AsyncMock, return_value=True)
+def test_get_supplies_malformed_response(mock_token, mock_get, snapshot):
+    """Test get_supplies with malformed response (missing required fields, syrupy snapshot)."""
+    malformed = [{"validDateFrom": "2022/03/09"}]  # missing 'cups', etc.
+    mock_response = MagicMock()
+    mock_response.status = 200
+    mock_response.text = AsyncMock(return_value="text")
+    mock_response.json = AsyncMock(return_value=malformed)
+    mock_get.return_value.__aenter__.return_value = mock_response
+    connector = DatadisConnector(MOCK_USERNAME, MOCK_PASSWORD)
+    assert connector.get_supplies() == snapshot
+
+
+@patch("aiohttp.ClientSession.get")
+@patch.object(DatadisConnector, "_async_get_token", new_callable=AsyncMock, return_value=True)
+def test_get_supplies_partial_response(mock_token, mock_get, snapshot):
+    """Test get_supplies with partial valid/invalid response (syrupy snapshot)."""
+    partial = [
+        SUPPLIES_RESPONSE[0],
+        {"validDateFrom": "2022/03/09"},  # invalid
+    ]
+    mock_response = MagicMock()
+    mock_response.status = 200
+    mock_response.text = AsyncMock(return_value="text")
+    mock_response.json = AsyncMock(return_value=partial)
+    mock_get.return_value.__aenter__.return_value = mock_response
+    connector = DatadisConnector(MOCK_USERNAME, MOCK_PASSWORD)
+    assert connector.get_supplies() == snapshot
+
+
+
+@patch("aiohttp.ClientSession.get")
+@patch.object(DatadisConnector, "_async_get_token", new_callable=AsyncMock, return_value=True)
+def test_get_consumption_data_cache(mock_token, mock_get, snapshot):
+    """Test get_consumption_data uses cache on second call (should not call HTTP again, syrupy snapshot)."""
+    mock_response = MagicMock()
+    mock_response.status = 200
+    mock_response.text = AsyncMock(return_value="text")
+    mock_response.json = AsyncMock(return_value=CONSUMPTIONS_RESPONSE)
+    mock_get.return_value.__aenter__.return_value = mock_response
+    connector = DatadisConnector(MOCK_USERNAME, MOCK_PASSWORD)
+    # First call populates cache
+    assert connector.get_consumption_data(
+        "ESXXXXXXXXXXXXXXXXTEST",
+        "2",
+        datetime.datetime(2022, 10, 22, 0, 0, 0),
+        datetime.datetime(2022, 10, 22, 2, 0, 0),
+        "0",
+        5,
+    ) == snapshot
+    # Second call should use cache, not call HTTP again
+    mock_get.reset_mock()
+    assert connector.get_consumption_data(
+        "ESXXXXXXXXXXXXXXXXTEST",
+        "2",
+        datetime.datetime(2022, 10, 22, 0, 0, 0),
+        datetime.datetime(2022, 10, 22, 2, 0, 0),
+        "0",
+        5,
+    ) == snapshot
+    mock_get.assert_not_called()
+
+
+@patch("aiohttp.ClientSession.get")
+@patch.object(DatadisConnector, "_async_get_token", new_callable=AsyncMock, return_value=True)
+def test_get_supplies_optional_fields_none(mock_token, mock_get, snapshot):
+    """Test get_supplies with optional fields as None (syrupy snapshot)."""
+    response = [
+        {
+            "cups": "ESXXXXXXXXXXXXXXXXTEST",
+            "validDateFrom": "2022/03/09",
+            "validDateTo": "2022/10/28",
+            "address": None,
+            "postalCode": None,
+            "province": None,
+            "municipality": None,
+            "distributor": None,
+            "pointType": 5,
+            "distributorCode": "2",
+        }
+    ]
+    mock_response = MagicMock()
+    mock_response.status = 200
+    mock_response.text = AsyncMock(return_value="text")
+    mock_response.json = AsyncMock(return_value=response)
+    mock_get.return_value.__aenter__.return_value = mock_response
+    connector = DatadisConnector(MOCK_USERNAME, MOCK_PASSWORD)
+    assert connector.get_supplies() == snapshot

tests/test_helpers.py

@@ -0,0 +1,52 @@
+"""A collection of tests for e-data processors"""
+
+import json
+import pathlib
+
+from freezegun import freeze_time
+
+from ..definitions import PricingRules
+from ..helpers import EdataHelper
+from ..processors import utils
+
+AT_TIME = "2022-10-22"
+TESTS_DIR = str(pathlib.Path(__file__).parent.resolve())
+TEST_GOOD_INPUT = TESTS_DIR + "/assets/helpers/edata.storage_TEST"
+TEST_EXPECTATIONS_DATA = TESTS_DIR + "/assets/helpers/data.out"
+TEST_EXPECTATIONS_ATTRIBUTES = (
+    TESTS_DIR + f"/assets/helpers/attributes_at_{AT_TIME}.out"
+)
+
+PRICING_RULES_PVPC = PricingRules(
+    p1_kw_year_eur=30.67266,
+    p2_kw_year_eur=1.4243591,
+    meter_month_eur=0.81,
+    market_kw_year_eur=3.113,
+    electricity_tax=1.0511300560,
+    iva_tax=1.05,
+    p1_kwh_eur=None,
+    p2_kwh_eur=None,
+    p3_kwh_eur=None,
+)
+
+@freeze_time(AT_TIME)
+def test_helper_offline(snapshot) -> None:
+    """Tests EdataHelper (syrupy snapshot)"""
+    with open(TEST_GOOD_INPUT, "r", encoding="utf-8") as original_file:
+        data = utils.deserialize_dict(json.load(original_file))
+
+        helper = EdataHelper(
+            "USER",
+            "PASS",
+            "CUPS",
+            datadis_authorized_nif=None,
+            pricing_rules=PRICING_RULES_PVPC,
+            data=data,
+        )
+        helper.process_data()
+
+        # Compara ambos outputs con snapshot
+        assert {
+            "data": utils.serialize_dict(helper.data),
+            "attributes": utils.serialize_dict(helper.attributes),
+        } == snapshot

tests/test_processors.py

@@ -0,0 +1,106 @@
+"""A collection of tests for e-data processors"""
+
+import datetime as dt
+import json
+import pathlib
+import typing
+from collections.abc import Iterable
+
+import pytest
+
+from ..definitions import PricingData, PricingRules
+from ..processors import utils
+from ..processors.base import Processor
+from ..processors.billing import BillingProcessor
+from ..processors.consumption import ConsumptionProcessor
+from ..processors.maximeter import MaximeterProcessor
+
+TESTS_DIR = str(pathlib.Path(__file__).parent.resolve())
+TEST_GOOD_INPUT = TESTS_DIR + "/assets/processors/edata.storage_TEST"
+
+def _compare_processor_output(
+    source_filepath: str,
+    processor_class: Processor,
+    key: str,
+    snapshot,
+):
+    with open(source_filepath, encoding="utf-8") as original_file:
+        data = utils.deserialize_dict(json.load(original_file))
+        if key == "consumptions":
+            processor = processor_class({"consumptions": data[key]})
+        else:
+            processor = processor_class(data[key])
+        assert utils.serialize_dict(processor.output) == snapshot
+
+
+@pytest.mark.parametrize(
+    "processor, key",
+    [(ConsumptionProcessor, "consumptions"), (MaximeterProcessor, "maximeter")],
+)
+def test_processor(processor: Processor, key: str, snapshot) -> None:
+    """Tests all processors but billing (syrupy snapshot)"""
+    _compare_processor_output(
+        TEST_GOOD_INPUT,
+        processor,
+        key,
+        snapshot,
+    )
+
+
+@pytest.mark.parametrize(
+    "_id, rules, prices",
+    [
+        (
+            "custom_prices",
+            PricingRules(
+                p1_kw_year_eur=30.67266,
+                p2_kw_year_eur=1.4243591,
+                meter_month_eur=0.81,
+                market_kw_year_eur=3.113,
+                electricity_tax=1.0511300560,
+                iva_tax=1.1,
+                p1_kwh_eur=None,
+                p2_kwh_eur=None,
+                p3_kwh_eur=None,
+            ),
+            [
+                PricingData(
+                    datetime=dt.datetime(2022, 10, 22, x, 0, 0),
+                    value_eur_kWh=1,
+                    delta_h=1,
+                )
+                for x in range(0, 24)
+            ],
+        ),
+        (
+            "constant_prices",
+            PricingRules(
+                p1_kw_year_eur=30.67266,
+                p2_kw_year_eur=1.4243591,
+                meter_month_eur=0.81,
+                market_kw_year_eur=3.113,
+                electricity_tax=1.0511300560,
+                iva_tax=1.1,
+                p1_kwh_eur=1,
+                p2_kwh_eur=1,
+                p3_kwh_eur=1,
+            ),
+            None,
+        ),
+    ],
+)
+def test_processor_billing(
+    _id: str, rules: PricingRules, prices: typing.Optional[Iterable[PricingData]], snapshot
+):
+    """Tests billing processor (syrupy snapshot)"""
+    with open(TEST_GOOD_INPUT, "r", encoding="utf-8") as original_file:
+        data = utils.deserialize_dict(json.load(original_file))
+        processor = BillingProcessor(
+            {
+                "consumptions": data["consumptions"],
+                "contracts": data["contracts"],
+                "prices": prices,
+                "rules": rules,
+            }
+        )
+    assert utils.serialize_dict(processor.output) == snapshot

tests/test_redata_connector.py

@@ -0,0 +1,14 @@
+"""Tests for REData (online)"""
+
+from datetime import datetime, timedelta
+
+from ..connectors.redata import REDataConnector
+
+def test_get_realtime_prices():
+    """Test a successful 'get_realtime_prices' query"""
+    connector = REDataConnector()
+    yesterday = datetime.now().replace(hour=0, minute=0, second=0) - timedelta(days=1)
+    response = connector.get_realtime_prices(
+        yesterday, yesterday + timedelta(days=1) - timedelta(minutes=1), False
+    )
+    assert len(response) == 24