mirror of
https://github.com/esphome/esphome.git
synced 2026-01-22 19:09:11 -07:00
112 lines
4.3 KiB
Python
112 lines
4.3 KiB
Python
"""Integration test for ESPTime::strftime_to() method."""
|
|
|
|
from __future__ import annotations
|
|
|
|
import asyncio
|
|
|
|
from aioesphomeapi import EntityState, TextSensorState
|
|
import pytest
|
|
|
|
from .state_utils import InitialStateHelper, require_entity
|
|
from .types import APIClientConnectedFactory, RunCompiledFunction
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_strftime_to(
|
|
yaml_config: str,
|
|
run_compiled: RunCompiledFunction,
|
|
api_client_connected: APIClientConnectedFactory,
|
|
) -> None:
|
|
"""Test ESPTime::strftime_to() formats time correctly."""
|
|
async with run_compiled(yaml_config), api_client_connected() as client:
|
|
device_info = await client.device_info()
|
|
assert device_info is not None
|
|
assert device_info.name == "strftime-to-test"
|
|
|
|
# Get entities
|
|
entities, _ = await client.list_entities_services()
|
|
|
|
# Find our text sensors
|
|
format_test = require_entity(
|
|
entities, "time_format_test", description="Time Format Test sensor"
|
|
)
|
|
short_format = require_entity(
|
|
entities, "time_short_format", description="Time Short Format sensor"
|
|
)
|
|
string_format = require_entity(
|
|
entities, "time_string_format", description="Time String Format sensor"
|
|
)
|
|
error_format = require_entity(
|
|
entities, "time_error_format", description="Time Error Format sensor"
|
|
)
|
|
|
|
# Set up state tracking with InitialStateHelper
|
|
loop = asyncio.get_running_loop()
|
|
states: dict[int, TextSensorState] = {}
|
|
all_received = loop.create_future()
|
|
expected_keys = {
|
|
format_test.key,
|
|
short_format.key,
|
|
string_format.key,
|
|
error_format.key,
|
|
}
|
|
initial_state_helper = InitialStateHelper(entities)
|
|
|
|
def on_state(state: EntityState) -> None:
|
|
if isinstance(state, TextSensorState) and not state.missing_state:
|
|
states[state.key] = state
|
|
if expected_keys <= states.keys() and not all_received.done():
|
|
all_received.set_result(True)
|
|
|
|
# Subscribe with the wrapper that filters initial states
|
|
client.subscribe_states(initial_state_helper.on_state_wrapper(on_state))
|
|
|
|
# Wait for initial states to be broadcast
|
|
try:
|
|
await initial_state_helper.wait_for_initial_states()
|
|
except TimeoutError:
|
|
pytest.fail("Timeout waiting for initial states")
|
|
|
|
# Wait for all expected states
|
|
try:
|
|
await asyncio.wait_for(all_received, timeout=5.0)
|
|
except TimeoutError:
|
|
pytest.fail(
|
|
f"Timeout waiting for text sensor states. Got: {list(states.keys())}"
|
|
)
|
|
|
|
# Validate strftime_to with full format
|
|
# Note: The exact output depends on timezone, but should contain date components
|
|
format_test_state = states[format_test.key].state
|
|
assert "2024" in format_test_state or "2023" in format_test_state, (
|
|
f"Expected year in format test output, got: {format_test_state}"
|
|
)
|
|
# Should have format like "YYYY-MM-DD HH:MM:SS"
|
|
assert len(format_test_state) == 19, (
|
|
f"Expected 19 chars for datetime format, got {len(format_test_state)}: {format_test_state}"
|
|
)
|
|
|
|
# Validate short format (HH:MM)
|
|
short_format_state = states[short_format.key].state
|
|
assert len(short_format_state) == 5, (
|
|
f"Expected 5 chars for HH:MM format, got {len(short_format_state)}: {short_format_state}"
|
|
)
|
|
assert ":" in short_format_state, (
|
|
f"Expected colon in HH:MM format, got: {short_format_state}"
|
|
)
|
|
|
|
# Validate string format (the std::string returning version)
|
|
string_format_state = states[string_format.key].state
|
|
assert len(string_format_state) == 10, (
|
|
f"Expected 10 chars for YYYY-MM-DD format, got {len(string_format_state)}: {string_format_state}"
|
|
)
|
|
assert string_format_state.count("-") == 2, (
|
|
f"Expected two dashes in YYYY-MM-DD format, got: {string_format_state}"
|
|
)
|
|
|
|
# Validate error format returns "ERROR"
|
|
error_format_state = states[error_format.key].state
|
|
assert error_format_state == "ERROR", (
|
|
f"Expected 'ERROR' for empty format string, got: {error_format_state}"
|
|
)
|