diff --git a/tests/components/alarm_control_panel/test_device_action.py b/tests/components/alarm_control_panel/test_device_action.py index b02fac96633..01235a99184 100644 --- a/tests/components/alarm_control_panel/test_device_action.py +++ b/tests/components/alarm_control_panel/test_device_action.py @@ -14,7 +14,7 @@ from homeassistant.const import ( STATE_ALARM_TRIGGERED, STATE_UNKNOWN, ) -from homeassistant.helpers import device_registry +from homeassistant.helpers import device_registry as dr from homeassistant.helpers.entity import EntityCategory from homeassistant.helpers.entity_registry import RegistryEntryHider from homeassistant.setup import async_setup_component @@ -24,24 +24,10 @@ from tests.common import ( assert_lists_same, async_get_device_automation_capabilities, async_get_device_automations, - mock_device_registry, - mock_registry, ) from tests.components.blueprint.conftest import stub_blueprint_populate # noqa: F401 -@pytest.fixture -def device_reg(hass): - """Return an empty, loaded, registry.""" - return mock_device_registry(hass) - - -@pytest.fixture -def entity_reg(hass): - """Return an empty, loaded, registry.""" - return mock_registry(hass) - - @pytest.mark.parametrize( "set_state,features_reg,features_state,expected_action_types", [ @@ -95,8 +81,8 @@ def entity_reg(hass): ) async def test_get_actions( hass, - device_reg, - entity_reg, + device_registry, + entity_registry, set_state, features_reg, features_state, @@ -105,11 +91,11 @@ async def test_get_actions( """Test we get the expected actions from a alarm_control_panel.""" config_entry = MockConfigEntry(domain="test", data={}) config_entry.add_to_hass(hass) - device_entry = device_reg.async_get_or_create( + device_entry = device_registry.async_get_or_create( config_entry_id=config_entry.entry_id, - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, ) - entity_reg.async_get_or_create( + entity_registry.async_get_or_create( DOMAIN, "test", "5678", @@ -148,19 +134,19 @@ async def test_get_actions( ) async def test_get_actions_hidden_auxiliary( hass, - device_reg, - entity_reg, + device_registry, + entity_registry, hidden_by, entity_category, ): """Test we get the expected actions from a hidden or auxiliary entity.""" config_entry = MockConfigEntry(domain="test", data={}) config_entry.add_to_hass(hass) - device_entry = device_reg.async_get_or_create( + device_entry = device_registry.async_get_or_create( config_entry_id=config_entry.entry_id, - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, ) - entity_reg.async_get_or_create( + entity_registry.async_get_or_create( DOMAIN, "test", "5678", @@ -186,15 +172,17 @@ async def test_get_actions_hidden_auxiliary( assert_lists_same(actions, expected_actions) -async def test_get_actions_arm_night_only(hass, device_reg, entity_reg): +async def test_get_actions_arm_night_only(hass, device_registry, entity_registry): """Test we get the expected actions from a alarm_control_panel.""" config_entry = MockConfigEntry(domain="test", data={}) config_entry.add_to_hass(hass) - device_entry = device_reg.async_get_or_create( + device_entry = device_registry.async_get_or_create( config_entry_id=config_entry.entry_id, - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + ) + entity_registry.async_get_or_create( + DOMAIN, "test", "5678", device_id=device_entry.id ) - entity_reg.async_get_or_create(DOMAIN, "test", "5678", device_id=device_entry.id) hass.states.async_set( "alarm_control_panel.test_5678", "attributes", {"supported_features": 4} ) @@ -221,7 +209,7 @@ async def test_get_actions_arm_night_only(hass, device_reg, entity_reg): async def test_get_action_capabilities( - hass, device_reg, entity_reg, enable_custom_integrations + hass, device_registry, entity_registry, enable_custom_integrations ): """Test we get the expected capabilities from a sensor trigger.""" platform = getattr(hass.components, f"test.{DOMAIN}") @@ -231,11 +219,11 @@ async def test_get_action_capabilities( config_entry = MockConfigEntry(domain="test", data={}) config_entry.add_to_hass(hass) - device_entry = device_reg.async_get_or_create( + device_entry = device_registry.async_get_or_create( config_entry_id=config_entry.entry_id, - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, ) - entity_reg.async_get_or_create( + entity_registry.async_get_or_create( DOMAIN, "test", platform.ENTITIES["no_arm_code"].unique_id, @@ -265,7 +253,7 @@ async def test_get_action_capabilities( async def test_get_action_capabilities_arm_code( - hass, device_reg, entity_reg, enable_custom_integrations + hass, device_registry, entity_registry, enable_custom_integrations ): """Test we get the expected capabilities from a sensor trigger.""" platform = getattr(hass.components, f"test.{DOMAIN}") @@ -275,11 +263,11 @@ async def test_get_action_capabilities_arm_code( config_entry = MockConfigEntry(domain="test", data={}) config_entry.add_to_hass(hass) - device_entry = device_reg.async_get_or_create( + device_entry = device_registry.async_get_or_create( config_entry_id=config_entry.entry_id, - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, ) - entity_reg.async_get_or_create( + entity_registry.async_get_or_create( DOMAIN, "test", platform.ENTITIES["arm_code"].unique_id, diff --git a/tests/components/alarm_control_panel/test_device_condition.py b/tests/components/alarm_control_panel/test_device_condition.py index 9c0f6077854..d9450e2c015 100644 --- a/tests/components/alarm_control_panel/test_device_condition.py +++ b/tests/components/alarm_control_panel/test_device_condition.py @@ -13,7 +13,7 @@ from homeassistant.const import ( STATE_ALARM_DISARMED, STATE_ALARM_TRIGGERED, ) -from homeassistant.helpers import device_registry +from homeassistant.helpers import device_registry as dr from homeassistant.helpers.entity import EntityCategory from homeassistant.helpers.entity_registry import RegistryEntryHider from homeassistant.setup import async_setup_component @@ -23,24 +23,10 @@ from tests.common import ( assert_lists_same, async_get_device_automations, async_mock_service, - mock_device_registry, - mock_registry, ) from tests.components.blueprint.conftest import stub_blueprint_populate # noqa: F401 -@pytest.fixture -def device_reg(hass): - """Return an empty, loaded, registry.""" - return mock_device_registry(hass) - - -@pytest.fixture -def entity_reg(hass): - """Return an empty, loaded, registry.""" - return mock_registry(hass) - - @pytest.fixture def calls(hass): """Track calls to a mock service.""" @@ -86,8 +72,8 @@ def calls(hass): ) async def test_get_conditions( hass, - device_reg, - entity_reg, + device_registry, + entity_registry, set_state, features_reg, features_state, @@ -96,11 +82,11 @@ async def test_get_conditions( """Test we get the expected conditions from a alarm_control_panel.""" config_entry = MockConfigEntry(domain="test", data={}) config_entry.add_to_hass(hass) - device_entry = device_reg.async_get_or_create( + device_entry = device_registry.async_get_or_create( config_entry_id=config_entry.entry_id, - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, ) - entity_reg.async_get_or_create( + entity_registry.async_get_or_create( DOMAIN, "test", "5678", @@ -154,19 +140,19 @@ async def test_get_conditions( ) async def test_get_conditions_hidden_auxiliary( hass, - device_reg, - entity_reg, + device_registry, + entity_registry, hidden_by, entity_category, ): """Test we get the expected conditions from a hidden or auxiliary entity.""" config_entry = MockConfigEntry(domain="test", data={}) config_entry.add_to_hass(hass) - device_entry = device_reg.async_get_or_create( + device_entry = device_registry.async_get_or_create( config_entry_id=config_entry.entry_id, - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, ) - entity_reg.async_get_or_create( + entity_registry.async_get_or_create( DOMAIN, "test", "5678", diff --git a/tests/components/alarm_control_panel/test_device_trigger.py b/tests/components/alarm_control_panel/test_device_trigger.py index a76c75e814d..4535b8231b0 100644 --- a/tests/components/alarm_control_panel/test_device_trigger.py +++ b/tests/components/alarm_control_panel/test_device_trigger.py @@ -15,7 +15,7 @@ from homeassistant.const import ( STATE_ALARM_PENDING, STATE_ALARM_TRIGGERED, ) -from homeassistant.helpers import device_registry +from homeassistant.helpers import device_registry as dr from homeassistant.helpers.entity import EntityCategory from homeassistant.helpers.entity_registry import RegistryEntryHider from homeassistant.setup import async_setup_component @@ -28,24 +28,10 @@ from tests.common import ( async_get_device_automation_capabilities, async_get_device_automations, async_mock_service, - mock_device_registry, - mock_registry, ) from tests.components.blueprint.conftest import stub_blueprint_populate # noqa: F401 -@pytest.fixture -def device_reg(hass): - """Return an empty, loaded, registry.""" - return mock_device_registry(hass) - - -@pytest.fixture -def entity_reg(hass): - """Return an empty, loaded, registry.""" - return mock_registry(hass) - - @pytest.fixture def calls(hass): """Track calls to a mock service.""" @@ -89,8 +75,8 @@ def calls(hass): ) async def test_get_triggers( hass, - device_reg, - entity_reg, + device_registry, + entity_registry, set_state, features_reg, features_state, @@ -99,11 +85,11 @@ async def test_get_triggers( """Test we get the expected triggers from an alarm_control_panel.""" config_entry = MockConfigEntry(domain="test", data={}) config_entry.add_to_hass(hass) - device_entry = device_reg.async_get_or_create( + device_entry = device_registry.async_get_or_create( config_entry_id=config_entry.entry_id, - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, ) - entity_reg.async_get_or_create( + entity_registry.async_get_or_create( DOMAIN, "test", "5678", @@ -146,19 +132,19 @@ async def test_get_triggers( ) async def test_get_triggers_hidden_auxiliary( hass, - device_reg, - entity_reg, + device_registry, + entity_registry, hidden_by, entity_category, ): """Test we get the expected triggers from a hidden or auxiliary entity.""" config_entry = MockConfigEntry(domain="test", data={}) config_entry.add_to_hass(hass) - device_entry = device_reg.async_get_or_create( + device_entry = device_registry.async_get_or_create( config_entry_id=config_entry.entry_id, - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, ) - entity_reg.async_get_or_create( + entity_registry.async_get_or_create( DOMAIN, "test", "5678", @@ -183,15 +169,17 @@ async def test_get_triggers_hidden_auxiliary( assert_lists_same(triggers, expected_triggers) -async def test_get_trigger_capabilities(hass, device_reg, entity_reg): +async def test_get_trigger_capabilities(hass, device_registry, entity_registry): """Test we get the expected capabilities from an alarm_control_panel.""" config_entry = MockConfigEntry(domain="test", data={}) config_entry.add_to_hass(hass) - device_entry = device_reg.async_get_or_create( + device_entry = device_registry.async_get_or_create( config_entry_id=config_entry.entry_id, - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + ) + entity_registry.async_get_or_create( + DOMAIN, "test", "5678", device_id=device_entry.id ) - entity_reg.async_get_or_create(DOMAIN, "test", "5678", device_id=device_entry.id) hass.states.async_set( "alarm_control_panel.test_5678", "attributes", {"supported_features": 15} ) diff --git a/tests/components/binary_sensor/test_device_condition.py b/tests/components/binary_sensor/test_device_condition.py index 2ef6fad7817..1c6af94452f 100644 --- a/tests/components/binary_sensor/test_device_condition.py +++ b/tests/components/binary_sensor/test_device_condition.py @@ -9,7 +9,7 @@ from homeassistant.components.binary_sensor import DOMAIN, BinarySensorDeviceCla from homeassistant.components.binary_sensor.device_condition import ENTITY_CONDITIONS from homeassistant.components.device_automation import DeviceAutomationType from homeassistant.const import CONF_PLATFORM, STATE_OFF, STATE_ON -from homeassistant.helpers import device_registry +from homeassistant.helpers import device_registry as dr from homeassistant.helpers.entity import EntityCategory from homeassistant.helpers.entity_registry import RegistryEntryHider from homeassistant.setup import async_setup_component @@ -21,31 +21,19 @@ from tests.common import ( async_get_device_automation_capabilities, async_get_device_automations, async_mock_service, - mock_device_registry, - mock_registry, ) from tests.components.blueprint.conftest import stub_blueprint_populate # noqa: F401 -@pytest.fixture -def device_reg(hass): - """Return an empty, loaded, registry.""" - return mock_device_registry(hass) - - -@pytest.fixture -def entity_reg(hass): - """Return an empty, loaded, registry.""" - return mock_registry(hass) - - @pytest.fixture def calls(hass): """Track calls to a mock service.""" return async_mock_service(hass, "test", "automation") -async def test_get_conditions(hass, device_reg, entity_reg, enable_custom_integrations): +async def test_get_conditions( + hass, device_registry, entity_registry, enable_custom_integrations +): """Test we get the expected conditions from a binary_sensor.""" platform = getattr(hass.components, f"test.{DOMAIN}") platform.init() @@ -54,12 +42,12 @@ async def test_get_conditions(hass, device_reg, entity_reg, enable_custom_integr config_entry = MockConfigEntry(domain="test", data={}) config_entry.add_to_hass(hass) - device_entry = device_reg.async_get_or_create( + device_entry = device_registry.async_get_or_create( config_entry_id=config_entry.entry_id, - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, ) for device_class in BinarySensorDeviceClass: - entity_reg.async_get_or_create( + entity_registry.async_get_or_create( DOMAIN, "test", platform.ENTITIES[device_class].unique_id, @@ -95,19 +83,19 @@ async def test_get_conditions(hass, device_reg, entity_reg, enable_custom_integr ) async def test_get_conditions_hidden_auxiliary( hass, - device_reg, - entity_reg, + device_registry, + entity_registry, hidden_by, entity_category, ): """Test we get the expected conditions from a hidden or auxiliary entity.""" config_entry = MockConfigEntry(domain="test", data={}) config_entry.add_to_hass(hass) - device_entry = device_reg.async_get_or_create( + device_entry = device_registry.async_get_or_create( config_entry_id=config_entry.entry_id, - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, ) - entity_reg.async_get_or_create( + entity_registry.async_get_or_create( DOMAIN, "test", "5678", @@ -132,17 +120,17 @@ async def test_get_conditions_hidden_auxiliary( assert_lists_same(conditions, expected_conditions) -async def test_get_conditions_no_state(hass, device_reg, entity_reg): +async def test_get_conditions_no_state(hass, device_registry, entity_registry): """Test we get the expected conditions from a binary_sensor.""" config_entry = MockConfigEntry(domain="test", data={}) config_entry.add_to_hass(hass) - device_entry = device_reg.async_get_or_create( + device_entry = device_registry.async_get_or_create( config_entry_id=config_entry.entry_id, - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, ) entity_ids = {} for device_class in BinarySensorDeviceClass: - entity_ids[device_class] = entity_reg.async_get_or_create( + entity_ids[device_class] = entity_registry.async_get_or_create( DOMAIN, "test", f"5678_{device_class}", @@ -170,15 +158,17 @@ async def test_get_conditions_no_state(hass, device_reg, entity_reg): assert conditions == expected_conditions -async def test_get_condition_capabilities(hass, device_reg, entity_reg): +async def test_get_condition_capabilities(hass, device_registry, entity_registry): """Test we get the expected capabilities from a binary_sensor condition.""" config_entry = MockConfigEntry(domain="test", data={}) config_entry.add_to_hass(hass) - device_entry = device_reg.async_get_or_create( + device_entry = device_registry.async_get_or_create( config_entry_id=config_entry.entry_id, - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + ) + entity_registry.async_get_or_create( + DOMAIN, "test", "5678", device_id=device_entry.id ) - entity_reg.async_get_or_create(DOMAIN, "test", "5678", device_id=device_entry.id) expected_capabilities = { "extra_fields": [ {"name": "for", "optional": True, "type": "positive_time_period_dict"} diff --git a/tests/components/binary_sensor/test_device_trigger.py b/tests/components/binary_sensor/test_device_trigger.py index 549318090a4..d65c933d529 100644 --- a/tests/components/binary_sensor/test_device_trigger.py +++ b/tests/components/binary_sensor/test_device_trigger.py @@ -8,7 +8,7 @@ from homeassistant.components.binary_sensor import DOMAIN, BinarySensorDeviceCla from homeassistant.components.binary_sensor.device_trigger import ENTITY_TRIGGERS from homeassistant.components.device_automation import DeviceAutomationType from homeassistant.const import CONF_PLATFORM, STATE_OFF, STATE_ON -from homeassistant.helpers import device_registry +from homeassistant.helpers import device_registry as dr from homeassistant.helpers.entity import EntityCategory from homeassistant.helpers.entity_registry import RegistryEntryHider from homeassistant.setup import async_setup_component @@ -21,31 +21,19 @@ from tests.common import ( async_get_device_automation_capabilities, async_get_device_automations, async_mock_service, - mock_device_registry, - mock_registry, ) from tests.components.blueprint.conftest import stub_blueprint_populate # noqa: F401 -@pytest.fixture -def device_reg(hass): - """Return an empty, loaded, registry.""" - return mock_device_registry(hass) - - -@pytest.fixture -def entity_reg(hass): - """Return an empty, loaded, registry.""" - return mock_registry(hass) - - @pytest.fixture def calls(hass): """Track calls to a mock service.""" return async_mock_service(hass, "test", "automation") -async def test_get_triggers(hass, device_reg, entity_reg, enable_custom_integrations): +async def test_get_triggers( + hass, device_registry, entity_registry, enable_custom_integrations +): """Test we get the expected triggers from a binary_sensor.""" platform = getattr(hass.components, f"test.{DOMAIN}") platform.init() @@ -54,12 +42,12 @@ async def test_get_triggers(hass, device_reg, entity_reg, enable_custom_integrat config_entry = MockConfigEntry(domain="test", data={}) config_entry.add_to_hass(hass) - device_entry = device_reg.async_get_or_create( + device_entry = device_registry.async_get_or_create( config_entry_id=config_entry.entry_id, - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, ) for device_class in BinarySensorDeviceClass: - entity_reg.async_get_or_create( + entity_registry.async_get_or_create( DOMAIN, "test", platform.ENTITIES[device_class].unique_id, @@ -95,19 +83,19 @@ async def test_get_triggers(hass, device_reg, entity_reg, enable_custom_integrat ) async def test_get_triggers_hidden_auxiliary( hass, - device_reg, - entity_reg, + device_registry, + entity_registry, hidden_by, entity_category, ): """Test we get the expected triggers from a hidden or auxiliary entity.""" config_entry = MockConfigEntry(domain="test", data={}) config_entry.add_to_hass(hass) - device_entry = device_reg.async_get_or_create( + device_entry = device_registry.async_get_or_create( config_entry_id=config_entry.entry_id, - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, ) - entity_reg.async_get_or_create( + entity_registry.async_get_or_create( DOMAIN, "test", "5678", @@ -132,7 +120,7 @@ async def test_get_triggers_hidden_auxiliary( assert_lists_same(triggers, expected_triggers) -async def test_get_triggers_no_state(hass, device_reg, entity_reg): +async def test_get_triggers_no_state(hass, device_registry, entity_registry): """Test we get the expected triggers from a binary_sensor.""" platform = getattr(hass.components, f"test.{DOMAIN}") platform.init() @@ -140,12 +128,12 @@ async def test_get_triggers_no_state(hass, device_reg, entity_reg): config_entry = MockConfigEntry(domain="test", data={}) config_entry.add_to_hass(hass) - device_entry = device_reg.async_get_or_create( + device_entry = device_registry.async_get_or_create( config_entry_id=config_entry.entry_id, - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, ) for device_class in BinarySensorDeviceClass: - entity_ids[device_class] = entity_reg.async_get_or_create( + entity_ids[device_class] = entity_registry.async_get_or_create( DOMAIN, "test", f"5678_{device_class}", @@ -173,15 +161,17 @@ async def test_get_triggers_no_state(hass, device_reg, entity_reg): assert_lists_same(triggers, expected_triggers) -async def test_get_trigger_capabilities(hass, device_reg, entity_reg): +async def test_get_trigger_capabilities(hass, device_registry, entity_registry): """Test we get the expected capabilities from a binary_sensor trigger.""" config_entry = MockConfigEntry(domain="test", data={}) config_entry.add_to_hass(hass) - device_entry = device_reg.async_get_or_create( + device_entry = device_registry.async_get_or_create( config_entry_id=config_entry.entry_id, - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + ) + entity_registry.async_get_or_create( + DOMAIN, "test", "5678", device_id=device_entry.id ) - entity_reg.async_get_or_create(DOMAIN, "test", "5678", device_id=device_entry.id) expected_capabilities = { "extra_fields": [ {"name": "for", "optional": True, "type": "positive_time_period_dict"} diff --git a/tests/components/button/test_device_action.py b/tests/components/button/test_device_action.py index c5d9fe967b5..474b19b870b 100644 --- a/tests/components/button/test_device_action.py +++ b/tests/components/button/test_device_action.py @@ -5,7 +5,7 @@ from homeassistant.components import automation from homeassistant.components.button import DOMAIN from homeassistant.components.device_automation import DeviceAutomationType from homeassistant.core import HomeAssistant -from homeassistant.helpers import device_registry, entity_registry +from homeassistant.helpers import device_registry as dr, entity_registry as er from homeassistant.helpers.entity import EntityCategory from homeassistant.setup import async_setup_component @@ -14,36 +14,24 @@ from tests.common import ( assert_lists_same, async_get_device_automations, async_mock_service, - mock_device_registry, - mock_registry, ) -@pytest.fixture -def device_reg(hass: HomeAssistant) -> device_registry.DeviceRegistry: - """Return an empty, loaded, registry.""" - return mock_device_registry(hass) - - -@pytest.fixture -def entity_reg(hass: HomeAssistant) -> entity_registry.EntityRegistry: - """Return an empty, loaded, registry.""" - return mock_registry(hass) - - async def test_get_actions( hass: HomeAssistant, - device_reg: device_registry.DeviceRegistry, - entity_reg: entity_registry.EntityRegistry, + device_registry: dr.DeviceRegistry, + entity_registry: er.EntityRegistry, ) -> None: """Test we get the expected actions from a button.""" config_entry = MockConfigEntry(domain="test", data={}) config_entry.add_to_hass(hass) - device_entry = device_reg.async_get_or_create( + device_entry = device_registry.async_get_or_create( config_entry_id=config_entry.entry_id, - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + ) + entity_registry.async_get_or_create( + DOMAIN, "test", "5678", device_id=device_entry.id ) - entity_reg.async_get_or_create(DOMAIN, "test", "5678", device_id=device_entry.id) expected_actions = [ { "domain": DOMAIN, @@ -62,27 +50,27 @@ async def test_get_actions( @pytest.mark.parametrize( "hidden_by,entity_category", ( - (entity_registry.RegistryEntryHider.INTEGRATION, None), - (entity_registry.RegistryEntryHider.USER, None), + (er.RegistryEntryHider.INTEGRATION, None), + (er.RegistryEntryHider.USER, None), (None, EntityCategory.CONFIG), (None, EntityCategory.DIAGNOSTIC), ), ) async def test_get_actions_hidden_auxiliary( - hass, - device_reg, - entity_reg, - hidden_by, - entity_category, + hass: HomeAssistant, + device_registry: dr.DeviceRegistry, + entity_registry: er.EntityRegistry, + hidden_by: er.RegistryEntryHider | None, + entity_category: EntityCategory | None, ): """Test we get the expected actions from a hidden or auxiliary entity.""" config_entry = MockConfigEntry(domain="test", data={}) config_entry.add_to_hass(hass) - device_entry = device_reg.async_get_or_create( + device_entry = device_registry.async_get_or_create( config_entry_id=config_entry.entry_id, - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, ) - entity_reg.async_get_or_create( + entity_registry.async_get_or_create( DOMAIN, "test", "5678", diff --git a/tests/components/button/test_device_trigger.py b/tests/components/button/test_device_trigger.py index d67cfd648c8..c8503aa0326 100644 --- a/tests/components/button/test_device_trigger.py +++ b/tests/components/button/test_device_trigger.py @@ -7,9 +7,8 @@ from homeassistant.components import automation from homeassistant.components.button import DOMAIN from homeassistant.components.device_automation import DeviceAutomationType from homeassistant.core import HomeAssistant, ServiceCall -from homeassistant.helpers import device_registry +from homeassistant.helpers import device_registry as dr, entity_registry as er from homeassistant.helpers.entity import EntityCategory -from homeassistant.helpers.entity_registry import EntityRegistry, RegistryEntryHider from homeassistant.setup import async_setup_component from tests.common import ( @@ -17,23 +16,9 @@ from tests.common import ( assert_lists_same, async_get_device_automations, async_mock_service, - mock_device_registry, - mock_registry, ) -@pytest.fixture -def device_reg(hass: HomeAssistant) -> device_registry.DeviceRegistry: - """Return an empty, loaded, registry.""" - return mock_device_registry(hass) - - -@pytest.fixture -def entity_reg(hass: HomeAssistant) -> EntityRegistry: - """Return an empty, loaded, registry.""" - return mock_registry(hass) - - @pytest.fixture def calls(hass: HomeAssistant) -> list[ServiceCall]: """Track calls to a mock service.""" @@ -42,17 +27,19 @@ def calls(hass: HomeAssistant) -> list[ServiceCall]: async def test_get_triggers( hass: HomeAssistant, - device_reg: device_registry.DeviceRegistry, - entity_reg: EntityRegistry, + device_registry: dr.DeviceRegistry, + entity_registry: er.EntityRegistry, ) -> None: """Test we get the expected triggers from a button.""" config_entry = MockConfigEntry(domain="test", data={}) config_entry.add_to_hass(hass) - device_entry = device_reg.async_get_or_create( + device_entry = device_registry.async_get_or_create( config_entry_id=config_entry.entry_id, - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + ) + entity_registry.async_get_or_create( + DOMAIN, "test", "5678", device_id=device_entry.id ) - entity_reg.async_get_or_create(DOMAIN, "test", "5678", device_id=device_entry.id) expected_triggers = [ { "platform": "device", @@ -72,27 +59,27 @@ async def test_get_triggers( @pytest.mark.parametrize( "hidden_by,entity_category", ( - (RegistryEntryHider.INTEGRATION, None), - (RegistryEntryHider.USER, None), + (er.RegistryEntryHider.INTEGRATION, None), + (er.RegistryEntryHider.USER, None), (None, EntityCategory.CONFIG), (None, EntityCategory.DIAGNOSTIC), ), ) async def test_get_triggers_hidden_auxiliary( hass, - device_reg, - entity_reg, - hidden_by, - entity_category, + device_registry: dr.DeviceRegistry, + entity_registry: er.EntityRegistry, + hidden_by: er.RegistryEntryHider | None, + entity_category: EntityCategory | None, ): """Test we get the expected triggers from a hidden or auxiliary entity.""" config_entry = MockConfigEntry(domain="test", data={}) config_entry.add_to_hass(hass) - device_entry = device_reg.async_get_or_create( + device_entry = device_registry.async_get_or_create( config_entry_id=config_entry.entry_id, - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, ) - entity_reg.async_get_or_create( + entity_registry.async_get_or_create( DOMAIN, "test", "5678", diff --git a/tests/components/climate/test_device_action.py b/tests/components/climate/test_device_action.py index 1a0b079309d..7583d9d53d2 100644 --- a/tests/components/climate/test_device_action.py +++ b/tests/components/climate/test_device_action.py @@ -6,7 +6,7 @@ import homeassistant.components.automation as automation from homeassistant.components.climate import DOMAIN, HVACMode, const, device_action from homeassistant.components.device_automation import DeviceAutomationType from homeassistant.core import HomeAssistant -from homeassistant.helpers import config_validation as cv, device_registry +from homeassistant.helpers import config_validation as cv, device_registry as dr from homeassistant.helpers.entity import EntityCategory from homeassistant.helpers.entity_registry import RegistryEntryHider from homeassistant.setup import async_setup_component @@ -16,24 +16,10 @@ from tests.common import ( assert_lists_same, async_get_device_automations, async_mock_service, - mock_device_registry, - mock_registry, ) from tests.components.blueprint.conftest import stub_blueprint_populate # noqa: F401 -@pytest.fixture -def device_reg(hass): - """Return an empty, loaded, registry.""" - return mock_device_registry(hass) - - -@pytest.fixture -def entity_reg(hass): - """Return an empty, loaded, registry.""" - return mock_registry(hass) - - @pytest.mark.parametrize( "set_state,features_reg,features_state,expected_action_types", [ @@ -55,8 +41,8 @@ def entity_reg(hass): ) async def test_get_actions( hass, - device_reg, - entity_reg, + device_registry, + entity_registry, set_state, features_reg, features_state, @@ -65,11 +51,11 @@ async def test_get_actions( """Test we get the expected actions from a climate.""" config_entry = MockConfigEntry(domain="test", data={}) config_entry.add_to_hass(hass) - device_entry = device_reg.async_get_or_create( + device_entry = device_registry.async_get_or_create( config_entry_id=config_entry.entry_id, - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, ) - entity_reg.async_get_or_create( + entity_registry.async_get_or_create( DOMAIN, "test", "5678", @@ -111,19 +97,19 @@ async def test_get_actions( ) async def test_get_actions_hidden_auxiliary( hass, - device_reg, - entity_reg, + device_registry, + entity_registry, hidden_by, entity_category, ): """Test we get the expected actions from a hidden or auxiliary entity.""" config_entry = MockConfigEntry(domain="test", data={}) config_entry.add_to_hass(hass) - device_entry = device_reg.async_get_or_create( + device_entry = device_registry.async_get_or_create( config_entry_id=config_entry.entry_id, - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, ) - entity_reg.async_get_or_create( + entity_registry.async_get_or_create( DOMAIN, "test", "5678", @@ -272,8 +258,8 @@ async def test_action(hass: HomeAssistant) -> None: ) async def test_capabilities( hass, - device_reg, - entity_reg, + device_registry, + entity_registry, set_state, capabilities_reg, capabilities_state, @@ -283,11 +269,11 @@ async def test_capabilities( """Test getting capabilities.""" config_entry = MockConfigEntry(domain="test", data={}) config_entry.add_to_hass(hass) - device_entry = device_reg.async_get_or_create( + device_entry = device_registry.async_get_or_create( config_entry_id=config_entry.entry_id, - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, ) - entity_reg.async_get_or_create( + entity_registry.async_get_or_create( DOMAIN, "test", "5678", @@ -325,9 +311,7 @@ async def test_capabilities( "action,capability_name", [("set_hvac_mode", "hvac_mode"), ("set_preset_mode", "preset_mode")], ) -async def test_capabilities_missing_entity( - hass, device_reg, entity_reg, action, capability_name -): +async def test_capabilities_missing_entity(hass, action, capability_name): """Test getting capabilities.""" config_entry = MockConfigEntry(domain="test", data={}) config_entry.add_to_hass(hass) diff --git a/tests/components/climate/test_device_condition.py b/tests/components/climate/test_device_condition.py index 2b21b7c4185..9836ef6aee4 100644 --- a/tests/components/climate/test_device_condition.py +++ b/tests/components/climate/test_device_condition.py @@ -5,7 +5,7 @@ import voluptuous_serialize import homeassistant.components.automation as automation from homeassistant.components.climate import DOMAIN, HVACMode, const, device_condition from homeassistant.components.device_automation import DeviceAutomationType -from homeassistant.helpers import config_validation as cv, device_registry +from homeassistant.helpers import config_validation as cv, device_registry as dr from homeassistant.helpers.entity import EntityCategory from homeassistant.helpers.entity_registry import RegistryEntryHider from homeassistant.setup import async_setup_component @@ -15,24 +15,10 @@ from tests.common import ( assert_lists_same, async_get_device_automations, async_mock_service, - mock_device_registry, - mock_registry, ) from tests.components.blueprint.conftest import stub_blueprint_populate # noqa: F401 -@pytest.fixture -def device_reg(hass): - """Return an empty, loaded, registry.""" - return mock_device_registry(hass) - - -@pytest.fixture -def entity_reg(hass): - """Return an empty, loaded, registry.""" - return mock_registry(hass) - - @pytest.fixture def calls(hass): """Track calls to a mock service.""" @@ -60,8 +46,8 @@ def calls(hass): ) async def test_get_conditions( hass, - device_reg, - entity_reg, + device_registry, + entity_registry, set_state, features_reg, features_state, @@ -70,11 +56,11 @@ async def test_get_conditions( """Test we get the expected conditions from a climate.""" config_entry = MockConfigEntry(domain="test", data={}) config_entry.add_to_hass(hass) - device_entry = device_reg.async_get_or_create( + device_entry = device_registry.async_get_or_create( config_entry_id=config_entry.entry_id, - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, ) - entity_reg.async_get_or_create( + entity_registry.async_get_or_create( DOMAIN, "test", "5678", @@ -114,19 +100,19 @@ async def test_get_conditions( ) async def test_get_conditions_hidden_auxiliary( hass, - device_reg, - entity_reg, + device_registry, + entity_registry, hidden_by, entity_category, ): """Test we get the expected conditions from a hidden or auxiliary entity.""" config_entry = MockConfigEntry(domain="test", data={}) config_entry.add_to_hass(hass) - device_entry = device_reg.async_get_or_create( + device_entry = device_registry.async_get_or_create( config_entry_id=config_entry.entry_id, - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, ) - entity_reg.async_get_or_create( + entity_registry.async_get_or_create( DOMAIN, "test", "5678", @@ -320,8 +306,8 @@ async def test_if_state(hass, calls): ) async def test_capabilities( hass, - device_reg, - entity_reg, + device_registry, + entity_registry, set_state, capabilities_reg, capabilities_state, @@ -331,11 +317,11 @@ async def test_capabilities( """Test getting capabilities.""" config_entry = MockConfigEntry(domain="test", data={}) config_entry.add_to_hass(hass) - device_entry = device_reg.async_get_or_create( + device_entry = device_registry.async_get_or_create( config_entry_id=config_entry.entry_id, - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, ) - entity_reg.async_get_or_create( + entity_registry.async_get_or_create( DOMAIN, "test", "5678", @@ -374,9 +360,7 @@ async def test_capabilities( "condition,capability_name", [("is_hvac_mode", "hvac_mode"), ("is_preset_mode", "preset_mode")], ) -async def test_capabilities_missing_entity( - hass, device_reg, entity_reg, condition, capability_name -): +async def test_capabilities_missing_entity(hass, condition, capability_name): """Test getting capabilities.""" config_entry = MockConfigEntry(domain="test", data={}) config_entry.add_to_hass(hass) diff --git a/tests/components/climate/test_device_trigger.py b/tests/components/climate/test_device_trigger.py index 23841886673..e61e9222cbf 100644 --- a/tests/components/climate/test_device_trigger.py +++ b/tests/components/climate/test_device_trigger.py @@ -13,7 +13,7 @@ from homeassistant.components.climate import ( from homeassistant.components.device_automation import DeviceAutomationType from homeassistant.const import UnitOfTemperature from homeassistant.core import HomeAssistant -from homeassistant.helpers import config_validation as cv, device_registry +from homeassistant.helpers import config_validation as cv, device_registry as dr from homeassistant.helpers.entity import EntityCategory from homeassistant.helpers.entity_registry import RegistryEntryHider from homeassistant.setup import async_setup_component @@ -23,39 +23,27 @@ from tests.common import ( assert_lists_same, async_get_device_automations, async_mock_service, - mock_device_registry, - mock_registry, ) from tests.components.blueprint.conftest import stub_blueprint_populate # noqa: F401 -@pytest.fixture -def device_reg(hass): - """Return an empty, loaded, registry.""" - return mock_device_registry(hass) - - -@pytest.fixture -def entity_reg(hass): - """Return an empty, loaded, registry.""" - return mock_registry(hass) - - @pytest.fixture def calls(hass): """Track calls to a mock service.""" return async_mock_service(hass, "test", "automation") -async def test_get_triggers(hass, device_reg, entity_reg): +async def test_get_triggers(hass, device_registry, entity_registry): """Test we get the expected triggers from a climate device.""" config_entry = MockConfigEntry(domain="test", data={}) config_entry.add_to_hass(hass) - device_entry = device_reg.async_get_or_create( + device_entry = device_registry.async_get_or_create( config_entry_id=config_entry.entry_id, - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + ) + entity_registry.async_get_or_create( + DOMAIN, "test", "5678", device_id=device_entry.id ) - entity_reg.async_get_or_create(DOMAIN, "test", "5678", device_id=device_entry.id) entity_id = f"{DOMAIN}.test_5678" hass.states.async_set( entity_id, @@ -98,19 +86,19 @@ async def test_get_triggers(hass, device_reg, entity_reg): ) async def test_get_triggers_hidden_auxiliary( hass, - device_reg, - entity_reg, + device_registry, + entity_registry, hidden_by, entity_category, ): """Test we get the expected triggers from a hidden or auxiliary entity.""" config_entry = MockConfigEntry(domain="test", data={}) config_entry.add_to_hass(hass) - device_entry = device_reg.async_get_or_create( + device_entry = device_registry.async_get_or_create( config_entry_id=config_entry.entry_id, - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, ) - entity_reg.async_get_or_create( + entity_registry.async_get_or_create( DOMAIN, "test", "5678", diff --git a/tests/components/cover/test_device_action.py b/tests/components/cover/test_device_action.py index bdf10f7f9a2..cd603931f84 100644 --- a/tests/components/cover/test_device_action.py +++ b/tests/components/cover/test_device_action.py @@ -5,7 +5,7 @@ import homeassistant.components.automation as automation from homeassistant.components.cover import DOMAIN, CoverEntityFeature from homeassistant.components.device_automation import DeviceAutomationType from homeassistant.const import CONF_PLATFORM -from homeassistant.helpers import device_registry +from homeassistant.helpers import device_registry as dr from homeassistant.helpers.entity import EntityCategory from homeassistant.helpers.entity_registry import RegistryEntryHider from homeassistant.setup import async_setup_component @@ -16,24 +16,10 @@ from tests.common import ( async_get_device_automation_capabilities, async_get_device_automations, async_mock_service, - mock_device_registry, - mock_registry, ) from tests.components.blueprint.conftest import stub_blueprint_populate # noqa: F401 -@pytest.fixture -def device_reg(hass): - """Return an empty, loaded, registry.""" - return mock_device_registry(hass) - - -@pytest.fixture -def entity_reg(hass): - """Return an empty, loaded, registry.""" - return mock_registry(hass) - - @pytest.mark.parametrize( "set_state,features_reg,features_state,expected_action_types", [ @@ -57,8 +43,8 @@ def entity_reg(hass): ) async def test_get_actions( hass, - device_reg, - entity_reg, + device_registry, + entity_registry, set_state, features_reg, features_state, @@ -67,11 +53,11 @@ async def test_get_actions( """Test we get the expected actions from a cover.""" config_entry = MockConfigEntry(domain="test", data={}) config_entry.add_to_hass(hass) - device_entry = device_reg.async_get_or_create( + device_entry = device_registry.async_get_or_create( config_entry_id=config_entry.entry_id, - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, ) - entity_reg.async_get_or_create( + entity_registry.async_get_or_create( DOMAIN, "test", "5678", @@ -112,19 +98,19 @@ async def test_get_actions( ) async def test_get_actions_hidden_auxiliary( hass, - device_reg, - entity_reg, + device_registry, + entity_registry, hidden_by, entity_category, ): """Test we get the expected actions from a hidden or auxiliary entity.""" config_entry = MockConfigEntry(domain="test", data={}) config_entry.add_to_hass(hass) - device_entry = device_reg.async_get_or_create( + device_entry = device_registry.async_get_or_create( config_entry_id=config_entry.entry_id, - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, ) - entity_reg.async_get_or_create( + entity_registry.async_get_or_create( DOMAIN, "test", "5678", @@ -151,7 +137,7 @@ async def test_get_actions_hidden_auxiliary( async def test_get_action_capabilities( - hass, device_reg, entity_reg, enable_custom_integrations + hass, device_registry, entity_registry, enable_custom_integrations ): """Test we get the expected capabilities from a cover action.""" platform = getattr(hass.components, f"test.{DOMAIN}") @@ -176,11 +162,11 @@ async def test_get_action_capabilities( config_entry = MockConfigEntry(domain="test", data={}) config_entry.add_to_hass(hass) - device_entry = device_reg.async_get_or_create( + device_entry = device_registry.async_get_or_create( config_entry_id=config_entry.entry_id, - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, ) - entity_reg.async_get_or_create( + entity_registry.async_get_or_create( DOMAIN, "test", ent.unique_id, device_id=device_entry.id ) @@ -198,7 +184,7 @@ async def test_get_action_capabilities( async def test_get_action_capabilities_set_pos( - hass, device_reg, entity_reg, enable_custom_integrations + hass, device_registry, entity_registry, enable_custom_integrations ): """Test we get the expected capabilities from a cover action.""" platform = getattr(hass.components, f"test.{DOMAIN}") @@ -209,11 +195,11 @@ async def test_get_action_capabilities_set_pos( config_entry = MockConfigEntry(domain="test", data={}) config_entry.add_to_hass(hass) - device_entry = device_reg.async_get_or_create( + device_entry = device_registry.async_get_or_create( config_entry_id=config_entry.entry_id, - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, ) - entity_reg.async_get_or_create( + entity_registry.async_get_or_create( DOMAIN, "test", ent.unique_id, device_id=device_entry.id ) @@ -246,7 +232,7 @@ async def test_get_action_capabilities_set_pos( async def test_get_action_capabilities_set_tilt_pos( - hass, device_reg, entity_reg, enable_custom_integrations + hass, device_registry, entity_registry, enable_custom_integrations ): """Test we get the expected capabilities from a cover action.""" platform = getattr(hass.components, f"test.{DOMAIN}") @@ -257,11 +243,11 @@ async def test_get_action_capabilities_set_tilt_pos( config_entry = MockConfigEntry(domain="test", data={}) config_entry.add_to_hass(hass) - device_entry = device_reg.async_get_or_create( + device_entry = device_registry.async_get_or_create( config_entry_id=config_entry.entry_id, - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, ) - entity_reg.async_get_or_create( + entity_registry.async_get_or_create( DOMAIN, "test", ent.unique_id, device_id=device_entry.id ) diff --git a/tests/components/cover/test_device_condition.py b/tests/components/cover/test_device_condition.py index 5c289fc6321..50068a43e58 100644 --- a/tests/components/cover/test_device_condition.py +++ b/tests/components/cover/test_device_condition.py @@ -12,7 +12,7 @@ from homeassistant.const import ( STATE_OPENING, STATE_UNAVAILABLE, ) -from homeassistant.helpers import device_registry +from homeassistant.helpers import device_registry as dr from homeassistant.helpers.entity import EntityCategory from homeassistant.helpers.entity_registry import RegistryEntryHider from homeassistant.setup import async_setup_component @@ -23,24 +23,10 @@ from tests.common import ( async_get_device_automation_capabilities, async_get_device_automations, async_mock_service, - mock_device_registry, - mock_registry, ) from tests.components.blueprint.conftest import stub_blueprint_populate # noqa: F401 -@pytest.fixture -def device_reg(hass): - """Return an empty, loaded, registry.""" - return mock_device_registry(hass) - - -@pytest.fixture -def entity_reg(hass): - """Return an empty, loaded, registry.""" - return mock_registry(hass) - - @pytest.fixture def calls(hass): """Track calls to a mock service.""" @@ -84,8 +70,8 @@ def calls(hass): ) async def test_get_conditions( hass, - device_reg, - entity_reg, + device_registry, + entity_registry, set_state, features_reg, features_state, @@ -94,11 +80,11 @@ async def test_get_conditions( """Test we get the expected conditions from a cover.""" config_entry = MockConfigEntry(domain="test", data={}) config_entry.add_to_hass(hass) - device_entry = device_reg.async_get_or_create( + device_entry = device_registry.async_get_or_create( config_entry_id=config_entry.entry_id, - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, ) - entity_reg.async_get_or_create( + entity_registry.async_get_or_create( DOMAIN, "test", "5678", @@ -140,19 +126,19 @@ async def test_get_conditions( ) async def test_get_conditions_hidden_auxiliary( hass, - device_reg, - entity_reg, + device_registry, + entity_registry, hidden_by, entity_category, ): """Test we get the expected conditions from a hidden or auxiliary entity.""" config_entry = MockConfigEntry(domain="test", data={}) config_entry.add_to_hass(hass) - device_entry = device_reg.async_get_or_create( + device_entry = device_registry.async_get_or_create( config_entry_id=config_entry.entry_id, - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, ) - entity_reg.async_get_or_create( + entity_registry.async_get_or_create( DOMAIN, "test", "5678", @@ -179,7 +165,7 @@ async def test_get_conditions_hidden_auxiliary( async def test_get_condition_capabilities( - hass, device_reg, entity_reg, enable_custom_integrations + hass, device_registry, entity_registry, enable_custom_integrations ): """Test we get the expected capabilities from a cover condition.""" platform = getattr(hass.components, f"test.{DOMAIN}") @@ -190,11 +176,11 @@ async def test_get_condition_capabilities( config_entry = MockConfigEntry(domain="test", data={}) config_entry.add_to_hass(hass) - device_entry = device_reg.async_get_or_create( + device_entry = device_registry.async_get_or_create( config_entry_id=config_entry.entry_id, - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, ) - entity_reg.async_get_or_create( + entity_registry.async_get_or_create( DOMAIN, "test", ent.unique_id, device_id=device_entry.id ) @@ -210,7 +196,7 @@ async def test_get_condition_capabilities( async def test_get_condition_capabilities_set_pos( - hass, device_reg, entity_reg, enable_custom_integrations + hass, device_registry, entity_registry, enable_custom_integrations ): """Test we get the expected capabilities from a cover condition.""" platform = getattr(hass.components, f"test.{DOMAIN}") @@ -221,11 +207,11 @@ async def test_get_condition_capabilities_set_pos( config_entry = MockConfigEntry(domain="test", data={}) config_entry.add_to_hass(hass) - device_entry = device_reg.async_get_or_create( + device_entry = device_registry.async_get_or_create( config_entry_id=config_entry.entry_id, - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, ) - entity_reg.async_get_or_create( + entity_registry.async_get_or_create( DOMAIN, "test", ent.unique_id, device_id=device_entry.id ) @@ -264,7 +250,7 @@ async def test_get_condition_capabilities_set_pos( async def test_get_condition_capabilities_set_tilt_pos( - hass, device_reg, entity_reg, enable_custom_integrations + hass, device_registry, entity_registry, enable_custom_integrations ): """Test we get the expected capabilities from a cover condition.""" platform = getattr(hass.components, f"test.{DOMAIN}") @@ -275,11 +261,11 @@ async def test_get_condition_capabilities_set_tilt_pos( config_entry = MockConfigEntry(domain="test", data={}) config_entry.add_to_hass(hass) - device_entry = device_reg.async_get_or_create( + device_entry = device_registry.async_get_or_create( config_entry_id=config_entry.entry_id, - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, ) - entity_reg.async_get_or_create( + entity_registry.async_get_or_create( DOMAIN, "test", ent.unique_id, device_id=device_entry.id ) diff --git a/tests/components/cover/test_device_trigger.py b/tests/components/cover/test_device_trigger.py index a8be2f681a0..1ac8fb3eb14 100644 --- a/tests/components/cover/test_device_trigger.py +++ b/tests/components/cover/test_device_trigger.py @@ -13,7 +13,7 @@ from homeassistant.const import ( STATE_OPEN, STATE_OPENING, ) -from homeassistant.helpers import device_registry +from homeassistant.helpers import device_registry as dr from homeassistant.helpers.entity import EntityCategory from homeassistant.helpers.entity_registry import RegistryEntryHider from homeassistant.setup import async_setup_component @@ -26,24 +26,10 @@ from tests.common import ( async_get_device_automation_capabilities, async_get_device_automations, async_mock_service, - mock_device_registry, - mock_registry, ) from tests.components.blueprint.conftest import stub_blueprint_populate # noqa: F401 -@pytest.fixture -def device_reg(hass): - """Return an empty, loaded, registry.""" - return mock_device_registry(hass) - - -@pytest.fixture -def entity_reg(hass): - """Return an empty, loaded, registry.""" - return mock_registry(hass) - - @pytest.fixture def calls(hass): """Track calls to a mock service.""" @@ -83,8 +69,8 @@ def calls(hass): ) async def test_get_triggers( hass, - device_reg, - entity_reg, + device_registry, + entity_registry, set_state, features_reg, features_state, @@ -93,11 +79,11 @@ async def test_get_triggers( """Test we get the expected triggers from a cover.""" config_entry = MockConfigEntry(domain="test", data={}) config_entry.add_to_hass(hass) - device_entry = device_reg.async_get_or_create( + device_entry = device_registry.async_get_or_create( config_entry_id=config_entry.entry_id, - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, ) - entity_reg.async_get_or_create( + entity_registry.async_get_or_create( DOMAIN, "test", "5678", @@ -141,19 +127,19 @@ async def test_get_triggers( ) async def test_get_triggers_hidden_auxiliary( hass, - device_reg, - entity_reg, + device_registry, + entity_registry, hidden_by, entity_category, ): """Test we get the expected triggers from a hidden or auxiliary entity.""" config_entry = MockConfigEntry(domain="test", data={}) config_entry.add_to_hass(hass) - device_entry = device_reg.async_get_or_create( + device_entry = device_registry.async_get_or_create( config_entry_id=config_entry.entry_id, - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, ) - entity_reg.async_get_or_create( + entity_registry.async_get_or_create( DOMAIN, "test", "5678", @@ -180,7 +166,7 @@ async def test_get_triggers_hidden_auxiliary( async def test_get_trigger_capabilities( - hass, device_reg, entity_reg, enable_custom_integrations + hass, device_registry, entity_registry, enable_custom_integrations ): """Test we get the expected capabilities from a cover trigger.""" platform = getattr(hass.components, f"test.{DOMAIN}") @@ -191,11 +177,11 @@ async def test_get_trigger_capabilities( config_entry = MockConfigEntry(domain="test", data={}) config_entry.add_to_hass(hass) - device_entry = device_reg.async_get_or_create( + device_entry = device_registry.async_get_or_create( config_entry_id=config_entry.entry_id, - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, ) - entity_reg.async_get_or_create( + entity_registry.async_get_or_create( DOMAIN, "test", ent.unique_id, device_id=device_entry.id ) @@ -215,7 +201,7 @@ async def test_get_trigger_capabilities( async def test_get_trigger_capabilities_set_pos( - hass, device_reg, entity_reg, enable_custom_integrations + hass, device_registry, entity_registry, enable_custom_integrations ): """Test we get the expected capabilities from a cover trigger.""" platform = getattr(hass.components, f"test.{DOMAIN}") @@ -226,11 +212,11 @@ async def test_get_trigger_capabilities_set_pos( config_entry = MockConfigEntry(domain="test", data={}) config_entry.add_to_hass(hass) - device_entry = device_reg.async_get_or_create( + device_entry = device_registry.async_get_or_create( config_entry_id=config_entry.entry_id, - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, ) - entity_reg.async_get_or_create( + entity_registry.async_get_or_create( DOMAIN, "test", ent.unique_id, device_id=device_entry.id ) @@ -277,7 +263,7 @@ async def test_get_trigger_capabilities_set_pos( async def test_get_trigger_capabilities_set_tilt_pos( - hass, device_reg, entity_reg, enable_custom_integrations + hass, device_registry, entity_registry, enable_custom_integrations ): """Test we get the expected capabilities from a cover trigger.""" platform = getattr(hass.components, f"test.{DOMAIN}") @@ -288,11 +274,11 @@ async def test_get_trigger_capabilities_set_tilt_pos( config_entry = MockConfigEntry(domain="test", data={}) config_entry.add_to_hass(hass) - device_entry = device_reg.async_get_or_create( + device_entry = device_registry.async_get_or_create( config_entry_id=config_entry.entry_id, - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, ) - entity_reg.async_get_or_create( + entity_registry.async_get_or_create( DOMAIN, "test", ent.unique_id, device_id=device_entry.id ) diff --git a/tests/components/device_automation/test_init.py b/tests/components/device_automation/test_init.py index 0bca86cc108..c0e244c46ea 100644 --- a/tests/components/device_automation/test_init.py +++ b/tests/components/device_automation/test_init.py @@ -15,7 +15,7 @@ from homeassistant.components.device_automation import ( from homeassistant.components.websocket_api.const import TYPE_RESULT from homeassistant.const import CONF_PLATFORM, STATE_OFF, STATE_ON from homeassistant.core import HomeAssistant -from homeassistant.helpers import device_registry +from homeassistant.helpers import device_registry as dr from homeassistant.helpers.typing import ConfigType from homeassistant.setup import async_setup_component @@ -23,27 +23,13 @@ from tests.common import ( MockConfigEntry, MockModule, async_mock_service, - mock_device_registry, mock_integration, mock_platform, - mock_registry, ) from tests.components.blueprint.conftest import stub_blueprint_populate # noqa: F401 from tests.typing import WebSocketGenerator -@pytest.fixture -def device_reg(hass): - """Return an empty, loaded, registry.""" - return mock_device_registry(hass) - - -@pytest.fixture -def entity_reg(hass): - """Return an empty, loaded, registry.""" - return mock_registry(hass) - - @pytest.fixture def fake_integration(hass): """Set up a mock integration with device automation support.""" @@ -108,17 +94,17 @@ def fake_integration(hass): async def test_websocket_get_actions( - hass, hass_ws_client, device_reg, entity_reg, fake_integration + hass, hass_ws_client, device_registry, entity_registry, fake_integration ): """Test we get the expected actions through websocket.""" await async_setup_component(hass, "device_automation", {}) config_entry = MockConfigEntry(domain="test", data={}) config_entry.add_to_hass(hass) - device_entry = device_reg.async_get_or_create( + device_entry = device_registry.async_get_or_create( config_entry_id=config_entry.entry_id, - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, ) - entity_reg.async_get_or_create( + entity_registry.async_get_or_create( "fake_integration", "test", "5678", device_id=device_entry.id ) expected_actions = [ @@ -159,17 +145,17 @@ async def test_websocket_get_actions( async def test_websocket_get_conditions( - hass, hass_ws_client, device_reg, entity_reg, fake_integration + hass, hass_ws_client, device_registry, entity_registry, fake_integration ): """Test we get the expected conditions through websocket.""" await async_setup_component(hass, "device_automation", {}) config_entry = MockConfigEntry(domain="test", data={}) config_entry.add_to_hass(hass) - device_entry = device_reg.async_get_or_create( + device_entry = device_registry.async_get_or_create( config_entry_id=config_entry.entry_id, - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, ) - entity_reg.async_get_or_create( + entity_registry.async_get_or_create( "fake_integration", "test", "5678", device_id=device_entry.id ) expected_conditions = [ @@ -209,17 +195,17 @@ async def test_websocket_get_conditions( async def test_websocket_get_triggers( - hass, hass_ws_client, device_reg, entity_reg, fake_integration + hass, hass_ws_client, device_registry, entity_registry, fake_integration ): """Test we get the expected triggers through websocket.""" await async_setup_component(hass, "device_automation", {}) config_entry = MockConfigEntry(domain="test", data={}) config_entry.add_to_hass(hass) - device_entry = device_reg.async_get_or_create( + device_entry = device_registry.async_get_or_create( config_entry_id=config_entry.entry_id, - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, ) - entity_reg.async_get_or_create( + entity_registry.async_get_or_create( "fake_integration", "test", "5678", device_id=device_entry.id ) expected_triggers = [ @@ -267,17 +253,17 @@ async def test_websocket_get_triggers( async def test_websocket_get_action_capabilities( - hass, hass_ws_client, device_reg, entity_reg, fake_integration + hass, hass_ws_client, device_registry, entity_registry, fake_integration ): """Test we get the expected action capabilities through websocket.""" await async_setup_component(hass, "device_automation", {}) config_entry = MockConfigEntry(domain="test", data={}) config_entry.add_to_hass(hass) - device_entry = device_reg.async_get_or_create( + device_entry = device_registry.async_get_or_create( config_entry_id=config_entry.entry_id, - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, ) - entity_reg.async_get_or_create( + entity_registry.async_get_or_create( "fake_integration", "test", "5678", device_id=device_entry.id ) expected_capabilities = { @@ -331,7 +317,7 @@ async def test_websocket_get_action_capabilities( async def test_websocket_get_action_capabilities_unknown_domain( - hass, hass_ws_client, device_reg, entity_reg + hass, hass_ws_client, device_registry, entity_registry ): """Test we get no action capabilities for a non existing domain.""" await async_setup_component(hass, "device_automation", {}) @@ -354,7 +340,7 @@ async def test_websocket_get_action_capabilities_unknown_domain( async def test_websocket_get_action_capabilities_no_capabilities( - hass, hass_ws_client, device_reg, entity_reg, fake_integration + hass, hass_ws_client, device_registry, entity_registry, fake_integration ): """Test we get no action capabilities for a domain which has none. @@ -381,7 +367,7 @@ async def test_websocket_get_action_capabilities_no_capabilities( async def test_websocket_get_action_capabilities_bad_action( - hass, hass_ws_client, device_reg, entity_reg, fake_integration + hass, hass_ws_client, device_registry, entity_registry, fake_integration ): """Test we get no action capabilities when there is an error.""" await async_setup_component(hass, "device_automation", {}) @@ -411,17 +397,17 @@ async def test_websocket_get_action_capabilities_bad_action( async def test_websocket_get_condition_capabilities( - hass, hass_ws_client, device_reg, entity_reg, fake_integration + hass, hass_ws_client, device_registry, entity_registry, fake_integration ): """Test we get the expected condition capabilities through websocket.""" await async_setup_component(hass, "device_automation", {}) config_entry = MockConfigEntry(domain="test", data={}) config_entry.add_to_hass(hass) - device_entry = device_reg.async_get_or_create( + device_entry = device_registry.async_get_or_create( config_entry_id=config_entry.entry_id, - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, ) - entity_reg.async_get_or_create( + entity_registry.async_get_or_create( "fake_integration", "test", "5678", device_id=device_entry.id ) expected_capabilities = { @@ -475,7 +461,7 @@ async def test_websocket_get_condition_capabilities( async def test_websocket_get_condition_capabilities_unknown_domain( - hass, hass_ws_client, device_reg, entity_reg + hass, hass_ws_client, device_registry, entity_registry ): """Test we get no condition capabilities for a non existing domain.""" await async_setup_component(hass, "device_automation", {}) @@ -498,7 +484,7 @@ async def test_websocket_get_condition_capabilities_unknown_domain( async def test_websocket_get_condition_capabilities_no_capabilities( - hass, hass_ws_client, device_reg, entity_reg, fake_integration + hass, hass_ws_client, device_registry, entity_registry, fake_integration ): """Test we get no condition capabilities for a domain which has none. @@ -529,7 +515,7 @@ async def test_websocket_get_condition_capabilities_no_capabilities( async def test_websocket_get_condition_capabilities_bad_condition( - hass, hass_ws_client, device_reg, entity_reg, fake_integration + hass, hass_ws_client, device_registry, entity_registry, fake_integration ): """Test we get no condition capabilities when there is an error.""" await async_setup_component(hass, "device_automation", {}) @@ -563,17 +549,19 @@ async def test_websocket_get_condition_capabilities_bad_condition( async def test_async_get_device_automations_single_device_trigger( - hass, device_reg, entity_reg + hass, device_registry, entity_registry ): """Test we get can fetch the triggers for a device id.""" await async_setup_component(hass, "device_automation", {}) config_entry = MockConfigEntry(domain="test", data={}) config_entry.add_to_hass(hass) - device_entry = device_reg.async_get_or_create( + device_entry = device_registry.async_get_or_create( config_entry_id=config_entry.entry_id, - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + ) + entity_registry.async_get_or_create( + "light", "test", "5678", device_id=device_entry.id ) - entity_reg.async_get_or_create("light", "test", "5678", device_id=device_entry.id) result = await device_automation.async_get_device_automations( hass, device_automation.DeviceAutomationType.TRIGGER, [device_entry.id] ) @@ -582,17 +570,19 @@ async def test_async_get_device_automations_single_device_trigger( async def test_async_get_device_automations_all_devices_trigger( - hass, device_reg, entity_reg + hass, device_registry, entity_registry ): """Test we get can fetch all the triggers when no device id is passed.""" await async_setup_component(hass, "device_automation", {}) config_entry = MockConfigEntry(domain="test", data={}) config_entry.add_to_hass(hass) - device_entry = device_reg.async_get_or_create( + device_entry = device_registry.async_get_or_create( config_entry_id=config_entry.entry_id, - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + ) + entity_registry.async_get_or_create( + "light", "test", "5678", device_id=device_entry.id ) - entity_reg.async_get_or_create("light", "test", "5678", device_id=device_entry.id) result = await device_automation.async_get_device_automations( hass, device_automation.DeviceAutomationType.TRIGGER ) @@ -601,17 +591,19 @@ async def test_async_get_device_automations_all_devices_trigger( async def test_async_get_device_automations_all_devices_condition( - hass, device_reg, entity_reg + hass, device_registry, entity_registry ): """Test we get can fetch all the conditions when no device id is passed.""" await async_setup_component(hass, "device_automation", {}) config_entry = MockConfigEntry(domain="test", data={}) config_entry.add_to_hass(hass) - device_entry = device_reg.async_get_or_create( + device_entry = device_registry.async_get_or_create( config_entry_id=config_entry.entry_id, - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + ) + entity_registry.async_get_or_create( + "light", "test", "5678", device_id=device_entry.id ) - entity_reg.async_get_or_create("light", "test", "5678", device_id=device_entry.id) result = await device_automation.async_get_device_automations( hass, device_automation.DeviceAutomationType.CONDITION ) @@ -620,17 +612,19 @@ async def test_async_get_device_automations_all_devices_condition( async def test_async_get_device_automations_all_devices_action( - hass, device_reg, entity_reg + hass, device_registry, entity_registry ): """Test we get can fetch all the actions when no device id is passed.""" await async_setup_component(hass, "device_automation", {}) config_entry = MockConfigEntry(domain="test", data={}) config_entry.add_to_hass(hass) - device_entry = device_reg.async_get_or_create( + device_entry = device_registry.async_get_or_create( config_entry_id=config_entry.entry_id, - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + ) + entity_registry.async_get_or_create( + "light", "test", "5678", device_id=device_entry.id ) - entity_reg.async_get_or_create("light", "test", "5678", device_id=device_entry.id) result = await device_automation.async_get_device_automations( hass, device_automation.DeviceAutomationType.ACTION ) @@ -639,17 +633,19 @@ async def test_async_get_device_automations_all_devices_action( async def test_async_get_device_automations_all_devices_action_exception_throw( - hass, device_reg, entity_reg, caplog + hass, device_registry, entity_registry, caplog ): """Test we get can fetch all the actions when no device id is passed and can handle one throwing an exception.""" await async_setup_component(hass, "device_automation", {}) config_entry = MockConfigEntry(domain="test", data={}) config_entry.add_to_hass(hass) - device_entry = device_reg.async_get_or_create( + device_entry = device_registry.async_get_or_create( config_entry_id=config_entry.entry_id, - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + ) + entity_registry.async_get_or_create( + "light", "test", "5678", device_id=device_entry.id ) - entity_reg.async_get_or_create("light", "test", "5678", device_id=device_entry.id) with patch( "homeassistant.components.light.device_trigger.async_get_triggers", side_effect=KeyError, @@ -663,17 +659,17 @@ async def test_async_get_device_automations_all_devices_action_exception_throw( async def test_websocket_get_trigger_capabilities( - hass, hass_ws_client, device_reg, entity_reg, fake_integration + hass, hass_ws_client, device_registry, entity_registry, fake_integration ): """Test we get the expected trigger capabilities through websocket.""" await async_setup_component(hass, "device_automation", {}) config_entry = MockConfigEntry(domain="test", data={}) config_entry.add_to_hass(hass) - device_entry = device_reg.async_get_or_create( + device_entry = device_registry.async_get_or_create( config_entry_id=config_entry.entry_id, - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, ) - entity_reg.async_get_or_create( + entity_registry.async_get_or_create( "fake_integration", "test", "5678", device_id=device_entry.id ) expected_capabilities = { @@ -727,7 +723,7 @@ async def test_websocket_get_trigger_capabilities( async def test_websocket_get_trigger_capabilities_unknown_domain( - hass, hass_ws_client, device_reg, entity_reg + hass, hass_ws_client, device_registry, entity_registry ): """Test we get no trigger capabilities for a non existing domain.""" await async_setup_component(hass, "device_automation", {}) @@ -750,7 +746,7 @@ async def test_websocket_get_trigger_capabilities_unknown_domain( async def test_websocket_get_trigger_capabilities_no_capabilities( - hass, hass_ws_client, device_reg, entity_reg, fake_integration + hass, hass_ws_client, device_registry, entity_registry, fake_integration ): """Test we get no trigger capabilities for a domain which has none. @@ -781,7 +777,7 @@ async def test_websocket_get_trigger_capabilities_no_capabilities( async def test_websocket_get_trigger_capabilities_bad_trigger( - hass, hass_ws_client, device_reg, entity_reg, fake_integration + hass, hass_ws_client, device_registry, entity_registry, fake_integration ): """Test we get no trigger capabilities when there is an error.""" await async_setup_component(hass, "device_automation", {}) @@ -870,7 +866,7 @@ async def test_automation_with_device_action(hass, caplog, fake_integration): async def test_automation_with_dynamically_validated_action( - hass, caplog, device_reg, fake_integration + hass, caplog, device_registry, fake_integration ): """Test device automation with an action which is dynamically validated.""" @@ -881,9 +877,9 @@ async def test_automation_with_dynamically_validated_action( config_entry = MockConfigEntry(domain="fake_integration", data={}) config_entry.state = config_entries.ConfigEntryState.LOADED config_entry.add_to_hass(hass) - device_entry = device_reg.async_get_or_create( + device_entry = device_registry.async_get_or_create( config_entry_id=config_entry.entry_id, - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, ) assert await async_setup_component( @@ -953,7 +949,7 @@ async def test_automation_with_device_condition(hass, caplog, fake_integration): async def test_automation_with_dynamically_validated_condition( - hass, caplog, device_reg, fake_integration + hass, caplog, device_registry, fake_integration ): """Test device automation with a condition which is dynamically validated.""" @@ -964,9 +960,9 @@ async def test_automation_with_dynamically_validated_condition( config_entry = MockConfigEntry(domain="fake_integration", data={}) config_entry.state = config_entries.ConfigEntryState.LOADED config_entry.add_to_hass(hass) - device_entry = device_reg.async_get_or_create( + device_entry = device_registry.async_get_or_create( config_entry_id=config_entry.entry_id, - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, ) assert await async_setup_component( @@ -1046,7 +1042,7 @@ async def test_automation_with_device_trigger(hass, caplog, fake_integration): async def test_automation_with_dynamically_validated_trigger( - hass, caplog, device_reg, entity_reg, fake_integration + hass, caplog, device_registry, entity_registry, fake_integration ): """Test device automation with a trigger which is dynamically validated.""" @@ -1058,11 +1054,11 @@ async def test_automation_with_dynamically_validated_trigger( config_entry = MockConfigEntry(domain="fake_integration", data={}) config_entry.state = config_entries.ConfigEntryState.LOADED config_entry.add_to_hass(hass) - device_entry = device_reg.async_get_or_create( + device_entry = device_registry.async_get_or_create( config_entry_id=config_entry.entry_id, - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, ) - entity_reg.async_get_or_create( + entity_registry.async_get_or_create( "fake_integration", "test", "5678", device_id=device_entry.id ) @@ -1395,7 +1391,7 @@ async def test_automation_with_unknown_device(hass, caplog, fake_integration): async def test_automation_with_device_wrong_domain( - hass, caplog, device_reg, fake_integration + hass, caplog, device_registry, fake_integration ): """Test device automation where the device doesn't have the right config entry.""" @@ -1403,9 +1399,9 @@ async def test_automation_with_device_wrong_domain( module = module_cache["fake_integration.device_trigger"] module.async_validate_trigger_config = AsyncMock() - device_entry = device_reg.async_get_or_create( + device_entry = device_registry.async_get_or_create( config_entry_id="not_fake_integration_config_entry", - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, ) assert await async_setup_component( hass, @@ -1432,7 +1428,7 @@ async def test_automation_with_device_wrong_domain( async def test_automation_with_device_component_not_loaded( - hass, caplog, device_reg, fake_integration + hass, caplog, device_registry, fake_integration ): """Test device automation where the device's config entry is not loaded.""" @@ -1443,9 +1439,9 @@ async def test_automation_with_device_component_not_loaded( config_entry = MockConfigEntry(domain="fake_integration", data={}) config_entry.add_to_hass(hass) - device_entry = device_reg.async_get_or_create( + device_entry = device_registry.async_get_or_create( config_entry_id=config_entry.entry_id, - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, ) assert await async_setup_component( hass, diff --git a/tests/components/device_tracker/test_device_condition.py b/tests/components/device_tracker/test_device_condition.py index 726c7479b7d..b1b025013be 100644 --- a/tests/components/device_tracker/test_device_condition.py +++ b/tests/components/device_tracker/test_device_condition.py @@ -5,7 +5,7 @@ import homeassistant.components.automation as automation from homeassistant.components.device_automation import DeviceAutomationType from homeassistant.components.device_tracker import DOMAIN from homeassistant.const import STATE_HOME -from homeassistant.helpers import device_registry +from homeassistant.helpers import device_registry as dr from homeassistant.helpers.entity import EntityCategory from homeassistant.helpers.entity_registry import RegistryEntryHider from homeassistant.setup import async_setup_component @@ -15,39 +15,27 @@ from tests.common import ( assert_lists_same, async_get_device_automations, async_mock_service, - mock_device_registry, - mock_registry, ) from tests.components.blueprint.conftest import stub_blueprint_populate # noqa: F401 -@pytest.fixture -def device_reg(hass): - """Return an empty, loaded, registry.""" - return mock_device_registry(hass) - - -@pytest.fixture -def entity_reg(hass): - """Return an empty, loaded, registry.""" - return mock_registry(hass) - - @pytest.fixture def calls(hass): """Track calls to a mock service.""" return async_mock_service(hass, "test", "automation") -async def test_get_conditions(hass, device_reg, entity_reg): +async def test_get_conditions(hass, device_registry, entity_registry): """Test we get the expected conditions from a device_tracker.""" config_entry = MockConfigEntry(domain="test", data={}) config_entry.add_to_hass(hass) - device_entry = device_reg.async_get_or_create( + device_entry = device_registry.async_get_or_create( config_entry_id=config_entry.entry_id, - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + ) + entity_registry.async_get_or_create( + DOMAIN, "test", "5678", device_id=device_entry.id ) - entity_reg.async_get_or_create(DOMAIN, "test", "5678", device_id=device_entry.id) expected_conditions = [ { "condition": "device", @@ -76,19 +64,19 @@ async def test_get_conditions(hass, device_reg, entity_reg): ) async def test_get_conditions_hidden_auxiliary( hass, - device_reg, - entity_reg, + device_registry, + entity_registry, hidden_by, entity_category, ): """Test we get the expected conditions from a hidden or auxiliary entity.""" config_entry = MockConfigEntry(domain="test", data={}) config_entry.add_to_hass(hass) - device_entry = device_reg.async_get_or_create( + device_entry = device_registry.async_get_or_create( config_entry_id=config_entry.entry_id, - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, ) - entity_reg.async_get_or_create( + entity_registry.async_get_or_create( DOMAIN, "test", "5678", diff --git a/tests/components/device_tracker/test_device_trigger.py b/tests/components/device_tracker/test_device_trigger.py index 00e39fdc3fe..fa6a659b7e5 100644 --- a/tests/components/device_tracker/test_device_trigger.py +++ b/tests/components/device_tracker/test_device_trigger.py @@ -6,7 +6,7 @@ import homeassistant.components.automation as automation from homeassistant.components.device_automation import DeviceAutomationType from homeassistant.components.device_tracker import DOMAIN, device_trigger import homeassistant.components.zone as zone -from homeassistant.helpers import config_validation as cv, device_registry +from homeassistant.helpers import config_validation as cv, device_registry as dr from homeassistant.helpers.entity import EntityCategory from homeassistant.helpers.entity_registry import RegistryEntryHider from homeassistant.setup import async_setup_component @@ -16,8 +16,6 @@ from tests.common import ( assert_lists_same, async_get_device_automations, async_mock_service, - mock_device_registry, - mock_registry, ) from tests.components.blueprint.conftest import stub_blueprint_populate # noqa: F401 @@ -28,18 +26,6 @@ HOME_LATITUDE = 32.880837 HOME_LONGITUDE = -117.237561 -@pytest.fixture -def device_reg(hass): - """Return an empty, loaded, registry.""" - return mock_device_registry(hass) - - -@pytest.fixture -def entity_reg(hass): - """Return an empty, loaded, registry.""" - return mock_registry(hass) - - @pytest.fixture def calls(hass): """Track calls to a mock service.""" @@ -65,15 +51,17 @@ def setup_zone(hass): ) -async def test_get_triggers(hass, device_reg, entity_reg): +async def test_get_triggers(hass, device_registry, entity_registry): """Test we get the expected triggers from a device_tracker.""" config_entry = MockConfigEntry(domain="test", data={}) config_entry.add_to_hass(hass) - device_entry = device_reg.async_get_or_create( + device_entry = device_registry.async_get_or_create( config_entry_id=config_entry.entry_id, - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + ) + entity_registry.async_get_or_create( + DOMAIN, "test", "5678", device_id=device_entry.id ) - entity_reg.async_get_or_create(DOMAIN, "test", "5678", device_id=device_entry.id) expected_triggers = [ { "platform": "device", @@ -102,19 +90,19 @@ async def test_get_triggers(hass, device_reg, entity_reg): ) async def test_get_triggers_hidden_auxiliary( hass, - device_reg, - entity_reg, + device_registry, + entity_registry, hidden_by, entity_category, ): """Test we get the expected triggers from a hidden or auxiliary entity.""" config_entry = MockConfigEntry(domain="test", data={}) config_entry.add_to_hass(hass) - device_entry = device_reg.async_get_or_create( + device_entry = device_registry.async_get_or_create( config_entry_id=config_entry.entry_id, - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, ) - entity_reg.async_get_or_create( + entity_registry.async_get_or_create( DOMAIN, "test", "5678", @@ -229,15 +217,17 @@ async def test_if_fires_on_zone_change(hass, calls): ) -async def test_get_trigger_capabilities(hass, device_reg, entity_reg): +async def test_get_trigger_capabilities(hass, device_registry, entity_registry): """Test we get the expected capabilities from a device_tracker trigger.""" config_entry = MockConfigEntry(domain="test", data={}) config_entry.add_to_hass(hass) - device_entry = device_reg.async_get_or_create( + device_entry = device_registry.async_get_or_create( config_entry_id=config_entry.entry_id, - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + ) + entity_registry.async_get_or_create( + DOMAIN, "test", "5678", device_id=device_entry.id ) - entity_reg.async_get_or_create(DOMAIN, "test", "5678", device_id=device_entry.id) capabilities = await device_trigger.async_get_trigger_capabilities( hass, { diff --git a/tests/components/fan/test_device_action.py b/tests/components/fan/test_device_action.py index 96269513306..fb0ac729112 100644 --- a/tests/components/fan/test_device_action.py +++ b/tests/components/fan/test_device_action.py @@ -5,7 +5,7 @@ import homeassistant.components.automation as automation from homeassistant.components.device_automation import DeviceAutomationType from homeassistant.components.fan import DOMAIN from homeassistant.core import HomeAssistant -from homeassistant.helpers import device_registry +from homeassistant.helpers import device_registry as dr from homeassistant.helpers.entity import EntityCategory from homeassistant.helpers.entity_registry import RegistryEntryHider from homeassistant.setup import async_setup_component @@ -15,33 +15,21 @@ from tests.common import ( assert_lists_same, async_get_device_automations, async_mock_service, - mock_device_registry, - mock_registry, ) from tests.components.blueprint.conftest import stub_blueprint_populate # noqa: F401 -@pytest.fixture -def device_reg(hass): - """Return an empty, loaded, registry.""" - return mock_device_registry(hass) - - -@pytest.fixture -def entity_reg(hass): - """Return an empty, loaded, registry.""" - return mock_registry(hass) - - -async def test_get_actions(hass, device_reg, entity_reg): +async def test_get_actions(hass, device_registry, entity_registry): """Test we get the expected actions from a fan.""" config_entry = MockConfigEntry(domain="test", data={}) config_entry.add_to_hass(hass) - device_entry = device_reg.async_get_or_create( + device_entry = device_registry.async_get_or_create( config_entry_id=config_entry.entry_id, - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + ) + entity_registry.async_get_or_create( + DOMAIN, "test", "5678", device_id=device_entry.id ) - entity_reg.async_get_or_create(DOMAIN, "test", "5678", device_id=device_entry.id) expected_actions = [] expected_actions += [ { @@ -70,19 +58,19 @@ async def test_get_actions(hass, device_reg, entity_reg): ) async def test_get_actions_hidden_auxiliary( hass, - device_reg, - entity_reg, + device_registry, + entity_registry, hidden_by, entity_category, ): """Test we get the expected actions from a hidden or auxiliary entity.""" config_entry = MockConfigEntry(domain="test", data={}) config_entry.add_to_hass(hass) - device_entry = device_reg.async_get_or_create( + device_entry = device_registry.async_get_or_create( config_entry_id=config_entry.entry_id, - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, ) - entity_reg.async_get_or_create( + entity_registry.async_get_or_create( DOMAIN, "test", "5678", diff --git a/tests/components/fan/test_device_condition.py b/tests/components/fan/test_device_condition.py index 241c9b129a3..0fa1306bc4f 100644 --- a/tests/components/fan/test_device_condition.py +++ b/tests/components/fan/test_device_condition.py @@ -5,7 +5,7 @@ import homeassistant.components.automation as automation from homeassistant.components.device_automation import DeviceAutomationType from homeassistant.components.fan import DOMAIN from homeassistant.const import STATE_OFF, STATE_ON -from homeassistant.helpers import device_registry +from homeassistant.helpers import device_registry as dr from homeassistant.helpers.entity import EntityCategory from homeassistant.helpers.entity_registry import RegistryEntryHider from homeassistant.setup import async_setup_component @@ -15,39 +15,27 @@ from tests.common import ( assert_lists_same, async_get_device_automations, async_mock_service, - mock_device_registry, - mock_registry, ) from tests.components.blueprint.conftest import stub_blueprint_populate # noqa: F401 -@pytest.fixture -def device_reg(hass): - """Return an empty, loaded, registry.""" - return mock_device_registry(hass) - - -@pytest.fixture -def entity_reg(hass): - """Return an empty, loaded, registry.""" - return mock_registry(hass) - - @pytest.fixture def calls(hass): """Track calls to a mock service.""" return async_mock_service(hass, "test", "automation") -async def test_get_conditions(hass, device_reg, entity_reg): +async def test_get_conditions(hass, device_registry, entity_registry): """Test we get the expected conditions from a fan.""" config_entry = MockConfigEntry(domain="test", data={}) config_entry.add_to_hass(hass) - device_entry = device_reg.async_get_or_create( + device_entry = device_registry.async_get_or_create( config_entry_id=config_entry.entry_id, - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + ) + entity_registry.async_get_or_create( + DOMAIN, "test", "5678", device_id=device_entry.id ) - entity_reg.async_get_or_create(DOMAIN, "test", "5678", device_id=device_entry.id) expected_conditions = [ { "condition": "device", @@ -76,19 +64,19 @@ async def test_get_conditions(hass, device_reg, entity_reg): ) async def test_get_conditions_hidden_auxiliary( hass, - device_reg, - entity_reg, + device_registry, + entity_registry, hidden_by, entity_category, ): """Test we get the expected conditions from a hidden or auxiliary entity.""" config_entry = MockConfigEntry(domain="test", data={}) config_entry.add_to_hass(hass) - device_entry = device_reg.async_get_or_create( + device_entry = device_registry.async_get_or_create( config_entry_id=config_entry.entry_id, - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, ) - entity_reg.async_get_or_create( + entity_registry.async_get_or_create( DOMAIN, "test", "5678", diff --git a/tests/components/fan/test_device_trigger.py b/tests/components/fan/test_device_trigger.py index 4255c592792..d09826462cf 100644 --- a/tests/components/fan/test_device_trigger.py +++ b/tests/components/fan/test_device_trigger.py @@ -7,7 +7,7 @@ import homeassistant.components.automation as automation from homeassistant.components.device_automation import DeviceAutomationType from homeassistant.components.fan import DOMAIN from homeassistant.const import STATE_OFF, STATE_ON -from homeassistant.helpers import device_registry +from homeassistant.helpers import device_registry as dr from homeassistant.helpers.entity import EntityCategory from homeassistant.helpers.entity_registry import RegistryEntryHider from homeassistant.setup import async_setup_component @@ -20,39 +20,27 @@ from tests.common import ( async_get_device_automation_capabilities, async_get_device_automations, async_mock_service, - mock_device_registry, - mock_registry, ) from tests.components.blueprint.conftest import stub_blueprint_populate # noqa: F401 -@pytest.fixture -def device_reg(hass): - """Return an empty, loaded, registry.""" - return mock_device_registry(hass) - - -@pytest.fixture -def entity_reg(hass): - """Return an empty, loaded, registry.""" - return mock_registry(hass) - - @pytest.fixture def calls(hass): """Track calls to a mock service.""" return async_mock_service(hass, "test", "automation") -async def test_get_triggers(hass, device_reg, entity_reg): +async def test_get_triggers(hass, device_registry, entity_registry): """Test we get the expected triggers from a fan.""" config_entry = MockConfigEntry(domain="test", data={}) config_entry.add_to_hass(hass) - device_entry = device_reg.async_get_or_create( + device_entry = device_registry.async_get_or_create( config_entry_id=config_entry.entry_id, - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + ) + entity_registry.async_get_or_create( + DOMAIN, "test", "5678", device_id=device_entry.id ) - entity_reg.async_get_or_create(DOMAIN, "test", "5678", device_id=device_entry.id) expected_triggers = [ { "platform": "device", @@ -81,19 +69,19 @@ async def test_get_triggers(hass, device_reg, entity_reg): ) async def test_get_triggers_hidden_auxiliary( hass, - device_reg, - entity_reg, + device_registry, + entity_registry, hidden_by, entity_category, ): """Test we get the expected triggers from a hidden or auxiliary entity.""" config_entry = MockConfigEntry(domain="test", data={}) config_entry.add_to_hass(hass) - device_entry = device_reg.async_get_or_create( + device_entry = device_registry.async_get_or_create( config_entry_id=config_entry.entry_id, - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, ) - entity_reg.async_get_or_create( + entity_registry.async_get_or_create( DOMAIN, "test", "5678", @@ -118,15 +106,17 @@ async def test_get_triggers_hidden_auxiliary( assert_lists_same(triggers, expected_triggers) -async def test_get_trigger_capabilities(hass, device_reg, entity_reg): +async def test_get_trigger_capabilities(hass, device_registry, entity_registry): """Test we get the expected capabilities from a switch trigger.""" config_entry = MockConfigEntry(domain="test", data={}) config_entry.add_to_hass(hass) - device_entry = device_reg.async_get_or_create( + device_entry = device_registry.async_get_or_create( config_entry_id=config_entry.entry_id, - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + ) + entity_registry.async_get_or_create( + DOMAIN, "test", "5678", device_id=device_entry.id ) - entity_reg.async_get_or_create(DOMAIN, "test", "5678", device_id=device_entry.id) expected_capabilities = { "extra_fields": [ {"name": "for", "optional": True, "type": "positive_time_period_dict"} diff --git a/tests/components/file/test_sensor.py b/tests/components/file/test_sensor.py index 725ccb527f8..e01d90b8cc3 100644 --- a/tests/components/file/test_sensor.py +++ b/tests/components/file/test_sensor.py @@ -1,19 +1,11 @@ """The tests for local file sensor platform.""" from unittest.mock import Mock, patch -import pytest - from homeassistant.const import STATE_UNKNOWN from homeassistant.core import HomeAssistant from homeassistant.setup import async_setup_component -from tests.common import get_fixture_path, mock_registry - - -@pytest.fixture -def entity_reg(hass): - """Return an empty, loaded, registry.""" - return mock_registry(hass) +from tests.common import get_fixture_path @patch("os.path.isfile", Mock(return_value=True)) diff --git a/tests/components/homeassistant/test_init.py b/tests/components/homeassistant/test_init.py index 554934cbd87..793e18d2523 100644 --- a/tests/components/homeassistant/test_init.py +++ b/tests/components/homeassistant/test_init.py @@ -32,7 +32,7 @@ from homeassistant.const import ( import homeassistant.core as ha from homeassistant.core import HomeAssistant from homeassistant.exceptions import HomeAssistantError, Unauthorized -from homeassistant.helpers import entity +from homeassistant.helpers import entity, entity_registry as er from homeassistant.setup import async_setup_component from tests.common import ( @@ -40,7 +40,6 @@ from tests.common import ( async_capture_events, async_mock_service, get_test_home_assistant, - mock_registry, mock_service, patch_yaml_files, ) @@ -379,18 +378,19 @@ async def test_not_allowing_recursion( ), service -async def test_reload_config_entry_by_entity_id(hass: HomeAssistant) -> None: +async def test_reload_config_entry_by_entity_id( + hass: HomeAssistant, entity_registry: er.EntityRegistry +) -> None: """Test being able to reload a config entry by entity_id.""" await async_setup_component(hass, "homeassistant", {}) - entity_reg = mock_registry(hass) entry1 = MockConfigEntry(domain="mockdomain") entry1.add_to_hass(hass) entry2 = MockConfigEntry(domain="mockdomain") entry2.add_to_hass(hass) - reg_entity1 = entity_reg.async_get_or_create( + reg_entity1 = entity_registry.async_get_or_create( "binary_sensor", "powerwall", "battery_charging", config_entry=entry1 ) - reg_entity2 = entity_reg.async_get_or_create( + reg_entity2 = entity_registry.async_get_or_create( "binary_sensor", "powerwall", "battery_status", config_entry=entry2 ) with patch( diff --git a/tests/components/humidifier/test_device_action.py b/tests/components/humidifier/test_device_action.py index 5205aa21885..85c667a2037 100644 --- a/tests/components/humidifier/test_device_action.py +++ b/tests/components/humidifier/test_device_action.py @@ -7,7 +7,7 @@ from homeassistant.components.device_automation import DeviceAutomationType from homeassistant.components.humidifier import DOMAIN, const, device_action from homeassistant.const import STATE_ON from homeassistant.core import HomeAssistant -from homeassistant.helpers import config_validation as cv, device_registry +from homeassistant.helpers import config_validation as cv, device_registry as dr from homeassistant.helpers.entity import EntityCategory from homeassistant.helpers.entity_registry import RegistryEntryHider from homeassistant.setup import async_setup_component @@ -17,24 +17,10 @@ from tests.common import ( assert_lists_same, async_get_device_automations, async_mock_service, - mock_device_registry, - mock_registry, ) from tests.components.blueprint.conftest import stub_blueprint_populate # noqa: F401 -@pytest.fixture -def device_reg(hass): - """Return an empty, loaded, registry.""" - return mock_device_registry(hass) - - -@pytest.fixture -def entity_reg(hass): - """Return an empty, loaded, registry.""" - return mock_registry(hass) - - @pytest.mark.parametrize( "set_state,features_reg,features_state,expected_action_types", [ @@ -46,8 +32,8 @@ def entity_reg(hass): ) async def test_get_actions( hass, - device_reg, - entity_reg, + device_registry, + entity_registry, set_state, features_reg, features_state, @@ -56,11 +42,11 @@ async def test_get_actions( """Test we get the expected actions from a humidifier.""" config_entry = MockConfigEntry(domain="test", data={}) config_entry.add_to_hass(hass) - device_entry = device_reg.async_get_or_create( + device_entry = device_registry.async_get_or_create( config_entry_id=config_entry.entry_id, - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, ) - entity_reg.async_get_or_create( + entity_registry.async_get_or_create( DOMAIN, "test", "5678", @@ -110,19 +96,19 @@ async def test_get_actions( ) async def test_get_actions_hidden_auxiliary( hass, - device_reg, - entity_reg, + device_registry, + entity_registry, hidden_by, entity_category, ): """Test we get the expected actions from a hidden or auxiliary entity.""" config_entry = MockConfigEntry(domain="test", data={}) config_entry.add_to_hass(hass) - device_entry = device_reg.async_get_or_create( + device_entry = device_registry.async_get_or_create( config_entry_id=config_entry.entry_id, - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, ) - entity_reg.async_get_or_create( + entity_registry.async_get_or_create( DOMAIN, "test", "5678", @@ -366,8 +352,8 @@ async def test_action(hass: HomeAssistant) -> None: ) async def test_capabilities( hass, - device_reg, - entity_reg, + device_registry, + entity_registry, set_state, capabilities_reg, capabilities_state, @@ -377,11 +363,11 @@ async def test_capabilities( """Test getting capabilities.""" config_entry = MockConfigEntry(domain="test", data={}) config_entry.add_to_hass(hass) - device_entry = device_reg.async_get_or_create( + device_entry = device_registry.async_get_or_create( config_entry_id=config_entry.entry_id, - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, ) - entity_reg.async_get_or_create( + entity_registry.async_get_or_create( DOMAIN, "test", "5678", @@ -422,9 +408,7 @@ async def test_capabilities( ("set_mode", "mode", {"type": "select", "options": []}), ], ) -async def test_capabilities_missing_entity( - hass, device_reg, entity_reg, action, capability_name, extra -): +async def test_capabilities_missing_entity(hass, action, capability_name, extra): """Test getting capabilities.""" config_entry = MockConfigEntry(domain="test", data={}) config_entry.add_to_hass(hass) diff --git a/tests/components/humidifier/test_device_condition.py b/tests/components/humidifier/test_device_condition.py index d63151a3433..49a3e48b721 100644 --- a/tests/components/humidifier/test_device_condition.py +++ b/tests/components/humidifier/test_device_condition.py @@ -6,7 +6,7 @@ import homeassistant.components.automation as automation from homeassistant.components.device_automation import DeviceAutomationType from homeassistant.components.humidifier import DOMAIN, const, device_condition from homeassistant.const import ATTR_MODE, STATE_OFF, STATE_ON -from homeassistant.helpers import config_validation as cv, device_registry +from homeassistant.helpers import config_validation as cv, device_registry as dr from homeassistant.helpers.entity import EntityCategory from homeassistant.helpers.entity_registry import RegistryEntryHider from homeassistant.setup import async_setup_component @@ -16,24 +16,10 @@ from tests.common import ( assert_lists_same, async_get_device_automations, async_mock_service, - mock_device_registry, - mock_registry, ) from tests.components.blueprint.conftest import stub_blueprint_populate # noqa: F401 -@pytest.fixture -def device_reg(hass): - """Return an empty, loaded, registry.""" - return mock_device_registry(hass) - - -@pytest.fixture -def entity_reg(hass): - """Return an empty, loaded, registry.""" - return mock_registry(hass) - - @pytest.fixture def calls(hass): """Track calls to a mock service.""" @@ -51,8 +37,8 @@ def calls(hass): ) async def test_get_conditions( hass, - device_reg, - entity_reg, + device_registry, + entity_registry, set_state, features_reg, features_state, @@ -61,11 +47,11 @@ async def test_get_conditions( """Test we get the expected conditions from a humidifier.""" config_entry = MockConfigEntry(domain="test", data={}) config_entry.add_to_hass(hass) - device_entry = device_reg.async_get_or_create( + device_entry = device_registry.async_get_or_create( config_entry_id=config_entry.entry_id, - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, ) - entity_reg.async_get_or_create( + entity_registry.async_get_or_create( DOMAIN, "test", "5678", @@ -117,19 +103,19 @@ async def test_get_conditions( ) async def test_get_conditions_hidden_auxiliary( hass, - device_reg, - entity_reg, + device_registry, + entity_registry, hidden_by, entity_category, ): """Test we get the expected conditions from a hidden or auxiliary entity.""" config_entry = MockConfigEntry(domain="test", data={}) config_entry.add_to_hass(hass) - device_entry = device_reg.async_get_or_create( + device_entry = device_registry.async_get_or_create( config_entry_id=config_entry.entry_id, - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, ) - entity_reg.async_get_or_create( + entity_registry.async_get_or_create( DOMAIN, "test", "5678", @@ -371,8 +357,8 @@ async def test_if_state(hass, calls): ) async def test_capabilities( hass, - device_reg, - entity_reg, + device_registry, + entity_registry, set_state, capabilities_reg, capabilities_state, @@ -382,11 +368,11 @@ async def test_capabilities( """Test getting capabilities.""" config_entry = MockConfigEntry(domain="test", data={}) config_entry.add_to_hass(hass) - device_entry = device_reg.async_get_or_create( + device_entry = device_registry.async_get_or_create( config_entry_id=config_entry.entry_id, - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, ) - entity_reg.async_get_or_create( + entity_registry.async_get_or_create( DOMAIN, "test", "5678", @@ -426,9 +412,7 @@ async def test_capabilities( ("is_mode", "mode", {"type": "select", "options": []}), ], ) -async def test_capabilities_missing_entity( - hass, device_reg, entity_reg, condition, capability_name, extra -): +async def test_capabilities_missing_entity(hass, condition, capability_name, extra): """Test getting capabilities.""" config_entry = MockConfigEntry(domain="test", data={}) config_entry.add_to_hass(hass) diff --git a/tests/components/humidifier/test_device_trigger.py b/tests/components/humidifier/test_device_trigger.py index 5b1b6032355..a64d5330575 100644 --- a/tests/components/humidifier/test_device_trigger.py +++ b/tests/components/humidifier/test_device_trigger.py @@ -9,7 +9,7 @@ from homeassistant.components.device_automation import DeviceAutomationType from homeassistant.components.humidifier import DOMAIN, const, device_trigger from homeassistant.const import ATTR_MODE, ATTR_SUPPORTED_FEATURES, STATE_OFF, STATE_ON from homeassistant.core import HomeAssistant -from homeassistant.helpers import config_validation as cv, device_registry +from homeassistant.helpers import config_validation as cv, device_registry as dr from homeassistant.helpers.entity import EntityCategory from homeassistant.helpers.entity_registry import RegistryEntryHider from homeassistant.setup import async_setup_component @@ -21,39 +21,27 @@ from tests.common import ( async_fire_time_changed, async_get_device_automations, async_mock_service, - mock_device_registry, - mock_registry, ) from tests.components.blueprint.conftest import stub_blueprint_populate # noqa: F401 -@pytest.fixture -def device_reg(hass): - """Return an empty, loaded, registry.""" - return mock_device_registry(hass) - - -@pytest.fixture -def entity_reg(hass): - """Return an empty, loaded, registry.""" - return mock_registry(hass) - - @pytest.fixture def calls(hass): """Track calls to a mock service.""" return async_mock_service(hass, "test", "automation") -async def test_get_triggers(hass, device_reg, entity_reg): +async def test_get_triggers(hass, device_registry, entity_registry): """Test we get the expected triggers from a humidifier device.""" config_entry = MockConfigEntry(domain="test", data={}) config_entry.add_to_hass(hass) - device_entry = device_reg.async_get_or_create( + device_entry = device_registry.async_get_or_create( config_entry_id=config_entry.entry_id, - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + ) + entity_registry.async_get_or_create( + DOMAIN, "test", "5678", device_id=device_entry.id ) - entity_reg.async_get_or_create(DOMAIN, "test", "5678", device_id=device_entry.id) entity_id = f"{DOMAIN}.test_5678" hass.states.async_set( entity_id, @@ -98,19 +86,19 @@ async def test_get_triggers(hass, device_reg, entity_reg): ) async def test_get_triggers_hidden_auxiliary( hass, - device_reg, - entity_reg, + device_registry, + entity_registry, hidden_by, entity_category, ): """Test we get the expected triggers from a hidden or auxiliary entity.""" config_entry = MockConfigEntry(domain="test", data={}) config_entry.add_to_hass(hass) - device_entry = device_reg.async_get_or_create( + device_entry = device_registry.async_get_or_create( config_entry_id=config_entry.entry_id, - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, ) - entity_reg.async_get_or_create( + entity_registry.async_get_or_create( DOMAIN, "test", "5678", diff --git a/tests/components/light/test_device_action.py b/tests/components/light/test_device_action.py index fc330048dc4..ac74e76b186 100644 --- a/tests/components/light/test_device_action.py +++ b/tests/components/light/test_device_action.py @@ -12,7 +12,7 @@ from homeassistant.components.light import ( LightEntityFeature, ) from homeassistant.const import CONF_PLATFORM, STATE_OFF, STATE_ON -from homeassistant.helpers import device_registry +from homeassistant.helpers import device_registry as dr from homeassistant.helpers.entity import EntityCategory from homeassistant.helpers.entity_registry import RegistryEntryHider from homeassistant.setup import async_setup_component @@ -23,39 +23,25 @@ from tests.common import ( async_get_device_automation_capabilities, async_get_device_automations, async_mock_service, - mock_device_registry, - mock_registry, ) from tests.components.blueprint.conftest import stub_blueprint_populate # noqa: F401 -@pytest.fixture -def device_reg(hass): - """Return an empty, loaded, registry.""" - return mock_device_registry(hass) - - -@pytest.fixture -def entity_reg(hass): - """Return an empty, loaded, registry.""" - return mock_registry(hass) - - @pytest.fixture def calls(hass): """Track calls to a mock service.""" return async_mock_service(hass, "test", "automation") -async def test_get_actions(hass, device_reg, entity_reg): +async def test_get_actions(hass, device_registry, entity_registry): """Test we get the expected actions from a light.""" config_entry = MockConfigEntry(domain="test", data={}) config_entry.add_to_hass(hass) - device_entry = device_reg.async_get_or_create( + device_entry = device_registry.async_get_or_create( config_entry_id=config_entry.entry_id, - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, ) - entity_reg.async_get_or_create( + entity_registry.async_get_or_create( DOMAIN, "test", "5678", @@ -98,19 +84,19 @@ async def test_get_actions(hass, device_reg, entity_reg): ) async def test_get_actions_hidden_auxiliary( hass, - device_reg, - entity_reg, + device_registry, + entity_registry, hidden_by, entity_category, ): """Test we get the expected actions from a hidden or auxiliary entity.""" config_entry = MockConfigEntry(domain="test", data={}) config_entry.add_to_hass(hass) - device_entry = device_reg.async_get_or_create( + device_entry = device_registry.async_get_or_create( config_entry_id=config_entry.entry_id, - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, ) - entity_reg.async_get_or_create( + entity_registry.async_get_or_create( DOMAIN, "test", "5678", @@ -137,16 +123,16 @@ async def test_get_actions_hidden_auxiliary( assert_lists_same(actions, expected_actions) -async def test_get_action_capabilities(hass, device_reg, entity_reg): +async def test_get_action_capabilities(hass, device_registry, entity_registry): """Test we get the expected capabilities from a light action.""" config_entry = MockConfigEntry(domain="test", data={}) config_entry.add_to_hass(hass) - device_entry = device_reg.async_get_or_create( + device_entry = device_registry.async_get_or_create( config_entry_id=config_entry.entry_id, - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, ) # Test with entity without optional capabilities - entity_id = entity_reg.async_get_or_create( + entity_id = entity_registry.async_get_or_create( DOMAIN, "test", "5678", @@ -165,7 +151,7 @@ async def test_get_action_capabilities(hass, device_reg, entity_reg): assert capabilities == {"extra_fields": []} # Test without entity - entity_reg.async_remove(entity_id) + entity_registry.async_remove(entity_id) for action in actions: capabilities = await async_get_device_automation_capabilities( hass, DeviceAutomationType.ACTION, action @@ -266,8 +252,8 @@ async def test_get_action_capabilities(hass, device_reg, entity_reg): ) async def test_get_action_capabilities_features( hass, - device_reg, - entity_reg, + device_registry, + entity_registry, set_state, expected_actions, supported_features_reg, @@ -279,11 +265,11 @@ async def test_get_action_capabilities_features( """Test we get the expected capabilities from a light action.""" config_entry = MockConfigEntry(domain="test", data={}) config_entry.add_to_hass(hass) - device_entry = device_reg.async_get_or_create( + device_entry = device_registry.async_get_or_create( config_entry_id=config_entry.entry_id, - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, ) - entity_id = entity_reg.async_get_or_create( + entity_id = entity_registry.async_get_or_create( DOMAIN, "test", "5678", diff --git a/tests/components/light/test_device_condition.py b/tests/components/light/test_device_condition.py index 81e95f63771..dca9921a388 100644 --- a/tests/components/light/test_device_condition.py +++ b/tests/components/light/test_device_condition.py @@ -8,7 +8,7 @@ import homeassistant.components.automation as automation from homeassistant.components.device_automation import DeviceAutomationType from homeassistant.components.light import DOMAIN from homeassistant.const import CONF_PLATFORM, STATE_OFF, STATE_ON -from homeassistant.helpers import device_registry +from homeassistant.helpers import device_registry as dr from homeassistant.helpers.entity import EntityCategory from homeassistant.helpers.entity_registry import RegistryEntryHider from homeassistant.setup import async_setup_component @@ -20,39 +20,27 @@ from tests.common import ( async_get_device_automation_capabilities, async_get_device_automations, async_mock_service, - mock_device_registry, - mock_registry, ) from tests.components.blueprint.conftest import stub_blueprint_populate # noqa: F401 -@pytest.fixture -def device_reg(hass): - """Return an empty, loaded, registry.""" - return mock_device_registry(hass) - - -@pytest.fixture -def entity_reg(hass): - """Return an empty, loaded, registry.""" - return mock_registry(hass) - - @pytest.fixture def calls(hass): """Track calls to a mock service.""" return async_mock_service(hass, "test", "automation") -async def test_get_conditions(hass, device_reg, entity_reg): +async def test_get_conditions(hass, device_registry, entity_registry): """Test we get the expected conditions from a light.""" config_entry = MockConfigEntry(domain="test", data={}) config_entry.add_to_hass(hass) - device_entry = device_reg.async_get_or_create( + device_entry = device_registry.async_get_or_create( config_entry_id=config_entry.entry_id, - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + ) + entity_registry.async_get_or_create( + DOMAIN, "test", "5678", device_id=device_entry.id ) - entity_reg.async_get_or_create(DOMAIN, "test", "5678", device_id=device_entry.id) expected_conditions = [ { "condition": "device", @@ -81,19 +69,19 @@ async def test_get_conditions(hass, device_reg, entity_reg): ) async def test_get_conditions_hidden_auxiliary( hass, - device_reg, - entity_reg, + device_registry, + entity_registry, hidden_by, entity_category, ): """Test we get the expected conditions from a hidden or auxiliary entity.""" config_entry = MockConfigEntry(domain="test", data={}) config_entry.add_to_hass(hass) - device_entry = device_reg.async_get_or_create( + device_entry = device_registry.async_get_or_create( config_entry_id=config_entry.entry_id, - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, ) - entity_reg.async_get_or_create( + entity_registry.async_get_or_create( DOMAIN, "test", "5678", @@ -118,15 +106,17 @@ async def test_get_conditions_hidden_auxiliary( assert_lists_same(conditions, expected_conditions) -async def test_get_condition_capabilities(hass, device_reg, entity_reg): +async def test_get_condition_capabilities(hass, device_registry, entity_registry): """Test we get the expected capabilities from a light condition.""" config_entry = MockConfigEntry(domain="test", data={}) config_entry.add_to_hass(hass) - device_entry = device_reg.async_get_or_create( + device_entry = device_registry.async_get_or_create( config_entry_id=config_entry.entry_id, - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + ) + entity_registry.async_get_or_create( + DOMAIN, "test", "5678", device_id=device_entry.id ) - entity_reg.async_get_or_create(DOMAIN, "test", "5678", device_id=device_entry.id) expected_capabilities = { "extra_fields": [ {"name": "for", "optional": True, "type": "positive_time_period_dict"} diff --git a/tests/components/light/test_device_trigger.py b/tests/components/light/test_device_trigger.py index 6cedb51f661..dedeeaf467f 100644 --- a/tests/components/light/test_device_trigger.py +++ b/tests/components/light/test_device_trigger.py @@ -7,7 +7,7 @@ import homeassistant.components.automation as automation from homeassistant.components.device_automation import DeviceAutomationType from homeassistant.components.light import DOMAIN from homeassistant.const import CONF_PLATFORM, STATE_OFF, STATE_ON -from homeassistant.helpers import device_registry +from homeassistant.helpers import device_registry as dr from homeassistant.helpers.entity import EntityCategory from homeassistant.helpers.entity_registry import RegistryEntryHider from homeassistant.setup import async_setup_component @@ -20,39 +20,27 @@ from tests.common import ( async_get_device_automation_capabilities, async_get_device_automations, async_mock_service, - mock_device_registry, - mock_registry, ) from tests.components.blueprint.conftest import stub_blueprint_populate # noqa: F401 -@pytest.fixture -def device_reg(hass): - """Return an empty, loaded, registry.""" - return mock_device_registry(hass) - - -@pytest.fixture -def entity_reg(hass): - """Return an empty, loaded, registry.""" - return mock_registry(hass) - - @pytest.fixture def calls(hass): """Track calls to a mock service.""" return async_mock_service(hass, "test", "automation") -async def test_get_triggers(hass, device_reg, entity_reg): +async def test_get_triggers(hass, device_registry, entity_registry): """Test we get the expected triggers from a light.""" config_entry = MockConfigEntry(domain="test", data={}) config_entry.add_to_hass(hass) - device_entry = device_reg.async_get_or_create( + device_entry = device_registry.async_get_or_create( config_entry_id=config_entry.entry_id, - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + ) + entity_registry.async_get_or_create( + DOMAIN, "test", "5678", device_id=device_entry.id ) - entity_reg.async_get_or_create(DOMAIN, "test", "5678", device_id=device_entry.id) expected_triggers = [ { "platform": "device", @@ -81,19 +69,19 @@ async def test_get_triggers(hass, device_reg, entity_reg): ) async def test_get_triggers_hidden_auxiliary( hass, - device_reg, - entity_reg, + device_registry, + entity_registry, hidden_by, entity_category, ): """Test we get the expected triggers from a hidden or auxiliary entity.""" config_entry = MockConfigEntry(domain="test", data={}) config_entry.add_to_hass(hass) - device_entry = device_reg.async_get_or_create( + device_entry = device_registry.async_get_or_create( config_entry_id=config_entry.entry_id, - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, ) - entity_reg.async_get_or_create( + entity_registry.async_get_or_create( DOMAIN, "test", "5678", @@ -118,15 +106,17 @@ async def test_get_triggers_hidden_auxiliary( assert_lists_same(triggers, expected_triggers) -async def test_get_trigger_capabilities(hass, device_reg, entity_reg): +async def test_get_trigger_capabilities(hass, device_registry, entity_registry): """Test we get the expected capabilities from a light trigger.""" config_entry = MockConfigEntry(domain="test", data={}) config_entry.add_to_hass(hass) - device_entry = device_reg.async_get_or_create( + device_entry = device_registry.async_get_or_create( config_entry_id=config_entry.entry_id, - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + ) + entity_registry.async_get_or_create( + DOMAIN, "test", "5678", device_id=device_entry.id ) - entity_reg.async_get_or_create(DOMAIN, "test", "5678", device_id=device_entry.id) expected_capabilities = { "extra_fields": [ {"name": "for", "optional": True, "type": "positive_time_period_dict"} diff --git a/tests/components/lock/test_device_action.py b/tests/components/lock/test_device_action.py index d30ceec9fe1..6e5c132804e 100644 --- a/tests/components/lock/test_device_action.py +++ b/tests/components/lock/test_device_action.py @@ -5,7 +5,7 @@ import homeassistant.components.automation as automation from homeassistant.components.device_automation import DeviceAutomationType from homeassistant.components.lock import DOMAIN, LockEntityFeature from homeassistant.core import HomeAssistant -from homeassistant.helpers import device_registry +from homeassistant.helpers import device_registry as dr from homeassistant.helpers.entity import EntityCategory from homeassistant.helpers.entity_registry import RegistryEntryHider from homeassistant.setup import async_setup_component @@ -15,24 +15,10 @@ from tests.common import ( assert_lists_same, async_get_device_automations, async_mock_service, - mock_device_registry, - mock_registry, ) from tests.components.blueprint.conftest import stub_blueprint_populate # noqa: F401 -@pytest.fixture -def device_reg(hass): - """Return an empty, loaded, registry.""" - return mock_device_registry(hass) - - -@pytest.fixture -def entity_reg(hass): - """Return an empty, loaded, registry.""" - return mock_registry(hass) - - @pytest.mark.parametrize( "set_state,features_reg,features_state,expected_action_types", [ @@ -44,8 +30,8 @@ def entity_reg(hass): ) async def test_get_actions( hass, - device_reg, - entity_reg, + device_registry, + entity_registry, set_state, features_reg, features_state, @@ -54,11 +40,11 @@ async def test_get_actions( """Test we get the expected actions from a lock.""" config_entry = MockConfigEntry(domain="test", data={}) config_entry.add_to_hass(hass) - device_entry = device_reg.async_get_or_create( + device_entry = device_registry.async_get_or_create( config_entry_id=config_entry.entry_id, - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, ) - entity_reg.async_get_or_create( + entity_registry.async_get_or_create( DOMAIN, "test", "5678", @@ -108,19 +94,19 @@ async def test_get_actions( ) async def test_get_actions_hidden_auxiliary( hass, - device_reg, - entity_reg, + device_registry, + entity_registry, hidden_by, entity_category, ): """Test we get the expected actions from a hidden or auxiliary entity.""" config_entry = MockConfigEntry(domain="test", data={}) config_entry.add_to_hass(hass) - device_entry = device_reg.async_get_or_create( + device_entry = device_registry.async_get_or_create( config_entry_id=config_entry.entry_id, - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, ) - entity_reg.async_get_or_create( + entity_registry.async_get_or_create( DOMAIN, "test", "5678", diff --git a/tests/components/lock/test_device_condition.py b/tests/components/lock/test_device_condition.py index c932b390e90..a168a53b797 100644 --- a/tests/components/lock/test_device_condition.py +++ b/tests/components/lock/test_device_condition.py @@ -11,7 +11,7 @@ from homeassistant.const import ( STATE_UNLOCKED, STATE_UNLOCKING, ) -from homeassistant.helpers import device_registry +from homeassistant.helpers import device_registry as dr from homeassistant.helpers.entity import EntityCategory from homeassistant.helpers.entity_registry import RegistryEntryHider from homeassistant.setup import async_setup_component @@ -21,39 +21,27 @@ from tests.common import ( assert_lists_same, async_get_device_automations, async_mock_service, - mock_device_registry, - mock_registry, ) from tests.components.blueprint.conftest import stub_blueprint_populate # noqa: F401 -@pytest.fixture -def device_reg(hass): - """Return an empty, loaded, registry.""" - return mock_device_registry(hass) - - -@pytest.fixture -def entity_reg(hass): - """Return an empty, loaded, registry.""" - return mock_registry(hass) - - @pytest.fixture def calls(hass): """Track calls to a mock service.""" return async_mock_service(hass, "test", "automation") -async def test_get_conditions(hass, device_reg, entity_reg): +async def test_get_conditions(hass, device_registry, entity_registry): """Test we get the expected conditions from a lock.""" config_entry = MockConfigEntry(domain="test", data={}) config_entry.add_to_hass(hass) - device_entry = device_reg.async_get_or_create( + device_entry = device_registry.async_get_or_create( config_entry_id=config_entry.entry_id, - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + ) + entity_registry.async_get_or_create( + DOMAIN, "test", "5678", device_id=device_entry.id ) - entity_reg.async_get_or_create(DOMAIN, "test", "5678", device_id=device_entry.id) expected_conditions = [ { "condition": "device", @@ -88,19 +76,19 @@ async def test_get_conditions(hass, device_reg, entity_reg): ) async def test_get_conditions_hidden_auxiliary( hass, - device_reg, - entity_reg, + device_registry, + entity_registry, hidden_by, entity_category, ): """Test we get the expected conditions from a hidden or auxiliary entity.""" config_entry = MockConfigEntry(domain="test", data={}) config_entry.add_to_hass(hass) - device_entry = device_reg.async_get_or_create( + device_entry = device_registry.async_get_or_create( config_entry_id=config_entry.entry_id, - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, ) - entity_reg.async_get_or_create( + entity_registry.async_get_or_create( DOMAIN, "test", "5678", diff --git a/tests/components/lock/test_device_trigger.py b/tests/components/lock/test_device_trigger.py index adca33f493b..1e2d5169001 100644 --- a/tests/components/lock/test_device_trigger.py +++ b/tests/components/lock/test_device_trigger.py @@ -13,7 +13,7 @@ from homeassistant.const import ( STATE_UNLOCKED, STATE_UNLOCKING, ) -from homeassistant.helpers import device_registry +from homeassistant.helpers import device_registry as dr from homeassistant.helpers.entity import EntityCategory from homeassistant.helpers.entity_registry import RegistryEntryHider from homeassistant.setup import async_setup_component @@ -26,39 +26,27 @@ from tests.common import ( async_get_device_automation_capabilities, async_get_device_automations, async_mock_service, - mock_device_registry, - mock_registry, ) from tests.components.blueprint.conftest import stub_blueprint_populate # noqa: F401 -@pytest.fixture -def device_reg(hass): - """Return an empty, loaded, registry.""" - return mock_device_registry(hass) - - -@pytest.fixture -def entity_reg(hass): - """Return an empty, loaded, registry.""" - return mock_registry(hass) - - @pytest.fixture def calls(hass): """Track calls to a mock service.""" return async_mock_service(hass, "test", "automation") -async def test_get_triggers(hass, device_reg, entity_reg): +async def test_get_triggers(hass, device_registry, entity_registry): """Test we get the expected triggers from a lock.""" config_entry = MockConfigEntry(domain="test", data={}) config_entry.add_to_hass(hass) - device_entry = device_reg.async_get_or_create( + device_entry = device_registry.async_get_or_create( config_entry_id=config_entry.entry_id, - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + ) + entity_registry.async_get_or_create( + DOMAIN, "test", "5678", device_id=device_entry.id ) - entity_reg.async_get_or_create(DOMAIN, "test", "5678", device_id=device_entry.id) expected_triggers = [ { "platform": "device", @@ -87,19 +75,19 @@ async def test_get_triggers(hass, device_reg, entity_reg): ) async def test_get_triggers_hidden_auxiliary( hass, - device_reg, - entity_reg, + device_registry, + entity_registry, hidden_by, entity_category, ): """Test we get the expected triggers from a hidden or auxiliary entity.""" config_entry = MockConfigEntry(domain="test", data={}) config_entry.add_to_hass(hass) - device_entry = device_reg.async_get_or_create( + device_entry = device_registry.async_get_or_create( config_entry_id=config_entry.entry_id, - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, ) - entity_reg.async_get_or_create( + entity_registry.async_get_or_create( DOMAIN, "test", "5678", @@ -124,15 +112,17 @@ async def test_get_triggers_hidden_auxiliary( assert_lists_same(triggers, expected_triggers) -async def test_get_trigger_capabilities(hass, device_reg, entity_reg): +async def test_get_trigger_capabilities(hass, device_registry, entity_registry): """Test we get the expected capabilities from a lock.""" config_entry = MockConfigEntry(domain="test", data={}) config_entry.add_to_hass(hass) - device_entry = device_reg.async_get_or_create( + device_entry = device_registry.async_get_or_create( config_entry_id=config_entry.entry_id, - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + ) + entity_registry.async_get_or_create( + DOMAIN, "test", "5678", device_id=device_entry.id ) - entity_reg.async_get_or_create(DOMAIN, "test", "5678", device_id=device_entry.id) triggers = await async_get_device_automations( hass, DeviceAutomationType.TRIGGER, device_entry.id diff --git a/tests/components/media_player/test_device_condition.py b/tests/components/media_player/test_device_condition.py index 7556c2476da..94170bf63cf 100644 --- a/tests/components/media_player/test_device_condition.py +++ b/tests/components/media_player/test_device_condition.py @@ -12,7 +12,7 @@ from homeassistant.const import ( STATE_PAUSED, STATE_PLAYING, ) -from homeassistant.helpers import device_registry +from homeassistant.helpers import device_registry as dr from homeassistant.helpers.entity import EntityCategory from homeassistant.helpers.entity_registry import RegistryEntryHider from homeassistant.setup import async_setup_component @@ -22,39 +22,27 @@ from tests.common import ( assert_lists_same, async_get_device_automations, async_mock_service, - mock_device_registry, - mock_registry, ) from tests.components.blueprint.conftest import stub_blueprint_populate # noqa: F401 -@pytest.fixture -def device_reg(hass): - """Return an empty, loaded, registry.""" - return mock_device_registry(hass) - - -@pytest.fixture -def entity_reg(hass): - """Return an empty, loaded, registry.""" - return mock_registry(hass) - - @pytest.fixture def calls(hass): """Track calls to a mock service.""" return async_mock_service(hass, "test", "automation") -async def test_get_conditions(hass, device_reg, entity_reg): +async def test_get_conditions(hass, device_registry, entity_registry): """Test we get the expected conditions from a media_player.""" config_entry = MockConfigEntry(domain="test", data={}) config_entry.add_to_hass(hass) - device_entry = device_reg.async_get_or_create( + device_entry = device_registry.async_get_or_create( config_entry_id=config_entry.entry_id, - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + ) + entity_registry.async_get_or_create( + DOMAIN, "test", "5678", device_id=device_entry.id ) - entity_reg.async_get_or_create(DOMAIN, "test", "5678", device_id=device_entry.id) expected_conditions = [ { "condition": "device", @@ -90,19 +78,19 @@ async def test_get_conditions(hass, device_reg, entity_reg): ) async def test_get_conditions_hidden_auxiliary( hass, - device_reg, - entity_reg, + device_registry, + entity_registry, hidden_by, entity_category, ): """Test we get the expected conditions from a hidden or auxiliary entity.""" config_entry = MockConfigEntry(domain="test", data={}) config_entry.add_to_hass(hass) - device_entry = device_reg.async_get_or_create( + device_entry = device_registry.async_get_or_create( config_entry_id=config_entry.entry_id, - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, ) - entity_reg.async_get_or_create( + entity_registry.async_get_or_create( DOMAIN, "test", "5678", diff --git a/tests/components/media_player/test_device_trigger.py b/tests/components/media_player/test_device_trigger.py index 5559369645c..2f1df5f75d3 100644 --- a/tests/components/media_player/test_device_trigger.py +++ b/tests/components/media_player/test_device_trigger.py @@ -14,7 +14,7 @@ from homeassistant.const import ( STATE_PAUSED, STATE_PLAYING, ) -from homeassistant.helpers import device_registry +from homeassistant.helpers import device_registry as dr from homeassistant.helpers.entity import EntityCategory from homeassistant.helpers.entity_registry import RegistryEntryHider from homeassistant.setup import async_setup_component @@ -27,39 +27,27 @@ from tests.common import ( async_get_device_automation_capabilities, async_get_device_automations, async_mock_service, - mock_device_registry, - mock_registry, ) from tests.components.blueprint.conftest import stub_blueprint_populate # noqa: F401 -@pytest.fixture -def device_reg(hass): - """Return an empty, loaded, registry.""" - return mock_device_registry(hass) - - -@pytest.fixture -def entity_reg(hass): - """Return an empty, loaded, registry.""" - return mock_registry(hass) - - @pytest.fixture def calls(hass): """Track calls to a mock service.""" return async_mock_service(hass, "test", "automation") -async def test_get_triggers(hass, device_reg, entity_reg): +async def test_get_triggers(hass, device_registry, entity_registry): """Test we get the expected triggers from a media player.""" config_entry = MockConfigEntry(domain="test", data={}) config_entry.add_to_hass(hass) - device_entry = device_reg.async_get_or_create( + device_entry = device_registry.async_get_or_create( config_entry_id=config_entry.entry_id, - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + ) + entity_registry.async_get_or_create( + DOMAIN, "test", "5678", device_id=device_entry.id ) - entity_reg.async_get_or_create(DOMAIN, "test", "5678", device_id=device_entry.id) trigger_types = { "buffering", @@ -98,19 +86,19 @@ async def test_get_triggers(hass, device_reg, entity_reg): ) async def test_get_triggers_hidden_auxiliary( hass, - device_reg, - entity_reg, + device_registry, + entity_registry, hidden_by, entity_category, ): """Test we get the expected triggers from a hidden or auxiliary entity.""" config_entry = MockConfigEntry(domain="test", data={}) config_entry.add_to_hass(hass) - device_entry = device_reg.async_get_or_create( + device_entry = device_registry.async_get_or_create( config_entry_id=config_entry.entry_id, - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, ) - entity_reg.async_get_or_create( + entity_registry.async_get_or_create( DOMAIN, "test", "5678", @@ -143,15 +131,17 @@ async def test_get_triggers_hidden_auxiliary( assert_lists_same(triggers, expected_triggers) -async def test_get_trigger_capabilities(hass, device_reg, entity_reg): +async def test_get_trigger_capabilities(hass, device_registry, entity_registry): """Test we get the expected capabilities from a media player.""" config_entry = MockConfigEntry(domain="test", data={}) config_entry.add_to_hass(hass) - device_entry = device_reg.async_get_or_create( + device_entry = device_registry.async_get_or_create( config_entry_id=config_entry.entry_id, - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + ) + entity_registry.async_get_or_create( + DOMAIN, "test", "5678", device_id=device_entry.id ) - entity_reg.async_get_or_create(DOMAIN, "test", "5678", device_id=device_entry.id) triggers = await async_get_device_automations( hass, DeviceAutomationType.TRIGGER, device_entry.id diff --git a/tests/components/number/test_device_action.py b/tests/components/number/test_device_action.py index e5edde221e7..d3780475f1b 100644 --- a/tests/components/number/test_device_action.py +++ b/tests/components/number/test_device_action.py @@ -6,7 +6,7 @@ import homeassistant.components.automation as automation from homeassistant.components.device_automation import DeviceAutomationType from homeassistant.components.number import DOMAIN, device_action from homeassistant.core import HomeAssistant -from homeassistant.helpers import config_validation as cv, device_registry +from homeassistant.helpers import config_validation as cv, device_registry as dr from homeassistant.helpers.entity import EntityCategory from homeassistant.helpers.entity_registry import RegistryEntryHider from homeassistant.setup import async_setup_component @@ -16,33 +16,21 @@ from tests.common import ( assert_lists_same, async_get_device_automations, async_mock_service, - mock_device_registry, - mock_registry, ) from tests.components.blueprint.conftest import stub_blueprint_populate # noqa: F401 -@pytest.fixture -def device_reg(hass): - """Return an empty, loaded, registry.""" - return mock_device_registry(hass) - - -@pytest.fixture -def entity_reg(hass): - """Return an empty, loaded, registry.""" - return mock_registry(hass) - - -async def test_get_actions(hass, device_reg, entity_reg): +async def test_get_actions(hass, device_registry, entity_registry): """Test we get the expected actions for an entity.""" config_entry = MockConfigEntry(domain="test", data={}) config_entry.add_to_hass(hass) - device_entry = device_reg.async_get_or_create( + device_entry = device_registry.async_get_or_create( config_entry_id=config_entry.entry_id, - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + ) + entity_registry.async_get_or_create( + DOMAIN, "test", "5678", device_id=device_entry.id ) - entity_reg.async_get_or_create(DOMAIN, "test", "5678", device_id=device_entry.id) hass.states.async_set("number.test_5678", 0.5, {"min_value": 0.0, "max_value": 1.0}) expected_actions = [ { @@ -70,19 +58,19 @@ async def test_get_actions(hass, device_reg, entity_reg): ) async def test_get_actions_hidden_auxiliary( hass, - device_reg, - entity_reg, + device_registry, + entity_registry, hidden_by, entity_category, ): """Test we get the expected actions from a hidden or auxiliary entity.""" config_entry = MockConfigEntry(domain="test", data={}) config_entry.add_to_hass(hass) - device_entry = device_reg.async_get_or_create( + device_entry = device_registry.async_get_or_create( config_entry_id=config_entry.entry_id, - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, ) - entity_reg.async_get_or_create( + entity_registry.async_get_or_create( DOMAIN, "test", "5678", @@ -107,15 +95,17 @@ async def test_get_actions_hidden_auxiliary( assert_lists_same(actions, expected_actions) -async def test_get_action_no_state(hass, device_reg, entity_reg): +async def test_get_action_no_state(hass, device_registry, entity_registry): """Test we get the expected actions for an entity.""" config_entry = MockConfigEntry(domain="test", data={}) config_entry.add_to_hass(hass) - device_entry = device_reg.async_get_or_create( + device_entry = device_registry.async_get_or_create( config_entry_id=config_entry.entry_id, - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + ) + entity_registry.async_get_or_create( + DOMAIN, "test", "5678", device_id=device_entry.id ) - entity_reg.async_get_or_create(DOMAIN, "test", "5678", device_id=device_entry.id) expected_actions = [ { "domain": DOMAIN, diff --git a/tests/components/remote/test_device_action.py b/tests/components/remote/test_device_action.py index 57cf92d5728..b540a8b7753 100644 --- a/tests/components/remote/test_device_action.py +++ b/tests/components/remote/test_device_action.py @@ -5,7 +5,7 @@ import homeassistant.components.automation as automation from homeassistant.components.device_automation import DeviceAutomationType from homeassistant.components.remote import DOMAIN from homeassistant.const import CONF_PLATFORM, STATE_OFF, STATE_ON -from homeassistant.helpers import device_registry +from homeassistant.helpers import device_registry as dr from homeassistant.helpers.entity import EntityCategory from homeassistant.helpers.entity_registry import RegistryEntryHider from homeassistant.setup import async_setup_component @@ -15,39 +15,27 @@ from tests.common import ( assert_lists_same, async_get_device_automations, async_mock_service, - mock_device_registry, - mock_registry, ) from tests.components.blueprint.conftest import stub_blueprint_populate # noqa: F401 -@pytest.fixture -def device_reg(hass): - """Return an empty, loaded, registry.""" - return mock_device_registry(hass) - - -@pytest.fixture -def entity_reg(hass): - """Return an empty, loaded, registry.""" - return mock_registry(hass) - - @pytest.fixture def calls(hass): """Track calls to a mock service.""" return async_mock_service(hass, "test", "automation") -async def test_get_actions(hass, device_reg, entity_reg): +async def test_get_actions(hass, device_registry, entity_registry): """Test we get the expected actions from a remote.""" config_entry = MockConfigEntry(domain="test", data={}) config_entry.add_to_hass(hass) - device_entry = device_reg.async_get_or_create( + device_entry = device_registry.async_get_or_create( config_entry_id=config_entry.entry_id, - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + ) + entity_registry.async_get_or_create( + DOMAIN, "test", "5678", device_id=device_entry.id ) - entity_reg.async_get_or_create(DOMAIN, "test", "5678", device_id=device_entry.id) expected_actions = [ { "domain": DOMAIN, @@ -75,19 +63,19 @@ async def test_get_actions(hass, device_reg, entity_reg): ) async def test_get_actions_hidden_auxiliary( hass, - device_reg, - entity_reg, + device_registry, + entity_registry, hidden_by, entity_category, ): """Test we get the expected actions from a hidden or auxiliary entity.""" config_entry = MockConfigEntry(domain="test", data={}) config_entry.add_to_hass(hass) - device_entry = device_reg.async_get_or_create( + device_entry = device_registry.async_get_or_create( config_entry_id=config_entry.entry_id, - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, ) - entity_reg.async_get_or_create( + entity_registry.async_get_or_create( DOMAIN, "test", "5678", diff --git a/tests/components/remote/test_device_condition.py b/tests/components/remote/test_device_condition.py index b993ccd0f74..8c318ffe7eb 100644 --- a/tests/components/remote/test_device_condition.py +++ b/tests/components/remote/test_device_condition.py @@ -8,7 +8,7 @@ import homeassistant.components.automation as automation from homeassistant.components.device_automation import DeviceAutomationType from homeassistant.components.remote import DOMAIN from homeassistant.const import CONF_PLATFORM, STATE_OFF, STATE_ON -from homeassistant.helpers import device_registry +from homeassistant.helpers import device_registry as dr from homeassistant.helpers.entity import EntityCategory from homeassistant.helpers.entity_registry import RegistryEntryHider from homeassistant.setup import async_setup_component @@ -20,39 +20,27 @@ from tests.common import ( async_get_device_automation_capabilities, async_get_device_automations, async_mock_service, - mock_device_registry, - mock_registry, ) from tests.components.blueprint.conftest import stub_blueprint_populate # noqa: F401 -@pytest.fixture -def device_reg(hass): - """Return an empty, loaded, registry.""" - return mock_device_registry(hass) - - -@pytest.fixture -def entity_reg(hass): - """Return an empty, loaded, registry.""" - return mock_registry(hass) - - @pytest.fixture def calls(hass): """Track calls to a mock service.""" return async_mock_service(hass, "test", "automation") -async def test_get_conditions(hass, device_reg, entity_reg): +async def test_get_conditions(hass, device_registry, entity_registry): """Test we get the expected conditions from a remote.""" config_entry = MockConfigEntry(domain="test", data={}) config_entry.add_to_hass(hass) - device_entry = device_reg.async_get_or_create( + device_entry = device_registry.async_get_or_create( config_entry_id=config_entry.entry_id, - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + ) + entity_registry.async_get_or_create( + DOMAIN, "test", "5678", device_id=device_entry.id ) - entity_reg.async_get_or_create(DOMAIN, "test", "5678", device_id=device_entry.id) expected_conditions = [ { "condition": "device", @@ -81,19 +69,19 @@ async def test_get_conditions(hass, device_reg, entity_reg): ) async def test_get_conditions_hidden_auxiliary( hass, - device_reg, - entity_reg, + device_registry, + entity_registry, hidden_by, entity_category, ): """Test we get the expected conditions from a hidden or auxiliary entity.""" config_entry = MockConfigEntry(domain="test", data={}) config_entry.add_to_hass(hass) - device_entry = device_reg.async_get_or_create( + device_entry = device_registry.async_get_or_create( config_entry_id=config_entry.entry_id, - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, ) - entity_reg.async_get_or_create( + entity_registry.async_get_or_create( DOMAIN, "test", "5678", @@ -118,15 +106,17 @@ async def test_get_conditions_hidden_auxiliary( assert_lists_same(conditions, expected_conditions) -async def test_get_condition_capabilities(hass, device_reg, entity_reg): +async def test_get_condition_capabilities(hass, device_registry, entity_registry): """Test we get the expected capabilities from a remote condition.""" config_entry = MockConfigEntry(domain="test", data={}) config_entry.add_to_hass(hass) - device_entry = device_reg.async_get_or_create( + device_entry = device_registry.async_get_or_create( config_entry_id=config_entry.entry_id, - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + ) + entity_registry.async_get_or_create( + DOMAIN, "test", "5678", device_id=device_entry.id ) - entity_reg.async_get_or_create(DOMAIN, "test", "5678", device_id=device_entry.id) expected_capabilities = { "extra_fields": [ {"name": "for", "optional": True, "type": "positive_time_period_dict"} diff --git a/tests/components/remote/test_device_trigger.py b/tests/components/remote/test_device_trigger.py index 4512c2467e2..dea93b4f20c 100644 --- a/tests/components/remote/test_device_trigger.py +++ b/tests/components/remote/test_device_trigger.py @@ -7,7 +7,7 @@ import homeassistant.components.automation as automation from homeassistant.components.device_automation import DeviceAutomationType from homeassistant.components.remote import DOMAIN from homeassistant.const import CONF_PLATFORM, STATE_OFF, STATE_ON -from homeassistant.helpers import device_registry +from homeassistant.helpers import device_registry as dr from homeassistant.helpers.entity import EntityCategory from homeassistant.helpers.entity_registry import RegistryEntryHider from homeassistant.setup import async_setup_component @@ -20,39 +20,27 @@ from tests.common import ( async_get_device_automation_capabilities, async_get_device_automations, async_mock_service, - mock_device_registry, - mock_registry, ) from tests.components.blueprint.conftest import stub_blueprint_populate # noqa: F401 -@pytest.fixture -def device_reg(hass): - """Return an empty, loaded, registry.""" - return mock_device_registry(hass) - - -@pytest.fixture -def entity_reg(hass): - """Return an empty, loaded, registry.""" - return mock_registry(hass) - - @pytest.fixture def calls(hass): """Track calls to a mock service.""" return async_mock_service(hass, "test", "automation") -async def test_get_triggers(hass, device_reg, entity_reg): +async def test_get_triggers(hass, device_registry, entity_registry): """Test we get the expected triggers from a remote.""" config_entry = MockConfigEntry(domain="test", data={}) config_entry.add_to_hass(hass) - device_entry = device_reg.async_get_or_create( + device_entry = device_registry.async_get_or_create( config_entry_id=config_entry.entry_id, - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + ) + entity_registry.async_get_or_create( + DOMAIN, "test", "5678", device_id=device_entry.id ) - entity_reg.async_get_or_create(DOMAIN, "test", "5678", device_id=device_entry.id) expected_triggers = [ { "platform": "device", @@ -81,19 +69,19 @@ async def test_get_triggers(hass, device_reg, entity_reg): ) async def test_get_triggers_hidden_auxiliary( hass, - device_reg, - entity_reg, + device_registry, + entity_registry, hidden_by, entity_category, ): """Test we get the expected triggers from a hidden or auxiliary entity.""" config_entry = MockConfigEntry(domain="test", data={}) config_entry.add_to_hass(hass) - device_entry = device_reg.async_get_or_create( + device_entry = device_registry.async_get_or_create( config_entry_id=config_entry.entry_id, - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, ) - entity_reg.async_get_or_create( + entity_registry.async_get_or_create( DOMAIN, "test", "5678", @@ -118,15 +106,17 @@ async def test_get_triggers_hidden_auxiliary( assert_lists_same(triggers, expected_triggers) -async def test_get_trigger_capabilities(hass, device_reg, entity_reg): +async def test_get_trigger_capabilities(hass, device_registry, entity_registry): """Test we get the expected capabilities from a remote trigger.""" config_entry = MockConfigEntry(domain="test", data={}) config_entry.add_to_hass(hass) - device_entry = device_reg.async_get_or_create( + device_entry = device_registry.async_get_or_create( config_entry_id=config_entry.entry_id, - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + ) + entity_registry.async_get_or_create( + DOMAIN, "test", "5678", device_id=device_entry.id ) - entity_reg.async_get_or_create(DOMAIN, "test", "5678", device_id=device_entry.id) expected_capabilities = { "extra_fields": [ {"name": "for", "optional": True, "type": "positive_time_period_dict"} diff --git a/tests/components/select/test_device_action.py b/tests/components/select/test_device_action.py index fcefa56e48e..1a245c26cad 100644 --- a/tests/components/select/test_device_action.py +++ b/tests/components/select/test_device_action.py @@ -9,8 +9,8 @@ from homeassistant.components.select.device_action import async_get_action_capab from homeassistant.core import HomeAssistant from homeassistant.helpers import ( config_validation as cv, - device_registry, - entity_registry, + device_registry as dr, + entity_registry as er, ) from homeassistant.helpers.entity import EntityCategory from homeassistant.setup import async_setup_component @@ -20,36 +20,24 @@ from tests.common import ( assert_lists_same, async_get_device_automations, async_mock_service, - mock_device_registry, - mock_registry, ) -@pytest.fixture -def device_reg(hass: HomeAssistant) -> device_registry.DeviceRegistry: - """Return an empty, loaded, registry.""" - return mock_device_registry(hass) - - -@pytest.fixture -def entity_reg(hass: HomeAssistant) -> entity_registry.EntityRegistry: - """Return an empty, loaded, registry.""" - return mock_registry(hass) - - async def test_get_actions( hass: HomeAssistant, - device_reg: device_registry.DeviceRegistry, - entity_reg: entity_registry.EntityRegistry, + device_registry: dr.DeviceRegistry, + entity_registry: er.EntityRegistry, ) -> None: """Test we get the expected actions from a select.""" config_entry = MockConfigEntry(domain="test", data={}) config_entry.add_to_hass(hass) - device_entry = device_reg.async_get_or_create( + device_entry = device_registry.async_get_or_create( config_entry_id=config_entry.entry_id, - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + ) + entity_registry.async_get_or_create( + DOMAIN, "test", "5678", device_id=device_entry.id ) - entity_reg.async_get_or_create(DOMAIN, "test", "5678", device_id=device_entry.id) expected_actions = [ { "domain": DOMAIN, @@ -75,27 +63,27 @@ async def test_get_actions( @pytest.mark.parametrize( "hidden_by,entity_category", ( - (entity_registry.RegistryEntryHider.INTEGRATION, None), - (entity_registry.RegistryEntryHider.USER, None), + (er.RegistryEntryHider.INTEGRATION, None), + (er.RegistryEntryHider.USER, None), (None, EntityCategory.CONFIG), (None, EntityCategory.DIAGNOSTIC), ), ) async def test_get_actions_hidden_auxiliary( hass, - device_reg, - entity_reg, + device_registry, + entity_registry, hidden_by, entity_category, ): """Test we get the expected actions from a hidden or auxiliary entity.""" config_entry = MockConfigEntry(domain="test", data={}) config_entry.add_to_hass(hass) - device_entry = device_reg.async_get_or_create( + device_entry = device_registry.async_get_or_create( config_entry_id=config_entry.entry_id, - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, ) - entity_reg.async_get_or_create( + entity_registry.async_get_or_create( DOMAIN, "test", "5678", diff --git a/tests/components/select/test_device_condition.py b/tests/components/select/test_device_condition.py index 7c1dc443e56..fe511d6a592 100644 --- a/tests/components/select/test_device_condition.py +++ b/tests/components/select/test_device_condition.py @@ -13,8 +13,8 @@ from homeassistant.components.select.device_condition import ( from homeassistant.core import HomeAssistant, ServiceCall from homeassistant.helpers import ( config_validation as cv, - device_registry, - entity_registry, + device_registry as dr, + entity_registry as er, ) from homeassistant.helpers.entity import EntityCategory from homeassistant.setup import async_setup_component @@ -24,23 +24,9 @@ from tests.common import ( assert_lists_same, async_get_device_automations, async_mock_service, - mock_device_registry, - mock_registry, ) -@pytest.fixture -def device_reg(hass: HomeAssistant) -> device_registry.DeviceRegistry: - """Return an empty, loaded, registry.""" - return mock_device_registry(hass) - - -@pytest.fixture -def entity_reg(hass: HomeAssistant) -> entity_registry.EntityRegistry: - """Return an empty, loaded, registry.""" - return mock_registry(hass) - - @pytest.fixture def calls(hass: HomeAssistant) -> list[ServiceCall]: """Track calls to a mock service.""" @@ -49,17 +35,19 @@ def calls(hass: HomeAssistant) -> list[ServiceCall]: async def test_get_conditions( hass: HomeAssistant, - device_reg: device_registry.DeviceRegistry, - entity_reg: entity_registry.EntityRegistry, + device_registry: dr.DeviceRegistry, + entity_registry: er.EntityRegistry, ) -> None: """Test we get the expected conditions from a select.""" config_entry = MockConfigEntry(domain="test", data={}) config_entry.add_to_hass(hass) - device_entry = device_reg.async_get_or_create( + device_entry = device_registry.async_get_or_create( config_entry_id=config_entry.entry_id, - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + ) + entity_registry.async_get_or_create( + DOMAIN, "test", "5678", device_id=device_entry.id ) - entity_reg.async_get_or_create(DOMAIN, "test", "5678", device_id=device_entry.id) expected_conditions = [ { "condition": "device", @@ -79,27 +67,27 @@ async def test_get_conditions( @pytest.mark.parametrize( "hidden_by,entity_category", ( - (entity_registry.RegistryEntryHider.INTEGRATION, None), - (entity_registry.RegistryEntryHider.USER, None), + (er.RegistryEntryHider.INTEGRATION, None), + (er.RegistryEntryHider.USER, None), (None, EntityCategory.CONFIG), (None, EntityCategory.DIAGNOSTIC), ), ) async def test_get_conditions_hidden_auxiliary( hass, - device_reg, - entity_reg, + device_registry, + entity_registry, hidden_by, entity_category, ): """Test we get the expected conditions from a hidden or auxiliary entity.""" config_entry = MockConfigEntry(domain="test", data={}) config_entry.add_to_hass(hass) - device_entry = device_reg.async_get_or_create( + device_entry = device_registry.async_get_or_create( config_entry_id=config_entry.entry_id, - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, ) - entity_reg.async_get_or_create( + entity_registry.async_get_or_create( DOMAIN, "test", "5678", diff --git a/tests/components/select/test_device_trigger.py b/tests/components/select/test_device_trigger.py index 09471068429..76a5faabf9c 100644 --- a/tests/components/select/test_device_trigger.py +++ b/tests/components/select/test_device_trigger.py @@ -11,7 +11,7 @@ from homeassistant.components.select.device_trigger import ( async_get_trigger_capabilities, ) from homeassistant.core import HomeAssistant, ServiceCall -from homeassistant.helpers import config_validation as cv, device_registry +from homeassistant.helpers import config_validation as cv, device_registry as dr from homeassistant.helpers.entity import EntityCategory from homeassistant.helpers.entity_registry import EntityRegistry, RegistryEntryHider from homeassistant.setup import async_setup_component @@ -21,23 +21,9 @@ from tests.common import ( assert_lists_same, async_get_device_automations, async_mock_service, - mock_device_registry, - mock_registry, ) -@pytest.fixture -def device_reg(hass: HomeAssistant) -> device_registry.DeviceRegistry: - """Return an empty, loaded, registry.""" - return mock_device_registry(hass) - - -@pytest.fixture -def entity_reg(hass: HomeAssistant) -> EntityRegistry: - """Return an empty, loaded, registry.""" - return mock_registry(hass) - - @pytest.fixture def calls(hass: HomeAssistant) -> list[ServiceCall]: """Track calls to a mock service.""" @@ -46,17 +32,19 @@ def calls(hass: HomeAssistant) -> list[ServiceCall]: async def test_get_triggers( hass: HomeAssistant, - device_reg: device_registry.DeviceRegistry, - entity_reg: EntityRegistry, + device_registry: dr.DeviceRegistry, + entity_registry: EntityRegistry, ) -> None: """Test we get the expected triggers from a select.""" config_entry = MockConfigEntry(domain="test", data={}) config_entry.add_to_hass(hass) - device_entry = device_reg.async_get_or_create( + device_entry = device_registry.async_get_or_create( config_entry_id=config_entry.entry_id, - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + ) + entity_registry.async_get_or_create( + DOMAIN, "test", "5678", device_id=device_entry.id ) - entity_reg.async_get_or_create(DOMAIN, "test", "5678", device_id=device_entry.id) expected_triggers = [ { "platform": "device", @@ -84,19 +72,19 @@ async def test_get_triggers( ) async def test_get_triggers_hidden_auxiliary( hass, - device_reg, - entity_reg, + device_registry, + entity_registry, hidden_by, entity_category, ): """Test we get the expected triggers from a hidden or auxiliary entity.""" config_entry = MockConfigEntry(domain="test", data={}) config_entry.add_to_hass(hass) - device_entry = device_reg.async_get_or_create( + device_entry = device_registry.async_get_or_create( config_entry_id=config_entry.entry_id, - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, ) - entity_reg.async_get_or_create( + entity_registry.async_get_or_create( DOMAIN, "test", "5678", diff --git a/tests/components/sensor/test_device_condition.py b/tests/components/sensor/test_device_condition.py index de0aa61b994..9e7660c7085 100644 --- a/tests/components/sensor/test_device_condition.py +++ b/tests/components/sensor/test_device_condition.py @@ -11,7 +11,7 @@ from homeassistant.components.sensor import ( ) from homeassistant.components.sensor.device_condition import ENTITY_CONDITIONS from homeassistant.const import CONF_PLATFORM, PERCENTAGE, STATE_UNKNOWN -from homeassistant.helpers import device_registry +from homeassistant.helpers import device_registry as dr from homeassistant.helpers.entity import EntityCategory from homeassistant.helpers.entity_registry import RegistryEntryHider from homeassistant.setup import async_setup_component @@ -22,32 +22,20 @@ from tests.common import ( async_get_device_automation_capabilities, async_get_device_automations, async_mock_service, - mock_device_registry, - mock_registry, ) from tests.components.blueprint.conftest import stub_blueprint_populate # noqa: F401 from tests.testing_config.custom_components.test.sensor import UNITS_OF_MEASUREMENT -@pytest.fixture -def device_reg(hass): - """Return an empty, loaded, registry.""" - return mock_device_registry(hass) - - -@pytest.fixture -def entity_reg(hass): - """Return an empty, loaded, registry.""" - return mock_registry(hass) - - @pytest.fixture def calls(hass): """Track calls to a mock service.""" return async_mock_service(hass, "test", "automation") -async def test_get_conditions(hass, device_reg, entity_reg, enable_custom_integrations): +async def test_get_conditions( + hass, device_registry, entity_registry, enable_custom_integrations +): """Test we get the expected conditions from a sensor.""" platform = getattr(hass.components, f"test.{DOMAIN}") platform.init() @@ -56,12 +44,12 @@ async def test_get_conditions(hass, device_reg, entity_reg, enable_custom_integr config_entry = MockConfigEntry(domain="test", data={}) config_entry.add_to_hass(hass) - device_entry = device_reg.async_get_or_create( + device_entry = device_registry.async_get_or_create( config_entry_id=config_entry.entry_id, - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, ) for device_class in SensorDeviceClass: - entity_reg.async_get_or_create( + entity_registry.async_get_or_create( DOMAIN, "test", platform.ENTITIES[device_class].unique_id, @@ -100,19 +88,19 @@ async def test_get_conditions(hass, device_reg, entity_reg, enable_custom_integr ) async def test_get_conditions_hidden_auxiliary( hass, - device_reg, - entity_reg, + device_registry, + entity_registry, hidden_by, entity_category, ): """Test we get the expected conditions from a hidden or auxiliary entity.""" config_entry = MockConfigEntry(domain="test", data={}) config_entry.add_to_hass(hass) - device_entry = device_reg.async_get_or_create( + device_entry = device_registry.async_get_or_create( config_entry_id=config_entry.entry_id, - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, ) - entity_reg.async_get_or_create( + entity_registry.async_get_or_create( DOMAIN, "test", "5678", @@ -138,17 +126,17 @@ async def test_get_conditions_hidden_auxiliary( assert_lists_same(conditions, expected_conditions) -async def test_get_conditions_no_state(hass, device_reg, entity_reg): +async def test_get_conditions_no_state(hass, device_registry, entity_registry): """Test we get the expected conditions from a sensor.""" config_entry = MockConfigEntry(domain="test", data={}) config_entry.add_to_hass(hass) - device_entry = device_reg.async_get_or_create( + device_entry = device_registry.async_get_or_create( config_entry_id=config_entry.entry_id, - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, ) entity_ids = {} for device_class in SensorDeviceClass: - entity_ids[device_class] = entity_reg.async_get_or_create( + entity_ids[device_class] = entity_registry.async_get_or_create( DOMAIN, "test", f"5678_{device_class}", @@ -191,8 +179,8 @@ async def test_get_conditions_no_state(hass, device_reg, entity_reg): ) async def test_get_conditions_no_unit_or_stateclass( hass, - device_reg, - entity_reg, + device_registry, + entity_registry, state_class, unit, condition_types, @@ -200,11 +188,11 @@ async def test_get_conditions_no_unit_or_stateclass( """Test we get the expected conditions from an entity with no unit or state class.""" config_entry = MockConfigEntry(domain="test", data={}) config_entry.add_to_hass(hass) - device_entry = device_reg.async_get_or_create( + device_entry = device_registry.async_get_or_create( config_entry_id=config_entry.entry_id, - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, ) - entity_reg.async_get_or_create( + entity_registry.async_get_or_create( DOMAIN, "test", "5678", @@ -238,8 +226,8 @@ async def test_get_conditions_no_unit_or_stateclass( ) async def test_get_condition_capabilities( hass, - device_reg, - entity_reg, + device_registry, + entity_registry, set_state, device_class_reg, device_class_state, @@ -252,11 +240,11 @@ async def test_get_condition_capabilities( config_entry = MockConfigEntry(domain="test", data={}) config_entry.add_to_hass(hass) - device_entry = device_reg.async_get_or_create( + device_entry = device_registry.async_get_or_create( config_entry_id=config_entry.entry_id, - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, ) - entity_id = entity_reg.async_get_or_create( + entity_id = entity_registry.async_get_or_create( DOMAIN, "test", platform.ENTITIES["battery"].unique_id, @@ -298,9 +286,7 @@ async def test_get_condition_capabilities( assert capabilities == expected_capabilities -async def test_get_condition_capabilities_none( - hass, device_reg, entity_reg, enable_custom_integrations -): +async def test_get_condition_capabilities_none(hass, enable_custom_integrations): """Test we get the expected capabilities from a sensor condition.""" platform = getattr(hass.components, f"test.{DOMAIN}") platform.init() diff --git a/tests/components/sensor/test_device_trigger.py b/tests/components/sensor/test_device_trigger.py index c4b321fa59d..1a28edcfd26 100644 --- a/tests/components/sensor/test_device_trigger.py +++ b/tests/components/sensor/test_device_trigger.py @@ -13,7 +13,7 @@ from homeassistant.components.sensor import ( ) from homeassistant.components.sensor.device_trigger import ENTITY_TRIGGERS from homeassistant.const import CONF_PLATFORM, PERCENTAGE, STATE_UNKNOWN -from homeassistant.helpers import device_registry +from homeassistant.helpers import device_registry as dr from homeassistant.helpers.entity import EntityCategory from homeassistant.helpers.entity_registry import RegistryEntryHider from homeassistant.setup import async_setup_component @@ -26,32 +26,20 @@ from tests.common import ( async_get_device_automation_capabilities, async_get_device_automations, async_mock_service, - mock_device_registry, - mock_registry, ) from tests.components.blueprint.conftest import stub_blueprint_populate # noqa: F401 from tests.testing_config.custom_components.test.sensor import UNITS_OF_MEASUREMENT -@pytest.fixture -def device_reg(hass): - """Return an empty, loaded, registry.""" - return mock_device_registry(hass) - - -@pytest.fixture -def entity_reg(hass): - """Return an empty, loaded, registry.""" - return mock_registry(hass) - - @pytest.fixture def calls(hass): """Track calls to a mock service.""" return async_mock_service(hass, "test", "automation") -async def test_get_triggers(hass, device_reg, entity_reg, enable_custom_integrations): +async def test_get_triggers( + hass, device_registry, entity_registry, enable_custom_integrations +): """Test we get the expected triggers from a sensor.""" platform = getattr(hass.components, f"test.{DOMAIN}") platform.init() @@ -60,12 +48,12 @@ async def test_get_triggers(hass, device_reg, entity_reg, enable_custom_integrat config_entry = MockConfigEntry(domain="test", data={}) config_entry.add_to_hass(hass) - device_entry = device_reg.async_get_or_create( + device_entry = device_registry.async_get_or_create( config_entry_id=config_entry.entry_id, - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, ) for device_class in SensorDeviceClass: - entity_reg.async_get_or_create( + entity_registry.async_get_or_create( DOMAIN, "test", platform.ENTITIES[device_class].unique_id, @@ -104,19 +92,19 @@ async def test_get_triggers(hass, device_reg, entity_reg, enable_custom_integrat ) async def test_get_triggers_hidden_auxiliary( hass, - device_reg, - entity_reg, + device_registry, + entity_registry, hidden_by, entity_category, ): """Test we get the expected triggers from a hidden or auxiliary entity.""" config_entry = MockConfigEntry(domain="test", data={}) config_entry.add_to_hass(hass) - device_entry = device_reg.async_get_or_create( + device_entry = device_registry.async_get_or_create( config_entry_id=config_entry.entry_id, - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, ) - entity_reg.async_get_or_create( + entity_registry.async_get_or_create( DOMAIN, "test", "5678", @@ -154,8 +142,8 @@ async def test_get_triggers_hidden_auxiliary( ) async def test_get_triggers_no_unit_or_stateclass( hass, - device_reg, - entity_reg, + device_registry, + entity_registry, state_class, unit, trigger_types, @@ -163,11 +151,11 @@ async def test_get_triggers_no_unit_or_stateclass( """Test we get the expected triggers from an entity with no unit or state class.""" config_entry = MockConfigEntry(domain="test", data={}) config_entry.add_to_hass(hass) - device_entry = device_reg.async_get_or_create( + device_entry = device_registry.async_get_or_create( config_entry_id=config_entry.entry_id, - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, ) - entity_reg.async_get_or_create( + entity_registry.async_get_or_create( DOMAIN, "test", "5678", @@ -201,8 +189,8 @@ async def test_get_triggers_no_unit_or_stateclass( ) async def test_get_trigger_capabilities( hass, - device_reg, - entity_reg, + device_registry, + entity_registry, set_state, device_class_reg, device_class_state, @@ -215,11 +203,11 @@ async def test_get_trigger_capabilities( config_entry = MockConfigEntry(domain="test", data={}) config_entry.add_to_hass(hass) - device_entry = device_reg.async_get_or_create( + device_entry = device_registry.async_get_or_create( config_entry_id=config_entry.entry_id, - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, ) - entity_id = entity_reg.async_get_or_create( + entity_id = entity_registry.async_get_or_create( DOMAIN, "test", platform.ENTITIES["battery"].unique_id, @@ -262,9 +250,7 @@ async def test_get_trigger_capabilities( assert capabilities == expected_capabilities -async def test_get_trigger_capabilities_none( - hass, device_reg, entity_reg, enable_custom_integrations -): +async def test_get_trigger_capabilities_none(hass, enable_custom_integrations): """Test we get the expected capabilities from a sensor trigger.""" platform = getattr(hass.components, f"test.{DOMAIN}") platform.init() diff --git a/tests/components/switch/test_device_action.py b/tests/components/switch/test_device_action.py index 43eb76f9cc5..5c597d60a02 100644 --- a/tests/components/switch/test_device_action.py +++ b/tests/components/switch/test_device_action.py @@ -5,7 +5,7 @@ import homeassistant.components.automation as automation from homeassistant.components.device_automation import DeviceAutomationType from homeassistant.components.switch import DOMAIN from homeassistant.const import CONF_PLATFORM, STATE_OFF, STATE_ON -from homeassistant.helpers import device_registry +from homeassistant.helpers import device_registry as dr from homeassistant.helpers.entity import EntityCategory from homeassistant.helpers.entity_registry import RegistryEntryHider from homeassistant.setup import async_setup_component @@ -15,39 +15,27 @@ from tests.common import ( assert_lists_same, async_get_device_automations, async_mock_service, - mock_device_registry, - mock_registry, ) from tests.components.blueprint.conftest import stub_blueprint_populate # noqa: F401 -@pytest.fixture -def device_reg(hass): - """Return an empty, loaded, registry.""" - return mock_device_registry(hass) - - -@pytest.fixture -def entity_reg(hass): - """Return an empty, loaded, registry.""" - return mock_registry(hass) - - @pytest.fixture def calls(hass): """Track calls to a mock service.""" return async_mock_service(hass, "test", "automation") -async def test_get_actions(hass, device_reg, entity_reg): +async def test_get_actions(hass, device_registry, entity_registry): """Test we get the expected actions from a switch.""" config_entry = MockConfigEntry(domain="test", data={}) config_entry.add_to_hass(hass) - device_entry = device_reg.async_get_or_create( + device_entry = device_registry.async_get_or_create( config_entry_id=config_entry.entry_id, - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + ) + entity_registry.async_get_or_create( + DOMAIN, "test", "5678", device_id=device_entry.id ) - entity_reg.async_get_or_create(DOMAIN, "test", "5678", device_id=device_entry.id) expected_actions = [] expected_actions += [ { @@ -76,19 +64,19 @@ async def test_get_actions(hass, device_reg, entity_reg): ) async def test_get_actions_hidden_auxiliary( hass, - device_reg, - entity_reg, + device_registry, + entity_registry, hidden_by, entity_category, ): """Test we get the expected actions from a hidden or auxiliary entity.""" config_entry = MockConfigEntry(domain="test", data={}) config_entry.add_to_hass(hass) - device_entry = device_reg.async_get_or_create( + device_entry = device_registry.async_get_or_create( config_entry_id=config_entry.entry_id, - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, ) - entity_reg.async_get_or_create( + entity_registry.async_get_or_create( DOMAIN, "test", "5678", diff --git a/tests/components/switch/test_device_condition.py b/tests/components/switch/test_device_condition.py index 501ede5b5be..8be86337f20 100644 --- a/tests/components/switch/test_device_condition.py +++ b/tests/components/switch/test_device_condition.py @@ -8,7 +8,7 @@ import homeassistant.components.automation as automation from homeassistant.components.device_automation import DeviceAutomationType from homeassistant.components.switch import DOMAIN from homeassistant.const import CONF_PLATFORM, STATE_OFF, STATE_ON -from homeassistant.helpers import device_registry +from homeassistant.helpers import device_registry as dr from homeassistant.helpers.entity import EntityCategory from homeassistant.helpers.entity_registry import RegistryEntryHider from homeassistant.setup import async_setup_component @@ -20,39 +20,27 @@ from tests.common import ( async_get_device_automation_capabilities, async_get_device_automations, async_mock_service, - mock_device_registry, - mock_registry, ) from tests.components.blueprint.conftest import stub_blueprint_populate # noqa: F401 -@pytest.fixture -def device_reg(hass): - """Return an empty, loaded, registry.""" - return mock_device_registry(hass) - - -@pytest.fixture -def entity_reg(hass): - """Return an empty, loaded, registry.""" - return mock_registry(hass) - - @pytest.fixture def calls(hass): """Track calls to a mock service.""" return async_mock_service(hass, "test", "automation") -async def test_get_conditions(hass, device_reg, entity_reg): +async def test_get_conditions(hass, device_registry, entity_registry): """Test we get the expected conditions from a switch.""" config_entry = MockConfigEntry(domain="test", data={}) config_entry.add_to_hass(hass) - device_entry = device_reg.async_get_or_create( + device_entry = device_registry.async_get_or_create( config_entry_id=config_entry.entry_id, - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + ) + entity_registry.async_get_or_create( + DOMAIN, "test", "5678", device_id=device_entry.id ) - entity_reg.async_get_or_create(DOMAIN, "test", "5678", device_id=device_entry.id) expected_conditions = [ { "condition": "device", @@ -81,19 +69,19 @@ async def test_get_conditions(hass, device_reg, entity_reg): ) async def test_get_conditions_hidden_auxiliary( hass, - device_reg, - entity_reg, + device_registry, + entity_registry, hidden_by, entity_category, ): """Test we get the expected conditions from a hidden or auxiliary entity.""" config_entry = MockConfigEntry(domain="test", data={}) config_entry.add_to_hass(hass) - device_entry = device_reg.async_get_or_create( + device_entry = device_registry.async_get_or_create( config_entry_id=config_entry.entry_id, - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, ) - entity_reg.async_get_or_create( + entity_registry.async_get_or_create( DOMAIN, "test", "5678", @@ -118,15 +106,17 @@ async def test_get_conditions_hidden_auxiliary( assert_lists_same(conditions, expected_conditions) -async def test_get_condition_capabilities(hass, device_reg, entity_reg): +async def test_get_condition_capabilities(hass, device_registry, entity_registry): """Test we get the expected capabilities from a switch condition.""" config_entry = MockConfigEntry(domain="test", data={}) config_entry.add_to_hass(hass) - device_entry = device_reg.async_get_or_create( + device_entry = device_registry.async_get_or_create( config_entry_id=config_entry.entry_id, - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + ) + entity_registry.async_get_or_create( + DOMAIN, "test", "5678", device_id=device_entry.id ) - entity_reg.async_get_or_create(DOMAIN, "test", "5678", device_id=device_entry.id) expected_capabilities = { "extra_fields": [ {"name": "for", "optional": True, "type": "positive_time_period_dict"} diff --git a/tests/components/switch/test_device_trigger.py b/tests/components/switch/test_device_trigger.py index f40e643b681..ad437fbfab5 100644 --- a/tests/components/switch/test_device_trigger.py +++ b/tests/components/switch/test_device_trigger.py @@ -7,7 +7,7 @@ import homeassistant.components.automation as automation from homeassistant.components.device_automation import DeviceAutomationType from homeassistant.components.switch import DOMAIN from homeassistant.const import CONF_PLATFORM, STATE_OFF, STATE_ON -from homeassistant.helpers import device_registry +from homeassistant.helpers import device_registry as dr from homeassistant.helpers.entity import EntityCategory from homeassistant.helpers.entity_registry import RegistryEntryHider from homeassistant.setup import async_setup_component @@ -20,39 +20,27 @@ from tests.common import ( async_get_device_automation_capabilities, async_get_device_automations, async_mock_service, - mock_device_registry, - mock_registry, ) from tests.components.blueprint.conftest import stub_blueprint_populate # noqa: F401 -@pytest.fixture -def device_reg(hass): - """Return an empty, loaded, registry.""" - return mock_device_registry(hass) - - -@pytest.fixture -def entity_reg(hass): - """Return an empty, loaded, registry.""" - return mock_registry(hass) - - @pytest.fixture def calls(hass): """Track calls to a mock service.""" return async_mock_service(hass, "test", "automation") -async def test_get_triggers(hass, device_reg, entity_reg): +async def test_get_triggers(hass, device_registry, entity_registry): """Test we get the expected triggers from a switch.""" config_entry = MockConfigEntry(domain="test", data={}) config_entry.add_to_hass(hass) - device_entry = device_reg.async_get_or_create( + device_entry = device_registry.async_get_or_create( config_entry_id=config_entry.entry_id, - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + ) + entity_registry.async_get_or_create( + DOMAIN, "test", "5678", device_id=device_entry.id ) - entity_reg.async_get_or_create(DOMAIN, "test", "5678", device_id=device_entry.id) expected_triggers = [ { "platform": "device", @@ -81,19 +69,19 @@ async def test_get_triggers(hass, device_reg, entity_reg): ) async def test_get_triggers_hidden_auxiliary( hass, - device_reg, - entity_reg, + device_registry, + entity_registry, hidden_by, entity_category, ): """Test we get the expected triggers from a hidden or auxiliary entity.""" config_entry = MockConfigEntry(domain="test", data={}) config_entry.add_to_hass(hass) - device_entry = device_reg.async_get_or_create( + device_entry = device_registry.async_get_or_create( config_entry_id=config_entry.entry_id, - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, ) - entity_reg.async_get_or_create( + entity_registry.async_get_or_create( DOMAIN, "test", "5678", @@ -118,15 +106,17 @@ async def test_get_triggers_hidden_auxiliary( assert_lists_same(triggers, expected_triggers) -async def test_get_trigger_capabilities(hass, device_reg, entity_reg): +async def test_get_trigger_capabilities(hass, device_registry, entity_registry): """Test we get the expected capabilities from a switch trigger.""" config_entry = MockConfigEntry(domain="test", data={}) config_entry.add_to_hass(hass) - device_entry = device_reg.async_get_or_create( + device_entry = device_registry.async_get_or_create( config_entry_id=config_entry.entry_id, - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + ) + entity_registry.async_get_or_create( + DOMAIN, "test", "5678", device_id=device_entry.id ) - entity_reg.async_get_or_create(DOMAIN, "test", "5678", device_id=device_entry.id) expected_capabilities = { "extra_fields": [ {"name": "for", "optional": True, "type": "positive_time_period_dict"} diff --git a/tests/components/text/test_device_action.py b/tests/components/text/test_device_action.py index 4edbc08a530..7a9a635e0e4 100644 --- a/tests/components/text/test_device_action.py +++ b/tests/components/text/test_device_action.py @@ -6,7 +6,7 @@ import homeassistant.components.automation as automation from homeassistant.components.device_automation import DeviceAutomationType from homeassistant.components.text import DOMAIN, device_action from homeassistant.core import HomeAssistant -from homeassistant.helpers import config_validation as cv, device_registry +from homeassistant.helpers import config_validation as cv, device_registry as dr from homeassistant.helpers.entity import EntityCategory from homeassistant.helpers.entity_registry import RegistryEntryHider from homeassistant.setup import async_setup_component @@ -16,33 +16,21 @@ from tests.common import ( assert_lists_same, async_get_device_automations, async_mock_service, - mock_device_registry, - mock_registry, ) from tests.components.blueprint.conftest import stub_blueprint_populate # noqa: F401 -@pytest.fixture -def device_reg(hass): - """Return an empty, loaded, registry.""" - return mock_device_registry(hass) - - -@pytest.fixture -def entity_reg(hass): - """Return an empty, loaded, registry.""" - return mock_registry(hass) - - -async def test_get_actions(hass, device_reg, entity_reg): +async def test_get_actions(hass, device_registry, entity_registry): """Test we get the expected actions for an entity.""" config_entry = MockConfigEntry(domain="test", data={}) config_entry.add_to_hass(hass) - device_entry = device_reg.async_get_or_create( + device_entry = device_registry.async_get_or_create( config_entry_id=config_entry.entry_id, - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + ) + entity_registry.async_get_or_create( + DOMAIN, "test", "5678", device_id=device_entry.id ) - entity_reg.async_get_or_create(DOMAIN, "test", "5678", device_id=device_entry.id) hass.states.async_set("text.test_5678", 0.5, {"min_value": 0.0, "max_value": 1.0}) expected_actions = [ { @@ -70,19 +58,19 @@ async def test_get_actions(hass, device_reg, entity_reg): ) async def test_get_actions_hidden_auxiliary( hass, - device_reg, - entity_reg, + device_registry, + entity_registry, hidden_by, entity_category, ): """Test we get the expected actions from a hidden or auxiliary entity.""" config_entry = MockConfigEntry(domain="test", data={}) config_entry.add_to_hass(hass) - device_entry = device_reg.async_get_or_create( + device_entry = device_registry.async_get_or_create( config_entry_id=config_entry.entry_id, - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, ) - entity_reg.async_get_or_create( + entity_registry.async_get_or_create( DOMAIN, "test", "5678", @@ -107,15 +95,17 @@ async def test_get_actions_hidden_auxiliary( assert_lists_same(actions, expected_actions) -async def test_get_action_no_state(hass, device_reg, entity_reg): +async def test_get_action_no_state(hass, device_registry, entity_registry): """Test we get the expected actions for an entity.""" config_entry = MockConfigEntry(domain="test", data={}) config_entry.add_to_hass(hass) - device_entry = device_reg.async_get_or_create( + device_entry = device_registry.async_get_or_create( config_entry_id=config_entry.entry_id, - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + ) + entity_registry.async_get_or_create( + DOMAIN, "test", "5678", device_id=device_entry.id ) - entity_reg.async_get_or_create(DOMAIN, "test", "5678", device_id=device_entry.id) expected_actions = [ { "domain": DOMAIN, diff --git a/tests/components/update/test_device_trigger.py b/tests/components/update/test_device_trigger.py index cc583324abb..7e36c0cbf02 100644 --- a/tests/components/update/test_device_trigger.py +++ b/tests/components/update/test_device_trigger.py @@ -8,7 +8,7 @@ from homeassistant.components.device_automation import DeviceAutomationType from homeassistant.components.update import DOMAIN from homeassistant.const import CONF_PLATFORM, STATE_OFF, STATE_ON from homeassistant.core import HomeAssistant, ServiceCall -from homeassistant.helpers import device_registry +from homeassistant.helpers import device_registry as dr from homeassistant.helpers.device_registry import DeviceRegistry from homeassistant.helpers.entity import EntityCategory from homeassistant.helpers.entity_registry import EntityRegistry, RegistryEntryHider @@ -22,24 +22,10 @@ from tests.common import ( async_get_device_automation_capabilities, async_get_device_automations, async_mock_service, - mock_device_registry, - mock_registry, ) from tests.components.blueprint.conftest import stub_blueprint_populate # noqa: F401 -@pytest.fixture -def device_reg(hass: HomeAssistant) -> DeviceRegistry: - """Return an empty, loaded, registry.""" - return mock_device_registry(hass) - - -@pytest.fixture -def entity_reg(hass: HomeAssistant) -> EntityRegistry: - """Return an empty, loaded, registry.""" - return mock_registry(hass) - - @pytest.fixture def calls(hass: HomeAssistant) -> list[ServiceCall]: """Track calls to a mock service.""" @@ -47,16 +33,20 @@ def calls(hass: HomeAssistant) -> list[ServiceCall]: async def test_get_triggers( - hass: HomeAssistant, device_reg: DeviceRegistry, entity_reg: EntityRegistry + hass: HomeAssistant, + device_registry: DeviceRegistry, + entity_registry: EntityRegistry, ) -> None: """Test we get the expected triggers from a update entity.""" config_entry = MockConfigEntry(domain="test", data={}) config_entry.add_to_hass(hass) - device_entry = device_reg.async_get_or_create( + device_entry = device_registry.async_get_or_create( config_entry_id=config_entry.entry_id, - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + ) + entity_registry.async_get_or_create( + DOMAIN, "test", "5678", device_id=device_entry.id ) - entity_reg.async_get_or_create(DOMAIN, "test", "5678", device_id=device_entry.id) expected_triggers = [ { "platform": "device", @@ -85,19 +75,19 @@ async def test_get_triggers( ) async def test_get_triggers_hidden_auxiliary( hass, - device_reg, - entity_reg, + device_registry, + entity_registry, hidden_by, entity_category, ): """Test we get the expected triggers from a hidden or auxiliary entity.""" config_entry = MockConfigEntry(domain="test", data={}) config_entry.add_to_hass(hass) - device_entry = device_reg.async_get_or_create( + device_entry = device_registry.async_get_or_create( config_entry_id=config_entry.entry_id, - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, ) - entity_reg.async_get_or_create( + entity_registry.async_get_or_create( DOMAIN, "test", "5678", @@ -123,16 +113,20 @@ async def test_get_triggers_hidden_auxiliary( async def test_get_trigger_capabilities( - hass: HomeAssistant, device_reg: DeviceRegistry, entity_reg: EntityRegistry + hass: HomeAssistant, + device_registry: DeviceRegistry, + entity_registry: EntityRegistry, ) -> None: """Test we get the expected capabilities from a update trigger.""" config_entry = MockConfigEntry(domain="test", data={}) config_entry.add_to_hass(hass) - device_entry = device_reg.async_get_or_create( + device_entry = device_registry.async_get_or_create( config_entry_id=config_entry.entry_id, - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + ) + entity_registry.async_get_or_create( + DOMAIN, "test", "5678", device_id=device_entry.id ) - entity_reg.async_get_or_create(DOMAIN, "test", "5678", device_id=device_entry.id) expected_capabilities = { "extra_fields": [ {"name": "for", "optional": True, "type": "positive_time_period_dict"} diff --git a/tests/components/vacuum/test_device_action.py b/tests/components/vacuum/test_device_action.py index 2c544b8b92c..a7759faff7c 100644 --- a/tests/components/vacuum/test_device_action.py +++ b/tests/components/vacuum/test_device_action.py @@ -5,7 +5,7 @@ import homeassistant.components.automation as automation from homeassistant.components.device_automation import DeviceAutomationType from homeassistant.components.vacuum import DOMAIN from homeassistant.core import HomeAssistant -from homeassistant.helpers import device_registry +from homeassistant.helpers import device_registry as dr from homeassistant.helpers.entity import EntityCategory from homeassistant.helpers.entity_registry import RegistryEntryHider from homeassistant.setup import async_setup_component @@ -15,33 +15,21 @@ from tests.common import ( assert_lists_same, async_get_device_automations, async_mock_service, - mock_device_registry, - mock_registry, ) from tests.components.blueprint.conftest import stub_blueprint_populate # noqa: F401 -@pytest.fixture -def device_reg(hass): - """Return an empty, loaded, registry.""" - return mock_device_registry(hass) - - -@pytest.fixture -def entity_reg(hass): - """Return an empty, loaded, registry.""" - return mock_registry(hass) - - -async def test_get_actions(hass, device_reg, entity_reg): +async def test_get_actions(hass, device_registry, entity_registry): """Test we get the expected actions from a vacuum.""" config_entry = MockConfigEntry(domain="test", data={}) config_entry.add_to_hass(hass) - device_entry = device_reg.async_get_or_create( + device_entry = device_registry.async_get_or_create( config_entry_id=config_entry.entry_id, - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + ) + entity_registry.async_get_or_create( + DOMAIN, "test", "5678", device_id=device_entry.id ) - entity_reg.async_get_or_create(DOMAIN, "test", "5678", device_id=device_entry.id) expected_actions = [] expected_actions += [ { @@ -70,19 +58,19 @@ async def test_get_actions(hass, device_reg, entity_reg): ) async def test_get_actions_hidden_auxiliary( hass, - device_reg, - entity_reg, + device_registry, + entity_registry, hidden_by, entity_category, ): """Test we get the expected actions from a hidden or auxiliary entity.""" config_entry = MockConfigEntry(domain="test", data={}) config_entry.add_to_hass(hass) - device_entry = device_reg.async_get_or_create( + device_entry = device_registry.async_get_or_create( config_entry_id=config_entry.entry_id, - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, ) - entity_reg.async_get_or_create( + entity_registry.async_get_or_create( DOMAIN, "test", "5678", diff --git a/tests/components/vacuum/test_device_condition.py b/tests/components/vacuum/test_device_condition.py index 12d4d9154a9..f81d2c9b729 100644 --- a/tests/components/vacuum/test_device_condition.py +++ b/tests/components/vacuum/test_device_condition.py @@ -9,7 +9,7 @@ from homeassistant.components.vacuum import ( STATE_DOCKED, STATE_RETURNING, ) -from homeassistant.helpers import device_registry +from homeassistant.helpers import device_registry as dr from homeassistant.helpers.entity import EntityCategory from homeassistant.helpers.entity_registry import RegistryEntryHider from homeassistant.setup import async_setup_component @@ -19,39 +19,27 @@ from tests.common import ( assert_lists_same, async_get_device_automations, async_mock_service, - mock_device_registry, - mock_registry, ) from tests.components.blueprint.conftest import stub_blueprint_populate # noqa: F401 -@pytest.fixture -def device_reg(hass): - """Return an empty, loaded, registry.""" - return mock_device_registry(hass) - - -@pytest.fixture -def entity_reg(hass): - """Return an empty, loaded, registry.""" - return mock_registry(hass) - - @pytest.fixture def calls(hass): """Track calls to a mock service.""" return async_mock_service(hass, "test", "automation") -async def test_get_conditions(hass, device_reg, entity_reg): +async def test_get_conditions(hass, device_registry, entity_registry): """Test we get the expected conditions from a vacuum.""" config_entry = MockConfigEntry(domain="test", data={}) config_entry.add_to_hass(hass) - device_entry = device_reg.async_get_or_create( + device_entry = device_registry.async_get_or_create( config_entry_id=config_entry.entry_id, - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + ) + entity_registry.async_get_or_create( + DOMAIN, "test", "5678", device_id=device_entry.id ) - entity_reg.async_get_or_create(DOMAIN, "test", "5678", device_id=device_entry.id) expected_conditions = [ { "condition": "device", @@ -80,19 +68,19 @@ async def test_get_conditions(hass, device_reg, entity_reg): ) async def test_get_conditions_hidden_auxiliary( hass, - device_reg, - entity_reg, + device_registry, + entity_registry, hidden_by, entity_category, ): """Test we get the expected conditions from a hidden or auxiliary entity.""" config_entry = MockConfigEntry(domain="test", data={}) config_entry.add_to_hass(hass) - device_entry = device_reg.async_get_or_create( + device_entry = device_registry.async_get_or_create( config_entry_id=config_entry.entry_id, - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, ) - entity_reg.async_get_or_create( + entity_registry.async_get_or_create( DOMAIN, "test", "5678", diff --git a/tests/components/vacuum/test_device_trigger.py b/tests/components/vacuum/test_device_trigger.py index 0436d01c7b0..a3fe65fe60a 100644 --- a/tests/components/vacuum/test_device_trigger.py +++ b/tests/components/vacuum/test_device_trigger.py @@ -6,7 +6,7 @@ import pytest import homeassistant.components.automation as automation from homeassistant.components.device_automation import DeviceAutomationType from homeassistant.components.vacuum import DOMAIN, STATE_CLEANING, STATE_DOCKED -from homeassistant.helpers import device_registry +from homeassistant.helpers import device_registry as dr from homeassistant.helpers.entity import EntityCategory from homeassistant.helpers.entity_registry import RegistryEntryHider from homeassistant.setup import async_setup_component @@ -19,39 +19,27 @@ from tests.common import ( async_get_device_automation_capabilities, async_get_device_automations, async_mock_service, - mock_device_registry, - mock_registry, ) from tests.components.blueprint.conftest import stub_blueprint_populate # noqa: F401 -@pytest.fixture -def device_reg(hass): - """Return an empty, loaded, registry.""" - return mock_device_registry(hass) - - -@pytest.fixture -def entity_reg(hass): - """Return an empty, loaded, registry.""" - return mock_registry(hass) - - @pytest.fixture def calls(hass): """Track calls to a mock service.""" return async_mock_service(hass, "test", "automation") -async def test_get_triggers(hass, device_reg, entity_reg): +async def test_get_triggers(hass, device_registry, entity_registry): """Test we get the expected triggers from a vacuum.""" config_entry = MockConfigEntry(domain="test", data={}) config_entry.add_to_hass(hass) - device_entry = device_reg.async_get_or_create( + device_entry = device_registry.async_get_or_create( config_entry_id=config_entry.entry_id, - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + ) + entity_registry.async_get_or_create( + DOMAIN, "test", "5678", device_id=device_entry.id ) - entity_reg.async_get_or_create(DOMAIN, "test", "5678", device_id=device_entry.id) expected_triggers = [ { "platform": "device", @@ -80,19 +68,19 @@ async def test_get_triggers(hass, device_reg, entity_reg): ) async def test_get_triggers_hidden_auxiliary( hass, - device_reg, - entity_reg, + device_registry, + entity_registry, hidden_by, entity_category, ): """Test we get the expected triggers from a hidden or auxiliary entity.""" config_entry = MockConfigEntry(domain="test", data={}) config_entry.add_to_hass(hass) - device_entry = device_reg.async_get_or_create( + device_entry = device_registry.async_get_or_create( config_entry_id=config_entry.entry_id, - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, ) - entity_reg.async_get_or_create( + entity_registry.async_get_or_create( DOMAIN, "test", "5678", @@ -117,15 +105,17 @@ async def test_get_triggers_hidden_auxiliary( assert_lists_same(triggers, expected_triggers) -async def test_get_trigger_capabilities(hass, device_reg, entity_reg): +async def test_get_trigger_capabilities(hass, device_registry, entity_registry): """Test we get the expected capabilities from a vacuum device.""" config_entry = MockConfigEntry(domain="test", data={}) config_entry.add_to_hass(hass) - device_entry = device_reg.async_get_or_create( + device_entry = device_registry.async_get_or_create( config_entry_id=config_entry.entry_id, - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + ) + entity_registry.async_get_or_create( + DOMAIN, "test", "5678", device_id=device_entry.id ) - entity_reg.async_get_or_create(DOMAIN, "test", "5678", device_id=device_entry.id) triggers = await async_get_device_automations( hass, DeviceAutomationType.TRIGGER, device_entry.id diff --git a/tests/components/water_heater/test_device_action.py b/tests/components/water_heater/test_device_action.py index 3832de6693c..df18d39f924 100644 --- a/tests/components/water_heater/test_device_action.py +++ b/tests/components/water_heater/test_device_action.py @@ -5,7 +5,7 @@ import homeassistant.components.automation as automation from homeassistant.components.device_automation import DeviceAutomationType from homeassistant.components.water_heater import DOMAIN from homeassistant.core import HomeAssistant -from homeassistant.helpers import device_registry +from homeassistant.helpers import device_registry as dr from homeassistant.helpers.entity import EntityCategory from homeassistant.helpers.entity_registry import RegistryEntryHider from homeassistant.setup import async_setup_component @@ -15,33 +15,21 @@ from tests.common import ( assert_lists_same, async_get_device_automations, async_mock_service, - mock_device_registry, - mock_registry, ) from tests.components.blueprint.conftest import stub_blueprint_populate # noqa: F401 -@pytest.fixture -def device_reg(hass): - """Return an empty, loaded, registry.""" - return mock_device_registry(hass) - - -@pytest.fixture -def entity_reg(hass): - """Return an empty, loaded, registry.""" - return mock_registry(hass) - - -async def test_get_actions(hass, device_reg, entity_reg): +async def test_get_actions(hass, device_registry, entity_registry): """Test we get the expected actions from a water_heater.""" config_entry = MockConfigEntry(domain="test", data={}) config_entry.add_to_hass(hass) - device_entry = device_reg.async_get_or_create( + device_entry = device_registry.async_get_or_create( config_entry_id=config_entry.entry_id, - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + ) + entity_registry.async_get_or_create( + DOMAIN, "test", "5678", device_id=device_entry.id ) - entity_reg.async_get_or_create(DOMAIN, "test", "5678", device_id=device_entry.id) expected_actions = [] expected_actions += [ { @@ -70,19 +58,19 @@ async def test_get_actions(hass, device_reg, entity_reg): ) async def test_get_actions_hidden_auxiliary( hass, - device_reg, - entity_reg, + device_registry, + entity_registry, hidden_by, entity_category, ): """Test we get the expected actions from a hidden or auxiliary entity.""" config_entry = MockConfigEntry(domain="test", data={}) config_entry.add_to_hass(hass) - device_entry = device_reg.async_get_or_create( + device_entry = device_registry.async_get_or_create( config_entry_id=config_entry.entry_id, - connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, + connections={(dr.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")}, ) - entity_reg.async_get_or_create( + entity_registry.async_get_or_create( DOMAIN, "test", "5678",