New overrides in universal media player (#48611)

* Update media_player.py

fix missing overrides in universal

* Update media_player.py

Black

* add tests and allow overrides for missing services

* switch sync to async

* Update tests/components/universal/test_media_player.py

Co-authored-by: Martin Hjelmare <marhje52@gmail.com>

* setup component after modifying config

* switch test to sync

* fix black

* fix test

* rework tests, disable override media_seek

Co-authored-by: raman325 <7243222+raman325@users.noreply.github.com>
Co-authored-by: Martin Hjelmare <marhje52@gmail.com>

homeassistant/components/universal/media_player.py

@@ -46,6 +46,7 @@ from homeassistant.components.media_player.const import (
     SUPPORT_NEXT_TRACK,
     SUPPORT_PAUSE,
     SUPPORT_PLAY,
+    SUPPORT_PLAY_MEDIA,
     SUPPORT_PREVIOUS_TRACK,
     SUPPORT_REPEAT_SET,
     SUPPORT_SELECT_SOUND_MODE,
@@ -485,6 +486,9 @@ class UniversalMediaPlayer(MediaPlayerEntity):
         ):
             flags |= SUPPORT_SELECT_SOURCE
 
+        if SERVICE_PLAY_MEDIA in self._cmds:
+            flags |= SUPPORT_PLAY_MEDIA
+
         if SERVICE_CLEAR_PLAYLIST in self._cmds:
             flags |= SUPPORT_CLEAR_PLAYLIST
 
@@ -538,23 +542,25 @@ class UniversalMediaPlayer(MediaPlayerEntity):
 
     async def async_media_play(self):
         """Send play command."""
-        await self._async_call_service(SERVICE_MEDIA_PLAY)
+        await self._async_call_service(SERVICE_MEDIA_PLAY, allow_override=True)
 
     async def async_media_pause(self):
         """Send pause command."""
-        await self._async_call_service(SERVICE_MEDIA_PAUSE)
+        await self._async_call_service(SERVICE_MEDIA_PAUSE, allow_override=True)
 
     async def async_media_stop(self):
         """Send stop command."""
-        await self._async_call_service(SERVICE_MEDIA_STOP)
+        await self._async_call_service(SERVICE_MEDIA_STOP, allow_override=True)
 
     async def async_media_previous_track(self):
         """Send previous track command."""
-        await self._async_call_service(SERVICE_MEDIA_PREVIOUS_TRACK)
+        await self._async_call_service(
+            SERVICE_MEDIA_PREVIOUS_TRACK, allow_override=True
+        )
 
     async def async_media_next_track(self):
         """Send next track command."""
-        await self._async_call_service(SERVICE_MEDIA_NEXT_TRACK)
+        await self._async_call_service(SERVICE_MEDIA_NEXT_TRACK, allow_override=True)
 
     async def async_media_seek(self, position):
         """Send seek command."""
@@ -564,7 +570,7 @@ class UniversalMediaPlayer(MediaPlayerEntity):
     async def async_play_media(self, media_type, media_id, **kwargs):
         """Play a piece of media."""
         data = {ATTR_MEDIA_CONTENT_TYPE: media_type, ATTR_MEDIA_CONTENT_ID: media_id}
-        await self._async_call_service(SERVICE_PLAY_MEDIA, data)
+        await self._async_call_service(SERVICE_PLAY_MEDIA, data, allow_override=True)
 
     async def async_volume_up(self):
         """Turn volume up for media player."""
@@ -576,7 +582,7 @@ class UniversalMediaPlayer(MediaPlayerEntity):
 
     async def async_media_play_pause(self):
         """Play or pause the media player."""
-        await self._async_call_service(SERVICE_MEDIA_PLAY_PAUSE)
+        await self._async_call_service(SERVICE_MEDIA_PLAY_PAUSE, allow_override=True)
 
     async def async_select_sound_mode(self, sound_mode):
         """Select sound mode."""
@@ -592,7 +598,7 @@ class UniversalMediaPlayer(MediaPlayerEntity):
 
     async def async_clear_playlist(self):
         """Clear players playlist."""
-        await self._async_call_service(SERVICE_CLEAR_PLAYLIST)
+        await self._async_call_service(SERVICE_CLEAR_PLAYLIST, allow_override=True)
 
     async def async_set_shuffle(self, shuffle):
         """Enable/disable shuffling."""
@@ -606,7 +612,7 @@ class UniversalMediaPlayer(MediaPlayerEntity):
 
     async def async_toggle(self):
         """Toggle the power on the media player."""
-        await self._async_call_service(SERVICE_TOGGLE)
+        await self._async_call_service(SERVICE_TOGGLE, allow_override=True)
 
     async def async_update(self):
         """Update state in HA."""

tests/components/universal/test_media_player.py

@@ -22,7 +22,7 @@ from homeassistant.const import (
     STATE_UNKNOWN,
 )
 from homeassistant.core import Context, callback
-from homeassistant.setup import async_setup_component
+from homeassistant.setup import async_setup_component, setup_component
 
 from tests.common import get_test_home_assistant, mock_service
 
@@ -630,7 +630,7 @@ class TestMediaPlayer(unittest.TestCase):
     def test_supported_features_children_and_cmds(self):
         """Test supported media commands with children and attrs."""
         config = copy(self.config_children_and_attr)
-        excmd = {"service": "media_player.test", "data": {"entity_id": "test"}}
+        excmd = {"service": "media_player.test", "data": {}}
         config["commands"] = {
             "turn_on": excmd,
             "turn_off": excmd,
@@ -648,6 +648,7 @@ class TestMediaPlayer(unittest.TestCase):
             "media_next_track": excmd,
             "media_previous_track": excmd,
             "toggle": excmd,
+            "play_media": excmd,
             "clear_playlist": excmd,
         }
         config = validate_config(config)
@@ -676,11 +677,185 @@ class TestMediaPlayer(unittest.TestCase):
             | universal.SUPPORT_STOP
             | universal.SUPPORT_NEXT_TRACK
             | universal.SUPPORT_PREVIOUS_TRACK
+            | universal.SUPPORT_PLAY_MEDIA
             | universal.SUPPORT_CLEAR_PLAYLIST
         )
 
         assert check_flags == ump.supported_features
 
