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

Move to new service handeling methods in Blink (#103435)

Browse source
This commit is contained in:
mkmer 2023-11-28 02:34:41 -05:00 • committed by GitHub
parent a1aff5f4a0
commit d318155f09
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
7 changed files with 561 additions and 256 deletions
Download patch file Download diff file Expand all files Collapse all files

2
tests/components/blink/conftest.py
View file

@ -13,7 +13,7 @@ from tests.common import MockConfigEntry
CAMERA_ATTRIBUTES = {
"name": "Camera 1",
"camera_id": "111111",
"serial": "serail",
"serial": "serial",
"temperature": None,
"temperature_c": 25.1,
"temperature_calibrated": None,

171
tests/components/blink/test_init.py
View file

@ -1,6 +1,6 @@
"""Test the Blink init."""
import asyncio
from unittest.mock import AsyncMock, MagicMock, Mock
from unittest.mock import AsyncMock, MagicMock
from aiohttp import ClientError
import pytest
@ -8,12 +8,10 @@ import pytest
from homeassistant.components.blink.const import (
DOMAIN,
SERVICE_REFRESH,
SERVICE_SAVE_RECENT_CLIPS,
SERVICE_SAVE_VIDEO,
SERVICE_SEND_PIN,
)
from homeassistant.config_entries import ConfigEntryState
from homeassistant.const import CONF_FILE_PATH, CONF_FILENAME, CONF_NAME, CONF_PIN
from homeassistant.core import HomeAssistant
from tests.common import MockConfigEntry
@ -61,25 +59,6 @@ async def test_setup_not_ready_authkey_required(
assert mock_config_entry.state is ConfigEntryState.SETUP_ERROR
async def test_unload_entry(
hass: HomeAssistant,
mock_blink_api: MagicMock,
mock_blink_auth_api: MagicMock,
mock_config_entry: MockConfigEntry,
) -> None:
"""Test being able to unload an entry."""
mock_config_entry.add_to_hass(hass)
assert await hass.config_entries.async_setup(mock_config_entry.entry_id)
await hass.async_block_till_done()
assert mock_config_entry.state is ConfigEntryState.LOADED
assert await hass.config_entries.async_unload(mock_config_entry.entry_id)
assert mock_config_entry.state is ConfigEntryState.NOT_LOADED
assert not hass.services.has_service(DOMAIN, SERVICE_REFRESH)
assert not hass.services.has_service(DOMAIN, SERVICE_SAVE_VIDEO)
assert not hass.services.has_service(DOMAIN, SERVICE_SEND_PIN)
async def test_unload_entry_multiple(
hass: HomeAssistant,
mock_blink_api: MagicMock,
@ -135,151 +114,3 @@ async def test_migrate(
await hass.async_block_till_done()
entry = hass.config_entries.async_get_entry(mock_config_entry.entry_id)
assert entry.state is ConfigEntryState.MIGRATION_ERROR
async def test_refresh_service_calls(
hass: HomeAssistant,
mock_blink_api: MagicMock,
mock_blink_auth_api: MagicMock,
mock_config_entry: MockConfigEntry,
) -> None:
"""Test refrest service calls."""
mock_config_entry.add_to_hass(hass)
assert await hass.config_entries.async_setup(mock_config_entry.entry_id)
await hass.async_block_till_done()
assert mock_config_entry.state is ConfigEntryState.LOADED
assert mock_blink_api.refresh.call_count == 1
await hass.services.async_call(
DOMAIN,
SERVICE_REFRESH,
blocking=True,
)
assert mock_blink_api.refresh.call_count == 2
async def test_video_service_calls(
hass: HomeAssistant,
mock_blink_api: MagicMock,
mock_blink_auth_api: MagicMock,
mock_config_entry: MockConfigEntry,
caplog: pytest.LogCaptureFixture,
) -> None:
"""Test video service calls."""
mock_config_entry.add_to_hass(hass)
assert await hass.config_entries.async_setup(mock_config_entry.entry_id)
await hass.async_block_till_done()
assert mock_config_entry.state is ConfigEntryState.LOADED
assert mock_blink_api.refresh.call_count == 1
caplog.clear()
await hass.services.async_call(
DOMAIN,
SERVICE_SAVE_VIDEO,
{CONF_NAME: CAMERA_NAME, CONF_FILENAME: FILENAME},
blocking=True,
)
assert "no access to path!" in caplog.text
hass.config.is_allowed_path = Mock(return_value=True)
caplog.clear()
mock_blink_api.cameras = {CAMERA_NAME: AsyncMock()}
await hass.services.async_call(
DOMAIN,
SERVICE_SAVE_VIDEO,
{CONF_NAME: CAMERA_NAME, CONF_FILENAME: FILENAME},
blocking=True,
)
mock_blink_api.cameras[CAMERA_NAME].video_to_file.assert_awaited_once()
mock_blink_api.cameras[CAMERA_NAME].video_to_file = AsyncMock(side_effect=OSError)
caplog.clear()
await hass.services.async_call(
DOMAIN,
SERVICE_SAVE_VIDEO,
{CONF_NAME: CAMERA_NAME, CONF_FILENAME: FILENAME},
blocking=True,
)
assert "Can't write image" in caplog.text
hass.config.is_allowed_path = Mock(return_value=False)
async def test_picture_service_calls(
hass: HomeAssistant,
mock_blink_api: MagicMock,
mock_blink_auth_api: MagicMock,
mock_config_entry: MockConfigEntry,
caplog: pytest.LogCaptureFixture,
) -> None:
"""Test picture servcie calls."""
mock_config_entry.add_to_hass(hass)
assert await hass.config_entries.async_setup(mock_config_entry.entry_id)
await hass.async_block_till_done()
assert mock_config_entry.state is ConfigEntryState.LOADED
assert mock_blink_api.refresh.call_count == 1
caplog.clear()
await hass.services.async_call(
DOMAIN,
SERVICE_SAVE_RECENT_CLIPS,
{CONF_NAME: CAMERA_NAME, CONF_FILE_PATH: FILENAME},
blocking=True,
)
assert "no access to path!" in caplog.text
hass.config.is_allowed_path = Mock(return_value=True)
mock_blink_api.cameras = {CAMERA_NAME: AsyncMock()}
await hass.services.async_call(
DOMAIN,
SERVICE_SAVE_RECENT_CLIPS,
{CONF_NAME: CAMERA_NAME, CONF_FILE_PATH: FILENAME},
blocking=True,
)
mock_blink_api.cameras[CAMERA_NAME].save_recent_clips.assert_awaited_once()
mock_blink_api.cameras[CAMERA_NAME].save_recent_clips = AsyncMock(
side_effect=OSError
)
caplog.clear()
await hass.services.async_call(
DOMAIN,
SERVICE_SAVE_RECENT_CLIPS,
{CONF_NAME: CAMERA_NAME, CONF_FILE_PATH: FILENAME},
blocking=True,
)
assert "Can't write recent clips to directory" in caplog.text
async def test_pin_service_calls(
hass: HomeAssistant,
mock_blink_api: MagicMock,
mock_blink_auth_api: MagicMock,
mock_config_entry: MockConfigEntry,
) -> None:
"""Test pin service calls."""
mock_config_entry.add_to_hass(hass)
assert await hass.config_entries.async_setup(mock_config_entry.entry_id)
await hass.async_block_till_done()
assert mock_config_entry.state is ConfigEntryState.LOADED
assert mock_blink_api.refresh.call_count == 1
await hass.services.async_call(
DOMAIN,
SERVICE_SEND_PIN,
{CONF_PIN: PIN},
blocking=True,
)
assert mock_blink_api.auth.send_auth_key.assert_awaited_once

393
tests/components/blink/test_services.py Normal file
View file

@ -0,0 +1,393 @@
"""Test the Blink services."""
from unittest.mock import AsyncMock, MagicMock, Mock
import pytest
from homeassistant.components.blink.const import (
DOMAIN,
SERVICE_REFRESH,
SERVICE_SAVE_RECENT_CLIPS,
SERVICE_SAVE_VIDEO,
SERVICE_SEND_PIN,
)
from homeassistant.config_entries import ConfigEntryState
from homeassistant.const import (
ATTR_DEVICE_ID,
CONF_FILE_PATH,
CONF_FILENAME,
CONF_NAME,
CONF_PIN,
)
from homeassistant.core import HomeAssistant
from homeassistant.exceptions import HomeAssistantError
from homeassistant.helpers import device_registry as dr
from tests.common import MockConfigEntry
CAMERA_NAME = "Camera 1"
FILENAME = "blah"
PIN = "1234"
async def test_refresh_service_calls(
hass: HomeAssistant,
device_registry: dr.DeviceRegistry,
mock_blink_api: MagicMock,
mock_blink_auth_api: MagicMock,
mock_config_entry: MockConfigEntry,
) -> None:
"""Test refrest service calls."""
mock_config_entry.add_to_hass(hass)
assert await hass.config_entries.async_setup(mock_config_entry.entry_id)
await hass.async_block_till_done()
device_entry = device_registry.async_get_device(identifiers={(DOMAIN, "12345")})
assert device_entry
assert mock_config_entry.state is ConfigEntryState.LOADED
assert mock_blink_api.refresh.call_count == 1
await hass.services.async_call(
DOMAIN,
SERVICE_REFRESH,
{ATTR_DEVICE_ID: [device_entry.id]},
blocking=True,
)
assert mock_blink_api.refresh.call_count == 2
with pytest.raises(HomeAssistantError) as execinfo:
await hass.services.async_call(
DOMAIN,
SERVICE_REFRESH,
{ATTR_DEVICE_ID: ["bad-device_id"]},
blocking=True,
)
assert "Device 'bad-device_id' not found in device registry" in str(execinfo)
async def test_video_service_calls(
hass: HomeAssistant,
device_registry: dr.DeviceRegistry,
mock_blink_api: MagicMock,
mock_blink_auth_api: MagicMock,
mock_config_entry: MockConfigEntry,
caplog: pytest.LogCaptureFixture,
) -> None:
"""Test video service calls."""
mock_config_entry.add_to_hass(hass)
assert await hass.config_entries.async_setup(mock_config_entry.entry_id)
await hass.async_block_till_done()
device_entry = device_registry.async_get_device(identifiers={(DOMAIN, "12345")})
assert device_entry
assert mock_config_entry.state is ConfigEntryState.LOADED
assert mock_blink_api.refresh.call_count == 1
caplog.clear()
await hass.services.async_call(
DOMAIN,
SERVICE_SAVE_VIDEO,
{
ATTR_DEVICE_ID: [device_entry.id],
CONF_NAME: CAMERA_NAME,
CONF_FILENAME: FILENAME,
},
blocking=True,
)
assert "no access to path!" in caplog.text
hass.config.is_allowed_path = Mock(return_value=True)
caplog.clear()
mock_blink_api.cameras = {CAMERA_NAME: AsyncMock()}
await hass.services.async_call(
DOMAIN,
SERVICE_SAVE_VIDEO,
{
ATTR_DEVICE_ID: [device_entry.id],
CONF_NAME: CAMERA_NAME,
CONF_FILENAME: FILENAME,
},
blocking=True,
)
mock_blink_api.cameras[CAMERA_NAME].video_to_file.assert_awaited_once()
with pytest.raises(HomeAssistantError) as execinfo:
await hass.services.async_call(
DOMAIN,
SERVICE_SAVE_VIDEO,
{
ATTR_DEVICE_ID: ["bad-device_id"],
CONF_NAME: CAMERA_NAME,
CONF_FILENAME: FILENAME,
},
blocking=True,
)
assert "Device 'bad-device_id' not found in device registry" in str(execinfo)
mock_blink_api.cameras[CAMERA_NAME].video_to_file = AsyncMock(side_effect=OSError)
caplog.clear()
await hass.services.async_call(
DOMAIN,
SERVICE_SAVE_VIDEO,
{
ATTR_DEVICE_ID: [device_entry.id],
CONF_NAME: CAMERA_NAME,
CONF_FILENAME: FILENAME,
},
blocking=True,
)
assert "Can't write image" in caplog.text
hass.config.is_allowed_path = Mock(return_value=False)
async def test_picture_service_calls(
hass: HomeAssistant,
device_registry: dr.DeviceRegistry,
mock_blink_api: MagicMock,
mock_blink_auth_api: MagicMock,
mock_config_entry: MockConfigEntry,
caplog: pytest.LogCaptureFixture,
) -> None:
"""Test picture servcie calls."""
mock_config_entry.add_to_hass(hass)
assert await hass.config_entries.async_setup(mock_config_entry.entry_id)
await hass.async_block_till_done()
device_entry = device_registry.async_get_device(identifiers={(DOMAIN, "12345")})
assert device_entry
assert mock_config_entry.state is ConfigEntryState.LOADED
assert mock_blink_api.refresh.call_count == 1
caplog.clear()
await hass.services.async_call(
DOMAIN,
SERVICE_SAVE_RECENT_CLIPS,
{
ATTR_DEVICE_ID: [device_entry.id],
CONF_NAME: CAMERA_NAME,
CONF_FILE_PATH: FILENAME,
},
blocking=True,
)
assert "no access to path!" in caplog.text
hass.config.is_allowed_path = Mock(return_value=True)
mock_blink_api.cameras = {CAMERA_NAME: AsyncMock()}
await hass.services.async_call(
DOMAIN,
SERVICE_SAVE_RECENT_CLIPS,
{
ATTR_DEVICE_ID: [device_entry.id],
CONF_NAME: CAMERA_NAME,
CONF_FILE_PATH: FILENAME,
},
blocking=True,
)
mock_blink_api.cameras[CAMERA_NAME].save_recent_clips.assert_awaited_once()
mock_blink_api.cameras[CAMERA_NAME].save_recent_clips = AsyncMock(
side_effect=OSError
)
caplog.clear()
await hass.services.async_call(
DOMAIN,
SERVICE_SAVE_RECENT_CLIPS,
{
ATTR_DEVICE_ID: [device_entry.id],
CONF_NAME: CAMERA_NAME,
CONF_FILE_PATH: FILENAME,
},
blocking=True,
)
assert "Can't write recent clips to directory" in caplog.text
with pytest.raises(HomeAssistantError) as execinfo:
await hass.services.async_call(
DOMAIN,
SERVICE_SAVE_RECENT_CLIPS,
{
ATTR_DEVICE_ID: ["bad-device_id"],
CONF_NAME: CAMERA_NAME,
CONF_FILE_PATH: FILENAME,
},
blocking=True,
)
assert "Device 'bad-device_id' not found in device registry" in str(execinfo)
async def test_pin_service_calls(
hass: HomeAssistant,
device_registry: dr.DeviceRegistry,
mock_blink_api: MagicMock,
mock_blink_auth_api: MagicMock,
mock_config_entry: MockConfigEntry,
) -> None:
"""Test pin service calls."""
mock_config_entry.add_to_hass(hass)
assert await hass.config_entries.async_setup(mock_config_entry.entry_id)
await hass.async_block_till_done()
device_entry = device_registry.async_get_device(identifiers={(DOMAIN, "12345")})
assert device_entry
assert mock_config_entry.state is ConfigEntryState.LOADED
assert mock_blink_api.refresh.call_count == 1
await hass.services.async_call(
DOMAIN,
SERVICE_SEND_PIN,
{ATTR_DEVICE_ID: [device_entry.id], CONF_PIN: PIN},
blocking=True,
)
assert mock_blink_api.auth.send_auth_key.assert_awaited_once
with pytest.raises(HomeAssistantError) as execinfo:
await hass.services.async_call(
DOMAIN,
SERVICE_SEND_PIN,
{ATTR_DEVICE_ID: ["bad-device_id"], CONF_PIN: PIN},
blocking=True,
)
assert "Device 'bad-device_id' not found in device registry" in str(execinfo)
@pytest.mark.parametrize(
("service", "params"),
[
(SERVICE_SEND_PIN, {CONF_PIN: PIN}),
(
SERVICE_SAVE_RECENT_CLIPS,
{
CONF_NAME: CAMERA_NAME,
CONF_FILE_PATH: FILENAME,
},
),
(
SERVICE_SAVE_VIDEO,
{
CONF_NAME: CAMERA_NAME,
CONF_FILENAME: FILENAME,
},
),
],
)
async def test_service_called_with_non_blink_device(
hass: HomeAssistant,
device_registry: dr.DeviceRegistry,
mock_blink_api: MagicMock,
mock_blink_auth_api: MagicMock,
mock_config_entry: MockConfigEntry,
service,
params,
) -> None:
"""Test service calls with non blink device."""
mock_config_entry.add_to_hass(hass)
assert await hass.config_entries.async_setup(mock_config_entry.entry_id)
await hass.async_block_till_done()
other_domain = "NotBlink"
other_config_id = "555"
await hass.config_entries.async_add(
MockConfigEntry(
title="Not Blink", domain=other_domain, entry_id=other_config_id
)
)
device_entry = device_registry.async_get_or_create(
config_entry_id=other_config_id,
identifiers={
(other_domain, 1),
},
)
hass.config.is_allowed_path = Mock(return_value=True)
mock_blink_api.cameras = {CAMERA_NAME: AsyncMock()}
parameters = {ATTR_DEVICE_ID: [device_entry.id]}
parameters.update(params)
with pytest.raises(HomeAssistantError) as execinfo:
await hass.services.async_call(
DOMAIN,
service,
parameters,
blocking=True,
)
assert f"Device '{device_entry.id}' is not a blink device" in str(execinfo)
@pytest.mark.parametrize(
("service", "params"),
[
(SERVICE_SEND_PIN, {CONF_PIN: PIN}),
(
SERVICE_SAVE_RECENT_CLIPS,
{
CONF_NAME: CAMERA_NAME,
CONF_FILE_PATH: FILENAME,
},
),
(
SERVICE_SAVE_VIDEO,
{
CONF_NAME: CAMERA_NAME,
CONF_FILENAME: FILENAME,
},
),
],
)
async def test_service_called_with_unloaded_entry(
hass: HomeAssistant,
device_registry: dr.DeviceRegistry,
mock_blink_api: MagicMock,
mock_blink_auth_api: MagicMock,
mock_config_entry: MockConfigEntry,
service,
params,
) -> None:
"""Test service calls with unloaded config entry."""
mock_config_entry.add_to_hass(hass)
assert await hass.config_entries.async_setup(mock_config_entry.entry_id)
await hass.async_block_till_done()
await mock_config_entry.async_unload(hass)
device_entry = device_registry.async_get_device(identifiers={(DOMAIN, "12345")})
assert device_entry
hass.config.is_allowed_path = Mock(return_value=True)
mock_blink_api.cameras = {CAMERA_NAME: AsyncMock()}
parameters = {ATTR_DEVICE_ID: [device_entry.id]}
parameters.update(params)
with pytest.raises(HomeAssistantError) as execinfo:
await hass.services.async_call(
DOMAIN,
service,
parameters,
blocking=True,
)
assert "Mock Title is not loaded" in str(execinfo)