Add ability to have same entity names on different sub devices (#9355)

Co-authored-by: pre-commit-ci-lite[bot] <117423508+pre-commit-ci-lite[bot]@users.noreply.github.com>

tests/integration/test_areas_and_devices.py

@@ -4,7 +4,7 @@ from __future__ import annotations
 
 import asyncio
 
-from aioesphomeapi import EntityState
+from aioesphomeapi import EntityState, SwitchInfo, SwitchState
 import pytest
 
 from .types import APIClientConnectedFactory, RunCompiledFunction
@@ -84,23 +84,45 @@ async def test_areas_and_devices(
 
         # Subscribe to states to get sensor values
         loop = asyncio.get_running_loop()
-        states: dict[int, EntityState] = {}
-        states_future: asyncio.Future[bool] = loop.create_future()
+        states: dict[tuple[int, int], EntityState] = {}
+        # Subscribe to all switch states
+        switch_state_futures: dict[
+            tuple[int, int], asyncio.Future[EntityState]
+        ] = {}  # (device_id, key) -> future
+        initial_states_received: set[tuple[int, int]] = set()
+        initial_states_future: asyncio.Future[bool] = loop.create_future()
 
         def on_state(state: EntityState) -> None:
-            states[state.key] = state
-            # Check if we have all expected sensor states
-            if len(states) >= 4 and not states_future.done():
-                states_future.set_result(True)
+            state_key = (state.device_id, state.key)
+            states[state_key] = state
+
+            initial_states_received.add(state_key)
+            # Check if we have all initial states
+            if (
+                len(initial_states_received) >= 8  # 8 entities expected
+                and not initial_states_future.done()
+            ):
+                initial_states_future.set_result(True)
+
+            if not initial_states_future.done():
+                return
+
+            # Resolve the future for this switch if it exists
+            if (
+                state_key in switch_state_futures
+                and not switch_state_futures[state_key].done()
+                and isinstance(state, SwitchState)
+            ):
+                switch_state_futures[state_key].set_result(state)
 
         client.subscribe_states(on_state)
 
         # Wait for sensor states
         try:
-            await asyncio.wait_for(states_future, timeout=10.0)
+            await asyncio.wait_for(initial_states_future, timeout=10.0)
         except TimeoutError:
             pytest.fail(
-                f"Did not receive all sensor states within 10 seconds. "
+                f"Did not receive all states within 10 seconds. "
                 f"Received {len(states)} states"
             )
 
@@ -119,3 +141,121 @@ async def test_areas_and_devices(
                     f"{entity.name} has device_id {entity.device_id}, "
                     f"expected {expected_device_id}"
                 )
+
+        all_entities, _ = entities  # Unpack the tuple
+        switch_entities = [e for e in all_entities if isinstance(e, SwitchInfo)]
+
+        # Find all switches named "Test Switch"
+        test_switches = [e for e in switch_entities if e.name == "Test Switch"]
+        assert len(test_switches) == 4, (
+            f"Expected 4 'Test Switch' entities, got {len(test_switches)}"
+        )
+
+        # Verify we have switches with different device_ids including one with 0 (main)
+        switch_device_ids = {s.device_id for s in test_switches}
+        assert len(switch_device_ids) == 4, (
+            "All Test Switch entities should have different device_ids"
+        )
+        assert 0 in switch_device_ids, (
+            "Should have a switch with device_id 0 (main device)"
+        )
+
+        # Wait for initial states to be received for all switches
+        await asyncio.wait_for(initial_states_future, timeout=2.0)
+
+        # Test controlling each switch specifically by device_id
+        for device_name, device in [
+            ("Light Controller", light_controller),
+            ("Temperature Sensor", temp_sensor),
+            ("Motion Detector", motion_detector),
+        ]:
+            # Find the switch for this specific device
+            device_switch = next(
+                (s for s in test_switches if s.device_id == device.device_id), None
+            )
+            assert device_switch is not None, f"No Test Switch found for {device_name}"
+
+            # Create future for this switch's state change
+            state_key = (device_switch.device_id, device_switch.key)
+            switch_state_futures[state_key] = loop.create_future()
+
+            # Turn on the switch with device_id
+            client.switch_command(
+                device_switch.key, True, device_id=device_switch.device_id
+            )
+
+            # Wait for state to change
+            await asyncio.wait_for(switch_state_futures[state_key], timeout=2.0)
+
+            # Verify the correct switch was turned on
+            assert states[state_key].state is True, f"{device_name} switch should be on"
+
+            # Create new future for turning off
+            switch_state_futures[state_key] = loop.create_future()
+
+            # Turn off the switch with device_id
+            client.switch_command(
+                device_switch.key, False, device_id=device_switch.device_id
+            )
+
+            # Wait for state to change
+            await asyncio.wait_for(switch_state_futures[state_key], timeout=2.0)
+
+            # Verify the correct switch was turned off
+            assert states[state_key].state is False, (
+                f"{device_name} switch should be off"
+            )
+
+        # Test that controlling a switch with device_id doesn't affect main switch
+        # Find the main switch (device_id = 0)
+        main_switch = next((s for s in test_switches if s.device_id == 0), None)
+        assert main_switch is not None, "No main switch (device_id=0) found"
+
+        # Find a switch with a device_id
+        device_switch = next(
+            (s for s in test_switches if s.device_id == light_controller.device_id),
+            None,
+        )
+        assert device_switch is not None, "No device switch found"
+
+        # Create futures for both switches
+        main_key = (main_switch.device_id, main_switch.key)
+        device_key = (device_switch.device_id, device_switch.key)
+
+        # Turn on the main switch first
+        switch_state_futures[main_key] = loop.create_future()
+        client.switch_command(main_switch.key, True, device_id=main_switch.device_id)
+        await asyncio.wait_for(switch_state_futures[main_key], timeout=2.0)
+        assert states[main_key].state is True, "Main switch should be on"
+
+        # Now turn on the device switch
+        switch_state_futures[device_key] = loop.create_future()
+        client.switch_command(
+            device_switch.key, True, device_id=device_switch.device_id
+        )
+        await asyncio.wait_for(switch_state_futures[device_key], timeout=2.0)
+
+        # Verify device switch is on and main switch is still on
+        assert states[device_key].state is True, "Device switch should be on"
+        assert states[main_key].state is True, (
+            "Main switch should still be on after turning on device switch"
+        )
+
+        # Turn off the device switch
+        switch_state_futures[device_key] = loop.create_future()
+        client.switch_command(
+            device_switch.key, False, device_id=device_switch.device_id
+        )
+        await asyncio.wait_for(switch_state_futures[device_key], timeout=2.0)
+
+        # Verify device switch is off and main switch is still on
+        assert states[device_key].state is False, "Device switch should be off"
+        assert states[main_key].state is True, (
+            "Main switch should still be on after turning off device switch"
+        )
+
+        # Clean up - turn off main switch
+        switch_state_futures[main_key] = loop.create_future()
+        client.switch_command(main_switch.key, False, device_id=main_switch.device_id)
+        await asyncio.wait_for(switch_state_futures[main_key], timeout=2.0)
+        assert states[main_key].state is False, "Main switch should be off"