tliu93/home-automation
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 17 Wiki Activity

M8-T15: add thermal meter cost engine

Browse Source
This commit is contained in:
tliu93
2026-08-23 21:22:06 +02:00
parent 567ddb9779
commit 489e5b596a
5 changed files with 909 additions and 16 deletions
Download Patch File Download Diff File Expand all files Collapse all files
tests/test_energy_cost.py
+180 -1
View File
@@ -32,7 +32,7 @@ from pathlib import Path
import pytest
from alembic import command
from alembic.config import Config
from sqlalchemy import create_engine, select
from sqlalchemy import create_engine, event, select
from sqlalchemy.orm import Session
from app.integrations.pricing.strategies import PeriodDeltas # noqa: F401
@@ -57,6 +57,28 @@ from app.services.energy_cost import (
from app.services import timezone as tz_module
def test_scheduler_isolates_electricity_and_thermal_cost_scopes(monkeypatch: pytest.MonkeyPatch) -> None:
"""A thermal/electricity failure must not suppress the other ledger or HA publish."""
from app import main
calls: list[str] = []
class DummySession:
def rollback(self) -> None:
calls.append("rollback")
def close(self) -> None:
calls.append("close")
monkeypatch.setattr(main, "get_session_local", lambda: lambda: DummySession())
monkeypatch.setattr(main, "compute_closed_periods", lambda _session: (_ for _ in ()).throw(ValueError()))
monkeypatch.setattr(main, "compute_closed_meter_cost_periods", lambda _session: calls.append("thermal"))
from app.services import ha_discovery
monkeypatch.setattr(ha_discovery, "publish_states", lambda _session: calls.append("publish"))
main._run_scheduled_energy_cost()
assert calls == ["rollback", "close", "thermal", "close", "publish", "close"]
# ---------------------------------------------------------------------------
# Fixtures
# ---------------------------------------------------------------------------
@@ -82,6 +104,163 @@ def energy_db(tmp_path: Path):
engine.dispose()
@pytest.mark.parametrize("failing_scope", ["electricity", "thermal"])
def test_scheduler_uses_clean_sessions_after_real_flush_failure(
energy_db: Session, monkeypatch: pytest.MonkeyPatch, failing_scope: str
) -> None:
"""A DB failed-transaction in either ledger cannot poison the next scope or HA."""
from app import main
from app.services import ha_discovery
assert energy_db.bind is not None
sessions: list[Session] = []
calls: list[str] = []
def factory() -> Session:
session = Session(energy_db.bind)
sessions.append(session)
return session
def flush_failure(session: Session) -> None:
session.add(EnergyContract())
session.flush()
def successful(name: str):
def operation(session: Session) -> None:
session.execute(select(EnergyContract)).all()
calls.append(name)
return operation
monkeypatch.setattr(main, "get_session_local", lambda: factory)
monkeypatch.setattr(
main, "compute_closed_periods",
flush_failure if failing_scope == "electricity" else successful("electricity"),
)
monkeypatch.setattr(
main, "compute_closed_meter_cost_periods",
flush_failure if failing_scope == "thermal" else successful("thermal"),
)
monkeypatch.setattr(ha_discovery, "publish_states", lambda session: successful("ha")(session))
main._run_scheduled_energy_cost()
assert calls == (["thermal", "ha"] if failing_scope == "electricity" else ["electricity", "ha"])
assert len({id(session) for session in sessions}) == 3
@pytest.mark.parametrize("failing_scope", ["electricity", "thermal"])
def test_scheduler_isolates_real_commit_failure_and_rolls_back_write(
energy_db: Session, monkeypatch: pytest.MonkeyPatch, failing_scope: str
) -> None:
"""A commit exception leaves no partial write and the later scopes still run."""
from app import main
from app.services import ha_discovery
assert energy_db.bind is not None
sessions: list[Session] = []
calls: list[str] = []
def factory() -> Session:
session = Session(energy_db.bind)
sessions.append(session)
if len(sessions) == (1 if failing_scope == "electricity" else 2):
event.listen(session, "before_commit", lambda _session: (_ for _ in ()).throw(RuntimeError("commit")))
return session
def write(name: str):
def operation(session: Session) -> None:
now = datetime.now(UTC)
session.add(EnergyContract(
name=name, kind="manual", scope="electricity", active=False, currency="EUR",
created_at=now, updated_at=now,
))
session.commit()
calls.append(name)
return operation
monkeypatch.setattr(main, "get_session_local", lambda: factory)
monkeypatch.setattr(main, "compute_closed_periods", write("electricity"))
monkeypatch.setattr(main, "compute_closed_meter_cost_periods", write("thermal"))
monkeypatch.setattr(ha_discovery, "publish_states", lambda _session: calls.append("ha"))
main._run_scheduled_energy_cost()
assert calls == (["thermal", "ha"] if failing_scope == "electricity" else ["electricity", "ha"])
persisted = Session(energy_db.bind)
try:
assert persisted.scalars(select(EnergyContract.name)).all() == (
["thermal"] if failing_scope == "electricity" else ["electricity"]
)
finally:
persisted.close()
@pytest.mark.parametrize("failure", ["factory", "rollback", "close"])
def test_scheduler_lifecycle_failures_are_non_fatal_and_keep_later_scopes_independent(
monkeypatch: pytest.MonkeyPatch, failure: str
) -> None:
"""Factory and cleanup errors are logged locally, never allowed to escape."""
from app import main
from app.services import ha_discovery
calls: list[str] = []
created = 0
class DummySession:
def rollback(self) -> None:
calls.append("rollback")
if failure == "rollback":
raise RuntimeError("rollback")
def close(self) -> None:
calls.append("close")
if failure == "close":
raise RuntimeError("close")
def factory() -> DummySession:
nonlocal created
created += 1
if failure == "factory" and created == 1:
raise RuntimeError("factory")
return DummySession()
def electricity(_session: DummySession) -> None:
if failure in {"rollback", "close"}:
raise RuntimeError("operation")
calls.append("electricity")
monkeypatch.setattr(main, "get_session_local", lambda: factory)
monkeypatch.setattr(main, "compute_closed_periods", electricity)
monkeypatch.setattr(main, "compute_closed_meter_cost_periods", lambda _session: calls.append("thermal"))
monkeypatch.setattr(ha_discovery, "publish_states", lambda _session: calls.append("ha"))
main._run_scheduled_energy_cost()
assert "thermal" in calls and "ha" in calls
assert created == 3
def test_scheduler_swallows_ha_failure_after_two_successful_scopes(monkeypatch: pytest.MonkeyPatch) -> None:
from app import main
from app.services import ha_discovery
calls: list[str] = []
class DummySession:
def rollback(self) -> None:
calls.append("rollback")
def close(self) -> None:
calls.append("close")
monkeypatch.setattr(main, "get_session_local", lambda: lambda: DummySession())
monkeypatch.setattr(main, "compute_closed_periods", lambda _session: calls.append("electricity"))
monkeypatch.setattr(main, "compute_closed_meter_cost_periods", lambda _session: calls.append("thermal"))
monkeypatch.setattr(ha_discovery, "publish_states", lambda _session: (_ for _ in ()).throw(RuntimeError("ha")))
main._run_scheduled_energy_cost()
assert calls == ["electricity", "close", "thermal", "close", "rollback", "close"]
# ---------------------------------------------------------------------------
# Data-builder helpers
# ---------------------------------------------------------------------------
tests/test_meter_cost.py
+402
View File
@@ -0,0 +1,402 @@
"""M8-T15 tests for the binding-aware thermal ledger."""
from __future__ import annotations
from datetime import UTC, datetime, timedelta
from decimal import Decimal
from pathlib import Path
from zoneinfo import ZoneInfo
import pytest
from alembic import command
from alembic.config import Config
from sqlalchemy import create_engine, select
from sqlalchemy.orm import Session
from app.models.energy import EnergyContract, EnergyContractVersion, Meter, MeterCostPeriod
from app.models.meter_source import MeterSource, MeterSourceBinding, MeterSourceChannel, WarmteLinkReading
from app.services import timezone as timezone_service
from app.services.meter_cost import compute_closed_periods, compute_period, recompute_range, summarize
@pytest.fixture()
def db(tmp_path: Path) -> Session:
url = f"sqlite:///{tmp_path / 'meter_cost.db'}"
cfg = Config("alembic_app.ini")
cfg.set_main_option("sqlalchemy.url", url)
command.upgrade(cfg, "head")
engine = create_engine(url)
session = Session(engine)
yield session
session.close()
engine.dispose()
T0 = datetime(2026, 6, 23, 10, tzinfo=UTC)
VALUES = {
"variable": {"heating": "20.0", "hot_water_heating": "4.0", "hot_water": "2.0", "hot_water_tax": "1.0"},
"standing": {"heating_network": "365", "metering": "73", "delivery_set": "0", "hot_water_network": "0", "other": "0"},
}
def _contract(session: Session, *, values: dict = VALUES, start: datetime = T0 - timedelta(days=1)) -> EnergyContractVersion:
now = datetime.now(UTC)
contract = EnergyContract(name="thermal", kind="district_heating", scope="thermal", active=True,
currency="EUR", created_at=now, updated_at=now)
session.add(contract)
session.flush()
version = EnergyContractVersion(contract_id=contract.id, effective_from=start, values=values, created_at=now)
session.add(version)
session.flush()
return version
def _domain(session: Session, commodity: str, *, start: datetime = T0 - timedelta(days=1), end: datetime | None = None):
now = datetime.now(UTC)
meter = Meter(label=commodity, commodity=commodity, started_at=start, ended_at=end,
reason="initial", created_at=now)
source = MeterSource(name=f"{commodity}-source", kind="warmtelink_serial", enabled=True, config={},
status="online", created_at=now, updated_at=now)
session.add_all((meter, source))
session.flush()
unit = "GJ" if commodity == "heating" else "m3"
channel = MeterSourceChannel(source_id=source.id, channel_key=commodity, label=commodity,
suggested_commodity=commodity, unit=unit, latest_quality="valid",
created_at=now, updated_at=now)
session.add(channel)
session.flush()
binding = MeterSourceBinding(meter_id=meter.id, channel_id=channel.id, started_at=start, ended_at=end,
created_at=now, updated_at=now)
session.add(binding)
session.flush()
return meter, channel, binding
def _reading(session: Session, channel: MeterSourceChannel, at: datetime, value: str, quality: str = "valid") -> None:
session.add(WarmteLinkReading(channel_id=channel.id, recorded_at=at, received_at=at, value=Decimal(value),
unit=channel.unit, quality=quality, equipment_fingerprint="test"))
def _setup_good(session: Session) -> None:
_contract(session)
_, heating, _ = _domain(session, "heating")
_, water, _ = _domain(session, "hot_water")
_reading(session, heating, T0, "10.000")
_reading(session, heating, T0 + timedelta(minutes=15), "10.050")
_reading(session, water, T0, "20.000")
_reading(session, water, T0 + timedelta(minutes=15), "20.200")
session.commit()
def _row(session: Session, commodity: str) -> MeterCostPeriod:
return session.execute(select(MeterCostPeriod).where(MeterCostPeriod.commodity == commodity)).scalar_one()
def _row_at(session: Session, commodity: str, start: datetime) -> MeterCostPeriod:
return session.execute(select(MeterCostPeriod).where(
MeterCostPeriod.commodity == commodity, MeterCostPeriod.period_start == start
)).scalar_one()
def _version(
session: Session, contract: EnergyContract, *, start: datetime, values: dict
) -> EnergyContractVersion:
version = EnergyContractVersion(
contract_id=contract.id, effective_from=start, values=values, created_at=datetime.now(UTC)
)
session.add(version)
session.flush()
return version
def test_two_commodity_decimal_breakdown_and_scheduler_idempotency(db: Session) -> None:
_setup_good(db)
assert compute_period(db, "heating", T0)
assert compute_period(db, "hot_water", T0)
db.commit()
heating, water = _row(db, "heating"), _row(db, "hot_water")
assert heating.quantity == Decimal("0.050000")
assert heating.cost == Decimal("1.000000000")
assert water.cost == Decimal("1.400000000")
assert {key: Decimal(value) for key, value in water.cost_breakdown.items()} == {
"hot_water_heating": Decimal("0.8"), "hot_water": Decimal("0.4"), "hot_water_tax": Decimal("0.2")
}
assert not compute_period(db, "heating", T0)
@pytest.mark.parametrize("commodity,start,end,reason", [
("heating", "10", "9.99", "negative_delta"),
("heating", "10", "10.101", "delta_limit_exceeded"),
("hot_water", "10", "11.001", "delta_limit_exceeded"),
])
def test_bad_deltas_are_degraded(db: Session, commodity: str, start: str, end: str, reason: str) -> None:
_contract(db)
_, channel, _ = _domain(db, commodity)
_reading(db, channel, T0, start)
_reading(db, channel, T0 + timedelta(minutes=15), end)
db.commit()
compute_period(db, commodity, T0)
db.commit()
row = _row(db, commodity)
assert row.degraded and row.degraded_reason == reason and row.contract_version_id is None
def test_freshness_quality_binding_and_contract_fail_closed(db: Session) -> None:
_contract(db)
meter, channel, binding = _domain(db, "heating")
_reading(db, channel, T0 - timedelta(seconds=121), "1")
_reading(db, channel, T0 + timedelta(minutes=15), "1.01")
db.commit()
compute_period(db, "heating", T0)
assert _row(db, "heating").degraded_reason == "missing_stale_or_invalid_reading"
# Recompute sees invalid quality independently at the end boundary.
db.query(WarmteLinkReading).delete()
_reading(db, channel, T0, "1")
_reading(db, channel, T0 + timedelta(minutes=15), "1.01", "invalid")
db.commit()
recompute_range(db, T0, T0 + timedelta(minutes=15))
assert _row(db, "heating").degraded_reason == "missing_stale_or_invalid_reading"
binding.ended_at = T0 + timedelta(minutes=15)
db.commit()
recompute_range(db, T0, T0 + timedelta(minutes=15))
assert _row(db, "heating").degraded_reason == "missing_or_ambiguous_binding"
assert meter.id is not None
@pytest.mark.parametrize(
("first_quality", "last_quality", "accepted", "period_quality"),
[
("valid", "valid", True, "valid"),
("valid", "unverifiable", True, "unverifiable"),
("unverifiable", "valid", True, "unverifiable"),
("unverifiable", "unverifiable", True, "unverifiable"),
("invalid", "valid", False, "invalid"),
("valid", "invalid", False, "invalid"),
],
)
def test_accepted_reading_quality_is_preserved_without_promotion(
db: Session, first_quality: str, last_quality: str, accepted: bool, period_quality: str
) -> None:
_contract(db)
_, channel, _ = _domain(db, "heating")
_reading(db, channel, T0, "10", first_quality)
_reading(db, channel, T0 + timedelta(minutes=15), "10.05", last_quality)
db.commit()
assert compute_period(db, "heating", T0)
db.commit()
row = _row(db, "heating")
assert row.degraded is not accepted
assert row.quality == period_quality
if not accepted:
assert row.degraded_reason == "missing_stale_or_invalid_reading"
def test_readings_must_be_inside_binding_and_meter_windows(db: Session) -> None:
_contract(db)
meter, channel, binding = _domain(db, "heating", start=T0)
_reading(db, channel, T0 - timedelta(seconds=60), "10")
_reading(db, channel, T0 + timedelta(minutes=15), "10.05")
db.commit()
compute_period(db, "heating", T0)
assert _row(db, "heating").degraded_reason == "missing_stale_or_invalid_reading"
# A candidate after a closed binding is equally outside the cumulative domain.
binding.started_at = T0 - timedelta(days=1)
binding.ended_at = T0 + timedelta(minutes=15, seconds=30)
meter.started_at = T0 - timedelta(days=1)
db.query(WarmteLinkReading).delete()
_reading(db, channel, T0, "10")
_reading(db, channel, T0 + timedelta(minutes=15, seconds=60), "10.05")
db.commit()
recompute_range(db, T0, T0 + timedelta(minutes=15))
assert _row(db, "heating").degraded_reason == "missing_stale_or_invalid_reading"
def test_freshness_is_independent_and_inclusive_with_nearest_candidate(db: Session) -> None:
_contract(db)
_, channel, _ = _domain(db, "heating")
_reading(db, channel, T0 - timedelta(seconds=120), "10")
_reading(db, channel, T0 + timedelta(minutes=15, seconds=120), "10.05")
db.commit()
compute_period(db, "heating", T0)
db.commit()
row = _row(db, "heating")
assert not row.degraded and row.quantity == Decimal("0.050000")
def test_closed_scheduler_retries_degraded_but_not_normal(db: Session) -> None:
_contract(db)
_, channel, _ = _domain(db, "heating")
# The first closed scheduler pass records a degraded row. Supplying the
# missing boundary inputs later must let its next pass repair that row.
db.commit()
assert compute_closed_periods(db, now=T0 + timedelta(minutes=16)) > 0
assert _row_at(db, "heating", T0).degraded
_reading(db, channel, T0, "10")
_reading(db, channel, T0 + timedelta(minutes=15), "10.05")
db.commit()
assert compute_closed_periods(db, now=T0 + timedelta(minutes=16)) > 0
normal = _row_at(db, "heating", T0)
assert not normal.degraded
frozen = (normal.cost, dict(normal.pricing_snapshot), normal.updated_at)
end_reading = db.execute(select(WarmteLinkReading).where(
WarmteLinkReading.channel_id == channel.id,
WarmteLinkReading.recorded_at == T0 + timedelta(minutes=15),
)).scalar_one()
end_reading.value = Decimal("10.090")
version = db.get(EnergyContractVersion, normal.contract_version_id)
assert version is not None
version.values = {**version.values, "variable": {**version.values["variable"], "heating": "99"}}
db.commit()
compute_closed_periods(db, now=T0 + timedelta(minutes=16))
db.expire_all()
unchanged = db.execute(select(MeterCostPeriod).where(MeterCostPeriod.id == normal.id)).scalar_one()
assert (unchanged.cost, unchanged.pricing_snapshot, unchanged.updated_at) == frozen
def test_explicit_recompute_overwrites_and_source_switch_degrades(db: Session) -> None:
_setup_good(db)
compute_period(db, "heating", T0)
db.commit()
row = _row(db, "heating")
old_cost = row.cost
channel = db.get(MeterSourceChannel, row.source_binding.channel_id)
end_reading = db.execute(select(WarmteLinkReading).where(
WarmteLinkReading.channel_id == channel.id,
WarmteLinkReading.recorded_at == T0 + timedelta(minutes=15),
)).scalar_one()
end_reading.value = Decimal("10.080")
db.commit()
assert recompute_range(db, T0, T0 + timedelta(minutes=15)) == 2
assert _row(db, "heating").cost != old_cost
# A hand-off precisely at the right boundary cannot form a single domain.
binding = _row(db, "heating").source_binding
binding.ended_at = T0 + timedelta(minutes=15)
db.commit()
recompute_range(db, T0, T0 + timedelta(minutes=15))
assert _row(db, "heating").degraded_reason == "missing_or_ambiguous_binding"
def test_real_source_binding_handoff_never_crosses_cumulative_registers(db: Session) -> None:
_contract(db)
meter, old_channel, old_binding = _domain(db, "heating")
handoff = T0 + timedelta(minutes=15)
old_binding.ended_at = handoff
new_meter, new_channel, new_binding = _domain(db, "heating", start=handoff, end=handoff)
# Keep the same Meter: this is a source/channel/binding handoff, not a meter swap.
new_binding.meter_id = meter.id
new_binding.ended_at = None
assert new_meter.id != meter.id
_reading(db, old_channel, T0, "1000")
_reading(db, old_channel, handoff - timedelta(seconds=1), "1000.01")
_reading(db, new_channel, handoff, "7")
_reading(db, new_channel, handoff + timedelta(seconds=1), "7.01")
db.commit()
compute_period(db, "heating", T0)
assert _row(db, "heating").degraded_reason == "cross_source_binding"
def test_real_meter_epoch_handoff_never_crosses_cumulative_registers(db: Session) -> None:
_contract(db)
handoff = T0 + timedelta(minutes=15)
_, old_channel, _ = _domain(db, "heating", end=handoff)
_, new_channel, _ = _domain(db, "heating", start=handoff)
_reading(db, old_channel, T0, "1000")
_reading(db, old_channel, handoff - timedelta(seconds=1), "1000.01")
_reading(db, new_channel, handoff, "2")
_reading(db, new_channel, handoff + timedelta(seconds=1), "2.01")
db.commit()
compute_period(db, "heating", T0)
assert _row(db, "heating").degraded_reason == "cross_meter_epoch"
def test_summary_fixed_once_per_contract_day_and_dst(db: Session, monkeypatch: pytest.MonkeyPatch) -> None:
_setup_good(db)
compute_period(db, "heating", T0)
compute_period(db, "hot_water", T0)
db.commit()
monkeypatch.setattr(timezone_service, "local_tz", lambda: ZoneInfo("Europe/Amsterdam"))
result = summarize(db, T0, T0 + timedelta(days=1), now=datetime(2026, 6, 24, 1, 6, tzinfo=UTC))
assert result["variable_cost"] == Decimal("2.400000000")
assert result["fixed_cost"] == Decimal("2.4") # two local days, each charged once not per commodity
# DST local day is charged once too, despite being 23 hours long.
db.execute(select(EnergyContractVersion)).scalar_one().effective_from = datetime(2026, 3, 1, tzinfo=UTC)
db.commit()
dst_start = datetime(2026, 3, 28, 23, tzinfo=UTC)
dst = summarize(db, dst_start, dst_start + timedelta(days=2), now=datetime(2026, 3, 31, tzinfo=UTC))
assert dst["fixed_cost"] == Decimal("3.6")
def test_summary_is_half_open_at_local_midnight_and_settlement(db: Session, monkeypatch: pytest.MonkeyPatch) -> None:
_contract(db)
monkeypatch.setattr(timezone_service, "local_tz", lambda: ZoneInfo("Europe/Amsterdam"))
local = ZoneInfo("Europe/Amsterdam")
start = datetime(2026, 6, 24, 0, tzinfo=local).astimezone(UTC)
end = datetime(2026, 6, 25, 0, tzinfo=local).astimezone(UTC)
assert summarize(db, start, start, now=end + timedelta(hours=2))["fixed_cost"] == Decimal("0")
assert summarize(db, end, start, now=end + timedelta(hours=2))["fixed_cost"] == Decimal("0")
before = datetime(2026, 6, 24, 1, 4, 59, tzinfo=local).astimezone(UTC)
after = datetime(2026, 6, 24, 1, 5, tzinfo=local).astimezone(UTC)
assert summarize(db, start, end, now=before)["fixed_cost"] == Decimal("0")
assert summarize(db, start, end, now=after)["fixed_cost"] == Decimal("1.2")
def test_summary_versions_cover_first_day_intra_day_and_cross_day(db: Session, monkeypatch: pytest.MonkeyPatch) -> None:
monkeypatch.setattr(timezone_service, "local_tz", lambda: ZoneInfo("Europe/Amsterdam"))
local = ZoneInfo("Europe/Amsterdam")
day = datetime(2026, 6, 24, tzinfo=local)
first = _contract(db, start=(day + timedelta(hours=6)).astimezone(UTC))
first.values = {**VALUES, "standing": {**VALUES["standing"], "heating_network": "365"}}
second_values = {**VALUES, "standing": {**VALUES["standing"], "heating_network": "730"}}
switch = (day + timedelta(hours=18)).astimezone(UTC)
first.effective_to = switch
_version(db, first.contract, start=switch, values=second_values)
db.commit()
start = day.astimezone(UTC)
next_day = (day + timedelta(days=1)).astimezone(UTC)
following = (day + timedelta(days=2)).astimezone(UTC)
# Initial-version day only owns 18h: V1 owns 12h, V2 6h; on the following
# day V2 owns the full daily fixed amount.
assert summarize(db, start, next_day, now=following + timedelta(hours=2))["fixed_cost"] == Decimal("1.15")
assert summarize(db, start, following, now=following + timedelta(hours=2))["fixed_cost"] == Decimal("3.35")
def test_normal_row_has_full_audit_snapshot_and_single_commodity_scheduler(db: Session) -> None:
version = _contract(db)
meter, channel, binding = _domain(db, "heating")
_reading(db, channel, T0, "10")
_reading(db, channel, T0 + timedelta(minutes=15), "10.05")
db.commit()
compute_closed_periods(db, now=T0 + timedelta(minutes=16))
row = _row_at(db, "heating", T0)
assert (row.meter_id, row.source_binding_id, row.contract_version_id) == (meter.id, binding.id, version.id)
assert row.pricing_snapshot == VALUES
assert row.currency == "EUR" and {
key: Decimal(value) for key, value in row.cost_breakdown.items()
} == {"heating": Decimal("1.0")}
assert not row.degraded
assert _row_at(db, "hot_water", T0).degraded
@pytest.mark.parametrize(("commodity", "end_value"), [("heating", "10.1"), ("hot_water", "11")])
def test_delta_limit_is_inclusive_at_exact_boundary(db: Session, commodity: str, end_value: str) -> None:
_contract(db)
_, channel, _ = _domain(db, commodity)
_reading(db, channel, T0, "10")
_reading(db, channel, T0 + timedelta(minutes=15), end_value)
db.commit()
compute_period(db, commodity, T0)
assert not _row(db, commodity).degraded
@pytest.mark.parametrize("day", [datetime(2026, 3, 29), datetime(2026, 10, 25)])
def test_summary_dst_local_midnights_charge_one_daily_rate(
db: Session, monkeypatch: pytest.MonkeyPatch, day: datetime
) -> None:
_contract(db, start=datetime(2026, 1, 1, tzinfo=UTC))
monkeypatch.setattr(timezone_service, "local_tz", lambda: ZoneInfo("Europe/Amsterdam"))
local = ZoneInfo("Europe/Amsterdam")
start = day.replace(tzinfo=local).astimezone(UTC)
end = (day + timedelta(days=1)).replace(tzinfo=local).astimezone(UTC)
assert summarize(db, start, end, now=end + timedelta(hours=2))["fixed_cost"] == Decimal("1.2")