FU11: anchor cumulative cost at recording start; add daily-reset cost entities; prefill add-version form
- MQTT import_cost_total / export_revenue_total now anchor fixed-fee / tax-credit accrual at max(contract start, first recorded period), so standing charges for untracked pre-recording days are no longer folded into the running total. - Add energy.import_cost_today / energy.export_revenue_today (monetary, total_increasing) that reset at server-local midnight, for per-day cost aggregation in Home Assistant alongside the running totals. - ContractForm add-version mode prefills the contract's open version values, so only the fields that actually change need editing.
This commit is contained in:
+145
-7
@@ -550,13 +550,17 @@ def _energy_cost_provider(session: Session) -> list[ExposableEntity]:
|
||||
"""Return a getter for the cumulative import cost plus prorated standing charges.
|
||||
|
||||
Principle B/D: delegates entirely to ``summarize(sess, anchor_utc, now_utc)``,
|
||||
where ``anchor_utc`` is the effective_from of the earliest version of the active
|
||||
contract (i.e. the contract billing start). This makes the cumulative total
|
||||
monotonically increasing and cross-version consistent:
|
||||
where ``anchor_utc`` is the **max** of:
|
||||
- the earliest version's effective_from (contract billing start), and
|
||||
- the earliest non-degraded EnergyCostPeriod.period_start (recording start).
|
||||
|
||||
This prevents counting fixed costs for the period before any data was recorded
|
||||
(e.g. contract starts Jan 1 but data recording only starts Jun 17 — we do not
|
||||
want to include ~€270 of standing charges for a period with no meter data).
|
||||
|
||||
value = summarize(anchor → now).metered_import + summarize(anchor → now).fixed_costs
|
||||
|
||||
Returns None when no non-degraded period exists in [anchor, now].
|
||||
Returns None when no non-degraded period exists.
|
||||
No arithmetic is done here — all fixed-cost/credit accounting lives in summarize().
|
||||
"""
|
||||
def _getter(sess: "Session") -> Any:
|
||||
@@ -580,8 +584,18 @@ def _energy_cost_provider(session: Session) -> list[ExposableEntity]:
|
||||
# No active contract — return pure SUM(import_cost) without standing charges.
|
||||
return float(has_data)
|
||||
|
||||
# anchor = earliest version's effective_from (contract billing start).
|
||||
anchor_utc = _cu(versions[0].effective_from)
|
||||
# anchor = max(contract billing start, earliest recording start).
|
||||
# This prevents accumulating fixed costs for days with no meter data.
|
||||
contract_anchor_utc = _cu(versions[0].effective_from)
|
||||
earliest_period_start = sess.query(_func.min(_ECP.period_start)).filter(
|
||||
_ECP.degraded.is_(False)
|
||||
).scalar()
|
||||
if earliest_period_start is not None:
|
||||
recording_anchor_utc = _cu(earliest_period_start)
|
||||
anchor_utc = max(contract_anchor_utc, recording_anchor_utc)
|
||||
else:
|
||||
anchor_utc = contract_anchor_utc
|
||||
|
||||
now_utc = _dt.now(UTC)
|
||||
|
||||
result = _summarize(sess, anchor_utc, now_utc)
|
||||
@@ -595,6 +609,7 @@ def _energy_cost_provider(session: Session) -> list[ExposableEntity]:
|
||||
"""Return a getter for the cumulative export revenue plus prorated tax credit.
|
||||
|
||||
Principle B/D: delegates entirely to ``summarize(sess, anchor_utc, now_utc)``.
|
||||
Anchor is the same max(contract_start, recording_start) logic as import getter.
|
||||
|
||||
value = summarize(anchor → now).metered_export + summarize(anchor → now).credits
|
||||
|
||||
@@ -620,7 +635,17 @@ def _energy_cost_provider(session: Session) -> list[ExposableEntity]:
|
||||
# No active contract — return pure SUM(export_revenue) without credits.
|
||||
return float(has_data)
|
||||
|
||||
anchor_utc = _cu(versions[0].effective_from)
|
||||
# anchor = max(contract billing start, earliest recording start).
|
||||
contract_anchor_utc = _cu(versions[0].effective_from)
|
||||
earliest_period_start = sess.query(_func.min(_ECP.period_start)).filter(
|
||||
_ECP.degraded.is_(False)
|
||||
).scalar()
|
||||
if earliest_period_start is not None:
|
||||
recording_anchor_utc = _cu(earliest_period_start)
|
||||
anchor_utc = max(contract_anchor_utc, recording_anchor_utc)
|
||||
else:
|
||||
anchor_utc = contract_anchor_utc
|
||||
|
||||
now_utc = _dt.now(UTC)
|
||||
|
||||
result = _summarize(sess, anchor_utc, now_utc)
|
||||
@@ -628,6 +653,85 @@ def _energy_cost_provider(session: Session) -> list[ExposableEntity]:
|
||||
|
||||
return _getter
|
||||
|
||||
# --- value_getter: today's import cost (local-day window, resets at local midnight) ---
|
||||
|
||||
def _make_import_cost_today_getter() -> Callable[["Session"], Any]:
|
||||
"""Return a getter for today's import cost (metered + standing for today).
|
||||
|
||||
Window: [local today 00:00, local tomorrow 00:00) in UTC.
|
||||
After local midnight the window rolls to the new day → value resets to that
|
||||
day's running cost, implementing "resets at local midnight" semantics for HA.
|
||||
|
||||
Uses timezone module via module-attribute access to preserve monkeypatch safety.
|
||||
Returns None when no non-degraded period exists or no active contract.
|
||||
"""
|
||||
def _getter(sess: "Session") -> Any:
|
||||
from app.services.contracts import active_contract_versions
|
||||
from app.models.energy import EnergyCostPeriod as _ECP
|
||||
from app.services.energy_cost import summarize as _summarize
|
||||
from app.services import timezone as _tz_mod
|
||||
from sqlalchemy import func as _func
|
||||
from datetime import timedelta as _td
|
||||
|
||||
# Quick check: any non-degraded period at all?
|
||||
has_data = sess.query(_func.sum(_ECP.import_cost)).filter(
|
||||
_ECP.degraded.is_(False)
|
||||
).scalar()
|
||||
if has_data is None:
|
||||
return None
|
||||
|
||||
versions = active_contract_versions(sess)
|
||||
if not versions:
|
||||
return None
|
||||
|
||||
# Today's window in UTC, using monkeypatch-safe module attribute calls.
|
||||
today_local = _tz_mod.local_now().date()
|
||||
tomorrow_local = today_local + _td(days=1)
|
||||
today_start_utc = _tz_mod.local_midnight_utc(today_local)
|
||||
tomorrow_start_utc = _tz_mod.local_midnight_utc(tomorrow_local)
|
||||
|
||||
result = _summarize(sess, today_start_utc, tomorrow_start_utc)
|
||||
return result["metered_import"] + result["fixed_costs"]
|
||||
|
||||
return _getter
|
||||
|
||||
# --- value_getter: today's export revenue (local-day window, resets at local midnight) ---
|
||||
|
||||
def _make_export_revenue_today_getter() -> Callable[["Session"], Any]:
|
||||
"""Return a getter for today's export revenue (metered + tax credit for today).
|
||||
|
||||
Same window semantics as import_cost_today.
|
||||
Returns None when no non-degraded period exists or no active contract.
|
||||
"""
|
||||
def _getter(sess: "Session") -> Any:
|
||||
from app.services.contracts import active_contract_versions
|
||||
from app.models.energy import EnergyCostPeriod as _ECP
|
||||
from app.services.energy_cost import summarize as _summarize
|
||||
from app.services import timezone as _tz_mod
|
||||
from sqlalchemy import func as _func
|
||||
from datetime import timedelta as _td
|
||||
|
||||
# Quick check: any non-degraded period at all?
|
||||
has_data = sess.query(_func.sum(_ECP.export_revenue)).filter(
|
||||
_ECP.degraded.is_(False)
|
||||
).scalar()
|
||||
if has_data is None:
|
||||
return None
|
||||
|
||||
versions = active_contract_versions(sess)
|
||||
if not versions:
|
||||
return None
|
||||
|
||||
today_local = _tz_mod.local_now().date()
|
||||
tomorrow_local = today_local + _td(days=1)
|
||||
today_start_utc = _tz_mod.local_midnight_utc(today_local)
|
||||
tomorrow_start_utc = _tz_mod.local_midnight_utc(tomorrow_local)
|
||||
|
||||
result = _summarize(sess, today_start_utc, tomorrow_start_utc)
|
||||
return result["metered_export"] + result["credits"]
|
||||
|
||||
return _getter
|
||||
|
||||
# Price unit string: "<currency>/kWh"
|
||||
price_unit = f"{currency}/kWh"
|
||||
|
||||
@@ -672,6 +776,40 @@ def _energy_cost_provider(session: Session) -> list[ExposableEntity]:
|
||||
value_getter=_make_export_revenue_getter(),
|
||||
state_class="total",
|
||||
),
|
||||
# Daily entities: reset at local midnight, state_class=total_increasing.
|
||||
#
|
||||
# device_class=monetary is correct here. The HA developer docs (long-term
|
||||
# statistics section) prohibit MONETARY from being combined with
|
||||
# state_class=measurement — they do NOT prohibit it with total or
|
||||
# total_increasing. monetary+total_increasing is valid (the cumulative
|
||||
# entities above use monetary+total with no issue).
|
||||
#
|
||||
# total_increasing is appropriate because these daily quantities are
|
||||
# non-negative (import/export metered cost ≥ 0, fixed standing fee/tax
|
||||
# credit ≥ 0) and monotonically non-decreasing within any given local day.
|
||||
# When the local midnight rolls over the value drops back to ~1 day's fixed
|
||||
# fee; HA interprets that decrease as a new cycle, giving correct daily
|
||||
# aggregation without any explicit last_reset pipeline.
|
||||
ExposableEntity(
|
||||
key="energy.import_cost_today",
|
||||
component="sensor",
|
||||
device=device_info,
|
||||
device_class="monetary",
|
||||
unit=currency,
|
||||
name="Energy Import Cost Today (incl. standing)",
|
||||
value_getter=_make_import_cost_today_getter(),
|
||||
state_class="total_increasing",
|
||||
),
|
||||
ExposableEntity(
|
||||
key="energy.export_revenue_today",
|
||||
component="sensor",
|
||||
device=device_info,
|
||||
device_class="monetary",
|
||||
unit=currency,
|
||||
name="Energy Export Revenue Today (incl. tax credit)",
|
||||
value_getter=_make_export_revenue_today_getter(),
|
||||
state_class="total_increasing",
|
||||
),
|
||||
]
|
||||
|
||||
return entities
|
||||
|
||||
@@ -246,4 +246,93 @@ describe('ContractForm', () => {
|
||||
|
||||
expect(onClose).toHaveBeenCalled()
|
||||
})
|
||||
|
||||
it('prefills fields from the open version when in add-version mode', async () => {
|
||||
// FU11: add-version mode should auto-prefill rate fields from the contract's
|
||||
// current open version so the user only has to change what's different.
|
||||
const CONTRACT_DETAIL = {
|
||||
id: 42,
|
||||
name: 'My Contract',
|
||||
kind: 'manual',
|
||||
active: true,
|
||||
currency: 'EUR',
|
||||
created_at: '2026-01-01T00:00:00Z',
|
||||
updated_at: '2026-01-01T00:00:00Z',
|
||||
versions: [
|
||||
{
|
||||
id: 1,
|
||||
contract_id: 42,
|
||||
effective_from: '2026-01-01T00:00:00Z',
|
||||
effective_to: null, // open version
|
||||
values: {
|
||||
energy: {
|
||||
buy: { normal: 0.133, dal: 0.127 },
|
||||
sell: { normal: 0.05, dal: 0.05 },
|
||||
energy_tax: 0.11,
|
||||
ode: 0.0,
|
||||
},
|
||||
standing: {
|
||||
network_fee: 30.0,
|
||||
management_fee: 60.0,
|
||||
},
|
||||
credits: {
|
||||
heffingskorting: 365.0,
|
||||
},
|
||||
},
|
||||
created_at: '2026-01-01T00:00:00Z',
|
||||
},
|
||||
],
|
||||
}
|
||||
|
||||
mockGet.mockImplementation((path: string) => {
|
||||
if (path === '/api/energy/profiles') {
|
||||
return Promise.resolve({ data: PROFILES_RESPONSE })
|
||||
}
|
||||
if (path === '/api/energy/contracts/{contract_id}') {
|
||||
return Promise.resolve({ data: CONTRACT_DETAIL })
|
||||
}
|
||||
return Promise.resolve({ data: null })
|
||||
})
|
||||
|
||||
const onClose = vi.fn()
|
||||
const onSaved = vi.fn()
|
||||
|
||||
renderWithProviders(
|
||||
<ContractForm contractId={42} defaultKind="manual" onClose={onClose} onSaved={onSaved} />,
|
||||
)
|
||||
|
||||
const user = userEvent.setup()
|
||||
|
||||
// Wait for the form to render and profile fields to appear
|
||||
await waitFor(() => {
|
||||
expect(screen.getByTestId('contract-section-energy')).toBeInTheDocument()
|
||||
}, { timeout: 3000 })
|
||||
|
||||
// Wait for prefill to apply: both profile and contract detail queries must resolve.
|
||||
// Fill in the required effective_from date and submit; the submitted values
|
||||
// body.values should contain the prefilled rates from the open version.
|
||||
mockPost.mockResolvedValue({ data: {} })
|
||||
|
||||
const effectiveInput = screen.getByTestId('contract-effective-from')
|
||||
await user.type(effectiveInput, '2026-07-01')
|
||||
|
||||
await user.click(screen.getByTestId('contract-form-submit'))
|
||||
|
||||
// The submitted body should contain the prefilled values from CONTRACT_DETAIL
|
||||
await waitFor(() => {
|
||||
expect(mockPost).toHaveBeenCalledWith(
|
||||
'/api/energy/contracts/{contract_id}/versions',
|
||||
expect.objectContaining({
|
||||
body: expect.objectContaining({
|
||||
values: expect.objectContaining({
|
||||
standing: expect.objectContaining({
|
||||
network_fee: 30,
|
||||
management_fee: 60,
|
||||
}),
|
||||
}),
|
||||
}),
|
||||
}),
|
||||
)
|
||||
}, { timeout: 3000 })
|
||||
})
|
||||
})
|
||||
|
||||
@@ -11,7 +11,7 @@
|
||||
* + profile value fields for the contract's kind.
|
||||
*/
|
||||
|
||||
import { useState } from 'react'
|
||||
import { useState, useMemo } from 'react'
|
||||
import {
|
||||
Modal,
|
||||
Stack,
|
||||
@@ -27,7 +27,7 @@ import {
|
||||
Divider,
|
||||
Title,
|
||||
} from '@mantine/core'
|
||||
import { useEnergyProfiles, useCreateContract, useAddContractVersion } from './hooks'
|
||||
import { useEnergyProfiles, useCreateContract, useAddContractVersion, useContractDetail } from './hooks'
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Props
|
||||
@@ -136,6 +136,9 @@ export function ContractForm({ contractId, defaultKind, onClose, onSaved }: Cont
|
||||
// Profiles query
|
||||
const profilesQuery = useEnergyProfiles()
|
||||
|
||||
// Contract detail query — only used in add-version mode to prefill from the open version.
|
||||
const contractDetailQuery = useContractDetail(contractId ?? 0)
|
||||
|
||||
// Create mode fields
|
||||
const [name, setName] = useState('')
|
||||
const [selectedKind, setSelectedKind] = useState<string | null>(defaultKind ?? null)
|
||||
@@ -143,8 +146,9 @@ export function ContractForm({ contractId, defaultKind, onClose, onSaved }: Cont
|
||||
// ISO date string "YYYY-MM-DD" for effective_from; empty = default to now
|
||||
const [effectiveFromStr, setEffectiveFromStr] = useState('')
|
||||
|
||||
// Dynamic profile field values: key = "<section>.<fieldPath>", value = number
|
||||
const [fieldValues, setFieldValues] = useState<Record<string, number | string>>({})
|
||||
// Dynamic profile field values: key = "<section>.<fieldPath>", value = number.
|
||||
// User edits are stored here; for add-version mode this is merged with prefillValues.
|
||||
const [userEdits, setUserEdits] = useState<Record<string, number | string>>({})
|
||||
|
||||
const [error, setError] = useState<string | null>(null)
|
||||
|
||||
@@ -166,24 +170,90 @@ export function ContractForm({ contractId, defaultKind, onClose, onSaved }: Cont
|
||||
// Find the selected profile structure
|
||||
const selectedProfile = profiles.find((p: Record<string, unknown>) => p.kind === effectiveKind)
|
||||
|
||||
// Extract section → leaf fields mapping from the selected profile
|
||||
const sectionFields: Record<string, LeafField[]> = {}
|
||||
if (selectedProfile) {
|
||||
// Extract section → leaf fields mapping from the selected profile (memoized for stable reference).
|
||||
const sectionFields = useMemo<Record<string, LeafField[]>>(() => {
|
||||
if (!selectedProfile) return {}
|
||||
const profileObj = selectedProfile as Record<string, unknown>
|
||||
const result: Record<string, LeafField[]> = {}
|
||||
for (const [key, val] of Object.entries(profileObj)) {
|
||||
// Skip metadata fields
|
||||
if (key === 'kind' || key === 'label') continue
|
||||
if (typeof val === 'object' && val !== null && !isLeaf(val)) {
|
||||
sectionFields[key] = extractLeafFields(val as Record<string, unknown>)
|
||||
result[key] = extractLeafFields(val as Record<string, unknown>)
|
||||
}
|
||||
}
|
||||
}
|
||||
return result
|
||||
}, [selectedProfile])
|
||||
|
||||
// Add-version prefill: compute the seeded values from the contract's open version.
|
||||
// Returns the flat fieldValues dict or null when data is not ready.
|
||||
const prefillValues = useMemo<Record<string, number | string> | null>(() => {
|
||||
if (!isAddVersion) return null
|
||||
if (contractDetailQuery.isLoading || contractDetailQuery.isError) return null
|
||||
if (Object.keys(sectionFields).length === 0) return null
|
||||
|
||||
const detail = contractDetailQuery.data
|
||||
if (!detail || !detail.versions || detail.versions.length === 0) return null
|
||||
|
||||
const versions = detail.versions as Array<{
|
||||
effective_from: string
|
||||
effective_to: string | null
|
||||
values: Record<string, unknown>
|
||||
}>
|
||||
let openVersion = versions.find((v) => v.effective_to == null)
|
||||
if (!openVersion) {
|
||||
openVersion = [...versions].sort((a, b) =>
|
||||
a.effective_from < b.effective_from ? 1 : -1
|
||||
)[0]
|
||||
}
|
||||
if (!openVersion?.values) return null
|
||||
|
||||
const seeded: Record<string, number | string> = {}
|
||||
for (const [section, fields] of Object.entries(sectionFields)) {
|
||||
const sectionVal = (openVersion.values as Record<string, unknown>)[section]
|
||||
if (typeof sectionVal !== 'object' || sectionVal === null) continue
|
||||
for (const leaf of fields) {
|
||||
const parts = leaf.fieldPath.split('.')
|
||||
let cursor: unknown = sectionVal
|
||||
for (const part of parts) {
|
||||
if (typeof cursor !== 'object' || cursor === null) { cursor = undefined; break }
|
||||
cursor = (cursor as Record<string, unknown>)[part]
|
||||
}
|
||||
if (cursor != null && (typeof cursor === 'number' || typeof cursor === 'string')) {
|
||||
const numVal = typeof cursor === 'number' ? cursor : parseFloat(String(cursor))
|
||||
seeded[`${section}.${leaf.fieldPath}`] = isNaN(numVal) ? 0 : numVal
|
||||
}
|
||||
}
|
||||
}
|
||||
return Object.keys(seeded).length > 0 ? seeded : null
|
||||
}, [
|
||||
isAddVersion,
|
||||
contractDetailQuery.isLoading,
|
||||
contractDetailQuery.isError,
|
||||
contractDetailQuery.data,
|
||||
sectionFields,
|
||||
])
|
||||
|
||||
// The effective field values: user edits override prefill; prefill is the base.
|
||||
// In add-version mode: when the user has not yet edited any field (userEdits is empty),
|
||||
// prefillValues is used as the initial base. Once the user edits any field, their
|
||||
// full merged value (prefill + override) is stored in userEdits.
|
||||
const fieldValues: Record<string, number | string> =
|
||||
isAddVersion && prefillValues !== null && Object.keys(userEdits).length === 0
|
||||
? prefillValues
|
||||
: userEdits
|
||||
|
||||
function handleFieldChange(key: string, val: number | string) {
|
||||
setFieldValues((prev) => ({ ...prev, [key]: val }))
|
||||
// On first edit in add-version mode, copy prefill into userEdits so we don't
|
||||
// lose the other prefilled values when the user changes one field.
|
||||
setUserEdits((prev) => {
|
||||
const base = isAddVersion && prefillValues !== null && Object.keys(prev).length === 0
|
||||
? { ...prefillValues }
|
||||
: prev
|
||||
return { ...base, [key]: val }
|
||||
})
|
||||
}
|
||||
|
||||
// Initialize default values when profile changes
|
||||
// Initialize default values when profile changes (create mode only)
|
||||
function initDefaults(kind: string | null) {
|
||||
if (!kind) return
|
||||
const profile = profiles.find((p: Record<string, unknown>) => p.kind === kind)
|
||||
@@ -199,7 +269,7 @@ export function ContractForm({ contractId, defaultKind, onClose, onSaved }: Cont
|
||||
}
|
||||
}
|
||||
}
|
||||
setFieldValues(defaults)
|
||||
setUserEdits(defaults)
|
||||
}
|
||||
|
||||
async function handleSubmit(e: React.FormEvent) {
|
||||
@@ -264,7 +334,7 @@ export function ContractForm({ contractId, defaultKind, onClose, onSaved }: Cont
|
||||
size="md"
|
||||
data-testid="contract-form-modal"
|
||||
>
|
||||
{profilesQuery.isLoading && (
|
||||
{(profilesQuery.isLoading || (isAddVersion && contractDetailQuery.isLoading)) && (
|
||||
<Center py="md">
|
||||
<Loader size="sm" data-testid="contract-form-loading" />
|
||||
</Center>
|
||||
@@ -276,7 +346,13 @@ export function ContractForm({ contractId, defaultKind, onClose, onSaved }: Cont
|
||||
</Alert>
|
||||
)}
|
||||
|
||||
{!profilesQuery.isLoading && (
|
||||
{isAddVersion && contractDetailQuery.isError && !contractDetailQuery.isLoading && (
|
||||
<Alert color="yellow" mb="sm" data-testid="contract-form-detail-error">
|
||||
Could not load existing contract values for prefill — fields start at 0.
|
||||
</Alert>
|
||||
)}
|
||||
|
||||
{!profilesQuery.isLoading && !(isAddVersion && contractDetailQuery.isLoading) && (
|
||||
<form onSubmit={handleSubmit} data-testid="contract-form">
|
||||
<Stack gap="sm">
|
||||
{/* Create mode fields */}
|
||||
|
||||
+356
-34
@@ -1,24 +1,29 @@
|
||||
"""Tests for M6-T08 + FU6: energy_cost expose provider + state publish.
|
||||
"""Tests for M6-T08 + FU6 + FU11: energy_cost expose provider + state publish.
|
||||
|
||||
Coverage:
|
||||
1. build_catalog contains all 4 energy_cost entities.
|
||||
1. build_catalog contains all 6 energy_cost entities (4 original + 2 daily).
|
||||
2. Cumulative entities (import_cost_total / export_revenue_total) have
|
||||
state_class="total" and device_class="monetary".
|
||||
3. All 4 energy_cost entities default to enabled=False (no toggle row).
|
||||
4. value_getter: buy/sell price from pricing snapshot for tibber and manual kinds.
|
||||
5. value_getter: cumulative SUM(import_cost) / SUM(export_revenue) from
|
||||
3. Daily entities (import_cost_today / export_revenue_today) have
|
||||
state_class="total_increasing" and device_class="monetary".
|
||||
4. All 6 energy_cost entities default to enabled=False (no toggle row).
|
||||
5. value_getter: buy/sell price from pricing snapshot for tibber and manual kinds.
|
||||
6. value_getter: cumulative SUM(import_cost) / SUM(export_revenue) from
|
||||
non-degraded rows; degraded rows excluded.
|
||||
6. value_getter returns None when no non-degraded period exists.
|
||||
7. MQTT not enabled → publish_states is a no-op (no raises, no publish calls).
|
||||
8. Integration: build_discovery_payload on an energy_cost entity does NOT raise
|
||||
7. value_getter returns None when no non-degraded period exists.
|
||||
8. MQTT not enabled → publish_states is a no-op (no raises, no publish calls).
|
||||
9. Integration: build_discovery_payload on an energy_cost entity does NOT raise
|
||||
IndexError (validates 2-element identifiers).
|
||||
9. Keys are stable fixed strings (not derived from mutable data or DB ids).
|
||||
10. Provider registered: energy_cost entities appear alongside modbus entities
|
||||
10. Keys are stable fixed strings (not derived from mutable data or DB ids).
|
||||
11. Provider registered: energy_cost entities appear alongside modbus entities
|
||||
in the full catalog.
|
||||
11. Standing charges prorated into import_cost_total getter.
|
||||
12. Tax credit (heffingskorting) prorated into export_revenue_total getter.
|
||||
13. effective_from in future → standing/credit cumulative = 0.
|
||||
14. No active contract → getters fall back to pure SUM.
|
||||
12. Standing charges prorated into import_cost_total getter.
|
||||
13. Tax credit (heffingskorting) prorated into export_revenue_total getter.
|
||||
14. effective_from in future → standing/credit cumulative = 0.
|
||||
15. No active contract → getters fall back to pure SUM (cumulative) or None (daily).
|
||||
16. FU11: anchor = max(contract_start, recording_start) — pre-recording fixed costs excluded.
|
||||
17. FU11: daily getter uses today's local window; returns None without active contract.
|
||||
18. FU11: daily getter None when no non-degraded periods.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
@@ -127,8 +132,8 @@ def energy_db(tmp_path: Path):
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
|
||||
def test_build_catalog_contains_4_energy_cost_entities(energy_db) -> None:
|
||||
"""build_catalog must include all 4 energy_cost sensor entities."""
|
||||
def test_build_catalog_contains_6_energy_cost_entities(energy_db) -> None:
|
||||
"""build_catalog must include all 6 energy_cost sensor entities (4 original + 2 daily)."""
|
||||
from app.integrations.expose import build_catalog
|
||||
|
||||
with Session(energy_db) as session:
|
||||
@@ -140,6 +145,8 @@ def test_build_catalog_contains_4_energy_cost_entities(energy_db) -> None:
|
||||
"energy.sell_price_now",
|
||||
"energy.import_cost_total",
|
||||
"energy.export_revenue_total",
|
||||
"energy.import_cost_today",
|
||||
"energy.export_revenue_today",
|
||||
}
|
||||
assert expected_keys == energy_keys, (
|
||||
f"Expected energy keys {expected_keys!r}, got {energy_keys!r}"
|
||||
@@ -184,14 +191,14 @@ def test_cumulative_entities_have_monetary_device_class(energy_db) -> None:
|
||||
|
||||
|
||||
def test_all_energy_entities_are_sensors(energy_db) -> None:
|
||||
"""All 4 energy_cost entities must have component='sensor'."""
|
||||
"""All 6 energy_cost entities must have component='sensor'."""
|
||||
from app.integrations.expose import build_catalog
|
||||
|
||||
with Session(energy_db) as session:
|
||||
catalog = build_catalog(session)
|
||||
|
||||
energy_entries = [e for e in catalog if e.entity.key.startswith("energy.")]
|
||||
assert len(energy_entries) == 4
|
||||
assert len(energy_entries) == 6
|
||||
for entry in energy_entries:
|
||||
assert entry.entity.component == "sensor", (
|
||||
f"Expected component='sensor' for {entry.entity.key!r}, "
|
||||
@@ -205,14 +212,14 @@ def test_all_energy_entities_are_sensors(energy_db) -> None:
|
||||
|
||||
|
||||
def test_energy_cost_entities_default_to_disabled(energy_db) -> None:
|
||||
"""All 4 energy_cost entities must default to enabled=False (no toggle row)."""
|
||||
"""All 6 energy_cost entities must default to enabled=False (no toggle row)."""
|
||||
from app.integrations.expose import build_catalog
|
||||
|
||||
with Session(energy_db) as session:
|
||||
catalog = build_catalog(session)
|
||||
|
||||
energy_entries = [e for e in catalog if e.entity.key.startswith("energy.")]
|
||||
assert len(energy_entries) == 4
|
||||
assert len(energy_entries) == 6
|
||||
for entry in energy_entries:
|
||||
assert entry.enabled is False, (
|
||||
f"Entity {entry.entity.key!r} must default to enabled=False "
|
||||
@@ -629,7 +636,7 @@ def test_build_discovery_payload_no_index_error_for_energy_entities(energy_db) -
|
||||
catalog = build_catalog(session)
|
||||
|
||||
energy_entries = [e for e in catalog if e.entity.key.startswith("energy.")]
|
||||
assert len(energy_entries) == 4, "Expected 4 energy_cost entities in catalog"
|
||||
assert len(energy_entries) == 6, "Expected 6 energy_cost entities in catalog"
|
||||
|
||||
for entry in energy_entries:
|
||||
# Must not raise — specifically no IndexError from identifiers[1]
|
||||
@@ -666,7 +673,7 @@ def test_energy_cost_entities_omit_availability_so_ha_shows_them(energy_db) -> N
|
||||
catalog = build_catalog(session)
|
||||
|
||||
energy_entries = [e for e in catalog if e.entity.key.startswith("energy.")]
|
||||
assert len(energy_entries) == 4
|
||||
assert len(energy_entries) == 6
|
||||
|
||||
for entry in energy_entries:
|
||||
assert entry.entity.device.provides_availability is False
|
||||
@@ -761,6 +768,8 @@ def test_energy_entity_keys_are_stable_fixed_strings(energy_db) -> None:
|
||||
"energy.sell_price_now",
|
||||
"energy.import_cost_total",
|
||||
"energy.export_revenue_total",
|
||||
"energy.import_cost_today",
|
||||
"energy.export_revenue_today",
|
||||
}
|
||||
assert keys1 == expected_keys, (
|
||||
f"Energy keys must be exactly {expected_keys!r}, got {keys1!r}"
|
||||
@@ -871,19 +880,18 @@ _STANDING_VALUES = {
|
||||
def test_import_cost_total_includes_standing_charges(energy_db) -> None:
|
||||
"""import_cost_total getter must add prorated standing charges from active contract.
|
||||
|
||||
Principle B/D: the getter delegates to summarize(anchor → now).
|
||||
anchor = earliest version's effective_from.
|
||||
Principle B/D + FU11 anchor guardrail: the getter delegates to
|
||||
summarize(anchor → now), where anchor = max(contract_start, recording_start).
|
||||
|
||||
With network_fee=30 EUR/month + management_fee=60 EUR/month, daily_standing = 3.0 EUR/day.
|
||||
The getter uses summarize, which counts whole *local* elapsed days under Principle C.
|
||||
We pin the timezone to UTC for simplicity: local days = UTC days.
|
||||
|
||||
Setup:
|
||||
- effective_from = 10 full UTC days ago (exact UTC midnight), so today is day 11
|
||||
but Principle C counts only days D ≤ today, and today is included as 1 day.
|
||||
With anchor = 10 days ago UTC midnight and now near end of day 11:
|
||||
local (UTC) dates: [10-days-ago, today_inclusive] = 11 days.
|
||||
We place period rows within [anchor, now] so summarize sees them.
|
||||
- effective_from = 10 full UTC days ago (exact UTC midnight).
|
||||
- First period placed AT effective_from (same UTC midnight), so recording_start =
|
||||
contract_start → anchor = max(contract_start, recording_start) = contract_start.
|
||||
- Under UTC pinned, Principle C counts days [effective_from.date(), today] = 11 days.
|
||||
"""
|
||||
from decimal import Decimal
|
||||
from datetime import timedelta
|
||||
@@ -901,8 +909,9 @@ def test_import_cost_total_includes_standing_charges(energy_db) -> None:
|
||||
expected_days = (now_utc.date() - effective_from.date()).days + 1 # = 11
|
||||
|
||||
import_cost_sum = 5.00 # EUR
|
||||
# Place period rows AFTER effective_from so summarize(anchor, now) picks them up.
|
||||
t0 = effective_from + timedelta(hours=1)
|
||||
# Place period rows AT effective_from (= recording_start = contract_start → same anchor).
|
||||
# This ensures anchor = max(effective_from, effective_from) = effective_from exactly.
|
||||
t0 = effective_from # first period starts exactly at contract effective_from
|
||||
t1 = t0 + timedelta(minutes=15)
|
||||
|
||||
with Session(energy_db) as session:
|
||||
@@ -944,9 +953,12 @@ def test_import_cost_total_includes_standing_charges(energy_db) -> None:
|
||||
def test_export_revenue_total_includes_tax_credit(energy_db) -> None:
|
||||
"""export_revenue_total getter must add prorated heffingskorting from active contract.
|
||||
|
||||
Principle B/D: delegates to summarize(anchor → now).
|
||||
Principle B/D + FU11 anchor guardrail: delegates to summarize(anchor → now),
|
||||
where anchor = max(contract_start, recording_start).
|
||||
With heffingskorting=365 EUR/year, daily_credit = 365/365 = 1.0 EUR/day.
|
||||
Timezone pinned to UTC for deterministic local-day counting.
|
||||
|
||||
Setup: period placed AT effective_from → recording_start = contract_start → same anchor.
|
||||
"""
|
||||
from decimal import Decimal
|
||||
from datetime import timedelta
|
||||
@@ -961,8 +973,8 @@ def test_export_revenue_total_includes_tax_credit(energy_db) -> None:
|
||||
# Under UTC pinned: expected_days = days from effective_from.date() to today inclusive.
|
||||
expected_days = (now_utc.date() - effective_from.date()).days + 1 # = 5
|
||||
|
||||
# Place period rows AFTER effective_from.
|
||||
t0 = effective_from + timedelta(hours=1)
|
||||
# Place period rows AT effective_from → recording_start = contract_start = same anchor.
|
||||
t0 = effective_from
|
||||
t1 = t0 + timedelta(minutes=15)
|
||||
export_sum = 2.50 # EUR
|
||||
|
||||
@@ -1373,3 +1385,313 @@ def test_tibber_sell_price_not_affected_by_tariff(energy_db, reset_tariff) -> No
|
||||
assert value == pytest.approx(0.1500), (
|
||||
f"Tibber sell price must be 0.1500 regardless of tariff={tariff_val!r}, got {value!r}"
|
||||
)
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# FU11 new tests: daily entities metadata + getter behaviour
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
|
||||
def test_daily_entities_in_catalog(energy_db) -> None:
|
||||
"""FU11: catalog must include import_cost_today and export_revenue_today."""
|
||||
from app.integrations.expose import build_catalog
|
||||
|
||||
with Session(energy_db) as session:
|
||||
catalog = build_catalog(session)
|
||||
|
||||
daily_keys = {
|
||||
"energy.import_cost_today",
|
||||
"energy.export_revenue_today",
|
||||
}
|
||||
found = {e.entity.key for e in catalog if e.entity.key in daily_keys}
|
||||
assert found == daily_keys, f"Expected daily keys {daily_keys!r} in catalog, got {found!r}"
|
||||
|
||||
|
||||
def test_daily_entities_have_total_increasing_state_class(energy_db) -> None:
|
||||
"""FU11: daily entities must have state_class='total_increasing' (not 'total')."""
|
||||
from app.integrations.expose import build_catalog
|
||||
|
||||
with Session(energy_db) as session:
|
||||
catalog = build_catalog(session)
|
||||
|
||||
daily_keys = {"energy.import_cost_today", "energy.export_revenue_today"}
|
||||
for entry in catalog:
|
||||
if entry.entity.key in daily_keys:
|
||||
assert entry.entity.state_class == "total_increasing", (
|
||||
f"Daily entity {entry.entity.key!r} must have state_class='total_increasing', "
|
||||
f"got {entry.entity.state_class!r}"
|
||||
)
|
||||
|
||||
|
||||
def test_daily_entities_have_monetary_device_class(energy_db) -> None:
|
||||
"""FU11: daily entities must have device_class='monetary' and state_class='total_increasing'.
|
||||
|
||||
HA developer docs prohibit MONETARY with state_class=measurement, but explicitly
|
||||
allow it with total and total_increasing. monetary+total_increasing is the correct
|
||||
combination for a non-negative, monotonically non-decreasing daily quantity that
|
||||
resets at local midnight.
|
||||
"""
|
||||
from app.integrations.expose import build_catalog
|
||||
|
||||
with Session(energy_db) as session:
|
||||
catalog = build_catalog(session)
|
||||
|
||||
daily_keys = {"energy.import_cost_today", "energy.export_revenue_today"}
|
||||
for entry in catalog:
|
||||
if entry.entity.key in daily_keys:
|
||||
assert entry.entity.device_class == "monetary", (
|
||||
f"Daily entity {entry.entity.key!r} must have device_class='monetary', "
|
||||
f"got {entry.entity.device_class!r}"
|
||||
)
|
||||
|
||||
|
||||
def test_daily_entities_default_disabled(energy_db) -> None:
|
||||
"""FU11: daily entities must default to enabled=False (no toggle row seeded)."""
|
||||
from app.integrations.expose import build_catalog
|
||||
|
||||
with Session(energy_db) as session:
|
||||
catalog = build_catalog(session)
|
||||
|
||||
daily_keys = {"energy.import_cost_today", "energy.export_revenue_today"}
|
||||
for entry in catalog:
|
||||
if entry.entity.key in daily_keys:
|
||||
assert entry.enabled is False, (
|
||||
f"Daily entity {entry.entity.key!r} must default to enabled=False, "
|
||||
f"got enabled={entry.enabled!r}"
|
||||
)
|
||||
|
||||
|
||||
def test_import_cost_today_getter_uses_local_day_window(energy_db) -> None:
|
||||
"""FU11: import_cost_today getter returns value for today's local window.
|
||||
|
||||
Setup: period at local 'today' (within today's UTC window), active contract.
|
||||
Timezone pinned to UTC. Verifies: value = metered_import + fixed_costs for 1 day
|
||||
(Principle C: today counts as elapsed if we're past local midnight — which UTC is).
|
||||
"""
|
||||
from datetime import timedelta
|
||||
from unittest.mock import patch
|
||||
from zoneinfo import ZoneInfo
|
||||
from app.integrations.expose import build_catalog
|
||||
from app.services import timezone as _tz_mod
|
||||
|
||||
now_utc = datetime.now(timezone.utc)
|
||||
# Place a period in today's window (1 hour ago, well within today UTC midnight→tomorrow)
|
||||
# When TZ=UTC, local today = UTC today, so a period 1h ago is in today's window.
|
||||
t0 = now_utc.replace(minute=0, second=0, microsecond=0) - timedelta(hours=1)
|
||||
# Ensure t0 is still today UTC (handle edge case where now is < 1h past UTC midnight)
|
||||
if t0.date() < now_utc.date():
|
||||
t0 = now_utc.replace(hour=0, minute=0, second=0, microsecond=0)
|
||||
|
||||
# Contract starting well before today
|
||||
effective_from = now_utc.replace(hour=0, minute=0, second=0, microsecond=0) - timedelta(days=30)
|
||||
|
||||
import_cost_today = 1.23
|
||||
|
||||
with Session(energy_db) as session:
|
||||
_make_contract_with_version(
|
||||
session,
|
||||
values=_STANDING_VALUES,
|
||||
effective_from=effective_from,
|
||||
active=True,
|
||||
)
|
||||
_make_period(session, period_start=t0, import_cost=import_cost_today, degraded=False)
|
||||
session.commit()
|
||||
|
||||
with Session(energy_db) as session:
|
||||
# Pin timezone to UTC so today_local = UTC date (deterministic on any CI host).
|
||||
with patch.object(_tz_mod, "local_tz", return_value=ZoneInfo("UTC")):
|
||||
catalog = build_catalog(session)
|
||||
today_entry = next(
|
||||
e for e in catalog if e.entity.key == "energy.import_cost_today"
|
||||
)
|
||||
value = today_entry.entity.value_getter(session)
|
||||
|
||||
# Principle C: today counts as 1 day (we're within it, and it's "today").
|
||||
# daily_standing = (30+60)/30 = 3.0 EUR/day × 1 day = 3.0
|
||||
from decimal import Decimal
|
||||
daily_standing = Decimal("90") / Decimal("30") # = 3.0
|
||||
expected = float(Decimal(str(import_cost_today)) + daily_standing * 1)
|
||||
|
||||
assert value == pytest.approx(expected, rel=1e-6), (
|
||||
f"import_cost_today expected {expected}, got {value!r}"
|
||||
)
|
||||
|
||||
|
||||
def test_export_revenue_today_getter_uses_local_day_window(energy_db) -> None:
|
||||
"""FU11: export_revenue_today getter returns value for today's local window."""
|
||||
from datetime import timedelta
|
||||
from unittest.mock import patch
|
||||
from zoneinfo import ZoneInfo
|
||||
from app.integrations.expose import build_catalog
|
||||
from app.services import timezone as _tz_mod
|
||||
|
||||
now_utc = datetime.now(timezone.utc)
|
||||
t0 = now_utc.replace(minute=0, second=0, microsecond=0) - timedelta(hours=1)
|
||||
if t0.date() < now_utc.date():
|
||||
t0 = now_utc.replace(hour=0, minute=0, second=0, microsecond=0)
|
||||
|
||||
effective_from = now_utc.replace(hour=0, minute=0, second=0, microsecond=0) - timedelta(days=30)
|
||||
export_today = 0.75
|
||||
|
||||
with Session(energy_db) as session:
|
||||
_make_contract_with_version(
|
||||
session,
|
||||
values=_STANDING_VALUES,
|
||||
effective_from=effective_from,
|
||||
active=True,
|
||||
)
|
||||
_make_period(session, period_start=t0, export_revenue=export_today, degraded=False)
|
||||
session.commit()
|
||||
|
||||
with Session(energy_db) as session:
|
||||
with patch.object(_tz_mod, "local_tz", return_value=ZoneInfo("UTC")):
|
||||
catalog = build_catalog(session)
|
||||
today_entry = next(
|
||||
e for e in catalog if e.entity.key == "energy.export_revenue_today"
|
||||
)
|
||||
value = today_entry.entity.value_getter(session)
|
||||
|
||||
from decimal import Decimal
|
||||
daily_credit = Decimal("365") / Decimal("365") # = 1.0 EUR/day × 1 day
|
||||
expected = float(Decimal(str(export_today)) + daily_credit * 1)
|
||||
|
||||
assert value == pytest.approx(expected, rel=1e-6), (
|
||||
f"export_revenue_today expected {expected}, got {value!r}"
|
||||
)
|
||||
|
||||
|
||||
def test_daily_getter_returns_none_when_no_active_contract(energy_db) -> None:
|
||||
"""FU11: daily getters return None when no active contract exists."""
|
||||
from app.integrations.expose import build_catalog
|
||||
|
||||
t0 = datetime(2026, 6, 25, 10, 0, tzinfo=timezone.utc)
|
||||
|
||||
with Session(energy_db) as session:
|
||||
# Inactive contract
|
||||
_make_contract_with_version(
|
||||
session,
|
||||
values=_STANDING_VALUES,
|
||||
effective_from=t0,
|
||||
active=False,
|
||||
)
|
||||
_make_period(session, period_start=t0, import_cost=1.0, export_revenue=0.5, degraded=False)
|
||||
session.commit()
|
||||
|
||||
with Session(energy_db) as session:
|
||||
catalog = build_catalog(session)
|
||||
import_today_entry = next(
|
||||
e for e in catalog if e.entity.key == "energy.import_cost_today"
|
||||
)
|
||||
export_today_entry = next(
|
||||
e for e in catalog if e.entity.key == "energy.export_revenue_today"
|
||||
)
|
||||
import_val = import_today_entry.entity.value_getter(session)
|
||||
export_val = export_today_entry.entity.value_getter(session)
|
||||
|
||||
assert import_val is None, (
|
||||
f"import_cost_today must be None with no active contract, got {import_val!r}"
|
||||
)
|
||||
assert export_val is None, (
|
||||
f"export_revenue_today must be None with no active contract, got {export_val!r}"
|
||||
)
|
||||
|
||||
|
||||
def test_daily_getter_returns_none_when_no_non_degraded_periods(energy_db) -> None:
|
||||
"""FU11: daily getters return None when only degraded rows exist."""
|
||||
from app.integrations.expose import build_catalog
|
||||
|
||||
t0 = datetime(2026, 6, 25, 10, 0, tzinfo=timezone.utc)
|
||||
|
||||
with Session(energy_db) as session:
|
||||
_make_contract_with_version(
|
||||
session,
|
||||
values=_STANDING_VALUES,
|
||||
effective_from=t0 - datetime.resolution * 0, # same time is fine here
|
||||
active=True,
|
||||
)
|
||||
_make_period(session, period_start=t0, import_cost=0.0, degraded=True)
|
||||
session.commit()
|
||||
|
||||
with Session(energy_db) as session:
|
||||
catalog = build_catalog(session)
|
||||
import_today_entry = next(
|
||||
e for e in catalog if e.entity.key == "energy.import_cost_today"
|
||||
)
|
||||
value = import_today_entry.entity.value_getter(session)
|
||||
|
||||
assert value is None, (
|
||||
f"import_cost_today must be None with only degraded rows, got {value!r}"
|
||||
)
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# FU11 new test: anchor = max(contract_start, recording_start)
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
|
||||
def test_cumulative_anchor_uses_recording_start_when_later_than_contract(energy_db) -> None:
|
||||
"""FU11: anchor = max(contract_start, recording_start) — no pre-recording fixed costs.
|
||||
|
||||
Scenario: contract effective_from = 180 days ago (lots of standing charges if used
|
||||
as anchor), but first non-degraded period_start = 7 days ago. Expected: anchor is
|
||||
7 days ago → only 8 days of standing charges (7 + today under Principle C).
|
||||
|
||||
Without the fix, anchor would be 180 days ago → ~180 days × 3 EUR/day = €540+.
|
||||
"""
|
||||
from decimal import Decimal
|
||||
from datetime import timedelta
|
||||
from unittest.mock import patch
|
||||
from zoneinfo import ZoneInfo
|
||||
from app.integrations.expose import build_catalog
|
||||
from app.services import timezone as _tz_mod
|
||||
|
||||
now_utc = datetime.now(timezone.utc)
|
||||
midnight_today = now_utc.replace(hour=0, minute=0, second=0, microsecond=0)
|
||||
|
||||
# Contract starts 180 days ago (far before any data)
|
||||
contract_start = midnight_today - timedelta(days=180)
|
||||
# First (and only) data period starts 7 days ago
|
||||
recording_start = midnight_today - timedelta(days=7)
|
||||
|
||||
t0 = recording_start # first period at recording start
|
||||
|
||||
with Session(energy_db) as session:
|
||||
_make_contract_with_version(
|
||||
session,
|
||||
values=_STANDING_VALUES,
|
||||
effective_from=contract_start,
|
||||
active=True,
|
||||
)
|
||||
_make_period(session, period_start=t0, import_cost=5.00, degraded=False)
|
||||
session.commit()
|
||||
|
||||
with Session(energy_db) as session:
|
||||
with patch.object(_tz_mod, "local_tz", return_value=ZoneInfo("UTC")):
|
||||
catalog = build_catalog(session)
|
||||
import_entry = next(
|
||||
e for e in catalog if e.entity.key == "energy.import_cost_total"
|
||||
)
|
||||
value = import_entry.entity.value_getter(session)
|
||||
|
||||
# Anchor = recording_start (7 days ago UTC midnight).
|
||||
# Principle C (UTC pinned): count local days from recording_start.date() to today inclusive.
|
||||
# That's 7+1 = 8 days.
|
||||
expected_days = (now_utc.date() - recording_start.date()).days + 1 # = 8
|
||||
daily_standing = Decimal("90") / Decimal("30") # = 3.0 EUR/day
|
||||
expected = float(Decimal("5.00") + daily_standing * expected_days)
|
||||
|
||||
# Without the fix, value would include ~180 days × 3 EUR/day = ~€540+ of extra standing.
|
||||
# With the fix, value ≈ 5.00 + 3.0 × 8 = 29.00.
|
||||
assert value == pytest.approx(expected, rel=1e-6), (
|
||||
f"Expected anchor=recording_start anchor, "
|
||||
f"import_cost_total={expected} (metered=5.00 + standing={float(daily_standing*expected_days)} "
|
||||
f"over {expected_days} days), got {value!r}"
|
||||
)
|
||||
|
||||
# Also verify that using the old anchor (contract start) would give a very different result.
|
||||
old_expected_days = (now_utc.date() - contract_start.date()).days + 1 # ~181 days
|
||||
old_expected = float(Decimal("5.00") + daily_standing * old_expected_days)
|
||||
assert abs(value - old_expected) > 100, (
|
||||
f"Old (wrong) anchor would yield ~{old_expected:.2f}, "
|
||||
f"the new value {value:.2f} should differ by >€100"
|
||||
)
|
||||
|
||||
@@ -205,9 +205,10 @@ def test_register_provider_direct_call():
|
||||
def test_build_catalog_empty_with_no_devices(expose_db):
|
||||
"""build_catalog with no enabled modbus devices must contain no modbus entities.
|
||||
|
||||
The energy_cost provider is always registered and always produces its 4 entities
|
||||
regardless of device state, so the catalog will not be empty. This test checks
|
||||
that no *modbus* entities are present when there are no enabled modbus devices.
|
||||
The energy_cost provider is always registered and always produces its 6 entities
|
||||
(4 original + 2 daily) regardless of device state, so the catalog will not be empty.
|
||||
This test checks that no *modbus* entities are present when there are no enabled
|
||||
modbus devices.
|
||||
"""
|
||||
from app.integrations.expose import build_catalog
|
||||
|
||||
@@ -215,16 +216,16 @@ def test_build_catalog_empty_with_no_devices(expose_db):
|
||||
catalog = build_catalog(session)
|
||||
|
||||
# The modbus provider finds no enabled devices → no modbus entities.
|
||||
# The energy_cost provider always produces 4 entities, so the catalog is non-empty.
|
||||
# The energy_cost provider always produces 6 entities, so the catalog is non-empty.
|
||||
modbus_entities = [e for e in catalog if e.entity.key.startswith("modbus.")]
|
||||
assert modbus_entities == [], (
|
||||
"Expected no modbus entities when no modbus devices are enabled"
|
||||
)
|
||||
|
||||
# The 4 energy_cost entities should always be present.
|
||||
# The 6 energy_cost entities should always be present (4 original + 2 daily).
|
||||
energy_keys = {e.entity.key for e in catalog if e.entity.key.startswith("energy.")}
|
||||
assert len(energy_keys) == 4, (
|
||||
f"Expected exactly 4 energy_cost entities, got {energy_keys!r}"
|
||||
assert len(energy_keys) == 6, (
|
||||
f"Expected exactly 6 energy_cost entities (4 original + 2 daily), got {energy_keys!r}"
|
||||
)
|
||||
|
||||
|
||||
|
||||
Reference in New Issue
Block a user