EOS/tests/test_dataabcrecord.py

"""Pytest test for data records fro dataabc module."""

import asyncio
import json
from datetime import datetime, timezone
from typing import Any, ClassVar, List, Optional, Union

import numpy as np
import pandas as pd
import pendulum
import pytest
from pydantic import Field, ValidationError

from akkudoktoreos.config.configabc import SettingsBaseModel
from akkudoktoreos.core.dataabc import (
    DataABC,
    DataRecord,
)
from akkudoktoreos.core.databaseabc import DatabaseTimestamp
from akkudoktoreos.utils.datetimeutil import compare_datetimes, to_datetime, to_duration

# Derived classes for testing
# ---------------------------

class DerivedConfig(SettingsBaseModel):
    env_var: Optional[int] = Field(default=None, description="Test config by environment var")
    instance_field: Optional[str] = Field(default=None, description="Test config by instance field")
    class_constant: Optional[int] = Field(default=None, description="Test config by class constant")


class DerivedBase(DataABC):
    instance_field: Optional[str] = Field(default=None, description="Field Value")
    class_constant: ClassVar[int] = 30


class DerivedRecord(DataRecord):
    """Date Record derived from base class DataRecord.

    The derived data record got the
    - `data_value` field and the
    - `dish_washer_emr`, `solar_power`, `temp` configurable field like data.
    """

    data_value: Optional[float] = Field(default=None, description="Data Value")

    @classmethod
    def configured_data_keys(cls) -> Optional[list[str]]:
        return ["dish_washer_emr", "solar_power", "temp"]


# Tests
# ----------


class TestDataABC:
    @pytest.fixture
    def base(self):
        # Provide default values for configuration
        derived = DerivedBase()
        return derived

    def test_get_config_value_key_error(self, base):
        with pytest.raises(AttributeError):
            base.config.non_existent_key


