mirror of
https://github.com/home-assistant/core.git
synced 2026-09-04 20:42:21 +01:00
270 lines
8.4 KiB
Python
270 lines
8.4 KiB
Python
"""The tests for the Collection Image image platform."""
|
|
|
|
from http import HTTPStatus
|
|
from pathlib import Path
|
|
from unittest.mock import AsyncMock, patch
|
|
|
|
from freezegun import freeze_time
|
|
import pytest
|
|
|
|
from homeassistant.components.image import Image, async_get_image
|
|
from homeassistant.components.media_source import BrowseMediaSource, PlayMedia
|
|
from homeassistant.const import (
|
|
EVENT_HOMEASSISTANT_STARTED,
|
|
STATE_UNAVAILABLE,
|
|
STATE_UNKNOWN,
|
|
)
|
|
from homeassistant.core import CoreState, HomeAssistant
|
|
from homeassistant.exceptions import HomeAssistantError
|
|
|
|
from .const import DEFAULT_ENTITY_ID, TEST_IMAGE
|
|
|
|
from tests.common import MockConfigEntry
|
|
from tests.typing import ClientSessionGenerator
|
|
|
|
TEST_TIME = "2025-11-08T12:00:00+00:00"
|
|
|
|
|
|
async def test_image(
|
|
hass: HomeAssistant,
|
|
hass_client: ClientSessionGenerator,
|
|
config_entry: MockConfigEntry,
|
|
mock_media_source,
|
|
) -> None:
|
|
"""Test loading an image."""
|
|
with (
|
|
freeze_time(TEST_TIME),
|
|
):
|
|
config_entry.add_to_hass(hass)
|
|
assert await hass.config_entries.async_setup(config_entry.entry_id)
|
|
await hass.async_block_till_done()
|
|
|
|
state = hass.states.get(DEFAULT_ENTITY_ID)
|
|
|
|
assert state and state.state == TEST_TIME
|
|
|
|
client = await hass_client()
|
|
|
|
resp = await client.get(f"/api/image_proxy/{DEFAULT_ENTITY_ID}")
|
|
assert resp.status == HTTPStatus.OK
|
|
assert resp.content_type == "image/png"
|
|
expected_data = await hass.async_add_executor_job(TEST_IMAGE.read_bytes)
|
|
body = await resp.read()
|
|
assert body == expected_data
|
|
|
|
|
|
async def test_image_during_startup(
|
|
hass: HomeAssistant,
|
|
hass_client: ClientSessionGenerator,
|
|
config_entry: MockConfigEntry,
|
|
mock_media_source,
|
|
) -> None:
|
|
"""Test loading an image, ensuring that we don't browse until after startup is complete."""
|
|
with freeze_time(TEST_TIME):
|
|
hass.set_state(CoreState.starting)
|
|
|
|
config_entry.add_to_hass(hass)
|
|
assert await hass.config_entries.async_setup(config_entry.entry_id)
|
|
await hass.async_block_till_done()
|
|
|
|
hass.set_state(CoreState.running)
|
|
hass.bus.async_fire(EVENT_HOMEASSISTANT_STARTED)
|
|
await hass.async_block_till_done()
|
|
|
|
state = hass.states.get(DEFAULT_ENTITY_ID)
|
|
|
|
assert state and state.state == TEST_TIME
|
|
|
|
client = await hass_client()
|
|
|
|
resp = await client.get(f"/api/image_proxy/{DEFAULT_ENTITY_ID}")
|
|
assert resp.status == HTTPStatus.OK
|
|
assert resp.content_type == "image/png"
|
|
expected_data = await hass.async_add_executor_job(TEST_IMAGE.read_bytes)
|
|
body = await resp.read()
|
|
assert body == expected_data
|
|
|
|
|
|
async def test_image_url(
|
|
hass: HomeAssistant,
|
|
hass_client: ClientSessionGenerator,
|
|
config_entry: MockConfigEntry,
|
|
browse_media_result: BrowseMediaSource,
|
|
) -> None:
|
|
"""Test loading an image, when media resolves to a URL."""
|
|
|
|
expected_data = await hass.async_add_executor_job(TEST_IMAGE.read_bytes)
|
|
|
|
with (
|
|
freeze_time(TEST_TIME),
|
|
patch(
|
|
"homeassistant.components.collection_image.image.async_browse_media",
|
|
return_value=browse_media_result,
|
|
),
|
|
patch(
|
|
"homeassistant.components.collection_image.image.async_resolve_media",
|
|
return_value=PlayMedia(
|
|
url="http://example.com/test.png",
|
|
mime_type="image/png",
|
|
),
|
|
),
|
|
):
|
|
config_entry.add_to_hass(hass)
|
|
assert await hass.config_entries.async_setup(config_entry.entry_id)
|
|
await hass.async_block_till_done()
|
|
|
|
state = hass.states.get(DEFAULT_ENTITY_ID)
|
|
|
|
assert state and state.state == TEST_TIME
|
|
|
|
client = await hass_client()
|
|
|
|
with patch(
|
|
"homeassistant.components.collection_image.image.CollectionImageImageEntity._async_load_image_from_url",
|
|
new_callable=AsyncMock,
|
|
) as mock_load:
|
|
mock_load.return_value = Image(
|
|
content_type="image/png",
|
|
content=expected_data,
|
|
)
|
|
resp = await client.get(f"/api/image_proxy/{DEFAULT_ENTITY_ID}")
|
|
mock_load.assert_awaited_once_with("http://example.com/test.png")
|
|
|
|
assert resp.status == HTTPStatus.OK
|
|
assert resp.content_type == "image/png"
|
|
body = await resp.read()
|
|
assert body == expected_data
|
|
|
|
|
|
async def test_no_images(
|
|
hass: HomeAssistant,
|
|
hass_client: ClientSessionGenerator,
|
|
config_entry: MockConfigEntry,
|
|
caplog: pytest.LogCaptureFixture,
|
|
) -> None:
|
|
"""Test when there are no images in the media folder."""
|
|
with patch(
|
|
"homeassistant.components.collection_image.image.async_browse_media",
|
|
return_value=BrowseMediaSource(
|
|
domain=None,
|
|
identifier=None,
|
|
media_class="",
|
|
media_content_type="",
|
|
title="",
|
|
can_play=False,
|
|
can_expand=True,
|
|
children=[],
|
|
),
|
|
):
|
|
config_entry.add_to_hass(hass)
|
|
assert await hass.config_entries.async_setup(config_entry.entry_id)
|
|
await hass.async_block_till_done()
|
|
|
|
state = hass.states.get(DEFAULT_ENTITY_ID)
|
|
|
|
assert state and state.state == STATE_UNAVAILABLE
|
|
|
|
await hass.async_block_till_done(wait_background_tasks=True)
|
|
|
|
assert (
|
|
"image.random_image: No valid images in media-source://mymedia" in caplog.text
|
|
)
|
|
|
|
client = await hass_client()
|
|
resp = await client.get(f"/api/image_proxy/{DEFAULT_ENTITY_ID}")
|
|
assert resp.status == HTTPStatus.INTERNAL_SERVER_ERROR
|
|
|
|
|
|
async def test_media_error(
|
|
hass: HomeAssistant,
|
|
hass_client: ClientSessionGenerator,
|
|
config_entry: MockConfigEntry,
|
|
caplog: pytest.LogCaptureFixture,
|
|
) -> None:
|
|
"""Test when media browse throws an error."""
|
|
|
|
config_entry.add_to_hass(hass)
|
|
assert await hass.config_entries.async_setup(config_entry.entry_id)
|
|
await hass.async_block_till_done()
|
|
|
|
state = hass.states.get(DEFAULT_ENTITY_ID)
|
|
|
|
assert state and state.state == STATE_UNAVAILABLE
|
|
|
|
await hass.async_block_till_done(wait_background_tasks=True)
|
|
|
|
assert "image.random_image: Media Source not loaded" in caplog.text
|
|
|
|
client = await hass_client()
|
|
resp = await client.get(f"/api/image_proxy/{DEFAULT_ENTITY_ID}")
|
|
assert resp.status == HTTPStatus.INTERNAL_SERVER_ERROR
|
|
|
|
|
|
async def test_unresolvable(
|
|
hass: HomeAssistant,
|
|
config_entry: MockConfigEntry,
|
|
browse_media_result: BrowseMediaSource,
|
|
caplog: pytest.LogCaptureFixture,
|
|
) -> None:
|
|
"""Test when resolving an image fails."""
|
|
|
|
with (
|
|
patch(
|
|
"homeassistant.components.collection_image.image.async_browse_media",
|
|
return_value=browse_media_result,
|
|
),
|
|
):
|
|
config_entry.add_to_hass(hass)
|
|
assert await hass.config_entries.async_setup(config_entry.entry_id)
|
|
await hass.async_block_till_done()
|
|
|
|
state = hass.states.get(DEFAULT_ENTITY_ID)
|
|
|
|
assert state and state.state == STATE_UNKNOWN
|
|
|
|
await hass.async_block_till_done(wait_background_tasks=True)
|
|
|
|
assert "image.random_image: Media Source not loaded" in caplog.text
|
|
|
|
|
|
async def test_image_file_read_error(
|
|
hass: HomeAssistant,
|
|
config_entry: MockConfigEntry,
|
|
browse_media_result: BrowseMediaSource,
|
|
hass_client: ClientSessionGenerator,
|
|
) -> None:
|
|
"""Test that a file read error is surfaced when serving the image."""
|
|
missing_path = Path(__file__).parent / "does_not_exist.png"
|
|
|
|
with (
|
|
freeze_time(TEST_TIME),
|
|
patch(
|
|
"homeassistant.components.collection_image.image.async_browse_media",
|
|
return_value=browse_media_result,
|
|
),
|
|
patch(
|
|
"homeassistant.components.collection_image.image.async_resolve_media",
|
|
return_value=PlayMedia(
|
|
url="",
|
|
mime_type="image/png",
|
|
path=missing_path,
|
|
),
|
|
),
|
|
):
|
|
config_entry.add_to_hass(hass)
|
|
assert await hass.config_entries.async_setup(config_entry.entry_id)
|
|
await hass.async_block_till_done()
|
|
|
|
# Browse and resolve succeeded, so the entity is available with an image.
|
|
state = hass.states.get(DEFAULT_ENTITY_ID)
|
|
assert state and state.state == TEST_TIME
|
|
|
|
with pytest.raises(HomeAssistantError) as exc_info:
|
|
await async_get_image(hass, DEFAULT_ENTITY_ID)
|
|
assert exc_info.value.translation_key == "image_read_error"
|
|
assert exc_info.value.translation_placeholders["path"] == str(missing_path)
|
|
|
|
client = await hass_client()
|
|
resp = await client.get(f"/api/image_proxy/{DEFAULT_ENTITY_ID}")
|
|
assert resp.status == HTTPStatus.INTERNAL_SERVER_ERROR
|