Home-Assistant
/
core
mirror of https://github.com/home-assistant/core.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

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

pull/119291/head
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
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 (
CONF_BROWSE_UNFILTERED,
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.media_player import DlnaDmrEntity
from homeassistant.components.media_player import (
ATTR_TO_PROPERTY,
DOMAIN as MP_DOMAIN,
MediaPlayerEntityFeature,
MediaPlayerState,
MediaType,
RepeatMode,
const as mp_const,
)
from homeassistant.components.media_source import DOMAIN as MS_DOMAIN, PlayMedia
from homeassistant.const import (
@ -551,56 +548,56 @@ async def test_attributes(
"""Test attributes of a connected DlnaDmrEntity."""
# Check attributes come directly from the device
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_const.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_const.ATTR_MEDIA_POSITION] is dmr_device_mock.media_position
assert attrs[mp.ATTR_MEDIA_VOLUME_LEVEL] is dmr_device_mock.volume_level
assert attrs[mp.ATTR_MEDIA_VOLUME_MUTED] is dmr_device_mock.is_volume_muted
assert attrs[mp.ATTR_MEDIA_DURATION] is dmr_device_mock.media_duration
assert attrs[mp.ATTR_MEDIA_POSITION] is dmr_device_mock.media_position
assert (
attrs[mp_const.ATTR_MEDIA_POSITION_UPDATED_AT]
attrs[mp.ATTR_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_const.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_const.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_const.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_const.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_const.ATTR_SOUND_MODE_LIST] is dmr_device_mock.preset_names
assert attrs[mp.ATTR_MEDIA_CONTENT_ID] is dmr_device_mock.current_track_uri
assert attrs[mp.ATTR_MEDIA_ARTIST] is dmr_device_mock.media_artist
assert attrs[mp.ATTR_MEDIA_ALBUM_NAME] is dmr_device_mock.media_album_name
assert attrs[mp.ATTR_MEDIA_ALBUM_ARTIST] is dmr_device_mock.media_album_artist
assert attrs[mp.ATTR_MEDIA_TRACK] is dmr_device_mock.media_track_number
assert attrs[mp.ATTR_MEDIA_SERIES_TITLE] is dmr_device_mock.media_series_title
assert attrs[mp.ATTR_MEDIA_SEASON] is dmr_device_mock.media_season_number
assert attrs[mp.ATTR_MEDIA_EPISODE] is dmr_device_mock.media_episode_number
assert attrs[mp.ATTR_MEDIA_CHANNEL] is dmr_device_mock.media_channel_name
assert attrs[mp.ATTR_SOUND_MODE_LIST] is dmr_device_mock.preset_names
# Entity picture is cached, won't correspond to remote image
assert isinstance(attrs[ha_const.ATTR_ENTITY_PICTURE], str)
# 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
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
dmr_device_mock.media_class = "object.item.audioItem.musicTrack"
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"
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"
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
dmr_device_mock.media_season_number = "0"
dmr_device_mock.media_episode_number = "123"
attrs = await get_attrs(hass, mock_entity_id)
assert attrs[mp_const.ATTR_MEDIA_SEASON] == "1"
assert attrs[mp_const.ATTR_MEDIA_EPISODE] == "23"
assert attrs[mp.ATTR_MEDIA_SEASON] == "1"
assert attrs[mp.ATTR_MEDIA_EPISODE] == "23"
dmr_device_mock.media_season_number = "0"
dmr_device_mock.media_episode_number = "S1E23" # Unexpected and not parsed
attrs = await get_attrs(hass, mock_entity_id)
assert attrs[mp_const.ATTR_MEDIA_SEASON] == "0"
assert attrs[mp_const.ATTR_MEDIA_EPISODE] == "S1E23"
assert attrs[mp.ATTR_MEDIA_SEASON] == "0"
assert attrs[mp.ATTR_MEDIA_EPISODE] == "S1E23"
# shuffle and repeat is based on device's play mode
for play_mode, shuffle, repeat in [
@ -614,13 +611,13 @@ async def test_attributes(
]:
dmr_device_mock.play_mode = play_mode
attrs = await get_attrs(hass, mock_entity_id)
assert attrs[mp_const.ATTR_MEDIA_SHUFFLE] is shuffle
assert attrs[mp_const.ATTR_MEDIA_REPEAT] == repeat
assert attrs[mp.ATTR_MEDIA_SHUFFLE] is shuffle
assert attrs[mp.ATTR_MEDIA_REPEAT] == repeat
for bad_play_mode in [None, PlayMode.VENDOR_DEFINED]:
dmr_device_mock.play_mode = bad_play_mode
attrs = await get_attrs(hass, mock_entity_id)
assert mp_const.ATTR_MEDIA_SHUFFLE not in attrs
assert mp_const.ATTR_MEDIA_REPEAT not in attrs
assert mp.ATTR_MEDIA_SHUFFLE not in attrs
assert mp.ATTR_MEDIA_REPEAT not in attrs
async def test_services(
@ -629,65 +626,65 @@ async def test_services(
"""Test service calls of a connected DlnaDmrEntity."""
# Check interface methods interact directly with the device
await hass.services.async_call(
MP_DOMAIN,
mp.DOMAIN,
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,
)
dmr_device_mock.async_set_volume_level.assert_awaited_once_with(0.80)
await hass.services.async_call(
MP_DOMAIN,
mp.DOMAIN,
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,
)
dmr_device_mock.async_mute_volume.assert_awaited_once_with(True)
await hass.services.async_call(
MP_DOMAIN,
mp.DOMAIN,
ha_const.SERVICE_MEDIA_PAUSE,
{ATTR_ENTITY_ID: mock_entity_id},
blocking=True,
)
dmr_device_mock.async_pause.assert_awaited_once_with()
await hass.services.async_call(
MP_DOMAIN,
mp.DOMAIN,
ha_const.SERVICE_MEDIA_PLAY,
{ATTR_ENTITY_ID: mock_entity_id},
blocking=True,
)
dmr_device_mock.async_pause.assert_awaited_once_with()
await hass.services.async_call(
MP_DOMAIN,
mp.DOMAIN,
ha_const.SERVICE_MEDIA_STOP,
{ATTR_ENTITY_ID: mock_entity_id},
blocking=True,
)
dmr_device_mock.async_stop.assert_awaited_once_with()
await hass.services.async_call(
MP_DOMAIN,
mp.DOMAIN,
ha_const.SERVICE_MEDIA_NEXT_TRACK,
{ATTR_ENTITY_ID: mock_entity_id},
blocking=True,
)
dmr_device_mock.async_next.assert_awaited_once_with()
await hass.services.async_call(
MP_DOMAIN,
mp.DOMAIN,
ha_const.SERVICE_MEDIA_PREVIOUS_TRACK,
{ATTR_ENTITY_ID: mock_entity_id},
blocking=True,
)
dmr_device_mock.async_previous.assert_awaited_once_with()
await hass.services.async_call(
MP_DOMAIN,
mp.DOMAIN,
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,
)
dmr_device_mock.async_seek_rel_time.assert_awaited_once_with(timedelta(seconds=33))
await hass.services.async_call(
MP_DOMAIN,
mp_const.SERVICE_SELECT_SOUND_MODE,
{ATTR_ENTITY_ID: mock_entity_id, mp_const.ATTR_SOUND_MODE: "Default"},
mp.DOMAIN,
mp.SERVICE_SELECT_SOUND_MODE,
{ATTR_ENTITY_ID: mock_entity_id, mp.ATTR_SOUND_MODE: "Default"},
blocking=True,
)
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.transport_state = TransportState.STOPPED
await hass.services.async_call(
MP_DOMAIN,
mp_const.SERVICE_PLAY_MEDIA,
mp.DOMAIN,
mp.SERVICE_PLAY_MEDIA,
{
ATTR_ENTITY_ID: mock_entity_id,
mp_const.ATTR_MEDIA_CONTENT_TYPE: MediaType.MUSIC,
mp_const.ATTR_MEDIA_CONTENT_ID: (
mp.ATTR_MEDIA_CONTENT_TYPE: MediaType.MUSIC,
mp.ATTR_MEDIA_CONTENT_ID: (
"http://198.51.100.20:8200/MediaItems/17621.mp3"
),
mp_const.ATTR_MEDIA_ENQUEUE: False,
mp.ATTR_MEDIA_ENQUEUE: False,
},
blocking=True,
)
@ -735,15 +732,15 @@ async def test_play_media_playing(
dmr_device_mock.can_stop = False
dmr_device_mock.transport_state = TransportState.PLAYING
await hass.services.async_call(
MP_DOMAIN,
mp_const.SERVICE_PLAY_MEDIA,
mp.DOMAIN,
mp.SERVICE_PLAY_MEDIA,
{
ATTR_ENTITY_ID: mock_entity_id,
mp_const.ATTR_MEDIA_CONTENT_TYPE: MediaType.MUSIC,
mp_const.ATTR_MEDIA_CONTENT_ID: (
mp.ATTR_MEDIA_CONTENT_TYPE: MediaType.MUSIC,
mp.ATTR_MEDIA_CONTENT_ID: (
"http://198.51.100.20:8200/MediaItems/17621.mp3"
),
mp_const.ATTR_MEDIA_ENQUEUE: False,
mp.ATTR_MEDIA_ENQUEUE: False,
},
blocking=True,
)
@ -770,16 +767,16 @@ async def test_play_media_no_autoplay(
dmr_device_mock.can_stop = True
dmr_device_mock.transport_state = TransportState.STOPPED
await hass.services.async_call(
MP_DOMAIN,
mp_const.SERVICE_PLAY_MEDIA,
mp.DOMAIN,
mp.SERVICE_PLAY_MEDIA,
{
ATTR_ENTITY_ID: mock_entity_id,
mp_const.ATTR_MEDIA_CONTENT_TYPE: MediaType.MUSIC,
mp_const.ATTR_MEDIA_CONTENT_ID: (
mp.ATTR_MEDIA_CONTENT_TYPE: MediaType.MUSIC,
mp.ATTR_MEDIA_CONTENT_ID: (
"http://198.51.100.20:8200/MediaItems/17621.mp3"
),
mp_const.ATTR_MEDIA_ENQUEUE: False,
mp_const.ATTR_MEDIA_EXTRA: {"autoplay": False},
mp.ATTR_MEDIA_ENQUEUE: False,
mp.ATTR_MEDIA_EXTRA: {"autoplay": False},
},
blocking=True,
)
@ -803,16 +800,16 @@ async def test_play_media_metadata(
) -> None:
"""Test play_media constructs useful metadata from user params."""
await hass.services.async_call(
MP_DOMAIN,
mp_const.SERVICE_PLAY_MEDIA,
mp.DOMAIN,
mp.SERVICE_PLAY_MEDIA,
{
ATTR_ENTITY_ID: mock_entity_id,
mp_const.ATTR_MEDIA_CONTENT_TYPE: MediaType.MUSIC,
mp_const.ATTR_MEDIA_CONTENT_ID: (
mp.ATTR_MEDIA_CONTENT_TYPE: MediaType.MUSIC,
mp.ATTR_MEDIA_CONTENT_ID: (
"http://198.51.100.20:8200/MediaItems/17621.mp3"
),
mp_const.ATTR_MEDIA_ENQUEUE: False,
mp_const.ATTR_MEDIA_EXTRA: {
mp.ATTR_MEDIA_ENQUEUE: False,
mp.ATTR_MEDIA_EXTRA: {
"title": "Mock song",
"thumb": "http://198.51.100.20:8200/MediaItems/17621.jpg",
"metadata": {"artist": "Mock artist", "album": "Mock album"},
@ -835,16 +832,14 @@ async def test_play_media_metadata(
# Check again for a different media type
dmr_device_mock.construct_play_media_metadata.reset_mock()
await hass.services.async_call(
MP_DOMAIN,
mp_const.SERVICE_PLAY_MEDIA,
mp.DOMAIN,
mp.SERVICE_PLAY_MEDIA,
{
ATTR_ENTITY_ID: mock_entity_id,
mp_const.ATTR_MEDIA_CONTENT_TYPE: MediaType.TVSHOW,
mp_const.ATTR_MEDIA_CONTENT_ID: (
"http://198.51.100.20:8200/MediaItems/123.mkv"
),
mp_const.ATTR_MEDIA_ENQUEUE: False,
mp_const.ATTR_MEDIA_EXTRA: {
mp.ATTR_MEDIA_CONTENT_TYPE: MediaType.TVSHOW,
mp.ATTR_MEDIA_CONTENT_ID: ("http://198.51.100.20:8200/MediaItems/123.mkv"),
mp.ATTR_MEDIA_ENQUEUE: False,
mp.ATTR_MEDIA_EXTRA: {
"title": "Mock show",
"metadata": {"season": 1, "episode": 12},
},
@ -870,12 +865,12 @@ async def test_play_media_local_source(
await hass.async_block_till_done()
await hass.services.async_call(
MP_DOMAIN,
mp_const.SERVICE_PLAY_MEDIA,
mp.DOMAIN,
mp.SERVICE_PLAY_MEDIA,
{
ATTR_ENTITY_ID: mock_entity_id,
mp_const.ATTR_MEDIA_CONTENT_TYPE: "video/mp4",
mp_const.ATTR_MEDIA_CONTENT_ID: (
mp.ATTR_MEDIA_CONTENT_TYPE: "video/mp4",
mp.ATTR_MEDIA_CONTENT_ID: (
"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,
):
await hass.services.async_call(
MP_DOMAIN,
mp_const.SERVICE_PLAY_MEDIA,
mp.DOMAIN,
mp.SERVICE_PLAY_MEDIA,
{
ATTR_ENTITY_ID: mock_entity_id,
mp_const.ATTR_MEDIA_CONTENT_TYPE: "video/mp4",
mp_const.ATTR_MEDIA_CONTENT_ID: (
mp.ATTR_MEDIA_CONTENT_TYPE: "video/mp4",
mp.ATTR_MEDIA_CONTENT_ID: (
"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
await hass.services.async_call(
MP_DOMAIN,
mp.DOMAIN,
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,
)
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
await hass.services.async_call(
MP_DOMAIN,
mp.DOMAIN,
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,
)
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}
await get_attrs(hass, mock_entity_id)
await hass.services.async_call(
MP_DOMAIN,
mp.DOMAIN,
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,
)
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}
await get_attrs(hass, mock_entity_id)
await hass.services.async_call(
MP_DOMAIN,
mp.DOMAIN,
ha_const.SERVICE_REPEAT_SET,
{
ATTR_ENTITY_ID: mock_entity_id,
mp_const.ATTR_MEDIA_REPEAT: RepeatMode.OFF,
mp.ATTR_MEDIA_REPEAT: RepeatMode.OFF,
},
blocking=True,
)
@ -1322,40 +1317,40 @@ async def test_unavailable_device(
# Check attributes are unavailable
attrs = mock_state.attributes
for attr in ATTR_TO_PROPERTY:
for attr in mp.ATTR_TO_PROPERTY:
assert attr not in attrs
assert attrs[ha_const.ATTR_FRIENDLY_NAME] == MOCK_DEVICE_NAME
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
SERVICES: list[tuple[str, dict]] = [
(ha_const.SERVICE_VOLUME_SET, {mp_const.ATTR_MEDIA_VOLUME_LEVEL: 0.80}),
(ha_const.SERVICE_VOLUME_MUTE, {mp_const.ATTR_MEDIA_VOLUME_MUTED: True}),
(ha_const.SERVICE_VOLUME_SET, {mp.ATTR_MEDIA_VOLUME_LEVEL: 0.80}),
(ha_const.SERVICE_VOLUME_MUTE, {mp.ATTR_MEDIA_VOLUME_MUTED: True}),
(ha_const.SERVICE_MEDIA_PAUSE, {}),
(ha_const.SERVICE_MEDIA_PLAY, {}),
(ha_const.SERVICE_MEDIA_STOP, {}),
(ha_const.SERVICE_MEDIA_NEXT_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_const.ATTR_MEDIA_CONTENT_ID: (
mp.ATTR_MEDIA_CONTENT_TYPE: MediaType.MUSIC,
mp.ATTR_MEDIA_CONTENT_ID: (
"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"}),
(ha_const.SERVICE_SHUFFLE_SET, {mp_const.ATTR_MEDIA_SHUFFLE: True}),
(ha_const.SERVICE_REPEAT_SET, {mp_const.ATTR_MEDIA_REPEAT: "all"}),
(mp.SERVICE_SELECT_SOUND_MODE, {mp.ATTR_SOUND_MODE: "Default"}),
(ha_const.SERVICE_SHUFFLE_SET, {mp.ATTR_MEDIA_SHUFFLE: True}),
(ha_const.SERVICE_REPEAT_SET, {mp.ATTR_MEDIA_REPEAT: "all"}),
]
for service, data in SERVICES:
await hass.services.async_call(
MP_DOMAIN,
mp.DOMAIN,
service,
{ATTR_ENTITY_ID: mock_entity_id, **data},
blocking=True,
@ -1980,9 +1975,9 @@ async def test_become_unavailable(
# Interface service calls should flag that the device is unavailable, but
# not disconnect it immediately
await hass.services.async_call(
MP_DOMAIN,
mp.DOMAIN,
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,
)
@ -2003,9 +1998,9 @@ async def test_become_unavailable(
dmr_device_mock.async_update.side_effect = UpnpConnectionError
await hass.services.async_call(
MP_DOMAIN,
mp.DOMAIN,
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,
)
await async_update_entity(hass, mock_entity_id)
@ -2083,10 +2078,10 @@ async def test_disappearing_device(
directly to skip the availability check.
"""
# 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
for attr in ATTR_TO_PROPERTY:
for attr in mp.ATTR_TO_PROPERTY:
value = getattr(entity, attr)
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
ent_reg = async_get_er(hass)
entry = ent_reg.async_get_or_create(
MP_DOMAIN,
mp.DOMAIN,
DOMAIN,
MOCK_DEVICE_UDN,
config_entry=config_entry_mock,