async def test_dhcp_already_exists(hass):
"""Test DHCP discovery flow that fails to connect."""
client = ClientMock()
entry = MockConfigEntry(
domain=TWINKLY_DOMAIN,
data={
CONF_HOST: "1.2.3.4",
CONF_ID: client.id,
CONF_NAME: client.id,
CONF_MODEL: TEST_MODEL,
},
unique_id=client.id,
)
entry.add_to_hass(hass)
with patch("homeassistant.components.twinkly.config_flow.Twinkly",
return_value=client):
result = await hass.config_entries.flow.async_init(
TWINKLY_DOMAIN,
context={"source": config_entries.SOURCE_DHCP},
data=dhcp.DhcpServiceInfo(
hostname="Twinkly_XYZ",
ip="1.2.3.4",
macaddress="aa:bb:cc:dd:ee:ff",
),
)
await hass.async_block_till_done()
assert result["type"] == "abort"
assert result["reason"] == "already_configured"
async def test_dhcp_success(hass):
"""Test DHCP discovery flow success."""
client = ClientMock()
with patch("homeassistant.components.twinkly.config_flow.Twinkly",
return_value=client), patch(
"homeassistant.components.twinkly.async_setup_entry",
return_value=True):
result = await hass.config_entries.flow.async_init(
TWINKLY_DOMAIN,
context={"source": config_entries.SOURCE_DHCP},
data=dhcp.DhcpServiceInfo(
hostname="Twinkly_XYZ",
ip="1.2.3.4",
macaddress="aa:bb:cc:dd:ee:ff",
),
)
await hass.async_block_till_done()
assert result["type"] == "form"
assert result["step_id"] == "discovery_confirm"
result = await hass.config_entries.flow.async_configure(
result["flow_id"], {})
assert result["type"] == "create_entry"
assert result["title"] == client.id
assert result["data"] == {
CONF_HOST: "1.2.3.4",
CONF_ID: client.id,
CONF_NAME: client.id,
CONF_MODEL: TEST_MODEL,
}
async def test_dhcp_discovery_updates_unique_id(hass):
"""Test we can update the unique id from dhcp."""
entry = MockConfigEntry(
domain=DOMAIN,
data=VALID_CONFIG,
unique_id="1.2.3.4",
)
entry.add_to_hass(hass)
mock_powerwall = await _mock_powerwall_site_name(hass, "Some site")
with patch(
"homeassistant.components.powerwall.config_flow.Powerwall",
return_value=mock_powerwall,
), patch(
"homeassistant.components.powerwall.async_setup_entry",
return_value=True,
):
result = await hass.config_entries.flow.async_init(
DOMAIN,
context={"source": config_entries.SOURCE_DHCP},
data=dhcp.DhcpServiceInfo(
ip="1.2.3.4",
macaddress="AA:BB:CC:DD:EE:FF",
hostname=MOCK_GATEWAY_DIN.lower(),
),
)
await hass.async_block_till_done()
assert result["type"] == FlowResultType.ABORT
assert result["reason"] == "already_configured"
assert entry.data[CONF_IP_ADDRESS] == "1.2.3.4"
assert entry.unique_id == MOCK_GATEWAY_DIN
async def test_dhcp_already_exists(hass):
"""Test DHCP discovery flow that fails to connect."""
entry = MockConfigEntry(
domain=DOMAIN,
data={CONF_HOST: "1.2.3.4"},
unique_id="aa:bb:cc:dd:ee:ff",
)
entry.add_to_hass(hass)
with patch(
"homeassistant.components.emonitor.config_flow.Emonitor.async_get_status",
return_value=_mock_emonitor(),
):
result = await hass.config_entries.flow.async_init(
DOMAIN,
context={"source": config_entries.SOURCE_DHCP},
data=dhcp.DhcpServiceInfo(
hostname="emonitor",
ip="1.2.3.4",
macaddress="aa:bb:cc:dd:ee:ff",
),
)
await hass.async_block_till_done()
assert result["type"] == "abort"
assert result["reason"] == "already_configured"
async def test_dhcp_flow(hass):
"""Successful flow from DHCP discovery."""
dhcp_data = dhcp.DhcpServiceInfo(
ip=TEST_HOST,
hostname="MOTION_abcdef",
macaddress=TEST_MAC,
)
result = await hass.config_entries.flow.async_init(
const.DOMAIN,
context={"source": config_entries.SOURCE_DHCP},
data=dhcp_data)
assert result["type"] == "form"
assert result["step_id"] == "connect"
assert result["errors"] == {}
with patch(
"homeassistant.components.motion_blinds.gateway.AsyncMotionMulticast.Start_listen",
side_effect=OSError,
):
result = await hass.config_entries.flow.async_configure(
result["flow_id"],
{CONF_API_KEY: TEST_API_KEY},
)
assert result["type"] == "create_entry"
assert result["title"] == DEFAULT_GATEWAY_NAME
assert result["data"] == {
CONF_HOST: TEST_HOST,
CONF_API_KEY: TEST_API_KEY,
const.CONF_INTERFACE: TEST_HOST_ANY,
}
async def test_form_user_already_configured_from_dhcp(hass):
"""Test we abort if already configured from dhcp."""
config_entry = MockConfigEntry(
domain=DOMAIN,
data={
CONF_HOST: "1.1.1.1",
CONF_PORT: 12,
CONF_SYSTEM_ID: 46
},
)
config_entry.add_to_hass(hass)
with patch(
"homeassistant.components.somfy_mylink.config_flow.SomfyMyLinkSynergy.status_info",
return_value={"any": "data"},
), patch(
"homeassistant.components.somfy_mylink.async_setup_entry",
return_value=True,
) as mock_setup_entry:
result = await hass.config_entries.flow.async_init(
DOMAIN,
context={"source": config_entries.SOURCE_DHCP},
data=dhcp.DhcpServiceInfo(
ip="1.1.1.1",
macaddress="AA:BB:CC:DD:EE:FF",
hostname="somfy_eeff",
),
)
await hass.async_block_till_done()
assert result["type"] == "abort"
assert len(mock_setup_entry.mock_calls) == 0
async def test_dhcp_flow(hass):
"""Successful flow from DHCP discovery."""
dhcp_data = dhcp.DhcpServiceInfo(
ip=TEST_HOST,
hostname="MOTION_abcdef",
macaddress=TEST_MAC,
)
result = await hass.config_entries.flow.async_init(
const.DOMAIN,
context={"source": config_entries.SOURCE_DHCP},
data=dhcp_data)
assert result["type"] == "form"
assert result["step_id"] == "connect"
assert result["errors"] == {}
result = await hass.config_entries.flow.async_configure(
result["flow_id"],
{CONF_API_KEY: TEST_API_KEY},
)
assert result["type"] == "create_entry"
assert result["title"] == DEFAULT_GATEWAY_NAME
assert result["data"] == {
CONF_HOST: TEST_HOST,
CONF_API_KEY: TEST_API_KEY,
const.CONF_INTERFACE: TEST_HOST_HA,
}
async def test_form_dhcp_with_polisy(hass: HomeAssistant):
"""Test we can setup from dhcp with polisy."""
result = await hass.config_entries.flow.async_init(
DOMAIN,
context={"source": SOURCE_DHCP},
data=dhcp.DhcpServiceInfo(
ip="1.2.3.4",
hostname="polisy",
macaddress=MOCK_POLISY_MAC,
),
)
assert result["type"] == data_entry_flow.FlowResultType.FORM
assert result["step_id"] == "user"
assert result["errors"] == {}
assert (_get_schema_default(result["data_schema"].schema,
CONF_HOST) == "http://1.2.3.4:8080")
with patch(PATCH_CONNECTION, return_value=MOCK_CONFIG_RESPONSE), patch(
PATCH_ASYNC_SETUP, return_value=True) as mock_setup, patch(
PATCH_ASYNC_SETUP_ENTRY,
return_value=True,
) as mock_setup_entry:
result2 = await hass.config_entries.flow.async_configure(
result["flow_id"],
MOCK_POLISY_USER_INPUT,
)
await hass.async_block_till_done()
assert result2["type"] == data_entry_flow.FlowResultType.CREATE_ENTRY
assert result2["title"] == f"{MOCK_DEVICE_NAME} ({MOCK_HOSTNAME})"
assert result2["result"].unique_id == MOCK_UUID
assert result2["data"] == MOCK_POLISY_USER_INPUT
assert len(mock_setup.mock_calls) == 1
assert len(mock_setup_entry.mock_calls) == 1
async def test_dhcp_discovery(hass):
"""Test we can process the discovery from dhcp."""
result = await hass.config_entries.flow.async_init(
DOMAIN,
context={"source": config_entries.SOURCE_DHCP},
data=dhcp.DhcpServiceInfo(
ip="1.1.1.1",
macaddress="AA:BB:CC:DD:EE:FF",
hostname="any",
),
)
assert result["type"] == "form"
assert result["errors"] == {}
mock_powerwall = await _mock_powerwall_site_name(hass, "Some site")
with patch(
"homeassistant.components.powerwall.config_flow.Powerwall",
return_value=mock_powerwall,
), patch(
"homeassistant.components.powerwall.async_setup_entry",
return_value=True,
) as mock_setup_entry:
result2 = await hass.config_entries.flow.async_configure(
result["flow_id"],
VALID_CONFIG,
)
await hass.async_block_till_done()
assert result2["type"] == "create_entry"
assert result2["title"] == "Some site"
assert result2["data"] == VALID_CONFIG
assert len(mock_setup_entry.mock_calls) == 1
async def test_discovery_dhcp_no_changes(hass, mock_client):
"""Test dhcp discovery updates host and aborts."""
entry = MockConfigEntry(
domain=DOMAIN,
data={
CONF_HOST: "192.168.43.183",
CONF_PORT: 6053,
CONF_PASSWORD: ""
},
)
entry.add_to_hass(hass)
mock_entry_data = MagicMock()
mock_entry_data.device_info.name = "test8266"
domain_data = DomainData.get(hass)
domain_data.set_entry_data(entry, mock_entry_data)
service_info = dhcp.DhcpServiceInfo(
ip="192.168.43.183",
hostname="test8266",
macaddress="00:00:00:00:00:00",
)
result = await hass.config_entries.flow.async_init(
"esphome",
context={"source": config_entries.SOURCE_DHCP},
data=service_info)
assert result["type"] == FlowResultType.ABORT
assert result["reason"] == "already_configured"
assert entry.unique_id == "test8266"
assert entry.data[CONF_HOST] == "192.168.43.183"
async def test_dhcp_flow_already_configured(hass):
"""Test that DHCP doesn't setup already configured devices."""
await setup_nuki_integration(hass)
result = await hass.config_entries.flow.async_init(
DOMAIN,
data=dhcp.DhcpServiceInfo(hostname=NAME, ip=HOST, macaddress=MAC),
context={"source": config_entries.SOURCE_DHCP},
)
assert result["type"] == data_entry_flow.RESULT_TYPE_ABORT
assert result["reason"] == "already_configured"
async def test_dhcp(hass: HomeAssistant) -> None:
"""Test that DHCP discovery works."""
result = await hass.config_entries.flow.async_init(
DOMAIN,
data=dhcp.DhcpServiceInfo(ip="1.2.3.4",
macaddress="01:23:45:67:89:ab",
hostname="mock_hostname"),
context={"source": config_entries.SOURCE_DHCP},
)
assert result.get("type") == FlowResultType.FORM
assert result.get("step_id") == "user"
async def test_discovered_dhcp(
ismartgateapi_mock, async_setup_entry_mock, hass
) -> None:
"""Test we get the form with homekit and abort for dhcp source when we get both."""
api: ISmartGateApi = MagicMock(spec=ISmartGateApi)
ismartgateapi_mock.return_value = api
api.reset_mock()
result = await hass.config_entries.flow.async_init(
DOMAIN,
context={"source": config_entries.SOURCE_DHCP},
data=dhcp.DhcpServiceInfo(
ip="1.2.3.4", macaddress=MOCK_MAC_ADDR, hostname="mock_hostname"
),
)
assert result["type"] == RESULT_TYPE_FORM
assert result["errors"] == {}
result2 = await hass.config_entries.flow.async_configure(
result["flow_id"],
user_input={
CONF_DEVICE: DEVICE_TYPE_ISMARTGATE,
CONF_IP_ADDRESS: "1.2.3.4",
CONF_USERNAME: "******",
CONF_PASSWORD: "******",
},
)
assert result2
assert result2["type"] == RESULT_TYPE_FORM
assert result2["errors"] == {"base": "cannot_connect"}
api.reset_mock()
closed_door_response = _mocked_ismartgate_closed_door_response()
api.async_info.return_value = closed_door_response
result3 = await hass.config_entries.flow.async_configure(
result2["flow_id"],
user_input={
CONF_DEVICE: DEVICE_TYPE_ISMARTGATE,
CONF_IP_ADDRESS: "1.2.3.4",
CONF_USERNAME: "******",
CONF_PASSWORD: "******",
},
)
assert result3
assert result3["type"] == RESULT_TYPE_CREATE_ENTRY
assert result3["data"] == {
"device": "ismartgate",
"ip_address": "1.2.3.4",
"password": "******",
"username": "******",
}
