diff --git a/src/linkplay/bridge.py b/src/linkplay/bridge.py index 0f6e5f3..5a52791 100644 --- a/src/linkplay/bridge.py +++ b/src/linkplay/bridge.py @@ -34,30 +34,30 @@ ) -class LinkPlayDevice: - """Represents a LinkPlay device.""" +class LinkPlayPlayer: + """Represents a LinkPlay player.""" bridge: LinkPlayBridge - properties: dict[DeviceAttribute, str] + device_properties: dict[DeviceAttribute, str] + properties: dict[PlayerAttribute, str] + custom_properties: dict[PlayerAttribute, str] + metainfo: dict[MetaInfo, dict[MetaInfoMetaData, str]] + + previous_playing_mode: PlayingMode | None = None controller: Callable[[], None] | None = None def __init__(self, bridge: LinkPlayBridge): self.bridge = bridge - self.properties = dict.fromkeys(DeviceAttribute.__members__.values(), "") - - def to_dict(self): - """Return the state of the LinkPlayDevice.""" - return {"properties": self.properties} + self.device_properties = dict.fromkeys(DeviceAttribute.__members__.values(), "") + self.properties = dict.fromkeys(PlayerAttribute.__members__.values(), "") + self.custom_properties = dict.fromkeys(PlayerAttribute.__members__.values(), "") + self.metainfo = dict.fromkeys(MetaInfo.__members__.values(), {}) def set_callback(self, controller: Callable[[], None]) -> None: """Sets a callback function to notify events.""" self.controller = controller - async def update_status(self) -> None: - """Update the device status.""" - self.properties = await self.bridge.json_request(LinkPlayCommand.DEVICE_STATUS) # type: ignore[assignment] - async def reboot(self) -> None: """Reboot the device.""" await self.bridge.request(LinkPlayCommand.REBOOT) @@ -65,18 +65,18 @@ async def reboot(self) -> None: @property def uuid(self) -> str: """The UUID of the device.""" - return self.properties.get(DeviceAttribute.UUID, "") + return self.device_properties.get(DeviceAttribute.UUID, "") @property def name(self) -> str: """The name of the device.""" - return self.properties.get(DeviceAttribute.DEVICE_NAME, "") + return self.device_properties.get(DeviceAttribute.DEVICE_NAME, "") @property def manufacturer(self) -> str: """The manufacturer of the device.""" manufacturer, _ = get_info_from_project( - self.properties.get(DeviceAttribute.PROJECT, "") + self.device_properties.get(DeviceAttribute.PROJECT, "") ) return manufacturer @@ -84,7 +84,7 @@ def manufacturer(self) -> str: def model(self) -> str: """The model of the device.""" _, model = get_info_from_project( - self.properties.get(DeviceAttribute.PROJECT, "") + self.device_properties.get(DeviceAttribute.PROJECT, "") ) return model @@ -93,7 +93,7 @@ def playmode_support(self) -> list[PlayingMode]: """Returns the player playmode support.""" flags = InputMode( - int(self.properties[DeviceAttribute.PLAYMODE_SUPPORT], base=16) + int(self.device_properties[DeviceAttribute.PLAYMODE_SUPPORT], base=16) ) playing_modes = [INPUT_MODE_MAP[flag] for flag in flags] @@ -103,21 +103,21 @@ def playmode_support(self) -> list[PlayingMode]: @property def mac(self) -> str | None: """Returns the mac address.""" - mac = self.properties.get(DeviceAttribute.ETH_MAC_ADDRESS) + mac = self.device_properties.get(DeviceAttribute.ETH_MAC_ADDRESS) if mac == "00:00:00:00:00:00" or mac is None: - mac = self.properties.get(DeviceAttribute.STA_MAC_ADDRESS) + mac = self.device_properties.get(DeviceAttribute.STA_MAC_ADDRESS) if mac == "00:00:00:00:00:00" or mac is None: - mac = self.properties.get(DeviceAttribute.MAC_ADDRESS) + mac = self.device_properties.get(DeviceAttribute.MAC_ADDRESS) return mac @property def eth(self) -> str | None: """Returns the ethernet address.""" - eth = self.properties.get(DeviceAttribute.ETH2) + eth = self.device_properties.get(DeviceAttribute.ETH2) if eth == "0.0.0.0" or eth == "" or eth is None: - eth = self.properties.get(DeviceAttribute.ETH0) + eth = self.device_properties.get(DeviceAttribute.ETH0) if eth == "0.0.0.0" or eth == "" or eth is None: - eth = self.properties.get(DeviceAttribute.APCLI0) + eth = self.device_properties.get(DeviceAttribute.APCLI0) return eth async def timesync(self) -> None: @@ -125,35 +125,26 @@ async def timesync(self) -> None: timestamp = time.strftime("%Y%m%d%H%M%S") await self.bridge.request(LinkPlayCommand.TIMESYNC.format(timestamp)) - -class LinkPlayPlayer: - """Represents a LinkPlay player.""" - - bridge: LinkPlayBridge - properties: dict[PlayerAttribute, str] - custom_properties: dict[PlayerAttribute, str] - metainfo: dict[MetaInfo, dict[MetaInfoMetaData, str]] - - previous_playing_mode: PlayingMode | None = None - - def __init__(self, bridge: LinkPlayBridge): - self.bridge = bridge - self.properties = dict.fromkeys(PlayerAttribute.__members__.values(), "") - self.custom_properties = dict.fromkeys(PlayerAttribute.__members__.values(), "") - self.metainfo = dict.fromkeys(MetaInfo.__members__.values(), {}) - def to_dict(self): """Return the state of the LinkPlayPlayer.""" - return {"properties": self.properties} + return { + "device_properties": self.device_properties, + "properties": self.properties, + } async def update_status(self) -> None: """Update the player status.""" + + self.device_properties = await self.bridge.json_request( + LinkPlayCommand.DEVICE_STATUS + ) # type: ignore[assignment] + properties: dict[PlayerAttribute, str] = await self.bridge.json_request( LinkPlayCommand.PLAYER_STATUS ) # type: ignore[assignment] self.properties = fixup_player_properties(properties) - if self.bridge.device.manufacturer == MANUFACTURER_WIIM: + if self.bridge.player.manufacturer == MANUFACTURER_WIIM: try: self.metainfo: dict[ MetaInfo, dict[MetaInfoMetaData, str] @@ -167,7 +158,7 @@ async def update_status(self) -> None: self.metainfo = {} # handle multiroom changes - if self.bridge.device.controller is not None and ( + if self.bridge.player.controller is not None and ( ( self.previous_playing_mode != PlayingMode.FOLLOWER and self.play_mode == PlayingMode.FOLLOWER @@ -177,7 +168,7 @@ async def update_status(self) -> None: and self.play_mode != PlayingMode.FOLLOWER ) ): - self.bridge.device.controller() + self.bridge.player.controller() self.previous_playing_mode = self.play_mode async def next(self) -> None: @@ -233,7 +224,7 @@ async def set_volume(self, value: int) -> None: async def set_equalizer_mode(self, mode: EqualizerMode) -> None: """Set the equalizer mode.""" - if self.bridge.device.manufacturer == MANUFACTURER_WIIM: + if self.bridge.player.manufacturer == MANUFACTURER_WIIM: await self._set_wiim_equalizer_mode(mode) else: await self._set_normal_equalizer_mode(mode) @@ -278,7 +269,7 @@ async def set_play_mode(self, mode: PlayingMode) -> None: async def play_preset(self, preset_number: int) -> None: """Play a preset.""" max_number_of_presets_allowed = int( - self.bridge.device.properties.get(DeviceAttribute.PRESET_KEY) or "10" + self.bridge.player.device_properties.get(DeviceAttribute.PRESET_KEY) or "10" ) if not 0 < preset_number <= max_number_of_presets_allowed: raise ValueError( @@ -374,7 +365,7 @@ def status(self) -> PlayingStatus: def equalizer_mode(self) -> EqualizerMode: """Returns the current equalizer mode.""" try: - if self.bridge.device.manufacturer == MANUFACTURER_WIIM: + if self.bridge.player.manufacturer == MANUFACTURER_WIIM: # WiiM devices have a different equalizer mode handling # and will never ever return what equalizer mode they are in return EqualizerMode( @@ -395,7 +386,7 @@ def equalizer_mode(self) -> EqualizerMode: @property def available_equalizer_modes(self) -> list[EqualizerMode]: """Returns the available equalizer modes.""" - if self.bridge.device.manufacturer == MANUFACTURER_WIIM: + if self.bridge.player.manufacturer == MANUFACTURER_WIIM: return [ EqualizerMode.NONE, EqualizerMode.FLAT, @@ -468,27 +459,24 @@ class LinkPlayBridge: """Represents a LinkPlay bridge to control the device and player attached to it.""" endpoint: LinkPlayEndpoint - device: LinkPlayDevice player: LinkPlayPlayer multiroom: LinkPlayMultiroom | None def __init__(self, *, endpoint: LinkPlayEndpoint): self.endpoint = endpoint - self.device = LinkPlayDevice(self) self.player = LinkPlayPlayer(self) self.multiroom = None def __str__(self) -> str: - if self.device.name == "": + if self.player.name == "": return f"{self.endpoint}" - return self.device.name + return self.player.name def to_dict(self): """Return the state of the LinkPlayBridge.""" return { "endpoint": self.endpoint.to_dict(), - "device": self.device.to_dict(), "player": self.player.to_dict(), "multiroom": self.multiroom.to_dict() if self.multiroom else None, } @@ -541,7 +529,7 @@ async def update_status(self, bridges: list[LinkPlayBridge]) -> None: for follower in properties[MultiroomAttribute.FOLLOWER_LIST] ] new_followers = [ - bridge for bridge in bridges if bridge.device.uuid in follower_uuids + bridge for bridge in bridges if bridge.player.uuid in follower_uuids ] self.followers.extend(new_followers) except LinkPlayInvalidDataException as exc: @@ -557,7 +545,7 @@ async def ungroup(self) -> None: async def add_follower(self, follower: LinkPlayBridge) -> None: """Adds a follower to the multiroom group.""" await follower.request( - LinkPlayCommand.MULTIROOM_JOIN.format(self.leader.device.eth) + LinkPlayCommand.MULTIROOM_JOIN.format(self.leader.player.eth) ) # type: ignore[str-format] if follower not in self.followers: follower.multiroom = self @@ -566,7 +554,7 @@ async def add_follower(self, follower: LinkPlayBridge) -> None: async def remove_follower(self, follower: LinkPlayBridge) -> None: """Removes a follower from the multiroom group.""" await self.leader.request( - LinkPlayCommand.MULTIROOM_KICK.format(follower.device.eth) + LinkPlayCommand.MULTIROOM_KICK.format(follower.player.eth) ) # type: ignore[str-format] if follower in self.followers: follower.multiroom = None diff --git a/src/linkplay/controller.py b/src/linkplay/controller.py index 012add7..d034488 100644 --- a/src/linkplay/controller.py +++ b/src/linkplay/controller.py @@ -33,11 +33,11 @@ async def discover_bridges(self) -> None: # Discover new bridges discovered_bridges = await discover_linkplay_bridges(self.session) - current_bridges = [bridge.device.uuid for bridge in self.bridges] + current_bridges = [bridge.player.uuid for bridge in self.bridges] new_bridges = [ discovered_bridge for discovered_bridge in discovered_bridges - if discovered_bridge.device.uuid not in current_bridges + if discovered_bridge.player.uuid not in current_bridges ] self.bridges.extend(new_bridges) @@ -45,7 +45,7 @@ async def find_bridge(self, bridge_uuid: str) -> LinkPlayBridge | None: """Find a LinkPlay device by its bridge uuid.""" for bridge in self.bridges: - if bridge.device.uuid == bridge_uuid: + if bridge.player.uuid == bridge_uuid: return bridge return None @@ -54,17 +54,17 @@ async def add_bridge(self, bridge_to_add: LinkPlayBridge) -> None: """Add given LinkPlay device if not already added.""" # Add bridge - current_bridges = [bridge.device.uuid for bridge in self.bridges] - if bridge_to_add.device.uuid not in current_bridges: - bridge_to_add.device.set_callback(self.get_bridge_callback()) + current_bridges = [bridge.player.uuid for bridge in self.bridges] + if bridge_to_add.player.uuid not in current_bridges: + bridge_to_add.player.set_callback(self.get_bridge_callback()) self.bridges.append(bridge_to_add) async def remove_bridge(self, bridge_to_remove: LinkPlayBridge) -> None: """Remove given LinkPlay device if not already deleted.""" # Remove bridge - current_bridges = [bridge.device.uuid for bridge in self.bridges] - if bridge_to_remove.device.uuid in current_bridges: + current_bridges = [bridge.player.uuid for bridge in self.bridges] + if bridge_to_remove.player.uuid in current_bridges: self.bridges.remove(bridge_to_remove) async def discover_multirooms(self) -> None: diff --git a/src/linkplay/discovery.py b/src/linkplay/discovery.py index e17d3a8..1e00994 100644 --- a/src/linkplay/discovery.py +++ b/src/linkplay/discovery.py @@ -36,7 +36,7 @@ async def linkplay_factory_bridge_endpoint( Raises LinkPlayRequestException if the device is not an expected LinkPlay device.""" bridge: LinkPlayBridge = LinkPlayBridge(endpoint=endpoint) - await bridge.device.update_status() + await bridge.player.update_status() await bridge.player.update_status() return bridge @@ -80,7 +80,7 @@ async def add_linkplay_device_to_list(upnp_device: CaseInsensitiveDict): try: bridge = await linkplay_factory_httpapi_bridge(ip_address, session) - bridges[bridge.device.uuid] = bridge + bridges[bridge.player.uuid] = bridge except LinkPlayRequestException: pass @@ -93,7 +93,7 @@ async def add_linkplay_device_to_list(upnp_device: CaseInsensitiveDict): multiroom_discovered_bridges: dict[str, LinkPlayBridge] = {} for bridge in bridges.values(): for new_bridge in await discover_bridges_through_multiroom(bridge, session): - multiroom_discovered_bridges[new_bridge.device.uuid] = new_bridge + multiroom_discovered_bridges[new_bridge.player.uuid] = new_bridge bridges = bridges | multiroom_discovered_bridges diff --git a/tests/linkplay/test_bridge.py b/tests/linkplay/test_bridge.py index 100a8f1..53d592f 100644 --- a/tests/linkplay/test_bridge.py +++ b/tests/linkplay/test_bridge.py @@ -1,12 +1,11 @@ """Test bridge functionality.""" from typing import Any -from unittest.mock import AsyncMock, MagicMock, Mock, patch +from unittest.mock import AsyncMock, MagicMock, Mock, call, patch import pytest from linkplay.bridge import ( LinkPlayBridge, - LinkPlayDevice, LinkPlayMultiroom, LinkPlayPlayer, ) @@ -34,7 +33,7 @@ def test_device_name(): bridge: LinkPlayBridge = LinkPlayBridge(endpoint=endpoint) assert f"{bridge}" == "http://1.2.3.4" - bridge.device.properties[DeviceAttribute.DEVICE_NAME] = "TestDevice" + bridge.player.device_properties[DeviceAttribute.DEVICE_NAME] = "TestDevice" assert f"{bridge}" == "TestDevice" @@ -42,18 +41,23 @@ async def test_device_update_status(): """Tests if the device update status is correctly called.""" bridge = AsyncMock() bridge.json_request.return_value = {DeviceAttribute.UUID: "1234"} - device = LinkPlayDevice(bridge) + device = LinkPlayPlayer(bridge) await device.update_status() - bridge.json_request.assert_called_once_with(LinkPlayCommand.DEVICE_STATUS) + bridge.json_request.assert_has_calls( + [ + call(LinkPlayCommand.DEVICE_STATUS), + call(LinkPlayCommand.PLAYER_STATUS), + ] + ) assert device.uuid == "1234" async def test_device_reboot(): """Tests if the device update is correctly called.""" bridge = AsyncMock() - device = LinkPlayDevice(bridge) + device = LinkPlayPlayer(bridge) await device.reboot() @@ -63,7 +67,7 @@ async def test_device_reboot(): async def test_deserialize_device(): """Test the device to deserialize correctly.""" bridge = AsyncMock() - device = LinkPlayDevice(bridge) + device = LinkPlayPlayer(bridge) device.to_dict() @@ -76,7 +80,12 @@ async def test_player_update_status(): await player.update_status() - bridge.json_request.assert_called_once_with(LinkPlayCommand.PLAYER_STATUS) + bridge.json_request.assert_has_calls( + [ + call(LinkPlayCommand.DEVICE_STATUS), + call(LinkPlayCommand.PLAYER_STATUS), + ] + ) async def test_player_update_status_calls_fixup_player_properties(): @@ -229,11 +238,9 @@ async def test_player_invalid_playmode(): async def test_player_get_equalizer_mode_wiim(): """Tests if the player handles an return the equalizer mode correctly.""" bridge = AsyncMock() - device = LinkPlayDevice(bridge) player = LinkPlayPlayer(bridge) - bridge.device = device bridge.player = player - bridge.device.properties[DeviceAttribute.PROJECT] = "WiiM_Pro_with_gc4a" + bridge.player.device_properties[DeviceAttribute.PROJECT] = "WiiM_Pro_with_gc4a" player.properties[PlayerAttribute.EQUALIZER_MODE] = 0 @@ -319,12 +326,12 @@ async def test_player_set_play_mode(): async def test_player_play_preset_when_max_key_empty(preset_number: int): """Tests if a player is able to play a preset.""" bridge = AsyncMock() - device = LinkPlayDevice(bridge) + device = LinkPlayPlayer(bridge) player = LinkPlayPlayer(bridge) bridge.device = device bridge.player = player - bridge.device.properties[DeviceAttribute.PRESET_KEY] = "" + bridge.player.properties[DeviceAttribute.PRESET_KEY] = "" await player.play_preset(preset_number) @@ -337,7 +344,7 @@ async def test_player_play_preset_when_max_key_empty(preset_number: int): async def test_player_play_preset(preset_number: int): """Tests if a player is able to play a preset.""" bridge = AsyncMock() - device = LinkPlayDevice(bridge) + device = LinkPlayPlayer(bridge) player = LinkPlayPlayer(bridge) bridge.device = device bridge.player = player @@ -359,7 +366,7 @@ async def test_player_play_preset(preset_number: int): async def test_player_play_preset_raises_value_error(preset_number: int): """Tests that a player fails in an expected way if play preset input is incorrect.""" bridge = AsyncMock() - device = LinkPlayDevice(bridge) + device = LinkPlayPlayer(bridge) player = LinkPlayPlayer(bridge) bridge.device = device bridge.player = player @@ -413,14 +420,14 @@ async def test_multiroom_ungroup(): async def test_multiroom_add_follower(): """Tests if multiroom add follower is correctly called on the follower.""" leader = AsyncMock() - leader.device.eth = "1.2.3.4" + leader.player.eth = "1.2.3.4" follower = AsyncMock() multiroom = LinkPlayMultiroom(leader) await multiroom.add_follower(follower) follower.request.assert_called_once_with( - LinkPlayCommand.MULTIROOM_JOIN.format(leader.device.eth) + LinkPlayCommand.MULTIROOM_JOIN.format(leader.player.eth) ) assert multiroom.followers == [follower] @@ -429,14 +436,14 @@ async def test_multiroom_remove_follower(): """Tests if multiroom remove folllower is correctly called on the leader.""" leader = AsyncMock() follower = AsyncMock() - follower.device.eth = "1.2.3.4" + follower.player.eth = "1.2.3.4" multiroom = LinkPlayMultiroom(leader) multiroom.followers = [follower] await multiroom.remove_follower(follower) leader.request.assert_called_once_with( - LinkPlayCommand.MULTIROOM_KICK.format(follower.device.eth) + LinkPlayCommand.MULTIROOM_KICK.format(follower.player.eth) ) assert not multiroom.followers @@ -485,13 +492,13 @@ async def test_multiroom_set_volume_raises_value_error(volume: int): @pytest.fixture def mock_bridge(): bridge = Mock(spec=LinkPlayBridge) - bridge.device = Mock(spec=LinkPlayDevice) + bridge.player = Mock(spec=LinkPlayPlayer) return bridge def test_set_callback_assigns_controller(mock_bridge): """Test that set_callback assigns the controller correctly.""" - device = LinkPlayDevice(mock_bridge) + device = LinkPlayPlayer(mock_bridge) mock_controller = Mock() device.set_callback(mock_controller) @@ -505,7 +512,7 @@ async def test_update_status_triggers_controller_on_mode_change_to_follower( ): """Test that update_status triggers the controller when playing mode changes to FOLLOWER.""" player = LinkPlayPlayer(mock_bridge) - mock_bridge.device.controller = Mock() + mock_bridge.player.controller = Mock() # Simulate initial state player.previous_playing_mode = PlayingMode.IDLE @@ -516,7 +523,7 @@ async def test_update_status_triggers_controller_on_mode_change_to_follower( # Call update_status and verify controller is called await player.update_status() - mock_bridge.device.controller.assert_called_once() + mock_bridge.player.controller.assert_called_once() @pytest.mark.asyncio @@ -525,7 +532,7 @@ async def test_update_status_triggers_controller_on_mode_change_from_follower( ): """Test that update_status triggers the controller when playing mode changes from FOLLOWER.""" player = LinkPlayPlayer(mock_bridge) - mock_bridge.device.controller = Mock() + mock_bridge.player.controller = Mock() # Simulate initial state player.previous_playing_mode = PlayingMode.FOLLOWER @@ -536,14 +543,14 @@ async def test_update_status_triggers_controller_on_mode_change_from_follower( # Call update_status and verify controller is called await player.update_status() - mock_bridge.device.controller.assert_called_once() + mock_bridge.player.controller.assert_called_once() @pytest.mark.asyncio async def test_update_status_does_not_trigger_controller_on_no_mode_change(mock_bridge): """Test that update_status does not trigger the controller when playing mode remains FOLLOWER.""" player = LinkPlayPlayer(mock_bridge) - mock_bridge.device.controller = Mock() + mock_bridge.player.controller = Mock() # Simulate no change in playing mode player.previous_playing_mode = PlayingMode.FOLLOWER @@ -553,7 +560,7 @@ async def test_update_status_does_not_trigger_controller_on_no_mode_change(mock_ await player.update_status() - mock_bridge.device.controller.assert_not_called() + mock_bridge.player.controller.assert_not_called() player.previous_playing_mode = PlayingMode.IDLE mock_bridge.json_request = AsyncMock( @@ -562,7 +569,7 @@ async def test_update_status_does_not_trigger_controller_on_no_mode_change(mock_ await player.update_status() - mock_bridge.device.controller.assert_not_called() + mock_bridge.player.controller.assert_not_called() async def test_meta_info_failed_handling(): @@ -584,8 +591,8 @@ async def mock_session_call_api_json_side_effect(endpoint, session, command): protocol="http", port=80, endpoint="1.2.3.4", session=None ) ) - mock_bridge.device = MagicMock() - mock_bridge.device.manufacturer = ( + mock_bridge.player = MagicMock() + mock_bridge.player.manufacturer = ( MANUFACTURER_WIIM # Set the manufacturer to WiiM ) @@ -621,8 +628,8 @@ async def mock_session_call_api_json_side_effect(endpoint, session, command): protocol="http", port=80, endpoint="1.2.3.4", session=None ) ) - mock_bridge.device = MagicMock() - mock_bridge.device.manufacturer = ( + mock_bridge.player = MagicMock() + mock_bridge.player.manufacturer = ( MANUFACTURER_WIIM # Set the manufacturer to WiiM ) diff --git a/tests/linkplay/test_controller.py b/tests/linkplay/test_controller.py index 264b25c..d81d30a 100644 --- a/tests/linkplay/test_controller.py +++ b/tests/linkplay/test_controller.py @@ -2,7 +2,7 @@ import pytest from aiohttp import ClientSession -from linkplay.bridge import LinkPlayBridge, LinkPlayDevice, LinkPlayMultiroom +from linkplay.bridge import LinkPlayBridge, LinkPlayMultiroom, LinkPlayPlayer from linkplay.controller import LinkPlayController from linkplay.exceptions import LinkPlayInvalidDataException @@ -20,8 +20,8 @@ def controller(mock_session): @pytest.fixture def mock_bridge(): bridge = MagicMock(spec=LinkPlayBridge) - bridge.device = MagicMock(spec=LinkPlayDevice) - bridge.device.uuid = "mock-uuid" + bridge.player = MagicMock(spec=LinkPlayPlayer) + bridge.player.uuid = "mock-uuid" return bridge @@ -74,9 +74,9 @@ async def test_discover_bridges(): # Mock the discover_linkplay_bridges function mock_bridge_1 = AsyncMock() - mock_bridge_1.device.uuid = "uuid-1" + mock_bridge_1.player.uuid = "uuid-1" mock_bridge_2 = AsyncMock() - mock_bridge_2.device.uuid = "uuid-2" + mock_bridge_2.player.uuid = "uuid-2" with patch( "linkplay.controller.discover_linkplay_bridges", @@ -90,8 +90,8 @@ async def test_discover_bridges(): # Assert bridges were added to the controller assert len(controller.bridges) == 2 - assert controller.bridges[0].device.uuid == "uuid-1" - assert controller.bridges[1].device.uuid == "uuid-2" + assert controller.bridges[0].player.uuid == "uuid-1" + assert controller.bridges[1].player.uuid == "uuid-2" # Call discover_bridges again with no new bridges await controller.discover_bridges()