334 lines
9.2 KiB
Python
334 lines
9.2 KiB
Python
"""Tests for the La Marzocco number entities."""
|
|
|
|
from unittest.mock import MagicMock
|
|
|
|
from lmcloud.const import KEYS_PER_MODEL, LaMarzoccoModel
|
|
import pytest
|
|
from syrupy import SnapshotAssertion
|
|
|
|
from homeassistant.components.number import (
|
|
ATTR_VALUE,
|
|
DOMAIN as NUMBER_DOMAIN,
|
|
SERVICE_SET_VALUE,
|
|
)
|
|
from homeassistant.const import ATTR_ENTITY_ID, STATE_UNAVAILABLE
|
|
from homeassistant.core import HomeAssistant
|
|
from homeassistant.helpers import device_registry as dr, entity_registry as er
|
|
|
|
pytestmark = pytest.mark.usefixtures("init_integration")
|
|
|
|
|
|
async def test_coffee_boiler(
|
|
hass: HomeAssistant,
|
|
mock_lamarzocco: MagicMock,
|
|
entity_registry: er.EntityRegistry,
|
|
device_registry: dr.DeviceRegistry,
|
|
snapshot: SnapshotAssertion,
|
|
) -> None:
|
|
"""Test the La Marzocco coffee temperature Number."""
|
|
serial_number = mock_lamarzocco.serial_number
|
|
|
|
state = hass.states.get(f"number.{serial_number}_coffee_target_temperature")
|
|
|
|
assert state
|
|
assert state == snapshot
|
|
|
|
entry = entity_registry.async_get(state.entity_id)
|
|
assert entry
|
|
assert entry.device_id
|
|
assert entry == snapshot
|
|
|
|
device = device_registry.async_get(entry.device_id)
|
|
assert device
|
|
|
|
# service call
|
|
await hass.services.async_call(
|
|
NUMBER_DOMAIN,
|
|
SERVICE_SET_VALUE,
|
|
{
|
|
ATTR_ENTITY_ID: f"number.{serial_number}_coffee_target_temperature",
|
|
ATTR_VALUE: 95,
|
|
},
|
|
blocking=True,
|
|
)
|
|
|
|
assert len(mock_lamarzocco.set_coffee_temp.mock_calls) == 1
|
|
mock_lamarzocco.set_coffee_temp.assert_called_once_with(
|
|
temperature=95, ble_device=None
|
|
)
|
|
|
|
|
|
@pytest.mark.parametrize(
|
|
"device_fixture", [LaMarzoccoModel.GS3_AV, LaMarzoccoModel.GS3_MP]
|
|
)
|
|
@pytest.mark.parametrize(
|
|
("entity_name", "value", "func_name", "kwargs"),
|
|
[
|
|
(
|
|
"steam_target_temperature",
|
|
131,
|
|
"set_steam_temp",
|
|
{"temperature": 131, "ble_device": None},
|
|
),
|
|
("tea_water_duration", 15, "set_dose_hot_water", {"value": 15}),
|
|
],
|
|
)
|
|
async def test_gs3_exclusive(
|
|
hass: HomeAssistant,
|
|
mock_lamarzocco: MagicMock,
|
|
entity_registry: er.EntityRegistry,
|
|
device_registry: dr.DeviceRegistry,
|
|
snapshot: SnapshotAssertion,
|
|
entity_name: str,
|
|
value: float,
|
|
func_name: str,
|
|
kwargs: dict[str, float],
|
|
) -> None:
|
|
"""Test exclusive entities for GS3 AV/MP."""
|
|
|
|
serial_number = mock_lamarzocco.serial_number
|
|
|
|
func = getattr(mock_lamarzocco, func_name)
|
|
|
|
state = hass.states.get(f"number.{serial_number}_{entity_name}")
|
|
assert state
|
|
assert state == snapshot
|
|
|
|
entry = entity_registry.async_get(state.entity_id)
|
|
assert entry
|
|
assert entry.device_id
|
|
assert entry == snapshot
|
|
|
|
device = device_registry.async_get(entry.device_id)
|
|
assert device
|
|
|
|
# service call
|
|
await hass.services.async_call(
|
|
NUMBER_DOMAIN,
|
|
SERVICE_SET_VALUE,
|
|
{
|
|
ATTR_ENTITY_ID: f"number.{serial_number}_{entity_name}",
|
|
ATTR_VALUE: value,
|
|
},
|
|
blocking=True,
|
|
)
|
|
|
|
assert len(func.mock_calls) == 1
|
|
func.assert_called_once_with(**kwargs)
|
|
|
|
|
|
@pytest.mark.parametrize(
|
|
"device_fixture", [LaMarzoccoModel.LINEA_MICRA, LaMarzoccoModel.LINEA_MINI]
|
|
)
|
|
async def test_gs3_exclusive_none(
|
|
hass: HomeAssistant,
|
|
mock_lamarzocco: MagicMock,
|
|
) -> None:
|
|
"""Ensure GS3 exclusive is None for unsupported models."""
|
|
|
|
ENTITIES = ("steam_target_temperature", "tea_water_duration")
|
|
|
|
serial_number = mock_lamarzocco.serial_number
|
|
for entity in ENTITIES:
|
|
state = hass.states.get(f"number.{serial_number}_{entity}")
|
|
assert state is None
|
|
|
|
|
|
@pytest.mark.parametrize(
|
|
"device_fixture", [LaMarzoccoModel.LINEA_MICRA, LaMarzoccoModel.LINEA_MINI]
|
|
)
|
|
@pytest.mark.parametrize(
|
|
("entity_name", "value", "kwargs"),
|
|
[
|
|
("prebrew_off_time", 6, {"on_time": 3000, "off_time": 6000, "key": 1}),
|
|
("prebrew_on_time", 6, {"on_time": 6000, "off_time": 5000, "key": 1}),
|
|
("preinfusion_time", 7, {"off_time": 7000, "key": 1}),
|
|
],
|
|
)
|
|
async def test_pre_brew_infusion_numbers(
|
|
hass: HomeAssistant,
|
|
mock_lamarzocco: MagicMock,
|
|
entity_registry: er.EntityRegistry,
|
|
device_registry: dr.DeviceRegistry,
|
|
snapshot: SnapshotAssertion,
|
|
entity_name: str,
|
|
value: float,
|
|
kwargs: dict[str, float],
|
|
) -> None:
|
|
"""Test the La Marzocco prebrew/-infusion sensors."""
|
|
|
|
mock_lamarzocco.current_status["enable_preinfusion"] = True
|
|
|
|
serial_number = mock_lamarzocco.serial_number
|
|
|
|
state = hass.states.get(f"number.{serial_number}_{entity_name}")
|
|
|
|
assert state
|
|
assert state == snapshot
|
|
|
|
entry = entity_registry.async_get(state.entity_id)
|
|
assert entry
|
|
assert entry.device_id
|
|
assert entry == snapshot
|
|
|
|
device = device_registry.async_get(entry.device_id)
|
|
assert device
|
|
|
|
# service call
|
|
await hass.services.async_call(
|
|
NUMBER_DOMAIN,
|
|
SERVICE_SET_VALUE,
|
|
{
|
|
ATTR_ENTITY_ID: f"number.{serial_number}_{entity_name}",
|
|
ATTR_VALUE: value,
|
|
},
|
|
blocking=True,
|
|
)
|
|
|
|
assert len(mock_lamarzocco.configure_prebrew.mock_calls) == 1
|
|
mock_lamarzocco.configure_prebrew.assert_called_once_with(**kwargs)
|
|
|
|
|
|
@pytest.mark.parametrize("device_fixture", [LaMarzoccoModel.GS3_AV])
|
|
@pytest.mark.usefixtures("entity_registry_enabled_by_default")
|
|
@pytest.mark.parametrize(
|
|
("entity_name", "value", "function_name", "kwargs"),
|
|
[
|
|
(
|
|
"prebrew_off_time",
|
|
6,
|
|
"configure_prebrew",
|
|
{"on_time": 3000, "off_time": 6000},
|
|
),
|
|
(
|
|
"prebrew_on_time",
|
|
6,
|
|
"configure_prebrew",
|
|
{"on_time": 6000, "off_time": 5000},
|
|
),
|
|
("preinfusion_time", 7, "configure_prebrew", {"off_time": 7000}),
|
|
("dose", 6, "set_dose", {"value": 6}),
|
|
],
|
|
)
|
|
async def test_pre_brew_infusion_key_numbers(
|
|
hass: HomeAssistant,
|
|
mock_lamarzocco: MagicMock,
|
|
snapshot: SnapshotAssertion,
|
|
entity_name: str,
|
|
value: float,
|
|
function_name: str,
|
|
kwargs: dict[str, float],
|
|
) -> None:
|
|
"""Test the La Marzocco number sensors for GS3AV model."""
|
|
|
|
mock_lamarzocco.current_status["enable_preinfusion"] = True
|
|
|
|
serial_number = mock_lamarzocco.serial_number
|
|
|
|
func = getattr(mock_lamarzocco, function_name)
|
|
|
|
state = hass.states.get(f"number.{serial_number}_{entity_name}")
|
|
assert state is None
|
|
|
|
for key in range(1, KEYS_PER_MODEL[mock_lamarzocco.model_name] + 1):
|
|
state = hass.states.get(f"number.{serial_number}_{entity_name}_key_{key}")
|
|
assert state
|
|
assert state == snapshot(name=f"{serial_number}_{entity_name}_key_{key}-state")
|
|
|
|
# service call
|
|
await hass.services.async_call(
|
|
NUMBER_DOMAIN,
|
|
SERVICE_SET_VALUE,
|
|
{
|
|
ATTR_ENTITY_ID: f"number.{serial_number}_{entity_name}_key_{key}",
|
|
ATTR_VALUE: value,
|
|
},
|
|
blocking=True,
|
|
)
|
|
|
|
kwargs["key"] = key
|
|
|
|
assert len(func.mock_calls) == key
|
|
func.assert_called_with(**kwargs)
|
|
|
|
|
|
@pytest.mark.parametrize("device_fixture", [LaMarzoccoModel.GS3_AV])
|
|
async def test_disabled_entites(
|
|
hass: HomeAssistant,
|
|
mock_lamarzocco: MagicMock,
|
|
) -> None:
|
|
"""Test the La Marzocco prebrew/-infusion sensors for GS3AV model."""
|
|
|
|
ENTITIES = (
|
|
"prebrew_off_time",
|
|
"prebrew_on_time",
|
|
"preinfusion_time",
|
|
"set_dose",
|
|
)
|
|
|
|
serial_number = mock_lamarzocco.serial_number
|
|
|
|
for entity_name in ENTITIES:
|
|
for key in range(1, KEYS_PER_MODEL[mock_lamarzocco.model_name] + 1):
|
|
state = hass.states.get(f"number.{serial_number}_{entity_name}_key_{key}")
|
|
assert state is None
|
|
|
|
|
|
@pytest.mark.parametrize(
|
|
"device_fixture",
|
|
[LaMarzoccoModel.GS3_MP, LaMarzoccoModel.LINEA_MICRA, LaMarzoccoModel.LINEA_MINI],
|
|
)
|
|
async def test_not_existing_key_entites(
|
|
hass: HomeAssistant,
|
|
mock_lamarzocco: MagicMock,
|
|
) -> None:
|
|
"""Assert not existing key entities."""
|
|
|
|
serial_number = mock_lamarzocco.serial_number
|
|
|
|
for entity in (
|
|
"prebrew_off_time",
|
|
"prebrew_on_time",
|
|
"preinfusion_time",
|
|
"set_dose",
|
|
):
|
|
for key in range(1, KEYS_PER_MODEL[LaMarzoccoModel.GS3_AV] + 1):
|
|
state = hass.states.get(f"number.{serial_number}_{entity}_key_{key}")
|
|
assert state is None
|
|
|
|
|
|
@pytest.mark.parametrize(
|
|
"device_fixture",
|
|
[LaMarzoccoModel.GS3_MP],
|
|
)
|
|
async def test_not_existing_entites(
|
|
hass: HomeAssistant,
|
|
mock_lamarzocco: MagicMock,
|
|
) -> None:
|
|
"""Assert not existing entities."""
|
|
|
|
serial_number = mock_lamarzocco.serial_number
|
|
|
|
for entity in (
|
|
"prebrew_off_time",
|
|
"prebrew_on_time",
|
|
"preinfusion_time",
|
|
"set_dose",
|
|
):
|
|
state = hass.states.get(f"number.{serial_number}_{entity}")
|
|
assert state is None
|
|
|
|
|
|
@pytest.mark.parametrize("device_fixture", [LaMarzoccoModel.LINEA_MICRA])
|
|
async def test_not_settable_entites(
|
|
hass: HomeAssistant,
|
|
mock_lamarzocco: MagicMock,
|
|
) -> None:
|
|
"""Assert not settable causes error."""
|
|
|
|
serial_number = mock_lamarzocco.serial_number
|
|
|
|
state = hass.states.get(f"number.{serial_number}_preinfusion_time")
|
|
assert state
|
|
assert state.state == STATE_UNAVAILABLE
|