Fix config entry from feedback

Co-authored-by: Copilot Autofix powered by AI <175728472+Copilot@users.noreply.github.com>

.github/copilot-instructions.md

@@ -25,6 +25,7 @@ This repository contains the core of Home Assistant, a Python 3 based home autom
 
 - When entering a new environment or worktree, run `script/setup` to set up the virtual environment with all development dependencies (pylint, pre-commit hooks, etc.). This is required before committing.
 - .vscode/tasks.json contains useful commands used for development.
+- After finishing a code session, run `uv run prek run --all-files` to check for linting and formatting issues.
 
 ## Python Syntax Notes
 

AGENTS.md

@@ -15,6 +15,7 @@ This repository contains the core of Home Assistant, a Python 3 based home autom
 
 - When entering a new environment or worktree, run `script/setup` to set up the virtual environment with all development dependencies (pylint, pre-commit hooks, etc.). This is required before committing.
 - .vscode/tasks.json contains useful commands used for development.
+- After finishing a code session, run `uv run prek run --all-files` to check for linting and formatting issues.
 
 ## Python Syntax Notes
 

homeassistant/components/analytics/__init__.py

@@ -5,8 +5,12 @@ from typing import Any
 import voluptuous as vol
 
 from homeassistant.components import labs, websocket_api
-from homeassistant.const import EVENT_HOMEASSISTANT_STARTED
-from homeassistant.core import Event, HomeAssistant, callback
+from homeassistant.components.hassio import HassioNotReadyError
+from homeassistant.config_entries import SOURCE_SYSTEM, ConfigEntry
+from homeassistant.core import HomeAssistant, callback
+from homeassistant.exceptions import ConfigEntryNotReady
+from homeassistant.helpers import discovery_flow
+from homeassistant.helpers.start import async_at_started
 from homeassistant.helpers.typing import ConfigType
 from homeassistant.util.hass_dict import HassKey
 
@@ -49,6 +53,7 @@ CONFIG_SCHEMA = vol.Schema(
 )
 
 DATA_COMPONENT: HassKey[Analytics] = HassKey(DOMAIN)
+_DATA_SNAPSHOTS_URL: HassKey[str | None] = HassKey(f"{DOMAIN}_snapshots_url")
 
 LABS_SNAPSHOT_FEATURE = "snapshots"
 
@@ -57,18 +62,39 @@ async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
     """Set up the analytics integration."""
     analytics_config = config.get(DOMAIN, {})
 
+    snapshots_url: str | None = None
     if CONF_SNAPSHOTS_URL in analytics_config:
         await labs.async_update_preview_feature(
             hass, DOMAIN, LABS_SNAPSHOT_FEATURE, enabled=True
         )
         snapshots_url = analytics_config[CONF_SNAPSHOTS_URL]
-    else:
-        snapshots_url = None
 
+    hass.data[_DATA_SNAPSHOTS_URL] = snapshots_url
+
+    discovery_flow.async_create_flow(
+        hass, DOMAIN, context={"source": SOURCE_SYSTEM}, data={}
+    )
+
+    websocket_api.async_register_command(hass, websocket_analytics)
+    websocket_api.async_register_command(hass, websocket_analytics_preferences)
+
+    hass.http.register_view(AnalyticsDevicesView)
+
+    return True
+
+
+async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
+    """Set up Analytics from a config entry."""
+    snapshots_url = hass.data.get(_DATA_SNAPSHOTS_URL)
     analytics = Analytics(hass, snapshots_url)
 
-    # Load stored data
-    await analytics.load()
+    try:
+        await analytics.load()
+    except HassioNotReadyError as err:
+        raise ConfigEntryNotReady(
+            translation_domain=DOMAIN,
+            translation_key="supervisor_not_ready",
+        ) from err
 
     started = False
 
@@ -80,26 +106,30 @@ async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
         if started:
             await analytics.async_schedule()
 
