jeans/core
jeans/core
1
0
Fork 0
mirror of https://github.com/home-assistant/core.git synced 2025-07-23 21:27:38 +00:00
Code Issues Packages Projects Releases Wiki Activity

Fix root-import pylint warning in dlna_dmr tests (#119286)

Browse Source
This commit is contained in:
epenet 2024-06-10 13:31:29 +02:00 committed by GitHub
parent 8cbfc5a58b
commit 94720fd015
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
1 changed files with 107 additions and 112 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

219
tests/components/dlna_dmr/test_media_player.py
View File

@ -20,7 +20,7 @@ from didl_lite import didl_lite
import pytest import pytest
from homeassistant import const as ha_const from homeassistant import const as ha_const
from homeassistant.components import ssdp from homeassistant.components import media_player as mp, ssdp
from homeassistant.components.dlna_dmr.const import ( from homeassistant.components.dlna_dmr.const import (
CONF_BROWSE_UNFILTERED, CONF_BROWSE_UNFILTERED,
CONF_CALLBACK_URL_OVERRIDE, CONF_CALLBACK_URL_OVERRIDE,
@ -31,13 +31,10 @@ from homeassistant.components.dlna_dmr.const import (
from homeassistant.components.dlna_dmr.data import EventListenAddr from homeassistant.components.dlna_dmr.data import EventListenAddr
from homeassistant.components.dlna_dmr.media_player import DlnaDmrEntity from homeassistant.components.dlna_dmr.media_player import DlnaDmrEntity
from homeassistant.components.media_player import ( from homeassistant.components.media_player import (
ATTR_TO_PROPERTY,
DOMAIN as MP_DOMAIN,
MediaPlayerEntityFeature, MediaPlayerEntityFeature,
MediaPlayerState, MediaPlayerState,
MediaType, MediaType,
RepeatMode, RepeatMode,
const as mp_const,
) )
from homeassistant.components.media_source import DOMAIN as MS_DOMAIN, PlayMedia from homeassistant.components.media_source import DOMAIN as MS_DOMAIN, PlayMedia
from homeassistant.const import ( from homeassistant.const import (
@ -551,56 +548,56 @@ async def test_attributes(
"""Test attributes of a connected DlnaDmrEntity.""" """Test attributes of a connected DlnaDmrEntity."""
# Check attributes come directly from the device # Check attributes come directly from the device
attrs = await get_attrs(hass, mock_entity_id) attrs = await get_attrs(hass, mock_entity_id)
assert attrs[mp_const.ATTR_MEDIA_VOLUME_LEVEL] is dmr_device_mock.volume_level assert attrs[mp.ATTR_MEDIA_VOLUME_LEVEL] is dmr_device_mock.volume_level
assert attrs[mp_const.ATTR_MEDIA_VOLUME_MUTED] is dmr_device_mock.is_volume_muted assert attrs[mp.ATTR_MEDIA_VOLUME_MUTED] is dmr_device_mock.is_volume_muted
assert attrs[mp_const.ATTR_MEDIA_DURATION] is dmr_device_mock.media_duration assert attrs[mp.ATTR_MEDIA_DURATION] is dmr_device_mock.media_duration
assert attrs[mp_const.ATTR_MEDIA_POSITION] is dmr_device_mock.media_position assert attrs[mp.ATTR_MEDIA_POSITION] is dmr_device_mock.media_position
assert ( assert (
attrs[mp_const.ATTR_MEDIA_POSITION_UPDATED_AT] attrs[mp.ATTR_MEDIA_POSITION_UPDATED_AT]
is dmr_device_mock.media_position_updated_at is dmr_device_mock.media_position_updated_at
) )
assert attrs[mp_const.ATTR_MEDIA_CONTENT_ID] is dmr_device_mock.current_track_uri assert attrs[mp.ATTR_MEDIA_CONTENT_ID] is dmr_device_mock.current_track_uri
assert attrs[mp_const.ATTR_MEDIA_ARTIST] is dmr_device_mock.media_artist assert attrs[mp.ATTR_MEDIA_ARTIST] is dmr_device_mock.media_artist
assert attrs[mp_const.ATTR_MEDIA_ALBUM_NAME] is dmr_device_mock.media_album_name assert attrs[mp.ATTR_MEDIA_ALBUM_NAME] is dmr_device_mock.media_album_name
assert attrs[mp_const.ATTR_MEDIA_ALBUM_ARTIST] is dmr_device_mock.media_album_artist assert attrs[mp.ATTR_MEDIA_ALBUM_ARTIST] is dmr_device_mock.media_album_artist
assert attrs[mp_const.ATTR_MEDIA_TRACK] is dmr_device_mock.media_track_number assert attrs[mp.ATTR_MEDIA_TRACK] is dmr_device_mock.media_track_number
assert attrs[mp_const.ATTR_MEDIA_SERIES_TITLE] is dmr_device_mock.media_series_title assert attrs[mp.ATTR_MEDIA_SERIES_TITLE] is dmr_device_mock.media_series_title
assert attrs[mp_const.ATTR_MEDIA_SEASON] is dmr_device_mock.media_season_number assert attrs[mp.ATTR_MEDIA_SEASON] is dmr_device_mock.media_season_number
assert attrs[mp_const.ATTR_MEDIA_EPISODE] is dmr_device_mock.media_episode_number assert attrs[mp.ATTR_MEDIA_EPISODE] is dmr_device_mock.media_episode_number
assert attrs[mp_const.ATTR_MEDIA_CHANNEL] is dmr_device_mock.media_channel_name assert attrs[mp.ATTR_MEDIA_CHANNEL] is dmr_device_mock.media_channel_name
assert attrs[mp_const.ATTR_SOUND_MODE_LIST] is dmr_device_mock.preset_names assert attrs[mp.ATTR_SOUND_MODE_LIST] is dmr_device_mock.preset_names
# Entity picture is cached, won't correspond to remote image # Entity picture is cached, won't correspond to remote image
assert isinstance(attrs[ha_const.ATTR_ENTITY_PICTURE], str) assert isinstance(attrs[ha_const.ATTR_ENTITY_PICTURE], str)
# media_title depends on what is available # media_title depends on what is available
assert attrs[mp_const.ATTR_MEDIA_TITLE] is dmr_device_mock.media_program_title assert attrs[mp.ATTR_MEDIA_TITLE] is dmr_device_mock.media_program_title
dmr_device_mock.media_program_title = None dmr_device_mock.media_program_title = None
attrs = await get_attrs(hass, mock_entity_id) attrs = await get_attrs(hass, mock_entity_id)
assert attrs[mp_const.ATTR_MEDIA_TITLE] is dmr_device_mock.media_title assert attrs[mp.ATTR_MEDIA_TITLE] is dmr_device_mock.media_title
# media_content_type is mapped from UPnP class to MediaPlayer type # media_content_type is mapped from UPnP class to MediaPlayer type
dmr_device_mock.media_class = "object.item.audioItem.musicTrack" dmr_device_mock.media_class = "object.item.audioItem.musicTrack"
attrs = await get_attrs(hass, mock_entity_id) attrs = await get_attrs(hass, mock_entity_id)
assert attrs[mp_const.ATTR_MEDIA_CONTENT_TYPE] == MediaType.MUSIC assert attrs[mp.ATTR_MEDIA_CONTENT_TYPE] == MediaType.MUSIC
dmr_device_mock.media_class = "object.item.videoItem.movie" dmr_device_mock.media_class = "object.item.videoItem.movie"
attrs = await get_attrs(hass, mock_entity_id) attrs = await get_attrs(hass, mock_entity_id)
assert attrs[mp_const.ATTR_MEDIA_CONTENT_TYPE] == MediaType.MOVIE assert attrs[mp.ATTR_MEDIA_CONTENT_TYPE] == MediaType.MOVIE
dmr_device_mock.media_class = "object.item.videoItem.videoBroadcast" dmr_device_mock.media_class = "object.item.videoItem.videoBroadcast"
attrs = await get_attrs(hass, mock_entity_id) attrs = await get_attrs(hass, mock_entity_id)
assert attrs[mp_const.ATTR_MEDIA_CONTENT_TYPE] == MediaType.TVSHOW assert attrs[mp.ATTR_MEDIA_CONTENT_TYPE] == MediaType.TVSHOW
# media_season & media_episode have a special case # media_season & media_episode have a special case
dmr_device_mock.media_season_number = "0" dmr_device_mock.media_season_number = "0"
dmr_device_mock.media_episode_number = "123" dmr_device_mock.media_episode_number = "123"
attrs = await get_attrs(hass, mock_entity_id) attrs = await get_attrs(hass, mock_entity_id)
assert attrs[mp_const.ATTR_MEDIA_SEASON] == "1" assert attrs[mp.ATTR_MEDIA_SEASON] == "1"
assert attrs[mp_const.ATTR_MEDIA_EPISODE] == "23" assert attrs[mp.ATTR_MEDIA_EPISODE] == "23"
dmr_device_mock.media_season_number = "0" dmr_device_mock.media_season_number = "0"
dmr_device_mock.media_episode_number = "S1E23" # Unexpected and not parsed dmr_device_mock.media_episode_number = "S1E23" # Unexpected and not parsed
attrs = await get_attrs(hass, mock_entity_id) attrs = await get_attrs(hass, mock_entity_id)
assert attrs[mp_const.ATTR_MEDIA_SEASON] == "0" assert attrs[mp.ATTR_MEDIA_SEASON] == "0"
assert attrs[mp_const.ATTR_MEDIA_EPISODE] == "S1E23" assert attrs[mp.ATTR_MEDIA_EPISODE] == "S1E23"
# shuffle and repeat is based on device's play mode # shuffle and repeat is based on device's play mode
for play_mode, shuffle, repeat in [ for play_mode, shuffle, repeat in [
@ -614,13 +611,13 @@ async def test_attributes(
]: ]:
dmr_device_mock.play_mode = play_mode dmr_device_mock.play_mode = play_mode
attrs = await get_attrs(hass, mock_entity_id) attrs = await get_attrs(hass, mock_entity_id)
assert attrs[mp_const.ATTR_MEDIA_SHUFFLE] is shuffle assert attrs[mp.ATTR_MEDIA_SHUFFLE] is shuffle
assert attrs[mp_const.ATTR_MEDIA_REPEAT] == repeat assert attrs[mp.ATTR_MEDIA_REPEAT] == repeat
for bad_play_mode in [None, PlayMode.VENDOR_DEFINED]: for bad_play_mode in [None, PlayMode.VENDOR_DEFINED]:
dmr_device_mock.play_mode = bad_play_mode dmr_device_mock.play_mode = bad_play_mode
attrs = await get_attrs(hass, mock_entity_id) attrs = await get_attrs(hass, mock_entity_id)
assert mp_const.ATTR_MEDIA_SHUFFLE not in attrs assert mp.ATTR_MEDIA_SHUFFLE not in attrs
assert mp_const.ATTR_MEDIA_REPEAT not in attrs assert mp.ATTR_MEDIA_REPEAT not in attrs
async def test_services( async def test_services(
@ -629,65 +626,65 @@ async def test_services(
"""Test service calls of a connected DlnaDmrEntity.""" """Test service calls of a connected DlnaDmrEntity."""
# Check interface methods interact directly with the device # Check interface methods interact directly with the device
await hass.services.async_call( await hass.services.async_call(
MP_DOMAIN, mp.DOMAIN,
ha_const.SERVICE_VOLUME_SET, ha_const.SERVICE_VOLUME_SET,
{ATTR_ENTITY_ID: mock_entity_id, mp_const.ATTR_MEDIA_VOLUME_LEVEL: 0.80}, {ATTR_ENTITY_ID: mock_entity_id, mp.ATTR_MEDIA_VOLUME_LEVEL: 0.80},
blocking=True, blocking=True,
) )
dmr_device_mock.async_set_volume_level.assert_awaited_once_with(0.80) dmr_device_mock.async_set_volume_level.assert_awaited_once_with(0.80)
await hass.services.async_call( await hass.services.async_call(
MP_DOMAIN, mp.DOMAIN,
ha_const.SERVICE_VOLUME_MUTE, ha_const.SERVICE_VOLUME_MUTE,
{ATTR_ENTITY_ID: mock_entity_id, mp_const.ATTR_MEDIA_VOLUME_MUTED: True}, {ATTR_ENTITY_ID: mock_entity_id, mp.ATTR_MEDIA_VOLUME_MUTED: True},
blocking=True, blocking=True,
) )
dmr_device_mock.async_mute_volume.assert_awaited_once_with(True) dmr_device_mock.async_mute_volume.assert_awaited_once_with(True)
await hass.services.async_call( await hass.services.async_call(
MP_DOMAIN, mp.DOMAIN,
ha_const.SERVICE_MEDIA_PAUSE, ha_const.SERVICE_MEDIA_PAUSE,
{ATTR_ENTITY_ID: mock_entity_id}, {ATTR_ENTITY_ID: mock_entity_id},
blocking=True, blocking=True,
) )
dmr_device_mock.async_pause.assert_awaited_once_with() dmr_device_mock.async_pause.assert_awaited_once_with()
await hass.services.async_call( await hass.services.async_call(
MP_DOMAIN, mp.DOMAIN,
ha_const.SERVICE_MEDIA_PLAY, ha_const.SERVICE_MEDIA_PLAY,
{ATTR_ENTITY_ID: mock_entity_id}, {ATTR_ENTITY_ID: mock_entity_id},
blocking=True, blocking=True,
) )
dmr_device_mock.async_pause.assert_awaited_once_with() dmr_device_mock.async_pause.assert_awaited_once_with()
await hass.services.async_call( await hass.services.async_call(
MP_DOMAIN, mp.DOMAIN,
ha_const.SERVICE_MEDIA_STOP, ha_const.SERVICE_MEDIA_STOP,
{ATTR_ENTITY_ID: mock_entity_id}, {ATTR_ENTITY_ID: mock_entity_id},
blocking=True, blocking=True,
) )
dmr_device_mock.async_stop.assert_awaited_once_with() dmr_device_mock.async_stop.assert_awaited_once_with()
await hass.services.async_call( await hass.services.async_call(
MP_DOMAIN, mp.DOMAIN,
ha_const.SERVICE_MEDIA_NEXT_TRACK, ha_const.SERVICE_MEDIA_NEXT_TRACK,
{ATTR_ENTITY_ID: mock_entity_id}, {ATTR_ENTITY_ID: mock_entity_id},
blocking=True, blocking=True,
) )
dmr_device_mock.async_next.assert_awaited_once_with() dmr_device_mock.async_next.assert_awaited_once_with()
await hass.services.async_call( await hass.services.async_call(
MP_DOMAIN, mp.DOMAIN,
ha_const.SERVICE_MEDIA_PREVIOUS_TRACK, ha_const.SERVICE_MEDIA_PREVIOUS_TRACK,
{ATTR_ENTITY_ID: mock_entity_id}, {ATTR_ENTITY_ID: mock_entity_id},
blocking=True, blocking=True,
) )
dmr_device_mock.async_previous.assert_awaited_once_with() dmr_device_mock.async_previous.assert_awaited_once_with()
await hass.services.async_call( await hass.services.async_call(
MP_DOMAIN, mp.DOMAIN,
ha_const.SERVICE_MEDIA_SEEK, ha_const.SERVICE_MEDIA_SEEK,
{ATTR_ENTITY_ID: mock_entity_id, mp_const.ATTR_MEDIA_SEEK_POSITION: 33}, {ATTR_ENTITY_ID: mock_entity_id, mp.ATTR_MEDIA_SEEK_POSITION: 33},
blocking=True, blocking=True,
) )
dmr_device_mock.async_seek_rel_time.assert_awaited_once_with(timedelta(seconds=33)) dmr_device_mock.async_seek_rel_time.assert_awaited_once_with(timedelta(seconds=33))
await hass.services.async_call( await hass.services.async_call(
MP_DOMAIN, mp.DOMAIN,
mp_const.SERVICE_SELECT_SOUND_MODE, mp.SERVICE_SELECT_SOUND_MODE,
{ATTR_ENTITY_ID: mock_entity_id, mp_const.ATTR_SOUND_MODE: "Default"}, {ATTR_ENTITY_ID: mock_entity_id, mp.ATTR_SOUND_MODE: "Default"},
blocking=True, blocking=True,
) )
dmr_device_mock.async_select_preset.assert_awaited_once_with("Default") dmr_device_mock.async_select_preset.assert_awaited_once_with("Default")
@ -701,15 +698,15 @@ async def test_play_media_stopped(
dmr_device_mock.can_stop = True dmr_device_mock.can_stop = True
dmr_device_mock.transport_state = TransportState.STOPPED dmr_device_mock.transport_state = TransportState.STOPPED
await hass.services.async_call( await hass.services.async_call(
MP_DOMAIN, mp.DOMAIN,
mp_const.SERVICE_PLAY_MEDIA, mp.SERVICE_PLAY_MEDIA,
{ {
ATTR_ENTITY_ID: mock_entity_id, ATTR_ENTITY_ID: mock_entity_id,
mp_const.ATTR_MEDIA_CONTENT_TYPE: MediaType.MUSIC, mp.ATTR_MEDIA_CONTENT_TYPE: MediaType.MUSIC,
mp_const.ATTR_MEDIA_CONTENT_ID: ( mp.ATTR_MEDIA_CONTENT_ID: (
"http://198.51.100.20:8200/MediaItems/17621.mp3" "http://198.51.100.20:8200/MediaItems/17621.mp3"
), ),
mp_const.ATTR_MEDIA_ENQUEUE: False, mp.ATTR_MEDIA_ENQUEUE: False,
}, },
blocking=True, blocking=True,
) )
@ -735,15 +732,15 @@ async def test_play_media_playing(
dmr_device_mock.can_stop = False dmr_device_mock.can_stop = False
dmr_device_mock.transport_state = TransportState.PLAYING dmr_device_mock.transport_state = TransportState.PLAYING
await hass.services.async_call( await hass.services.async_call(
MP_DOMAIN, mp.DOMAIN,
mp_const.SERVICE_PLAY_MEDIA, mp.SERVICE_PLAY_MEDIA,
{ {
ATTR_ENTITY_ID: mock_entity_id, ATTR_ENTITY_ID: mock_entity_id,
mp_const.ATTR_MEDIA_CONTENT_TYPE: MediaType.MUSIC, mp.ATTR_MEDIA_CONTENT_TYPE: MediaType.MUSIC,
mp_const.ATTR_MEDIA_CONTENT_ID: ( mp.ATTR_MEDIA_CONTENT_ID: (
"http://198.51.100.20:8200/MediaItems/17621.mp3" "http://198.51.100.20:8200/MediaItems/17621.mp3"
), ),
mp_const.ATTR_MEDIA_ENQUEUE: False, mp.ATTR_MEDIA_ENQUEUE: False,
}, },
blocking=True, blocking=True,
) )
@ -770,16 +767,16 @@ async def test_play_media_no_autoplay(
dmr_device_mock.can_stop = True dmr_device_mock.can_stop = True
dmr_device_mock.transport_state = TransportState.STOPPED dmr_device_mock.transport_state = TransportState.STOPPED
await hass.services.async_call( await hass.services.async_call(
MP_DOMAIN, mp.DOMAIN,
mp_const.SERVICE_PLAY_MEDIA, mp.SERVICE_PLAY_MEDIA,
{ {
ATTR_ENTITY_ID: mock_entity_id, ATTR_ENTITY_ID: mock_entity_id,
mp_const.ATTR_MEDIA_CONTENT_TYPE: MediaType.MUSIC, mp.ATTR_MEDIA_CONTENT_TYPE: MediaType.MUSIC,
mp_const.ATTR_MEDIA_CONTENT_ID: ( mp.ATTR_MEDIA_CONTENT_ID: (
"http://198.51.100.20:8200/MediaItems/17621.mp3" "http://198.51.100.20:8200/MediaItems/17621.mp3"
), ),
mp_const.ATTR_MEDIA_ENQUEUE: False, mp.ATTR_MEDIA_ENQUEUE: False,
mp_const.ATTR_MEDIA_EXTRA: {"autoplay": False}, mp.ATTR_MEDIA_EXTRA: {"autoplay": False},
}, },
blocking=True, blocking=True,
) )
@ -803,16 +800,16 @@ async def test_play_media_metadata(
) -> None: ) -> None:
"""Test play_media constructs useful metadata from user params.""" """Test play_media constructs useful metadata from user params."""
await hass.services.async_call( await hass.services.async_call(
MP_DOMAIN, mp.DOMAIN,
mp_const.SERVICE_PLAY_MEDIA, mp.SERVICE_PLAY_MEDIA,
{ {
ATTR_ENTITY_ID: mock_entity_id, ATTR_ENTITY_ID: mock_entity_id,
mp_const.ATTR_MEDIA_CONTENT_TYPE: MediaType.MUSIC, mp.ATTR_MEDIA_CONTENT_TYPE: MediaType.MUSIC,
mp_const.ATTR_MEDIA_CONTENT_ID: ( mp.ATTR_MEDIA_CONTENT_ID: (
"http://198.51.100.20:8200/MediaItems/17621.mp3" "http://198.51.100.20:8200/MediaItems/17621.mp3"
), ),
mp_const.ATTR_MEDIA_ENQUEUE: False, mp.ATTR_MEDIA_ENQUEUE: False,
mp_const.ATTR_MEDIA_EXTRA: { mp.ATTR_MEDIA_EXTRA: {
"title": "Mock song", "title": "Mock song",
"thumb": "http://198.51.100.20:8200/MediaItems/17621.jpg", "thumb": "http://198.51.100.20:8200/MediaItems/17621.jpg",
"metadata": {"artist": "Mock artist", "album": "Mock album"}, "metadata": {"artist": "Mock artist", "album": "Mock album"},
@ -835,16 +832,14 @@ async def test_play_media_metadata(
# Check again for a different media type # Check again for a different media type
dmr_device_mock.construct_play_media_metadata.reset_mock() dmr_device_mock.construct_play_media_metadata.reset_mock()
await hass.services.async_call( await hass.services.async_call(
MP_DOMAIN, mp.DOMAIN,
mp_const.SERVICE_PLAY_MEDIA, mp.SERVICE_PLAY_MEDIA,
{ {
ATTR_ENTITY_ID: mock_entity_id, ATTR_ENTITY_ID: mock_entity_id,
mp_const.ATTR_MEDIA_CONTENT_TYPE: MediaType.TVSHOW, mp.ATTR_MEDIA_CONTENT_TYPE: MediaType.TVSHOW,
mp_const.ATTR_MEDIA_CONTENT_ID: ( mp.ATTR_MEDIA_CONTENT_ID: ("http://198.51.100.20:8200/MediaItems/123.mkv"),
"http://198.51.100.20:8200/MediaItems/123.mkv" mp.ATTR_MEDIA_ENQUEUE: False,
), mp.ATTR_MEDIA_EXTRA: {
mp_const.ATTR_MEDIA_ENQUEUE: False,
mp_const.ATTR_MEDIA_EXTRA: {
"title": "Mock show", "title": "Mock show",
"metadata": {"season": 1, "episode": 12}, "metadata": {"season": 1, "episode": 12},
}, },
@ -870,12 +865,12 @@ async def test_play_media_local_source(
await hass.async_block_till_done() await hass.async_block_till_done()
await hass.services.async_call( await hass.services.async_call(
MP_DOMAIN, mp.DOMAIN,
mp_const.SERVICE_PLAY_MEDIA, mp.SERVICE_PLAY_MEDIA,
{ {
ATTR_ENTITY_ID: mock_entity_id, ATTR_ENTITY_ID: mock_entity_id,
mp_const.ATTR_MEDIA_CONTENT_TYPE: "video/mp4", mp.ATTR_MEDIA_CONTENT_TYPE: "video/mp4",
mp_const.ATTR_MEDIA_CONTENT_ID: ( mp.ATTR_MEDIA_CONTENT_ID: (
"media-source://media_source/local/Epic Sax Guy 10 Hours.mp4" "media-source://media_source/local/Epic Sax Guy 10 Hours.mp4"
), ),
}, },
@ -927,12 +922,12 @@ async def test_play_media_didl_metadata(
return_value=play_media, return_value=play_media,
): ):
await hass.services.async_call( await hass.services.async_call(
MP_DOMAIN, mp.DOMAIN,
mp_const.SERVICE_PLAY_MEDIA, mp.SERVICE_PLAY_MEDIA,
{ {
ATTR_ENTITY_ID: mock_entity_id, ATTR_ENTITY_ID: mock_entity_id,
mp_const.ATTR_MEDIA_CONTENT_TYPE: "video/mp4", mp.ATTR_MEDIA_CONTENT_TYPE: "video/mp4",
mp_const.ATTR_MEDIA_CONTENT_ID: ( mp.ATTR_MEDIA_CONTENT_ID: (
"media-source://media_source/local/Epic Sax Guy 10 Hours.mp4" "media-source://media_source/local/Epic Sax Guy 10 Hours.mp4"
), ),
}, },
@ -968,9 +963,9 @@ async def test_shuffle_repeat_modes(
]: ]:
dmr_device_mock.play_mode = init_mode dmr_device_mock.play_mode = init_mode
await hass.services.async_call( await hass.services.async_call(
MP_DOMAIN, mp.DOMAIN,
ha_const.SERVICE_SHUFFLE_SET, ha_const.SERVICE_SHUFFLE_SET,
{ATTR_ENTITY_ID: mock_entity_id, mp_const.ATTR_MEDIA_SHUFFLE: shuffle_set}, {ATTR_ENTITY_ID: mock_entity_id, mp.ATTR_MEDIA_SHUFFLE: shuffle_set},
blocking=True, blocking=True,
) )
dmr_device_mock.async_set_play_mode.assert_awaited_with(expect_mode) dmr_device_mock.async_set_play_mode.assert_awaited_with(expect_mode)
@ -995,9 +990,9 @@ async def test_shuffle_repeat_modes(
]: ]:
dmr_device_mock.play_mode = init_mode dmr_device_mock.play_mode = init_mode
await hass.services.async_call( await hass.services.async_call(
MP_DOMAIN, mp.DOMAIN,
ha_const.SERVICE_REPEAT_SET, ha_const.SERVICE_REPEAT_SET,
{ATTR_ENTITY_ID: mock_entity_id, mp_const.ATTR_MEDIA_REPEAT: repeat_set}, {ATTR_ENTITY_ID: mock_entity_id, mp.ATTR_MEDIA_REPEAT: repeat_set},
blocking=True, blocking=True,
) )
dmr_device_mock.async_set_play_mode.assert_awaited_with(expect_mode) dmr_device_mock.async_set_play_mode.assert_awaited_with(expect_mode)
@ -1009,9 +1004,9 @@ async def test_shuffle_repeat_modes(
dmr_device_mock.valid_play_modes = {PlayMode.SHUFFLE, PlayMode.RANDOM} dmr_device_mock.valid_play_modes = {PlayMode.SHUFFLE, PlayMode.RANDOM}
await get_attrs(hass, mock_entity_id) await get_attrs(hass, mock_entity_id)
await hass.services.async_call( await hass.services.async_call(
MP_DOMAIN, mp.DOMAIN,
ha_const.SERVICE_SHUFFLE_SET, ha_const.SERVICE_SHUFFLE_SET,
{ATTR_ENTITY_ID: mock_entity_id, mp_const.ATTR_MEDIA_SHUFFLE: False}, {ATTR_ENTITY_ID: mock_entity_id, mp.ATTR_MEDIA_SHUFFLE: False},
blocking=True, blocking=True,
) )
dmr_device_mock.async_set_play_mode.assert_not_awaited() dmr_device_mock.async_set_play_mode.assert_not_awaited()
@ -1023,11 +1018,11 @@ async def test_shuffle_repeat_modes(
dmr_device_mock.valid_play_modes = {PlayMode.REPEAT_ONE, PlayMode.REPEAT_ALL} dmr_device_mock.valid_play_modes = {PlayMode.REPEAT_ONE, PlayMode.REPEAT_ALL}
await get_attrs(hass, mock_entity_id) await get_attrs(hass, mock_entity_id)
await hass.services.async_call( await hass.services.async_call(
MP_DOMAIN, mp.DOMAIN,
ha_const.SERVICE_REPEAT_SET, ha_const.SERVICE_REPEAT_SET,
{ {
ATTR_ENTITY_ID: mock_entity_id, ATTR_ENTITY_ID: mock_entity_id,
mp_const.ATTR_MEDIA_REPEAT: RepeatMode.OFF, mp.ATTR_MEDIA_REPEAT: RepeatMode.OFF,
}, },
blocking=True, blocking=True,
) )
@ -1322,40 +1317,40 @@ async def test_unavailable_device(
# Check attributes are unavailable # Check attributes are unavailable
attrs = mock_state.attributes attrs = mock_state.attributes
for attr in ATTR_TO_PROPERTY: for attr in mp.ATTR_TO_PROPERTY:
assert attr not in attrs assert attr not in attrs
assert attrs[ha_const.ATTR_FRIENDLY_NAME] == MOCK_DEVICE_NAME assert attrs[ha_const.ATTR_FRIENDLY_NAME] == MOCK_DEVICE_NAME
assert attrs[ha_const.ATTR_SUPPORTED_FEATURES] == 0 assert attrs[ha_const.ATTR_SUPPORTED_FEATURES] == 0
assert mp_const.ATTR_SOUND_MODE_LIST not in attrs assert mp.ATTR_SOUND_MODE_LIST not in attrs
# Check service calls do nothing # Check service calls do nothing
SERVICES: list[tuple[str, dict]] = [ SERVICES: list[tuple[str, dict]] = [
(ha_const.SERVICE_VOLUME_SET, {mp_const.ATTR_MEDIA_VOLUME_LEVEL: 0.80}), (ha_const.SERVICE_VOLUME_SET, {mp.ATTR_MEDIA_VOLUME_LEVEL: 0.80}),
(ha_const.SERVICE_VOLUME_MUTE, {mp_const.ATTR_MEDIA_VOLUME_MUTED: True}), (ha_const.SERVICE_VOLUME_MUTE, {mp.ATTR_MEDIA_VOLUME_MUTED: True}),
(ha_const.SERVICE_MEDIA_PAUSE, {}), (ha_const.SERVICE_MEDIA_PAUSE, {}),
(ha_const.SERVICE_MEDIA_PLAY, {}), (ha_const.SERVICE_MEDIA_PLAY, {}),
(ha_const.SERVICE_MEDIA_STOP, {}), (ha_const.SERVICE_MEDIA_STOP, {}),
(ha_const.SERVICE_MEDIA_NEXT_TRACK, {}), (ha_const.SERVICE_MEDIA_NEXT_TRACK, {}),
(ha_const.SERVICE_MEDIA_PREVIOUS_TRACK, {}), (ha_const.SERVICE_MEDIA_PREVIOUS_TRACK, {}),
(ha_const.SERVICE_MEDIA_SEEK, {mp_const.ATTR_MEDIA_SEEK_POSITION: 33}), (ha_const.SERVICE_MEDIA_SEEK, {mp.ATTR_MEDIA_SEEK_POSITION: 33}),
( (
mp_const.SERVICE_PLAY_MEDIA, mp.SERVICE_PLAY_MEDIA,
{ {
mp_const.ATTR_MEDIA_CONTENT_TYPE: MediaType.MUSIC, mp.ATTR_MEDIA_CONTENT_TYPE: MediaType.MUSIC,
mp_const.ATTR_MEDIA_CONTENT_ID: ( mp.ATTR_MEDIA_CONTENT_ID: (
"http://198.51.100.20:8200/MediaItems/17621.mp3" "http://198.51.100.20:8200/MediaItems/17621.mp3"
), ),
mp_const.ATTR_MEDIA_ENQUEUE: False, mp.ATTR_MEDIA_ENQUEUE: False,
}, },
), ),
(mp_const.SERVICE_SELECT_SOUND_MODE, {mp_const.ATTR_SOUND_MODE: "Default"}), (mp.SERVICE_SELECT_SOUND_MODE, {mp.ATTR_SOUND_MODE: "Default"}),
(ha_const.SERVICE_SHUFFLE_SET, {mp_const.ATTR_MEDIA_SHUFFLE: True}), (ha_const.SERVICE_SHUFFLE_SET, {mp.ATTR_MEDIA_SHUFFLE: True}),
(ha_const.SERVICE_REPEAT_SET, {mp_const.ATTR_MEDIA_REPEAT: "all"}), (ha_const.SERVICE_REPEAT_SET, {mp.ATTR_MEDIA_REPEAT: "all"}),
] ]
for service, data in SERVICES: for service, data in SERVICES:
await hass.services.async_call( await hass.services.async_call(
MP_DOMAIN, mp.DOMAIN,
service, service,
{ATTR_ENTITY_ID: mock_entity_id, **data}, {ATTR_ENTITY_ID: mock_entity_id, **data},
blocking=True, blocking=True,
@ -1980,9 +1975,9 @@ async def test_become_unavailable(
# Interface service calls should flag that the device is unavailable, but # Interface service calls should flag that the device is unavailable, but
# not disconnect it immediately # not disconnect it immediately
await hass.services.async_call( await hass.services.async_call(
MP_DOMAIN, mp.DOMAIN,
ha_const.SERVICE_VOLUME_SET, ha_const.SERVICE_VOLUME_SET,
{ATTR_ENTITY_ID: mock_entity_id, mp_const.ATTR_MEDIA_VOLUME_LEVEL: 0.80}, {ATTR_ENTITY_ID: mock_entity_id, mp.ATTR_MEDIA_VOLUME_LEVEL: 0.80},
blocking=True, blocking=True,
) )
@ -2003,9 +1998,9 @@ async def test_become_unavailable(
dmr_device_mock.async_update.side_effect = UpnpConnectionError dmr_device_mock.async_update.side_effect = UpnpConnectionError
await hass.services.async_call( await hass.services.async_call(
MP_DOMAIN, mp.DOMAIN,
ha_const.SERVICE_VOLUME_SET, ha_const.SERVICE_VOLUME_SET,
{ATTR_ENTITY_ID: mock_entity_id, mp_const.ATTR_MEDIA_VOLUME_LEVEL: 0.80}, {ATTR_ENTITY_ID: mock_entity_id, mp.ATTR_MEDIA_VOLUME_LEVEL: 0.80},
blocking=True, blocking=True,
) )
await async_update_entity(hass, mock_entity_id) await async_update_entity(hass, mock_entity_id)
@ -2083,10 +2078,10 @@ async def test_disappearing_device(
directly to skip the availability check. directly to skip the availability check.
""" """
# Retrieve entity directly. # Retrieve entity directly.
entity: DlnaDmrEntity = hass.data[MP_DOMAIN].get_entity(mock_disconnected_entity_id) entity: DlnaDmrEntity = hass.data[mp.DOMAIN].get_entity(mock_disconnected_entity_id)
# Test attribute access # Test attribute access
for attr in ATTR_TO_PROPERTY: for attr in mp.ATTR_TO_PROPERTY:
value = getattr(entity, attr) value = getattr(entity, attr)
assert value is None assert value is None
@ -2456,7 +2451,7 @@ async def test_udn_upnp_connection_added_if_missing(
# Cause connection attempts to fail before adding entity # Cause connection attempts to fail before adding entity
ent_reg = async_get_er(hass) ent_reg = async_get_er(hass)
entry = ent_reg.async_get_or_create( entry = ent_reg.async_get_or_create(
MP_DOMAIN, mp.DOMAIN,
DOMAIN, DOMAIN,
MOCK_DEVICE_UDN, MOCK_DEVICE_UDN,
config_entry=config_entry_mock, config_entry=config_entry_mock,