evlli/hass-core
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Migrates tests to use MediaPlayerEntityFeature enum (#86779)

Browse source
This commit is contained in:
Franck Nijhof 2023-01-27 10:56:40 +01:00 • committed by GitHub
parent 42c4f2f7fa
commit fca3382d37
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
8 changed files with 79 additions and 80 deletions
Download patch file Download diff file Expand all files Collapse all files

62
tests/components/alexa/test_smart_home.py
View file

@ -8,22 +8,7 @@ import pytest
from homeassistant.components.alexa import messages, smart_home from homeassistant.components.alexa import messages, smart_home
import homeassistant.components.camera as camera import homeassistant.components.camera as camera
from homeassistant.components.cover import CoverDeviceClass from homeassistant.components.cover import CoverDeviceClass
from homeassistant.components.media_player import ( from homeassistant.components.media_player import MediaPlayerEntityFeature
SUPPORT_NEXT_TRACK,
SUPPORT_PAUSE,
SUPPORT_PLAY,
SUPPORT_PLAY_MEDIA,
SUPPORT_PREVIOUS_TRACK,
SUPPORT_SEEK,
SUPPORT_SELECT_SOUND_MODE,
SUPPORT_SELECT_SOURCE,
SUPPORT_STOP,
SUPPORT_TURN_OFF,
SUPPORT_TURN_ON,
SUPPORT_VOLUME_MUTE,
SUPPORT_VOLUME_SET,
SUPPORT_VOLUME_STEP,
)
import homeassistant.components.vacuum as vacuum import homeassistant.components.vacuum as vacuum
from homeassistant.config import async_process_ha_core_config from homeassistant.config import async_process_ha_core_config
from homeassistant.const import STATE_UNKNOWN, UnitOfTemperature from homeassistant.const import STATE_UNKNOWN, UnitOfTemperature
@ -1131,17 +1116,17 @@ async def test_media_player(hass):
"off", "off",
{ {
"friendly_name": "Test media player", "friendly_name": "Test media player",
"supported_features": SUPPORT_NEXT_TRACK "supported_features": MediaPlayerEntityFeature.NEXT_TRACK
| SUPPORT_PAUSE | MediaPlayerEntityFeature.PAUSE
| SUPPORT_PLAY | MediaPlayerEntityFeature.PLAY
| SUPPORT_PLAY_MEDIA | MediaPlayerEntityFeature.PLAY_MEDIA
| SUPPORT_PREVIOUS_TRACK | MediaPlayerEntityFeature.PREVIOUS_TRACK
| SUPPORT_SELECT_SOURCE | MediaPlayerEntityFeature.SELECT_SOURCE
| SUPPORT_STOP | MediaPlayerEntityFeature.STOP
| SUPPORT_TURN_OFF | MediaPlayerEntityFeature.TURN_OFF
| SUPPORT_TURN_ON | MediaPlayerEntityFeature.TURN_ON
| SUPPORT_VOLUME_MUTE | MediaPlayerEntityFeature.VOLUME_MUTE
| SUPPORT_VOLUME_SET, | MediaPlayerEntityFeature.VOLUME_SET,
"volume_level": 0.75, "volume_level": 0.75,
"source_list": ["hdmi", "tv"], "source_list": ["hdmi", "tv"],
}, },
@ -1339,7 +1324,7 @@ async def test_media_player_inputs(hass):
"on", "on",
{ {
"friendly_name": "Test media player", "friendly_name": "Test media player",
"supported_features": SUPPORT_SELECT_SOURCE, "supported_features": MediaPlayerEntityFeature.SELECT_SOURCE,
"volume_level": 0.75, "volume_level": 0.75,
"source_list": [ "source_list": [
"foo", "foo",
@ -1443,7 +1428,7 @@ async def test_media_player_no_supported_inputs(hass):
"off", "off",
{ {
"friendly_name": "Test media player", "friendly_name": "Test media player",
"supported_features": SUPPORT_SELECT_SOURCE, "supported_features": MediaPlayerEntityFeature.SELECT_SOURCE,
"volume_level": 0.75, "volume_level": 0.75,
"source_list": [ "source_list": [
"foo", "foo",
@ -1478,7 +1463,8 @@ async def test_media_player_speaker(hass):
"off", "off",
{ {
"friendly_name": "Test media player speaker", "friendly_name": "Test media player speaker",
"supported_features": SUPPORT_VOLUME_MUTE | SUPPORT_VOLUME_SET, "supported_features": MediaPlayerEntityFeature.VOLUME_MUTE
| MediaPlayerEntityFeature.VOLUME_SET,
"volume_level": 0.75, "volume_level": 0.75,
"device_class": "speaker", "device_class": "speaker",
}, },
@ -1551,7 +1537,8 @@ async def test_media_player_step_speaker(hass):
"off", "off",
{ {
"friendly_name": "Test media player step speaker", "friendly_name": "Test media player step speaker",
"supported_features": SUPPORT_VOLUME_MUTE | SUPPORT_VOLUME_STEP, "supported_features": MediaPlayerEntityFeature.VOLUME_MUTE
| MediaPlayerEntityFeature.VOLUME_STEP,
"device_class": "speaker", "device_class": "speaker",
}, },
) )
@ -1616,7 +1603,7 @@ async def test_media_player_seek(hass):
"playing", "playing",
{ {
"friendly_name": "Test media player seek", "friendly_name": "Test media player seek",
"supported_features": SUPPORT_SEEK, "supported_features": MediaPlayerEntityFeature.SEEK,
"media_position": 300, # 5min "media_position": 300, # 5min
"media_duration": 600, # 10min "media_duration": 600, # 10min
}, },
@ -1701,7 +1688,10 @@ async def test_media_player_seek_error(hass):
device = ( device = (
"media_player.test_seek", "media_player.test_seek",
"playing", "playing",
{"friendly_name": "Test media player seek", "supported_features": SUPPORT_SEEK}, {
"friendly_name": "Test media player seek",
"supported_features": MediaPlayerEntityFeature.SEEK,
},
) )
await discovery_test(device, hass) await discovery_test(device, hass)
@ -3529,7 +3519,7 @@ async def test_media_player_eq_modes(hass):
"on", "on",
{ {
"friendly_name": "Test media player", "friendly_name": "Test media player",
"supported_features": SUPPORT_SELECT_SOUND_MODE, "supported_features": MediaPlayerEntityFeature.SELECT_SOUND_MODE,
"sound_mode": "tv", "sound_mode": "tv",
"sound_mode_list": ["movie", "music", "night", "sport", "tv", "rocknroll"], "sound_mode_list": ["movie", "music", "night", "sport", "tv", "rocknroll"],
}, },
@ -3577,7 +3567,7 @@ async def test_media_player_sound_mode_list_unsupported(hass):
"on", "on",
{ {
"friendly_name": "Test media player", "friendly_name": "Test media player",
"supported_features": SUPPORT_SELECT_SOUND_MODE, "supported_features": MediaPlayerEntityFeature.SELECT_SOUND_MODE,
"sound_mode": "unknown", "sound_mode": "unknown",
"sound_mode_list": ["unsupported", "non-existing"], "sound_mode_list": ["unsupported", "non-existing"],
}, },
@ -3599,7 +3589,7 @@ async def test_media_player_eq_bands_not_supported(hass):
"on", "on",
{ {
"friendly_name": "Test media player", "friendly_name": "Test media player",
"supported_features": SUPPORT_SELECT_SOUND_MODE, "supported_features": MediaPlayerEntityFeature.SELECT_SOUND_MODE,
"sound_mode": "tv", "sound_mode": "tv",
"sound_mode_list": ["movie", "music", "night", "sport", "tv", "rocknroll"], "sound_mode_list": ["movie", "music", "night", "sport", "tv", "rocknroll"],
}, },

10
tests/components/blackbird/test_media_player.py
View file

@ -11,11 +11,7 @@ from homeassistant.components.blackbird.media_player import (
PLATFORM_SCHEMA, PLATFORM_SCHEMA,
setup_platform, setup_platform,
) )
from homeassistant.components.media_player import ( from homeassistant.components.media_player import MediaPlayerEntityFeature
SUPPORT_SELECT_SOURCE,
SUPPORT_TURN_OFF,
SUPPORT_TURN_ON,
)
from homeassistant.const import STATE_OFF, STATE_ON from homeassistant.const import STATE_OFF, STATE_ON
@ -290,7 +286,9 @@ async def test_state(hass, media_player_entity, mock_blackbird):
async def test_supported_features(media_player_entity): async def test_supported_features(media_player_entity):
"""Test supported features property.""" """Test supported features property."""
assert ( assert (
SUPPORT_TURN_ON | SUPPORT_TURN_OFF | SUPPORT_SELECT_SOURCE MediaPlayerEntityFeature.TURN_ON
| MediaPlayerEntityFeature.TURN_OFF
| MediaPlayerEntityFeature.SELECT_SOURCE
== media_player_entity.supported_features == media_player_entity.supported_features
) )

47
tests/components/google_assistant/test_trait.py
View file

@ -1865,7 +1865,10 @@ async def test_inputselector(hass):
"""Test input selector trait.""" """Test input selector trait."""
assert helpers.get_google_type(media_player.DOMAIN, None) is not None assert helpers.get_google_type(media_player.DOMAIN, None) is not None
assert trait.InputSelectorTrait.supported( assert trait.InputSelectorTrait.supported(
media_player.DOMAIN, media_player.SUPPORT_SELECT_SOURCE, None, None media_player.DOMAIN,
media_player.MediaPlayerEntityFeature.SELECT_SOURCE,
None,
None,
) )
trt = trait.InputSelectorTrait( trt = trait.InputSelectorTrait(
@ -2252,7 +2255,10 @@ async def test_sound_modes(hass):
"""Test Mode trait.""" """Test Mode trait."""
assert helpers.get_google_type(media_player.DOMAIN, None) is not None assert helpers.get_google_type(media_player.DOMAIN, None) is not None
assert trait.ModesTrait.supported( assert trait.ModesTrait.supported(
media_player.DOMAIN, media_player.SUPPORT_SELECT_SOUND_MODE, None, None media_player.DOMAIN,
media_player.MediaPlayerEntityFeature.SELECT_SOUND_MODE,
None,
None,
) )
trt = trait.ModesTrait( trt = trait.ModesTrait(
@ -2698,7 +2704,10 @@ async def test_volume_media_player(hass):
"""Test volume trait support for media player domain.""" """Test volume trait support for media player domain."""
assert helpers.get_google_type(media_player.DOMAIN, None) is not None assert helpers.get_google_type(media_player.DOMAIN, None) is not None
assert trait.VolumeTrait.supported( assert trait.VolumeTrait.supported(
media_player.DOMAIN, media_player.SUPPORT_VOLUME_SET, None, None media_player.DOMAIN,
media_player.MediaPlayerEntityFeature.VOLUME_SET,
None,
None,
) )
trt = trait.VolumeTrait( trt = trait.VolumeTrait(
@ -2707,7 +2716,7 @@ async def test_volume_media_player(hass):
"media_player.bla", "media_player.bla",
media_player.STATE_PLAYING, media_player.STATE_PLAYING,
{ {
ATTR_SUPPORTED_FEATURES: media_player.SUPPORT_VOLUME_SET, ATTR_SUPPORTED_FEATURES: media_player.MediaPlayerEntityFeature.VOLUME_SET,
media_player.ATTR_MEDIA_VOLUME_LEVEL: 0.3, media_player.ATTR_MEDIA_VOLUME_LEVEL: 0.3,
}, },
), ),
@ -2749,7 +2758,10 @@ async def test_volume_media_player(hass):
async def test_volume_media_player_relative(hass): async def test_volume_media_player_relative(hass):
"""Test volume trait support for relative-volume-only media players.""" """Test volume trait support for relative-volume-only media players."""
assert trait.VolumeTrait.supported( assert trait.VolumeTrait.supported(
media_player.DOMAIN, media_player.SUPPORT_VOLUME_STEP, None, None media_player.DOMAIN,
media_player.MediaPlayerEntityFeature.VOLUME_STEP,
None,
None,
) )
trt = trait.VolumeTrait( trt = trait.VolumeTrait(
hass, hass,
@ -2758,7 +2770,7 @@ async def test_volume_media_player_relative(hass):
media_player.STATE_PLAYING, media_player.STATE_PLAYING,
{ {
ATTR_ASSUMED_STATE: True, ATTR_ASSUMED_STATE: True,
ATTR_SUPPORTED_FEATURES: media_player.SUPPORT_VOLUME_STEP, ATTR_SUPPORTED_FEATURES: media_player.MediaPlayerEntityFeature.VOLUME_STEP,
}, },
), ),
BASIC_CONFIG, BASIC_CONFIG,
@ -2815,7 +2827,8 @@ async def test_media_player_mute(hass):
"""Test volume trait support for muting.""" """Test volume trait support for muting."""
assert trait.VolumeTrait.supported( assert trait.VolumeTrait.supported(
media_player.DOMAIN, media_player.DOMAIN,
media_player.SUPPORT_VOLUME_STEP | media_player.SUPPORT_VOLUME_MUTE, media_player.MediaPlayerEntityFeature.VOLUME_STEP
| media_player.MediaPlayerEntityFeature.VOLUME_MUTE,
None, None,
None, None,
) )
@ -2826,7 +2839,8 @@ async def test_media_player_mute(hass):
media_player.STATE_PLAYING, media_player.STATE_PLAYING,
{ {
ATTR_SUPPORTED_FEATURES: ( ATTR_SUPPORTED_FEATURES: (
media_player.SUPPORT_VOLUME_STEP | media_player.SUPPORT_VOLUME_MUTE media_player.MediaPlayerEntityFeature.VOLUME_STEP
| media_player.MediaPlayerEntityFeature.VOLUME_MUTE
), ),
media_player.ATTR_MEDIA_VOLUME_MUTED: False, media_player.ATTR_MEDIA_VOLUME_MUTED: False,
}, },
@ -2986,8 +3000,8 @@ async def test_transport_control(hass):
media_player.ATTR_MEDIA_POSITION_UPDATED_AT: now media_player.ATTR_MEDIA_POSITION_UPDATED_AT: now
- timedelta(seconds=10), - timedelta(seconds=10),
media_player.ATTR_MEDIA_VOLUME_LEVEL: 0.5, media_player.ATTR_MEDIA_VOLUME_LEVEL: 0.5,
ATTR_SUPPORTED_FEATURES: media_player.SUPPORT_PLAY ATTR_SUPPORTED_FEATURES: media_player.MediaPlayerEntityFeature.PLAY
| media_player.SUPPORT_STOP, | media_player.MediaPlayerEntityFeature.STOP,
}, },
), ),
BASIC_CONFIG, BASIC_CONFIG,
@ -3101,7 +3115,7 @@ async def test_media_state(hass, state):
assert helpers.get_google_type(media_player.DOMAIN, None) is not None assert helpers.get_google_type(media_player.DOMAIN, None) is not None
assert trait.TransportControlTrait.supported( assert trait.TransportControlTrait.supported(
media_player.DOMAIN, media_player.SUPPORT_PLAY, None, None media_player.DOMAIN, media_player.MediaPlayerEntityFeature.PLAY, None, None
) )
trt = trait.MediaStateTrait( trt = trait.MediaStateTrait(
@ -3113,8 +3127,8 @@ async def test_media_state(hass, state):
media_player.ATTR_MEDIA_POSITION: 100, media_player.ATTR_MEDIA_POSITION: 100,
media_player.ATTR_MEDIA_DURATION: 200, media_player.ATTR_MEDIA_DURATION: 200,
media_player.ATTR_MEDIA_VOLUME_LEVEL: 0.5, media_player.ATTR_MEDIA_VOLUME_LEVEL: 0.5,
ATTR_SUPPORTED_FEATURES: media_player.SUPPORT_PLAY ATTR_SUPPORTED_FEATURES: media_player.MediaPlayerEntityFeature.PLAY
| media_player.SUPPORT_STOP, | media_player.MediaPlayerEntityFeature.STOP,
}, },
), ),
BASIC_CONFIG, BASIC_CONFIG,
@ -3135,13 +3149,16 @@ async def test_channel(hass):
assert helpers.get_google_type(media_player.DOMAIN, None) is not None assert helpers.get_google_type(media_player.DOMAIN, None) is not None
assert trait.ChannelTrait.supported( assert trait.ChannelTrait.supported(
media_player.DOMAIN, media_player.DOMAIN,
media_player.SUPPORT_PLAY_MEDIA, media_player.MediaPlayerEntityFeature.PLAY_MEDIA,
media_player.MediaPlayerDeviceClass.TV, media_player.MediaPlayerDeviceClass.TV,
None, None,
) )
assert ( assert (
trait.ChannelTrait.supported( trait.ChannelTrait.supported(
media_player.DOMAIN, media_player.SUPPORT_PLAY_MEDIA, None, None media_player.DOMAIN,
media_player.MediaPlayerEntityFeature.PLAY_MEDIA,
None,
None,
) )
is False is False
) )

4
tests/components/homekit/test_get_accessories.py
View file

@ -179,8 +179,8 @@ def test_type_covers(type_name, entity_id, state, attrs):
"media_player.test", "media_player.test",
"on", "on",
{ {
ATTR_SUPPORTED_FEATURES: media_player_c.SUPPORT_TURN_ON ATTR_SUPPORTED_FEATURES: media_player_c.MediaPlayerEntityFeature.TURN_ON
| media_player_c.SUPPORT_TURN_OFF | media_player_c.MediaPlayerEntityFeature.TURN_OFF
}, },
{CONF_FEATURE_LIST: {FEATURE_ON_OFF: None}}, {CONF_FEATURE_LIST: {FEATURE_ON_OFF: None}},
), ),

10
tests/components/homekit_controller/specific_devices/test_lg_tv.py
View file

@ -1,10 +1,6 @@
"""Make sure that handling real world LG HomeKit characteristics isn't broken.""" """Make sure that handling real world LG HomeKit characteristics isn't broken."""
from homeassistant.components.media_player import ( from homeassistant.components.media_player import MediaPlayerEntityFeature
SUPPORT_PAUSE,
SUPPORT_PLAY,
SUPPORT_SELECT_SOURCE,
)
from ..common import ( from ..common import (
HUB_TEST_ACCESSORY_ID, HUB_TEST_ACCESSORY_ID,
@ -38,7 +34,9 @@ async def test_lg_tv(hass):
friendly_name="LG webOS TV AF80", friendly_name="LG webOS TV AF80",
unique_id="00:00:00:00:00:00_1_48", unique_id="00:00:00:00:00:00_1_48",
supported_features=( supported_features=(
SUPPORT_PAUSE | SUPPORT_PLAY | SUPPORT_SELECT_SOURCE MediaPlayerEntityFeature.PAUSE
| MediaPlayerEntityFeature.PLAY
| MediaPlayerEntityFeature.SELECT_SOURCE
), ),
capabilities={ capabilities={
"source_list": [ "source_list": [

19
tests/components/monoprice/test_media_player.py
View file

@ -10,12 +10,7 @@ from homeassistant.components.media_player import (
ATTR_MEDIA_VOLUME_LEVEL, ATTR_MEDIA_VOLUME_LEVEL,
DOMAIN as MEDIA_PLAYER_DOMAIN, DOMAIN as MEDIA_PLAYER_DOMAIN,
SERVICE_SELECT_SOURCE, SERVICE_SELECT_SOURCE,
SUPPORT_SELECT_SOURCE, MediaPlayerEntityFeature,
SUPPORT_TURN_OFF,
SUPPORT_TURN_ON,
SUPPORT_VOLUME_MUTE,
SUPPORT_VOLUME_SET,
SUPPORT_VOLUME_STEP,
) )
from homeassistant.components.monoprice.const import ( from homeassistant.components.monoprice.const import (
CONF_NOT_FIRST_RUN, CONF_NOT_FIRST_RUN,
@ -364,12 +359,12 @@ async def test_supported_features(hass):
state = hass.states.get(ZONE_1_ID) state = hass.states.get(ZONE_1_ID)
assert ( assert (
SUPPORT_VOLUME_MUTE MediaPlayerEntityFeature.VOLUME_MUTE
| SUPPORT_VOLUME_SET | MediaPlayerEntityFeature.VOLUME_SET
| SUPPORT_VOLUME_STEP | MediaPlayerEntityFeature.VOLUME_STEP
| SUPPORT_TURN_ON | MediaPlayerEntityFeature.TURN_ON
| SUPPORT_TURN_OFF | MediaPlayerEntityFeature.TURN_OFF
| SUPPORT_SELECT_SOURCE | MediaPlayerEntityFeature.SELECT_SOURCE
== state.attributes["supported_features"] == state.attributes["supported_features"]
) )

5
tests/components/samsungtv/test_init.py
View file

@ -3,7 +3,7 @@ from unittest.mock import Mock, patch
import pytest import pytest
from homeassistant.components.media_player import DOMAIN, SUPPORT_TURN_ON from homeassistant.components.media_player import DOMAIN, MediaPlayerEntityFeature
from homeassistant.components.samsungtv.const import ( from homeassistant.components.samsungtv.const import (
CONF_MANUFACTURER, CONF_MANUFACTURER,
CONF_ON_ACTION, CONF_ON_ACTION,
@ -87,7 +87,8 @@ async def test_setup(hass: HomeAssistant) -> None:
assert state assert state
assert state.name == "fake_name" assert state.name == "fake_name"
assert ( assert (
state.attributes[ATTR_SUPPORTED_FEATURES] == SUPPORT_SAMSUNGTV | SUPPORT_TURN_ON state.attributes[ATTR_SUPPORTED_FEATURES]
== SUPPORT_SAMSUNGTV | MediaPlayerEntityFeature.TURN_ON
) )
# test host and port # test host and port

2
tests/components/webostv/test_media_player.py
View file

@ -582,7 +582,7 @@ async def test_cached_supported_features(hass, client, monkeypatch):
await client.mock_state_update() await client.mock_state_update()
# TV off, restored state supports mute, step # TV off, restored state supports mute, step
# validate SUPPORT_TURN_ON is not cached # validate MediaPlayerEntityFeature.TURN_ON is not cached
attrs = hass.states.get(ENTITY_ID).attributes attrs = hass.states.get(ENTITY_ID).attributes
assert ( assert (