-    async def start_schedule(_event: Event) -> None:
-        """Start the send schedule after the started event."""
+    async def start_schedule(hass: HomeAssistant) -> None:
+        """Start the send schedule once Home Assistant has started."""
         nonlocal started
         started = True
         await analytics.async_schedule()
 
-    labs.async_subscribe_preview_feature(
-        hass, DOMAIN, LABS_SNAPSHOT_FEATURE, _async_handle_labs_update
+    entry.async_on_unload(
+        labs.async_subscribe_preview_feature(
+            hass, DOMAIN, LABS_SNAPSHOT_FEATURE, _async_handle_labs_update
+        )
     )
-    hass.bus.async_listen_once(EVENT_HOMEASSISTANT_STARTED, start_schedule)
-
-    websocket_api.async_register_command(hass, websocket_analytics)
-    websocket_api.async_register_command(hass, websocket_analytics_preferences)
-
-    hass.http.register_view(AnalyticsDevicesView)
+    entry.async_on_unload(async_at_started(hass, start_schedule))
 
     hass.data[DATA_COMPONENT] = analytics
     return True
 
 
+async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
+    """Unload an Analytics config entry."""
+    analytics = hass.data.pop(DATA_COMPONENT)
+    analytics.cancel_scheduled()
+    return True
+
+
 @callback
 @websocket_api.require_admin
 @websocket_api.websocket_command({vol.Required("type"): "analytics"})
@@ -109,7 +139,9 @@ def websocket_analytics(
     msg: dict[str, Any],
 ) -> None:
     """Return analytics preferences."""
-    analytics = hass.data[DATA_COMPONENT]
+    if (analytics := hass.data.get(DATA_COMPONENT)) is None:
+        connection.send_error(msg["id"], websocket_api.ERR_NOT_FOUND, "Not loaded")
+        return
     connection.send_result(
         msg["id"],
         {ATTR_PREFERENCES: analytics.preferences, ATTR_ONBOARDED: analytics.onboarded},
@@ -130,8 +162,10 @@ async def websocket_analytics_preferences(
     msg: dict[str, Any],
 ) -> None:
     """Update analytics preferences."""
+    if (analytics := hass.data.get(DATA_COMPONENT)) is None:
+        connection.send_error(msg["id"], websocket_api.ERR_NOT_FOUND, "Not loaded")
+        return
     preferences = msg[ATTR_PREFERENCES]
-    analytics = hass.data[DATA_COMPONENT]
 
     await analytics.save_preferences(preferences)
     await analytics.async_schedule()

homeassistant/components/analytics/analytics.py

@@ -299,12 +299,8 @@ class Analytics:
             self._data = AnalyticsData.from_dict(stored)
 
         if self.supervisor and not self.onboarded:
-            # This may raise HassioNotReadyError if Supervisor was unreachable
-            # during setup of the Supervisor integration. That will fail setup
-            # of this integration. However there is no better option at this time
-            # since we need to get the diagnostic setting from Supervisor to correctly
-            # setup this integration and we can't raise ConfigEntryNotReady to
-            # trigger a retry from async_setup.
+            # This may raise HassioNotReadyError if Supervisor was unreachable.
+            # The caller is responsible for handling this and triggering a retry.
             supervisor_info = hassio.get_supervisor_info(self._hass)
 
             # User have not configured analytics, get this setting from the supervisor
@@ -349,8 +345,7 @@ class Analytics:
             await self._save()
 
         if self.supervisor:
-            # get_supervisor_info was called during setup so we can't get here
-            # if it raised. The others may raise HassioNotReadyError if only some
+            # The others may raise HassioNotReadyError if only some
             # data was successfully fetched from Supervisor
             supervisor_info = hassio.get_supervisor_info(hass)
             with contextlib.suppress(hassio.HassioNotReadyError):
@@ -630,6 +625,16 @@ class Analytics:
                 err,
             )
 
+    @callback
+    def cancel_scheduled(self) -> None:
+        """Cancel all scheduled analytics tasks."""
+        if self._basic_scheduled is not None:
+            self._basic_scheduled()
+            self._basic_scheduled = None
+        if self._snapshot_scheduled is not None:
+            self._snapshot_scheduled()
+            self._snapshot_scheduled = None
+
     async def async_schedule(self) -> None:
         """Schedule analytics."""
         if not self.onboarded:

homeassistant/components/analytics/config_flow.py

@@ -0,0 +1,19 @@
+"""Config flow for Analytics integration."""
+
+from typing import Any
+
+from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
+
+from .const import DOMAIN
+
+
+class AnalyticsConfigFlow(ConfigFlow, domain=DOMAIN):
+    """Handle a config flow for Analytics."""
+
+    VERSION = 1
+
+    async def async_step_system(
+        self, user_input: dict[str, Any] | None = None
+    ) -> ConfigFlowResult:
+        """Handle the initial step."""
+        return self.async_create_entry(title="Analytics", data={})

homeassistant/components/analytics/manifest.json

@@ -3,6 +3,8 @@
   "name": "Analytics",
   "after_dependencies": ["energy", "hassio", "recorder"],
   "codeowners": ["@home-assistant/core"],
+  "config_flow": true,
+  "single_config_entry": true,
   "dependencies": ["api", "websocket_api", "http"],
   "documentation": "https://www.home-assistant.io/integrations/analytics",
   "integration_type": "system",

homeassistant/components/analytics/strings.json

@@ -1,4 +1,9 @@
 {
+  "exceptions": {
+    "supervisor_not_ready": {
+      "message": "Supervisor was not ready during setup, will retry"
+    }
+  },
   "preview_features": {
     "snapshots": {
       "description": "We're creating the [Open Home Foundation Device Database](https://www.home-assistant.io/blog/2026/02/02/about-device-database/): a free, open source community-powered resource to help users find practical information about how smart home devices perform in real installations.\n\nYou can help us build it by opting in to share anonymized data about your devices. This data will only ever include device-specific details (like model or manufacturer) – never personally identifying information (like the names you assign).\n\nFind out how we process your data (should you choose to contribute) in our [Data Use Statement](https://www.openhomefoundation.org/device-database-data-use-statement).",

homeassistant/components/dnsip/__init__.py

@@ -6,7 +6,6 @@ import logging
 
 import aiodns
 from aiodns.error import DNSError
-from pycares import AresError
 
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import CONF_PORT
@@ -78,11 +77,7 @@ async def async_setup_entry(hass: HomeAssistant, entry: DnsIPConfigEntry) -> boo
         ) from err
 
     errors = [
-        result
-        for result in results
-        if isinstance(
-            result, (TimeoutError, DNSError, AresError, asyncio.CancelledError)
-        )
+        result for result in results if isinstance(result, (TimeoutError, DNSError))
     ]
     if errors and len(errors) == len(results):
         await _close_resolvers()

homeassistant/generated/config_flows.py

@@ -59,6 +59,7 @@ FLOWS = {
         "amberelectric",
         "ambient_network",
         "ambient_station",
+        "analytics",
         "analytics_insights",
         "android_ip_webcam",
         "androidtv",

homeassistant/package_constraints.txt

@@ -133,7 +133,7 @@ multidict>=6.0.2
 Brotli>=1.2.0
 
 # ensure pydantic version does not float since it might have breaking changes
-pydantic==2.13.2
+pydantic==2.13.4
 
 # Required for Python 3.14.0 compatibility (#119223).
 mashumaro>=3.17.0

requirements_test.txt

@@ -18,7 +18,7 @@ license-expression==30.4.3
 mock-open==1.4.0
 mypy==2.1.0
 prek==0.2.28
-pydantic==2.13.2
+pydantic==2.13.4
 pylint==4.0.5
 pylint-per-file-ignores==3.2.1
 pipdeptree==2.26.1

script/gen_requirements_all.py

@@ -117,7 +117,7 @@ multidict>=6.0.2
 Brotli>=1.2.0
 
 # ensure pydantic version does not float since it might have breaking changes
-pydantic==2.13.2
+pydantic==2.13.4
 
 # Required for Python 3.14.0 compatibility (#119223).
 mashumaro>=3.17.0

tests/components/analytics/test_init.py

@@ -6,15 +6,18 @@ from unittest.mock import patch
 
 import pytest
 
-from homeassistant.components.analytics import LABS_SNAPSHOT_FEATURE
+from homeassistant.components.analytics import CONF_SNAPSHOTS_URL, LABS_SNAPSHOT_FEATURE
 from homeassistant.components.analytics.const import (
     BASIC_ENDPOINT_URL,
+    BASIC_ENDPOINT_URL_DEV,
     DOMAIN,
     SNAPSHOT_DEFAULT_URL,
     SNAPSHOT_URL_PATH,
     STORAGE_KEY,
 )
+from homeassistant.components.hassio import HassioNotReadyError
 from homeassistant.components.labs import async_update_preview_feature
+from homeassistant.config_entries import ConfigEntryState
 from homeassistant.const import EVENT_HOMEASSISTANT_STARTED
 from homeassistant.core import HomeAssistant
 from homeassistant.setup import async_setup_component
@@ -37,6 +40,175 @@ async def test_setup(hass: HomeAssistant) -> None:
     assert DOMAIN in hass.data
 
 
+async def test_setup_with_snapshots_url(
+    hass: HomeAssistant,
+    hass_storage: dict[str, Any],
+    hass_ws_client: WebSocketGenerator,
+    aioclient_mock: AiohttpClientMocker,
+) -> None:
+    """Test setup with snapshots_url in YAML config sends snapshots to that URL."""
+    custom_url = "https://custom-snapshot-endpoint.example.com"
+    snapshot_endpoint = custom_url + SNAPSHOT_URL_PATH
+    aioclient_mock.post(snapshot_endpoint, status=200, json={})
+
+    with patch(
+        "homeassistant.components.analytics.analytics._async_snapshot_payload",
+        return_value={"mock": {}},
+    ):
+        assert await async_setup_component(hass, "labs", {})
+        assert await async_setup_component(
+            hass, DOMAIN, {DOMAIN: {CONF_SNAPSHOTS_URL: custom_url}}
+        )
+        await hass.async_block_till_done()
+
+        ws_client = await hass_ws_client(hass)
+        await ws_client.send_json_auto_id(
+            {"type": "analytics/preferences", "preferences": {"snapshots": True}}
+        )
+        assert (await ws_client.receive_json())["success"]
+
+        async_fire_time_changed(hass, dt_util.utcnow() + timedelta(hours=25))
+        await hass.async_block_till_done()
+
+    assert any(str(call[1]) == snapshot_endpoint for call in aioclient_mock.mock_calls)
+
+
+async def test_setup_entry_supervisor_not_ready(hass: HomeAssistant) -> None:
+    """Test that HassioNotReadyError raises ConfigEntryNotReady."""
+    with (
+        patch(
+            "homeassistant.components.analytics.analytics.is_hassio",
+            return_value=True,
+        ),
+        patch(
+            "homeassistant.components.hassio.get_supervisor_info",
+            side_effect=HassioNotReadyError,
+        ),
+    ):
+        assert await async_setup_component(hass, DOMAIN, {DOMAIN: {}})
+        await hass.async_block_till_done()
+
+    entry = hass.config_entries.async_entries(DOMAIN)[0]
+    assert entry.state is ConfigEntryState.SETUP_RETRY
+
+
+async def test_schedule_starts_and_sends_analytics(
+    hass: HomeAssistant,
+    hass_storage: dict[str, Any],
+    hass_ws_client: WebSocketGenerator,
+    aioclient_mock: AiohttpClientMocker,
+) -> None:
+    """Test that the analytics schedule fires and sends analytics after time travel."""
+    aioclient_mock.post(BASIC_ENDPOINT_URL, status=200)
+    aioclient_mock.post(BASIC_ENDPOINT_URL_DEV, status=200)
+
+    assert await async_setup_component(hass, DOMAIN, {DOMAIN: {}})
+    await hass.async_block_till_done()
+
+    ws_client = await hass_ws_client(hass)
+    with patch("homeassistant.components.analytics.analytics.HA_VERSION", MOCK_VERSION):
+        await ws_client.send_json_auto_id(
+            {"type": "analytics/preferences", "preferences": {"base": True}}
+        )
+        assert (await ws_client.receive_json())["success"]
+
+        assert len(aioclient_mock.mock_calls) == 0
+
+        async_fire_time_changed(hass, dt_util.utcnow() + timedelta(seconds=901))
+        await hass.async_block_till_done()
+
+    assert len(aioclient_mock.mock_calls) == 1
+
+
+async def test_unload_entry(
+    hass: HomeAssistant,
+    hass_storage: dict[str, Any],
+    hass_ws_client: WebSocketGenerator,
+    aioclient_mock: AiohttpClientMocker,
+) -> None:
+    """Test that unloading the config entry stops the analytics schedule."""
+    aioclient_mock.post(BASIC_ENDPOINT_URL, status=200)
+    aioclient_mock.post(BASIC_ENDPOINT_URL_DEV, status=200)
+
+    assert await async_setup_component(hass, DOMAIN, {DOMAIN: {}})
+    await hass.async_block_till_done()
+
+    ws_client = await hass_ws_client(hass)
+    with patch("homeassistant.components.analytics.analytics.HA_VERSION", MOCK_VERSION):
+        await ws_client.send_json_auto_id(
+            {"type": "analytics/preferences", "preferences": {"base": True}}
+        )
+        await ws_client.receive_json()
+
+        async_fire_time_changed(hass, dt_util.utcnow() + timedelta(seconds=901))
+        await hass.async_block_till_done()
+
+    assert len(aioclient_mock.mock_calls) == 1
+
+    entry = hass.config_entries.async_entries(DOMAIN)[0]
+    await hass.config_entries.async_unload(entry.entry_id)
+    await hass.async_block_till_done()
+
+    async_fire_time_changed(hass, dt_util.utcnow() + timedelta(days=2))
+    await hass.async_block_till_done()
+
+    assert len(aioclient_mock.mock_calls) == 1
+
+
+async def test_websocket_not_loaded(
+    hass: HomeAssistant,
+    hass_ws_client: WebSocketGenerator,
+) -> None:
+    """Test websocket returns error when analytics entry failed to load."""
+    with (
+        patch(
+            "homeassistant.components.analytics.analytics.is_hassio",
+            return_value=True,
+        ),
+        patch(
+            "homeassistant.components.hassio.get_supervisor_info",
+            side_effect=HassioNotReadyError,
+        ),
+    ):
+        assert await async_setup_component(hass, DOMAIN, {DOMAIN: {}})
+        await hass.async_block_till_done()
+
+    ws_client = await hass_ws_client(hass)
+    await ws_client.send_json_auto_id({"type": "analytics"})
+    response = await ws_client.receive_json()
+
+    assert not response["success"]
+    assert response["error"]["code"] == "not_found"
+
+
+async def test_websocket_preferences_not_loaded(
+    hass: HomeAssistant,
+    hass_ws_client: WebSocketGenerator,
+) -> None:
+    """Test preferences websocket returns error when analytics entry failed to load."""
+    with (
+        patch(
+            "homeassistant.components.analytics.analytics.is_hassio",
+            return_value=True,
+        ),
+        patch(
+            "homeassistant.components.hassio.get_supervisor_info",
+            side_effect=HassioNotReadyError,
+        ),
+    ):
+        assert await async_setup_component(hass, DOMAIN, {DOMAIN: {}})
+        await hass.async_block_till_done()
+
+    ws_client = await hass_ws_client(hass)
+    await ws_client.send_json_auto_id(
+        {"type": "analytics/preferences", "preferences": {"base": True}}
+    )
+    response = await ws_client.receive_json()
+
+    assert not response["success"]
+    assert response["error"]["code"] == "not_found"
+
+
 @pytest.mark.usefixtures("mock_snapshot_payload")
 async def test_labs_feature_toggle(
     hass: HomeAssistant,

tests/components/dnsip/test_init.py

@@ -1,10 +1,8 @@
 """Test for DNS IP integration Init."""
 
-import asyncio
 from unittest.mock import patch
 
 from aiodns.error import DNSError
-from pycares import AresError
 import pytest
 
 from homeassistant.components.dnsip.const import (
@@ -180,8 +178,6 @@ async def test_migrate_error_from_future(hass: HomeAssistant) -> None:
     [
         TimeoutError(),
         DNSError(),
-        AresError(),
-        asyncio.CancelledError(),
     ],
 )
 async def test_setup_dns_error(hass: HomeAssistant, error: Exception) -> None:

tests/components/history/test_websocket_api.py

@@ -1,10 +1,7 @@
 """The tests the History component websocket_api."""
 
 import asyncio
-from collections.abc import Callable, Iterator
-from contextlib import contextmanager
 from datetime import timedelta
-from typing import Any
 from unittest.mock import ANY, patch
 
 from freezegun import freeze_time
@@ -12,12 +9,7 @@ import pytest
 
 from homeassistant.components import history
 from homeassistant.components.history import websocket_api
-from homeassistant.const import (
-    EVENT_HOMEASSISTANT_FINAL_WRITE,
-    EVENT_STATE_CHANGED,
-    STATE_OFF,
-    STATE_ON,
-)
+from homeassistant.const import EVENT_HOMEASSISTANT_FINAL_WRITE, STATE_OFF, STATE_ON
 from homeassistant.core import HomeAssistant, callback
 from homeassistant.helpers.event import async_track_state_change_event
 from homeassistant.setup import async_setup_component
@@ -43,27 +35,6 @@ def listeners_without_writes(listeners: dict[str, int]) -> dict[str, int]:
     }
 
 
-@contextmanager
-def assert_no_listener_leak(hass: HomeAssistant) -> Iterator[None]:
-    """Capture bus listeners on entry, assert no leak on exit.
-
-    EVENT_STATE_CHANGED is excluded because unrelated components can
-    asynchronously add or remove state_changed listeners during a test.
-    """
-    excluded = {EVENT_HOMEASSISTANT_FINAL_WRITE, EVENT_STATE_CHANGED}
-
-    def _snapshot() -> dict[str, int]:
-        return {
-            key: value
-            for key, value in hass.bus.async_listeners().items()
-            if key not in excluded
-        }
-
-    before = _snapshot()
-    yield
-    assert _snapshot() == before
-
-
 @pytest.mark.usefixtures("hass_history")
 def test_setup() -> None:
     """Test setup method of history."""
@@ -1600,28 +1571,7 @@ async def test_overflow_queue(
     """Test overflowing the history stream queue."""
     now = dt_util.utcnow()
     wanted_entities = ["sensor.two", "sensor.four", "sensor.one"]
-
-    unsub_calls = 0
-
-    def spy_track_state_change_event(*args: Any, **kwargs: Any) -> Callable[[], None]:
-        nonlocal unsub_calls
-        real_unsub = async_track_state_change_event(*args, **kwargs)
-
-        def wrapped_unsub() -> None:
-            nonlocal unsub_calls
-            unsub_calls += 1
-            real_unsub()
-
-        return wrapped_unsub
-
-    with (
-        patch.object(websocket_api, "MAX_PENDING_HISTORY_STATES", 5),
-        patch.object(
-            websocket_api,
-            "async_track_state_change_event",
-            spy_track_state_change_event,
-        ),
-    ):
+    with patch.object(websocket_api, "MAX_PENDING_HISTORY_STATES", 5):
         await async_setup_component(
             hass,
             "history",
@@ -1645,63 +1595,61 @@ async def test_overflow_queue(
         await async_wait_recording_done(hass)
 
         client = await hass_ws_client()
+        init_listeners = hass.bus.async_listeners()
 
-        with assert_no_listener_leak(hass):
-            await client.send_json(
-                {
-                    "id": 1,
-                    "type": "history/stream",
-                    "entity_ids": wanted_entities,
-                    "start_time": now.isoformat(),
-                    "include_start_time_state": True,
-                    "significant_changes_only": False,
-                    "no_attributes": True,
-                    "minimal_response": True,
-                }
-            )
-            response = await client.receive_json()
-            assert response["success"]
-            assert response["id"] == 1
-            assert response["type"] == "result"
-
-            response = await client.receive_json()
-            first_end_time = sensor_two_last_updated_timestamp
-
-            assert response == {
-                "event": {
-                    "end_time": pytest.approx(first_end_time),
-                    "start_time": pytest.approx(now.timestamp()),
-                    "states": {
-                        "sensor.one": [
-                            {
-                                "lu": pytest.approx(sensor_one_last_updated_timestamp),
-                                "s": "on",
-                            }
-                        ],
-                        "sensor.two": [
-                            {
-                                "lu": pytest.approx(sensor_two_last_updated_timestamp),
-                                "s": "off",
-                            }
-                        ],
-                    },
-                },
+        await client.send_json(
+            {
                 "id": 1,
-                "type": "event",
+                "type": "history/stream",
+                "entity_ids": wanted_entities,
+                "start_time": now.isoformat(),
+                "include_start_time_state": True,
+                "significant_changes_only": False,
+                "no_attributes": True,
+                "minimal_response": True,
             }
+        )
+        response = await client.receive_json()
+        assert response["success"]
+        assert response["id"] == 1
+        assert response["type"] == "result"
 
-            await async_recorder_block_till_done(hass)
-            # Overflow the queue
-            for val in range(10):
-                hass.states.async_set(
-                    "sensor.one", str(val), attributes={"any": "attr"}
-                )
-                hass.states.async_set(
-                    "sensor.two", str(val), attributes={"any": "attr"}
-                )
-            await async_recorder_block_till_done(hass)
+        response = await client.receive_json()
+        first_end_time = sensor_two_last_updated_timestamp
 
-    assert unsub_calls == 1
+        assert response == {
+            "event": {
+                "end_time": pytest.approx(first_end_time),
+                "start_time": pytest.approx(now.timestamp()),
+                "states": {
+                    "sensor.one": [
+                        {
+                            "lu": pytest.approx(sensor_one_last_updated_timestamp),
+                            "s": "on",
+                        }
+                    ],
+                    "sensor.two": [
+                        {
+                            "lu": pytest.approx(sensor_two_last_updated_timestamp),
+                            "s": "off",
+                        }
+                    ],
+                },
+            },
+            "id": 1,
+            "type": "event",
+        }
+
+        await async_recorder_block_till_done(hass)
+        # Overflow the queue
+        for val in range(10):
+            hass.states.async_set("sensor.one", str(val), attributes={"any": "attr"})
+            hass.states.async_set("sensor.two", str(val), attributes={"any": "attr"})
+        await async_recorder_block_till_done(hass)
+
+    assert listeners_without_writes(
+        hass.bus.async_listeners()
+    ) == listeners_without_writes(init_listeners)
 
 
 @pytest.mark.usefixtures("recorder_mock")