From 1dbfc66669b3238bbeffc704196d1a6b696237f3 Mon Sep 17 00:00:00 2001 From: SukramJ Date: Mon, 27 Jan 2020 21:34:15 +0100 Subject: [PATCH] Cleanup of HomematicIP Cloud tests (#31181) * CleanUp tests for HomematicIP_Cloud * Remove not required CoroutineMock * remove None return in mocks, add asserts * rewrite test --- .../components/homematicip_cloud/conftest.py | 43 ++--- .../homematicip_cloud/test_config_flow.py | 73 +++------ .../components/homematicip_cloud/test_hap.py | 154 +++++++----------- .../components/homematicip_cloud/test_init.py | 75 +++++---- 4 files changed, 145 insertions(+), 200 deletions(-) diff --git a/tests/components/homematicip_cloud/conftest.py b/tests/components/homematicip_cloud/conftest.py index a37583cc139..9d70464f842 100644 --- a/tests/components/homematicip_cloud/conftest.py +++ b/tests/components/homematicip_cloud/conftest.py @@ -1,5 +1,5 @@ """Initializer helpers for HomematicIP fake server.""" -from asynctest import MagicMock, Mock, patch +from asynctest import CoroutineMock, MagicMock, Mock, patch from homematicip.aio.auth import AsyncAuth from homematicip.aio.connection import AsyncConnection from homematicip.aio.home import AsyncHome @@ -9,14 +9,19 @@ from homeassistant import config_entries from homeassistant.components.homematicip_cloud import ( DOMAIN as HMIPC_DOMAIN, async_setup as hmip_async_setup, - const as hmipc, - hap as hmip_hap, ) +from homeassistant.components.homematicip_cloud.const import ( + HMIPC_AUTHTOKEN, + HMIPC_HAPID, + HMIPC_NAME, + HMIPC_PIN, +) +from homeassistant.components.homematicip_cloud.hap import HomematicipHAP from homeassistant.helpers.typing import ConfigType, HomeAssistantType from .helper import AUTH_TOKEN, HAPID, HAPPIN, HomeTemplate -from tests.common import MockConfigEntry, mock_coro +from tests.common import MockConfigEntry @pytest.fixture(name="mock_connection") @@ -30,8 +35,8 @@ def mock_connection_fixture() -> AsyncConnection: connection._restCall.side_effect = ( # pylint: disable=protected-access _rest_call_side_effect ) - connection.api_call.return_value = mock_coro(True) - connection.init.side_effect = mock_coro(True) + connection.api_call = CoroutineMock(return_value=True) + connection.init = CoroutineMock(side_effect=True) return connection @@ -40,10 +45,10 @@ def mock_connection_fixture() -> AsyncConnection: def hmip_config_entry_fixture() -> config_entries.ConfigEntry: """Create a mock config entriy for homematic ip cloud.""" entry_data = { - hmipc.HMIPC_HAPID: HAPID, - hmipc.HMIPC_AUTHTOKEN: AUTH_TOKEN, - hmipc.HMIPC_NAME: "", - hmipc.HMIPC_PIN: HAPPIN, + HMIPC_HAPID: HAPID, + HMIPC_AUTHTOKEN: AUTH_TOKEN, + HMIPC_NAME: "", + HMIPC_PIN: HAPPIN, } config_entry = MockConfigEntry( version=1, @@ -68,7 +73,7 @@ def default_mock_home_fixture(mock_connection) -> AsyncHome: @pytest.fixture(name="default_mock_hap") async def default_mock_hap_fixture( hass: HomeAssistantType, mock_connection, hmip_config_entry -) -> hmip_hap.HomematicipHAP: +) -> HomematicipHAP: """Create a mocked homematic access point.""" return await get_mock_hap(hass, mock_connection, hmip_config_entry) @@ -77,17 +82,17 @@ async def get_mock_hap( hass: HomeAssistantType, mock_connection, hmip_config_entry: config_entries.ConfigEntry, -) -> hmip_hap.HomematicipHAP: +) -> HomematicipHAP: """Create a mocked homematic access point.""" hass.config.components.add(HMIPC_DOMAIN) - hap = hmip_hap.HomematicipHAP(hass, hmip_config_entry) + hap = HomematicipHAP(hass, hmip_config_entry) home_name = hmip_config_entry.data["name"] mock_home = ( HomeTemplate(connection=mock_connection, home_name=home_name) .init_home() .get_async_home_mock() ) - with patch.object(hap, "get_hap", return_value=mock_coro(mock_home)): + with patch.object(hap, "get_hap", return_value=mock_home): assert await hap.async_setup() mock_home.on_update(hap.async_update) mock_home.on_create(hap.async_create_entity) @@ -104,10 +109,10 @@ def hmip_config_fixture() -> ConfigType: """Create a config for homematic ip cloud.""" entry_data = { - hmipc.HMIPC_HAPID: HAPID, - hmipc.HMIPC_AUTHTOKEN: AUTH_TOKEN, - hmipc.HMIPC_NAME: "", - hmipc.HMIPC_PIN: HAPPIN, + HMIPC_HAPID: HAPID, + HMIPC_AUTHTOKEN: AUTH_TOKEN, + HMIPC_NAME: "", + HMIPC_PIN: HAPPIN, } return {HMIPC_DOMAIN: [entry_data]} @@ -122,7 +127,7 @@ def dummy_config_fixture() -> ConfigType: @pytest.fixture(name="mock_hap_with_service") async def mock_hap_with_service_fixture( hass: HomeAssistantType, default_mock_hap, dummy_config -) -> hmip_hap.HomematicipHAP: +) -> HomematicipHAP: """Create a fake homematic access point with hass services.""" await hmip_async_setup(hass, dummy_config) await hass.async_block_till_done() diff --git a/tests/components/homematicip_cloud/test_config_flow.py b/tests/components/homematicip_cloud/test_config_flow.py index bf1d628d9c2..01e820e7565 100644 --- a/tests/components/homematicip_cloud/test_config_flow.py +++ b/tests/components/homematicip_cloud/test_config_flow.py @@ -1,25 +1,30 @@ """Tests for HomematicIP Cloud config flow.""" from asynctest import patch -from homeassistant.components.homematicip_cloud import const +from homeassistant.components.homematicip_cloud.const import ( + DOMAIN as HMIPC_DOMAIN, + HMIPC_AUTHTOKEN, + HMIPC_HAPID, + HMIPC_NAME, + HMIPC_PIN, +) from tests.common import MockConfigEntry +DEFAULT_CONFIG = {HMIPC_HAPID: "ABC123", HMIPC_PIN: "123", HMIPC_NAME: "hmip"} + +IMPORT_CONFIG = {HMIPC_HAPID: "ABC123", HMIPC_AUTHTOKEN: "123", HMIPC_NAME: "hmip"} + async def test_flow_works(hass): """Test config flow.""" - config = { - const.HMIPC_HAPID: "ABC123", - const.HMIPC_PIN: "123", - const.HMIPC_NAME: "hmip", - } with patch( "homeassistant.components.homematicip_cloud.hap.HomematicipAuth.async_checkbutton", return_value=False, ): result = await hass.config_entries.flow.async_init( - const.DOMAIN, context={"source": "user"}, data=config + HMIPC_DOMAIN, context={"source": "user"}, data=DEFAULT_CONFIG ) assert result["type"] == "form" @@ -57,18 +62,12 @@ async def test_flow_works(hass): async def test_flow_init_connection_error(hass): """Test config flow with accesspoint connection error.""" - config = { - const.HMIPC_HAPID: "ABC123", - const.HMIPC_PIN: "123", - const.HMIPC_NAME: "hmip", - } - with patch( "homeassistant.components.homematicip_cloud.hap.HomematicipAuth.async_setup", return_value=False, ): result = await hass.config_entries.flow.async_init( - const.DOMAIN, context={"source": "user"}, data=config + HMIPC_DOMAIN, context={"source": "user"}, data=DEFAULT_CONFIG ) assert result["type"] == "form" @@ -77,12 +76,6 @@ async def test_flow_init_connection_error(hass): async def test_flow_link_connection_error(hass): """Test config flow client registration connection error.""" - config = { - const.HMIPC_HAPID: "ABC123", - const.HMIPC_PIN: "123", - const.HMIPC_NAME: "hmip", - } - with patch( "homeassistant.components.homematicip_cloud.hap.HomematicipAuth.async_checkbutton", return_value=True, @@ -94,7 +87,7 @@ async def test_flow_link_connection_error(hass): return_value=False, ): result = await hass.config_entries.flow.async_init( - const.DOMAIN, context={"source": "user"}, data=config + HMIPC_DOMAIN, context={"source": "user"}, data=DEFAULT_CONFIG ) assert result["type"] == "abort" @@ -103,12 +96,6 @@ async def test_flow_link_connection_error(hass): async def test_flow_link_press_button(hass): """Test config flow ask for pressing the blue button.""" - config = { - const.HMIPC_HAPID: "ABC123", - const.HMIPC_PIN: "123", - const.HMIPC_NAME: "hmip", - } - with patch( "homeassistant.components.homematicip_cloud.hap.HomematicipAuth.async_checkbutton", return_value=False, @@ -117,7 +104,7 @@ async def test_flow_link_press_button(hass): return_value=True, ): result = await hass.config_entries.flow.async_init( - const.DOMAIN, context={"source": "user"}, data=config + HMIPC_DOMAIN, context={"source": "user"}, data=DEFAULT_CONFIG ) assert result["type"] == "form" @@ -129,7 +116,7 @@ async def test_init_flow_show_form(hass): """Test config flow shows up with a form.""" result = await hass.config_entries.flow.async_init( - const.DOMAIN, context={"source": "user"} + HMIPC_DOMAIN, context={"source": "user"} ) assert result["type"] == "form" assert result["step_id"] == "init" @@ -137,19 +124,13 @@ async def test_init_flow_show_form(hass): async def test_init_already_configured(hass): """Test accesspoint is already configured.""" - MockConfigEntry(domain=const.DOMAIN, unique_id="ABC123").add_to_hass(hass) - config = { - const.HMIPC_HAPID: "ABC123", - const.HMIPC_PIN: "123", - const.HMIPC_NAME: "hmip", - } - + MockConfigEntry(domain=HMIPC_DOMAIN, unique_id="ABC123").add_to_hass(hass) with patch( "homeassistant.components.homematicip_cloud.hap.HomematicipAuth.async_checkbutton", return_value=True, ): result = await hass.config_entries.flow.async_init( - const.DOMAIN, context={"source": "user"}, data=config + HMIPC_DOMAIN, context={"source": "user"}, data=DEFAULT_CONFIG ) assert result["type"] == "abort" @@ -158,12 +139,6 @@ async def test_init_already_configured(hass): async def test_import_config(hass): """Test importing a host with an existing config file.""" - config = { - const.HMIPC_HAPID: "ABC123", - const.HMIPC_AUTHTOKEN: "123", - const.HMIPC_NAME: "hmip", - } - with patch( "homeassistant.components.homematicip_cloud.hap.HomematicipAuth.async_checkbutton", return_value=True, @@ -175,7 +150,7 @@ async def test_import_config(hass): return_value=True, ): result = await hass.config_entries.flow.async_init( - const.DOMAIN, context={"source": "import"}, data=config + HMIPC_DOMAIN, context={"source": "import"}, data=IMPORT_CONFIG ) assert result["type"] == "create_entry" @@ -186,13 +161,7 @@ async def test_import_config(hass): async def test_import_existing_config(hass): """Test abort of an existing accesspoint from config.""" - MockConfigEntry(domain=const.DOMAIN, unique_id="ABC123").add_to_hass(hass) - config = { - const.HMIPC_HAPID: "ABC123", - const.HMIPC_AUTHTOKEN: "123", - const.HMIPC_NAME: "hmip", - } - + MockConfigEntry(domain=HMIPC_DOMAIN, unique_id="ABC123").add_to_hass(hass) with patch( "homeassistant.components.homematicip_cloud.hap.HomematicipAuth.async_checkbutton", return_value=True, @@ -204,7 +173,7 @@ async def test_import_existing_config(hass): return_value=True, ): result = await hass.config_entries.flow.async_init( - const.DOMAIN, context={"source": "import"}, data=config + HMIPC_DOMAIN, context={"source": "import"}, data=IMPORT_CONFIG ) assert result["type"] == "abort" diff --git a/tests/components/homematicip_cloud/test_hap.py b/tests/components/homematicip_cloud/test_hap.py index 324649ef515..765bee4a75d 100644 --- a/tests/components/homematicip_cloud/test_hap.py +++ b/tests/components/homematicip_cloud/test_hap.py @@ -5,81 +5,71 @@ from homematicip.aio.auth import AsyncAuth from homematicip.base.base_connection import HmipConnectionError import pytest -from homeassistant.components.homematicip_cloud import ( - DOMAIN as HMIPC_DOMAIN, - const, - errors, - hap as hmipc, +from homeassistant.components.homematicip_cloud import DOMAIN as HMIPC_DOMAIN +from homeassistant.components.homematicip_cloud.const import ( + HMIPC_AUTHTOKEN, + HMIPC_HAPID, + HMIPC_NAME, + HMIPC_PIN, ) +from homeassistant.components.homematicip_cloud.errors import HmipcConnectionError from homeassistant.components.homematicip_cloud.hap import ( HomematicipAuth, HomematicipHAP, ) +from homeassistant.config_entries import ENTRY_STATE_LOADED, ENTRY_STATE_NOT_LOADED from homeassistant.exceptions import ConfigEntryNotReady from .helper import HAPID, HAPPIN -from tests.common import mock_coro, mock_coro_func +from tests.common import MockConfigEntry async def test_auth_setup(hass): """Test auth setup for client registration.""" - config = { - const.HMIPC_HAPID: "ABC123", - const.HMIPC_PIN: "123", - const.HMIPC_NAME: "hmip", - } - hap = hmipc.HomematicipAuth(hass, config) - with patch.object(hap, "get_auth", return_value=mock_coro()): - assert await hap.async_setup() + config = {HMIPC_HAPID: "ABC123", HMIPC_PIN: "123", HMIPC_NAME: "hmip"} + hmip_auth = HomematicipAuth(hass, config) + with patch.object(hmip_auth, "get_auth"): + assert await hmip_auth.async_setup() async def test_auth_setup_connection_error(hass): """Test auth setup connection error behaviour.""" - config = { - const.HMIPC_HAPID: "ABC123", - const.HMIPC_PIN: "123", - const.HMIPC_NAME: "hmip", - } - hap = hmipc.HomematicipAuth(hass, config) - with patch.object(hap, "get_auth", side_effect=errors.HmipcConnectionError): - assert not await hap.async_setup() + config = {HMIPC_HAPID: "ABC123", HMIPC_PIN: "123", HMIPC_NAME: "hmip"} + hmip_auth = HomematicipAuth(hass, config) + with patch.object(hmip_auth, "get_auth", side_effect=HmipcConnectionError): + assert not await hmip_auth.async_setup() async def test_auth_auth_check_and_register(hass): """Test auth client registration.""" - config = { - const.HMIPC_HAPID: "ABC123", - const.HMIPC_PIN: "123", - const.HMIPC_NAME: "hmip", - } - hap = hmipc.HomematicipAuth(hass, config) - hap.auth = Mock() + config = {HMIPC_HAPID: "ABC123", HMIPC_PIN: "123", HMIPC_NAME: "hmip"} + + hmip_auth = HomematicipAuth(hass, config) + hmip_auth.auth = Mock(spec=AsyncAuth) with patch.object( - hap.auth, "isRequestAcknowledged", return_value=mock_coro(True) + hmip_auth.auth, "isRequestAcknowledged", return_value=True ), patch.object( - hap.auth, "requestAuthToken", return_value=mock_coro("ABC") + hmip_auth.auth, "requestAuthToken", return_value="ABC" ), patch.object( - hap.auth, "confirmAuthToken", return_value=mock_coro() + hmip_auth.auth, "confirmAuthToken" ): - assert await hap.async_checkbutton() - assert await hap.async_register() == "ABC" + assert await hmip_auth.async_checkbutton() + assert await hmip_auth.async_register() == "ABC" async def test_auth_auth_check_and_register_with_exception(hass): """Test auth client registration.""" - config = { - const.HMIPC_HAPID: "ABC123", - const.HMIPC_PIN: "123", - const.HMIPC_NAME: "hmip", - } - hap = hmipc.HomematicipAuth(hass, config) - hap.auth = Mock(spec=AsyncAuth) + config = {HMIPC_HAPID: "ABC123", HMIPC_PIN: "123", HMIPC_NAME: "hmip"} + hmip_auth = HomematicipAuth(hass, config) + hmip_auth.auth = Mock(spec=AsyncAuth) with patch.object( - hap.auth, "isRequestAcknowledged", side_effect=HmipConnectionError - ), patch.object(hap.auth, "requestAuthToken", side_effect=HmipConnectionError): - assert not await hap.async_checkbutton() - assert await hap.async_register() is False + hmip_auth.auth, "isRequestAcknowledged", side_effect=HmipConnectionError + ), patch.object( + hmip_auth.auth, "requestAuthToken", side_effect=HmipConnectionError + ): + assert not await hmip_auth.async_checkbutton() + assert await hmip_auth.async_register() is False async def test_hap_setup_works(aioclient_mock): @@ -87,13 +77,9 @@ async def test_hap_setup_works(aioclient_mock): hass = Mock() entry = Mock() home = Mock() - entry.data = { - hmipc.HMIPC_HAPID: "ABC123", - hmipc.HMIPC_AUTHTOKEN: "123", - hmipc.HMIPC_NAME: "hmip", - } - hap = hmipc.HomematicipHAP(hass, entry) - with patch.object(hap, "get_hap", return_value=mock_coro(home)): + entry.data = {HMIPC_HAPID: "ABC123", HMIPC_AUTHTOKEN: "123", HMIPC_NAME: "hmip"} + hap = HomematicipHAP(hass, entry) + with patch.object(hap, "get_hap", return_value=home): assert await hap.async_setup() assert hap.home is home @@ -112,44 +98,34 @@ async def test_hap_setup_connection_error(): """Test a failed accesspoint setup.""" hass = Mock() entry = Mock() - entry.data = { - hmipc.HMIPC_HAPID: "ABC123", - hmipc.HMIPC_AUTHTOKEN: "123", - hmipc.HMIPC_NAME: "hmip", - } - hap = hmipc.HomematicipHAP(hass, entry) - with patch.object( - hap, "get_hap", side_effect=errors.HmipcConnectionError - ), pytest.raises(ConfigEntryNotReady): + entry.data = {HMIPC_HAPID: "ABC123", HMIPC_AUTHTOKEN: "123", HMIPC_NAME: "hmip"} + hap = HomematicipHAP(hass, entry) + with patch.object(hap, "get_hap", side_effect=HmipcConnectionError), pytest.raises( + ConfigEntryNotReady + ): await hap.async_setup() assert not hass.async_add_job.mock_calls assert not hass.config_entries.flow.async_init.mock_calls -async def test_hap_reset_unloads_entry_if_setup(): +async def test_hap_reset_unloads_entry_if_setup(hass, default_mock_hap, hmip_config): """Test calling reset while the entry has been setup.""" - hass = Mock() - entry = Mock() - home = Mock() - home.disable_events = mock_coro_func() - entry.data = { - hmipc.HMIPC_HAPID: "ABC123", - hmipc.HMIPC_AUTHTOKEN: "123", - hmipc.HMIPC_NAME: "hmip", - } - hap = hmipc.HomematicipHAP(hass, entry) - with patch.object(hap, "get_hap", return_value=mock_coro(home)): - assert await hap.async_setup() + MockConfigEntry( + domain=HMIPC_DOMAIN, + unique_id=HAPID, + data=hmip_config[HMIPC_DOMAIN][0], + state=ENTRY_STATE_LOADED, + ).add_to_hass(hass) - assert hap.home is home - assert not hass.services.async_register.mock_calls - assert len(hass.config_entries.async_forward_entry_setup.mock_calls) == 8 - - hass.config_entries.async_forward_entry_unload.return_value = mock_coro(True) - await hap.async_reset() - - assert len(hass.config_entries.async_forward_entry_unload.mock_calls) == 8 + assert hass.data[HMIPC_DOMAIN][HAPID] == default_mock_hap + config_entries = hass.config_entries.async_entries(HMIPC_DOMAIN) + assert len(config_entries) == 1 + # hap_reset is called during unload + await hass.config_entries.async_unload(config_entries[0].entry_id) + # entry is unloaded + assert config_entries[0].state == ENTRY_STATE_NOT_LOADED + assert hass.data[HMIPC_DOMAIN] == {} async def test_hap_create(hass, hmip_config_entry, simple_mock_home): @@ -160,7 +136,7 @@ async def test_hap_create(hass, hmip_config_entry, simple_mock_home): with patch( "homeassistant.components.homematicip_cloud.hap.AsyncHome", return_value=simple_mock_home, - ), patch.object(hap, "async_connect", return_value=mock_coro(None)): + ), patch.object(hap, "async_connect"): assert await hap.async_setup() @@ -185,11 +161,7 @@ async def test_hap_create_exception(hass, hmip_config_entry, simple_mock_home): async def test_auth_create(hass, simple_mock_auth): """Mock AsyncAuth to execute get_auth.""" - config = { - const.HMIPC_HAPID: HAPID, - const.HMIPC_PIN: HAPPIN, - const.HMIPC_NAME: "hmip", - } + config = {HMIPC_HAPID: HAPID, HMIPC_PIN: HAPPIN, HMIPC_NAME: "hmip"} hmip_auth = HomematicipAuth(hass, config) assert hmip_auth @@ -204,11 +176,7 @@ async def test_auth_create(hass, simple_mock_auth): async def test_auth_create_exception(hass, simple_mock_auth): """Mock AsyncAuth to execute get_auth.""" - config = { - const.HMIPC_HAPID: HAPID, - const.HMIPC_PIN: HAPPIN, - const.HMIPC_NAME: "hmip", - } + config = {HMIPC_HAPID: HAPID, HMIPC_PIN: HAPPIN, HMIPC_NAME: "hmip"} hmip_auth = HomematicipAuth(hass, config) simple_mock_auth.connectionRequest.side_effect = HmipConnectionError assert hmip_auth diff --git a/tests/components/homematicip_cloud/test_init.py b/tests/components/homematicip_cloud/test_init.py index c1ce12d4bfc..ee63dba3c97 100644 --- a/tests/components/homematicip_cloud/test_init.py +++ b/tests/components/homematicip_cloud/test_init.py @@ -1,33 +1,43 @@ """Test HomematicIP Cloud setup process.""" -from asynctest import CoroutineMock, patch +from asynctest import CoroutineMock, Mock, patch -from homeassistant.components import homematicip_cloud as hmipc +from homeassistant.components.homematicip_cloud.const import ( + CONF_ACCESSPOINT, + CONF_AUTHTOKEN, + DOMAIN as HMIPC_DOMAIN, + HMIPC_AUTHTOKEN, + HMIPC_HAPID, + HMIPC_NAME, +) +from homeassistant.components.homematicip_cloud.hap import HomematicipHAP +from homeassistant.config_entries import ENTRY_STATE_LOADED, ENTRY_STATE_NOT_LOADED +from homeassistant.const import CONF_NAME from homeassistant.setup import async_setup_component -from tests.common import Mock, MockConfigEntry +from tests.common import MockConfigEntry async def test_config_with_accesspoint_passed_to_config_entry(hass): """Test that config for a accesspoint are loaded via config entry.""" entry_config = { - hmipc.CONF_ACCESSPOINT: "ABC123", - hmipc.CONF_AUTHTOKEN: "123", - hmipc.CONF_NAME: "name", + CONF_ACCESSPOINT: "ABC123", + CONF_AUTHTOKEN: "123", + CONF_NAME: "name", } # no config_entry exists - assert len(hass.config_entries.async_entries(hmipc.DOMAIN)) == 0 + assert len(hass.config_entries.async_entries(HMIPC_DOMAIN)) == 0 # no acccesspoint exists - assert not hass.data.get(hmipc.DOMAIN) + assert not hass.data.get(HMIPC_DOMAIN) assert ( - await async_setup_component(hass, hmipc.DOMAIN, {hmipc.DOMAIN: entry_config}) + await async_setup_component(hass, HMIPC_DOMAIN, {HMIPC_DOMAIN: entry_config}) is True ) # config_entry created for access point - config_entries = hass.config_entries.async_entries(hmipc.DOMAIN) + config_entries = hass.config_entries.async_entries(HMIPC_DOMAIN) assert len(config_entries) == 1 assert config_entries[0].data == { "authtoken": "123", @@ -35,21 +45,17 @@ async def test_config_with_accesspoint_passed_to_config_entry(hass): "name": "name", } # defined access_point created for config_entry - assert isinstance(hass.data[hmipc.DOMAIN]["ABC123"], hmipc.HomematicipHAP) + assert isinstance(hass.data[HMIPC_DOMAIN]["ABC123"], HomematicipHAP) async def test_config_already_registered_not_passed_to_config_entry(hass): """Test that an already registered accesspoint does not get imported.""" - mock_config = { - hmipc.HMIPC_AUTHTOKEN: "123", - hmipc.HMIPC_HAPID: "ABC123", - hmipc.HMIPC_NAME: "name", - } - MockConfigEntry(domain=hmipc.DOMAIN, data=mock_config).add_to_hass(hass) + mock_config = {HMIPC_AUTHTOKEN: "123", HMIPC_HAPID: "ABC123", HMIPC_NAME: "name"} + MockConfigEntry(domain=HMIPC_DOMAIN, data=mock_config).add_to_hass(hass) # one config_entry exists - config_entries = hass.config_entries.async_entries(hmipc.DOMAIN) + config_entries = hass.config_entries.async_entries(HMIPC_DOMAIN) assert len(config_entries) == 1 assert config_entries[0].data == { "authtoken": "123", @@ -60,17 +66,17 @@ async def test_config_already_registered_not_passed_to_config_entry(hass): assert not config_entries[0].unique_id entry_config = { - hmipc.CONF_ACCESSPOINT: "ABC123", - hmipc.CONF_AUTHTOKEN: "123", - hmipc.CONF_NAME: "name", + CONF_ACCESSPOINT: "ABC123", + CONF_AUTHTOKEN: "123", + CONF_NAME: "name", } assert ( - await async_setup_component(hass, hmipc.DOMAIN, {hmipc.DOMAIN: entry_config}) + await async_setup_component(hass, HMIPC_DOMAIN, {HMIPC_DOMAIN: entry_config}) is True ) # no new config_entry created / still one config_entry - config_entries = hass.config_entries.async_entries(hmipc.DOMAIN) + config_entries = hass.config_entries.async_entries(HMIPC_DOMAIN) assert len(config_entries) == 1 assert config_entries[0].data == { "authtoken": "123", @@ -83,14 +89,10 @@ async def test_config_already_registered_not_passed_to_config_entry(hass): async def test_unload_entry(hass): """Test being able to unload an entry.""" - mock_config = { - hmipc.HMIPC_AUTHTOKEN: "123", - hmipc.HMIPC_HAPID: "ABC123", - hmipc.HMIPC_NAME: "name", - } - MockConfigEntry(domain=hmipc.DOMAIN, data=mock_config).add_to_hass(hass) + mock_config = {HMIPC_AUTHTOKEN: "123", HMIPC_HAPID: "ABC123", HMIPC_NAME: "name"} + MockConfigEntry(domain=HMIPC_DOMAIN, data=mock_config).add_to_hass(hass) - with patch.object(hmipc, "HomematicipHAP") as mock_hap: + with patch("homeassistant.components.homematicip_cloud.HomematicipHAP") as mock_hap: instance = mock_hap.return_value instance.async_setup = CoroutineMock(return_value=True) instance.home.id = "1" @@ -99,18 +101,19 @@ async def test_unload_entry(hass): instance.home.currentAPVersion = "mock-ap-version" instance.async_reset = CoroutineMock(return_value=True) - assert await async_setup_component(hass, hmipc.DOMAIN, {}) is True + assert await async_setup_component(hass, HMIPC_DOMAIN, {}) is True assert mock_hap.return_value.mock_calls[0][0] == "async_setup" - assert hass.data[hmipc.DOMAIN]["ABC123"] - config_entries = hass.config_entries.async_entries(hmipc.DOMAIN) + assert hass.data[HMIPC_DOMAIN]["ABC123"] + config_entries = hass.config_entries.async_entries(HMIPC_DOMAIN) assert len(config_entries) == 1 - + assert config_entries[0].state == ENTRY_STATE_LOADED await hass.config_entries.async_unload(config_entries[0].entry_id) - + assert config_entries[0].state == ENTRY_STATE_NOT_LOADED + assert mock_hap.return_value.mock_calls[3][0] == "async_reset" # entry is unloaded - assert hass.data[hmipc.DOMAIN] == {} + assert hass.data[HMIPC_DOMAIN] == {} async def test_hmip_dump_hap_config_services(hass, mock_hap_with_service):