From d2eda91588cd529b67d071aa08cd278a299adebc Mon Sep 17 00:00:00 2001 From: Aaron Bach Date: Sun, 23 Jan 2022 13:17:07 -0700 Subject: [PATCH] Clean up RainMachine tests (#64785) * Clean up RainMachine tests * Remove old stuff --- tests/components/rainmachine/conftest.py | 59 +++++ .../rainmachine/test_config_flow.py | 202 ++++-------------- 2 files changed, 103 insertions(+), 158 deletions(-) create mode 100644 tests/components/rainmachine/conftest.py diff --git a/tests/components/rainmachine/conftest.py b/tests/components/rainmachine/conftest.py new file mode 100644 index 00000000000..486cd385b4d --- /dev/null +++ b/tests/components/rainmachine/conftest.py @@ -0,0 +1,59 @@ +"""Define test fixtures for RainMachine.""" +from unittest.mock import AsyncMock, patch + +import pytest + +from homeassistant.components.rainmachine import DOMAIN +from homeassistant.const import CONF_IP_ADDRESS, CONF_PASSWORD, CONF_PORT, CONF_SSL +from homeassistant.setup import async_setup_component + +from tests.common import MockConfigEntry + + +@pytest.fixture(name="client") +def client_fixture(controller_mac): + """Define a regenmaschine client.""" + controller = AsyncMock() + controller.name = "My RainMachine" + controller.mac = controller_mac + return AsyncMock(load_local=AsyncMock(), controllers={controller_mac: controller}) + + +@pytest.fixture(name="config") +def config_fixture(hass): + """Define a config entry data fixture.""" + return { + CONF_IP_ADDRESS: "192.168.1.100", + CONF_PASSWORD: "password", + CONF_PORT: 8080, + CONF_SSL: True, + } + + +@pytest.fixture(name="config_entry") +def config_entry_fixture(hass, config, controller_mac): + """Define a config entry fixture.""" + entry = MockConfigEntry(domain=DOMAIN, unique_id=controller_mac, data=config) + entry.add_to_hass(hass) + return entry + + +@pytest.fixture(name="controller_mac") +def controller_mac_fixture(): + """Define a controller MAC address.""" + return "aa:bb:cc:dd:ee:ff" + + +@pytest.fixture(name="setup_rainmachine") +async def setup_rainmachine_fixture(hass, client, config): + """Define a fixture to set up RainMachine.""" + with patch( + "homeassistant.components.rainmachine.Client", return_value=client + ), patch( + "homeassistant.components.rainmachine.config_flow.Client", return_value=client + ), patch( + "homeassistant.components.rainmachine.PLATFORMS", [] + ): + assert await async_setup_component(hass, DOMAIN, config) + await hass.async_block_till_done() + yield diff --git a/tests/components/rainmachine/test_config_flow.py b/tests/components/rainmachine/test_config_flow.py index 35824296cc6..883e21891fc 100644 --- a/tests/components/rainmachine/test_config_flow.py +++ b/tests/components/rainmachine/test_config_flow.py @@ -1,5 +1,5 @@ """Define tests for the OpenUV config flow.""" -from unittest.mock import AsyncMock, Mock, patch +from unittest.mock import patch import pytest from regenmaschine.errors import RainMachineError @@ -10,64 +10,22 @@ from homeassistant.components.rainmachine import CONF_ZONE_RUN_TIME, DOMAIN from homeassistant.const import CONF_IP_ADDRESS, CONF_PASSWORD, CONF_PORT, CONF_SSL from homeassistant.helpers import entity_registry as er -from tests.common import MockConfigEntry - -def _get_mock_client(): - mock_controller = Mock() - mock_controller.name = "My Rain Machine" - mock_controller.mac = "aa:bb:cc:dd:ee:ff" - return Mock( - load_local=AsyncMock(), controllers={"aa:bb:cc:dd:ee:ff": mock_controller} - ) - - -async def test_duplicate_error(hass): +async def test_duplicate_error(hass, config, config_entry, setup_rainmachine): """Test that errors are shown when duplicates are added.""" - conf = { - CONF_IP_ADDRESS: "192.168.1.100", - CONF_PASSWORD: "password", - CONF_PORT: 8080, - CONF_SSL: True, - } - - MockConfigEntry( - domain=DOMAIN, unique_id="aa:bb:cc:dd:ee:ff", data=conf - ).add_to_hass(hass) - - with patch( - "homeassistant.components.rainmachine.config_flow.Client", - return_value=_get_mock_client(), - ): - result = await hass.config_entries.flow.async_init( - DOMAIN, - context={"source": config_entries.SOURCE_USER}, - data=conf, - ) + result = await hass.config_entries.flow.async_init( + DOMAIN, context={"source": config_entries.SOURCE_USER}, data=config + ) assert result["type"] == data_entry_flow.RESULT_TYPE_ABORT assert result["reason"] == "already_configured" -async def test_invalid_password(hass): +async def test_invalid_password(hass, config): """Test that an invalid password throws an error.""" - conf = { - CONF_IP_ADDRESS: "192.168.1.100", - CONF_PASSWORD: "bad_password", - CONF_PORT: 8080, - CONF_SSL: True, - } - - with patch( - "regenmaschine.client.Client.load_local", - side_effect=RainMachineError, - ): + with patch("regenmaschine.client.Client.load_local", side_effect=RainMachineError): result = await hass.config_entries.flow.async_init( - DOMAIN, - context={"source": config_entries.SOURCE_USER}, - data=conf, + DOMAIN, context={"source": config_entries.SOURCE_USER}, data=config ) - await hass.async_block_till_done() - assert result["errors"] == {CONF_PASSWORD: "invalid_auth"} @@ -91,19 +49,17 @@ async def test_invalid_password(hass): ], ) async def test_migrate_1_2( - hass, platform, entity_name, entity_id, old_unique_id, new_unique_id + hass, + client, + config, + config_entry, + entity_id, + entity_name, + old_unique_id, + new_unique_id, + platform, ): """Test migration from version 1 to 2 (consistent unique IDs).""" - conf = { - CONF_IP_ADDRESS: "192.168.1.100", - CONF_PASSWORD: "password", - CONF_PORT: 8080, - CONF_SSL: True, - } - - entry = MockConfigEntry(domain=DOMAIN, unique_id="aa:bb:cc:dd:ee:ff", data=conf) - entry.add_to_hass(hass) - ent_reg = er.async_get(hass) # Create entity RegistryEntry using old unique ID format: @@ -112,7 +68,7 @@ async def test_migrate_1_2( DOMAIN, old_unique_id, suggested_object_id=entity_name, - config_entry=entry, + config_entry=config_entry, original_name=entity_name, ) assert entity_entry.entity_id == entity_id @@ -121,8 +77,7 @@ async def test_migrate_1_2( with patch( "homeassistant.components.rainmachine.async_setup_entry", return_value=True ), patch( - "homeassistant.components.rainmachine.config_flow.Client", - return_value=_get_mock_client(), + "homeassistant.components.rainmachine.config_flow.Client", return_value=client ): await setup.async_setup_component(hass, DOMAIN, {}) await hass.async_block_till_done() @@ -133,36 +88,19 @@ async def test_migrate_1_2( assert ent_reg.async_get_entity_id(platform, DOMAIN, old_unique_id) is None -async def test_options_flow(hass): +async def test_options_flow(hass, config, config_entry): """Test config flow options.""" - conf = { - CONF_IP_ADDRESS: "192.168.1.100", - CONF_PASSWORD: "password", - CONF_PORT: 8080, - CONF_SSL: True, - } - - config_entry = MockConfigEntry( - domain=DOMAIN, - unique_id="abcde12345", - data=conf, - options={CONF_ZONE_RUN_TIME: 900}, - ) - config_entry.add_to_hass(hass) - with patch( "homeassistant.components.rainmachine.async_setup_entry", return_value=True ): await hass.config_entries.async_setup(config_entry.entry_id) result = await hass.config_entries.options.async_init(config_entry.entry_id) - assert result["type"] == data_entry_flow.RESULT_TYPE_FORM assert result["step_id"] == "init" result = await hass.config_entries.options.async_configure( result["flow_id"], user_input={CONF_ZONE_RUN_TIME: 600} ) - assert result["type"] == data_entry_flow.RESULT_TYPE_CREATE_ENTRY assert config_entry.options == {CONF_ZONE_RUN_TIME: 600} @@ -174,34 +112,19 @@ async def test_show_form(hass): context={"source": config_entries.SOURCE_USER}, data=None, ) - assert result["type"] == data_entry_flow.RESULT_TYPE_FORM assert result["step_id"] == "user" -async def test_step_user(hass): +async def test_step_user(hass, config, setup_rainmachine): """Test that the user step works.""" - conf = { - CONF_IP_ADDRESS: "192.168.1.100", - CONF_PASSWORD: "password", - CONF_PORT: 8080, - CONF_SSL: True, - } - - with patch( - "homeassistant.components.rainmachine.async_setup_entry", return_value=True - ) as mock_setup_entry, patch( - "homeassistant.components.rainmachine.config_flow.Client", - return_value=_get_mock_client(), - ): - result = await hass.config_entries.flow.async_init( - DOMAIN, - context={"source": config_entries.SOURCE_USER}, - data=conf, - ) - + result = await hass.config_entries.flow.async_init( + DOMAIN, + context={"source": config_entries.SOURCE_USER}, + data=config, + ) assert result["type"] == data_entry_flow.RESULT_TYPE_CREATE_ENTRY - assert result["title"] == "My Rain Machine" + assert result["title"] == "My RainMachine" assert result["data"] == { CONF_IP_ADDRESS: "192.168.1.100", CONF_PASSWORD: "password", @@ -209,28 +132,17 @@ async def test_step_user(hass): CONF_SSL: True, CONF_ZONE_RUN_TIME: 600, } - assert mock_setup_entry.called @pytest.mark.parametrize( "source", [config_entries.SOURCE_ZEROCONF, config_entries.SOURCE_HOMEKIT] ) -async def test_step_homekit_zeroconf_ip_already_exists(hass, source): +async def test_step_homekit_zeroconf_ip_already_exists( + hass, client, config, config_entry, source +): """Test homekit and zeroconf with an ip that already exists.""" - conf = { - CONF_IP_ADDRESS: "192.168.1.100", - CONF_PASSWORD: "password", - CONF_PORT: 8080, - CONF_SSL: True, - } - - MockConfigEntry( - domain=DOMAIN, unique_id="aa:bb:cc:dd:ee:ff", data=conf - ).add_to_hass(hass) - with patch( - "homeassistant.components.rainmachine.config_flow.Client", - return_value=_get_mock_client(), + "homeassistant.components.rainmachine.config_flow.Client", return_value=client ): result = await hass.config_entries.flow.async_init( DOMAIN, @@ -252,21 +164,10 @@ async def test_step_homekit_zeroconf_ip_already_exists(hass, source): @pytest.mark.parametrize( "source", [config_entries.SOURCE_ZEROCONF, config_entries.SOURCE_HOMEKIT] ) -async def test_step_homekit_zeroconf_ip_change(hass, source): +async def test_step_homekit_zeroconf_ip_change(hass, client, config_entry, source): """Test zeroconf with an ip change.""" - conf = { - CONF_IP_ADDRESS: "192.168.1.100", - CONF_PASSWORD: "password", - CONF_PORT: 8080, - CONF_SSL: True, - } - - entry = MockConfigEntry(domain=DOMAIN, unique_id="aa:bb:cc:dd:ee:ff", data=conf) - entry.add_to_hass(hass) - with patch( - "homeassistant.components.rainmachine.config_flow.Client", - return_value=_get_mock_client(), + "homeassistant.components.rainmachine.config_flow.Client", return_value=client ): result = await hass.config_entries.flow.async_init( DOMAIN, @@ -283,28 +184,18 @@ async def test_step_homekit_zeroconf_ip_change(hass, source): assert result["type"] == data_entry_flow.RESULT_TYPE_ABORT assert result["reason"] == "already_configured" - assert entry.data[CONF_IP_ADDRESS] == "192.168.1.2" + assert config_entry.data[CONF_IP_ADDRESS] == "192.168.1.2" @pytest.mark.parametrize( "source", [config_entries.SOURCE_ZEROCONF, config_entries.SOURCE_HOMEKIT] ) -async def test_step_homekit_zeroconf_new_controller_when_some_exist(hass, source): +async def test_step_homekit_zeroconf_new_controller_when_some_exist( + hass, client, config, source +): """Test homekit and zeroconf for a new controller when one already exists.""" - existing_conf = { - CONF_IP_ADDRESS: "192.168.1.3", - CONF_PASSWORD: "password", - CONF_PORT: 8080, - CONF_SSL: True, - } - entry = MockConfigEntry( - domain=DOMAIN, unique_id="zz:bb:cc:dd:ee:ff", data=existing_conf - ) - entry.add_to_hass(hass) - with patch( - "homeassistant.components.rainmachine.config_flow.Client", - return_value=_get_mock_client(), + "homeassistant.components.rainmachine.config_flow.Client", return_value=client ): result = await hass.config_entries.flow.async_init( DOMAIN, @@ -324,9 +215,8 @@ async def test_step_homekit_zeroconf_new_controller_when_some_exist(hass, source with patch( "homeassistant.components.rainmachine.async_setup_entry", return_value=True - ) as mock_setup_entry, patch( - "homeassistant.components.rainmachine.config_flow.Client", - return_value=_get_mock_client(), + ), patch( + "homeassistant.components.rainmachine.config_flow.Client", return_value=client ): result2 = await hass.config_entries.flow.async_configure( result["flow_id"], @@ -339,7 +229,7 @@ async def test_step_homekit_zeroconf_new_controller_when_some_exist(hass, source await hass.async_block_till_done() assert result2["type"] == data_entry_flow.RESULT_TYPE_CREATE_ENTRY - assert result2["title"] == "My Rain Machine" + assert result2["title"] == "My RainMachine" assert result2["data"] == { CONF_IP_ADDRESS: "192.168.1.100", CONF_PASSWORD: "password", @@ -347,15 +237,12 @@ async def test_step_homekit_zeroconf_new_controller_when_some_exist(hass, source CONF_SSL: True, CONF_ZONE_RUN_TIME: 600, } - assert mock_setup_entry.called -async def test_discovery_by_homekit_and_zeroconf_same_time(hass): +async def test_discovery_by_homekit_and_zeroconf_same_time(hass, client): """Test the same controller gets discovered by two different methods.""" - with patch( - "homeassistant.components.rainmachine.config_flow.Client", - return_value=_get_mock_client(), + "homeassistant.components.rainmachine.config_flow.Client", return_value=client ): result = await hass.config_entries.flow.async_init( DOMAIN, @@ -374,8 +261,7 @@ async def test_discovery_by_homekit_and_zeroconf_same_time(hass): assert result["step_id"] == "user" with patch( - "homeassistant.components.rainmachine.config_flow.Client", - return_value=_get_mock_client(), + "homeassistant.components.rainmachine.config_flow.Client", return_value=client ): result2 = await hass.config_entries.flow.async_init( DOMAIN,