Add cloud tts entity (#108293)

* Add cloud tts entity

* Test test_login_view_missing_entity

* Fix pipeline iteration for migration

* Update tests

* Make migration more strict

* Fix docstring

tests/components/cloud/test_tts.py

@@ -1,23 +1,36 @@
 """Tests for cloud tts."""
-from collections.abc import Callable, Coroutine
+from collections.abc import AsyncGenerator, Callable, Coroutine
+from copy import deepcopy
 from http import HTTPStatus
 from typing import Any
-from unittest.mock import AsyncMock, MagicMock
+from unittest.mock import AsyncMock, MagicMock, patch
 
 from hass_nabucasa.voice import MAP_VOICE, VoiceError, VoiceTokenError
 import pytest
 import voluptuous as vol
 
+from homeassistant.components.assist_pipeline.pipeline import STORAGE_KEY
 from homeassistant.components.cloud import DOMAIN, const, tts
 from homeassistant.components.tts import DOMAIN as TTS_DOMAIN
 from homeassistant.components.tts.helper import get_engine_instance
 from homeassistant.config import async_process_ha_core_config
+from homeassistant.const import STATE_UNAVAILABLE, STATE_UNKNOWN
 from homeassistant.core import HomeAssistant
+from homeassistant.helpers.entity_registry import EntityRegistry
 from homeassistant.setup import async_setup_component
 
+from . import PIPELINE_DATA
+
 from tests.typing import ClientSessionGenerator
 
 
+@pytest.fixture(autouse=True)
+async def delay_save_fixture() -> AsyncGenerator[None, None]:
+    """Load the homeassistant integration."""
+    with patch("homeassistant.helpers.collection.SAVE_DELAY", new=0):
+        yield
+
+
 @pytest.fixture(autouse=True)
 async def internal_url_mock(hass: HomeAssistant) -> None:
     """Mock internal URL of the instance."""
@@ -70,6 +83,10 @@ def test_schema() -> None:
                 "gender": "female",
             },
         ),