+    def test_overrides(self):
+        """Test overrides."""
+        config = copy(self.config_children_and_attr)
+        excmd = {"service": "test.override", "data": {}}
+        config["name"] = "overridden"
+        config["commands"] = {
+            "turn_on": excmd,
+            "turn_off": excmd,
+            "volume_up": excmd,
+            "volume_down": excmd,
+            "volume_mute": excmd,
+            "volume_set": excmd,
+            "select_sound_mode": excmd,
+            "select_source": excmd,
+            "repeat_set": excmd,
+            "shuffle_set": excmd,
+            "media_play": excmd,
+            "media_play_pause": excmd,
+            "media_pause": excmd,
+            "media_stop": excmd,
+            "media_next_track": excmd,
+            "media_previous_track": excmd,
+            "clear_playlist": excmd,
+            "play_media": excmd,
+            "toggle": excmd,
+        }
+        setup_component(self.hass, "media_player", {"media_player": config})
+
+        service = mock_service(self.hass, "test", "override")
+        self.hass.services.call(
+            "media_player",
+            "turn_on",
+            service_data={"entity_id": "media_player.overridden"},
+            blocking=True,
+        )
+        assert len(service) == 1
+        self.hass.services.call(
+            "media_player",
+            "turn_off",
+            service_data={"entity_id": "media_player.overridden"},
+            blocking=True,
+        )
+        assert len(service) == 2
+        self.hass.services.call(
+            "media_player",
+            "volume_up",
+            service_data={"entity_id": "media_player.overridden"},
+            blocking=True,
+        )
+        assert len(service) == 3
+        self.hass.services.call(
+            "media_player",
+            "volume_down",
+            service_data={"entity_id": "media_player.overridden"},
+            blocking=True,
+        )
+        assert len(service) == 4
+        self.hass.services.call(
+            "media_player",
+            "volume_mute",
+            service_data={
+                "entity_id": "media_player.overridden",
+                "is_volume_muted": True,
+            },
+            blocking=True,
+        )
+        assert len(service) == 5
+        self.hass.services.call(
+            "media_player",
+            "volume_set",
+            service_data={"entity_id": "media_player.overridden", "volume_level": 1},
+            blocking=True,
+        )
+        assert len(service) == 6
+        self.hass.services.call(
+            "media_player",
+            "select_sound_mode",
+            service_data={
+                "entity_id": "media_player.overridden",
+                "sound_mode": "music",
+            },
+            blocking=True,
+        )
+        assert len(service) == 7
+        self.hass.services.call(
+            "media_player",
+            "select_source",
+            service_data={"entity_id": "media_player.overridden", "source": "video1"},
+            blocking=True,
+        )
+        assert len(service) == 8
+        self.hass.services.call(
+            "media_player",
+            "repeat_set",
+            service_data={"entity_id": "media_player.overridden", "repeat": "all"},
+            blocking=True,
+        )
+        assert len(service) == 9
+        self.hass.services.call(
+            "media_player",
+            "shuffle_set",
+            service_data={"entity_id": "media_player.overridden", "shuffle": True},
+            blocking=True,
+        )
+        assert len(service) == 10
+        self.hass.services.call(
+            "media_player",
+            "media_play",
+            service_data={"entity_id": "media_player.overridden"},
+            blocking=True,
+        )
+        assert len(service) == 11
+        self.hass.services.call(
+            "media_player",
+            "media_pause",
+            service_data={"entity_id": "media_player.overridden"},
+            blocking=True,
+        )
+        assert len(service) == 12
+        self.hass.services.call(
+            "media_player",
+            "media_stop",
+            service_data={"entity_id": "media_player.overridden"},
+            blocking=True,
+        )
+        assert len(service) == 13
+        self.hass.services.call(
+            "media_player",
+            "media_next_track",
+            service_data={"entity_id": "media_player.overridden"},
+            blocking=True,
+        )
+        assert len(service) == 14
+        self.hass.services.call(
+            "media_player",
+            "media_previous_track",
+            service_data={"entity_id": "media_player.overridden"},
+            blocking=True,
+        )
+        assert len(service) == 15
+        self.hass.services.call(
+            "media_player",
+            "clear_playlist",
+            service_data={"entity_id": "media_player.overridden"},
+            blocking=True,
+        )
+        assert len(service) == 16
+        self.hass.services.call(
+            "media_player",
+            "media_play_pause",
+            service_data={"entity_id": "media_player.overridden"},
+            blocking=True,
+        )
+        assert len(service) == 17
+        self.hass.services.call(
+            "media_player",
+            "play_media",
+            service_data={
+                "entity_id": "media_player.overridden",
+                "media_content_id": 1,
+                "media_content_type": "channel",
+            },
+            blocking=True,
+        )
+        assert len(service) == 18
+        self.hass.services.call(
+            "media_player",
+            "toggle",
+            service_data={"entity_id": "media_player.overridden"},
+            blocking=True,
+        )
+        assert len(service) == 19
+
     def test_supported_features_play_pause(self):
         """Test supported media commands with play_pause function."""
         config = copy(self.config_children_and_attr)