class TestDataRecord:
    def create_test_record(self, date, value):
        """Helper function to create a test DataRecord."""
        return DerivedRecord(date_time=date, data_value=value)

    @pytest.fixture
    def record(self):
        """Fixture to create a sample DerivedDataRecord with some data set."""
        rec = DerivedRecord(date_time=to_datetime("1967-01-11"), data_value=10.0)
        rec.configured_data = {"dish_washer_emr": 123.0, "solar_power": 456.0}
        return rec

    def test_getitem(self):
        record = self.create_test_record(datetime(2024, 1, 3, tzinfo=timezone.utc), 10.0)
        assert record["data_value"] == 10.0

    def test_setitem(self):
        record = self.create_test_record(datetime(2024, 1, 3, tzinfo=timezone.utc), 10.0)
        record["data_value"] = 20.0
        assert record.data_value == 20.0

    def test_delitem(self):
        record = self.create_test_record(datetime(2024, 1, 3, tzinfo=timezone.utc), 10.0)
        record.data_value = 20.0
        del record["data_value"]
        assert record.data_value is None

    def test_len(self):
        record = self.create_test_record(datetime(2024, 1, 3, tzinfo=timezone.utc), 10.0)
        record.date_time = None
        record.data_value = 20.0
        assert len(record) == 5 # 2 regular fields + 3 configured data "fields"

    def test_to_dict(self):
        record = self.create_test_record(datetime(2024, 1, 3, tzinfo=timezone.utc), 10.0)
        record.data_value = 20.0
        record_dict = record.to_dict()
        assert "data_value" in record_dict
        assert record_dict["data_value"] == 20.0
        record2 = DerivedRecord.from_dict(record_dict)
        assert record2.model_dump() == record.model_dump()

    def test_to_json(self):
        record = self.create_test_record(datetime(2024, 1, 3, tzinfo=timezone.utc), 10.0)
        record.data_value = 20.0
        json_str = record.to_json()
        assert "data_value" in json_str
        assert "20.0" in json_str
        record2 = DerivedRecord.from_json(json_str)
        assert record2.model_dump() == record.model_dump()

    def test_record_keys_includes_configured_data_keys(self, record):
        """Ensure record_keys includes all configured configured data keys."""
        assert set(record.record_keys()) >= set(record.configured_data_keys())

    def test_record_keys_writable_includes_configured_data_keys(self, record):
        """Ensure record_keys_writable includes all configured configured data keys."""
        assert set(record.record_keys_writable()) >= set(record.configured_data_keys())

    def test_getitem_existing_field(self, record):
        """Test that __getitem__ returns correct value for existing native field."""
        record.date_time = "2024-01-01T00:00:00+00:00"
        assert record["date_time"] is not None

    def test_getitem_existing_configured_data(self, record):
        """Test that __getitem__ retrieves existing configured data values."""
        assert record["dish_washer_emr"] == 123.0
        assert record["solar_power"] == 456.0

    def test_getitem_missing_configured_data_returns_none(self, record):
        """Test that __getitem__ returns None for missing but known configured data keys."""
        assert record["temp"] is None

    def test_getitem_raises_keyerror(self, record):
        """Test that __getitem__ raises KeyError for completely unknown keys."""
        with pytest.raises(KeyError):
            _ = record["nonexistent"]

    def test_setitem_field(self, record):
        """Test setting a native field using __setitem__."""
        record["date_time"] = "2025-01-01T12:00:00+00:00"
        assert str(record.date_time).startswith("2025-01-01")

    def test_setitem_configured_data(self, record):
        """Test setting a known configured data key using __setitem__."""
        record["temp"] = 25.5
        assert record.configured_data["temp"] == 25.5

    def test_setitem_invalid_key_raises(self, record):
        """Test that __setitem__ raises KeyError for unknown keys."""
        with pytest.raises(KeyError):
            record["unknown_key"] = 123

    def test_delitem_field(self, record):
        """Test deleting a native field using __delitem__."""
        record["date_time"] = "2025-01-01T12:00:00+00:00"
        del record["date_time"]
        assert record.date_time is None

    def test_delitem_configured_data(self, record):
        """Test deleting a known configured data key using __delitem__."""
        del record["solar_power"]
        assert "solar_power" not in record.configured_data

    def test_delitem_unknown_raises(self, record):
        """Test that __delitem__ raises KeyError for unknown keys."""
        with pytest.raises(KeyError):
            del record["nonexistent"]

    def test_attribute_get_existing_field(self, record):
        """Test accessing a native field via attribute."""
        record.date_time = "2025-01-01T12:00:00+00:00"
        assert record.date_time is not None

    def test_attribute_get_existing_configured_data(self, record):
        """Test accessing an existing configured data via attribute."""
        assert record.dish_washer_emr == 123.0

    def test_attribute_get_missing_configured_data(self, record):
        """Test accessing a missing but known configured data returns None."""
        assert record.temp is None

    def test_attribute_get_invalid_raises(self, record):
        """Test accessing an unknown attribute raises AttributeError."""
        with pytest.raises(AttributeError):
            _ = record.nonexistent

    def test_attribute_set_existing_field(self, record):
        """Test setting a native field via attribute."""
        record.date_time = "2025-06-25T12:00:00+00:00"
        assert record.date_time is not None

    def test_attribute_set_existing_configured_data(self, record):
        """Test setting a known configured data key via attribute."""
        record.temp = 99.9
        assert record.configured_data["temp"] == 99.9

    def test_attribute_set_invalid_raises(self, record):
        """Test setting an unknown attribute raises AttributeError."""
        with pytest.raises(AttributeError):
            record.invalid = 123

    def test_delattr_field(self, record):
        """Test deleting a native field via attribute."""
        record.date_time = "2025-06-25T12:00:00+00:00"
        del record.date_time
        assert record.date_time is None

    def test_delattr_configured_data(self, record):
        """Test deleting a known configured data key via attribute."""
        record.temp = 88.0
        del record.temp
        assert "temp" not in record.configured_data

    def test_delattr_ignored_missing_configured_data_key(self, record):
        """Test deleting a known configured data key that was never set is a no-op."""
        del record.temp
        assert "temp" not in record.configured_data

    def test_len_and_iter(self, record):
        """Test that __len__ and __iter__ behave as expected."""
        keys = list(iter(record))
        assert set(record.record_keys_writable()) == set(keys)
        assert len(record) == len(keys)

    def test_in_operator_includes_configured_data(self, record):
        """Test that 'in' operator includes configured data keys."""
        assert "dish_washer_emr" in record
        assert "temp" in record  # known key, even if not yet set
        assert "nonexistent" not in record

    def test_hasattr_behavior(self, record):
        """Test that hasattr returns True for fields and known configured dataWs."""
        assert hasattr(record, "date_time")
        assert hasattr(record, "dish_washer_emr")
        assert hasattr(record, "temp")  # allowed, even if not yet set
        assert not hasattr(record, "nonexistent")

    def test_model_validate_roundtrip(self, record):
        """Test that MeasurementDataRecord can be serialized and revalidated."""
        dumped = record.model_dump()
        restored = DerivedRecord.model_validate(dumped)
        assert restored.dish_washer_emr == 123.0
        assert restored.solar_power == 456.0
        assert restored.temp is None  # not set

    def test_copy_preserves_configured_data(self, record):
        """Test that copying preserves configured data values."""
        record.temp = 22.2
        copied = record.model_copy()
        assert copied.dish_washer_emr == 123.0
        assert copied.temp == 22.2
        assert copied is not record

    def test_equality_includes_configured_data(self, record):
        """Test that equality includes the `configured data` content."""
        other = record.model_copy()
        assert record == other

    def test_inequality_differs_with_configured_data(self, record):
        """Test that records with different configured datas are not equal."""
        other = record.model_copy(deep=True)
        # Modify one configured data value in the copy
        other.configured_data["dish_washer_emr"] = 999.9
        assert record != other

    def test_in_operator_for_configured_data_and_fields(self, record):
        """Ensure 'in' works for both fields and configured configured data keys."""
        assert "dish_washer_emr" in record
        assert "solar_power" in record
        assert "date_time" in record  # standard field
        assert "temp" in record       # allowed but not yet set
        assert "unknown" not in record

    def test_hasattr_equivalence_to_getattr(self, record):
        """hasattr should return True for all valid keys/configured datas."""
        assert hasattr(record, "dish_washer_emr")
        assert hasattr(record, "temp")
        assert hasattr(record, "date_time")
        assert not hasattr(record, "nonexistent")

    def test_dir_includes_configured_data_keys(self, record):
        """`dir(record)` should include configured data keys for introspection.
         It shall not include the internal 'configured datas' attribute.
        """
        keys = dir(record)
        assert "configured datas" not in keys
        for key in record.configured_data_keys():
            assert key in keys

    def test_init_configured_field_like_data_applies_before_model_init(self):
        """Test that keys listed in `_configured_data_keys` are moved to `configured_data` at init time."""
        record = DerivedRecord(
            date_time="2024-01-03T00:00:00+00:00",
            data_value=42.0,
            dish_washer_emr=111.1,
            solar_power=222.2,
            temp=333.3  # assume `temp` is also a valid configured key
        )

        assert record.data_value == 42.0
        assert record.configured_data == {
            "dish_washer_emr": 111.1,
            "solar_power": 222.2,
            "temp": 333.3,
        }