ucapi-framework 1.2.2__tar.gz → 1.3.0__tar.gz

{ucapi_framework-1.2.2 → ucapi_framework-1.3.0}/PKG-INFO

@@ -1,11 +1,11 @@
 Metadata-Version: 2.4
 Name: ucapi-framework
-Version: 1.2.2
+Version: 1.3.0
 Summary: ucapi framework that provides core functionality for building integrations.
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 Requires-Dist: pyee>=9.0.0
-Requires-Dist: ucapi>=0.4.0
+Requires-Dist: ucapi>=0.5.0
 Requires-Dist: aiohttp>=3.9.0
 
 [![Tests](https://github.com/jackjpowell/ucapi-framework/actions/workflows/test.yml/badge.svg)](https://github.com/jackjpowell/ucapi-framework/actions/workflows/test.yml)

{ucapi_framework-1.2.2 → ucapi_framework-1.3.0}/pyproject.toml

@@ -1,12 +1,12 @@
 [project]
 name = "ucapi-framework"
-version = "1.2.2"
+version = "1.3.0"
 description = "ucapi framework that provides core functionality for building integrations."
 readme = "README.md"
 requires-python = ">=3.11"
 dependencies = [
     "pyee>=9.0.0",
-    "ucapi>=0.4.0",
+    "ucapi>=0.5.0",
     "aiohttp>=3.9.0",
 ]
 
@@ -19,6 +19,7 @@ dev = [
 docs = [
     "mkdocs-material>=9.5.0",
     "mkdocstrings[python]>=0.24.0",
+    "mkdocstrings-python>=1.0.0",
 ]
 
 [tool.pytest.ini_options]

{ucapi_framework-1.2.2 → ucapi_framework-1.3.0}/tests/test_driver.py

@@ -153,6 +153,12 @@ class MockEntityCollection:
     def contains(self, entity_id):
         return any(e.id == entity_id for e in self._entities)
 
+    def get(self, entity_id):
+        for e in self._entities:
+            if e.id == entity_id:
+                return e
+        return None
+
     def get_all(self):
         # Return list of dicts matching ucapi Entities.get_all() behavior
         return [
@@ -761,10 +767,9 @@ class TestBaseIntegrationDriver:
         assert entity_type == "light"
 
     def test_entity_type_from_entity_id_invalid(self, driver):
-        """Test entity_type_from_entity_id with invalid entity ID."""
-        entity_type = driver.entity_type_from_entity_id("invalid")
-
-        assert entity_type is None
+        """Test entity_type_from_entity_id with invalid entity ID raises ValueError."""
+        with pytest.raises(ValueError, match="does not contain the expected separator"):
+            driver.entity_type_from_entity_id("invalid")
 
     def test_entity_type_from_entity_id_none(self, driver):
         """Test entity_type_from_entity_id with None."""
@@ -799,10 +804,9 @@ class TestBaseIntegrationDriver:
         assert sub_device == "zone.outlet_1"
 
     def test_sub_device_from_entity_id_invalid(self, driver):
-        """Test sub_device_from_entity_id with invalid entity ID."""
-        sub_device = driver.sub_device_from_entity_id("invalid")
-
-        assert sub_device is None
+        """Test sub_device_from_entity_id with invalid entity ID raises ValueError."""
+        with pytest.raises(ValueError, match="does not contain the expected separator"):
+            driver.sub_device_from_entity_id("invalid")
 
     def test_sub_device_from_entity_id_none(self, driver):
         """Test sub_device_from_entity_id with None."""
@@ -837,68 +841,14 @@ class TestBaseIntegrationDriver:
 
         # Test invalid formats
         assert driver.device_from_entity_id("") is None
-        assert driver.device_from_entity_id("invalid") is None
+        with pytest.raises(ValueError, match="does not contain the expected separator"):
+            driver.device_from_entity_id("invalid")
         assert driver.device_from_entity_id("only.one") == "one"
 
-    def test_entity_type_from_entity_id_requires_override_when_create_entities_overridden(
-        self, mock_loop
-    ):
-        """Test that overriding create_entities requires overriding entity_type_from_entity_id."""
-
-        class DriverWithCustomEntities(BaseIntegrationDriver):
-            """Driver that overrides create_entities but not entity_type_from_entity_id."""
-
-            def create_entities(self, device_config, device):
-                # Custom entity creation with non-standard ID format
-                return []
-
-            def device_from_entity_id(self, entity_id):
-                return entity_id  # Custom format
-
-            def get_entity_ids_for_device(self, device_id):
-                return [device_id]  # Custom format
-
-        driver = DriverWithCustomEntities(DeviceForTests, [], loop=mock_loop)
-
-        # Should raise NotImplementedError with helpful message
-        with pytest.raises(
-            NotImplementedError,
-            match="create_entities\\(\\) is overridden but entity_type_from_entity_id\\(\\) is not",
-        ):
-            driver.entity_type_from_entity_id("custom_entity_id")
-
     def test_sub_device_from_entity_id_requires_override_when_3_part_format_used(
         self, mock_loop
     ):
-        """Test that overriding create_entities with 3-part format requires overriding sub_device_from_entity_id."""
-
-        class DriverWith3PartEntities(BaseIntegrationDriver):
-            """Driver that overrides create_entities with 3-part format but not sub_device_from_entity_id."""
-
-            def create_entities(self, device_config, device):
-                # Custom entity creation with 3-part format
-                return []
-
-            def entity_type_from_entity_id(self, entity_id):
-                return "light"
-
-            def device_from_entity_id(self, entity_id):
-                return "hub_1"
-
-            def get_entity_ids_for_device(self, device_id):
-                return [f"light.{device_id}.bedroom"]  # 3-part format
-
-        driver = DriverWith3PartEntities(DeviceForTests, [], loop=mock_loop)
-
-        # Should raise NotImplementedError when 3-part format is detected
-        with pytest.raises(
-            NotImplementedError,
-            match="create_entities\\(\\) is overridden and uses 3-part entity IDs.*sub_device_from_entity_id\\(\\) is not",
-        ):
-            driver.sub_device_from_entity_id("light.hub_1.bedroom")
-
-    def test_sub_device_from_entity_id_no_error_for_2_part_format(self, mock_loop):
-        """Test that overriding create_entities with 2-part format doesn't require overriding sub_device_from_entity_id."""
+        """Test that sub_device_from_entity_id works with standard 2-part format."""
 
         class DriverWith2PartEntities(BaseIntegrationDriver):
             """Driver that overrides create_entities with 2-part format."""
@@ -907,45 +857,15 @@ class TestBaseIntegrationDriver:
                 # Custom entity creation with 2-part format (no sub-devices)
                 return []
 
-            def entity_type_from_entity_id(self, entity_id):
-                return "media_player"
-
-            def device_from_entity_id(self, entity_id):
-                return entity_id  # Custom format
-
             def get_entity_ids_for_device(self, device_id):
                 return [f"media_player.{device_id}"]  # 2-part format
 
         driver = DriverWith2PartEntities(DeviceForTests, [], loop=mock_loop)
 
-        # Should NOT raise error for 2-part format
+        # Should work fine with 2-part format (using default separator)
         result = driver.sub_device_from_entity_id("media_player.dev1")
         assert result is None  # 2-part format has no sub-device
 
-    def test_device_from_entity_id_requires_override_when_create_entities_overridden(
-        self, mock_loop
-    ):
-        """Test that overriding create_entities requires overriding device_from_entity_id."""
-
-        class DriverWithCustomEntities(BaseIntegrationDriver):
-            """Driver that overrides create_entities but not device_from_entity_id."""
-
-            def create_entities(self, device_config, device):
-                # Custom entity creation with non-standard ID format
-                return []
-
-            def get_entity_ids_for_device(self, device_id):
-                return [device_id]  # Custom format
-
-        driver = DriverWithCustomEntities(DeviceForTests, [], loop=mock_loop)
-
-        # Should raise NotImplementedError with helpful message
-        with pytest.raises(
-            NotImplementedError,
-            match="create_entities\\(\\) is overridden but device_from_entity_id\\(\\) is not",
-        ):
-            driver.device_from_entity_id("custom_entity_id")
-
     def test_device_from_entity_id_works_when_both_overridden(self, mock_loop):
         """Test that both methods can be overridden together successfully."""
 
@@ -969,6 +889,54 @@ class TestBaseIntegrationDriver:
         assert driver.device_from_entity_id("my_device_id") == "my_device_id"
         assert driver.device_from_entity_id("account_123") == "account_123"
 
+    def test_custom_entity_id_separator(self, mock_loop):
+        """Test using a custom entity_id_separator."""
+
+        class DriverWithCustomSeparator(BaseIntegrationDriver):
+            """Driver using underscore as separator."""
+
+            def __init__(self, *args, **kwargs):
+                super().__init__(*args, **kwargs)
+                self.entity_id_separator = "_"
+
+            def create_entities(self, device_config, device):
+                return []
+
+            def get_entity_ids_for_device(self, device_id):
+                return []
+
+        driver = DriverWithCustomSeparator(DeviceForTests, [], loop=mock_loop)
+
+        # Should parse using underscore separator
+        assert driver.entity_type_from_entity_id("media_player_dev1") == "media"
+        assert driver.device_from_entity_id("media_player_dev1") == "player"
+        assert driver.sub_device_from_entity_id("light_hub1_bedroom") == "bedroom"
+
+    def test_custom_separator_raises_error_for_wrong_format(self, mock_loop):
+        """Test that ValueError is raised when entity_id doesn't contain custom separator."""
+
+        class DriverWithCustomSeparator(BaseIntegrationDriver):
+            """Driver using underscore as separator."""
+
+            def __init__(self, *args, **kwargs):
+                super().__init__(*args, **kwargs)
+                self.entity_id_separator = "_"
+
+            def create_entities(self, device_config, device):
+                return []
+
+            def get_entity_ids_for_device(self, device_id):
+                return []
+
+        driver = DriverWithCustomSeparator(DeviceForTests, [], loop=mock_loop)
+
+        # Should raise ValueError when period is used instead of underscore
+        # Use an entity_id that has period but no underscore
+        with pytest.raises(
+            ValueError, match="does not contain the expected separator '_'"
+        ):
+            driver.entity_type_from_entity_id("type.dev1")
+
     def test_get_entity_ids_for_device(self, driver):
         """Test getting entity IDs for a device."""
         # Add a device so entities are registered
@@ -1934,13 +1902,11 @@ class TestOnSubscribeEntitiesEdgeCases:
 
     @pytest.mark.asyncio
     async def test_on_subscribe_entities_invalid_entity_id(self):
-        """Test on_subscribe_entities with invalid entity ID format."""
+        """Test on_subscribe_entities with invalid entity ID format raises ValueError."""
         driver = self._create_driver()
-        # Entity ID without dots can't be parsed
-        await driver.on_subscribe_entities(["invalid_entity_id"])
-
-        # Should return early without adding any devices
-        assert len(driver._configured_devices) == 0
+        # Entity ID without dots can't be parsed and should raise ValueError
+        with pytest.raises(ValueError, match="does not contain the expected separator"):
+            await driver.on_subscribe_entities(["invalid_entity_id"])
 
     @pytest.mark.asyncio
     async def test_on_subscribe_entities_no_device_config(self):
@@ -1991,6 +1957,8 @@ class TestDeviceEventHandlersEntityTypes:
             EntityTypes.REMOTE,
             EntityTypes.SENSOR,
             EntityTypes.SWITCH,
+            EntityTypes.IR_EMITTER,
+            EntityTypes.VOICE_ASSISTANT,
         ]:
             mock_entity = MagicMock()
             mock_entity.entity_type = entity_type
@@ -2017,6 +1985,8 @@ class TestDeviceEventHandlersEntityTypes:
             EntityTypes.REMOTE,
             EntityTypes.SENSOR,
             EntityTypes.SWITCH,
+            EntityTypes.IR_EMITTER,
+            EntityTypes.VOICE_ASSISTANT,
         ]:
             mock_entity = MagicMock()
             mock_entity.entity_type = entity_type
@@ -2043,6 +2013,8 @@ class TestDeviceEventHandlersEntityTypes:
             EntityTypes.REMOTE,
             EntityTypes.SENSOR,
             EntityTypes.SWITCH,
+            EntityTypes.IR_EMITTER,
+            EntityTypes.VOICE_ASSISTANT,
         ]:
             mock_entity = MagicMock()
             mock_entity.entity_type = entity_type
@@ -2214,6 +2186,40 @@ class TestOnDeviceUpdateEntityTypes:
 
         driver.api.configured_entities.update_attributes.assert_called()
 
+    @pytest.mark.asyncio
+    async def test_on_device_update_ir_emitter(self):
+        """Test on_device_update for IR emitter entity."""
+        driver = self._create_driver()
+        config = DeviceConfigForTests("dev1", "Device 1", "192.168.1.1")
+        driver.add_configured_device(config, connect=False)
+
+        mock_entity = MagicMock()
+        mock_entity.entity_type = EntityTypes.IR_EMITTER
+        driver.api.configured_entities.get = MagicMock(return_value=mock_entity)
+        driver.api.configured_entities.contains = MagicMock(return_value=True)
+        driver.api.configured_entities.update_attributes = MagicMock()
+
+        await driver.on_device_update("dev1", {"state": "on"})
+
+        driver.api.configured_entities.update_attributes.assert_called()
+
+    @pytest.mark.asyncio
+    async def test_on_device_update_voice_assistant(self):
+        """Test on_device_update for voice assistant entity."""
+        driver = self._create_driver()
+        config = DeviceConfigForTests("dev1", "Device 1", "192.168.1.1")
+        driver.add_configured_device(config, connect=False)
+
+        mock_entity = MagicMock()
+        mock_entity.entity_type = EntityTypes.VOICE_ASSISTANT
+        driver.api.configured_entities.get = MagicMock(return_value=mock_entity)
+        driver.api.configured_entities.contains = MagicMock(return_value=True)
+        driver.api.configured_entities.update_attributes = MagicMock()
+
+        await driver.on_device_update("dev1", {"state": "on"})
+
+        driver.api.configured_entities.update_attributes.assert_called()
+
     @pytest.mark.asyncio
     async def test_on_device_update_unknown_entity_type(self, caplog):
         """Test on_device_update with unknown entity type logs warning."""
@@ -2248,3 +2254,336 @@ class TestOnDeviceUpdateEntityTypes:
         await driver.on_device_update("dev1", None)
 
         assert "Received None update" in caplog.text
+
+
+class TestDriverCoverageGaps:
+    """Additional tests to fill coverage gaps."""
+
+    def _create_driver(self):
+        """Create a driver for testing."""
+        loop = asyncio.get_event_loop()
+        driver = ConcreteDriver(DeviceForTests, [media_player.MediaPlayer], loop=loop)
+        driver.api = MagicMock()
+        driver.api.configured_entities = MagicMock()
+        driver.api.available_entities = MockEntityCollection()
+        driver.api.set_device_state = AsyncMock()
+        return driver
+
+    @pytest.mark.asyncio
+    async def test_on_device_connected_unknown_device(self, caplog):
+        """Test on_device_connected with unknown device logs warning."""
+        import logging
+
+        caplog.set_level(logging.WARNING)
+
+        driver = self._create_driver()
+        # Don't add any device - call on_device_connected with unknown device
+        await driver.on_device_connected("unknown_device")
+
+        assert "Device unknown_device is not configured" in caplog.text
+
+    @pytest.mark.asyncio
+    async def test_on_device_update_media_player_clears_media_when_off(self):
+        """Test on_device_update clears media attributes when media player turns OFF."""
+        driver = self._create_driver()
+        config = DeviceConfigForTests("dev1", "Device 1", "192.168.1.1")
+        driver.add_configured_device(config, connect=False)
+
+        mock_entity = MagicMock()
+        mock_entity.entity_type = EntityTypes.MEDIA_PLAYER
+        driver.api.configured_entities.get = MagicMock(return_value=mock_entity)
+        driver.api.configured_entities.contains = MagicMock(return_value=True)
+        driver.api.configured_entities.update_attributes = MagicMock()
+
+        # Send update with OFF state
+        await driver.on_device_update("dev1", {"state": "OFF"})
+
+        # Should have cleared media attributes
+        call_args = driver.api.configured_entities.update_attributes.call_args
+        assert call_args is not None
+        attributes = call_args[0][1]
+
+        # Check that media attributes are cleared
+        assert media_player.Attributes.MEDIA_DURATION in attributes
+        assert media_player.Attributes.MEDIA_POSITION in attributes
+        assert media_player.Attributes.MEDIA_TITLE in attributes
+
+    @pytest.mark.asyncio
+    async def test_on_device_update_entity_not_found(self, caplog):
+        """Test on_device_update when entity is not found in configured or available."""
+        import logging
+
+        caplog.set_level(logging.DEBUG)
+
+        driver = self._create_driver()
+        config = DeviceConfigForTests("dev1", "Device 1", "192.168.1.1")
+        driver.add_configured_device(config, connect=False)
+
+        # Entity not found
+        driver.api.configured_entities.get = MagicMock(return_value=None)
+        driver.api.available_entities = MockEntityCollection()  # Empty
+
+        await driver.on_device_update("dev1", {"state": "on"})
+
+        assert "Entity not found" in caplog.text
+
+    def test_entity_type_from_entity_id_no_period(self):
+        """Test entity_type_from_entity_id with entity_id that has no period raises ValueError."""
+        driver = self._create_driver()
+        with pytest.raises(ValueError, match="does not contain the expected separator"):
+            driver.entity_type_from_entity_id("no_period")
+
+    def test_entity_type_from_entity_id_empty(self):
+        """Test entity_type_from_entity_id with empty entity_id."""
+        driver = self._create_driver()
+        result = driver.entity_type_from_entity_id("")
+        assert result is None
+
+    def test_device_from_entity_id_no_period(self):
+        """Test device_from_entity_id with entity_id that has no period raises ValueError."""
+        driver = self._create_driver()
+        with pytest.raises(ValueError, match="does not contain the expected separator"):
+            driver.device_from_entity_id("no_period")
+
+    def test_device_from_entity_id_empty(self):
+        """Test device_from_entity_id with empty entity_id."""
+        driver = self._create_driver()
+        result = driver.device_from_entity_id("")
+        assert result is None
+
+    def test_sub_device_from_entity_id_no_sub_device(self):
+        """Test sub_device_from_entity_id when no sub-device present."""
+        driver = self._create_driver()
+        result = driver.sub_device_from_entity_id("media_player.dev1")
+        assert result is None
+
+    def test_sub_device_from_entity_id_with_sub_device(self):
+        """Test sub_device_from_entity_id with sub-device."""
+        driver = self._create_driver()
+        result = driver.sub_device_from_entity_id("media_player.dev1.zone2")
+        assert result == "zone2"
+
+    def test_remove_device_not_found(self, caplog):
+        """Test remove_device when device is not found."""
+        import logging
+
+        caplog.set_level(logging.WARNING)
+
+        driver = self._create_driver()
+        driver.remove_device("nonexistent")
+
+        assert "Device nonexistent not found" in caplog.text
+
+
+class TestCreateEntities:
+    """Tests for create_entities() override pattern."""
+
+    def test_create_entities_default_uses_entity_classes(self, mock_loop):
+        """Test default create_entities instantiates from entity_classes."""
+
+        # Create a custom entity class that accepts (device_config, device)
+        class TestMediaPlayer(media_player.MediaPlayer):
+            def __init__(self, device_config, device):
+                super().__init__(
+                    f"media_player.{device_config.identifier}",
+                    device_config.name,
+                    features=[media_player.Features.ON_OFF],
+                    attributes={
+                        media_player.Attributes.STATE: media_player.States.UNKNOWN
+                    },
+                )
+
+        class MinimalDriver(BaseIntegrationDriver):
+            pass
+
+        # Pass actual entity class
+        driver = MinimalDriver(
+            device_class=DeviceForTests,
+            entity_classes=[TestMediaPlayer],
+            loop=mock_loop,
+        )
+        config = DeviceConfigForTests("test", "Test Device", "192.168.1.1")
+        device = DeviceForTests(config, loop=mock_loop)
+
+        entities = driver.create_entities(config, device)
+        # Should use default: instantiate from entity_classes
+        assert len(entities) == 1
+        assert isinstance(entities[0], media_player.MediaPlayer)
+        assert entities[0].id == "media_player.test"
+
+    def test_create_entities_override_for_multiple_zones(self, mock_loop):
+        """Test overriding create_entities for multiple zones pattern."""
+
+        @dataclass
+        class ZoneConfig:
+            id: str
+            name: str
+
+        @dataclass
+        class MultiZoneConfig:
+            identifier: str
+            name: str
+            address: str
+            zones: list[ZoneConfig]
+
+        class MultiZoneDriver(BaseIntegrationDriver):
+            def create_entities(self, device_config, device):
+                entities = []
+                for zone in device_config.zones:
+                    entities.append(
+                        media_player.MediaPlayer(
+                            f"media_player.{device_config.identifier}_zone_{zone.id}",
+                            f"{device_config.name} {zone.name}",
+                            features=[media_player.Features.ON_OFF],
+                            attributes={
+                                media_player.Attributes.STATE: media_player.States.UNKNOWN
+                            },
+                        )
+                    )
+                return entities
+
+        driver = MultiZoneDriver(
+            device_class=DeviceForTests,
+            entity_classes=EntityTypes.MEDIA_PLAYER,
+            loop=mock_loop,
+        )
+        config = MultiZoneConfig(
+            "receiver",
+            "AV Receiver",
+            "192.168.1.100",
+            [
+                ZoneConfig("1", "Main"),
+                ZoneConfig("2", "Zone 2"),
+                ZoneConfig("3", "Zone 3"),
+            ],
+        )
+        device = DeviceForTests(config, loop=mock_loop)
+
+        entities = driver.create_entities(config, device)
+        assert len(entities) == 3
+        assert entities[0].id == "media_player.receiver_zone_1"
+        assert entities[0].name["en"] == "AV Receiver Main"
+        assert entities[1].id == "media_player.receiver_zone_2"
+        assert entities[2].id == "media_player.receiver_zone_3"
+
+    def test_create_entities_override_hub_discovery(self, mock_loop):
+        """Test overriding create_entities for hub discovery with multiple entity types."""
+        from ucapi import light, cover
+
+        class HubDriver(BaseIntegrationDriver):
+            def create_entities(self, device_config, device):
+                entities = []
+                # Simulate hub discovery
+                entities.append(
+                    light.Light(
+                        f"light.{device_config.identifier}_light1",
+                        "Living Room Light",
+                        features=[light.Features.ON_OFF, light.Features.DIM],
+                        attributes={light.Attributes.STATE: light.States.OFF},
+                    )
+                )
+                entities.append(
+                    light.Light(
+                        f"light.{device_config.identifier}_light2",
+                        "Bedroom Light",
+                        features=[light.Features.ON_OFF],
+                        attributes={light.Attributes.STATE: light.States.OFF},
+                    )
+                )
+                entities.append(
+                    cover.Cover(
+                        f"cover.{device_config.identifier}_cover1",
+                        "Living Room Blinds",
+                        features=[cover.Features.OPEN, cover.Features.CLOSE],
+                        attributes={cover.Attributes.STATE: cover.States.CLOSED},
+                    )
+                )
+                return entities
+
+        driver = HubDriver(
+            device_class=DeviceForTests,
+            entity_classes=[EntityTypes.LIGHT, EntityTypes.COVER],
+            loop=mock_loop,
+        )
+        config = DeviceConfigForTests("hub1", "Smart Hub", "192.168.1.50")
+        device = DeviceForTests(config, loop=mock_loop)
+
+        entities = driver.create_entities(config, device)
+        assert len(entities) == 3
+        assert entities[0].id == "light.hub1_light1"
+        assert entities[1].id == "light.hub1_light2"
+        assert entities[2].id == "cover.hub1_cover1"
+
+    def test_create_entities_conditional_based_on_capabilities(self, mock_loop):
+        """Test conditional entity creation based on device capabilities."""
+        from ucapi import remote
+
+        @dataclass
+        class CapableDeviceConfig:
+            identifier: str
+            name: str
+            address: str
+            supports_playback: bool
+            supports_remote: bool
+
+        class CapableDevice(DeviceForTests):
+            def __init__(self, device_config, loop):
+                super().__init__(device_config, loop)
+                self.supports_playback = device_config.supports_playback
+                self.supports_remote = device_config.supports_remote
+
+        class ConditionalDriver(BaseIntegrationDriver):
+            def create_entities(self, device_config, device):
+                entities = []
+                if device.supports_playback:
+                    entities.append(
+                        media_player.MediaPlayer(
+                            f"media_player.{device_config.identifier}",
+                            device_config.name,
+                            features=[media_player.Features.ON_OFF],
+                            attributes={
+                                media_player.Attributes.STATE: media_player.States.UNKNOWN
+                            },
+                        )
+                    )
+                if device.supports_remote:
+                    entities.append(
+                        remote.Remote(
+                            f"remote.{device_config.identifier}",
+                            device_config.name,
+                            features=[remote.Features.SEND_CMD],
+                            attributes={remote.Attributes.STATE: remote.States.UNKNOWN},
+                        )
+                    )
+                return entities
+
+        driver = ConditionalDriver(
+            device_class=CapableDevice,
+            entity_classes=[EntityTypes.MEDIA_PLAYER, EntityTypes.REMOTE],
+            loop=mock_loop,
+        )
+
+        # Test with both capabilities
+        config_both = CapableDeviceConfig(
+            "test1", "Test Both", "192.168.1.1", True, True
+        )
+        device_both = CapableDevice(config_both, loop=mock_loop)
+        entities = driver.create_entities(config_both, device_both)
+        assert len(entities) == 2
+
+        # Test with only playback
+        config_playback = CapableDeviceConfig(
+            "test2", "Test Playback", "192.168.1.2", True, False
+        )
+        device_playback = CapableDevice(config_playback, loop=mock_loop)
+        entities = driver.create_entities(config_playback, device_playback)
+        assert len(entities) == 1
+        assert entities[0].id == "media_player.test2"
+
+        # Test with neither
+        config_none = CapableDeviceConfig(
+            "test3", "Test None", "192.168.1.3", False, False
+        )
+        device_none = CapableDevice(config_none, loop=mock_loop)
+        entities = driver.create_entities(config_none, device_none)
+        assert len(entities) == 0