+        (
+            "tts.home_assistant_cloud",
+            None,
+        ),
     ],
 )
 async def test_prefs_default_voice(
@@ -104,9 +121,17 @@ async def test_prefs_default_voice(
     assert engine.default_options == {"gender": "male", "audio_output": "mp3"}
 
 
+@pytest.mark.parametrize(
+    "engine_id",
+    [
+        DOMAIN,
+        "tts.home_assistant_cloud",
+    ],
+)
 async def test_provider_properties(
     hass: HomeAssistant,
     cloud: MagicMock,
+    engine_id: str,
 ) -> None:
     """Test cloud provider."""
     assert await async_setup_component(hass, "homeassistant", {})
@@ -115,7 +140,7 @@ async def test_provider_properties(
     on_start_callback = cloud.register_on_start.call_args[0][0]
     await on_start_callback()
 
-    engine = get_engine_instance(hass, DOMAIN)
+    engine = get_engine_instance(hass, engine_id)
 
     assert engine is not None
     assert engine.supported_options == ["gender", "voice", "audio_output"]
@@ -132,6 +157,7 @@ async def test_provider_properties(
     [
         ({"platform": DOMAIN}, DOMAIN),
         ({"engine_id": DOMAIN}, DOMAIN),
+        ({"engine_id": "tts.home_assistant_cloud"}, "tts.home_assistant_cloud"),
     ],
 )
 @pytest.mark.parametrize(
@@ -241,3 +267,144 @@ async def test_get_tts_audio_logged_out(
     assert mock_process_tts.call_args.kwargs["language"] == "en-US"
     assert mock_process_tts.call_args.kwargs["gender"] == "female"
     assert mock_process_tts.call_args.kwargs["output"] == "mp3"
+
+
+@pytest.mark.parametrize(
+    ("mock_process_tts_return_value", "mock_process_tts_side_effect"),
+    [
+        (b"", None),
+        (None, VoiceError("Boom!")),
+    ],
+)
+async def test_tts_entity(
+    hass: HomeAssistant,
+    hass_client: ClientSessionGenerator,
+    entity_registry: EntityRegistry,
+    cloud: MagicMock,
+    mock_process_tts_return_value: bytes | None,
+    mock_process_tts_side_effect: Exception | None,
+) -> None:
+    """Test text-to-speech entity."""
+    mock_process_tts = AsyncMock(
+        return_value=mock_process_tts_return_value,
+        side_effect=mock_process_tts_side_effect,
+    )
+    cloud.voice.process_tts = mock_process_tts
+    assert await async_setup_component(hass, "homeassistant", {})
+    assert await async_setup_component(hass, DOMAIN, {DOMAIN: {}})
+    await hass.async_block_till_done()
+    on_start_callback = cloud.register_on_start.call_args[0][0]
+    await on_start_callback()
+    client = await hass_client()
+    entity_id = "tts.home_assistant_cloud"
+
+    state = hass.states.get(entity_id)
+    assert state
+    assert state.state == STATE_UNKNOWN
+
+    url = "/api/tts_get_url"
+    data = {
+        "engine_id": entity_id,
+        "message": "There is someone at the door.",
+    }
+
+    req = await client.post(url, json=data)
+    assert req.status == HTTPStatus.OK
+    response = await req.json()
+
+    assert response == {
+        "url": (
+            "http://example.local:8123/api/tts_proxy/"
+            "42f18378fd4393d18c8dd11d03fa9563c1e54491"
+            f"_en-us_e09b5a0968_{entity_id}.mp3"
+        ),
+        "path": (
+            "/api/tts_proxy/42f18378fd4393d18c8dd11d03fa9563c1e54491"
+            f"_en-us_e09b5a0968_{entity_id}.mp3"
+        ),
+    }
+    await hass.async_block_till_done()
+
+    assert mock_process_tts.call_count == 1
+    assert mock_process_tts.call_args is not None
+    assert mock_process_tts.call_args.kwargs["text"] == "There is someone at the door."
+    assert mock_process_tts.call_args.kwargs["language"] == "en-US"
+    assert mock_process_tts.call_args.kwargs["gender"] == "female"
+    assert mock_process_tts.call_args.kwargs["output"] == "mp3"
+
+    state = hass.states.get(entity_id)
+    assert state
+    assert state.state not in (STATE_UNAVAILABLE, STATE_UNKNOWN)
+
+    # Test removing the entity
+    entity_registry.async_remove(entity_id)
+    await hass.async_block_till_done()
+
+    state = hass.states.get(entity_id)
+    assert state is None
+
+
+async def test_migrating_pipelines(
+    hass: HomeAssistant,
+    cloud: MagicMock,
+    hass_client: ClientSessionGenerator,
+    hass_storage: dict[str, Any],
+) -> None:
+    """Test migrating pipelines when cloud tts entity is added."""
+    entity_id = "tts.home_assistant_cloud"
+    mock_process_tts = AsyncMock(
+        return_value=b"",
+    )
+    cloud.voice.process_tts = mock_process_tts
+    hass_storage[STORAGE_KEY] = {
+        "version": 1,
+        "minor_version": 1,
+        "key": "assist_pipeline.pipelines",
+        "data": deepcopy(PIPELINE_DATA),
+    }
+
+    assert await async_setup_component(hass, "assist_pipeline", {})
+    assert await async_setup_component(hass, DOMAIN, {"cloud": {}})
+    await hass.async_block_till_done()
+
+    await cloud.login("test-user", "test-pass")
+    await hass.async_block_till_done()
+
+    state = hass.states.get(entity_id)
+    assert state
+    assert state.state == STATE_UNKNOWN
+
+    # The stt/tts engines should have been updated to the new cloud engine ids.
+    assert (
+        hass_storage[STORAGE_KEY]["data"]["items"][0]["stt_engine"]
+        == "stt.home_assistant_cloud"
+    )
+    assert hass_storage[STORAGE_KEY]["data"]["items"][0]["tts_engine"] == entity_id
+
+    # The other items should stay the same.
+    assert (
+        hass_storage[STORAGE_KEY]["data"]["items"][0]["conversation_engine"]
+        == "conversation_engine_1"
+    )
+    assert (
+        hass_storage[STORAGE_KEY]["data"]["items"][0]["conversation_language"]
+        == "language_1"
+    )
+    assert (
+        hass_storage[STORAGE_KEY]["data"]["items"][0]["id"]
+        == "01GX8ZWBAQYWNB1XV3EXEZ75DY"
+    )
+    assert hass_storage[STORAGE_KEY]["data"]["items"][0]["language"] == "language_1"
+    assert (
+        hass_storage[STORAGE_KEY]["data"]["items"][0]["name"] == "Home Assistant Cloud"
+    )
+    assert hass_storage[STORAGE_KEY]["data"]["items"][0]["stt_language"] == "language_1"
+    assert hass_storage[STORAGE_KEY]["data"]["items"][0]["tts_language"] == "language_1"
+    assert (
+        hass_storage[STORAGE_KEY]["data"]["items"][0]["tts_voice"]
+        == "Arnold Schwarzenegger"
+    )
+    assert hass_storage[STORAGE_KEY]["data"]["items"][0]["wake_word_entity"] is None
+    assert hass_storage[STORAGE_KEY]["data"]["items"][0]["wake_word_id"] is None
+    assert hass_storage[STORAGE_KEY]["data"]["items"][1] == PIPELINE_DATA["items"][1]
+    assert hass_storage[STORAGE_KEY]["data"]["items"][2] == PIPELINE_DATA["items"][2]