diff --git a/homeassistant/components/camera/__init__.py b/homeassistant/components/camera/__init__.py index c759f5704cf..70394fc3c0e 100644 --- a/homeassistant/components/camera/__init__.py +++ b/homeassistant/components/camera/__init__.py @@ -4,7 +4,7 @@ from __future__ import annotations import asyncio import collections -from collections.abc import Awaitable, Callable +from collections.abc import Awaitable, Callable, Coroutine from contextlib import suppress from dataclasses import asdict from datetime import datetime, timedelta @@ -86,12 +86,20 @@ from .img_util import scale_jpeg_camera_image from .prefs import CameraPreferences, DynamicStreamSettings # noqa: F401 from .webrtc import ( DATA_ICE_SERVERS, + CameraWebRTCLegacyProvider, CameraWebRTCProvider, + WebRTCAnswer, + WebRTCCandidate, # noqa: F401 WebRTCClientConfiguration, - async_get_supported_providers, + WebRTCError, + WebRTCMessage, # noqa: F401 + WebRTCSendMessage, + async_get_supported_legacy_provider, + async_get_supported_provider, async_register_ice_servers, async_register_rtsp_to_web_rtc_provider, # noqa: F401 - ws_get_client_config, + async_register_webrtc_provider, # noqa: F401 + async_register_ws, ) _LOGGER = logging.getLogger(__name__) @@ -342,10 +350,9 @@ async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool: hass.http.register_view(CameraMjpegStream(component)) websocket_api.async_register_command(hass, ws_camera_stream) - websocket_api.async_register_command(hass, ws_camera_web_rtc_offer) websocket_api.async_register_command(hass, websocket_get_prefs) websocket_api.async_register_command(hass, websocket_update_prefs) - websocket_api.async_register_command(hass, ws_get_client_config) + async_register_ws(hass) await component.async_setup(config) @@ -463,7 +470,11 @@ class Camera(Entity, cached_properties=CACHED_PROPERTIES_WITH_ATTR_): self._warned_old_signature = False self.async_update_token() self._create_stream_lock: asyncio.Lock | None = None - self._webrtc_providers: list[CameraWebRTCProvider] = [] + self._webrtc_provider: CameraWebRTCProvider | None = None + self._legacy_webrtc_provider: CameraWebRTCLegacyProvider | None = None + self._webrtc_sync_offer = ( + type(self).async_handle_web_rtc_offer != Camera.async_handle_web_rtc_offer + ) @cached_property def entity_picture(self) -> str: @@ -537,7 +548,7 @@ class Camera(Entity, cached_properties=CACHED_PROPERTIES_WITH_ATTR_): return self._attr_frontend_stream_type if CameraEntityFeature.STREAM not in self.supported_features_compat: return None - if self._webrtc_providers: + if self._webrtc_provider or self._legacy_webrtc_provider: return StreamType.WEB_RTC return StreamType.HLS @@ -587,12 +598,66 @@ class Camera(Entity, cached_properties=CACHED_PROPERTIES_WITH_ATTR_): Integrations can override with a native WebRTC implementation. """ - for provider in self._webrtc_providers: - if answer := await provider.async_handle_web_rtc_offer(self, offer_sdp): - return answer - raise HomeAssistantError( - "WebRTC offer was not accepted by the supported providers" - ) + + async def async_handle_async_webrtc_offer( + self, offer_sdp: str, session_id: str, send_message: WebRTCSendMessage + ) -> None: + """Handle the async WebRTC offer. + + Async means that it could take some time to process the offer and responses/message + will be sent with the send_message callback. + This method is used by cameras with CameraEntityFeature.STREAM and StreamType.WEB_RTC. + An integration overriding this method must also implement async_on_webrtc_candidate. + + Integrations can override with a native WebRTC implementation. + """ + if self._webrtc_sync_offer: + try: + answer = await self.async_handle_web_rtc_offer(offer_sdp) + except ValueError as ex: + _LOGGER.error("Error handling WebRTC offer: %s", ex) + send_message( + WebRTCError( + "webrtc_offer_failed", + str(ex), + ) + ) + except TimeoutError: + # This catch was already here and should stay through the deprecation + _LOGGER.error("Timeout handling WebRTC offer") + send_message( + WebRTCError( + "webrtc_offer_failed", + "Timeout handling WebRTC offer", + ) + ) + else: + if answer: + send_message(WebRTCAnswer(answer)) + else: + _LOGGER.error("Error handling WebRTC offer: No answer") + send_message( + WebRTCError( + "webrtc_offer_failed", + "No answer on WebRTC offer", + ) + ) + return + + if self._webrtc_provider: + await self._webrtc_provider.async_handle_async_webrtc_offer( + self, offer_sdp, session_id, send_message + ) + return + + if self._legacy_webrtc_provider and ( + answer := await self._legacy_webrtc_provider.async_handle_web_rtc_offer( + self, offer_sdp + ) + ): + send_message(WebRTCAnswer(answer)) + else: + raise HomeAssistantError("Camera does not support WebRTC") def camera_image( self, width: int | None = None, height: int | None = None @@ -702,38 +767,41 @@ class Camera(Entity, cached_properties=CACHED_PROPERTIES_WITH_ATTR_): async def async_internal_added_to_hass(self) -> None: """Run when entity about to be added to hass.""" await super().async_internal_added_to_hass() - # Avoid calling async_refresh_providers() in here because it - # it will write state a second time since state is always - # written when an entity is added to hass. - self._webrtc_providers = await self._async_get_supported_webrtc_providers() + await self.async_refresh_providers(write_state=False) - async def async_refresh_providers(self) -> None: + async def async_refresh_providers(self, *, write_state: bool = True) -> None: """Determine if any of the registered providers are suitable for this entity. This affects state attributes, so it should be invoked any time the registered providers or inputs to the state attributes change. - - Returns True if any state was updated (and needs to be written) """ - old_providers = self._webrtc_providers - new_providers = await self._async_get_supported_webrtc_providers() - self._webrtc_providers = new_providers - if old_providers != new_providers: - self.async_write_ha_state() + old_provider = self._webrtc_provider + new_provider = await self._async_get_supported_webrtc_provider( + async_get_supported_provider + ) - async def _async_get_supported_webrtc_providers( - self, - ) -> list[CameraWebRTCProvider]: - """Get the all providers that supports this camera.""" + old_legacy_provider = self._legacy_webrtc_provider + new_legacy_provider = None + if new_provider is None: + # Only add the legacy provider if the new provider is not available + new_legacy_provider = await self._async_get_supported_webrtc_provider( + async_get_supported_legacy_provider + ) + + if old_provider != new_provider or old_legacy_provider != new_legacy_provider: + self._webrtc_provider = new_provider + self._legacy_webrtc_provider = new_legacy_provider + if write_state: + self.async_write_ha_state() + + async def _async_get_supported_webrtc_provider[_T]( + self, fn: Callable[[HomeAssistant, Camera], Coroutine[None, None, _T | None]] + ) -> _T | None: + """Get first provider that supports this camera.""" if CameraEntityFeature.STREAM not in self.supported_features_compat: - return [] + return None - return await async_get_supported_providers(self.hass, self) - - @property - def webrtc_providers(self) -> list[CameraWebRTCProvider]: - """Return the WebRTC providers.""" - return self._webrtc_providers + return await fn(self.hass, self) async def _async_get_webrtc_client_configuration(self) -> WebRTCClientConfiguration: """Return the WebRTC client configuration adjustable per integration.""" @@ -751,8 +819,25 @@ class Camera(Entity, cached_properties=CACHED_PROPERTIES_WITH_ATTR_): ] config.configuration.ice_servers.extend(ice_servers) + config.get_candidates_upfront = ( + self._webrtc_sync_offer or self._legacy_webrtc_provider is not None + ) + return config + async def async_on_webrtc_candidate(self, session_id: str, candidate: str) -> None: + """Handle a WebRTC candidate.""" + if self._webrtc_provider: + await self._webrtc_provider.async_on_webrtc_candidate(session_id, candidate) + else: + raise HomeAssistantError("Cannot handle WebRTC candidate") + + @callback + def close_webrtc_session(self, session_id: str) -> None: + """Close a WebRTC session.""" + if self._webrtc_provider: + self._webrtc_provider.async_close_session(session_id) + class CameraView(HomeAssistantView): """Base CameraView.""" @@ -873,53 +958,6 @@ async def ws_camera_stream( ) -@websocket_api.websocket_command( - { - vol.Required("type"): "camera/web_rtc_offer", - vol.Required("entity_id"): cv.entity_id, - vol.Required("offer"): str, - } -) -@websocket_api.async_response -async def ws_camera_web_rtc_offer( - hass: HomeAssistant, connection: ActiveConnection, msg: dict[str, Any] -) -> None: - """Handle the signal path for a WebRTC stream. - - This signal path is used to route the offer created by the client to the - camera device through the integration for negotiation on initial setup, - which returns an answer. The actual streaming is handled entirely between - the client and camera device. - - Async friendly. - """ - entity_id = msg["entity_id"] - offer = msg["offer"] - camera = get_camera_from_entity_id(hass, entity_id) - if camera.frontend_stream_type != StreamType.WEB_RTC: - connection.send_error( - msg["id"], - "web_rtc_offer_failed", - ( - "Camera does not support WebRTC," - f" frontend_stream_type={camera.frontend_stream_type}" - ), - ) - return - try: - answer = await camera.async_handle_web_rtc_offer(offer) - except (HomeAssistantError, ValueError) as ex: - _LOGGER.error("Error handling WebRTC offer: %s", ex) - connection.send_error(msg["id"], "web_rtc_offer_failed", str(ex)) - except TimeoutError: - _LOGGER.error("Timeout handling WebRTC offer") - connection.send_error( - msg["id"], "web_rtc_offer_failed", "Timeout handling WebRTC offer" - ) - else: - connection.send_result(msg["id"], {"answer": answer}) - - @websocket_api.websocket_command( {vol.Required("type"): "camera/get_prefs", vol.Required("entity_id"): cv.entity_id} ) diff --git a/homeassistant/components/camera/webrtc.py b/homeassistant/components/camera/webrtc.py index 12cca6fabd9..cd79e0cefad 100644 --- a/homeassistant/components/camera/webrtc.py +++ b/homeassistant/components/camera/webrtc.py @@ -4,7 +4,9 @@ from __future__ import annotations import asyncio from collections.abc import Awaitable, Callable, Iterable -from dataclasses import dataclass, field +from dataclasses import asdict, dataclass, field +from functools import cache, partial +import logging from typing import TYPE_CHECKING, Any, Protocol import voluptuous as vol @@ -12,8 +14,10 @@ from webrtc_models import RTCConfiguration, RTCIceServer from homeassistant.components import websocket_api from homeassistant.core import HomeAssistant, callback +from homeassistant.exceptions import HomeAssistantError from homeassistant.helpers import config_validation as cv from homeassistant.util.hass_dict import HassKey +from homeassistant.util.ulid import ulid from .const import DATA_COMPONENT, DOMAIN, StreamType from .helper import get_camera_from_entity_id @@ -21,15 +25,72 @@ from .helper import get_camera_from_entity_id if TYPE_CHECKING: from . import Camera +_LOGGER = logging.getLogger(__name__) + DATA_WEBRTC_PROVIDERS: HassKey[set[CameraWebRTCProvider]] = HassKey( - "camera_web_rtc_providers" + "camera_webrtc_providers" +) +DATA_WEBRTC_LEGACY_PROVIDERS: HassKey[set[CameraWebRTCLegacyProvider]] = HassKey( + "camera_webrtc_legacy_providers" ) DATA_ICE_SERVERS: HassKey[list[Callable[[], Iterable[RTCIceServer]]]] = HassKey( - "camera_web_rtc_ice_servers" + "camera_webrtc_ice_servers" ) +_WEBRTC = "WebRTC" + + +@dataclass(frozen=True) +class WebRTCMessage: + """Base class for WebRTC messages.""" + + @classmethod + @cache + def _get_type(cls) -> str: + _, _, name = cls.__name__.partition(_WEBRTC) + return name.lower() + + def as_dict(self) -> dict[str, Any]: + """Return a dict representation of the message.""" + data = asdict(self) + data["type"] = self._get_type() + return data + + +@dataclass(frozen=True) +class WebRTCSession(WebRTCMessage): + """WebRTC session.""" + + session_id: str + + +@dataclass(frozen=True) +class WebRTCAnswer(WebRTCMessage): + """WebRTC answer.""" + + answer: str + + +@dataclass(frozen=True) +class WebRTCCandidate(WebRTCMessage): + """WebRTC candidate.""" + + candidate: str + + +@dataclass(frozen=True) +class WebRTCError(WebRTCMessage): + """WebRTC error.""" + + code: str + message: str + + +type WebRTCSendMessage = Callable[[WebRTCMessage], None] + + @dataclass(kw_only=True) class WebRTCClientConfiguration: """WebRTC configuration for the client. @@ -39,11 +100,13 @@ class WebRTCClientConfiguration: configuration: RTCConfiguration = field(default_factory=RTCConfiguration) data_channel: str | None = None + get_candidates_upfront: bool = False def to_frontend_dict(self) -> dict[str, Any]: """Return a dict that can be used by the frontend.""" data: dict[str, Any] = { "configuration": self.configuration.to_dict(), + "getCandidatesUpfront": self.get_candidates_upfront, } if self.data_channel is not None: data["dataChannel"] = self.data_channel @@ -53,6 +116,30 @@ class WebRTCClientConfiguration: class CameraWebRTCProvider(Protocol): """WebRTC provider.""" + @callback + def async_is_supported(self, stream_source: str) -> bool: + """Determine if the provider supports the stream source.""" + + async def async_handle_async_webrtc_offer( + self, + camera: Camera, + offer_sdp: str, + session_id: str, + send_message: WebRTCSendMessage, + ) -> None: + """Handle the WebRTC offer and return the answer via the provided callback.""" + + async def async_on_webrtc_candidate(self, session_id: str, candidate: str) -> None: + """Handle the WebRTC candidate.""" + + @callback + def async_close_session(self, session_id: str) -> None: + """Close the session.""" + + +class CameraWebRTCLegacyProvider(Protocol): + """WebRTC provider.""" + async def async_is_supported(self, stream_source: str) -> bool: """Determine if the provider supports the stream source.""" @@ -62,9 +149,10 @@ class CameraWebRTCProvider(Protocol): """Handle the WebRTC offer and return an answer.""" -def async_register_webrtc_provider( +def _async_register_webrtc_provider[_T]( hass: HomeAssistant, - provider: CameraWebRTCProvider, + key: HassKey[set[_T]], + provider: _T, ) -> Callable[[], None]: """Register a WebRTC provider. @@ -73,9 +161,7 @@ def async_register_webrtc_provider( if DOMAIN not in hass.data: raise ValueError("Unexpected state, camera not loaded") - providers: set[CameraWebRTCProvider] = hass.data.setdefault( - DATA_WEBRTC_PROVIDERS, set() - ) + providers = hass.data.setdefault(key, set()) @callback def remove_provider() -> None: @@ -90,6 +176,18 @@ def async_register_webrtc_provider( return remove_provider +@callback +def async_register_webrtc_provider( + hass: HomeAssistant, + provider: CameraWebRTCProvider, +) -> Callable[[], None]: + """Register a WebRTC provider. + + The first provider to satisfy the offer will be used. + """ + return _async_register_webrtc_provider(hass, DATA_WEBRTC_PROVIDERS, provider) + + async def _async_refresh_providers(hass: HomeAssistant) -> None: """Check all cameras for any state changes for registered providers.""" @@ -99,6 +197,72 @@ async def _async_refresh_providers(hass: HomeAssistant) -> None: ) +@websocket_api.websocket_command( + { + vol.Required("type"): "camera/webrtc/offer", + vol.Required("entity_id"): cv.entity_id, + vol.Required("offer"): str, + } +) +@websocket_api.async_response +async def ws_webrtc_offer( + hass: HomeAssistant, connection: websocket_api.ActiveConnection, msg: dict[str, Any] +) -> None: + """Handle the signal path for a WebRTC stream. + + This signal path is used to route the offer created by the client to the + camera device through the integration for negotiation on initial setup. + The ws endpoint returns a subscription id, where ice candidates and the + final answer will be returned. + The actual streaming is handled entirely between the client and camera device. + + Async friendly. + """ + entity_id = msg["entity_id"] + offer = msg["offer"] + camera = get_camera_from_entity_id(hass, entity_id) + if camera.frontend_stream_type != StreamType.WEB_RTC: + connection.send_error( + msg["id"], + "webrtc_offer_failed", + ( + "Camera does not support WebRTC," + f" frontend_stream_type={camera.frontend_stream_type}" + ), + ) + return + + session_id = ulid() + connection.subscriptions[msg["id"]] = partial( + camera.close_webrtc_session, session_id + ) + + connection.send_message(websocket_api.result_message(msg["id"])) + + @callback + def send_message(message: WebRTCMessage) -> None: + """Push a value to websocket.""" + connection.send_message( + websocket_api.event_message( + msg["id"], + message.as_dict(), + ) + ) + + send_message(WebRTCSession(session_id)) + + try: + await camera.async_handle_async_webrtc_offer(offer, session_id, send_message) + except HomeAssistantError as ex: + _LOGGER.error("Error handling WebRTC offer: %s", ex) + send_message( + WebRTCError( + "webrtc_offer_failed", + str(ex), + ) + ) + + @websocket_api.websocket_command( { vol.Required("type"): "camera/webrtc/get_client_config", @@ -115,7 +279,7 @@ async def ws_get_client_config( if camera.frontend_stream_type != StreamType.WEB_RTC: connection.send_error( msg["id"], - "web_rtc_offer_failed", + "webrtc_get_client_config_failed", ( "Camera does not support WebRTC," f" frontend_stream_type={camera.frontend_stream_type}" @@ -130,19 +294,74 @@ async def ws_get_client_config( ) -async def async_get_supported_providers( - hass: HomeAssistant, camera: Camera -) -> list[CameraWebRTCProvider]: - """Return a list of supported providers for the camera.""" - providers = hass.data.get(DATA_WEBRTC_PROVIDERS) - if not providers or not (stream_source := await camera.stream_source()): - return [] +@websocket_api.websocket_command( + { + vol.Required("type"): "camera/webrtc/candidate", + vol.Required("entity_id"): cv.entity_id, + vol.Required("session_id"): str, + vol.Required("candidate"): str, + } +) +@websocket_api.async_response +async def ws_candidate( + hass: HomeAssistant, connection: websocket_api.ActiveConnection, msg: dict[str, Any] +) -> None: + """Handle WebRTC candidate websocket command.""" + entity_id = msg["entity_id"] + camera = get_camera_from_entity_id(hass, entity_id) + if camera.frontend_stream_type != StreamType.WEB_RTC: + connection.send_error( + msg["id"], + "webrtc_candidate_failed", + ( + "Camera does not support WebRTC," + f" frontend_stream_type={camera.frontend_stream_type}" + ), + ) + return - return [ - provider - for provider in providers - if await provider.async_is_supported(stream_source) - ] + await camera.async_on_webrtc_candidate(msg["session_id"], msg["candidate"]) + connection.send_message(websocket_api.result_message(msg["id"])) + + +@callback +def async_register_ws(hass: HomeAssistant) -> None: + """Register camera webrtc ws endpoints.""" + + websocket_api.async_register_command(hass, ws_webrtc_offer) + websocket_api.async_register_command(hass, ws_get_client_config) + websocket_api.async_register_command(hass, ws_candidate) + + +async def _async_get_supported_provider[ + _T: CameraWebRTCLegacyProvider | CameraWebRTCProvider +](hass: HomeAssistant, camera: Camera, key: HassKey[set[_T]]) -> _T | None: + """Return the first supported provider for the camera.""" + providers = hass.data.get(key) + if not providers or not (stream_source := await camera.stream_source()): + return None + + for provider in providers: + if provider.async_is_supported(stream_source): + return provider + + return None + + +async def async_get_supported_provider( + hass: HomeAssistant, camera: Camera +) -> CameraWebRTCProvider | None: + """Return the first supported provider for the camera.""" + return await _async_get_supported_provider(hass, camera, DATA_WEBRTC_PROVIDERS) + + +async def async_get_supported_legacy_provider( + hass: HomeAssistant, camera: Camera +) -> CameraWebRTCLegacyProvider | None: + """Return the first supported provider for the camera.""" + return await _async_get_supported_provider( + hass, camera, DATA_WEBRTC_LEGACY_PROVIDERS + ) @callback @@ -177,7 +396,7 @@ _RTSP_PREFIXES = {"rtsp://", "rtsps://", "rtmp://"} type RtspToWebRtcProviderType = Callable[[str, str, str], Awaitable[str | None]] -class _CameraRtspToWebRTCProvider(CameraWebRTCProvider): +class _CameraRtspToWebRTCProvider(CameraWebRTCLegacyProvider): def __init__(self, fn: RtspToWebRtcProviderType) -> None: """Initialize the RTSP to WebRTC provider.""" self._fn = fn @@ -206,4 +425,6 @@ def async_register_rtsp_to_web_rtc_provider( The first provider to satisfy the offer will be used. """ provider_instance = _CameraRtspToWebRTCProvider(provider) - return async_register_webrtc_provider(hass, provider_instance) + return _async_register_webrtc_provider( + hass, DATA_WEBRTC_LEGACY_PROVIDERS, provider_instance + ) diff --git a/homeassistant/components/go2rtc/__init__.py b/homeassistant/components/go2rtc/__init__.py index 9421069fd7f..77743d971bd 100644 --- a/homeassistant/components/go2rtc/__init__.py +++ b/homeassistant/components/go2rtc/__init__.py @@ -3,16 +3,29 @@ import logging import shutil -from go2rtc_client import Go2RtcClient, WebRTCSdpOffer +from go2rtc_client import Go2RtcRestClient +from go2rtc_client.ws import ( + Go2RtcWsClient, + ReceiveMessages, + WebRTCAnswer, + WebRTCCandidate, + WebRTCOffer, + WsError, +) import voluptuous as vol -from homeassistant.components.camera import Camera -from homeassistant.components.camera.webrtc import ( +from homeassistant.components.camera import ( + Camera, CameraWebRTCProvider, + WebRTCAnswer as HAWebRTCAnswer, + WebRTCCandidate as HAWebRTCCandidate, + WebRTCError, + WebRTCMessage, + WebRTCSendMessage, async_register_webrtc_provider, ) from homeassistant.const import CONF_URL, EVENT_HOMEASSISTANT_STOP -from homeassistant.core import Event, HomeAssistant +from homeassistant.core import Event, HomeAssistant, callback from homeassistant.helpers import config_validation as cv from homeassistant.helpers.aiohttp_client import async_get_clientsession from homeassistant.helpers.typing import ConfigType @@ -22,6 +35,7 @@ from .const import DOMAIN from .server import Server _LOGGER = logging.getLogger(__name__) + _SUPPORTED_STREAMS = frozenset( ( "bubble", @@ -87,13 +101,13 @@ async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool: # Validate the server URL try: - client = Go2RtcClient(async_get_clientsession(hass), url) + client = Go2RtcRestClient(async_get_clientsession(hass), url) await client.streams.list() except Exception: # noqa: BLE001 _LOGGER.warning("Could not connect to go2rtc instance on %s", url) return False - provider = WebRTCProvider(client) + provider = WebRTCProvider(hass, url) async_register_webrtc_provider(hass, provider) return True @@ -106,25 +120,71 @@ async def _get_binary(hass: HomeAssistant) -> str | None: class WebRTCProvider(CameraWebRTCProvider): """WebRTC provider.""" - def __init__(self, client: Go2RtcClient) -> None: + def __init__(self, hass: HomeAssistant, url: str) -> None: """Initialize the WebRTC provider.""" - self._client = client + self._hass = hass + self._url = url + self._session = async_get_clientsession(hass) + self._rest_client = Go2RtcRestClient(self._session, url) + self._sessions: dict[str, Go2RtcWsClient] = {} - async def async_is_supported(self, stream_source: str) -> bool: + def async_is_supported(self, stream_source: str) -> bool: """Return if this provider is supports the Camera as source.""" return stream_source.partition(":")[0] in _SUPPORTED_STREAMS - async def async_handle_web_rtc_offer( - self, camera: Camera, offer_sdp: str - ) -> str | None: - """Handle the WebRTC offer and return an answer.""" - streams = await self._client.streams.list() + async def async_handle_async_webrtc_offer( + self, + camera: Camera, + offer_sdp: str, + session_id: str, + send_message: WebRTCSendMessage, + ) -> None: + """Handle the WebRTC offer and return the answer via the provided callback.""" + self._sessions[session_id] = ws_client = Go2RtcWsClient( + self._session, self._url, source=camera.entity_id + ) + + streams = await self._rest_client.streams.list() if camera.entity_id not in streams: if not (stream_source := await camera.stream_source()): - return None - await self._client.streams.add(camera.entity_id, stream_source) + send_message( + WebRTCError( + "go2rtc_webrtc_offer_failed", "Camera has no stream source" + ) + ) + return + await self._rest_client.streams.add(camera.entity_id, stream_source) - answer = await self._client.webrtc.forward_whep_sdp_offer( - camera.entity_id, WebRTCSdpOffer(offer_sdp) - ) - return answer.sdp + @callback + def on_messages(message: ReceiveMessages) -> None: + """Handle messages.""" + value: WebRTCMessage + match message: + case WebRTCCandidate(): + value = HAWebRTCCandidate(message.candidate) + case WebRTCAnswer(): + value = HAWebRTCAnswer(message.answer) + case WsError(): + value = WebRTCError("go2rtc_webrtc_offer_failed", message.error) + case _: + _LOGGER.warning("Unknown message %s", message) + return + + send_message(value) + + ws_client.subscribe(on_messages) + await ws_client.send(WebRTCOffer(offer_sdp)) + + async def async_on_webrtc_candidate(self, session_id: str, candidate: str) -> None: + """Handle the WebRTC candidate.""" + + if ws_client := self._sessions.get(session_id): + await ws_client.send(WebRTCCandidate(candidate)) + else: + _LOGGER.debug("Unknown session %s. Ignoring candidate", session_id) + + @callback + def async_close_session(self, session_id: str) -> None: + """Close the session.""" + ws_client = self._sessions.pop(session_id) + self._hass.async_create_task(ws_client.close()) diff --git a/homeassistant/components/go2rtc/manifest.json b/homeassistant/components/go2rtc/manifest.json index ff32b85f72f..025b26317bb 100644 --- a/homeassistant/components/go2rtc/manifest.json +++ b/homeassistant/components/go2rtc/manifest.json @@ -7,5 +7,5 @@ "documentation": "https://www.home-assistant.io/integrations/go2rtc", "integration_type": "system", "iot_class": "local_polling", - "requirements": ["go2rtc-client==0.0.1b0"] + "requirements": ["go2rtc-client==0.0.1b1"] } diff --git a/requirements_all.txt b/requirements_all.txt index d1f9cd55d8e..5a8fae8efcf 100644 --- a/requirements_all.txt +++ b/requirements_all.txt @@ -986,7 +986,7 @@ gitterpy==0.1.7 glances-api==0.8.0 # homeassistant.components.go2rtc -go2rtc-client==0.0.1b0 +go2rtc-client==0.0.1b1 # homeassistant.components.goalzero goalzero==0.2.2 diff --git a/requirements_test_all.txt b/requirements_test_all.txt index 6f79eea6cee..23b9973bd79 100644 --- a/requirements_test_all.txt +++ b/requirements_test_all.txt @@ -836,7 +836,7 @@ gios==5.0.0 glances-api==0.8.0 # homeassistant.components.go2rtc -go2rtc-client==0.0.1b0 +go2rtc-client==0.0.1b1 # homeassistant.components.goalzero goalzero==0.2.2 diff --git a/tests/components/camera/conftest.py b/tests/components/camera/conftest.py index 5eda2f1eb55..bec44704ec2 100644 --- a/tests/components/camera/conftest.py +++ b/tests/components/camera/conftest.py @@ -7,6 +7,7 @@ import pytest from homeassistant.components import camera from homeassistant.components.camera.const import StreamType +from homeassistant.components.camera.webrtc import WebRTCAnswer, WebRTCSendMessage from homeassistant.const import Platform from homeassistant.core import HomeAssistant from homeassistant.helpers.device_registry import DeviceInfo @@ -56,23 +57,37 @@ def mock_camera_hls_fixture(mock_camera: None) -> Generator[None]: yield -@pytest.fixture(name="mock_camera_web_rtc") -async def mock_camera_web_rtc_fixture(hass: HomeAssistant) -> AsyncGenerator[None]: +@pytest.fixture +async def mock_camera_webrtc_frontendtype_only( + hass: HomeAssistant, +) -> AsyncGenerator[None]: """Initialize a demo camera platform with WebRTC.""" assert await async_setup_component( hass, "camera", {camera.DOMAIN: {"platform": "demo"}} ) await hass.async_block_till_done() - with ( - patch( - "homeassistant.components.camera.Camera.frontend_stream_type", - new_callable=PropertyMock(return_value=StreamType.WEB_RTC), - ), - patch( - "homeassistant.components.camera.Camera.async_handle_web_rtc_offer", - return_value=WEBRTC_ANSWER, - ), + with patch( + "homeassistant.components.camera.Camera.frontend_stream_type", + new_callable=PropertyMock(return_value=StreamType.WEB_RTC), + ): + yield + + +@pytest.fixture +async def mock_camera_webrtc( + mock_camera_webrtc_frontendtype_only: None, +) -> AsyncGenerator[None]: + """Initialize a demo camera platform with WebRTC.""" + + async def async_handle_async_webrtc_offer( + offer_sdp: str, session_id: str, send_message: WebRTCSendMessage + ) -> None: + send_message(WebRTCAnswer(WEBRTC_ANSWER)) + + with patch( + "homeassistant.components.camera.Camera.async_handle_async_webrtc_offer", + side_effect=async_handle_async_webrtc_offer, ): yield diff --git a/tests/components/camera/test_init.py b/tests/components/camera/test_init.py index b56ecdec78a..42648d690b7 100644 --- a/tests/components/camera/test_init.py +++ b/tests/components/camera/test_init.py @@ -1,6 +1,5 @@ """The tests for the camera component.""" -from collections.abc import Generator from http import HTTPStatus import io from types import ModuleType @@ -28,7 +27,7 @@ from homeassistant.helpers import entity_registry as er, issue_registry as ir from homeassistant.setup import async_setup_component from homeassistant.util import dt as dt_util -from .common import EMPTY_8_6_JPEG, STREAM_SOURCE, WEBRTC_ANSWER, mock_turbo_jpeg +from .common import EMPTY_8_6_JPEG, STREAM_SOURCE, mock_turbo_jpeg from tests.common import ( async_fire_time_changed, @@ -37,9 +36,6 @@ from tests.common import ( ) from tests.typing import ClientSessionGenerator, WebSocketGenerator -HLS_STREAM_SOURCE = "http://127.0.0.1/example.m3u" -WEBRTC_OFFER = "v=0\r\n" - @pytest.fixture(name="image_mock_url") async def image_mock_url_fixture(hass: HomeAssistant) -> None: @@ -50,34 +46,6 @@ async def image_mock_url_fixture(hass: HomeAssistant) -> None: await hass.async_block_till_done() -@pytest.fixture(name="mock_hls_stream_source") -async def mock_hls_stream_source_fixture() -> Generator[AsyncMock]: - """Fixture to create an HLS stream source.""" - with patch( - "homeassistant.components.camera.Camera.stream_source", - return_value=HLS_STREAM_SOURCE, - ) as mock_hls_stream_source: - yield mock_hls_stream_source - - -async def provide_web_rtc_answer(stream_source: str, offer: str, stream_id: str) -> str: - """Simulate an rtsp to webrtc provider.""" - assert stream_source == STREAM_SOURCE - assert offer == WEBRTC_OFFER - return WEBRTC_ANSWER - - -@pytest.fixture(name="mock_rtsp_to_web_rtc") -def mock_rtsp_to_web_rtc_fixture(hass: HomeAssistant) -> Generator[Mock]: - """Fixture that registers a mock rtsp to web_rtc provider.""" - mock_provider = Mock(side_effect=provide_web_rtc_answer) - unsub = camera.async_register_rtsp_to_web_rtc_provider( - hass, "mock_domain", mock_provider - ) - yield mock_provider - unsub() - - @pytest.mark.usefixtures("image_mock_url") async def test_get_image_from_camera(hass: HomeAssistant) -> None: """Grab an image from camera entity.""" @@ -705,148 +673,6 @@ async def test_camera_proxy_stream(hass_client: ClientSessionGenerator) -> None: assert response.status == HTTPStatus.BAD_GATEWAY -@pytest.mark.usefixtures("mock_camera_web_rtc") -async def test_websocket_web_rtc_offer( - hass: HomeAssistant, hass_ws_client: WebSocketGenerator -) -> None: - """Test initiating a WebRTC stream with offer and answer.""" - client = await hass_ws_client(hass) - await client.send_json( - { - "id": 9, - "type": "camera/web_rtc_offer", - "entity_id": "camera.demo_camera", - "offer": WEBRTC_OFFER, - } - ) - response = await client.receive_json() - - assert response["id"] == 9 - assert response["type"] == TYPE_RESULT - assert response["success"] - assert response["result"]["answer"] == WEBRTC_ANSWER - - -@pytest.mark.usefixtures("mock_camera_web_rtc") -async def test_websocket_web_rtc_offer_invalid_entity( - hass: HomeAssistant, hass_ws_client: WebSocketGenerator -) -> None: - """Test WebRTC with a camera entity that does not exist.""" - client = await hass_ws_client(hass) - await client.send_json( - { - "id": 9, - "type": "camera/web_rtc_offer", - "entity_id": "camera.does_not_exist", - "offer": WEBRTC_OFFER, - } - ) - response = await client.receive_json() - - assert response["id"] == 9 - assert response["type"] == TYPE_RESULT - assert not response["success"] - - -@pytest.mark.usefixtures("mock_camera_web_rtc") -async def test_websocket_web_rtc_offer_missing_offer( - hass: HomeAssistant, hass_ws_client: WebSocketGenerator -) -> None: - """Test WebRTC stream with missing required fields.""" - client = await hass_ws_client(hass) - await client.send_json( - { - "id": 9, - "type": "camera/web_rtc_offer", - "entity_id": "camera.demo_camera", - } - ) - response = await client.receive_json() - - assert response["id"] == 9 - assert response["type"] == TYPE_RESULT - assert not response["success"] - assert response["error"]["code"] == "invalid_format" - - -@pytest.mark.usefixtures("mock_camera_web_rtc") -async def test_websocket_web_rtc_offer_failure( - hass: HomeAssistant, hass_ws_client: WebSocketGenerator -) -> None: - """Test WebRTC stream that fails handling the offer.""" - client = await hass_ws_client(hass) - - with patch( - "homeassistant.components.camera.Camera.async_handle_web_rtc_offer", - side_effect=HomeAssistantError("offer failed"), - ): - await client.send_json( - { - "id": 9, - "type": "camera/web_rtc_offer", - "entity_id": "camera.demo_camera", - "offer": WEBRTC_OFFER, - } - ) - response = await client.receive_json() - - assert response["id"] == 9 - assert response["type"] == TYPE_RESULT - assert not response["success"] - assert response["error"]["code"] == "web_rtc_offer_failed" - assert response["error"]["message"] == "offer failed" - - -@pytest.mark.usefixtures("mock_camera_web_rtc") -async def test_websocket_web_rtc_offer_timeout( - hass: HomeAssistant, hass_ws_client: WebSocketGenerator -) -> None: - """Test WebRTC stream with timeout handling the offer.""" - client = await hass_ws_client(hass) - - with patch( - "homeassistant.components.camera.Camera.async_handle_web_rtc_offer", - side_effect=TimeoutError(), - ): - await client.send_json( - { - "id": 9, - "type": "camera/web_rtc_offer", - "entity_id": "camera.demo_camera", - "offer": WEBRTC_OFFER, - } - ) - response = await client.receive_json() - - assert response["id"] == 9 - assert response["type"] == TYPE_RESULT - assert not response["success"] - assert response["error"]["code"] == "web_rtc_offer_failed" - assert response["error"]["message"] == "Timeout handling WebRTC offer" - - -@pytest.mark.usefixtures("mock_camera") -async def test_websocket_web_rtc_offer_invalid_stream_type( - hass: HomeAssistant, hass_ws_client: WebSocketGenerator -) -> None: - """Test WebRTC initiating for a camera with a different stream_type.""" - client = await hass_ws_client(hass) - await client.send_json( - { - "id": 9, - "type": "camera/web_rtc_offer", - "entity_id": "camera.demo_camera", - "offer": WEBRTC_OFFER, - } - ) - response = await client.receive_json() - - assert response["id"] == 9 - assert response["type"] == TYPE_RESULT - assert not response["success"] - assert response["error"]["code"] == "web_rtc_offer_failed" - - @pytest.mark.usefixtures("mock_camera") async def test_state_streaming(hass: HomeAssistant) -> None: """Camera state.""" @@ -908,144 +734,6 @@ async def test_stream_unavailable( assert demo_camera.state == camera.CameraState.STREAMING -@pytest.mark.usefixtures("mock_camera", "mock_stream_source") -async def test_rtsp_to_web_rtc_offer( - hass: HomeAssistant, - hass_ws_client: WebSocketGenerator, - mock_rtsp_to_web_rtc: Mock, -) -> None: - """Test creating a web_rtc offer from an rstp provider.""" - client = await hass_ws_client(hass) - await client.send_json( - { - "id": 9, - "type": "camera/web_rtc_offer", - "entity_id": "camera.demo_camera", - "offer": WEBRTC_OFFER, - } - ) - response = await client.receive_json() - - assert response.get("id") == 9 - assert response.get("type") == TYPE_RESULT - assert response.get("success") - assert "result" in response - assert response["result"] == {"answer": WEBRTC_ANSWER} - - assert mock_rtsp_to_web_rtc.called - - -@pytest.mark.usefixtures( - "mock_camera", - "mock_hls_stream_source", # Not an RTSP stream source - "mock_rtsp_to_web_rtc", -) -async def test_unsupported_rtsp_to_web_rtc_stream_type( - hass: HomeAssistant, hass_ws_client: WebSocketGenerator -) -> None: - """Test rtsp-to-webrtc is not registered for non-RTSP streams.""" - client = await hass_ws_client(hass) - await client.send_json( - { - "id": 10, - "type": "camera/web_rtc_offer", - "entity_id": "camera.demo_camera", - "offer": WEBRTC_OFFER, - } - ) - response = await client.receive_json() - - assert response.get("id") == 10 - assert response.get("type") == TYPE_RESULT - assert "success" in response - assert not response["success"] - - -@pytest.mark.usefixtures("mock_camera", "mock_stream_source") -async def test_rtsp_to_web_rtc_provider_unregistered( - hass: HomeAssistant, hass_ws_client: WebSocketGenerator -) -> None: - """Test creating a web_rtc offer from an rstp provider.""" - mock_provider = Mock(side_effect=provide_web_rtc_answer) - unsub = camera.async_register_rtsp_to_web_rtc_provider( - hass, "mock_domain", mock_provider - ) - - client = await hass_ws_client(hass) - - # Registered provider can handle the WebRTC offer - await client.send_json( - { - "id": 11, - "type": "camera/web_rtc_offer", - "entity_id": "camera.demo_camera", - "offer": WEBRTC_OFFER, - } - ) - response = await client.receive_json() - assert response["id"] == 11 - assert response["type"] == TYPE_RESULT - assert response["success"] - assert response["result"]["answer"] == WEBRTC_ANSWER - - assert mock_provider.called - mock_provider.reset_mock() - - # Unregister provider, then verify the WebRTC offer cannot be handled - unsub() - await client.send_json( - { - "id": 12, - "type": "camera/web_rtc_offer", - "entity_id": "camera.demo_camera", - "offer": WEBRTC_OFFER, - } - ) - response = await client.receive_json() - assert response.get("id") == 12 - assert response.get("type") == TYPE_RESULT - assert "success" in response - assert not response["success"] - - assert not mock_provider.called - - -@pytest.mark.usefixtures("mock_camera", "mock_stream_source") -async def test_rtsp_to_web_rtc_offer_not_accepted( - hass: HomeAssistant, hass_ws_client: WebSocketGenerator -) -> None: - """Test a provider that can't satisfy the rtsp to webrtc offer.""" - - async def provide_none(stream_source: str, offer: str) -> str: - """Simulate a provider that can't accept the offer.""" - return None - - mock_provider = Mock(side_effect=provide_none) - unsub = camera.async_register_rtsp_to_web_rtc_provider( - hass, "mock_domain", mock_provider - ) - client = await hass_ws_client(hass) - - # Registered provider can handle the WebRTC offer - await client.send_json( - { - "id": 11, - "type": "camera/web_rtc_offer", - "entity_id": "camera.demo_camera", - "offer": WEBRTC_OFFER, - } - ) - response = await client.receive_json() - assert response["id"] == 11 - assert response.get("type") == TYPE_RESULT - assert "success" in response - assert not response["success"] - - assert mock_provider.called - - unsub() - - @pytest.mark.usefixtures("mock_camera") async def test_use_stream_for_stills( hass: HomeAssistant, hass_client: ClientSessionGenerator diff --git a/tests/components/camera/test_media_source.py b/tests/components/camera/test_media_source.py index 0780ecc2a9c..85f876d4e81 100644 --- a/tests/components/camera/test_media_source.py +++ b/tests/components/camera/test_media_source.py @@ -65,8 +65,8 @@ async def test_browsing_mjpeg(hass: HomeAssistant) -> None: assert item.children[0].title == "Demo camera without stream" -@pytest.mark.usefixtures("mock_camera_web_rtc") -async def test_browsing_web_rtc(hass: HomeAssistant) -> None: +@pytest.mark.usefixtures("mock_camera_webrtc") +async def test_browsing_webrtc(hass: HomeAssistant) -> None: """Test browsing WebRTC camera media source.""" # 3 cameras: # one only supports WebRTC (no stream source) diff --git a/tests/components/camera/test_webrtc.py b/tests/components/camera/test_webrtc.py index 135e559f6dd..632e673625f 100644 --- a/tests/components/camera/test_webrtc.py +++ b/tests/components/camera/test_webrtc.py @@ -1,24 +1,176 @@ """Test camera WebRTC.""" +from collections.abc import AsyncGenerator, Generator +import logging +from typing import Any +from unittest.mock import AsyncMock, Mock, patch + import pytest -from homeassistant.components.camera import Camera -from homeassistant.components.camera.const import StreamType -from homeassistant.components.camera.helper import get_camera_from_entity_id -from homeassistant.components.camera.webrtc import ( +from homeassistant.components.camera import ( DATA_ICE_SERVERS, + DOMAIN as CAMERA_DOMAIN, + Camera, + CameraEntityFeature, CameraWebRTCProvider, RTCIceServer, + StreamType, + WebRTCAnswer, + WebRTCCandidate, + WebRTCError, + WebRTCMessage, + WebRTCSendMessage, async_register_ice_servers, + async_register_rtsp_to_web_rtc_provider, async_register_webrtc_provider, + get_camera_from_entity_id, ) from homeassistant.components.websocket_api import TYPE_RESULT +from homeassistant.config_entries import ConfigEntry, ConfigFlow from homeassistant.core import HomeAssistant, callback from homeassistant.core_config import async_process_ha_core_config +from homeassistant.exceptions import HomeAssistantError from homeassistant.setup import async_setup_component +from .common import STREAM_SOURCE, WEBRTC_ANSWER + +from tests.common import ( + MockConfigEntry, + MockModule, + mock_config_flow, + mock_integration, + mock_platform, + setup_test_component_platform, +) from tests.typing import WebSocketGenerator +WEBRTC_OFFER = "v=0\r\n" +HLS_STREAM_SOURCE = "http://127.0.0.1/example.m3u" +TEST_INTEGRATION_DOMAIN = "test" + + +class TestProvider(CameraWebRTCProvider): + """Test provider.""" + + def __init__(self) -> None: + """Initialize the provider.""" + self._is_supported = True + + def async_is_supported(self, stream_source: str) -> bool: + """Determine if the provider supports the stream source.""" + return self._is_supported + + async def async_handle_async_webrtc_offer( + self, + camera: Camera, + offer_sdp: str, + session_id: str, + send_message: WebRTCSendMessage, + ) -> None: + """Handle the WebRTC offer and return the answer via the provided callback. + + Return value determines if the offer was handled successfully. + """ + send_message(WebRTCAnswer(answer="answer")) + + async def async_on_webrtc_candidate(self, session_id: str, candidate: str) -> None: + """Handle the WebRTC candidate.""" + + @callback + def async_close_session(self, session_id: str) -> None: + """Close the session.""" + + +class MockCamera(Camera): + """Mock Camera Entity.""" + + _attr_name = "Test" + _attr_supported_features: CameraEntityFeature = CameraEntityFeature.STREAM + _attr_frontend_stream_type: StreamType = StreamType.WEB_RTC + + def __init__(self) -> None: + """Initialize the mock entity.""" + super().__init__() + self._sync_answer: str | None | Exception = WEBRTC_ANSWER + + def set_sync_answer(self, value: str | None | Exception) -> None: + """Set sync offer answer.""" + self._sync_answer = value + + async def async_handle_web_rtc_offer(self, offer_sdp: str) -> str | None: + """Handle the WebRTC offer and return the answer.""" + if isinstance(self._sync_answer, Exception): + raise self._sync_answer + return self._sync_answer + + async def stream_source(self) -> str | None: + """Return the source of the stream. + + This is used by cameras with CameraEntityFeature.STREAM + and StreamType.HLS. + """ + return "rtsp://stream" + + +@pytest.fixture +async def init_test_integration( + hass: HomeAssistant, +) -> MockCamera: + """Initialize components.""" + + entry = MockConfigEntry(domain=TEST_INTEGRATION_DOMAIN) + entry.add_to_hass(hass) + + async def async_setup_entry_init( + hass: HomeAssistant, config_entry: ConfigEntry + ) -> bool: + """Set up test config entry.""" + await hass.config_entries.async_forward_entry_setups( + config_entry, [CAMERA_DOMAIN] + ) + return True + + async def async_unload_entry_init( + hass: HomeAssistant, config_entry: ConfigEntry + ) -> bool: + """Unload test config entry.""" + await hass.config_entries.async_forward_entry_unload( + config_entry, CAMERA_DOMAIN + ) + return True + + mock_integration( + hass, + MockModule( + TEST_INTEGRATION_DOMAIN, + async_setup_entry=async_setup_entry_init, + async_unload_entry=async_unload_entry_init, + ), + ) + test_camera = MockCamera() + setup_test_component_platform( + hass, CAMERA_DOMAIN, [test_camera], from_config_entry=True + ) + mock_platform(hass, f"{TEST_INTEGRATION_DOMAIN}.config_flow", Mock()) + + with mock_config_flow(TEST_INTEGRATION_DOMAIN, ConfigFlow): + assert await hass.config_entries.async_setup(entry.entry_id) + await hass.async_block_till_done() + + return test_camera + + +@pytest.fixture +async def register_test_provider(hass: HomeAssistant) -> AsyncGenerator[TestProvider]: + """Add WebRTC test provider.""" + await async_setup_component(hass, "camera", {}) + + provider = TestProvider() + unsub = async_register_webrtc_provider(hass, provider) + await hass.async_block_till_done() + yield provider + unsub() + @pytest.mark.usefixtures("mock_camera", "mock_stream", "mock_stream_source") async def test_async_register_webrtc_provider( @@ -30,36 +182,21 @@ async def test_async_register_webrtc_provider( camera = get_camera_from_entity_id(hass, "camera.demo_camera") assert camera.frontend_stream_type is StreamType.HLS - stream_supported = True - - class TestProvider(CameraWebRTCProvider): - """Test provider.""" - - async def async_is_supported(self, stream_source: str) -> bool: - """Determine if the provider supports the stream source.""" - nonlocal stream_supported - return stream_supported - - async def async_handle_web_rtc_offer( - self, camera: Camera, offer_sdp: str - ) -> str | None: - """Handle the WebRTC offer and return an answer.""" - return "answer" - - unregister = async_register_webrtc_provider(hass, TestProvider()) + provider = TestProvider() + unregister = async_register_webrtc_provider(hass, provider) await hass.async_block_till_done() assert camera.frontend_stream_type is StreamType.WEB_RTC # Mark stream as unsupported - stream_supported = False + provider._is_supported = False # Manually refresh the provider await camera.async_refresh_providers() assert camera.frontend_stream_type is StreamType.HLS - # Mark stream as unsupported - stream_supported = True + # Mark stream as supported + provider._is_supported = True # Manually refresh the provider await camera.async_refresh_providers() assert camera.frontend_stream_type is StreamType.WEB_RTC @@ -73,49 +210,17 @@ async def test_async_register_webrtc_provider( @pytest.mark.usefixtures("mock_camera", "mock_stream", "mock_stream_source") async def test_async_register_webrtc_provider_twice( hass: HomeAssistant, + register_test_provider: TestProvider, ) -> None: """Test registering a WebRTC provider twice should raise.""" - await async_setup_component(hass, "camera", {}) - - class TestProvider(CameraWebRTCProvider): - """Test provider.""" - - async def async_is_supported(self, stream_source: str) -> bool: - """Determine if the provider supports the stream source.""" - return True - - async def async_handle_web_rtc_offer( - self, camera: Camera, offer_sdp: str - ) -> str | None: - """Handle the WebRTC offer and return an answer.""" - return "answer" - - provider = TestProvider() - async_register_webrtc_provider(hass, provider) - await hass.async_block_till_done() - with pytest.raises(ValueError, match="Provider already registered"): - async_register_webrtc_provider(hass, provider) + async_register_webrtc_provider(hass, register_test_provider) async def test_async_register_webrtc_provider_camera_not_loaded( hass: HomeAssistant, ) -> None: """Test registering a WebRTC provider when camera is not loaded.""" - - class TestProvider(CameraWebRTCProvider): - """Test provider.""" - - async def async_is_supported(self, stream_source: str) -> bool: - """Determine if the provider supports the stream source.""" - return True - - async def async_handle_web_rtc_offer( - self, camera: Camera, offer_sdp: str - ) -> str | None: - """Handle the WebRTC offer and return an answer.""" - return "answer" - with pytest.raises(ValueError, match="Unexpected state, camera not loaded"): async_register_webrtc_provider(hass, TestProvider()) @@ -157,7 +262,7 @@ async def test_async_register_ice_server( called_2 = 0 @callback - def get_ice_servers_2() -> RTCIceServer: + def get_ice_servers_2() -> list[RTCIceServer]: nonlocal called_2 called_2 += 1 return [ @@ -205,7 +310,7 @@ async def test_async_register_ice_server( assert config.configuration.ice_servers == [] -@pytest.mark.usefixtures("mock_camera_web_rtc") +@pytest.mark.usefixtures("mock_camera_webrtc") async def test_ws_get_client_config( hass: HomeAssistant, hass_ws_client: WebSocketGenerator ) -> None: @@ -222,11 +327,48 @@ async def test_ws_get_client_config( assert msg["type"] == TYPE_RESULT assert msg["success"] assert msg["result"] == { - "configuration": {"iceServers": [{"urls": "stun:stun.home-assistant.io:80"}]} + "configuration": { + "iceServers": [{"urls": "stun:stun.home-assistant.io:80"}], + }, + "getCandidatesUpfront": False, + } + + @callback + def get_ice_server() -> list[RTCIceServer]: + return [ + RTCIceServer( + urls=["stun:example2.com", "turn:example2.com"], + username="user", + credential="pass", + ) + ] + + async_register_ice_servers(hass, get_ice_server) + + await client.send_json_auto_id( + {"type": "camera/webrtc/get_client_config", "entity_id": "camera.demo_camera"} + ) + msg = await client.receive_json() + + # Assert WebSocket response + assert msg["type"] == TYPE_RESULT + assert msg["success"] + assert msg["result"] == { + "configuration": { + "iceServers": [ + {"urls": "stun:stun.home-assistant.io:80"}, + { + "urls": ["stun:example2.com", "turn:example2.com"], + "username": "user", + "credential": "pass", + }, + ], + }, + "getCandidatesUpfront": False, } -@pytest.mark.usefixtures("mock_camera_web_rtc") +@pytest.mark.usefixtures("mock_camera_webrtc") async def test_ws_get_client_config_custom_config( hass: HomeAssistant, hass_ws_client: WebSocketGenerator ) -> None: @@ -248,7 +390,8 @@ async def test_ws_get_client_config_custom_config( assert msg["type"] == TYPE_RESULT assert msg["success"] assert msg["result"] == { - "configuration": {"iceServers": [{"urls": ["stun:custom_stun_server:3478"]}]} + "configuration": {"iceServers": [{"urls": ["stun:custom_stun_server:3478"]}]}, + "getCandidatesUpfront": False, } @@ -269,6 +412,676 @@ async def test_ws_get_client_config_no_rtc_camera( assert msg["type"] == TYPE_RESULT assert not msg["success"] assert msg["error"] == { - "code": "web_rtc_offer_failed", + "code": "webrtc_get_client_config_failed", + "message": "Camera does not support WebRTC, frontend_stream_type=hls", + } + + +async def provide_webrtc_answer(stream_source: str, offer: str, stream_id: str) -> str: + """Simulate an rtsp to webrtc provider.""" + assert stream_source == STREAM_SOURCE + assert offer == WEBRTC_OFFER + return WEBRTC_ANSWER + + +@pytest.fixture(name="mock_rtsp_to_webrtc") +def mock_rtsp_to_webrtc_fixture(hass: HomeAssistant) -> Generator[Mock]: + """Fixture that registers a mock rtsp to webrtc provider.""" + mock_provider = Mock(side_effect=provide_webrtc_answer) + unsub = async_register_rtsp_to_web_rtc_provider(hass, "mock_domain", mock_provider) + yield mock_provider + unsub() + + +@pytest.mark.usefixtures("mock_camera_webrtc") +async def test_websocket_webrtc_offer( + hass: HomeAssistant, hass_ws_client: WebSocketGenerator +) -> None: + """Test initiating a WebRTC stream with offer and answer.""" + client = await hass_ws_client(hass) + await client.send_json_auto_id( + { + "type": "camera/webrtc/offer", + "entity_id": "camera.demo_camera", + "offer": WEBRTC_OFFER, + } + ) + response = await client.receive_json() + assert response["type"] == TYPE_RESULT + assert response["success"] + subscription_id = response["id"] + + # Session id + response = await client.receive_json() + assert response["id"] == subscription_id + assert response["type"] == "event" + assert response["event"]["type"] == "session" + + # Answer + response = await client.receive_json() + assert response["id"] == subscription_id + assert response["type"] == "event" + assert response["event"] == { + "type": "answer", + "answer": WEBRTC_ANSWER, + } + + # Unsubscribe/Close session + await client.send_json_auto_id( + { + "type": "unsubscribe_events", + "subscription": subscription_id, + } + ) + msg = await client.receive_json() + assert msg["success"] + + +@pytest.mark.parametrize( + ("message", "expected_frontend_message"), + [ + (WebRTCCandidate("candidate"), {"type": "candidate", "candidate": "candidate"}), + ( + WebRTCError("webrtc_offer_failed", "error"), + {"type": "error", "code": "webrtc_offer_failed", "message": "error"}, + ), + (WebRTCAnswer("answer"), {"type": "answer", "answer": "answer"}), + ], + ids=["candidate", "error", "answer"], +) +@pytest.mark.usefixtures("mock_stream_source", "mock_camera") +async def test_websocket_webrtc_offer_webrtc_provider( + hass: HomeAssistant, + hass_ws_client: WebSocketGenerator, + register_test_provider: TestProvider, + message: WebRTCMessage, + expected_frontend_message: dict[str, Any], +) -> None: + """Test initiating a WebRTC stream with a webrtc provider.""" + client = await hass_ws_client(hass) + with ( + patch.object( + register_test_provider, "async_handle_async_webrtc_offer", autospec=True + ) as mock_async_handle_async_webrtc_offer, + patch.object( + register_test_provider, "async_close_session", autospec=True + ) as mock_async_close_session, + ): + await client.send_json_auto_id( + { + "type": "camera/webrtc/offer", + "entity_id": "camera.demo_camera", + "offer": WEBRTC_OFFER, + } + ) + response = await client.receive_json() + assert response["type"] == TYPE_RESULT + assert response["success"] + subscription_id = response["id"] + mock_async_handle_async_webrtc_offer.assert_called_once() + assert mock_async_handle_async_webrtc_offer.call_args[0][1] == WEBRTC_OFFER + send_message: WebRTCSendMessage = ( + mock_async_handle_async_webrtc_offer.call_args[0][3] + ) + + # Session id + response = await client.receive_json() + assert response["id"] == subscription_id + assert response["type"] == "event" + assert response["event"]["type"] == "session" + session_id = response["event"]["session_id"] + + send_message(message) + + response = await client.receive_json() + assert response["id"] == subscription_id + assert response["type"] == "event" + assert response["event"] == expected_frontend_message + + # Unsubscribe/Close session + await client.send_json_auto_id( + { + "type": "unsubscribe_events", + "subscription": subscription_id, + } + ) + msg = await client.receive_json() + assert msg["success"] + mock_async_close_session.assert_called_once_with(session_id) + + +@pytest.mark.usefixtures("mock_camera_webrtc") +async def test_websocket_webrtc_offer_invalid_entity( + hass: HomeAssistant, hass_ws_client: WebSocketGenerator +) -> None: + """Test WebRTC with a camera entity that does not exist.""" + client = await hass_ws_client(hass) + await client.send_json_auto_id( + { + "type": "camera/webrtc/offer", + "entity_id": "camera.does_not_exist", + "offer": WEBRTC_OFFER, + } + ) + response = await client.receive_json() + + assert response["type"] == TYPE_RESULT + assert not response["success"] + assert response["error"] == { + "code": "home_assistant_error", + "message": "Camera not found", + } + + +@pytest.mark.usefixtures("mock_camera_webrtc") +async def test_websocket_webrtc_offer_missing_offer( + hass: HomeAssistant, hass_ws_client: WebSocketGenerator +) -> None: + """Test WebRTC stream with missing required fields.""" + client = await hass_ws_client(hass) + await client.send_json_auto_id( + { + "type": "camera/webrtc/offer", + "entity_id": "camera.demo_camera", + } + ) + response = await client.receive_json() + + assert response["type"] == TYPE_RESULT + assert not response["success"] + assert response["error"]["code"] == "invalid_format" + + +@pytest.mark.parametrize( + ("error", "expected_message"), + [ + (ValueError("value error"), "value error"), + (HomeAssistantError("offer failed"), "offer failed"), + (TimeoutError(), "Timeout handling WebRTC offer"), + ], +) +@pytest.mark.usefixtures("mock_camera_webrtc_frontendtype_only") +async def test_websocket_webrtc_offer_failure( + hass: HomeAssistant, + hass_ws_client: WebSocketGenerator, + init_test_integration: MockCamera, + error: Exception, + expected_message: str, +) -> None: + """Test WebRTC stream that fails handling the offer.""" + client = await hass_ws_client(hass) + init_test_integration.set_sync_answer(error) + + await client.send_json_auto_id( + { + "type": "camera/webrtc/offer", + "entity_id": "camera.test", + "offer": WEBRTC_OFFER, + } + ) + response = await client.receive_json() + + assert response["type"] == TYPE_RESULT + assert response["success"] + subscription_id = response["id"] + + # Session id + response = await client.receive_json() + assert response["id"] == subscription_id + assert response["type"] == "event" + assert response["event"]["type"] == "session" + + # Error + response = await client.receive_json() + assert response["id"] == subscription_id + assert response["type"] == "event" + assert response["event"] == { + "type": "error", + "code": "webrtc_offer_failed", + "message": expected_message, + } + + +async def test_websocket_webrtc_offer_sync( + hass: HomeAssistant, + hass_ws_client: WebSocketGenerator, + init_test_integration: MockCamera, +) -> None: + """Test sync WebRTC stream offer.""" + client = await hass_ws_client(hass) + init_test_integration.set_sync_answer(WEBRTC_ANSWER) + + await client.send_json_auto_id( + { + "type": "camera/webrtc/offer", + "entity_id": "camera.test", + "offer": WEBRTC_OFFER, + } + ) + response = await client.receive_json() + + assert response["type"] == TYPE_RESULT + assert response["success"] + subscription_id = response["id"] + + # Session id + response = await client.receive_json() + assert response["id"] == subscription_id + assert response["type"] == "event" + assert response["event"]["type"] == "session" + + # Answer + response = await client.receive_json() + assert response["id"] == subscription_id + assert response["type"] == "event" + assert response["event"] == {"type": "answer", "answer": WEBRTC_ANSWER} + + +async def test_websocket_webrtc_offer_sync_no_answer( + hass: HomeAssistant, + hass_ws_client: WebSocketGenerator, + caplog: pytest.LogCaptureFixture, + init_test_integration: MockCamera, +) -> None: + """Test sync WebRTC stream offer with no answer.""" + client = await hass_ws_client(hass) + init_test_integration.set_sync_answer(None) + + await client.send_json_auto_id( + { + "type": "camera/webrtc/offer", + "entity_id": "camera.test", + "offer": WEBRTC_OFFER, + } + ) + response = await client.receive_json() + + assert response["type"] == TYPE_RESULT + assert response["success"] + subscription_id = response["id"] + + # Session id + response = await client.receive_json() + assert response["id"] == subscription_id + assert response["type"] == "event" + assert response["event"]["type"] == "session" + + # Answer + response = await client.receive_json() + assert response["id"] == subscription_id + assert response["type"] == "event" + assert response["event"] == { + "type": "error", + "code": "webrtc_offer_failed", + "message": "No answer on WebRTC offer", + } + assert ( + "homeassistant.components.camera", + logging.ERROR, + "Error handling WebRTC offer: No answer", + ) in caplog.record_tuples + + +@pytest.mark.usefixtures("mock_camera") +async def test_websocket_webrtc_offer_invalid_stream_type( + hass: HomeAssistant, hass_ws_client: WebSocketGenerator +) -> None: + """Test WebRTC initiating for a camera with a different stream_type.""" + client = await hass_ws_client(hass) + await client.send_json_auto_id( + { + "type": "camera/webrtc/offer", + "entity_id": "camera.demo_camera", + "offer": WEBRTC_OFFER, + } + ) + response = await client.receive_json() + + assert response["type"] == TYPE_RESULT + assert not response["success"] + assert response["error"] == { + "code": "webrtc_offer_failed", + "message": "Camera does not support WebRTC, frontend_stream_type=hls", + } + + +@pytest.mark.usefixtures("mock_camera", "mock_stream_source") +async def test_rtsp_to_webrtc_offer( + hass: HomeAssistant, + hass_ws_client: WebSocketGenerator, + mock_rtsp_to_webrtc: Mock, +) -> None: + """Test creating a webrtc offer from an rstp provider.""" + client = await hass_ws_client(hass) + await client.send_json_auto_id( + { + "type": "camera/webrtc/offer", + "entity_id": "camera.demo_camera", + "offer": WEBRTC_OFFER, + } + ) + response = await client.receive_json() + + assert response["type"] == TYPE_RESULT + assert response["success"] + subscription_id = response["id"] + + # Session id + response = await client.receive_json() + assert response["id"] == subscription_id + assert response["type"] == "event" + assert response["event"]["type"] == "session" + + # Answer + response = await client.receive_json() + assert response["id"] == subscription_id + assert response["type"] == "event" + assert response["event"] == { + "type": "answer", + "answer": WEBRTC_ANSWER, + } + + assert mock_rtsp_to_webrtc.called + + +@pytest.fixture(name="mock_hls_stream_source") +async def mock_hls_stream_source_fixture() -> AsyncGenerator[AsyncMock]: + """Fixture to create an HLS stream source.""" + with patch( + "homeassistant.components.camera.Camera.stream_source", + return_value=HLS_STREAM_SOURCE, + ) as mock_hls_stream_source: + yield mock_hls_stream_source + + +@pytest.mark.usefixtures( + "mock_camera", + "mock_hls_stream_source", # Not an RTSP stream source + "mock_camera_webrtc_frontendtype_only", +) +async def test_unsupported_rtsp_to_webrtc_stream_type( + hass: HomeAssistant, hass_ws_client: WebSocketGenerator +) -> None: + """Test rtsp-to-webrtc is not registered for non-RTSP streams.""" + client = await hass_ws_client(hass) + await client.send_json_auto_id( + { + "type": "camera/webrtc/offer", + "entity_id": "camera.demo_camera", + "offer": WEBRTC_OFFER, + } + ) + response = await client.receive_json() + assert response["type"] == TYPE_RESULT + assert response["success"] + subscription_id = response["id"] + + # Session id + response = await client.receive_json() + assert response["id"] == subscription_id + assert response["type"] == "event" + assert response["event"]["type"] == "session" + + # Answer + response = await client.receive_json() + assert response["id"] == subscription_id + assert response["type"] == "event" + assert response["event"] == { + "type": "error", + "code": "webrtc_offer_failed", + "message": "Camera does not support WebRTC", + } + + +@pytest.mark.usefixtures("mock_camera", "mock_stream_source") +async def test_rtsp_to_webrtc_provider_unregistered( + hass: HomeAssistant, hass_ws_client: WebSocketGenerator +) -> None: + """Test creating a webrtc offer from an rstp provider.""" + mock_provider = Mock(side_effect=provide_webrtc_answer) + unsub = async_register_rtsp_to_web_rtc_provider(hass, "mock_domain", mock_provider) + + client = await hass_ws_client(hass) + + # Registered provider can handle the WebRTC offer + await client.send_json_auto_id( + { + "type": "camera/webrtc/offer", + "entity_id": "camera.demo_camera", + "offer": WEBRTC_OFFER, + } + ) + response = await client.receive_json() + assert response["type"] == TYPE_RESULT + assert response["success"] + subscription_id = response["id"] + + # Session id + response = await client.receive_json() + assert response["id"] == subscription_id + assert response["type"] == "event" + assert response["event"]["type"] == "session" + + # Answer + response = await client.receive_json() + assert response["id"] == subscription_id + assert response["type"] == "event" + assert response["event"] == { + "type": "answer", + "answer": WEBRTC_ANSWER, + } + + assert mock_provider.called + mock_provider.reset_mock() + + # Unregister provider, then verify the WebRTC offer cannot be handled + unsub() + await client.send_json_auto_id( + { + "type": "camera/webrtc/offer", + "entity_id": "camera.demo_camera", + "offer": WEBRTC_OFFER, + } + ) + response = await client.receive_json() + assert response.get("type") == TYPE_RESULT + assert not response["success"] + assert response["error"] == { + "code": "webrtc_offer_failed", + "message": "Camera does not support WebRTC, frontend_stream_type=hls", + } + + assert not mock_provider.called + + +@pytest.mark.usefixtures("mock_camera", "mock_stream_source") +async def test_rtsp_to_webrtc_offer_not_accepted( + hass: HomeAssistant, hass_ws_client: WebSocketGenerator +) -> None: + """Test a provider that can't satisfy the rtsp to webrtc offer.""" + + async def provide_none( + stream_source: str, offer: str, stream_id: str + ) -> str | None: + """Simulate a provider that can't accept the offer.""" + return None + + mock_provider = Mock(side_effect=provide_none) + unsub = async_register_rtsp_to_web_rtc_provider(hass, "mock_domain", mock_provider) + client = await hass_ws_client(hass) + + # Registered provider can handle the WebRTC offer + await client.send_json_auto_id( + { + "type": "camera/webrtc/offer", + "entity_id": "camera.demo_camera", + "offer": WEBRTC_OFFER, + } + ) + response = await client.receive_json() + assert response["type"] == TYPE_RESULT + assert response["success"] + subscription_id = response["id"] + + # Session id + response = await client.receive_json() + assert response["id"] == subscription_id + assert response["type"] == "event" + assert response["event"]["type"] == "session" + + # Answer + response = await client.receive_json() + assert response["id"] == subscription_id + assert response["type"] == "event" + assert response["event"] == { + "type": "error", + "code": "webrtc_offer_failed", + "message": "Camera does not support WebRTC", + } + + assert mock_provider.called + + unsub() + + +@pytest.mark.usefixtures("mock_camera_webrtc") +async def test_ws_webrtc_candidate( + hass: HomeAssistant, hass_ws_client: WebSocketGenerator +) -> None: + """Test ws webrtc candidate command.""" + client = await hass_ws_client(hass) + session_id = "session_id" + candidate = "candidate" + with patch( + "homeassistant.components.camera.Camera.async_on_webrtc_candidate" + ) as mock_on_webrtc_candidate: + await client.send_json_auto_id( + { + "type": "camera/webrtc/candidate", + "entity_id": "camera.demo_camera", + "session_id": session_id, + "candidate": candidate, + } + ) + response = await client.receive_json() + assert response["type"] == TYPE_RESULT + assert response["success"] + mock_on_webrtc_candidate.assert_called_once_with(session_id, candidate) + + +@pytest.mark.usefixtures("mock_camera_webrtc") +async def test_ws_webrtc_candidate_not_supported( + hass: HomeAssistant, hass_ws_client: WebSocketGenerator +) -> None: + """Test ws webrtc candidate command is raising if not supported.""" + client = await hass_ws_client(hass) + await client.send_json_auto_id( + { + "type": "camera/webrtc/candidate", + "entity_id": "camera.demo_camera", + "session_id": "session_id", + "candidate": "candidate", + } + ) + response = await client.receive_json() + assert response["type"] == TYPE_RESULT + assert not response["success"] + assert response["error"] == { + "code": "home_assistant_error", + "message": "Cannot handle WebRTC candidate", + } + + +@pytest.mark.usefixtures("mock_camera", "mock_stream_source") +async def test_ws_webrtc_candidate_webrtc_provider( + hass: HomeAssistant, + hass_ws_client: WebSocketGenerator, + register_test_provider: TestProvider, +) -> None: + """Test ws webrtc candidate command with WebRTC provider.""" + with patch.object( + register_test_provider, "async_on_webrtc_candidate" + ) as mock_on_webrtc_candidate: + client = await hass_ws_client(hass) + session_id = "session_id" + candidate = "candidate" + await client.send_json_auto_id( + { + "type": "camera/webrtc/candidate", + "entity_id": "camera.demo_camera", + "session_id": session_id, + "candidate": candidate, + } + ) + response = await client.receive_json() + assert response["type"] == TYPE_RESULT + assert response["success"] + mock_on_webrtc_candidate.assert_called_once_with(session_id, candidate) + + +@pytest.mark.usefixtures("mock_camera_webrtc") +async def test_ws_webrtc_candidate_invalid_entity( + hass: HomeAssistant, hass_ws_client: WebSocketGenerator +) -> None: + """Test ws WebRTC candidate command with a camera entity that does not exist.""" + client = await hass_ws_client(hass) + await client.send_json_auto_id( + { + "type": "camera/webrtc/candidate", + "entity_id": "camera.does_not_exist", + "session_id": "session_id", + "candidate": "candidate", + } + ) + response = await client.receive_json() + + assert response["type"] == TYPE_RESULT + assert not response["success"] + assert response["error"] == { + "code": "home_assistant_error", + "message": "Camera not found", + } + + +@pytest.mark.usefixtures("mock_camera_webrtc") +async def test_ws_webrtc_canidate_missing_candidtae( + hass: HomeAssistant, hass_ws_client: WebSocketGenerator +) -> None: + """Test ws WebRTC candidate command with missing required fields.""" + client = await hass_ws_client(hass) + await client.send_json_auto_id( + { + "type": "camera/webrtc/candidate", + "entity_id": "camera.demo_camera", + "session_id": "session_id", + } + ) + response = await client.receive_json() + + assert response["type"] == TYPE_RESULT + assert not response["success"] + assert response["error"]["code"] == "invalid_format" + + +@pytest.mark.usefixtures("mock_camera") +async def test_ws_webrtc_candidate_invalid_stream_type( + hass: HomeAssistant, hass_ws_client: WebSocketGenerator +) -> None: + """Test ws WebRTC candidate command for a camera with a different stream_type.""" + client = await hass_ws_client(hass) + await client.send_json_auto_id( + { + "type": "camera/webrtc/candidate", + "entity_id": "camera.demo_camera", + "session_id": "session_id", + "candidate": "candidate", + } + ) + response = await client.receive_json() + + assert response["type"] == TYPE_RESULT + assert not response["success"] + assert response["error"] == { + "code": "webrtc_candidate_failed", "message": "Camera does not support WebRTC, frontend_stream_type=hls", } diff --git a/tests/components/go2rtc/conftest.py b/tests/components/go2rtc/conftest.py index d0e9bbb8826..2dcca40cc87 100644 --- a/tests/components/go2rtc/conftest.py +++ b/tests/components/go2rtc/conftest.py @@ -3,7 +3,7 @@ from collections.abc import Generator from unittest.mock import AsyncMock, Mock, patch -from go2rtc_client.client import _StreamClient, _WebRTCClient +from go2rtc_client.rest import _StreamClient, _WebRTCClient import pytest from homeassistant.components.go2rtc.server import Server @@ -12,11 +12,11 @@ GO2RTC_PATH = "homeassistant.components.go2rtc" @pytest.fixture -def mock_client() -> Generator[AsyncMock]: - """Mock a go2rtc client.""" +def rest_client() -> Generator[AsyncMock]: + """Mock a go2rtc rest client.""" with ( patch( - "homeassistant.components.go2rtc.Go2RtcClient", + "homeassistant.components.go2rtc.Go2RtcRestClient", ) as mock_client, ): client = mock_client.return_value @@ -26,7 +26,16 @@ def mock_client() -> Generator[AsyncMock]: @pytest.fixture -def mock_server_start() -> Generator[AsyncMock]: +def ws_client() -> Generator[Mock]: + """Mock a go2rtc websocket client.""" + with patch( + "homeassistant.components.go2rtc.Go2RtcWsClient", autospec=True + ) as ws_client_mock: + yield ws_client_mock.return_value + + +@pytest.fixture +def server_start() -> Generator[AsyncMock]: """Mock start of a go2rtc server.""" with ( patch(f"{GO2RTC_PATH}.server.asyncio.create_subprocess_exec") as mock_subproc, @@ -41,7 +50,7 @@ def mock_server_start() -> Generator[AsyncMock]: @pytest.fixture -def mock_server_stop() -> Generator[AsyncMock]: +def server_stop() -> Generator[AsyncMock]: """Mock stop of a go2rtc server.""" with ( patch( @@ -52,7 +61,7 @@ def mock_server_stop() -> Generator[AsyncMock]: @pytest.fixture -def mock_server(mock_server_start, mock_server_stop) -> Generator[AsyncMock]: +def server(server_start, server_stop) -> Generator[AsyncMock]: """Mock a go2rtc server.""" with patch(f"{GO2RTC_PATH}.Server", wraps=Server) as mock_server: yield mock_server diff --git a/tests/components/go2rtc/test_init.py b/tests/components/go2rtc/test_init.py index 0df38f3cd37..e0749029699 100644 --- a/tests/components/go2rtc/test_init.py +++ b/tests/components/go2rtc/test_init.py @@ -1,25 +1,37 @@ """The tests for the go2rtc component.""" from collections.abc import Callable, Generator +import logging +from typing import NamedTuple from unittest.mock import AsyncMock, Mock, patch -from go2rtc_client import Stream, WebRTCSdpAnswer, WebRTCSdpOffer +from go2rtc_client import Stream from go2rtc_client.models import Producer +from go2rtc_client.ws import ( + ReceiveMessages, + WebRTCAnswer, + WebRTCCandidate, + WebRTCOffer, + WsError, +) import pytest from homeassistant.components.camera import ( DOMAIN as CAMERA_DOMAIN, Camera, CameraEntityFeature, + StreamType, + WebRTCAnswer as HAWebRTCAnswer, + WebRTCCandidate as HAWebRTCCandidate, + WebRTCError, + WebRTCMessage, + WebRTCSendMessage, ) -from homeassistant.components.camera.const import StreamType -from homeassistant.components.camera.helper import get_camera_from_entity_id from homeassistant.components.go2rtc import WebRTCProvider from homeassistant.components.go2rtc.const import DOMAIN from homeassistant.config_entries import ConfigEntry, ConfigFlow from homeassistant.const import CONF_URL from homeassistant.core import HomeAssistant -from homeassistant.exceptions import HomeAssistantError from homeassistant.helpers.typing import ConfigType from homeassistant.setup import async_setup_component @@ -64,12 +76,6 @@ class MockCamera(Camera): return self._stream_source -@pytest.fixture -def integration_entity() -> MockCamera: - """Mock Camera Entity.""" - return MockCamera() - - @pytest.fixture def integration_config_entry(hass: HomeAssistant) -> ConfigEntry: """Test mock config entry.""" @@ -110,12 +116,23 @@ def mock_is_docker_env(is_docker_env) -> Generator[Mock]: yield mock_is_docker_env +@pytest.fixture +async def init_integration( + hass: HomeAssistant, + rest_client: AsyncMock, + mock_is_docker_env, + mock_get_binary, + server: Mock, +) -> None: + """Initialize the go2rtc integration.""" + assert await async_setup_component(hass, DOMAIN, {DOMAIN: {}}) + + @pytest.fixture async def init_test_integration( hass: HomeAssistant, integration_config_entry: ConfigEntry, - integration_entity: MockCamera, -) -> None: +) -> MockCamera: """Initialize components.""" async def async_setup_entry_init( @@ -144,8 +161,9 @@ async def init_test_integration( async_unload_entry=async_unload_entry_init, ), ) + test_camera = MockCamera() setup_test_component_platform( - hass, CAMERA_DOMAIN, [integration_entity], from_config_entry=True + hass, CAMERA_DOMAIN, [test_camera], from_config_entry=True ) mock_platform(hass, f"{TEST_DOMAIN}.config_flow", Mock()) @@ -153,54 +171,66 @@ async def init_test_integration( assert await hass.config_entries.async_setup(integration_config_entry.entry_id) await hass.async_block_till_done() - return integration_config_entry + return test_camera -async def _test_setup( +async def _test_setup_and_signaling( hass: HomeAssistant, - mock_client: AsyncMock, + rest_client: AsyncMock, + ws_client: Mock, config: ConfigType, after_setup_fn: Callable[[], None], + camera: MockCamera, ) -> None: """Test the go2rtc config entry.""" - entity_id = "camera.test" - camera = get_camera_from_entity_id(hass, entity_id) + entity_id = camera.entity_id assert camera.frontend_stream_type == StreamType.HLS assert await async_setup_component(hass, DOMAIN, config) await hass.async_block_till_done() after_setup_fn() - mock_client.webrtc.forward_whep_sdp_offer.return_value = WebRTCSdpAnswer(ANSWER_SDP) + receive_message_callback = Mock(spec_set=WebRTCSendMessage) - answer = await camera.async_handle_web_rtc_offer(OFFER_SDP) - assert answer == ANSWER_SDP + async def test() -> None: + await camera.async_handle_async_webrtc_offer( + OFFER_SDP, "session_id", receive_message_callback + ) + ws_client.send.assert_called_once_with(WebRTCOffer(OFFER_SDP)) + ws_client.subscribe.assert_called_once() - mock_client.webrtc.forward_whep_sdp_offer.assert_called_once_with( - entity_id, WebRTCSdpOffer(OFFER_SDP) - ) - mock_client.streams.add.assert_called_once_with(entity_id, "rtsp://stream") + # Simulate the answer from the go2rtc server + callback = ws_client.subscribe.call_args[0][0] + callback(WebRTCAnswer(ANSWER_SDP)) + receive_message_callback.assert_called_once_with(HAWebRTCAnswer(ANSWER_SDP)) + + await test() + + rest_client.streams.add.assert_called_once_with(entity_id, "rtsp://stream") # If the stream is already added, the stream should not be added again. - mock_client.streams.add.reset_mock() - mock_client.streams.list.return_value = { + rest_client.streams.add.reset_mock() + rest_client.streams.list.return_value = { entity_id: Stream([Producer("rtsp://stream")]) } - answer = await camera.async_handle_web_rtc_offer(OFFER_SDP) - assert answer == ANSWER_SDP - mock_client.streams.add.assert_not_called() - assert mock_client.webrtc.forward_whep_sdp_offer.call_count == 2 - assert isinstance(camera._webrtc_providers[0], WebRTCProvider) + receive_message_callback.reset_mock() + ws_client.reset_mock() + await test() + + rest_client.streams.add.assert_not_called() + assert isinstance(camera._webrtc_provider, WebRTCProvider) # Set stream source to None and provider should be skipped - mock_client.streams.list.return_value = {} + rest_client.streams.list.return_value = {} + receive_message_callback.reset_mock() camera.set_stream_source(None) - with pytest.raises( - HomeAssistantError, - match="WebRTC offer was not accepted by the supported providers", - ): - await camera.async_handle_web_rtc_offer(OFFER_SDP) + await camera.async_handle_async_webrtc_offer( + OFFER_SDP, "session_id", receive_message_callback + ) + receive_message_callback.assert_called_once_with( + WebRTCError("go2rtc_webrtc_offer_failed", "Camera has no stream source") + ) @pytest.mark.usefixtures( @@ -208,21 +238,25 @@ async def _test_setup( ) async def test_setup_go_binary( hass: HomeAssistant, - mock_client: AsyncMock, - mock_server: AsyncMock, - mock_server_start: Mock, - mock_server_stop: Mock, + rest_client: AsyncMock, + ws_client: Mock, + server: AsyncMock, + server_start: Mock, + server_stop: Mock, + init_test_integration: MockCamera, ) -> None: """Test the go2rtc config entry with binary.""" def after_setup() -> None: - mock_server.assert_called_once_with(hass, "/usr/bin/go2rtc") - mock_server_start.assert_called_once() + server.assert_called_once_with(hass, "/usr/bin/go2rtc") + server_start.assert_called_once() - await _test_setup(hass, mock_client, {DOMAIN: {}}, after_setup) + await _test_setup_and_signaling( + hass, rest_client, ws_client, {DOMAIN: {}}, after_setup, init_test_integration + ) await hass.async_stop() - mock_server_stop.assert_called_once() + server_stop.assert_called_once() @pytest.mark.parametrize( @@ -232,11 +266,12 @@ async def test_setup_go_binary( (None, False), ], ) -@pytest.mark.usefixtures("init_test_integration") async def test_setup_go( hass: HomeAssistant, - mock_client: AsyncMock, - mock_server: Mock, + rest_client: AsyncMock, + ws_client: Mock, + server: Mock, + init_test_integration: MockCamera, mock_get_binary: Mock, mock_is_docker_env: Mock, ) -> None: @@ -244,13 +279,150 @@ async def test_setup_go( config = {DOMAIN: {CONF_URL: "http://localhost:1984/"}} def after_setup() -> None: - mock_server.assert_not_called() + server.assert_not_called() - await _test_setup(hass, mock_client, config, after_setup) + await _test_setup_and_signaling( + hass, rest_client, ws_client, config, after_setup, init_test_integration + ) mock_get_binary.assert_not_called() - mock_get_binary.assert_not_called() - mock_server.assert_not_called() + server.assert_not_called() + + +class Callbacks(NamedTuple): + """Callbacks for the test.""" + + on_message: Mock + send_message: Mock + + +@pytest.fixture +async def message_callbacks( + ws_client: Mock, + init_test_integration: MockCamera, +) -> Callbacks: + """Prepare and return receive message callback.""" + receive_callback = Mock(spec_set=WebRTCSendMessage) + + await init_test_integration.async_handle_async_webrtc_offer( + OFFER_SDP, "session_id", receive_callback + ) + ws_client.send.assert_called_once_with(WebRTCOffer(OFFER_SDP)) + ws_client.subscribe.assert_called_once() + + # Simulate messages from the go2rtc server + send_callback = ws_client.subscribe.call_args[0][0] + + return Callbacks(receive_callback, send_callback) + + +@pytest.mark.parametrize( + ("message", "expected_message"), + [ + ( + WebRTCCandidate("candidate"), + HAWebRTCCandidate("candidate"), + ), + ( + WebRTCAnswer(ANSWER_SDP), + HAWebRTCAnswer(ANSWER_SDP), + ), + ( + WsError("error"), + WebRTCError("go2rtc_webrtc_offer_failed", "error"), + ), + ], +) +@pytest.mark.usefixtures("init_integration") +async def test_receiving_messages_from_go2rtc_server( + message_callbacks: Callbacks, + message: ReceiveMessages, + expected_message: WebRTCMessage, +) -> None: + """Test receiving message from go2rtc server.""" + on_message, send_message = message_callbacks + + send_message(message) + on_message.assert_called_once_with(expected_message) + + +@pytest.mark.usefixtures("init_integration") +async def test_receiving_unknown_message_from_go2rtc_server( + message_callbacks: Callbacks, + caplog: pytest.LogCaptureFixture, +) -> None: + """Test receiving unknown message from go2rtc server.""" + on_message, send_message = message_callbacks + + send_message({"type": "unknown"}) + on_message.assert_not_called() + assert ( + "homeassistant.components.go2rtc", + logging.WARNING, + "Unknown message {'type': 'unknown'}", + ) in caplog.record_tuples + + +@pytest.mark.usefixtures("init_integration") +async def test_on_candidate( + ws_client: Mock, + init_test_integration: MockCamera, + caplog: pytest.LogCaptureFixture, +) -> None: + """Test frontend sending candidate to go2rtc server.""" + camera = init_test_integration + session_id = "session_id" + + # Session doesn't exist + await camera.async_on_webrtc_candidate(session_id, "candidate") + assert ( + "homeassistant.components.go2rtc", + logging.DEBUG, + f"Unknown session {session_id}. Ignoring candidate", + ) in caplog.record_tuples + caplog.clear() + + # Store session + await init_test_integration.async_handle_async_webrtc_offer( + OFFER_SDP, session_id, Mock() + ) + ws_client.send.assert_called_once_with(WebRTCOffer(OFFER_SDP)) + ws_client.reset_mock() + + await camera.async_on_webrtc_candidate(session_id, "candidate") + ws_client.send.assert_called_once_with(WebRTCCandidate("candidate")) + assert caplog.record_tuples == [] + + +@pytest.mark.usefixtures("init_integration") +async def test_close_session( + ws_client: Mock, + init_test_integration: MockCamera, +) -> None: + """Test closing session.""" + camera = init_test_integration + session_id = "session_id" + + # Session doesn't exist + with pytest.raises(KeyError): + camera.close_webrtc_session(session_id) + ws_client.close.assert_not_called() + + # Store session + await init_test_integration.async_handle_async_webrtc_offer( + OFFER_SDP, session_id, Mock() + ) + ws_client.send.assert_called_once_with(WebRTCOffer(OFFER_SDP)) + + # Close session + camera.close_webrtc_session(session_id) + ws_client.close.assert_called_once() + + # Close again should raise an error + ws_client.reset_mock() + with pytest.raises(KeyError): + camera.close_webrtc_session(session_id) + ws_client.close.assert_not_called() ERR_BINARY_NOT_FOUND = "Could not find go2rtc docker binary" @@ -288,7 +460,7 @@ async def test_non_user_setup_with_error( ({DOMAIN: {CONF_URL: "http://localhost:1984/"}}, None, True, ERR_CONNECT), ], ) -@pytest.mark.usefixtures("mock_get_binary", "mock_is_docker_env", "mock_server") +@pytest.mark.usefixtures("mock_get_binary", "mock_is_docker_env", "server") async def test_setup_with_error( hass: HomeAssistant, config: ConfigType, diff --git a/tests/components/nest/test_camera.py b/tests/components/nest/test_camera.py index dda7bcfa093..3afe210fda4 100644 --- a/tests/components/nest/test_camera.py +++ b/tests/components/nest/test_camera.py @@ -577,11 +577,11 @@ async def test_refresh_expired_stream_failure( assert create_stream.called +@pytest.mark.usefixtures("webrtc_camera_device") async def test_camera_web_rtc( hass: HomeAssistant, auth, hass_ws_client: WebSocketGenerator, - webrtc_camera_device, setup_platform, ) -> None: """Test a basic camera that supports web rtc.""" @@ -606,31 +606,43 @@ async def test_camera_web_rtc( assert cam.attributes["frontend_stream_type"] == StreamType.WEB_RTC client = await hass_ws_client(hass) - await client.send_json( + await client.send_json_auto_id( { - "id": 5, - "type": "camera/web_rtc_offer", + "type": "camera/webrtc/offer", "entity_id": "camera.my_camera", "offer": "a=recvonly", } ) - msg = await client.receive_json() - assert msg["id"] == 5 - assert msg["type"] == TYPE_RESULT - assert msg["success"] - assert msg["result"]["answer"] == "v=0\r\ns=-\r\n" + response = await client.receive_json() + assert response["type"] == TYPE_RESULT + assert response["success"] + subscription_id = response["id"] + + # Session id + response = await client.receive_json() + assert response["id"] == subscription_id + assert response["type"] == "event" + assert response["event"]["type"] == "session" + + # Answer + response = await client.receive_json() + assert response["id"] == subscription_id + assert response["type"] == "event" + assert response["event"] == { + "type": "answer", + "answer": "v=0\r\ns=-\r\n", + } # Nest WebRTC cameras return a placeholder await async_get_image(hass) await async_get_image(hass, width=1024, height=768) +@pytest.mark.usefixtures("auth", "camera_device") async def test_camera_web_rtc_unsupported( hass: HomeAssistant, - auth, hass_ws_client: WebSocketGenerator, - camera_device, setup_platform, ) -> None: """Test a basic camera that supports web rtc.""" @@ -643,28 +655,28 @@ async def test_camera_web_rtc_unsupported( assert cam.attributes["frontend_stream_type"] == StreamType.HLS client = await hass_ws_client(hass) - await client.send_json( + await client.send_json_auto_id( { - "id": 5, - "type": "camera/web_rtc_offer", + "type": "camera/webrtc/offer", "entity_id": "camera.my_camera", "offer": "a=recvonly", } ) msg = await client.receive_json() - assert msg["id"] == 5 assert msg["type"] == TYPE_RESULT assert not msg["success"] - assert msg["error"]["code"] == "web_rtc_offer_failed" - assert msg["error"]["message"].startswith("Camera does not support WebRTC") + assert msg["error"] == { + "code": "webrtc_offer_failed", + "message": "Camera does not support WebRTC, frontend_stream_type=hls", + } +@pytest.mark.usefixtures("webrtc_camera_device") async def test_camera_web_rtc_offer_failure( hass: HomeAssistant, auth, hass_ws_client: WebSocketGenerator, - webrtc_camera_device, setup_platform, ) -> None: """Test a basic camera that supports web rtc.""" @@ -679,30 +691,43 @@ async def test_camera_web_rtc_offer_failure( assert cam.state == CameraState.STREAMING client = await hass_ws_client(hass) - await client.send_json( + await client.send_json_auto_id( { - "id": 5, - "type": "camera/web_rtc_offer", + "type": "camera/webrtc/offer", "entity_id": "camera.my_camera", "offer": "a=recvonly", } ) - msg = await client.receive_json() - assert msg["id"] == 5 - assert msg["type"] == TYPE_RESULT - assert not msg["success"] - assert msg["error"]["code"] == "web_rtc_offer_failed" - assert msg["error"]["message"].startswith("Nest API error") + response = await client.receive_json() + assert response["type"] == TYPE_RESULT + assert response["success"] + subscription_id = response["id"] + + # Session id + response = await client.receive_json() + assert response["id"] == subscription_id + assert response["type"] == "event" + assert response["event"]["type"] == "session" + + # Answer + response = await client.receive_json() + assert response["id"] == subscription_id + assert response["type"] == "event" + assert response["event"] == { + "type": "error", + "code": "webrtc_offer_failed", + "message": "Nest API error: Bad Request response from API (400)", + } +@pytest.mark.usefixtures("mock_create_stream") async def test_camera_multiple_streams( hass: HomeAssistant, auth, hass_ws_client: WebSocketGenerator, create_device, setup_platform, - mock_create_stream, ) -> None: """Test a camera supporting multiple stream types.""" expiration = utcnow() + datetime.timedelta(seconds=100) @@ -751,17 +776,30 @@ async def test_camera_multiple_streams( # WebRTC stream client = await hass_ws_client(hass) - await client.send_json( + await client.send_json_auto_id( { - "id": 5, - "type": "camera/web_rtc_offer", + "type": "camera/webrtc/offer", "entity_id": "camera.my_camera", "offer": "a=recvonly", } ) - msg = await client.receive_json() - assert msg["id"] == 5 - assert msg["type"] == TYPE_RESULT - assert msg["success"] - assert msg["result"]["answer"] == "v=0\r\ns=-\r\n" + response = await client.receive_json() + assert response["type"] == TYPE_RESULT + assert response["success"] + subscription_id = response["id"] + + # Session id + response = await client.receive_json() + assert response["id"] == subscription_id + assert response["type"] == "event" + assert response["event"]["type"] == "session" + + # Answer + response = await client.receive_json() + assert response["id"] == subscription_id + assert response["type"] == "event" + assert response["event"] == { + "type": "answer", + "answer": "v=0\r\ns=-\r\n", + } diff --git a/tests/components/rtsp_to_webrtc/test_init.py b/tests/components/rtsp_to_webrtc/test_init.py index cb4d5f7a131..85155855a09 100644 --- a/tests/components/rtsp_to_webrtc/test_init.py +++ b/tests/components/rtsp_to_webrtc/test_init.py @@ -86,12 +86,11 @@ async def test_setup_communication_failure( assert entries[0].state is ConfigEntryState.SETUP_RETRY +@pytest.mark.usefixtures("mock_camera", "rtsp_to_webrtc_client") async def test_offer_for_stream_source( hass: HomeAssistant, aioclient_mock: AiohttpClientMocker, hass_ws_client: WebSocketGenerator, - mock_camera: Any, - rtsp_to_webrtc_client: Any, setup_integration: ComponentSetup, ) -> None: """Test successful response from RTSPtoWebRTC server.""" @@ -103,21 +102,33 @@ async def test_offer_for_stream_source( ) client = await hass_ws_client(hass) - await client.send_json( + await client.send_json_auto_id( { - "id": 1, - "type": "camera/web_rtc_offer", + "type": "camera/webrtc/offer", "entity_id": "camera.demo_camera", "offer": OFFER_SDP, } ) + response = await client.receive_json() - assert response.get("id") == 1 - assert response.get("type") == TYPE_RESULT - assert response.get("success") - assert "result" in response - assert response["result"].get("answer") == ANSWER_SDP - assert "error" not in response + assert response["type"] == TYPE_RESULT + assert response["success"] + subscription_id = response["id"] + + # Session id + response = await client.receive_json() + assert response["id"] == subscription_id + assert response["type"] == "event" + assert response["event"]["type"] == "session" + + # Answer + response = await client.receive_json() + assert response["id"] == subscription_id + assert response["type"] == "event" + assert response["event"] == { + "type": "answer", + "answer": ANSWER_SDP, + } # Validate request parameters were sent correctly assert len(aioclient_mock.mock_calls) == 1 @@ -127,12 +138,11 @@ async def test_offer_for_stream_source( } +@pytest.mark.usefixtures("mock_camera", "rtsp_to_webrtc_client") async def test_offer_failure( hass: HomeAssistant, aioclient_mock: AiohttpClientMocker, hass_ws_client: WebSocketGenerator, - mock_camera: Any, - rtsp_to_webrtc_client: Any, setup_integration: ComponentSetup, ) -> None: """Test a transient failure talking to RTSPtoWebRTC server.""" @@ -144,20 +154,31 @@ async def test_offer_failure( ) client = await hass_ws_client(hass) - await client.send_json( + await client.send_json_auto_id( { - "id": 2, - "type": "camera/web_rtc_offer", + "type": "camera/webrtc/offer", "entity_id": "camera.demo_camera", "offer": OFFER_SDP, } ) + response = await client.receive_json() - assert response.get("id") == 2 - assert response.get("type") == TYPE_RESULT - assert "success" in response - assert not response.get("success") - assert "error" in response - assert response["error"].get("code") == "web_rtc_offer_failed" - assert "message" in response["error"] - assert "RTSPtoWebRTC server communication failure" in response["error"]["message"] + assert response["type"] == TYPE_RESULT + assert response["success"] + subscription_id = response["id"] + + # Session id + response = await client.receive_json() + assert response["id"] == subscription_id + assert response["type"] == "event" + assert response["event"]["type"] == "session" + + # Answer + response = await client.receive_json() + assert response["id"] == subscription_id + assert response["type"] == "event" + assert response["event"] == { + "type": "error", + "code": "webrtc_offer_failed", + "message": "RTSPtoWebRTC server communication failure: ", + }