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

Extend component root imports in tests (2) (#120123)

Browse Source
This commit is contained in:
Marc Mueller 2024-06-22 09:06:05 +02:00 committed by GitHub
parent cb78caf455
commit 2e3aeae520
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
1 changed files with 153 additions and 118 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

271
tests/components/demo/test_media_player.py
View File

@ -6,11 +6,46 @@ from unittest.mock import patch
import pytest import pytest
import voluptuous as vol import voluptuous as vol
import homeassistant.components.media_player as mp from homeassistant.components.media_player import (
ATTR_GROUP_MEMBERS,
ATTR_INPUT_SOURCE,
ATTR_MEDIA_CONTENT_ID,
ATTR_MEDIA_CONTENT_TYPE,
ATTR_MEDIA_EPISODE,
ATTR_MEDIA_REPEAT,
ATTR_MEDIA_SEEK_POSITION,
ATTR_MEDIA_TRACK,
ATTR_MEDIA_VOLUME_LEVEL,
ATTR_MEDIA_VOLUME_MUTED,
DOMAIN as MP_DOMAIN,
SERVICE_CLEAR_PLAYLIST,
SERVICE_JOIN,
SERVICE_PLAY_MEDIA,
SERVICE_SELECT_SOURCE,
SERVICE_UNJOIN,
MediaPlayerEntityFeature,
RepeatMode,
is_on,
)
from homeassistant.const import ( from homeassistant.const import (
ATTR_ENTITY_ID, ATTR_ENTITY_ID,
ATTR_ENTITY_PICTURE, ATTR_ENTITY_PICTURE,
ATTR_SUPPORTED_FEATURES, ATTR_SUPPORTED_FEATURES,
SERVICE_MEDIA_NEXT_TRACK,
SERVICE_MEDIA_PAUSE,
SERVICE_MEDIA_PLAY,
SERVICE_MEDIA_PLAY_PAUSE,
SERVICE_MEDIA_PREVIOUS_TRACK,
SERVICE_MEDIA_SEEK,
SERVICE_MEDIA_STOP,
SERVICE_REPEAT_SET,
SERVICE_TOGGLE,
SERVICE_TURN_OFF,
SERVICE_TURN_ON,
SERVICE_VOLUME_DOWN,
SERVICE_VOLUME_MUTE,
SERVICE_VOLUME_SET,
SERVICE_VOLUME_UP,
STATE_OFF, STATE_OFF,
STATE_PAUSED, STATE_PAUSED,
STATE_PLAYING, STATE_PLAYING,
@ -50,30 +85,30 @@ async def test_source_select(hass: HomeAssistant) -> None:
entity_id = "media_player.lounge_room" entity_id = "media_player.lounge_room"
assert await async_setup_component( assert await async_setup_component(
hass, mp.DOMAIN, {"media_player": {"platform": "demo"}} hass, MP_DOMAIN, {"media_player": {"platform": "demo"}}
) )
await hass.async_block_till_done() await hass.async_block_till_done()
state = hass.states.get(entity_id) state = hass.states.get(entity_id)
assert state.attributes.get(mp.ATTR_INPUT_SOURCE) == "dvd" assert state.attributes.get(ATTR_INPUT_SOURCE) == "dvd"
with pytest.raises(vol.Invalid): with pytest.raises(vol.Invalid):
await hass.services.async_call( await hass.services.async_call(
mp.DOMAIN, MP_DOMAIN,
mp.SERVICE_SELECT_SOURCE, SERVICE_SELECT_SOURCE,
{ATTR_ENTITY_ID: entity_id, mp.ATTR_INPUT_SOURCE: None}, {ATTR_ENTITY_ID: entity_id, ATTR_INPUT_SOURCE: None},
blocking=True, blocking=True,
) )
state = hass.states.get(entity_id) state = hass.states.get(entity_id)
assert state.attributes.get(mp.ATTR_INPUT_SOURCE) == "dvd" assert state.attributes.get(ATTR_INPUT_SOURCE) == "dvd"
await hass.services.async_call( await hass.services.async_call(
mp.DOMAIN, MP_DOMAIN,
mp.SERVICE_SELECT_SOURCE, SERVICE_SELECT_SOURCE,
{ATTR_ENTITY_ID: entity_id, mp.ATTR_INPUT_SOURCE: "xbox"}, {ATTR_ENTITY_ID: entity_id, ATTR_INPUT_SOURCE: "xbox"},
blocking=True, blocking=True,
) )
state = hass.states.get(entity_id) state = hass.states.get(entity_id)
assert state.attributes.get(mp.ATTR_INPUT_SOURCE) == "xbox" assert state.attributes.get(ATTR_INPUT_SOURCE) == "xbox"
async def test_repeat_set(hass: HomeAssistant) -> None: async def test_repeat_set(hass: HomeAssistant) -> None:
@ -81,26 +116,26 @@ async def test_repeat_set(hass: HomeAssistant) -> None:
entity_id = "media_player.walkman" entity_id = "media_player.walkman"
assert await async_setup_component( assert await async_setup_component(
hass, mp.DOMAIN, {"media_player": {"platform": "demo"}} hass, MP_DOMAIN, {"media_player": {"platform": "demo"}}
) )
await hass.async_block_till_done() await hass.async_block_till_done()
state = hass.states.get(entity_id) state = hass.states.get(entity_id)
assert state.attributes.get(mp.ATTR_MEDIA_REPEAT) == mp.const.REPEAT_MODE_OFF assert state.attributes.get(ATTR_MEDIA_REPEAT) == RepeatMode.OFF
await hass.services.async_call( await hass.services.async_call(
mp.DOMAIN, MP_DOMAIN,
mp.SERVICE_REPEAT_SET, SERVICE_REPEAT_SET,
{ATTR_ENTITY_ID: entity_id, mp.ATTR_MEDIA_REPEAT: mp.const.REPEAT_MODE_ALL}, {ATTR_ENTITY_ID: entity_id, ATTR_MEDIA_REPEAT: RepeatMode.ALL},
blocking=True, blocking=True,
) )
state = hass.states.get(entity_id) state = hass.states.get(entity_id)
assert state.attributes.get(mp.ATTR_MEDIA_REPEAT) == mp.const.REPEAT_MODE_ALL assert state.attributes.get(ATTR_MEDIA_REPEAT) == RepeatMode.ALL
async def test_clear_playlist(hass: HomeAssistant) -> None: async def test_clear_playlist(hass: HomeAssistant) -> None:
"""Test clear playlist.""" """Test clear playlist."""
assert await async_setup_component( assert await async_setup_component(
hass, mp.DOMAIN, {"media_player": {"platform": "demo"}} hass, MP_DOMAIN, {"media_player": {"platform": "demo"}}
) )
await hass.async_block_till_done() await hass.async_block_till_done()
@ -108,8 +143,8 @@ async def test_clear_playlist(hass: HomeAssistant) -> None:
assert state.state == STATE_PLAYING assert state.state == STATE_PLAYING
await hass.services.async_call( await hass.services.async_call(
mp.DOMAIN, MP_DOMAIN,
mp.SERVICE_CLEAR_PLAYLIST, SERVICE_CLEAR_PLAYLIST,
{ATTR_ENTITY_ID: TEST_ENTITY_ID}, {ATTR_ENTITY_ID: TEST_ENTITY_ID},
blocking=True, blocking=True,
) )
@ -120,79 +155,79 @@ async def test_clear_playlist(hass: HomeAssistant) -> None:
async def test_volume_services(hass: HomeAssistant) -> None: async def test_volume_services(hass: HomeAssistant) -> None:
"""Test the volume service.""" """Test the volume service."""
assert await async_setup_component( assert await async_setup_component(
hass, mp.DOMAIN, {"media_player": {"platform": "demo"}} hass, MP_DOMAIN, {"media_player": {"platform": "demo"}}
) )
await hass.async_block_till_done() await hass.async_block_till_done()
state = hass.states.get(TEST_ENTITY_ID) state = hass.states.get(TEST_ENTITY_ID)
assert state.attributes.get(mp.ATTR_MEDIA_VOLUME_LEVEL) == 1.0 assert state.attributes.get(ATTR_MEDIA_VOLUME_LEVEL) == 1.0
with pytest.raises(vol.Invalid): with pytest.raises(vol.Invalid):
await hass.services.async_call( await hass.services.async_call(
mp.DOMAIN, MP_DOMAIN,
mp.SERVICE_VOLUME_SET, SERVICE_VOLUME_SET,
{ATTR_ENTITY_ID: TEST_ENTITY_ID, mp.ATTR_MEDIA_VOLUME_LEVEL: None}, {ATTR_ENTITY_ID: TEST_ENTITY_ID, ATTR_MEDIA_VOLUME_LEVEL: None},
blocking=True, blocking=True,
) )
state = hass.states.get(TEST_ENTITY_ID) state = hass.states.get(TEST_ENTITY_ID)
assert state.attributes.get(mp.ATTR_MEDIA_VOLUME_LEVEL) == 1.0 assert state.attributes.get(ATTR_MEDIA_VOLUME_LEVEL) == 1.0
await hass.services.async_call( await hass.services.async_call(
mp.DOMAIN, MP_DOMAIN,
mp.SERVICE_VOLUME_SET, SERVICE_VOLUME_SET,
{ATTR_ENTITY_ID: TEST_ENTITY_ID, mp.ATTR_MEDIA_VOLUME_LEVEL: 0.5}, {ATTR_ENTITY_ID: TEST_ENTITY_ID, ATTR_MEDIA_VOLUME_LEVEL: 0.5},
blocking=True, blocking=True,
) )
state = hass.states.get(TEST_ENTITY_ID) state = hass.states.get(TEST_ENTITY_ID)
assert state.attributes.get(mp.ATTR_MEDIA_VOLUME_LEVEL) == 0.5 assert state.attributes.get(ATTR_MEDIA_VOLUME_LEVEL) == 0.5
await hass.services.async_call( await hass.services.async_call(
mp.DOMAIN, MP_DOMAIN,
mp.SERVICE_VOLUME_DOWN, SERVICE_VOLUME_DOWN,
{ATTR_ENTITY_ID: TEST_ENTITY_ID}, {ATTR_ENTITY_ID: TEST_ENTITY_ID},
blocking=True, blocking=True,
) )
state = hass.states.get(TEST_ENTITY_ID) state = hass.states.get(TEST_ENTITY_ID)
assert state.attributes.get(mp.ATTR_MEDIA_VOLUME_LEVEL) == 0.4 assert state.attributes.get(ATTR_MEDIA_VOLUME_LEVEL) == 0.4
await hass.services.async_call( await hass.services.async_call(
mp.DOMAIN, MP_DOMAIN,
mp.SERVICE_VOLUME_UP, SERVICE_VOLUME_UP,
{ATTR_ENTITY_ID: TEST_ENTITY_ID}, {ATTR_ENTITY_ID: TEST_ENTITY_ID},
blocking=True, blocking=True,
) )
state = hass.states.get(TEST_ENTITY_ID) state = hass.states.get(TEST_ENTITY_ID)
assert state.attributes.get(mp.ATTR_MEDIA_VOLUME_LEVEL) == 0.5 assert state.attributes.get(ATTR_MEDIA_VOLUME_LEVEL) == 0.5
assert state.attributes.get(mp.ATTR_MEDIA_VOLUME_MUTED) is False assert state.attributes.get(ATTR_MEDIA_VOLUME_MUTED) is False
with pytest.raises(vol.Invalid): with pytest.raises(vol.Invalid):
await hass.services.async_call( await hass.services.async_call(
mp.DOMAIN, MP_DOMAIN,
mp.SERVICE_VOLUME_MUTE, SERVICE_VOLUME_MUTE,
{ATTR_ENTITY_ID: TEST_ENTITY_ID, mp.ATTR_MEDIA_VOLUME_MUTED: None}, {ATTR_ENTITY_ID: TEST_ENTITY_ID, ATTR_MEDIA_VOLUME_MUTED: None},
blocking=True, blocking=True,
) )
state = hass.states.get(TEST_ENTITY_ID) state = hass.states.get(TEST_ENTITY_ID)
assert state.attributes.get(mp.ATTR_MEDIA_VOLUME_MUTED) is False assert state.attributes.get(ATTR_MEDIA_VOLUME_MUTED) is False
await hass.services.async_call( await hass.services.async_call(
mp.DOMAIN, MP_DOMAIN,
mp.SERVICE_VOLUME_MUTE, SERVICE_VOLUME_MUTE,
{ATTR_ENTITY_ID: TEST_ENTITY_ID, mp.ATTR_MEDIA_VOLUME_MUTED: True}, {ATTR_ENTITY_ID: TEST_ENTITY_ID, ATTR_MEDIA_VOLUME_MUTED: True},
blocking=True, blocking=True,
) )
state = hass.states.get(TEST_ENTITY_ID) state = hass.states.get(TEST_ENTITY_ID)
assert state.attributes.get(mp.ATTR_MEDIA_VOLUME_MUTED) is True assert state.attributes.get(ATTR_MEDIA_VOLUME_MUTED) is True
async def test_turning_off_and_on(hass: HomeAssistant) -> None: async def test_turning_off_and_on(hass: HomeAssistant) -> None:
"""Test turn_on and turn_off.""" """Test turn_on and turn_off."""
assert await async_setup_component( assert await async_setup_component(
hass, mp.DOMAIN, {"media_player": {"platform": "demo"}} hass, MP_DOMAIN, {"media_player": {"platform": "demo"}}
) )
await hass.async_block_till_done() await hass.async_block_till_done()
@ -200,40 +235,40 @@ async def test_turning_off_and_on(hass: HomeAssistant) -> None:
assert state.state == STATE_PLAYING assert state.state == STATE_PLAYING
await hass.services.async_call( await hass.services.async_call(
mp.DOMAIN, MP_DOMAIN,
mp.SERVICE_TURN_OFF, SERVICE_TURN_OFF,
{ATTR_ENTITY_ID: TEST_ENTITY_ID}, {ATTR_ENTITY_ID: TEST_ENTITY_ID},
blocking=True, blocking=True,
) )
state = hass.states.get(TEST_ENTITY_ID) state = hass.states.get(TEST_ENTITY_ID)
assert state.state == STATE_OFF assert state.state == STATE_OFF
assert not mp.is_on(hass, TEST_ENTITY_ID) assert not is_on(hass, TEST_ENTITY_ID)
await hass.services.async_call( await hass.services.async_call(
mp.DOMAIN, MP_DOMAIN,
mp.SERVICE_TURN_ON, SERVICE_TURN_ON,
{ATTR_ENTITY_ID: TEST_ENTITY_ID}, {ATTR_ENTITY_ID: TEST_ENTITY_ID},
blocking=True, blocking=True,
) )
state = hass.states.get(TEST_ENTITY_ID) state = hass.states.get(TEST_ENTITY_ID)
assert state.state == STATE_PLAYING assert state.state == STATE_PLAYING
assert mp.is_on(hass, TEST_ENTITY_ID) assert is_on(hass, TEST_ENTITY_ID)
await hass.services.async_call( await hass.services.async_call(
mp.DOMAIN, MP_DOMAIN,
mp.SERVICE_TOGGLE, SERVICE_TOGGLE,
{ATTR_ENTITY_ID: TEST_ENTITY_ID}, {ATTR_ENTITY_ID: TEST_ENTITY_ID},
blocking=True, blocking=True,
) )
state = hass.states.get(TEST_ENTITY_ID) state = hass.states.get(TEST_ENTITY_ID)
assert state.state == STATE_OFF assert state.state == STATE_OFF
assert not mp.is_on(hass, TEST_ENTITY_ID) assert not is_on(hass, TEST_ENTITY_ID)
async def test_playing_pausing(hass: HomeAssistant) -> None: async def test_playing_pausing(hass: HomeAssistant) -> None:
"""Test media_pause.""" """Test media_pause."""
assert await async_setup_component( assert await async_setup_component(
hass, mp.DOMAIN, {"media_player": {"platform": "demo"}} hass, MP_DOMAIN, {"media_player": {"platform": "demo"}}
) )
await hass.async_block_till_done() await hass.async_block_till_done()
@ -241,8 +276,8 @@ async def test_playing_pausing(hass: HomeAssistant) -> None:
assert state.state == STATE_PLAYING assert state.state == STATE_PLAYING
await hass.services.async_call( await hass.services.async_call(
mp.DOMAIN, MP_DOMAIN,
mp.SERVICE_MEDIA_PAUSE, SERVICE_MEDIA_PAUSE,
{ATTR_ENTITY_ID: TEST_ENTITY_ID}, {ATTR_ENTITY_ID: TEST_ENTITY_ID},
blocking=True, blocking=True,
) )
@ -250,8 +285,8 @@ async def test_playing_pausing(hass: HomeAssistant) -> None:
assert state.state == STATE_PAUSED assert state.state == STATE_PAUSED
await hass.services.async_call( await hass.services.async_call(
mp.DOMAIN, MP_DOMAIN,
mp.SERVICE_MEDIA_PLAY_PAUSE, SERVICE_MEDIA_PLAY_PAUSE,
{ATTR_ENTITY_ID: TEST_ENTITY_ID}, {ATTR_ENTITY_ID: TEST_ENTITY_ID},
blocking=True, blocking=True,
) )
@ -259,8 +294,8 @@ async def test_playing_pausing(hass: HomeAssistant) -> None:
assert state.state == STATE_PLAYING assert state.state == STATE_PLAYING
await hass.services.async_call( await hass.services.async_call(
mp.DOMAIN, MP_DOMAIN,
mp.SERVICE_MEDIA_PLAY_PAUSE, SERVICE_MEDIA_PLAY_PAUSE,
{ATTR_ENTITY_ID: TEST_ENTITY_ID}, {ATTR_ENTITY_ID: TEST_ENTITY_ID},
blocking=True, blocking=True,
) )
@ -268,8 +303,8 @@ async def test_playing_pausing(hass: HomeAssistant) -> None:
assert state.state == STATE_PAUSED assert state.state == STATE_PAUSED
await hass.services.async_call( await hass.services.async_call(
mp.DOMAIN, MP_DOMAIN,
mp.SERVICE_MEDIA_PLAY, SERVICE_MEDIA_PLAY,
{ATTR_ENTITY_ID: TEST_ENTITY_ID}, {ATTR_ENTITY_ID: TEST_ENTITY_ID},
blocking=True, blocking=True,
) )
@ -280,148 +315,148 @@ async def test_playing_pausing(hass: HomeAssistant) -> None:
async def test_prev_next_track(hass: HomeAssistant) -> None: async def test_prev_next_track(hass: HomeAssistant) -> None:
"""Test media_next_track and media_previous_track .""" """Test media_next_track and media_previous_track ."""
assert await async_setup_component( assert await async_setup_component(
hass, mp.DOMAIN, {"media_player": {"platform": "demo"}} hass, MP_DOMAIN, {"media_player": {"platform": "demo"}}
) )
await hass.async_block_till_done() await hass.async_block_till_done()
state = hass.states.get(TEST_ENTITY_ID) state = hass.states.get(TEST_ENTITY_ID)
assert state.attributes.get(mp.ATTR_MEDIA_TRACK) == 1 assert state.attributes.get(ATTR_MEDIA_TRACK) == 1
await hass.services.async_call( await hass.services.async_call(
mp.DOMAIN, MP_DOMAIN,
mp.SERVICE_MEDIA_NEXT_TRACK, SERVICE_MEDIA_NEXT_TRACK,
{ATTR_ENTITY_ID: TEST_ENTITY_ID}, {ATTR_ENTITY_ID: TEST_ENTITY_ID},
blocking=True, blocking=True,
) )
state = hass.states.get(TEST_ENTITY_ID) state = hass.states.get(TEST_ENTITY_ID)
assert state.attributes.get(mp.ATTR_MEDIA_TRACK) == 2 assert state.attributes.get(ATTR_MEDIA_TRACK) == 2
await hass.services.async_call( await hass.services.async_call(
mp.DOMAIN, MP_DOMAIN,
mp.SERVICE_MEDIA_NEXT_TRACK, SERVICE_MEDIA_NEXT_TRACK,
{ATTR_ENTITY_ID: TEST_ENTITY_ID}, {ATTR_ENTITY_ID: TEST_ENTITY_ID},
blocking=True, blocking=True,
) )
state = hass.states.get(TEST_ENTITY_ID) state = hass.states.get(TEST_ENTITY_ID)
assert state.attributes.get(mp.ATTR_MEDIA_TRACK) == 3 assert state.attributes.get(ATTR_MEDIA_TRACK) == 3
await hass.services.async_call( await hass.services.async_call(
mp.DOMAIN, MP_DOMAIN,
mp.SERVICE_MEDIA_PREVIOUS_TRACK, SERVICE_MEDIA_PREVIOUS_TRACK,
{ATTR_ENTITY_ID: TEST_ENTITY_ID}, {ATTR_ENTITY_ID: TEST_ENTITY_ID},
blocking=True, blocking=True,
) )
state = hass.states.get(TEST_ENTITY_ID) state = hass.states.get(TEST_ENTITY_ID)
assert state.attributes.get(mp.ATTR_MEDIA_TRACK) == 2 assert state.attributes.get(ATTR_MEDIA_TRACK) == 2
assert await async_setup_component( assert await async_setup_component(
hass, mp.DOMAIN, {"media_player": {"platform": "demo"}} hass, MP_DOMAIN, {"media_player": {"platform": "demo"}}
) )
await hass.async_block_till_done() await hass.async_block_till_done()
ent_id = "media_player.lounge_room" ent_id = "media_player.lounge_room"
state = hass.states.get(ent_id) state = hass.states.get(ent_id)
assert state.attributes.get(mp.ATTR_MEDIA_EPISODE) == "1" assert state.attributes.get(ATTR_MEDIA_EPISODE) == "1"
await hass.services.async_call( await hass.services.async_call(
mp.DOMAIN, MP_DOMAIN,
mp.SERVICE_MEDIA_NEXT_TRACK, SERVICE_MEDIA_NEXT_TRACK,
{ATTR_ENTITY_ID: ent_id}, {ATTR_ENTITY_ID: ent_id},
blocking=True, blocking=True,
) )
state = hass.states.get(ent_id) state = hass.states.get(ent_id)
assert state.attributes.get(mp.ATTR_MEDIA_EPISODE) == "2" assert state.attributes.get(ATTR_MEDIA_EPISODE) == "2"
await hass.services.async_call( await hass.services.async_call(
mp.DOMAIN, MP_DOMAIN,
mp.SERVICE_MEDIA_PREVIOUS_TRACK, SERVICE_MEDIA_PREVIOUS_TRACK,
{ATTR_ENTITY_ID: ent_id}, {ATTR_ENTITY_ID: ent_id},
blocking=True, blocking=True,
) )
state = hass.states.get(ent_id) state = hass.states.get(ent_id)
assert state.attributes.get(mp.ATTR_MEDIA_EPISODE) == "1" assert state.attributes.get(ATTR_MEDIA_EPISODE) == "1"
async def test_play_media(hass: HomeAssistant) -> None: async def test_play_media(hass: HomeAssistant) -> None:
"""Test play_media .""" """Test play_media ."""
assert await async_setup_component( assert await async_setup_component(
hass, mp.DOMAIN, {"media_player": {"platform": "demo"}} hass, MP_DOMAIN, {"media_player": {"platform": "demo"}}
) )
await hass.async_block_till_done() await hass.async_block_till_done()
ent_id = "media_player.living_room" ent_id = "media_player.living_room"
state = hass.states.get(ent_id) state = hass.states.get(ent_id)
assert ( assert (
mp.MediaPlayerEntityFeature.PLAY_MEDIA MediaPlayerEntityFeature.PLAY_MEDIA
& state.attributes.get(ATTR_SUPPORTED_FEATURES) & state.attributes.get(ATTR_SUPPORTED_FEATURES)
> 0 > 0
) )
assert state.attributes.get(mp.ATTR_MEDIA_CONTENT_ID) is not None assert state.attributes.get(ATTR_MEDIA_CONTENT_ID) is not None
with pytest.raises(vol.Invalid): with pytest.raises(vol.Invalid):
await hass.services.async_call( await hass.services.async_call(
mp.DOMAIN, MP_DOMAIN,
mp.SERVICE_PLAY_MEDIA, SERVICE_PLAY_MEDIA,
{ATTR_ENTITY_ID: ent_id, mp.ATTR_MEDIA_CONTENT_ID: "some_id"}, {ATTR_ENTITY_ID: ent_id, ATTR_MEDIA_CONTENT_ID: "some_id"},
blocking=True, blocking=True,
) )
state = hass.states.get(ent_id) state = hass.states.get(ent_id)
assert ( assert (
mp.MediaPlayerEntityFeature.PLAY_MEDIA MediaPlayerEntityFeature.PLAY_MEDIA
& state.attributes.get(ATTR_SUPPORTED_FEATURES) & state.attributes.get(ATTR_SUPPORTED_FEATURES)
> 0 > 0
) )
assert state.attributes.get(mp.ATTR_MEDIA_CONTENT_ID) != "some_id" assert state.attributes.get(ATTR_MEDIA_CONTENT_ID) != "some_id"
await hass.services.async_call( await hass.services.async_call(
mp.DOMAIN, MP_DOMAIN,
mp.SERVICE_PLAY_MEDIA, SERVICE_PLAY_MEDIA,
{ {
ATTR_ENTITY_ID: ent_id, ATTR_ENTITY_ID: ent_id,
mp.ATTR_MEDIA_CONTENT_TYPE: "youtube", ATTR_MEDIA_CONTENT_TYPE: "youtube",
mp.ATTR_MEDIA_CONTENT_ID: "some_id", ATTR_MEDIA_CONTENT_ID: "some_id",
}, },
blocking=True, blocking=True,
) )
state = hass.states.get(ent_id) state = hass.states.get(ent_id)
assert ( assert (
mp.MediaPlayerEntityFeature.PLAY_MEDIA MediaPlayerEntityFeature.PLAY_MEDIA
& state.attributes.get(ATTR_SUPPORTED_FEATURES) & state.attributes.get(ATTR_SUPPORTED_FEATURES)
> 0 > 0
) )
assert state.attributes.get(mp.ATTR_MEDIA_CONTENT_ID) == "some_id" assert state.attributes.get(ATTR_MEDIA_CONTENT_ID) == "some_id"
async def test_seek(hass: HomeAssistant, mock_media_seek) -> None: async def test_seek(hass: HomeAssistant, mock_media_seek) -> None:
"""Test seek.""" """Test seek."""
assert await async_setup_component( assert await async_setup_component(
hass, mp.DOMAIN, {"media_player": {"platform": "demo"}} hass, MP_DOMAIN, {"media_player": {"platform": "demo"}}
) )
await hass.async_block_till_done() await hass.async_block_till_done()
ent_id = "media_player.living_room" ent_id = "media_player.living_room"
state = hass.states.get(ent_id) state = hass.states.get(ent_id)
assert state.attributes[ATTR_SUPPORTED_FEATURES] & mp.MediaPlayerEntityFeature.SEEK assert state.attributes[ATTR_SUPPORTED_FEATURES] & MediaPlayerEntityFeature.SEEK
assert not mock_media_seek.called assert not mock_media_seek.called
with pytest.raises(vol.Invalid): with pytest.raises(vol.Invalid):
await hass.services.async_call( await hass.services.async_call(
mp.DOMAIN, MP_DOMAIN,
mp.SERVICE_MEDIA_SEEK, SERVICE_MEDIA_SEEK,
{ {
ATTR_ENTITY_ID: ent_id, ATTR_ENTITY_ID: ent_id,
mp.ATTR_MEDIA_SEEK_POSITION: None, ATTR_MEDIA_SEEK_POSITION: None,
}, },
blocking=True, blocking=True,
) )
assert not mock_media_seek.called assert not mock_media_seek.called
await hass.services.async_call( await hass.services.async_call(
mp.DOMAIN, MP_DOMAIN,
mp.SERVICE_MEDIA_SEEK, SERVICE_MEDIA_SEEK,
{ {
ATTR_ENTITY_ID: ent_id, ATTR_ENTITY_ID: ent_id,
mp.ATTR_MEDIA_SEEK_POSITION: 100, ATTR_MEDIA_SEEK_POSITION: 100,
}, },
blocking=True, blocking=True,
) )
@ -431,7 +466,7 @@ async def test_seek(hass: HomeAssistant, mock_media_seek) -> None:
async def test_stop(hass: HomeAssistant) -> None: async def test_stop(hass: HomeAssistant) -> None:
"""Test stop.""" """Test stop."""
assert await async_setup_component( assert await async_setup_component(
hass, mp.DOMAIN, {"media_player": {"platform": "demo"}} hass, MP_DOMAIN, {"media_player": {"platform": "demo"}}
) )
await hass.async_block_till_done() await hass.async_block_till_done()
@ -439,8 +474,8 @@ async def test_stop(hass: HomeAssistant) -> None:
assert state.state == STATE_PLAYING assert state.state == STATE_PLAYING
await hass.services.async_call( await hass.services.async_call(
mp.DOMAIN, MP_DOMAIN,
mp.SERVICE_MEDIA_STOP, SERVICE_MEDIA_STOP,
{ATTR_ENTITY_ID: TEST_ENTITY_ID}, {ATTR_ENTITY_ID: TEST_ENTITY_ID},
blocking=True, blocking=True,
) )
@ -453,7 +488,7 @@ async def test_media_image_proxy(
) -> None: ) -> None:
"""Test the media server image proxy server .""" """Test the media server image proxy server ."""
assert await async_setup_component( assert await async_setup_component(
hass, mp.DOMAIN, {"media_player": {"platform": "demo"}} hass, MP_DOMAIN, {"media_player": {"platform": "demo"}}
) )
await hass.async_block_till_done() await hass.async_block_till_done()
@ -500,31 +535,31 @@ async def test_grouping(hass: HomeAssistant) -> None:
kitchen = "media_player.kitchen" kitchen = "media_player.kitchen"
assert await async_setup_component( assert await async_setup_component(
hass, mp.DOMAIN, {"media_player": {"platform": "demo"}} hass, MP_DOMAIN, {"media_player": {"platform": "demo"}}
) )
await hass.async_block_till_done() await hass.async_block_till_done()
state = hass.states.get(walkman) state = hass.states.get(walkman)
assert state.attributes.get(mp.ATTR_GROUP_MEMBERS) == [] assert state.attributes.get(ATTR_GROUP_MEMBERS) == []
await hass.services.async_call( await hass.services.async_call(
mp.DOMAIN, MP_DOMAIN,
mp.SERVICE_JOIN, SERVICE_JOIN,
{ {
ATTR_ENTITY_ID: walkman, ATTR_ENTITY_ID: walkman,
mp.ATTR_GROUP_MEMBERS: [ ATTR_GROUP_MEMBERS: [
kitchen, kitchen,
], ],
}, },
blocking=True, blocking=True,
) )
state = hass.states.get(walkman) state = hass.states.get(walkman)
assert state.attributes.get(mp.ATTR_GROUP_MEMBERS) == [walkman, kitchen] assert state.attributes.get(ATTR_GROUP_MEMBERS) == [walkman, kitchen]
await hass.services.async_call( await hass.services.async_call(
mp.DOMAIN, MP_DOMAIN,
mp.SERVICE_UNJOIN, SERVICE_UNJOIN,
{ATTR_ENTITY_ID: walkman}, {ATTR_ENTITY_ID: walkman},
blocking=True, blocking=True,
) )
state = hass.states.get(walkman) state = hass.states.get(walkman)
assert state.attributes.get(mp.ATTR_GROUP_MEMBERS) == [] assert state.attributes.get(ATTR_GROUP_MEMBERS) == []