This commit is contained in:
Paulus Schoutsen committed 2019-07-31 12:25:30 -07:00
1 parent da05dfe708
commit 4de97abc3a
2676 files changed
+163166 -140084

No files matched your search

+185 -175
View File
@@ -8,7 +8,10 @@ import pytest
from homeassistant.setup import setup_component, async_setup_component
from homeassistant.const import (
ATTR_ENTITY_ID, ATTR_ENTITY_PICTURE, EVENT_HOMEASSISTANT_START)
ATTR_ENTITY_ID,
ATTR_ENTITY_PICTURE,
EVENT_HOMEASSISTANT_START,
)
from homeassistant.components import camera, http
from homeassistant.components.camera.const import DOMAIN, PREF_PRELOAD_STREAM
from homeassistant.components.camera.prefs import CameraEntityPreferences
@@ -17,37 +20,40 @@ from homeassistant.exceptions import HomeAssistantError
from homeassistant.util.async_ import run_coroutine_threadsafe
from tests.common import (
get_test_home_assistant, get_test_instance_port, assert_setup_component,
mock_coro)
get_test_home_assistant,
get_test_instance_port,
assert_setup_component,
mock_coro,
)
from tests.components.camera import common
@pytest.fixture
def mock_camera(hass):
"""Initialize a demo camera platform."""
assert hass.loop.run_until_complete(async_setup_component(hass, 'camera', {
camera.DOMAIN: {
'platform': 'demo'
}
}))
assert hass.loop.run_until_complete(
async_setup_component(hass, "camera", {camera.DOMAIN: {"platform": "demo"}})
)
with patch('homeassistant.components.demo.camera.DemoCamera.camera_image',
return_value=b'Test'):
with patch(
"homeassistant.components.demo.camera.DemoCamera.camera_image",
return_value=b"Test",
):
yield
@pytest.fixture
def mock_stream(hass):
"""Initialize a demo camera platform with streaming."""
assert hass.loop.run_until_complete(async_setup_component(hass, 'stream', {
'stream': {}
}))
assert hass.loop.run_until_complete(
async_setup_component(hass, "stream", {"stream": {}})
)
@pytest.fixture
def setup_camera_prefs(hass):
"""Initialize HTTP API."""
return common.mock_camera_prefs(hass, 'camera.demo_camera')
return common.mock_camera_prefs(hass, "camera.demo_camera")
class TestSetupCamera:
@@ -63,11 +69,7 @@ class TestSetupCamera:
def test_setup_component(self):
"""Set up demo platform on camera component."""
config = {
camera.DOMAIN: {
'platform': 'demo'
}
}
config = {camera.DOMAIN: {"platform": "demo"}}
with assert_setup_component(1, camera.DOMAIN):
setup_component(self.hass, camera.DOMAIN, config)
@@ -81,61 +83,69 @@ class TestGetImage:
self.hass = get_test_home_assistant()
setup_component(
self.hass, http.DOMAIN,
{http.DOMAIN: {http.CONF_SERVER_PORT: get_test_instance_port()}})
self.hass,
http.DOMAIN,
{http.DOMAIN: {http.CONF_SERVER_PORT: get_test_instance_port()}},
)
config = {
camera.DOMAIN: {
'platform': 'demo'
}
}
config = {camera.DOMAIN: {"platform": "demo"}}
setup_component(self.hass, camera.DOMAIN, config)
state = self.hass.states.get('camera.demo_camera')
state = self.hass.states.get("camera.demo_camera")
self.url = "{0}{1}".format(
self.hass.config.api.base_url,
state.attributes.get(ATTR_ENTITY_PICTURE))
self.hass.config.api.base_url, state.attributes.get(ATTR_ENTITY_PICTURE)
)
def teardown_method(self):
"""Stop everything that was started."""
self.hass.stop()
@patch('homeassistant.components.demo.camera.DemoCamera.camera_image',
autospec=True, return_value=b'Test')
@patch(
"homeassistant.components.demo.camera.DemoCamera.camera_image",
autospec=True,
return_value=b"Test",
)
def test_get_image_from_camera(self, mock_camera):
"""Grab an image from camera entity."""
self.hass.start()
image = run_coroutine_threadsafe(camera.async_get_image(
self.hass, 'camera.demo_camera'), self.hass.loop).result()
image = run_coroutine_threadsafe(
camera.async_get_image(self.hass, "camera.demo_camera"), self.hass.loop
).result()
assert mock_camera.called
assert image.content == b'Test'
assert image.content == b"Test"
def test_get_image_without_exists_camera(self):
"""Try to get image without exists camera."""
with patch('homeassistant.helpers.entity_component.EntityComponent.'
'get_entity', return_value=None), \
pytest.raises(HomeAssistantError):
run_coroutine_threadsafe(camera.async_get_image(
self.hass, 'camera.demo_camera'), self.hass.loop).result()
with patch(
"homeassistant.helpers.entity_component.EntityComponent." "get_entity",
return_value=None,
), pytest.raises(HomeAssistantError):
run_coroutine_threadsafe(
camera.async_get_image(self.hass, "camera.demo_camera"), self.hass.loop
).result()
def test_get_image_with_timeout(self):
"""Try to get image with timeout."""
with patch('homeassistant.components.camera.Camera.async_camera_image',
side_effect=asyncio.TimeoutError), \
pytest.raises(HomeAssistantError):
run_coroutine_threadsafe(camera.async_get_image(
self.hass, 'camera.demo_camera'), self.hass.loop).result()
with patch(
"homeassistant.components.camera.Camera.async_camera_image",
side_effect=asyncio.TimeoutError,
), pytest.raises(HomeAssistantError):
run_coroutine_threadsafe(
camera.async_get_image(self.hass, "camera.demo_camera"), self.hass.loop
).result()
def test_get_image_fails(self):
"""Try to get image with timeout."""
with patch('homeassistant.components.camera.Camera.async_camera_image',
return_value=mock_coro(None)), \
pytest.raises(HomeAssistantError):
run_coroutine_threadsafe(camera.async_get_image(
self.hass, 'camera.demo_camera'), self.hass.loop).result()
with patch(
"homeassistant.components.camera.Camera.async_camera_image",
return_value=mock_coro(None),
), pytest.raises(HomeAssistantError):
run_coroutine_threadsafe(
camera.async_get_image(self.hass, "camera.demo_camera"), self.hass.loop
).result()
@asyncio.coroutine
@@ -143,155 +153,158 @@ def test_snapshot_service(hass, mock_camera):
"""Test snapshot service."""
mopen = mock_open()
with patch('homeassistant.components.camera.open', mopen, create=True), \
patch.object(hass.config, 'is_allowed_path',
return_value=True):
common.async_snapshot(hass, '/tmp/bla')
with patch(
"homeassistant.components.camera.open", mopen, create=True
), patch.object(hass.config, "is_allowed_path", return_value=True):
common.async_snapshot(hass, "/tmp/bla")
yield from hass.async_block_till_done()
mock_write = mopen().write
assert len(mock_write.mock_calls) == 1
assert mock_write.mock_calls[0][1][0] == b'Test'
assert mock_write.mock_calls[0][1][0] == b"Test"
async def test_websocket_camera_thumbnail(hass, hass_ws_client, mock_camera):
"""Test camera_thumbnail websocket command."""
await async_setup_component(hass, 'camera', {})
await async_setup_component(hass, "camera", {})
client = await hass_ws_client(hass)
await client.send_json({
'id': 5,
'type': 'camera_thumbnail',
'entity_id': 'camera.demo_camera',
})
await client.send_json(
{"id": 5, "type": "camera_thumbnail", "entity_id": "camera.demo_camera"}
)
msg = await client.receive_json()
assert msg['id'] == 5
assert msg['type'] == TYPE_RESULT
assert msg['success']
assert msg['result']['content_type'] == 'image/jpeg'
assert msg['result']['content'] == \
base64.b64encode(b'Test').decode('utf-8')
assert msg["id"] == 5
assert msg["type"] == TYPE_RESULT
assert msg["success"]
assert msg["result"]["content_type"] == "image/jpeg"
assert msg["result"]["content"] == base64.b64encode(b"Test").decode("utf-8")
async def test_websocket_stream_no_source(hass, hass_ws_client,
mock_camera, mock_stream):
async def test_websocket_stream_no_source(
hass, hass_ws_client, mock_camera, mock_stream
):
"""Test camera/stream websocket command."""
await async_setup_component(hass, 'camera', {})
await async_setup_component(hass, "camera", {})
with patch('homeassistant.components.camera.request_stream',
return_value='http://home.assistant/playlist.m3u8') \
as mock_request_stream:
with patch(
"homeassistant.components.camera.request_stream",
return_value="http://home.assistant/playlist.m3u8",
) as mock_request_stream:
# Request playlist through WebSocket
client = await hass_ws_client(hass)
await client.send_json({
'id': 6,
'type': 'camera/stream',
'entity_id': 'camera.demo_camera',
})
await client.send_json(
{"id": 6, "type": "camera/stream", "entity_id": "camera.demo_camera"}
)
msg = await client.receive_json()
# Assert WebSocket response
assert not mock_request_stream.called
assert msg['id'] == 6
assert msg['type'] == TYPE_RESULT
assert not msg['success']
assert msg["id"] == 6
assert msg["type"] == TYPE_RESULT
assert not msg["success"]
async def test_websocket_camera_stream(hass, hass_ws_client,
mock_camera, mock_stream):
async def test_websocket_camera_stream(hass, hass_ws_client, mock_camera, mock_stream):
"""Test camera/stream websocket command."""
await async_setup_component(hass, 'camera', {})
await async_setup_component(hass, "camera", {})
with patch('homeassistant.components.camera.request_stream',
return_value='http://home.assistant/playlist.m3u8'
) as mock_request_stream, \
patch('homeassistant.components.demo.camera.DemoCamera.stream_source',
return_value=mock_coro('http://example.com')):
with patch(
"homeassistant.components.camera.request_stream",
return_value="http://home.assistant/playlist.m3u8",
) as mock_request_stream, patch(
"homeassistant.components.demo.camera.DemoCamera.stream_source",
return_value=mock_coro("http://example.com"),
):
# Request playlist through WebSocket
client = await hass_ws_client(hass)
await client.send_json({
'id': 6,
'type': 'camera/stream',
'entity_id': 'camera.demo_camera',
})
await client.send_json(
{"id": 6, "type": "camera/stream", "entity_id": "camera.demo_camera"}
)
msg = await client.receive_json()
# Assert WebSocket response
assert mock_request_stream.called
assert msg['id'] == 6
assert msg['type'] == TYPE_RESULT
assert msg['success']
assert msg['result']['url'][-13:] == 'playlist.m3u8'
assert msg["id"] == 6
assert msg["type"] == TYPE_RESULT
assert msg["success"]
assert msg["result"]["url"][-13:] == "playlist.m3u8"
async def test_websocket_get_prefs(hass, hass_ws_client,
mock_camera):
async def test_websocket_get_prefs(hass, hass_ws_client, mock_camera):
"""Test get camera preferences websocket command."""
await async_setup_component(hass, 'camera', {})
await async_setup_component(hass, "camera", {})
# Request preferences through websocket
client = await hass_ws_client(hass)
await client.send_json({
'id': 7,
'type': 'camera/get_prefs',
'entity_id': 'camera.demo_camera',
})
await client.send_json(
{"id": 7, "type": "camera/get_prefs", "entity_id": "camera.demo_camera"}
)
msg = await client.receive_json()
# Assert WebSocket response
assert msg['success']
assert msg["success"]
async def test_websocket_update_prefs(hass, hass_ws_client,
mock_camera, setup_camera_prefs):
async def test_websocket_update_prefs(
hass, hass_ws_client, mock_camera, setup_camera_prefs
):
"""Test updating preference."""
await async_setup_component(hass, 'camera', {})
await async_setup_component(hass, "camera", {})
assert setup_camera_prefs[PREF_PRELOAD_STREAM]
client = await hass_ws_client(hass)
await client.send_json({
'id': 8,
'type': 'camera/update_prefs',
'entity_id': 'camera.demo_camera',
'preload_stream': False,
})
await client.send_json(
{
"id": 8,
"type": "camera/update_prefs",
"entity_id": "camera.demo_camera",
"preload_stream": False,
}
)
response = await client.receive_json()
assert response['success']
assert response["success"]
assert not setup_camera_prefs[PREF_PRELOAD_STREAM]
assert response['result'][PREF_PRELOAD_STREAM] == \
setup_camera_prefs[PREF_PRELOAD_STREAM]
assert (
response["result"][PREF_PRELOAD_STREAM]
== setup_camera_prefs[PREF_PRELOAD_STREAM]
)
async def test_play_stream_service_no_source(hass, mock_camera, mock_stream):
"""Test camera play_stream service."""
data = {
ATTR_ENTITY_ID: 'camera.demo_camera',
camera.ATTR_MEDIA_PLAYER: 'media_player.test'
ATTR_ENTITY_ID: "camera.demo_camera",
camera.ATTR_MEDIA_PLAYER: "media_player.test",
}
with patch('homeassistant.components.camera.request_stream'), \
pytest.raises(HomeAssistantError):
with patch("homeassistant.components.camera.request_stream"), pytest.raises(
HomeAssistantError
):
# Call service
await hass.services.async_call(
camera.DOMAIN, camera.SERVICE_PLAY_STREAM, data, blocking=True)
camera.DOMAIN, camera.SERVICE_PLAY_STREAM, data, blocking=True
)
async def test_handle_play_stream_service(hass, mock_camera, mock_stream):
"""Test camera play_stream service."""
await async_setup_component(hass, 'media_player', {})
await async_setup_component(hass, "media_player", {})
data = {
ATTR_ENTITY_ID: 'camera.demo_camera',
camera.ATTR_MEDIA_PLAYER: 'media_player.test'
ATTR_ENTITY_ID: "camera.demo_camera",
camera.ATTR_MEDIA_PLAYER: "media_player.test",
}
with patch('homeassistant.components.camera.request_stream'
) as mock_request_stream, \
patch('homeassistant.components.demo.camera.DemoCamera.stream_source',
return_value=mock_coro('http://example.com')):
with patch(
"homeassistant.components.camera.request_stream"
) as mock_request_stream, patch(
"homeassistant.components.demo.camera.DemoCamera.stream_source",
return_value=mock_coro("http://example.com"),
):
# Call service
await hass.services.async_call(
camera.DOMAIN, camera.SERVICE_PLAY_STREAM, data, blocking=True)
camera.DOMAIN, camera.SERVICE_PLAY_STREAM, data, blocking=True
)
# So long as we request the stream, the rest should be covered
# by the play_media service tests.
assert mock_request_stream.called
@@ -299,21 +312,18 @@ async def test_handle_play_stream_service(hass, mock_camera, mock_stream):
async def test_no_preload_stream(hass, mock_stream):
"""Test camera preload preference."""
demo_prefs = CameraEntityPreferences({
PREF_PRELOAD_STREAM: False,
})
with patch('homeassistant.components.camera.request_stream'
) as mock_request_stream, \
patch('homeassistant.components.camera.prefs.CameraPreferences.get',
return_value=demo_prefs), \
patch('homeassistant.components.demo.camera.DemoCamera.stream_source',
new_callable=PropertyMock) as mock_stream_source:
demo_prefs = CameraEntityPreferences({PREF_PRELOAD_STREAM: False})
with patch(
"homeassistant.components.camera.request_stream"
) as mock_request_stream, patch(
"homeassistant.components.camera.prefs.CameraPreferences.get",
return_value=demo_prefs,
), patch(
"homeassistant.components.demo.camera.DemoCamera.stream_source",
new_callable=PropertyMock,
) as mock_stream_source:
mock_stream_source.return_value = io.BytesIO()
await async_setup_component(hass, 'camera', {
DOMAIN: {
'platform': 'demo'
}
})
await async_setup_component(hass, "camera", {DOMAIN: {"platform": "demo"}})
hass.bus.async_fire(EVENT_HOMEASSISTANT_START)
await hass.async_block_till_done()
assert not mock_request_stream.called
@@ -321,20 +331,17 @@ async def test_no_preload_stream(hass, mock_stream):
async def test_preload_stream(hass, mock_stream):
"""Test camera preload preference."""
demo_prefs = CameraEntityPreferences({
PREF_PRELOAD_STREAM: True,
})
with patch('homeassistant.components.camera.request_stream'
) as mock_request_stream, \
patch('homeassistant.components.camera.prefs.CameraPreferences.get',
return_value=demo_prefs), \
patch('homeassistant.components.demo.camera.DemoCamera.stream_source',
return_value=mock_coro("http://example.com")):
await async_setup_component(hass, 'camera', {
DOMAIN: {
'platform': 'demo'
}
})
demo_prefs = CameraEntityPreferences({PREF_PRELOAD_STREAM: True})
with patch(
"homeassistant.components.camera.request_stream"
) as mock_request_stream, patch(
"homeassistant.components.camera.prefs.CameraPreferences.get",
return_value=demo_prefs,
), patch(
"homeassistant.components.demo.camera.DemoCamera.stream_source",
return_value=mock_coro("http://example.com"),
):
await async_setup_component(hass, "camera", {DOMAIN: {"platform": "demo"}})
hass.bus.async_fire(EVENT_HOMEASSISTANT_START)
await hass.async_block_till_done()
assert mock_request_stream.called
@@ -343,32 +350,35 @@ async def test_preload_stream(hass, mock_stream):
async def test_record_service_invalid_path(hass, mock_camera):
"""Test record service with invalid path."""
data = {
ATTR_ENTITY_ID: 'camera.demo_camera',
camera.CONF_FILENAME: '/my/invalid/path'
ATTR_ENTITY_ID: "camera.demo_camera",
camera.CONF_FILENAME: "/my/invalid/path",
}
with patch.object(hass.config, 'is_allowed_path', return_value=False), \
pytest.raises(HomeAssistantError):
with patch.object(
hass.config, "is_allowed_path", return_value=False
), pytest.raises(HomeAssistantError):
# Call service
await hass.services.async_call(
camera.DOMAIN, camera.SERVICE_RECORD, data, blocking=True)
camera.DOMAIN, camera.SERVICE_RECORD, data, blocking=True
)
async def test_record_service(hass, mock_camera, mock_stream):
"""Test record service."""
data = {
ATTR_ENTITY_ID: 'camera.demo_camera',
camera.CONF_FILENAME: '/my/path'
}
data = {ATTR_ENTITY_ID: "camera.demo_camera", camera.CONF_FILENAME: "/my/path"}
with patch('homeassistant.components.demo.camera.DemoCamera.stream_source',
return_value=mock_coro("http://example.com")), \
patch(
'homeassistant.components.stream.async_handle_record_service',
return_value=mock_coro()) as mock_record_service, \
patch.object(hass.config, 'is_allowed_path', return_value=True):
with patch(
"homeassistant.components.demo.camera.DemoCamera.stream_source",
return_value=mock_coro("http://example.com"),
), patch(
"homeassistant.components.stream.async_handle_record_service",
return_value=mock_coro(),
) as mock_record_service, patch.object(
hass.config, "is_allowed_path", return_value=True
):
# Call service
await hass.services.async_call(
camera.DOMAIN, camera.SERVICE_RECORD, data, blocking=True)
camera.DOMAIN, camera.SERVICE_RECORD, data, blocking=True
)
# So long as we call stream.record, the rest should be covered
# by those tests.
assert mock_record_service.called