async def test_discovery_via_usb_deconz_already_discovered(detect_mock, hass): """Test usb flow -- deconz discovered.""" result = await hass.config_entries.flow.async_init( "deconz", data=ssdp.SsdpServiceInfo( ssdp_usn="mock_usn", ssdp_st="mock_st", ssdp_location="http://1.2.3.4:80/", upnp={ ATTR_UPNP_MANUFACTURER_URL: "http://www.dresden-elektronik.de", ATTR_UPNP_SERIAL: "0000000000000000", }, ), context={"source": SOURCE_SSDP}, ) await hass.async_block_till_done() discovery_info = usb.UsbServiceInfo( device="/dev/ttyZIGBEE", pid="AAAA", vid="AAAA", serial_number="1234", description="zigbee radio", manufacturer="test", ) result = await hass.config_entries.flow.async_init( "zha", context={"source": SOURCE_USB}, data=discovery_info ) await hass.async_block_till_done() assert result["type"] == "abort" assert result["reason"] == "not_zha_device"
async def test_discovery_via_usb_zha_ignored_updates(detect_mock, hass): """Test usb flow that was ignored gets updated.""" entry = MockConfigEntry( domain=DOMAIN, source=config_entries.SOURCE_IGNORE, data={}, unique_id="AAAA:AAAA_1234_test_zigbee radio", ) entry.add_to_hass(hass) await hass.async_block_till_done() discovery_info = usb.UsbServiceInfo( device="/dev/ttyZIGBEE", pid="AAAA", vid="AAAA", serial_number="1234", description="zigbee radio", manufacturer="test", ) result = await hass.config_entries.flow.async_init( "zha", context={"source": SOURCE_USB}, data=discovery_info ) await hass.async_block_till_done() assert result["type"] == RESULT_TYPE_ABORT assert result["reason"] == "already_configured" assert entry.data[CONF_DEVICE] == { CONF_DEVICE_PATH: "/dev/ttyZIGBEE", }
async def test_discovery_via_usb(detect_mock, hass): """Test usb flow -- radio detected.""" discovery_info = usb.UsbServiceInfo( device="/dev/ttyZIGBEE", pid="AAAA", vid="AAAA", serial_number="1234", description="zigbee radio", manufacturer="test", ) result = await hass.config_entries.flow.async_init( "zha", context={"source": SOURCE_USB}, data=discovery_info ) await hass.async_block_till_done() assert result["type"] == RESULT_TYPE_FORM assert result["step_id"] == "confirm" with patch("homeassistant.components.zha.async_setup_entry"): result2 = await hass.config_entries.flow.async_configure( result["flow_id"], user_input={} ) await hass.async_block_till_done() assert result2["type"] == RESULT_TYPE_CREATE_ENTRY assert "zigbee radio" in result2["title"] assert result2["data"] == { "device": { "baudrate": 115200, "flow_control": None, "path": "/dev/ttyZIGBEE", }, CONF_RADIO_TYPE: "znp", }
async def test_discovery_via_usb_no_radio(detect_mock, hass): """Test usb flow -- no radio detected.""" discovery_info = usb.UsbServiceInfo( device="/dev/null", pid="AAAA", vid="AAAA", serial_number="1234", description="zigbee radio", manufacturer="test", ) result = await hass.config_entries.flow.async_init( "zha", context={"source": SOURCE_USB}, data=discovery_info ) await hass.async_block_till_done() assert result["type"] == RESULT_TYPE_FORM assert result["step_id"] == "confirm" with patch("homeassistant.components.zha.async_setup_entry"): result2 = await hass.config_entries.flow.async_configure( result["flow_id"], user_input={} ) await hass.async_block_till_done() assert result2["type"] == RESULT_TYPE_ABORT assert result2["reason"] == "usb_probe_failed"
async def test_discovery_via_usb_already_setup(hass): """Test usb flow -- already setup.""" MockConfigEntry(domain=DOMAIN, data={ CONF_DEVICE: { CONF_DEVICE: "/dev/ttyUSB1" } }).add_to_hass(hass) discovery_info = usb.UsbServiceInfo( device="/dev/ttyINSTEON", pid="AAAA", vid="AAAA", serial_number="1234", description="insteon radio", manufacturer="test", ) result = await hass.config_entries.flow.async_init( "insteon", context={"source": config_entries.SOURCE_USB}, data=discovery_info) await hass.async_block_till_done() assert result["type"] == data_entry_flow.RESULT_TYPE_ABORT assert result["reason"] == "single_instance_allowed"
async def test_discovery_via_usb_path_changes(hass): """Test usb flow already setup and the path changes.""" entry = MockConfigEntry( domain=DOMAIN, unique_id="AAAA:AAAA_1234_test_zigbee radio", data={ CONF_DEVICE: { CONF_DEVICE_PATH: "/dev/ttyUSB1", CONF_BAUDRATE: 115200, CONF_FLOWCONTROL: None, } }, ) entry.add_to_hass(hass) discovery_info = usb.UsbServiceInfo( device="/dev/ttyZIGBEE", pid="AAAA", vid="AAAA", serial_number="1234", description="zigbee radio", manufacturer="test", ) result = await hass.config_entries.flow.async_init( "zha", context={"source": SOURCE_USB}, data=discovery_info) await hass.async_block_till_done() assert result["type"] == RESULT_TYPE_ABORT assert result["reason"] == "already_configured" assert entry.data[CONF_DEVICE] == { CONF_DEVICE_PATH: "/dev/ttyZIGBEE", CONF_BAUDRATE: 115200, CONF_FLOWCONTROL: None, }
async def test_discovery_via_usb(hass): """Test usb flow.""" discovery_info = usb.UsbServiceInfo( device="/dev/ttyINSTEON", pid="AAAA", vid="AAAA", serial_number="1234", description="insteon radio", manufacturer="test", ) result = await hass.config_entries.flow.async_init( "insteon", context={"source": config_entries.SOURCE_USB}, data=discovery_info) await hass.async_block_till_done() assert result["type"] == data_entry_flow.RESULT_TYPE_FORM assert result["step_id"] == "confirm_usb" with patch("homeassistant.components.insteon.config_flow.async_connect" ), patch("homeassistant.components.insteon.async_setup_entry", return_value=True): result2 = await hass.config_entries.flow.async_configure( result["flow_id"], user_input={}) await hass.async_block_till_done() assert result2["type"] == data_entry_flow.RESULT_TYPE_CREATE_ENTRY assert result2["data"] == {"device": "/dev/ttyINSTEON"}
async def test_discovery_via_usb_deconz_already_setup(detect_mock, hass): """Test usb flow -- deconz setup.""" MockConfigEntry(domain="deconz", data={}).add_to_hass(hass) await hass.async_block_till_done() discovery_info = usb.UsbServiceInfo( device="/dev/ttyZIGBEE", pid="AAAA", vid="AAAA", serial_number="1234", description="zigbee radio", manufacturer="test", ) result = await hass.config_entries.flow.async_init( "zha", context={"source": SOURCE_USB}, data=discovery_info) await hass.async_block_till_done() assert result["type"] == "abort" assert result["reason"] == "not_zha_device"
async def test_service_info_compatibility(hass, caplog): """Test compatibility with old-style dict. To be removed in 2022.6 """ discovery_info = usb.UsbServiceInfo( device=slae_sh_device.device, vid=12345, pid=12345, serial_number=slae_sh_device.serial_number, manufacturer=slae_sh_device.manufacturer, description=slae_sh_device.description, ) # Ensure first call get logged with patch("homeassistant.helpers.frame._REPORTED_INTEGRATIONS", set()): assert discovery_info["vid"] == 12345 assert "Detected integration that accessed discovery_info['vid']" in caplog.text
async def test_discovery_via_usb_deconz_ignored(detect_mock, hass): """Test usb flow -- deconz ignored.""" MockConfigEntry(domain="deconz", source=config_entries.SOURCE_IGNORE, data={}).add_to_hass(hass) await hass.async_block_till_done() discovery_info = usb.UsbServiceInfo( device="/dev/ttyZIGBEE", pid="AAAA", vid="AAAA", serial_number="1234", description="zigbee radio", manufacturer="test", ) result = await hass.config_entries.flow.async_init( "zha", context={"source": SOURCE_USB}, data=discovery_info) await hass.async_block_till_done() assert result["type"] == RESULT_TYPE_FORM assert result["step_id"] == "confirm"
async def test_service_info_compatibility(hass, caplog): """Test compatibility with old-style dict. To be removed in 2022.6 """ discovery_info = usb.UsbServiceInfo( device=slae_sh_device.device, vid=12345, pid=12345, serial_number=slae_sh_device.serial_number, manufacturer=slae_sh_device.manufacturer, description=slae_sh_device.description, ) # Ensure first call get logged assert discovery_info["vid"] == 12345 assert "Detected code that accessed discovery_info['vid']" in caplog.text # Ensure second call doesn't get logged caplog.clear() assert discovery_info["vid"] == 12345 assert "Detected code that accessed discovery_info['vid']" not in caplog.text
async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool: """Set up a Home Assistant Sky Connect config entry.""" usb_info = usb.UsbServiceInfo( device=entry.data["device"], vid=entry.data["vid"], pid=entry.data["pid"], serial_number=entry.data["serial_number"], manufacturer=entry.data["manufacturer"], description=entry.data["description"], ) if not usb.async_is_plugged_in(hass, cast(usb.USBCallbackMatcher, entry.data)): # The USB dongle is not plugged in raise ConfigEntryNotReady await hass.config_entries.flow.async_init( "zha", context={"source": "usb"}, data=usb_info, ) return True
from homeassistant import data_entry_flow from homeassistant.components import usb from homeassistant.components.velbus import config_flow from homeassistant.components.velbus.const import DOMAIN from homeassistant.config_entries import SOURCE_USB from homeassistant.const import CONF_NAME, CONF_PORT, CONF_SOURCE from homeassistant.core import HomeAssistant from .const import PORT_SERIAL, PORT_TCP from tests.common import MockConfigEntry DISCOVERY_INFO = usb.UsbServiceInfo( device=PORT_SERIAL, pid="10CF", vid="0B1B", serial_number="1234", description="Velbus VMB1USB", manufacturer="Velleman", ) def com_port(): """Mock of a serial port.""" port = serial.tools.list_ports_common.ListPortInfo(PORT_SERIAL) port.serial_number = "1234" port.manufacturer = "Virtual serial port" port.device = PORT_SERIAL port.description = "Some serial port" return port
import phone_modem from homeassistant import data_entry_flow from homeassistant.components import usb from homeassistant.components.modem_callerid.const import DOMAIN from homeassistant.config_entries import SOURCE_USB, SOURCE_USER from homeassistant.const import CONF_DEVICE, CONF_SOURCE from homeassistant.core import HomeAssistant from . import com_port, patch_config_flow_modem DISCOVERY_INFO = usb.UsbServiceInfo( device=phone_modem.DEFAULT_PORT, pid="1340", vid="0572", serial_number="1234", description="modem", manufacturer="Connexant", ) def _patch_setup(): return patch("homeassistant.components.modem_callerid.async_setup_entry", ) @patch("serial.tools.list_ports.comports", MagicMock(return_value=[com_port()])) async def test_flow_usb(hass: HomeAssistant): """Test usb discovery flow.""" with patch_config_flow_modem(), _patch_setup(): result = await hass.config_entries.flow.async_init(
"""Test the Home Assistant Sky Connect config flow.""" import copy from unittest.mock import patch from homeassistant.components import homeassistant_sky_connect, usb from homeassistant.components.homeassistant_sky_connect.const import DOMAIN from homeassistant.core import HomeAssistant from homeassistant.data_entry_flow import FlowResultType from tests.common import MockConfigEntry USB_DATA = usb.UsbServiceInfo( device="bla_device", vid="bla_vid", pid="bla_pid", serial_number="bla_serial_number", manufacturer="bla_manufacturer", description="bla_description", ) async def test_config_flow(hass: HomeAssistant) -> None: """Test the config flow.""" with patch( "homeassistant.components.homeassistant_sky_connect.async_setup_entry", return_value=True, ) as mock_setup_entry: result = await hass.config_entries.flow.async_init( DOMAIN, context={"source": "usb"}, data=USB_DATA) expected_data = {