jeans/core
jeans/core
1
0
Fork 0
mirror of https://github.com/home-assistant/core.git synced 2025-07-25 14:17:45 +00:00
Code Issues Packages Projects Releases Wiki Activity

Speed up tests of HomematicIP Cloud (#31810)

Browse Source 
* Speed up tests of HomematicIP Cloud

* load the json once
This commit is contained in:
SukramJ 2020-02-14 07:56:17 +01:00 committed by GitHub
parent f9fda7d616
commit 9eb0415234
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
12 changed files with 366 additions and 183 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

52
tests/components/homematicip_cloud/conftest.py
View File

@ -1,5 +1,5 @@
"""Initializer helpers for HomematicIP fake server.""" """Initializer helpers for HomematicIP fake server."""
from asynctest import CoroutineMock, MagicMock, Mock, patch from asynctest import CoroutineMock, MagicMock, Mock
from homematicip.aio.auth import AsyncAuth from homematicip.aio.auth import AsyncAuth
from homematicip.aio.connection import AsyncConnection from homematicip.aio.connection import AsyncConnection
from homematicip.aio.home import AsyncHome from homematicip.aio.home import AsyncHome
@ -19,9 +19,8 @@ from homeassistant.components.homematicip_cloud.const import (
from homeassistant.components.homematicip_cloud.hap import HomematicipHAP from homeassistant.components.homematicip_cloud.hap import HomematicipHAP
from homeassistant.config_entries import SOURCE_IMPORT from homeassistant.config_entries import SOURCE_IMPORT
from homeassistant.helpers.typing import ConfigType, HomeAssistantType from homeassistant.helpers.typing import ConfigType, HomeAssistantType
from homeassistant.setup import async_setup_component
from .helper import AUTH_TOKEN, HAPID, HAPPIN, HomeTemplate from .helper import AUTH_TOKEN, HAPID, HAPPIN, HomeFactory
from tests.common import MockConfigEntry from tests.common import MockConfigEntry
@ -66,46 +65,12 @@ def hmip_config_entry_fixture() -> config_entries.ConfigEntry:
return config_entry return config_entry
@pytest.fixture(name="default_mock_home") @pytest.fixture(name="default_mock_hap_factory")
def default_mock_home_fixture(mock_connection) -> AsyncHome: async def default_mock_hap_factory_fixture(
"""Create a fake homematic async home."""
return HomeTemplate(connection=mock_connection).init_home().get_async_home_mock()
@pytest.fixture(name="default_mock_hap")
async def default_mock_hap_fixture(
hass: HomeAssistantType, mock_connection, hmip_config_entry hass: HomeAssistantType, mock_connection, hmip_config_entry
) -> HomematicipHAP: ) -> HomematicipHAP:
"""Create a mocked homematic access point.""" """Create a mocked homematic access point."""
return await get_mock_hap(hass, mock_connection, hmip_config_entry) return HomeFactory(hass, mock_connection, hmip_config_entry)
async def get_mock_hap(
hass: HomeAssistantType,
mock_connection,
hmip_config_entry: config_entries.ConfigEntry,
) -> HomematicipHAP:
"""Create a mocked homematic access point."""
home_name = hmip_config_entry.data["name"]
mock_home = (
HomeTemplate(connection=mock_connection, home_name=home_name)
.init_home()
.get_async_home_mock()
)
hmip_config_entry.add_to_hass(hass)
with patch(
"homeassistant.components.homematicip_cloud.hap.HomematicipHAP.get_hap",
return_value=mock_home,
):
assert await async_setup_component(hass, HMIPC_DOMAIN, {}) is True
await hass.async_block_till_done()
hap = hass.data[HMIPC_DOMAIN][HAPID]
mock_home.on_update(hap.async_update)
mock_home.on_create(hap.async_create_entity)
return hap
@pytest.fixture(name="hmip_config") @pytest.fixture(name="hmip_config")
@ -130,13 +95,14 @@ def dummy_config_fixture() -> ConfigType:
@pytest.fixture(name="mock_hap_with_service") @pytest.fixture(name="mock_hap_with_service")
async def mock_hap_with_service_fixture( async def mock_hap_with_service_fixture(
hass: HomeAssistantType, default_mock_hap, dummy_config hass: HomeAssistantType, default_mock_hap_factory, dummy_config
) -> HomematicipHAP: ) -> HomematicipHAP:
"""Create a fake homematic access point with hass services.""" """Create a fake homematic access point with hass services."""
mock_hap = await default_mock_hap_factory.async_get_mock_hap()
await hmip_async_setup(hass, dummy_config) await hmip_async_setup(hass, dummy_config)
await hass.async_block_till_done() await hass.async_block_till_done()
hass.data[HMIPC_DOMAIN] = {HAPID: default_mock_hap} hass.data[HMIPC_DOMAIN] = {HAPID: mock_hap}
return default_mock_hap return mock_hap
@pytest.fixture(name="simple_mock_home") @pytest.fixture(name="simple_mock_home")

84
tests/components/homematicip_cloud/helper.py
View File

@ -1,7 +1,7 @@
"""Helper for HomematicIP Cloud Tests.""" """Helper for HomematicIP Cloud Tests."""
import json import json
from asynctest import Mock from asynctest import Mock, patch
from homematicip.aio.class_maps import ( from homematicip.aio.class_maps import (
TYPE_CLASS_MAP, TYPE_CLASS_MAP,
TYPE_GROUP_MAP, TYPE_GROUP_MAP,
@ -12,10 +12,15 @@ from homematicip.aio.group import AsyncGroup
from homematicip.aio.home import AsyncHome from homematicip.aio.home import AsyncHome
from homematicip.home import Home from homematicip.home import Home
from homeassistant import config_entries
from homeassistant.components.homematicip_cloud import DOMAIN as HMIPC_DOMAIN
from homeassistant.components.homematicip_cloud.device import ( from homeassistant.components.homematicip_cloud.device import (
ATTR_IS_GROUP, ATTR_IS_GROUP,
ATTR_MODEL_TYPE, ATTR_MODEL_TYPE,
) )
from homeassistant.components.homematicip_cloud.hap import HomematicipHAP
from homeassistant.helpers.typing import HomeAssistantType
from homeassistant.setup import async_setup_component
from tests.common import load_fixture from tests.common import load_fixture
@ -23,11 +28,10 @@ HAPID = "3014F7110000000000000001"
HAPPIN = "5678" HAPPIN = "5678"
AUTH_TOKEN = "1234" AUTH_TOKEN = "1234"
HOME_JSON = "homematicip_cloud.json" HOME_JSON = "homematicip_cloud.json"
FIXTURE_DATA = load_fixture(HOME_JSON)
def get_and_check_entity_basics( def get_and_check_entity_basics(hass, mock_hap, entity_id, entity_name, device_model):
hass, default_mock_hap, entity_id, entity_name, device_model
):
"""Get and test basic device.""" """Get and test basic device."""
ha_state = hass.states.get(entity_id) ha_state = hass.states.get(entity_id)
assert ha_state is not None assert ha_state is not None
@ -35,7 +39,7 @@ def get_and_check_entity_basics(
assert ha_state.attributes[ATTR_MODEL_TYPE] == device_model assert ha_state.attributes[ATTR_MODEL_TYPE] == device_model
assert ha_state.name == entity_name assert ha_state.name == entity_name
hmip_device = default_mock_hap.hmip_device_by_entity_id.get(entity_id) hmip_device = mock_hap.hmip_device_by_entity_id.get(entity_id)
if hmip_device: if hmip_device:
if isinstance(hmip_device, AsyncDevice): if isinstance(hmip_device, AsyncDevice):
@ -67,6 +71,51 @@ async def async_manipulate_test_data(
await hass.async_block_till_done() await hass.async_block_till_done()
class HomeFactory:
"""Factory to create a HomematicIP Cloud Home."""
def __init__(
self,
hass: HomeAssistantType,
mock_connection,
hmip_config_entry: config_entries.ConfigEntry,
):
"""Initialize the Factory."""
self.hass = hass
self.mock_connection = mock_connection
self.hmip_config_entry = hmip_config_entry
async def async_get_mock_hap(
self, test_devices=[], test_groups=[]
) -> HomematicipHAP:
"""Create a mocked homematic access point."""
home_name = self.hmip_config_entry.data["name"]
mock_home = (
HomeTemplate(
connection=self.mock_connection,
home_name=home_name,
test_devices=test_devices,
test_groups=test_groups,
)
.init_home()
.get_async_home_mock()
)
self.hmip_config_entry.add_to_hass(self.hass)
with patch(
"homeassistant.components.homematicip_cloud.hap.HomematicipHAP.get_hap",
return_value=mock_home,
):
assert await async_setup_component(self.hass, HMIPC_DOMAIN, {}) is True
await self.hass.async_block_till_done()
hap = self.hass.data[HMIPC_DOMAIN][HAPID]
mock_home.on_update(hap.async_update)
mock_home.on_create(hap.async_create_entity)
return hap
class HomeTemplate(Home): class HomeTemplate(Home):
""" """
Home template as builder for home mock. Home template as builder for home mock.
@ -84,17 +133,36 @@ class HomeTemplate(Home):
_typeGroupMap = TYPE_GROUP_MAP _typeGroupMap = TYPE_GROUP_MAP
_typeSecurityEventMap = TYPE_SECURITY_EVENT_MAP _typeSecurityEventMap = TYPE_SECURITY_EVENT_MAP
def __init__(self, connection=None, home_name=""): def __init__(self, connection=None, home_name="", test_devices=[], test_groups=[]):
"""Init template with connection.""" """Init template with connection."""
super().__init__(connection=connection) super().__init__(connection=connection)
self.label = "Access Point" self.label = "Access Point"
self.name = home_name self.name = home_name
self.model_type = "HmIP-HAP" self.model_type = "HmIP-HAP"
self.init_json_state = None self.init_json_state = None
self.test_devices = test_devices
self.test_groups = test_groups
def init_home(self, json_path=HOME_JSON): def _cleanup_json(self, json):
if self.test_devices is not None:
new_devices = {}
for json_device in json["devices"].items():
if json_device[1]["label"] in self.test_devices:
new_devices.update([json_device])
json["devices"] = new_devices
if self.test_groups is not None:
new_groups = {}
for json_group in json["groups"].items():
if json_group[1]["label"] in self.test_groups:
new_groups.update([json_group])
json["groups"] = new_groups
return json
def init_home(self):
"""Init template with json.""" """Init template with json."""
self.init_json_state = json.loads(load_fixture(HOME_JSON)) self.init_json_state = self._cleanup_json(json.loads(FIXTURE_DATA))
self.update_home(json_state=self.init_json_state, clearConfig=True) self.update_home(json_state=self.init_json_state, clearConfig=True)
return self return self

9
tests/components/homematicip_cloud/test_alarm_control_panel.py
View File

@ -51,20 +51,23 @@ async def test_manually_configured_platform(hass):
assert not hass.data.get(HMIPC_DOMAIN) assert not hass.data.get(HMIPC_DOMAIN)
async def test_hmip_alarm_control_panel(hass, default_mock_hap): async def test_hmip_alarm_control_panel(hass, default_mock_hap_factory):
"""Test HomematicipAlarmControlPanel.""" """Test HomematicipAlarmControlPanel."""
entity_id = "alarm_control_panel.hmip_alarm_control_panel" entity_id = "alarm_control_panel.hmip_alarm_control_panel"
entity_name = "HmIP Alarm Control Panel" entity_name = "HmIP Alarm Control Panel"
device_model = None device_model = None
mock_hap = await default_mock_hap_factory.async_get_mock_hap(
test_groups=["EXTERNAL", "INTERNAL"]
)
ha_state, hmip_device = get_and_check_entity_basics( ha_state, hmip_device = get_and_check_entity_basics(
hass, default_mock_hap, entity_id, entity_name, device_model hass, mock_hap, entity_id, entity_name, device_model
) )
assert ha_state.state == "disarmed" assert ha_state.state == "disarmed"
assert not hmip_device assert not hmip_device
home = default_mock_hap.home home = mock_hap.home
await hass.services.async_call( await hass.services.async_call(
"alarm_control_panel", "alarm_arm_away", {"entity_id": entity_id}, blocking=True "alarm_control_panel", "alarm_arm_away", {"entity_id": entity_id}, blocking=True

98
tests/components/homematicip_cloud/test_binary_sensor.py
View File

@ -41,14 +41,17 @@ async def test_manually_configured_platform(hass):
assert not hass.data.get(HMIPC_DOMAIN) assert not hass.data.get(HMIPC_DOMAIN)
async def test_hmip_acceleration_sensor(hass, default_mock_hap): async def test_hmip_acceleration_sensor(hass, default_mock_hap_factory):
"""Test HomematicipAccelerationSensor.""" """Test HomematicipAccelerationSensor."""
entity_id = "binary_sensor.garagentor" entity_id = "binary_sensor.garagentor"
entity_name = "Garagentor" entity_name = "Garagentor"
device_model = "HmIP-SAM" device_model = "HmIP-SAM"
mock_hap = await default_mock_hap_factory.async_get_mock_hap(
test_devices=[entity_name]
)
ha_state, hmip_device = get_and_check_entity_basics( ha_state, hmip_device = get_and_check_entity_basics(
hass, default_mock_hap, entity_id, entity_name, device_model hass, mock_hap, entity_id, entity_name, device_model
) )
assert ha_state.state == STATE_ON assert ha_state.state == STATE_ON
@ -75,14 +78,17 @@ async def test_hmip_acceleration_sensor(hass, default_mock_hap):
assert len(hmip_device.mock_calls) == service_call_counter + 2 assert len(hmip_device.mock_calls) == service_call_counter + 2
async def test_hmip_contact_interface(hass, default_mock_hap): async def test_hmip_contact_interface(hass, default_mock_hap_factory):
"""Test HomematicipContactInterface.""" """Test HomematicipContactInterface."""
entity_id = "binary_sensor.kontakt_schnittstelle_unterputz_1_fach" entity_id = "binary_sensor.kontakt_schnittstelle_unterputz_1_fach"
entity_name = "Kontakt-Schnittstelle Unterputz – 1-fach" entity_name = "Kontakt-Schnittstelle Unterputz – 1-fach"
device_model = "HmIP-FCI1" device_model = "HmIP-FCI1"
mock_hap = await default_mock_hap_factory.async_get_mock_hap(
test_devices=[entity_name]
)
ha_state, hmip_device = get_and_check_entity_basics( ha_state, hmip_device = get_and_check_entity_basics(
hass, default_mock_hap, entity_id, entity_name, device_model hass, mock_hap, entity_id, entity_name, device_model
) )
assert ha_state.state == STATE_OFF assert ha_state.state == STATE_OFF
@ -95,14 +101,17 @@ async def test_hmip_contact_interface(hass, default_mock_hap):
assert ha_state.state == STATE_OFF assert ha_state.state == STATE_OFF
async def test_hmip_shutter_contact(hass, default_mock_hap): async def test_hmip_shutter_contact(hass, default_mock_hap_factory):
"""Test HomematicipShutterContact.""" """Test HomematicipShutterContact."""
entity_id = "binary_sensor.fenstergriffsensor" entity_id = "binary_sensor.fenstergriffsensor"
entity_name = "Fenstergriffsensor" entity_name = "Fenstergriffsensor"
device_model = "HmIP-SRH" device_model = "HmIP-SRH"
mock_hap = await default_mock_hap_factory.async_get_mock_hap(
test_devices=[entity_name]
)
ha_state, hmip_device = get_and_check_entity_basics( ha_state, hmip_device = get_and_check_entity_basics(
hass, default_mock_hap, entity_id, entity_name, device_model hass, mock_hap, entity_id, entity_name, device_model
) )
assert ha_state.state == STATE_ON assert ha_state.state == STATE_ON
@ -124,14 +133,17 @@ async def test_hmip_shutter_contact(hass, default_mock_hap):
assert ha_state.attributes[ATTR_SABOTAGE] assert ha_state.attributes[ATTR_SABOTAGE]
async def test_hmip_motion_detector(hass, default_mock_hap): async def test_hmip_motion_detector(hass, default_mock_hap_factory):
"""Test HomematicipMotionDetector.""" """Test HomematicipMotionDetector."""
entity_id = "binary_sensor.bewegungsmelder_fur_55er_rahmen_innen" entity_id = "binary_sensor.bewegungsmelder_fur_55er_rahmen_innen"
entity_name = "Bewegungsmelder für 55er Rahmen – innen" entity_name = "Bewegungsmelder für 55er Rahmen – innen"
device_model = "HmIP-SMI55" device_model = "HmIP-SMI55"
mock_hap = await default_mock_hap_factory.async_get_mock_hap(
test_devices=[entity_name]
)
ha_state, hmip_device = get_and_check_entity_basics( ha_state, hmip_device = get_and_check_entity_basics(
hass, default_mock_hap, entity_id, entity_name, device_model hass, mock_hap, entity_id, entity_name, device_model
) )
assert ha_state.state == STATE_OFF assert ha_state.state == STATE_OFF
@ -140,14 +152,17 @@ async def test_hmip_motion_detector(hass, default_mock_hap):
assert ha_state.state == STATE_ON assert ha_state.state == STATE_ON
async def test_hmip_presence_detector(hass, default_mock_hap): async def test_hmip_presence_detector(hass, default_mock_hap_factory):
"""Test HomematicipPresenceDetector.""" """Test HomematicipPresenceDetector."""
entity_id = "binary_sensor.spi_1" entity_id = "binary_sensor.spi_1"
entity_name = "SPI_1" entity_name = "SPI_1"
device_model = "HmIP-SPI" device_model = "HmIP-SPI"
mock_hap = await default_mock_hap_factory.async_get_mock_hap(
test_devices=[entity_name]
)
ha_state, hmip_device = get_and_check_entity_basics( ha_state, hmip_device = get_and_check_entity_basics(
hass, default_mock_hap, entity_id, entity_name, device_model hass, mock_hap, entity_id, entity_name, device_model
) )
assert ha_state.state == STATE_OFF assert ha_state.state == STATE_OFF
@ -161,14 +176,19 @@ async def test_hmip_presence_detector(hass, default_mock_hap):
assert ha_state.attributes[ATTR_EVENT_DELAY] assert ha_state.attributes[ATTR_EVENT_DELAY]
async def test_hmip_pluggable_mains_failure_surveillance_sensor(hass, default_mock_hap): async def test_hmip_pluggable_mains_failure_surveillance_sensor(
hass, default_mock_hap_factory
):
"""Test HomematicipPresenceDetector.""" """Test HomematicipPresenceDetector."""
entity_id = "binary_sensor.netzausfall" entity_id = "binary_sensor.netzausfall"
entity_name = "Netzausfall" entity_name = "Netzausfall"
device_model = "HmIP-PMFS" device_model = "HmIP-PMFS"
mock_hap = await default_mock_hap_factory.async_get_mock_hap(
test_devices=[entity_name]
)
ha_state, hmip_device = get_and_check_entity_basics( ha_state, hmip_device = get_and_check_entity_basics(
hass, default_mock_hap, entity_id, entity_name, device_model hass, mock_hap, entity_id, entity_name, device_model
) )
assert ha_state.state == STATE_ON assert ha_state.state == STATE_ON
@ -177,14 +197,17 @@ async def test_hmip_pluggable_mains_failure_surveillance_sensor(hass, default_mo
assert ha_state.state == STATE_OFF assert ha_state.state == STATE_OFF
async def test_hmip_smoke_detector(hass, default_mock_hap): async def test_hmip_smoke_detector(hass, default_mock_hap_factory):
"""Test HomematicipSmokeDetector.""" """Test HomematicipSmokeDetector."""
entity_id = "binary_sensor.rauchwarnmelder" entity_id = "binary_sensor.rauchwarnmelder"
entity_name = "Rauchwarnmelder" entity_name = "Rauchwarnmelder"
device_model = "HmIP-SWSD" device_model = "HmIP-SWSD"
mock_hap = await default_mock_hap_factory.async_get_mock_hap(
test_devices=[entity_name]
)
ha_state, hmip_device = get_and_check_entity_basics( ha_state, hmip_device = get_and_check_entity_basics(
hass, default_mock_hap, entity_id, entity_name, device_model hass, mock_hap, entity_id, entity_name, device_model
) )
assert ha_state.state == STATE_OFF assert ha_state.state == STATE_OFF
@ -198,14 +221,17 @@ async def test_hmip_smoke_detector(hass, default_mock_hap):
assert ha_state.state == STATE_ON assert ha_state.state == STATE_ON
async def test_hmip_water_detector(hass, default_mock_hap): async def test_hmip_water_detector(hass, default_mock_hap_factory):
"""Test HomematicipWaterDetector.""" """Test HomematicipWaterDetector."""
entity_id = "binary_sensor.wassersensor" entity_id = "binary_sensor.wassersensor"
entity_name = "Wassersensor" entity_name = "Wassersensor"
device_model = "HmIP-SWD" device_model = "HmIP-SWD"
mock_hap = await default_mock_hap_factory.async_get_mock_hap(
test_devices=[entity_name]
)
ha_state, hmip_device = get_and_check_entity_basics( ha_state, hmip_device = get_and_check_entity_basics(
hass, default_mock_hap, entity_id, entity_name, device_model hass, mock_hap, entity_id, entity_name, device_model
) )
assert ha_state.state == STATE_OFF assert ha_state.state == STATE_OFF
@ -230,14 +256,17 @@ async def test_hmip_water_detector(hass, default_mock_hap):
assert ha_state.state == STATE_OFF assert ha_state.state == STATE_OFF
async def test_hmip_storm_sensor(hass, default_mock_hap): async def test_hmip_storm_sensor(hass, default_mock_hap_factory):
"""Test HomematicipStormSensor.""" """Test HomematicipStormSensor."""
entity_id = "binary_sensor.weather_sensor_plus_storm" entity_id = "binary_sensor.weather_sensor_plus_storm"
entity_name = "Weather Sensor – plus Storm" entity_name = "Weather Sensor – plus Storm"
device_model = "HmIP-SWO-PL" device_model = "HmIP-SWO-PL"
mock_hap = await default_mock_hap_factory.async_get_mock_hap(
test_devices=["Weather Sensor – plus"]
)
ha_state, hmip_device = get_and_check_entity_basics( ha_state, hmip_device = get_and_check_entity_basics(
hass, default_mock_hap, entity_id, entity_name, device_model hass, mock_hap, entity_id, entity_name, device_model
) )
assert ha_state.state == STATE_OFF assert ha_state.state == STATE_OFF
@ -246,14 +275,17 @@ async def test_hmip_storm_sensor(hass, default_mock_hap):
assert ha_state.state == STATE_ON assert ha_state.state == STATE_ON
async def test_hmip_rain_sensor(hass, default_mock_hap): async def test_hmip_rain_sensor(hass, default_mock_hap_factory):
"""Test HomematicipRainSensor.""" """Test HomematicipRainSensor."""
entity_id = "binary_sensor.wettersensor_pro_raining" entity_id = "binary_sensor.wettersensor_pro_raining"
entity_name = "Wettersensor - pro Raining" entity_name = "Wettersensor - pro Raining"
device_model = "HmIP-SWO-PR" device_model = "HmIP-SWO-PR"
mock_hap = await default_mock_hap_factory.async_get_mock_hap(
test_devices=["Wettersensor - pro"]
)
ha_state, hmip_device = get_and_check_entity_basics( ha_state, hmip_device = get_and_check_entity_basics(
hass, default_mock_hap, entity_id, entity_name, device_model hass, mock_hap, entity_id, entity_name, device_model
) )
assert ha_state.state == STATE_OFF assert ha_state.state == STATE_OFF
@ -262,14 +294,17 @@ async def test_hmip_rain_sensor(hass, default_mock_hap):
assert ha_state.state == STATE_ON assert ha_state.state == STATE_ON
async def test_hmip_sunshine_sensor(hass, default_mock_hap): async def test_hmip_sunshine_sensor(hass, default_mock_hap_factory):
"""Test HomematicipSunshineSensor.""" """Test HomematicipSunshineSensor."""
entity_id = "binary_sensor.wettersensor_pro_sunshine" entity_id = "binary_sensor.wettersensor_pro_sunshine"
entity_name = "Wettersensor - pro Sunshine" entity_name = "Wettersensor - pro Sunshine"
device_model = "HmIP-SWO-PR" device_model = "HmIP-SWO-PR"
mock_hap = await default_mock_hap_factory.async_get_mock_hap(
test_devices=["Wettersensor - pro"]
)
ha_state, hmip_device = get_and_check_entity_basics( ha_state, hmip_device = get_and_check_entity_basics(
hass, default_mock_hap, entity_id, entity_name, device_model hass, mock_hap, entity_id, entity_name, device_model
) )
assert ha_state.state == STATE_ON assert ha_state.state == STATE_ON
@ -279,14 +314,17 @@ async def test_hmip_sunshine_sensor(hass, default_mock_hap):
assert ha_state.state == STATE_OFF assert ha_state.state == STATE_OFF
async def test_hmip_battery_sensor(hass, default_mock_hap): async def test_hmip_battery_sensor(hass, default_mock_hap_factory):
"""Test HomematicipSunshineSensor.""" """Test HomematicipSunshineSensor."""
entity_id = "binary_sensor.wohnungsture_battery" entity_id = "binary_sensor.wohnungsture_battery"
entity_name = "Wohnungstüre Battery" entity_name = "Wohnungstüre Battery"
device_model = "HMIP-SWDO" device_model = "HMIP-SWDO"
mock_hap = await default_mock_hap_factory.async_get_mock_hap(
test_devices=["Wohnungstüre"]
)
ha_state, hmip_device = get_and_check_entity_basics( ha_state, hmip_device = get_and_check_entity_basics(
hass, default_mock_hap, entity_id, entity_name, device_model hass, mock_hap, entity_id, entity_name, device_model
) )
assert ha_state.state == STATE_OFF assert ha_state.state == STATE_OFF
@ -295,14 +333,17 @@ async def test_hmip_battery_sensor(hass, default_mock_hap):
assert ha_state.state == STATE_ON assert ha_state.state == STATE_ON
async def test_hmip_security_zone_sensor_group(hass, default_mock_hap): async def test_hmip_security_zone_sensor_group(hass, default_mock_hap_factory):
"""Test HomematicipSecurityZoneSensorGroup.""" """Test HomematicipSecurityZoneSensorGroup."""
entity_id = "binary_sensor.internal_securityzone" entity_id = "binary_sensor.internal_securityzone"
entity_name = "INTERNAL SecurityZone" entity_name = "INTERNAL SecurityZone"
device_model = "HmIP-SecurityZone" device_model = "HmIP-SecurityZone"
mock_hap = await default_mock_hap_factory.async_get_mock_hap(
test_groups=["INTERNAL"]
)
ha_state, hmip_device = get_and_check_entity_basics( ha_state, hmip_device = get_and_check_entity_basics(
hass, default_mock_hap, entity_id, entity_name, device_model hass, mock_hap, entity_id, entity_name, device_model
) )
assert ha_state.state == STATE_OFF assert ha_state.state == STATE_OFF
@ -327,14 +368,15 @@ async def test_hmip_security_zone_sensor_group(hass, default_mock_hap):
assert ha_state.attributes[ATTR_WINDOW_STATE] == WindowState.OPEN assert ha_state.attributes[ATTR_WINDOW_STATE] == WindowState.OPEN
async def test_hmip_security_sensor_group(hass, default_mock_hap): async def test_hmip_security_sensor_group(hass, default_mock_hap_factory):
"""Test HomematicipSecuritySensorGroup.""" """Test HomematicipSecuritySensorGroup."""
entity_id = "binary_sensor.buro_sensors" entity_id = "binary_sensor.buro_sensors"
entity_name = "Büro Sensors" entity_name = "Büro Sensors"
device_model = None device_model = None
mock_hap = await default_mock_hap_factory.async_get_mock_hap(test_groups=["Büro"])
ha_state, hmip_device = get_and_check_entity_basics( ha_state, hmip_device = get_and_check_entity_basics(
hass, default_mock_hap, entity_id, entity_name, device_model hass, mock_hap, entity_id, entity_name, device_model
) )
await async_manipulate_test_data( await async_manipulate_test_data(

40
tests/components/homematicip_cloud/test_climate.py
View File

@ -41,14 +41,18 @@ async def test_manually_configured_platform(hass):
assert not hass.data.get(HMIPC_DOMAIN) assert not hass.data.get(HMIPC_DOMAIN)
async def test_hmip_heating_group_heat(hass, default_mock_hap): async def test_hmip_heating_group_heat(hass, default_mock_hap_factory):
"""Test HomematicipHeatingGroup.""" """Test HomematicipHeatingGroup."""
entity_id = "climate.badezimmer" entity_id = "climate.badezimmer"
entity_name = "Badezimmer" entity_name = "Badezimmer"
device_model = None device_model = None
mock_hap = await default_mock_hap_factory.async_get_mock_hap(
test_devices=["Wandthermostat", "Heizkörperthermostat"],
test_groups=[entity_name],
)
ha_state, hmip_device = get_and_check_entity_basics( ha_state, hmip_device = get_and_check_entity_basics(
hass, default_mock_hap, entity_id, entity_name, device_model hass, mock_hap, entity_id, entity_name, device_model
) )
assert ha_state.state == HVAC_MODE_AUTO assert ha_state.state == HVAC_MODE_AUTO
@ -142,7 +146,7 @@ async def test_hmip_heating_group_heat(hass, default_mock_hap):
await async_manipulate_test_data(hass, hmip_device, "controlMode", "ECO") await async_manipulate_test_data(hass, hmip_device, "controlMode", "ECO")
await async_manipulate_test_data( await async_manipulate_test_data(
hass, hass,
default_mock_hap.home.get_functionalHome(IndoorClimateHome), mock_hap.home.get_functionalHome(IndoorClimateHome),
"absenceType", "absenceType",
AbsenceType.VACATION, AbsenceType.VACATION,
fire_device=hmip_device, fire_device=hmip_device,
@ -153,7 +157,7 @@ async def test_hmip_heating_group_heat(hass, default_mock_hap):
await async_manipulate_test_data(hass, hmip_device, "controlMode", "ECO") await async_manipulate_test_data(hass, hmip_device, "controlMode", "ECO")
await async_manipulate_test_data( await async_manipulate_test_data(
hass, hass,
default_mock_hap.home.get_functionalHome(IndoorClimateHome), mock_hap.home.get_functionalHome(IndoorClimateHome),
"absenceType", "absenceType",
AbsenceType.PERIOD, AbsenceType.PERIOD,
fire_device=hmip_device, fire_device=hmip_device,
@ -172,7 +176,7 @@ async def test_hmip_heating_group_heat(hass, default_mock_hap):
assert hmip_device.mock_calls[-1][0] == "set_active_profile" assert hmip_device.mock_calls[-1][0] == "set_active_profile"
assert hmip_device.mock_calls[-1][1] == (1,) assert hmip_device.mock_calls[-1][1] == (1,)
default_mock_hap.home.get_functionalHome( mock_hap.home.get_functionalHome(
IndoorClimateHome IndoorClimateHome
).absenceType = AbsenceType.PERMANENT ).absenceType = AbsenceType.PERMANENT
await async_manipulate_test_data(hass, hmip_device, "controlMode", "ECO") await async_manipulate_test_data(hass, hmip_device, "controlMode", "ECO")
@ -230,14 +234,17 @@ async def test_hmip_heating_group_heat(hass, default_mock_hap):
assert ha_state.attributes[ATTR_HVAC_ACTION] == CURRENT_HVAC_IDLE assert ha_state.attributes[ATTR_HVAC_ACTION] == CURRENT_HVAC_IDLE
async def test_hmip_heating_group_cool(hass, default_mock_hap): async def test_hmip_heating_group_cool(hass, default_mock_hap_factory):
"""Test HomematicipHeatingGroup.""" """Test HomematicipHeatingGroup."""
entity_id = "climate.badezimmer" entity_id = "climate.badezimmer"
entity_name = "Badezimmer" entity_name = "Badezimmer"
device_model = None device_model = None
mock_hap = await default_mock_hap_factory.async_get_mock_hap(
test_groups=[entity_name]
)
ha_state, hmip_device = get_and_check_entity_basics( ha_state, hmip_device = get_and_check_entity_basics(
hass, default_mock_hap, entity_id, entity_name, device_model hass, mock_hap, entity_id, entity_name, device_model
) )
hmip_device.activeProfile = hmip_device.profiles[3] hmip_device.activeProfile = hmip_device.profiles[3]
@ -347,14 +354,17 @@ async def test_hmip_heating_group_cool(hass, default_mock_hap):
assert hmip_device.mock_calls[-1][1] == (4,) assert hmip_device.mock_calls[-1][1] == (4,)
async def test_hmip_heating_group_heat_with_switch(hass, default_mock_hap): async def test_hmip_heating_group_heat_with_switch(hass, default_mock_hap_factory):
"""Test HomematicipHeatingGroup.""" """Test HomematicipHeatingGroup."""
entity_id = "climate.schlafzimmer" entity_id = "climate.schlafzimmer"
entity_name = "Schlafzimmer" entity_name = "Schlafzimmer"
device_model = None device_model = None
mock_hap = await default_mock_hap_factory.async_get_mock_hap(
test_devices=["Wandthermostat", "Heizkörperthermostat", "Pc"],
test_groups=[entity_name],
)
ha_state, hmip_device = get_and_check_entity_basics( ha_state, hmip_device = get_and_check_entity_basics(
hass, default_mock_hap, entity_id, entity_name, device_model hass, mock_hap, entity_id, entity_name, device_model
) )
assert hmip_device assert hmip_device
@ -480,14 +490,17 @@ async def test_hmip_climate_services(hass, mock_hap_with_service):
assert len(home._connection.mock_calls) == 10 # pylint: disable=protected-access assert len(home._connection.mock_calls) == 10 # pylint: disable=protected-access
async def test_hmip_heating_group_services(hass, mock_hap_with_service): async def test_hmip_heating_group_services(hass, default_mock_hap_factory):
"""Test HomematicipHeatingGroup services.""" """Test HomematicipHeatingGroup services."""
entity_id = "climate.badezimmer" entity_id = "climate.badezimmer"
entity_name = "Badezimmer" entity_name = "Badezimmer"
device_model = None device_model = None
mock_hap = await default_mock_hap_factory.async_get_mock_hap(
test_groups=[entity_name]
)
ha_state, hmip_device = get_and_check_entity_basics( ha_state, hmip_device = get_and_check_entity_basics(
hass, mock_hap_with_service, entity_id, entity_name, device_model hass, mock_hap, entity_id, entity_name, device_model
) )
assert ha_state assert ha_state
@ -512,6 +525,5 @@ async def test_hmip_heating_group_services(hass, mock_hap_with_service):
assert hmip_device.mock_calls[-1][0] == "set_active_profile" assert hmip_device.mock_calls[-1][0] == "set_active_profile"
assert hmip_device.mock_calls[-1][1] == (1,) assert hmip_device.mock_calls[-1][1] == (1,)
assert ( assert (
len(hmip_device._connection.mock_calls) # pylint: disable=protected-access len(hmip_device._connection.mock_calls) == 4 # pylint: disable=protected-access
== 12
) )

21
tests/components/homematicip_cloud/test_cover.py
View File

@ -24,14 +24,17 @@ async def test_manually_configured_platform(hass):
assert not hass.data.get(HMIPC_DOMAIN) assert not hass.data.get(HMIPC_DOMAIN)
async def test_hmip_cover_shutter(hass, default_mock_hap): async def test_hmip_cover_shutter(hass, default_mock_hap_factory):
"""Test HomematicipCoverShutte.""" """Test HomematicipCoverShutte."""
entity_id = "cover.sofa_links" entity_id = "cover.sofa_links"
entity_name = "Sofa links" entity_name = "Sofa links"
device_model = "HmIP-FBL" device_model = "HmIP-FBL"
mock_hap = await default_mock_hap_factory.async_get_mock_hap(
test_devices=[entity_name]
)
ha_state, hmip_device = get_and_check_entity_basics( ha_state, hmip_device = get_and_check_entity_basics(
hass, default_mock_hap, entity_id, entity_name, device_model hass, mock_hap, entity_id, entity_name, device_model
) )
assert ha_state.state == "closed" assert ha_state.state == "closed"
@ -90,14 +93,17 @@ async def test_hmip_cover_shutter(hass, default_mock_hap):
assert ha_state.state == STATE_UNKNOWN assert ha_state.state == STATE_UNKNOWN
async def test_hmip_cover_slats(hass, default_mock_hap): async def test_hmip_cover_slats(hass, default_mock_hap_factory):
"""Test HomematicipCoverSlats.""" """Test HomematicipCoverSlats."""
entity_id = "cover.sofa_links" entity_id = "cover.sofa_links"
entity_name = "Sofa links" entity_name = "Sofa links"
device_model = "HmIP-FBL" device_model = "HmIP-FBL"
mock_hap = await default_mock_hap_factory.async_get_mock_hap(
test_devices=[entity_name]
)
ha_state, hmip_device = get_and_check_entity_basics( ha_state, hmip_device = get_and_check_entity_basics(
hass, default_mock_hap, entity_id, entity_name, device_model hass, mock_hap, entity_id, entity_name, device_model
) )
assert ha_state.state == STATE_CLOSED assert ha_state.state == STATE_CLOSED
@ -157,14 +163,17 @@ async def test_hmip_cover_slats(hass, default_mock_hap):
assert ha_state.state == STATE_UNKNOWN assert ha_state.state == STATE_UNKNOWN
async def test_hmip_garage_door_tormatic(hass, default_mock_hap): async def test_hmip_garage_door_tormatic(hass, default_mock_hap_factory):
"""Test HomematicipCoverShutte.""" """Test HomematicipCoverShutte."""
entity_id = "cover.garage_door_module" entity_id = "cover.garage_door_module"
entity_name = "Garage Door Module" entity_name = "Garage Door Module"
device_model = "HmIP-MOD-TM" device_model = "HmIP-MOD-TM"
mock_hap = await default_mock_hap_factory.async_get_mock_hap(
test_devices=[entity_name]
)
ha_state, hmip_device = get_and_check_entity_basics( ha_state, hmip_device = get_and_check_entity_basics(
hass, default_mock_hap, entity_id, entity_name, device_model hass, mock_hap, entity_id, entity_name, device_model
) )
assert ha_state.state == "closed" assert ha_state.state == "closed"

84
tests/components/homematicip_cloud/test_device.py
View File

@ -7,18 +7,25 @@ from homeassistant.components.homematicip_cloud.hap import HomematicipHAP
from homeassistant.const import STATE_ON, STATE_UNAVAILABLE from homeassistant.const import STATE_ON, STATE_UNAVAILABLE
from homeassistant.helpers import device_registry as dr, entity_registry as er from homeassistant.helpers import device_registry as dr, entity_registry as er
from .conftest import get_mock_hap from .helper import (
from .helper import HAPID, async_manipulate_test_data, get_and_check_entity_basics HAPID,
HomeFactory,
async_manipulate_test_data,
get_and_check_entity_basics,
)
async def test_hmip_remove_device(hass, default_mock_hap): async def test_hmip_remove_device(hass, default_mock_hap_factory):
"""Test Remove of hmip device.""" """Test Remove of hmip device."""
entity_id = "light.treppe" entity_id = "light.treppe"
entity_name = "Treppe" entity_name = "Treppe"
device_model = "HmIP-BSL" device_model = "HmIP-BSL"
mock_hap = await default_mock_hap_factory.async_get_mock_hap(
test_devices=[entity_name]
)
ha_state, hmip_device = get_and_check_entity_basics( ha_state, hmip_device = get_and_check_entity_basics(
hass, default_mock_hap, entity_id, entity_name, device_model hass, mock_hap, entity_id, entity_name, device_model
) )
assert ha_state.state == STATE_ON assert ha_state.state == STATE_ON
@ -29,7 +36,7 @@ async def test_hmip_remove_device(hass, default_mock_hap):
pre_device_count = len(device_registry.devices) pre_device_count = len(device_registry.devices)
pre_entity_count = len(entity_registry.entities) pre_entity_count = len(entity_registry.entities)
pre_mapping_count = len(default_mock_hap.hmip_device_by_entity_id) pre_mapping_count = len(mock_hap.hmip_device_by_entity_id)
hmip_device.fire_remove_event() hmip_device.fire_remove_event()
@ -37,17 +44,20 @@ async def test_hmip_remove_device(hass, default_mock_hap):
assert len(device_registry.devices) == pre_device_count - 1 assert len(device_registry.devices) == pre_device_count - 1
assert len(entity_registry.entities) == pre_entity_count - 3 assert len(entity_registry.entities) == pre_entity_count - 3
assert len(default_mock_hap.hmip_device_by_entity_id) == pre_mapping_count - 3 assert len(mock_hap.hmip_device_by_entity_id) == pre_mapping_count - 3
async def test_hmip_add_device(hass, default_mock_hap, hmip_config_entry): async def test_hmip_add_device(hass, default_mock_hap_factory, hmip_config_entry):
"""Test Remove of hmip device.""" """Test Remove of hmip device."""
entity_id = "light.treppe" entity_id = "light.treppe"
entity_name = "Treppe" entity_name = "Treppe"
device_model = "HmIP-BSL" device_model = "HmIP-BSL"
mock_hap = await default_mock_hap_factory.async_get_mock_hap(
test_devices=[entity_name]
)
ha_state, hmip_device = get_and_check_entity_basics( ha_state, hmip_device = get_and_check_entity_basics(
hass, default_mock_hap, entity_id, entity_name, device_model hass, mock_hap, entity_id, entity_name, device_model
) )
assert ha_state.state == STATE_ON assert ha_state.state == STATE_ON
@ -58,25 +68,25 @@ async def test_hmip_add_device(hass, default_mock_hap, hmip_config_entry):
pre_device_count = len(device_registry.devices) pre_device_count = len(device_registry.devices)
pre_entity_count = len(entity_registry.entities) pre_entity_count = len(entity_registry.entities)
pre_mapping_count = len(default_mock_hap.hmip_device_by_entity_id) pre_mapping_count = len(mock_hap.hmip_device_by_entity_id)
hmip_device.fire_remove_event() hmip_device.fire_remove_event()
await hass.async_block_till_done() await hass.async_block_till_done()
assert len(device_registry.devices) == pre_device_count - 1 assert len(device_registry.devices) == pre_device_count - 1
assert len(entity_registry.entities) == pre_entity_count - 3 assert len(entity_registry.entities) == pre_entity_count - 3
assert len(default_mock_hap.hmip_device_by_entity_id) == pre_mapping_count - 3 assert len(mock_hap.hmip_device_by_entity_id) == pre_mapping_count - 3
reloaded_hap = HomematicipHAP(hass, hmip_config_entry) reloaded_hap = HomematicipHAP(hass, hmip_config_entry)
with patch( with patch(
"homeassistant.components.homematicip_cloud.HomematicipHAP", "homeassistant.components.homematicip_cloud.HomematicipHAP",
return_value=reloaded_hap, return_value=reloaded_hap,
), patch.object(reloaded_hap, "async_connect"), patch.object( ), patch.object(reloaded_hap, "async_connect"), patch.object(
reloaded_hap, "get_hap", return_value=default_mock_hap.home reloaded_hap, "get_hap", return_value=mock_hap.home
), patch( ), patch(
"homeassistant.components.homematicip_cloud.hap.asyncio.sleep" "homeassistant.components.homematicip_cloud.hap.asyncio.sleep"
): ):
default_mock_hap.home.fire_create_event(event_type=EventType.DEVICE_ADDED) mock_hap.home.fire_create_event(event_type=EventType.DEVICE_ADDED)
await hass.async_block_till_done() await hass.async_block_till_done()
assert len(device_registry.devices) == pre_device_count assert len(device_registry.devices) == pre_device_count
@ -85,14 +95,15 @@ async def test_hmip_add_device(hass, default_mock_hap, hmip_config_entry):
assert len(new_hap.hmip_device_by_entity_id) == pre_mapping_count assert len(new_hap.hmip_device_by_entity_id) == pre_mapping_count
async def test_hmip_remove_group(hass, default_mock_hap): async def test_hmip_remove_group(hass, default_mock_hap_factory):
"""Test Remove of hmip group.""" """Test Remove of hmip group."""
entity_id = "switch.strom_group" entity_id = "switch.strom_group"
entity_name = "Strom Group" entity_name = "Strom Group"
device_model = None device_model = None
mock_hap = await default_mock_hap_factory.async_get_mock_hap(test_groups=["Strom"])
ha_state, hmip_device = get_and_check_entity_basics( ha_state, hmip_device = get_and_check_entity_basics(
hass, default_mock_hap, entity_id, entity_name, device_model hass, mock_hap, entity_id, entity_name, device_model
) )
assert ha_state.state == STATE_ON assert ha_state.state == STATE_ON
@ -103,59 +114,67 @@ async def test_hmip_remove_group(hass, default_mock_hap):
pre_device_count = len(device_registry.devices) pre_device_count = len(device_registry.devices)
pre_entity_count = len(entity_registry.entities) pre_entity_count = len(entity_registry.entities)
pre_mapping_count = len(default_mock_hap.hmip_device_by_entity_id) pre_mapping_count = len(mock_hap.hmip_device_by_entity_id)
hmip_device.fire_remove_event() hmip_device.fire_remove_event()
await hass.async_block_till_done() await hass.async_block_till_done()
assert len(device_registry.devices) == pre_device_count assert len(device_registry.devices) == pre_device_count
assert len(entity_registry.entities) == pre_entity_count - 1 assert len(entity_registry.entities) == pre_entity_count - 1
assert len(default_mock_hap.hmip_device_by_entity_id) == pre_mapping_count - 1 assert len(mock_hap.hmip_device_by_entity_id) == pre_mapping_count - 1
async def test_all_devices_unavailable_when_hap_not_connected(hass, default_mock_hap): async def test_all_devices_unavailable_when_hap_not_connected(
hass, default_mock_hap_factory
):
"""Test make all devices unavaulable when hap is not connected.""" """Test make all devices unavaulable when hap is not connected."""
entity_id = "light.treppe" entity_id = "light.treppe"
entity_name = "Treppe" entity_name = "Treppe"
device_model = "HmIP-BSL" device_model = "HmIP-BSL"
mock_hap = await default_mock_hap_factory.async_get_mock_hap(
test_devices=[entity_name]
)
ha_state, hmip_device = get_and_check_entity_basics( ha_state, hmip_device = get_and_check_entity_basics(
hass, default_mock_hap, entity_id, entity_name, device_model hass, mock_hap, entity_id, entity_name, device_model
) )
assert ha_state.state == STATE_ON assert ha_state.state == STATE_ON
assert hmip_device assert hmip_device
assert default_mock_hap.home.connected assert mock_hap.home.connected
await async_manipulate_test_data(hass, default_mock_hap.home, "connected", False) await async_manipulate_test_data(hass, mock_hap.home, "connected", False)
ha_state = hass.states.get(entity_id) ha_state = hass.states.get(entity_id)
assert ha_state.state == STATE_UNAVAILABLE assert ha_state.state == STATE_UNAVAILABLE
async def test_hap_reconnected(hass, default_mock_hap): async def test_hap_reconnected(hass, default_mock_hap_factory):
"""Test reconnect hap.""" """Test reconnect hap."""
entity_id = "light.treppe" entity_id = "light.treppe"
entity_name = "Treppe" entity_name = "Treppe"
device_model = "HmIP-BSL" device_model = "HmIP-BSL"
mock_hap = await default_mock_hap_factory.async_get_mock_hap(
test_devices=[entity_name]
)
ha_state, hmip_device = get_and_check_entity_basics( ha_state, hmip_device = get_and_check_entity_basics(
hass, default_mock_hap, entity_id, entity_name, device_model hass, mock_hap, entity_id, entity_name, device_model
) )
assert ha_state.state == STATE_ON assert ha_state.state == STATE_ON
assert hmip_device assert hmip_device
assert default_mock_hap.home.connected assert mock_hap.home.connected
await async_manipulate_test_data(hass, default_mock_hap.home, "connected", False) await async_manipulate_test_data(hass, mock_hap.home, "connected", False)
ha_state = hass.states.get(entity_id) ha_state = hass.states.get(entity_id)
assert ha_state.state == STATE_UNAVAILABLE assert ha_state.state == STATE_UNAVAILABLE
default_mock_hap._accesspoint_connected = False # pylint: disable=protected-access mock_hap._accesspoint_connected = False # pylint: disable=protected-access
await async_manipulate_test_data(hass, default_mock_hap.home, "connected", True) await async_manipulate_test_data(hass, mock_hap.home, "connected", True)
await hass.async_block_till_done() await hass.async_block_till_done()
ha_state = hass.states.get(entity_id) ha_state = hass.states.get(entity_id)
assert ha_state.state == STATE_ON assert ha_state.state == STATE_ON
@ -169,7 +188,9 @@ async def test_hap_with_name(hass, mock_connection, hmip_config_entry):
device_model = "HmIP-BSL" device_model = "HmIP-BSL"
hmip_config_entry.data["name"] = home_name hmip_config_entry.data["name"] = home_name
mock_hap = await get_mock_hap(hass, mock_connection, hmip_config_entry) mock_hap = await HomeFactory(
hass, mock_connection, hmip_config_entry
).async_get_mock_hap(test_devices=["Treppe"])
assert mock_hap assert mock_hap
ha_state, hmip_device = get_and_check_entity_basics( ha_state, hmip_device = get_and_check_entity_basics(
@ -181,14 +202,17 @@ async def test_hap_with_name(hass, mock_connection, hmip_config_entry):
assert ha_state.attributes["friendly_name"] == entity_name assert ha_state.attributes["friendly_name"] == entity_name
async def test_hmip_reset_energy_counter_services(hass, mock_hap_with_service): async def test_hmip_reset_energy_counter_services(hass, default_mock_hap_factory):
"""Test reset_energy_counter service.""" """Test reset_energy_counter service."""
entity_id = "switch.pc" entity_id = "switch.pc"
entity_name = "Pc" entity_name = "Pc"
device_model = "HMIP-PSM" device_model = "HMIP-PSM"
mock_hap = await default_mock_hap_factory.async_get_mock_hap(
test_devices=[entity_name]
)
ha_state, hmip_device = get_and_check_entity_basics( ha_state, hmip_device = get_and_check_entity_basics(
hass, mock_hap_with_service, entity_id, entity_name, device_model hass, mock_hap, entity_id, entity_name, device_model
) )
assert ha_state assert ha_state
@ -205,4 +229,4 @@ async def test_hmip_reset_energy_counter_services(hass, mock_hap_with_service):
"homematicip_cloud", "reset_energy_counter", {"entity_id": "all"}, blocking=True "homematicip_cloud", "reset_energy_counter", {"entity_id": "all"}, blocking=True
) )
assert hmip_device.mock_calls[-1][0] == "reset_energy_counter" assert hmip_device.mock_calls[-1][0] == "reset_energy_counter"
assert len(hmip_device._connection.mock_calls) == 12 # pylint: disable=W0212 assert len(hmip_device._connection.mock_calls) == 4 # pylint: disable=W0212

5
tests/components/homematicip_cloud/test_hap.py
View File

@ -107,9 +107,10 @@ async def test_hap_setup_connection_error():
assert not hass.config_entries.flow.async_init.mock_calls assert not hass.config_entries.flow.async_init.mock_calls
async def test_hap_reset_unloads_entry_if_setup(hass, default_mock_hap): async def test_hap_reset_unloads_entry_if_setup(hass, default_mock_hap_factory):
"""Test calling reset while the entry has been setup.""" """Test calling reset while the entry has been setup."""
assert hass.data[HMIPC_DOMAIN][HAPID] == default_mock_hap mock_hap = await default_mock_hap_factory.async_get_mock_hap()
assert hass.data[HMIPC_DOMAIN][HAPID] == mock_hap
config_entries = hass.config_entries.async_entries(HMIPC_DOMAIN) config_entries = hass.config_entries.async_entries(HMIPC_DOMAIN)
assert len(config_entries) == 1 assert len(config_entries) == 1
# hap_reset is called during unload # hap_reset is called during unload

28
tests/components/homematicip_cloud/test_light.py
View File

@ -28,14 +28,17 @@ async def test_manually_configured_platform(hass):
assert not hass.data.get(HMIPC_DOMAIN) assert not hass.data.get(HMIPC_DOMAIN)
async def test_hmip_light(hass, default_mock_hap): async def test_hmip_light(hass, default_mock_hap_factory):
"""Test HomematicipLight.""" """Test HomematicipLight."""
entity_id = "light.treppe" entity_id = "light.treppe"
entity_name = "Treppe" entity_name = "Treppe"
device_model = "HmIP-BSL" device_model = "HmIP-BSL"
mock_hap = await default_mock_hap_factory.async_get_mock_hap(
test_devices=[entity_name]
)
ha_state, hmip_device = get_and_check_entity_basics( ha_state, hmip_device = get_and_check_entity_basics(
hass, default_mock_hap, entity_id, entity_name, device_model hass, mock_hap, entity_id, entity_name, device_model
) )
assert ha_state.state == STATE_ON assert ha_state.state == STATE_ON
@ -64,14 +67,17 @@ async def test_hmip_light(hass, default_mock_hap):
assert ha_state.state == STATE_ON assert ha_state.state == STATE_ON
async def test_hmip_notification_light(hass, default_mock_hap): async def test_hmip_notification_light(hass, default_mock_hap_factory):
"""Test HomematicipNotificationLight.""" """Test HomematicipNotificationLight."""
entity_id = "light.treppe_top_notification" entity_id = "light.treppe_top_notification"
entity_name = "Treppe Top Notification" entity_name = "Treppe Top Notification"
device_model = "HmIP-BSL" device_model = "HmIP-BSL"
mock_hap = await default_mock_hap_factory.async_get_mock_hap(
test_devices=["Treppe"]
)
ha_state, hmip_device = get_and_check_entity_basics( ha_state, hmip_device = get_and_check_entity_basics(
hass, default_mock_hap, entity_id, entity_name, device_model hass, mock_hap, entity_id, entity_name, device_model
) )
assert ha_state.state == STATE_OFF assert ha_state.state == STATE_OFF
@ -152,14 +158,17 @@ async def test_hmip_notification_light(hass, default_mock_hap):
assert not ha_state.attributes.get(ATTR_BRIGHTNESS) assert not ha_state.attributes.get(ATTR_BRIGHTNESS)
async def test_hmip_dimmer(hass, default_mock_hap): async def test_hmip_dimmer(hass, default_mock_hap_factory):
"""Test HomematicipDimmer.""" """Test HomematicipDimmer."""
entity_id = "light.schlafzimmerlicht" entity_id = "light.schlafzimmerlicht"
entity_name = "Schlafzimmerlicht" entity_name = "Schlafzimmerlicht"
device_model = "HmIP-BDT" device_model = "HmIP-BDT"
mock_hap = await default_mock_hap_factory.async_get_mock_hap(
test_devices=[entity_name]
)
ha_state, hmip_device = get_and_check_entity_basics( ha_state, hmip_device = get_and_check_entity_basics(
hass, default_mock_hap, entity_id, entity_name, device_model hass, mock_hap, entity_id, entity_name, device_model
) )
assert ha_state.state == STATE_OFF assert ha_state.state == STATE_OFF
@ -201,14 +210,17 @@ async def test_hmip_dimmer(hass, default_mock_hap):
assert not ha_state.attributes.get(ATTR_BRIGHTNESS) assert not ha_state.attributes.get(ATTR_BRIGHTNESS)
async def test_hmip_light_measuring(hass, default_mock_hap): async def test_hmip_light_measuring(hass, default_mock_hap_factory):
"""Test HomematicipLightMeasuring.""" """Test HomematicipLightMeasuring."""
entity_id = "light.flur_oben" entity_id = "light.flur_oben"
entity_name = "Flur oben" entity_name = "Flur oben"
device_model = "HmIP-BSM" device_model = "HmIP-BSM"
mock_hap = await default_mock_hap_factory.async_get_mock_hap(
test_devices=[entity_name]
)
ha_state, hmip_device = get_and_check_entity_basics( ha_state, hmip_device = get_and_check_entity_basics(
hass, default_mock_hap, entity_id, entity_name, device_model hass, mock_hap, entity_id, entity_name, device_model
) )
assert ha_state.state == STATE_OFF assert ha_state.state == STATE_OFF

77
tests/components/homematicip_cloud/test_sensor.py
View File

@ -39,14 +39,17 @@ async def test_manually_configured_platform(hass):
assert not hass.data.get(HMIPC_DOMAIN) assert not hass.data.get(HMIPC_DOMAIN)
async def test_hmip_accesspoint_status(hass, default_mock_hap): async def test_hmip_accesspoint_status(hass, default_mock_hap_factory):
"""Test HomematicipSwitch.""" """Test HomematicipSwitch."""
entity_id = "sensor.access_point" entity_id = "sensor.access_point"
entity_name = "Access Point" entity_name = "Access Point"
device_model = None device_model = None
mock_hap = await default_mock_hap_factory.async_get_mock_hap(
test_devices=[entity_name]
)
ha_state, hmip_device = get_and_check_entity_basics( ha_state, hmip_device = get_and_check_entity_basics(
hass, default_mock_hap, entity_id, entity_name, device_model hass, mock_hap, entity_id, entity_name, device_model
) )
assert hmip_device assert hmip_device
assert ha_state.state == "8.0" assert ha_state.state == "8.0"
@ -58,14 +61,17 @@ async def test_hmip_accesspoint_status(hass, default_mock_hap):
assert ha_state.state == "17.3" assert ha_state.state == "17.3"
async def test_hmip_heating_thermostat(hass, default_mock_hap): async def test_hmip_heating_thermostat(hass, default_mock_hap_factory):
"""Test HomematicipHeatingThermostat.""" """Test HomematicipHeatingThermostat."""
entity_id = "sensor.heizkorperthermostat_heating" entity_id = "sensor.heizkorperthermostat_heating"
entity_name = "Heizkörperthermostat Heating" entity_name = "Heizkörperthermostat Heating"
device_model = "HMIP-eTRV" device_model = "HMIP-eTRV"
mock_hap = await default_mock_hap_factory.async_get_mock_hap(
test_devices=["Heizkörperthermostat"]
)
ha_state, hmip_device = get_and_check_entity_basics( ha_state, hmip_device = get_and_check_entity_basics(
hass, default_mock_hap, entity_id, entity_name, device_model hass, mock_hap, entity_id, entity_name, device_model
) )
assert ha_state.state == "0" assert ha_state.state == "0"
@ -89,14 +95,17 @@ async def test_hmip_heating_thermostat(hass, default_mock_hap):
assert ha_state.attributes["icon"] == "mdi:battery-outline" assert ha_state.attributes["icon"] == "mdi:battery-outline"
async def test_hmip_humidity_sensor(hass, default_mock_hap): async def test_hmip_humidity_sensor(hass, default_mock_hap_factory):
"""Test HomematicipHumiditySensor.""" """Test HomematicipHumiditySensor."""
entity_id = "sensor.bwth_1_humidity" entity_id = "sensor.bwth_1_humidity"
entity_name = "BWTH 1 Humidity" entity_name = "BWTH 1 Humidity"
device_model = "HmIP-BWTH" device_model = "HmIP-BWTH"
mock_hap = await default_mock_hap_factory.async_get_mock_hap(
test_devices=["BWTH 1"]
)
ha_state, hmip_device = get_and_check_entity_basics( ha_state, hmip_device = get_and_check_entity_basics(
hass, default_mock_hap, entity_id, entity_name, device_model hass, mock_hap, entity_id, entity_name, device_model
) )
assert ha_state.state == "40" assert ha_state.state == "40"
@ -109,14 +118,17 @@ async def test_hmip_humidity_sensor(hass, default_mock_hap):
assert ha_state.attributes[ATTR_RSSI_PEER] == -77 assert ha_state.attributes[ATTR_RSSI_PEER] == -77
async def test_hmip_temperature_sensor1(hass, default_mock_hap): async def test_hmip_temperature_sensor1(hass, default_mock_hap_factory):
"""Test HomematicipTemperatureSensor.""" """Test HomematicipTemperatureSensor."""
entity_id = "sensor.bwth_1_temperature" entity_id = "sensor.bwth_1_temperature"
entity_name = "BWTH 1 Temperature" entity_name = "BWTH 1 Temperature"
device_model = "HmIP-BWTH" device_model = "HmIP-BWTH"
mock_hap = await default_mock_hap_factory.async_get_mock_hap(
test_devices=["BWTH 1"]
)
ha_state, hmip_device = get_and_check_entity_basics( ha_state, hmip_device = get_and_check_entity_basics(
hass, default_mock_hap, entity_id, entity_name, device_model hass, mock_hap, entity_id, entity_name, device_model
) )
assert ha_state.state == "21.0" assert ha_state.state == "21.0"
@ -131,14 +143,17 @@ async def test_hmip_temperature_sensor1(hass, default_mock_hap):
assert ha_state.attributes[ATTR_TEMPERATURE_OFFSET] == 10 assert ha_state.attributes[ATTR_TEMPERATURE_OFFSET] == 10
async def test_hmip_temperature_sensor2(hass, default_mock_hap): async def test_hmip_temperature_sensor2(hass, default_mock_hap_factory):
"""Test HomematicipTemperatureSensor.""" """Test HomematicipTemperatureSensor."""
entity_id = "sensor.heizkorperthermostat_temperature" entity_id = "sensor.heizkorperthermostat_temperature"
entity_name = "Heizkörperthermostat Temperature" entity_name = "Heizkörperthermostat Temperature"
device_model = "HMIP-eTRV" device_model = "HMIP-eTRV"
mock_hap = await default_mock_hap_factory.async_get_mock_hap(
test_devices=["Heizkörperthermostat"]
)
ha_state, hmip_device = get_and_check_entity_basics( ha_state, hmip_device = get_and_check_entity_basics(
hass, default_mock_hap, entity_id, entity_name, device_model hass, mock_hap, entity_id, entity_name, device_model
) )
assert ha_state.state == "20.0" assert ha_state.state == "20.0"
@ -153,14 +168,17 @@ async def test_hmip_temperature_sensor2(hass, default_mock_hap):
assert ha_state.attributes[ATTR_TEMPERATURE_OFFSET] == 10 assert ha_state.attributes[ATTR_TEMPERATURE_OFFSET] == 10
async def test_hmip_power_sensor(hass, default_mock_hap): async def test_hmip_power_sensor(hass, default_mock_hap_factory):
"""Test HomematicipPowerSensor.""" """Test HomematicipPowerSensor."""
entity_id = "sensor.flur_oben_power" entity_id = "sensor.flur_oben_power"
entity_name = "Flur oben Power" entity_name = "Flur oben Power"
device_model = "HmIP-BSM" device_model = "HmIP-BSM"
mock_hap = await default_mock_hap_factory.async_get_mock_hap(
test_devices=["Flur oben"]
)
ha_state, hmip_device = get_and_check_entity_basics( ha_state, hmip_device = get_and_check_entity_basics(
hass, default_mock_hap, entity_id, entity_name, device_model hass, mock_hap, entity_id, entity_name, device_model
) )
assert ha_state.state == "0.0" assert ha_state.state == "0.0"
@ -187,14 +205,17 @@ async def test_hmip_power_sensor(hass, default_mock_hap):
assert ha_state.attributes[ATTR_CONFIG_PENDING] assert ha_state.attributes[ATTR_CONFIG_PENDING]
async def test_hmip_illuminance_sensor1(hass, default_mock_hap): async def test_hmip_illuminance_sensor1(hass, default_mock_hap_factory):
"""Test HomematicipIlluminanceSensor.""" """Test HomematicipIlluminanceSensor."""
entity_id = "sensor.wettersensor_illuminance" entity_id = "sensor.wettersensor_illuminance"
entity_name = "Wettersensor Illuminance" entity_name = "Wettersensor Illuminance"
device_model = "HmIP-SWO-B" device_model = "HmIP-SWO-B"
mock_hap = await default_mock_hap_factory.async_get_mock_hap(
test_devices=["Wettersensor"]
)
ha_state, hmip_device = get_and_check_entity_basics( ha_state, hmip_device = get_and_check_entity_basics(
hass, default_mock_hap, entity_id, entity_name, device_model hass, mock_hap, entity_id, entity_name, device_model
) )
assert ha_state.state == "4890.0" assert ha_state.state == "4890.0"
@ -204,14 +225,17 @@ async def test_hmip_illuminance_sensor1(hass, default_mock_hap):
assert ha_state.state == "231" assert ha_state.state == "231"
async def test_hmip_illuminance_sensor2(hass, default_mock_hap): async def test_hmip_illuminance_sensor2(hass, default_mock_hap_factory):
"""Test HomematicipIlluminanceSensor.""" """Test HomematicipIlluminanceSensor."""
entity_id = "sensor.lichtsensor_nord_illuminance" entity_id = "sensor.lichtsensor_nord_illuminance"
entity_name = "Lichtsensor Nord Illuminance" entity_name = "Lichtsensor Nord Illuminance"
device_model = "HmIP-SLO" device_model = "HmIP-SLO"
mock_hap = await default_mock_hap_factory.async_get_mock_hap(
test_devices=["Lichtsensor Nord"]
)
ha_state, hmip_device = get_and_check_entity_basics( ha_state, hmip_device = get_and_check_entity_basics(
hass, default_mock_hap, entity_id, entity_name, device_model hass, mock_hap, entity_id, entity_name, device_model
) )
assert ha_state.state == "807.3" assert ha_state.state == "807.3"
@ -224,14 +248,17 @@ async def test_hmip_illuminance_sensor2(hass, default_mock_hap):
assert ha_state.attributes[ATTR_LOWEST_ILLUMINATION] == 785.2 assert ha_state.attributes[ATTR_LOWEST_ILLUMINATION] == 785.2
async def test_hmip_windspeed_sensor(hass, default_mock_hap): async def test_hmip_windspeed_sensor(hass, default_mock_hap_factory):
"""Test HomematicipWindspeedSensor.""" """Test HomematicipWindspeedSensor."""
entity_id = "sensor.wettersensor_pro_windspeed" entity_id = "sensor.wettersensor_pro_windspeed"
entity_name = "Wettersensor - pro Windspeed" entity_name = "Wettersensor - pro Windspeed"
device_model = "HmIP-SWO-PR" device_model = "HmIP-SWO-PR"
mock_hap = await default_mock_hap_factory.async_get_mock_hap(
test_devices=["Wettersensor - pro"]
)
ha_state, hmip_device = get_and_check_entity_basics( ha_state, hmip_device = get_and_check_entity_basics(
hass, default_mock_hap, entity_id, entity_name, device_model hass, mock_hap, entity_id, entity_name, device_model
) )
assert ha_state.state == "2.6" assert ha_state.state == "2.6"
@ -268,14 +295,17 @@ async def test_hmip_windspeed_sensor(hass, default_mock_hap):
assert ha_state.attributes[ATTR_WIND_DIRECTION] == txt assert ha_state.attributes[ATTR_WIND_DIRECTION] == txt
async def test_hmip_today_rain_sensor(hass, default_mock_hap): async def test_hmip_today_rain_sensor(hass, default_mock_hap_factory):
"""Test HomematicipTodayRainSensor.""" """Test HomematicipTodayRainSensor."""
entity_id = "sensor.weather_sensor_plus_today_rain" entity_id = "sensor.weather_sensor_plus_today_rain"
entity_name = "Weather Sensor – plus Today Rain" entity_name = "Weather Sensor – plus Today Rain"
device_model = "HmIP-SWO-PL" device_model = "HmIP-SWO-PL"
mock_hap = await default_mock_hap_factory.async_get_mock_hap(
test_devices=["Weather Sensor – plus"]
)
ha_state, hmip_device = get_and_check_entity_basics( ha_state, hmip_device = get_and_check_entity_basics(
hass, default_mock_hap, entity_id, entity_name, device_model hass, mock_hap, entity_id, entity_name, device_model
) )
assert ha_state.state == "3.9" assert ha_state.state == "3.9"
@ -285,14 +315,17 @@ async def test_hmip_today_rain_sensor(hass, default_mock_hap):
assert ha_state.state == "14.2" assert ha_state.state == "14.2"
async def test_hmip_passage_detector_delta_counter(hass, default_mock_hap): async def test_hmip_passage_detector_delta_counter(hass, default_mock_hap_factory):
"""Test HomematicipPassageDetectorDeltaCounter.""" """Test HomematicipPassageDetectorDeltaCounter."""
entity_id = "sensor.spdr_1" entity_id = "sensor.spdr_1"
entity_name = "SPDR_1" entity_name = "SPDR_1"
device_model = "HmIP-SPDR" device_model = "HmIP-SPDR"
mock_hap = await default_mock_hap_factory.async_get_mock_hap(
test_devices=[entity_name]
)
ha_state, hmip_device = get_and_check_entity_basics( ha_state, hmip_device = get_and_check_entity_basics(
hass, default_mock_hap, entity_id, entity_name, device_model hass, mock_hap, entity_id, entity_name, device_model
) )
assert ha_state.state == "164" assert ha_state.state == "164"

26
tests/components/homematicip_cloud/test_switch.py
View File

@ -25,14 +25,17 @@ async def test_manually_configured_platform(hass):
assert not hass.data.get(HMIPC_DOMAIN) assert not hass.data.get(HMIPC_DOMAIN)
async def test_hmip_switch(hass, default_mock_hap): async def test_hmip_switch(hass, default_mock_hap_factory):
"""Test HomematicipSwitch.""" """Test HomematicipSwitch."""
entity_id = "switch.schrank" entity_id = "switch.schrank"
entity_name = "Schrank" entity_name = "Schrank"
device_model = "HMIP-PS" device_model = "HMIP-PS"
mock_hap = await default_mock_hap_factory.async_get_mock_hap(
test_devices=[entity_name]
)
ha_state, hmip_device = get_and_check_entity_basics( ha_state, hmip_device = get_and_check_entity_basics(
hass, default_mock_hap, entity_id, entity_name, device_model hass, mock_hap, entity_id, entity_name, device_model
) )
assert ha_state.state == STATE_ON assert ha_state.state == STATE_ON
@ -59,14 +62,17 @@ async def test_hmip_switch(hass, default_mock_hap):
assert ha_state.state == STATE_ON assert ha_state.state == STATE_ON
async def test_hmip_switch_measuring(hass, default_mock_hap): async def test_hmip_switch_measuring(hass, default_mock_hap_factory):
"""Test HomematicipSwitchMeasuring.""" """Test HomematicipSwitchMeasuring."""
entity_id = "switch.pc" entity_id = "switch.pc"
entity_name = "Pc" entity_name = "Pc"
device_model = "HMIP-PSM" device_model = "HMIP-PSM"
mock_hap = await default_mock_hap_factory.async_get_mock_hap(
test_devices=[entity_name]
)
ha_state, hmip_device = get_and_check_entity_basics( ha_state, hmip_device = get_and_check_entity_basics(
hass, default_mock_hap, entity_id, entity_name, device_model hass, mock_hap, entity_id, entity_name, device_model
) )
assert ha_state.state == STATE_ON assert ha_state.state == STATE_ON
@ -100,14 +106,15 @@ async def test_hmip_switch_measuring(hass, default_mock_hap):
assert not ha_state.attributes.get(ATTR_TODAY_ENERGY_KWH) assert not ha_state.attributes.get(ATTR_TODAY_ENERGY_KWH)
async def test_hmip_group_switch(hass, default_mock_hap): async def test_hmip_group_switch(hass, default_mock_hap_factory):
"""Test HomematicipGroupSwitch.""" """Test HomematicipGroupSwitch."""
entity_id = "switch.strom_group" entity_id = "switch.strom_group"
entity_name = "Strom Group" entity_name = "Strom Group"
device_model = None device_model = None
mock_hap = await default_mock_hap_factory.async_get_mock_hap(test_groups=["Strom"])
ha_state, hmip_device = get_and_check_entity_basics( ha_state, hmip_device = get_and_check_entity_basics(
hass, default_mock_hap, entity_id, entity_name, device_model hass, mock_hap, entity_id, entity_name, device_model
) )
assert ha_state.state == STATE_ON assert ha_state.state == STATE_ON
@ -139,14 +146,17 @@ async def test_hmip_group_switch(hass, default_mock_hap):
assert ha_state.attributes[ATTR_GROUP_MEMBER_UNREACHABLE] assert ha_state.attributes[ATTR_GROUP_MEMBER_UNREACHABLE]
async def test_hmip_multi_switch(hass, default_mock_hap): async def test_hmip_multi_switch(hass, default_mock_hap_factory):
"""Test HomematicipMultiSwitch.""" """Test HomematicipMultiSwitch."""
entity_id = "switch.jalousien_1_kizi_2_schlazi_channel1" entity_id = "switch.jalousien_1_kizi_2_schlazi_channel1"
entity_name = "Jalousien - 1 KiZi, 2 SchlaZi Channel1" entity_name = "Jalousien - 1 KiZi, 2 SchlaZi Channel1"
device_model = "HmIP-PCBS2" device_model = "HmIP-PCBS2"
mock_hap = await default_mock_hap_factory.async_get_mock_hap(
test_devices=["Jalousien - 1 KiZi, 2 SchlaZi"]
)
ha_state, hmip_device = get_and_check_entity_basics( ha_state, hmip_device = get_and_check_entity_basics(
hass, default_mock_hap, entity_id, entity_name, device_model hass, mock_hap, entity_id, entity_name, device_model
) )
assert ha_state.state == STATE_OFF assert ha_state.state == STATE_OFF

25
tests/components/homematicip_cloud/test_weather.py
View File

@ -24,14 +24,17 @@ async def test_manually_configured_platform(hass):
assert not hass.data.get(HMIPC_DOMAIN) assert not hass.data.get(HMIPC_DOMAIN)
async def test_hmip_weather_sensor(hass, default_mock_hap): async def test_hmip_weather_sensor(hass, default_mock_hap_factory):
"""Test HomematicipWeatherSensor.""" """Test HomematicipWeatherSensor."""
entity_id = "weather.weather_sensor_plus" entity_id = "weather.weather_sensor_plus"
entity_name = "Weather Sensor – plus" entity_name = "Weather Sensor – plus"
device_model = "HmIP-SWO-PL" device_model = "HmIP-SWO-PL"
mock_hap = await default_mock_hap_factory.async_get_mock_hap(
test_devices=[entity_name]
)
ha_state, hmip_device = get_and_check_entity_basics( ha_state, hmip_device = get_and_check_entity_basics(
hass, default_mock_hap, entity_id, entity_name, device_model hass, mock_hap, entity_id, entity_name, device_model
) )
assert ha_state.state == "" assert ha_state.state == ""
@ -45,14 +48,17 @@ async def test_hmip_weather_sensor(hass, default_mock_hap):
assert ha_state.attributes[ATTR_WEATHER_TEMPERATURE] == 12.1 assert ha_state.attributes[ATTR_WEATHER_TEMPERATURE] == 12.1
async def test_hmip_weather_sensor_pro(hass, default_mock_hap): async def test_hmip_weather_sensor_pro(hass, default_mock_hap_factory):
"""Test HomematicipWeatherSensorPro.""" """Test HomematicipWeatherSensorPro."""
entity_id = "weather.wettersensor_pro" entity_id = "weather.wettersensor_pro"
entity_name = "Wettersensor - pro" entity_name = "Wettersensor - pro"
device_model = "HmIP-SWO-PR" device_model = "HmIP-SWO-PR"
mock_hap = await default_mock_hap_factory.async_get_mock_hap(
test_devices=[entity_name]
)
ha_state, hmip_device = get_and_check_entity_basics( ha_state, hmip_device = get_and_check_entity_basics(
hass, default_mock_hap, entity_id, entity_name, device_model hass, mock_hap, entity_id, entity_name, device_model
) )
assert ha_state.state == "sunny" assert ha_state.state == "sunny"
@ -67,14 +73,15 @@ async def test_hmip_weather_sensor_pro(hass, default_mock_hap):
assert ha_state.attributes[ATTR_WEATHER_TEMPERATURE] == 12.1 assert ha_state.attributes[ATTR_WEATHER_TEMPERATURE] == 12.1
async def test_hmip_home_weather(hass, default_mock_hap): async def test_hmip_home_weather(hass, default_mock_hap_factory):
"""Test HomematicipHomeWeather.""" """Test HomematicipHomeWeather."""
entity_id = "weather.weather_1010_wien_osterreich" entity_id = "weather.weather_1010_wien_osterreich"
entity_name = "Weather 1010 Wien, Österreich" entity_name = "Weather 1010 Wien, Österreich"
device_model = None device_model = None
mock_hap = await default_mock_hap_factory.async_get_mock_hap()
ha_state, hmip_device = get_and_check_entity_basics( ha_state, hmip_device = get_and_check_entity_basics(
hass, default_mock_hap, entity_id, entity_name, device_model hass, mock_hap, entity_id, entity_name, device_model
) )
assert hmip_device assert hmip_device
assert ha_state.state == "partlycloudy" assert ha_state.state == "partlycloudy"
@ -85,11 +92,7 @@ async def test_hmip_home_weather(hass, default_mock_hap):
assert ha_state.attributes[ATTR_WEATHER_ATTRIBUTION] == "Powered by Homematic IP" assert ha_state.attributes[ATTR_WEATHER_ATTRIBUTION] == "Powered by Homematic IP"
await async_manipulate_test_data( await async_manipulate_test_data(
hass, hass, mock_hap.home.weather, "temperature", 28.3, fire_device=mock_hap.home
default_mock_hap.home.weather,
"temperature",
28.3,
fire_device=default_mock_hap.home,
) )
ha_state = hass.states.get(entity_id) ha_state = hass.states.get(entity_id)