Improve query; change state class

homeassistant/components/github/coordinator.py

@@ -78,6 +78,12 @@ query ($owner: String!, $repository: String!) {
         number
       }
     }
+    merged_pull_request: pullRequests(
+      first:1
+      states: MERGED
+    ) {
+      total: totalCount
+    }
     release: latestRelease {
       name
       url

homeassistant/components/github/icons.json

@@ -28,6 +28,9 @@
       "latest_tag": {
         "default": "mdi:tag"
       },
+      "merged_pulls_count": {
+        "default": "mdi:source-merge"
+      },
       "pulls_count": {
         "default": "mdi:source-pull"
       },

homeassistant/components/github/sensor.py

@@ -75,6 +75,13 @@ SENSOR_DESCRIPTIONS: tuple[GitHubSensorEntityDescription, ...] = (
         state_class=SensorStateClass.MEASUREMENT,
         value_fn=lambda data: data["pull_request"]["total"],
     ),
+    GitHubSensorEntityDescription(
+        key="merged_pulls_count",
+        translation_key="merged_pulls_count",
+        entity_category=EntityCategory.DIAGNOSTIC,
+        state_class=SensorStateClass.TOTAL,
+        value_fn=lambda data: data["merged_pull_request"]["total"],
+    ),
     GitHubSensorEntityDescription(
         key="latest_commit",
         translation_key="latest_commit",

homeassistant/components/github/strings.json

@@ -48,6 +48,10 @@
       "latest_tag": {
         "name": "Latest tag"
       },
+      "merged_pulls_count": {
+        "name": "Merged pull requests",
+        "unit_of_measurement": "pull requests"
+      },
       "pulls_count": {
         "name": "Pull requests",
         "unit_of_measurement": "pull requests"

homeassistant/components/smartthings/icons.json

@@ -177,6 +177,12 @@
           "on": "mdi:lightbulb-on"
         }
       },
+      "do_not_disturb": {
+        "default": "mdi:minus-circle-off",
+        "state": {
+          "on": "mdi:minus-circle"
+        }
+      },
       "dry_plus": {
         "default": "mdi:heat-wave"
       },

homeassistant/components/smartthings/manifest.json

@@ -34,5 +34,5 @@
   "iot_class": "cloud_push",
   "loggers": ["pysmartthings"],
   "quality_scale": "bronze",
-  "requirements": ["pysmartthings==3.5.3"]
+  "requirements": ["pysmartthings==3.6.0"]
 }

homeassistant/components/smartthings/strings.json

@@ -859,6 +859,9 @@
       "display_lighting": {
         "name": "Display lighting"
       },
+      "do_not_disturb": {
+        "name": "Do not disturb"
+      },
       "dry_plus": {
         "name": "Dry plus"
       },

homeassistant/components/smartthings/switch.py

@@ -162,6 +162,14 @@ CAPABILITY_TO_SWITCHES: dict[Capability | str, SmartThingsSwitchEntityDescriptio
         status_attribute=Attribute.STATUS,
         entity_category=EntityCategory.CONFIG,
     ),
+    Capability.CUSTOM_DO_NOT_DISTURB_MODE: SmartThingsSwitchEntityDescription(
+        key=Capability.CUSTOM_DO_NOT_DISTURB_MODE,
+        translation_key="do_not_disturb",
+        status_attribute=Attribute.DO_NOT_DISTURB,
+        entity_category=EntityCategory.CONFIG,
+        on_command=Command.DO_NOT_DISTURB_ON,
+        off_command=Command.DO_NOT_DISTURB_OFF,
+    ),
 }
 DISHWASHER_WASHING_OPTIONS_TO_SWITCHES: dict[
     Attribute | str, SmartThingsDishwasherWashingOptionSwitchEntityDescription

requirements_all.txt

@@ -2476,7 +2476,7 @@ pysmappee==0.2.29
 pysmarlaapi==1.0.1
 
 # homeassistant.components.smartthings
-pysmartthings==3.5.3
+pysmartthings==3.6.0
 
 # homeassistant.components.smarty
 pysmarty2==0.10.3

requirements_test_all.txt

@@ -2108,7 +2108,7 @@ pysmappee==0.2.29
 pysmarlaapi==1.0.1
 
 # homeassistant.components.smartthings
-pysmartthings==3.5.3
+pysmartthings==3.6.0
 
 # homeassistant.components.smarty
 pysmarty2==0.10.3

tests/components/arcam_fmj/test_config_flow.py

@@ -70,6 +70,15 @@ def dummy_client_fixture() -> Generator[MagicMock]:
         yield client.return_value
 
 
+@pytest.fixture(autouse=True)
+def mock_setup_entry() -> Generator[AsyncMock]:
+    """Override async_setup_entry."""
+    with patch(
+        "homeassistant.components.arcam_fmj.async_setup_entry", return_value=True
+    ) as mock_setup:
+        yield mock_setup
+
+
 async def test_ssdp(hass: HomeAssistant) -> None:
     """Test a ssdp import flow."""
     result = await hass.config_entries.flow.async_init(

tests/components/axis/test_init.py

@@ -19,18 +19,16 @@ async def test_setup_entry(config_entry_setup: MockConfigEntry) -> None:
 async def test_setup_entry_fails(
     hass: HomeAssistant, config_entry: MockConfigEntry
 ) -> None:
-    """Test successful setup of entry."""
+    """Test failed setup of entry."""
     config_entry.add_to_hass(hass)
 
-    mock_device = Mock()
-    mock_device.async_setup = AsyncMock(return_value=False)
+    with patch(
+        "homeassistant.components.axis.get_axis_api",
+        side_effect=axis.CannotConnect,
+    ):
+        await hass.config_entries.async_setup(config_entry.entry_id)
 
-    with patch.object(axis, "AxisHub") as mock_device_class:
-        mock_device_class.return_value = mock_device
-
-        assert not await hass.config_entries.async_setup(config_entry.entry_id)
-
-    assert config_entry.state is ConfigEntryState.SETUP_ERROR
+    assert config_entry.state is ConfigEntryState.SETUP_RETRY
 
 
 async def test_unload_entry(

tests/components/ccm15/test_config_flow.py

@@ -79,7 +79,9 @@ async def test_form_invalid_host(
     assert result2["type"] is FlowResultType.CREATE_ENTRY
 
 
-async def test_form_cannot_connect(hass: HomeAssistant) -> None:
+async def test_form_cannot_connect(
+    hass: HomeAssistant, mock_setup_entry: AsyncMock
+) -> None:
     """Test we handle cannot connect error."""
     result = await hass.config_entries.flow.async_init(
         DOMAIN, context={"source": config_entries.SOURCE_USER}
@@ -111,7 +113,9 @@ async def test_form_cannot_connect(hass: HomeAssistant) -> None:
     assert result2["type"] is FlowResultType.CREATE_ENTRY
 
 
-async def test_form_unexpected_error(hass: HomeAssistant) -> None:
+async def test_form_unexpected_error(
+    hass: HomeAssistant, mock_setup_entry: AsyncMock
+) -> None:
     """Test we handle cannot connect error."""
     result = await hass.config_entries.flow.async_init(
         DOMAIN, context={"source": config_entries.SOURCE_USER}

tests/components/daikin/test_config_flow.py

@@ -1,7 +1,8 @@
 """Tests for the Daikin config flow."""
 
+from collections.abc import Generator
 from ipaddress import ip_address
-from unittest.mock import PropertyMock, patch
+from unittest.mock import AsyncMock, PropertyMock, patch
 
 from aiohttp import ClientError, web_exceptions
 from pydaikin.exceptions import DaikinException
@@ -20,6 +21,15 @@ MAC = "AABBCCDDEEFF"
 HOST = "127.0.0.1"
 
 
+@pytest.fixture(autouse=True)
+def mock_setup_entry() -> Generator[AsyncMock]:
+    """Override async_setup_entry."""
+    with patch(
+        "homeassistant.components.daikin.async_setup_entry", return_value=True
+    ) as mock_setup:
+        yield mock_setup
+
+
 @pytest.fixture
 def mock_daikin():
     """Mock pydaikin."""

tests/components/elkm1/test_config_flow.py

@@ -849,15 +849,19 @@ async def test_unknown_exception(hass: HomeAssistant) -> None:
 
 async def test_form_invalid_auth(hass: HomeAssistant) -> None:
     """Test we handle invalid auth error."""
-    result = await hass.config_entries.flow.async_init(
-        DOMAIN, context={"source": config_entries.SOURCE_USER}
-    )
+    with _patch_discovery(no_device=True):
+        result = await hass.config_entries.flow.async_init(
+            DOMAIN, context={"source": config_entries.SOURCE_USER}
+        )
 
     mocked_elk = mock_elk(invalid_auth=True, sync_complete=True)
 
-    with patch(
-        "homeassistant.components.elkm1.config_flow.Elk",
-        return_value=mocked_elk,
+    with (
+        _patch_discovery(no_device=True),
+        patch(
+            "homeassistant.components.elkm1.config_flow.Elk",
+            return_value=mocked_elk,
+        ),
     ):
         result2 = await hass.config_entries.flow.async_configure(
             result["flow_id"],
@@ -914,15 +918,19 @@ async def test_form_invalid_auth(hass: HomeAssistant) -> None:
 
 async def test_form_invalid_auth_no_password(hass: HomeAssistant) -> None:
     """Test we handle invalid auth error when no password is provided."""
-    result = await hass.config_entries.flow.async_init(
-        DOMAIN, context={"source": config_entries.SOURCE_USER}
-    )
+    with _patch_discovery(no_device=True):
+        result = await hass.config_entries.flow.async_init(
+            DOMAIN, context={"source": config_entries.SOURCE_USER}
+        )
 
     mocked_elk = mock_elk(invalid_auth=True, sync_complete=True)
 
-    with patch(
-        "homeassistant.components.elkm1.config_flow.Elk",
-        return_value=mocked_elk,
+    with (
+        _patch_discovery(no_device=True),
+        patch(
+            "homeassistant.components.elkm1.config_flow.Elk",
+            return_value=mocked_elk,
+        ),
     ):
         result2 = await hass.config_entries.flow.async_configure(
             result["flow_id"],
@@ -1991,6 +1999,7 @@ async def test_reconfigure_nonsecure(
     mocked_elk = mock_elk(invalid_auth=False, sync_complete=True)
 
     with (
+        _patch_discovery(no_device=True),
         _patch_elk(mocked_elk),
         patch(
             "homeassistant.components.elkm1.async_setup_entry",

tests/components/emulated_roku/test_config_flow.py

@@ -1,5 +1,10 @@
 """Tests for emulated_roku config flow."""
 
+from collections.abc import Generator
+from unittest.mock import AsyncMock, patch
+
+import pytest
+
 from homeassistant import config_entries
 from homeassistant.components.emulated_roku import config_flow
 from homeassistant.core import HomeAssistant
@@ -8,6 +13,15 @@ from homeassistant.data_entry_flow import FlowResultType
 from tests.common import MockConfigEntry
 
 
+@pytest.fixture(autouse=True)
+def mock_setup_entry() -> Generator[AsyncMock]:
+    """Override async_setup_entry."""
+    with patch(
+        "homeassistant.components.emulated_roku.async_setup_entry", return_value=True
+    ) as mock_setup:
+        yield mock_setup
+
+
 async def test_flow_works(hass: HomeAssistant) -> None:
     """Test that config flow works."""
     result = await hass.config_entries.flow.async_init(

tests/components/forked_daapd/test_config_flow.py

@@ -76,6 +76,10 @@ async def test_config_flow(hass: HomeAssistant, config_entry: MockConfigEntry) -
             "homeassistant.components.forked_daapd.ForkedDaapdAPI.get_request",
             autospec=True,
         ) as mock_get_request,
+        patch(
+            "homeassistant.components.forked_daapd.async_setup_entry",
+            return_value=True,
+        ),
     ):
         mock_get_request.return_value = SAMPLE_CONFIG
         mock_test_connection.return_value = ["ok", "My Music on myhost"]
@@ -229,10 +233,16 @@ async def test_config_flow_zeroconf_valid(hass: HomeAssistant) -> None:
 async def test_options_flow(hass: HomeAssistant, config_entry: MockConfigEntry) -> None:
     """Test config flow options."""
 
-    with patch(
-        "homeassistant.components.forked_daapd.ForkedDaapdAPI.get_request",
-        autospec=True,
-    ) as mock_get_request:
+    with (
+        patch(
+            "homeassistant.components.forked_daapd.ForkedDaapdAPI.get_request",
+            autospec=True,
+        ) as mock_get_request,
+        patch(
+            "homeassistant.components.forked_daapd.async_setup_entry",
+            return_value=True,
+        ),
+    ):
         mock_get_request.return_value = SAMPLE_CONFIG
         config_entry.add_to_hass(hass)
         await hass.config_entries.async_setup(config_entry.entry_id)

tests/components/fully_kiosk/test_config_flow.py

@@ -168,6 +168,7 @@ async def test_duplicate_updates_existing_entry(
 async def test_dhcp_discovery_updates_entry(
     hass: HomeAssistant,
     mock_config_entry: MockConfigEntry,
+    mock_setup_entry: AsyncMock,
 ) -> None:
     """Test DHCP discovery updates config entries."""
     mock_config_entry.add_to_hass(hass)

tests/components/github/fixtures/graphql.json

@@ -49,6 +49,9 @@
           }
         ]
       },
+      "merged_pull_request": {
+        "total": 42
+      },
       "release": {
         "name": "v1.0.0",
         "url": "https://github.com/octocat/Hello-World/releases/v1.0.0",

tests/components/home_connect/test_init.py

@@ -336,7 +336,13 @@ async def test_entity_migration(
             config_entry=config_entry_v1_1,
         )
 
-    with patch("homeassistant.components.home_connect.PLATFORMS", platforms):
+    with (
+        patch("homeassistant.components.home_connect.PLATFORMS", platforms),
+        patch(
+            "homeassistant.components.home_connect.async_setup_entry",
+            return_value=True,
+        ),
+    ):
         await hass.config_entries.async_setup(config_entry_v1_1.entry_id)
         await hass.async_block_till_done()
 
@@ -364,8 +370,12 @@ async def test_config_entry_unique_id_migration(
     assert config_entry_v1_2.unique_id != "1234567890"
     assert config_entry_v1_2.minor_version == 2
 
-    await hass.config_entries.async_setup(config_entry_v1_2.entry_id)
-    await hass.async_block_till_done()
+    with patch(
+        "homeassistant.components.home_connect.async_setup_entry",
+        return_value=True,
+    ):
+        await hass.config_entries.async_setup(config_entry_v1_2.entry_id)
+        await hass.async_block_till_done()
 
     assert config_entry_v1_2.unique_id == "1234567890"
     assert config_entry_v1_2.minor_version == 3

tests/components/homematic/test_notify.py

@@ -1,5 +1,7 @@
 """The tests for the Homematic notification platform."""
 
+from unittest.mock import MagicMock, patch
+
 from homeassistant.components.notify import DOMAIN as NOTIFY_DOMAIN
 from homeassistant.core import HomeAssistant
 from homeassistant.setup import async_setup_component
@@ -9,11 +11,15 @@ from tests.common import assert_setup_component
 
 async def test_setup_full(hass: HomeAssistant) -> None:
     """Test valid configuration."""
-    await async_setup_component(
-        hass,
-        "homematic",
-        {"homematic": {"hosts": {"ccu2": {"host": "127.0.0.1"}}}},
-    )
+    with patch(
+        "homeassistant.components.homematic.HMConnection",
+        return_value=MagicMock(),
+    ):
+        await async_setup_component(
+            hass,
+            "homematic",
+            {"homematic": {"hosts": {"ccu2": {"host": "127.0.0.1"}}}},
+        )
     with assert_setup_component(1, domain="notify") as handle_config:
         assert await async_setup_component(
             hass,
@@ -35,11 +41,15 @@ async def test_setup_full(hass: HomeAssistant) -> None:
 
 async def test_setup_without_optional(hass: HomeAssistant) -> None:
     """Test valid configuration without optional."""
-    await async_setup_component(
-        hass,
-        "homematic",
-        {"homematic": {"hosts": {"ccu2": {"host": "127.0.0.1"}}}},
-    )
+    with patch(
+        "homeassistant.components.homematic.HMConnection",
+        return_value=MagicMock(),
+    ):
+        await async_setup_component(
+            hass,
+            "homematic",
+            {"homematic": {"hosts": {"ccu2": {"host": "127.0.0.1"}}}},
+        )
     with assert_setup_component(1, domain="notify") as handle_config:
         assert await async_setup_component(
             hass,

tests/components/jvc_projector/conftest.py

@@ -136,6 +136,7 @@ def fixture_mock_config_entry() -> MockConfigEntry:
 async def fixture_mock_integration(
     hass: HomeAssistant,
     mock_config_entry: MockConfigEntry,
+    mock_device: MagicMock,
 ) -> MockConfigEntry:
     """Return a mock ConfigEntry setup for the integration."""
     with (

tests/components/jvc_projector/test_config_flow.py

@@ -1,6 +1,7 @@
 """Tests for JVC Projector config flow."""
 
-from unittest.mock import AsyncMock
+from collections.abc import Generator
+from unittest.mock import AsyncMock, patch
 
 from jvcprojector import JvcProjectorAuthError, JvcProjectorTimeoutError
 import pytest
@@ -18,6 +19,16 @@ from tests.common import MockConfigEntry
 TARGET = "homeassistant.components.jvc_projector.config_flow.JvcProjector"
 
 
+@pytest.fixture(autouse=True)
+def mock_setup_entry() -> Generator[AsyncMock]:
+    """Override async_setup_entry."""
+    with patch(
+        "homeassistant.components.jvc_projector.async_setup_entry",
+        return_value=True,
+    ) as mock_setup_entry:
+        yield mock_setup_entry
+
+
 @pytest.mark.parametrize("mock_device", [{"target": TARGET}], indirect=True)
 async def test_user_config_flow_success(
     hass: HomeAssistant, mock_device: AsyncMock

tests/components/kostal_plenticore/test_config_flow.py

@@ -400,14 +400,18 @@ async def test_reconfigure(
         return_value={"scb:network": {"Hostname": "scb"}}
     )
 
-    result = await hass.config_entries.flow.async_configure(
-        result["flow_id"],
-        {
-            "host": "1.1.1.1",
-            "password": "test-password",
-        },
-    )
-    await hass.async_block_till_done()
+    with patch(
+        "homeassistant.components.kostal_plenticore.async_setup_entry",
+        return_value=True,
+    ):
+        result = await hass.config_entries.flow.async_configure(
+            result["flow_id"],
+            {
+                "host": "1.1.1.1",
+                "password": "test-password",
+            },
+        )
+        await hass.async_block_till_done()
 
     mock_apiclient_class.assert_called_once_with(ANY, "1.1.1.1")
     mock_apiclient.__aenter__.assert_called_once()

tests/components/lametric/test_config_flow.py

@@ -1,7 +1,7 @@
 """Tests for the LaMetric config flow."""
 
 from http import HTTPStatus
-from unittest.mock import MagicMock
+from unittest.mock import AsyncMock, MagicMock
 
 from demetriek import (
     LaMetricConnectionError,
@@ -686,6 +686,7 @@ async def test_cloud_errors(
 async def test_dhcp_discovery_updates_entry(
     hass: HomeAssistant,
     mock_config_entry: MockConfigEntry,
+    mock_setup_entry: AsyncMock,
 ) -> None:
     """Test DHCP discovery updates config entries."""
     mock_config_entry.add_to_hass(hass)

tests/components/lunatone/test_config_flow.py

@@ -90,6 +90,7 @@ async def test_device_already_configured(
 async def test_user_step_fail_with_error(
     hass: HomeAssistant,
     mock_lunatone_info: AsyncMock,
+    mock_setup_entry: AsyncMock,
     exception: Exception,
     expected_error: str,
 ) -> None:
@@ -124,6 +125,7 @@ async def test_user_step_fail_with_error(
 async def test_reconfigure(
     hass: HomeAssistant,
     mock_lunatone_info: AsyncMock,
+    mock_setup_entry: AsyncMock,
     mock_config_entry: MockConfigEntry,
 ) -> None:
     """Test reconfigure flow."""
@@ -153,6 +155,7 @@ async def test_reconfigure(
 async def test_reconfigure_fail_with_error(
     hass: HomeAssistant,
     mock_lunatone_info: AsyncMock,
+    mock_setup_entry: AsyncMock,
     mock_config_entry: MockConfigEntry,
     exception: Exception,
     expected_error: str,

tests/components/madvr/snapshots/test_remote.ambr

@@ -46,6 +46,6 @@
     'last_changed': <ANY>,
     'last_reported': <ANY>,
     'last_updated': <ANY>,
-    'state': 'off',
+    'state': 'on',
   })
 # ---

tests/components/madvr/test_binary_sensor.py

@@ -20,6 +20,7 @@ from tests.common import MockConfigEntry, snapshot_platform
 async def test_binary_sensor_setup(
     hass: HomeAssistant,
     snapshot: SnapshotAssertion,
+    mock_madvr_client: AsyncMock,
     mock_config_entry: MockConfigEntry,
     entity_registry: er.EntityRegistry,
 ) -> None:

tests/components/madvr/test_remote.py

@@ -38,6 +38,7 @@ from tests.common import MockConfigEntry, snapshot_platform
 async def test_remote_setup(
     hass: HomeAssistant,
     snapshot: SnapshotAssertion,
+    mock_madvr_client: AsyncMock,
     mock_config_entry: MockConfigEntry,
     entity_registry: er.EntityRegistry,
 ) -> None:

tests/components/metoffice/conftest.py

@@ -9,7 +9,9 @@ import pytest
 @pytest.fixture
 def mock_simple_manager_fail():
     """Mock datapoint Manager with default values for testing in config_flow."""
-    with patch("datapoint.Manager.Manager") as mock_manager:
+    with patch(
+        "homeassistant.components.metoffice.config_flow.Manager"
+    ) as mock_manager:
         instance = mock_manager.return_value
         instance.get_forecast = APIException()
         instance.latitude = None

tests/components/mochad/conftest.py

@@ -1,3 +1,14 @@
 """mochad conftest."""
 
+from unittest import mock
+
+import pytest
+
 from tests.components.light.conftest import mock_light_profiles  # noqa: F401
+
+
+@pytest.fixture(autouse=True)
+def mock_pymochad_controller():
+    """Mock pymochad controller to prevent real socket connections."""
+    with mock.patch("homeassistant.components.mochad.controller.PyMochad"):
+        yield

tests/components/onvif/test_config_flow.py

@@ -687,10 +687,11 @@ async def test_discovered_by_dhcp_updates_host(
     assert config_entry.data[CONF_HOST] == "1.2.3.4"
     await hass.config_entries.async_unload(config_entry.entry_id)
 
-    result = await hass.config_entries.flow.async_init(
-        DOMAIN, context={"source": SOURCE_DHCP}, data=DHCP_DISCOVERY
-    )
-    await hass.async_block_till_done()
+    with patch("homeassistant.components.onvif.async_setup_entry", return_value=True):
+        result = await hass.config_entries.flow.async_init(
+            DOMAIN, context={"source": SOURCE_DHCP}, data=DHCP_DISCOVERY
+        )
+        await hass.async_block_till_done()
 
     assert result["type"] is FlowResultType.ABORT
     assert result["reason"] == "already_configured"

tests/components/panasonic_viera/test_config_flow.py

@@ -1,8 +1,10 @@
 """Test the Panasonic Viera config flow."""
 
-from unittest.mock import patch
+from collections.abc import Generator
+from unittest.mock import AsyncMock, patch
 
 from panasonic_viera import SOAPError
+import pytest
 
 from homeassistant import config_entries
 from homeassistant.components.panasonic_viera.const import (
@@ -26,6 +28,16 @@ from .conftest import (
 from tests.common import MockConfigEntry
 
 
+@pytest.fixture(autouse=True)
+def mock_setup_entry() -> Generator[AsyncMock]:
+    """Mock setting up a config entry."""
+    with patch(
+        "homeassistant.components.panasonic_viera.async_setup_entry",
+        return_value=True,
+    ) as mock_setup:
+        yield mock_setup
+
+
 async def test_flow_non_encrypted(hass: HomeAssistant) -> None:
     """Test flow without encryption."""
 

tests/components/radarr/test_config_flow.py

@@ -122,9 +122,12 @@ async def test_unknown_error(hass: HomeAssistant) -> None:
 
 async def test_zero_conf(hass: HomeAssistant) -> None:
     """Test the manual flow for zero config."""
-    with patch(
-        "homeassistant.components.radarr.config_flow.RadarrClient.async_try_zeroconf",
-        return_value=("v3", API_KEY, "/test"),
+    with (
+        patch(
+            "homeassistant.components.radarr.config_flow.RadarrClient.async_try_zeroconf",
+            return_value=("v3", API_KEY, "/test"),
+        ),
+        patch_async_setup_entry(),
     ):
         result = await hass.config_entries.flow.async_init(
             DOMAIN,
@@ -139,9 +142,12 @@ async def test_zero_conf(hass: HomeAssistant) -> None:
 
 async def test_url_rewrite(hass: HomeAssistant) -> None:
     """Test auth flow url rewrite."""
-    with patch(
-        "homeassistant.components.radarr.config_flow.RadarrClient.async_try_zeroconf",
-        return_value=("v3", API_KEY, "/test"),
+    with (
+        patch(
+            "homeassistant.components.radarr.config_flow.RadarrClient.async_try_zeroconf",
+            return_value=("v3", API_KEY, "/test"),
+        ),
+        patch_async_setup_entry(),
     ):
         result = await hass.config_entries.flow.async_init(
             DOMAIN,

tests/components/roku/test_config_flow.py

@@ -264,7 +264,9 @@ async def test_ssdp_discovery(
 
 
 async def test_options_flow(
-    hass: HomeAssistant, mock_config_entry: MockConfigEntry
+    hass: HomeAssistant,
+    mock_setup_entry: None,
+    mock_config_entry: MockConfigEntry,
 ) -> None:
     """Test options config flow."""
     mock_config_entry.add_to_hass(hass)

tests/components/samsungtv/test_init.py

@@ -77,7 +77,7 @@ async def test_setup_h_j_model(
     assert "H and J series use an encrypted protocol" in caplog.text
 
 
-@pytest.mark.usefixtures("remote_websocket")
+@pytest.mark.usefixtures("remote_websocket", "rest_api")
 async def test_setup_updates_from_ssdp(hass: HomeAssistant) -> None:
     """Test setting up the entry fetches data from ssdp cache."""
     entry = MockConfigEntry(

tests/components/sharkiq/test_config_flow.py

@@ -31,7 +31,8 @@ async def test_setup_success_no_region(hass: HomeAssistant) -> None:
     )
     mock_config.add_to_hass(hass)
 
-    result = await async_setup_component(hass=hass, domain=DOMAIN, config={})
+    with patch("homeassistant.components.sharkiq.async_setup_entry", return_value=True):
+        result = await async_setup_component(hass=hass, domain=DOMAIN, config={})
 
     assert result is True
 

tests/components/sma/test_config_flow.py

@@ -149,7 +149,9 @@ async def test_dhcp_discovery(
 
 
 async def test_dhcp_already_configured(
-    hass: HomeAssistant, mock_config_entry: MockConfigEntry
+    hass: HomeAssistant,
+    mock_config_entry: MockConfigEntry,
+    mock_setup_entry: AsyncMock,
 ) -> None:
     """Test starting a flow by dhcp when already configured."""
     mock_config_entry.add_to_hass(hass)
@@ -162,7 +164,9 @@ async def test_dhcp_already_configured(
 
 
 async def test_dhcp_already_configured_duplicate(
-    hass: HomeAssistant, mock_config_entry: MockConfigEntry
+    hass: HomeAssistant,
+    mock_config_entry: MockConfigEntry,
+    mock_sma_client: MagicMock,
 ) -> None:
     """Test starting a flow by DHCP when already configured and MAC is added."""
     mock_config_entry.add_to_hass(hass)
@@ -280,6 +284,7 @@ async def test_full_flow_reauth(
 async def test_reauth_flow_exceptions(
     hass: HomeAssistant,
     mock_config_entry: MockConfigEntry,
+    mock_setup_entry: AsyncMock,
     exception: Exception,
     error: str,
 ) -> None:

tests/components/smartthings/snapshots/test_switch.ambr

@@ -244,6 +244,55 @@
     'state': 'on',
   })
 # ---
+# name: test_all_entities[da_ks_hood_01001][switch.range_hood_do_not_disturb-entry]
+  EntityRegistryEntrySnapshot({
+    'aliases': set({
+    }),
+    'area_id': None,
+    'capabilities': None,
+    'config_entry_id': <ANY>,
+    'config_subentry_id': <ANY>,
+    'device_class': None,
+    'device_id': <ANY>,
+    'disabled_by': None,
+    'domain': 'switch',
+    'entity_category': <EntityCategory.CONFIG: 'config'>,
+    'entity_id': 'switch.range_hood_do_not_disturb',
+    'has_entity_name': True,
+    'hidden_by': None,
+    'icon': None,
+    'id': <ANY>,
+    'labels': set({
+    }),
+    'name': None,
+    'object_id_base': 'Do not disturb',
+    'options': dict({
+    }),
+    'original_device_class': None,
+    'original_icon': None,
+    'original_name': 'Do not disturb',
+    'platform': 'smartthings',
+    'previous_unique_id': None,
+    'suggested_object_id': None,
+    'supported_features': 0,
+    'translation_key': 'do_not_disturb',
+    'unique_id': 'fa5fca25-fa7a-1807-030a-2f72ee0f7bff_main_custom.doNotDisturbMode_doNotDisturb_doNotDisturb',
+    'unit_of_measurement': None,
+  })
+# ---
+# name: test_all_entities[da_ks_hood_01001][switch.range_hood_do_not_disturb-state]
+  StateSnapshot({
+    'attributes': ReadOnlyDict({
+      'friendly_name': 'Range hood Do not disturb',
+    }),
+    'context': <ANY>,
+    'entity_id': 'switch.range_hood_do_not_disturb',
+    'last_changed': <ANY>,
+    'last_reported': <ANY>,
+    'last_updated': <ANY>,
+    'state': 'off',
+  })
+# ---
 # name: test_all_entities[da_ks_walloven_0107x][switch.four_sabbath_mode-entry]
   EntityRegistryEntrySnapshot({
     'aliases': set({
@@ -979,6 +1028,55 @@
     'state': 'on',
   })
 # ---
+# name: test_all_entities[da_rvc_map_01011][switch.robot_vacuum_do_not_disturb-entry]
+  EntityRegistryEntrySnapshot({
+    'aliases': set({
+    }),
+    'area_id': None,
+    'capabilities': None,
+    'config_entry_id': <ANY>,
+    'config_subentry_id': <ANY>,
+    'device_class': None,
+    'device_id': <ANY>,
+    'disabled_by': None,
+    'domain': 'switch',
+    'entity_category': <EntityCategory.CONFIG: 'config'>,
+    'entity_id': 'switch.robot_vacuum_do_not_disturb',
+    'has_entity_name': True,
+    'hidden_by': None,
+    'icon': None,
+    'id': <ANY>,
+    'labels': set({
+    }),
+    'name': None,
+    'object_id_base': 'Do not disturb',
+    'options': dict({
+    }),
+    'original_device_class': None,
+    'original_icon': None,
+    'original_name': 'Do not disturb',
+    'platform': 'smartthings',
+    'previous_unique_id': None,
+    'suggested_object_id': None,
+    'supported_features': 0,
+    'translation_key': 'do_not_disturb',
+    'unique_id': '05accb39-2017-c98b-a5ab-04a81f4d3d9a_main_custom.doNotDisturbMode_doNotDisturb_doNotDisturb',
+    'unit_of_measurement': None,
+  })
+# ---
+# name: test_all_entities[da_rvc_map_01011][switch.robot_vacuum_do_not_disturb-state]
+  StateSnapshot({
+    'attributes': ReadOnlyDict({
+      'friendly_name': 'Robot vacuum Do not disturb',
+    }),
+    'context': <ANY>,
+    'entity_id': 'switch.robot_vacuum_do_not_disturb',
+    'last_changed': <ANY>,
+    'last_reported': <ANY>,
+    'last_updated': <ANY>,
+    'state': 'off',
+  })
+# ---
 # name: test_all_entities[da_rvc_normal_000001][switch.robot_vacuum-entry]
   EntityRegistryEntrySnapshot({
     'aliases': set({

tests/components/speedtestdotnet/conftest.py

@@ -7,6 +7,16 @@ import pytest
 from . import MOCK_SERVERS
 
 
+@pytest.fixture
+def mock_setup_entry():
+    """Mock setting up a config entry."""
+    with patch(
+        "homeassistant.components.speedtestdotnet.async_setup_entry",
+        return_value=True,
+    ) as mock_setup:
+        yield mock_setup
+
+
 @pytest.fixture
 def mock_api():
     """Mock entry setup."""

tests/components/speedtestdotnet/test_config_flow.py

@@ -14,7 +14,7 @@ from homeassistant.data_entry_flow import FlowResultType
 from tests.common import MockConfigEntry
 
 
-async def test_flow_works(hass: HomeAssistant) -> None:
+async def test_flow_works(hass: HomeAssistant, mock_setup_entry: MagicMock) -> None:
     """Test user config."""
     result = await hass.config_entries.flow.async_init(
         DOMAIN, context={"source": config_entries.SOURCE_USER}

tests/components/tautulli/test_config_flow.py

@@ -25,12 +25,15 @@ async def test_flow_user(hass: HomeAssistant) -> None:
     assert result["step_id"] == "user"
     assert result["errors"] == {}
 
-    with patch_config_flow_tautulli(AsyncMock()):
+    with (
+        patch_config_flow_tautulli(AsyncMock()),
+        patch("homeassistant.components.tautulli.async_setup_entry", return_value=True),
+    ):
         result2 = await hass.config_entries.flow.async_configure(
             result["flow_id"],
             user_input=CONF_DATA,
         )
-    await hass.async_block_till_done()
+        await hass.async_block_till_done()
 
     assert result2["type"] is FlowResultType.CREATE_ENTRY
     assert result2["title"] == NAME
@@ -48,12 +51,15 @@ async def test_flow_user_cannot_connect(hass: HomeAssistant) -> None:
     assert result["step_id"] == "user"
     assert result["errors"]["base"] == "cannot_connect"
 
-    with patch_config_flow_tautulli(AsyncMock()):
+    with (
+        patch_config_flow_tautulli(AsyncMock()),
+        patch("homeassistant.components.tautulli.async_setup_entry", return_value=True),
+    ):
         result2 = await hass.config_entries.flow.async_configure(
             result["flow_id"],
             user_input=CONF_DATA,
         )
-    await hass.async_block_till_done()
+        await hass.async_block_till_done()
 
     assert result2["type"] is FlowResultType.CREATE_ENTRY
     assert result2["title"] == NAME
@@ -71,12 +77,15 @@ async def test_flow_user_invalid_auth(hass: HomeAssistant) -> None:
     assert result["step_id"] == "user"
     assert result["errors"]["base"] == "invalid_auth"
 
-    with patch_config_flow_tautulli(AsyncMock()):
+    with (
+        patch_config_flow_tautulli(AsyncMock()),
+        patch("homeassistant.components.tautulli.async_setup_entry", return_value=True),
+    ):
         result2 = await hass.config_entries.flow.async_configure(
             result["flow_id"],
             user_input=CONF_DATA,
         )
-    await hass.async_block_till_done()
+        await hass.async_block_till_done()
 
     assert result2["type"] is FlowResultType.CREATE_ENTRY
     assert result2["title"] == NAME
@@ -94,12 +103,15 @@ async def test_flow_user_unknown_error(hass: HomeAssistant) -> None:
         assert result["step_id"] == "user"
         assert result["errors"]["base"] == "unknown"
 
-    with patch_config_flow_tautulli(AsyncMock()):
+    with (
+        patch_config_flow_tautulli(AsyncMock()),
+        patch("homeassistant.components.tautulli.async_setup_entry", return_value=True),
+    ):
         result2 = await hass.config_entries.flow.async_configure(
             result["flow_id"],
             user_input=CONF_DATA,
         )
-    await hass.async_block_till_done()
+        await hass.async_block_till_done()
 
     assert result2["type"] is FlowResultType.CREATE_ENTRY
     assert result2["title"] == NAME
@@ -138,12 +150,15 @@ async def test_flow_user_multiple_entries_allowed(hass: HomeAssistant) -> None:
         CONF_API_KEY: "efgh",
         CONF_VERIFY_SSL: True,
     }
-    with patch_config_flow_tautulli(AsyncMock()):
+    with (
+        patch_config_flow_tautulli(AsyncMock()),
+        patch("homeassistant.components.tautulli.async_setup_entry", return_value=True),
+    ):
         result2 = await hass.config_entries.flow.async_configure(
             result["flow_id"],
             user_input=user_input,
         )
-    await hass.async_block_till_done()
+        await hass.async_block_till_done()
 
     assert result2["type"] is FlowResultType.CREATE_ENTRY
     assert result2["title"] == NAME

tests/components/todoist/test_calendar.py

@@ -183,18 +183,21 @@ async def test_failed_coordinator_update(hass: HomeAssistant, api: AsyncMock) ->
     """Test a failed data coordinator update is handled correctly."""
     api.get_tasks.side_effect = Exception("API error")
 
-    assert await setup.async_setup_component(
-        hass,
-        "calendar",
-        {
-            "calendar": {
-                "platform": DOMAIN,
-                CONF_TOKEN: "token",
-                "custom_projects": [{"name": "All projects", "labels": ["Label1"]}],
-            }
-        },
-    )
-    await hass.async_block_till_done()
+    with patch(
+        "homeassistant.components.todoist.calendar.TodoistAPIAsync", return_value=api
+    ):
+        assert await setup.async_setup_component(
+            hass,
+            "calendar",
+            {
+                "calendar": {
+                    "platform": DOMAIN,
+                    CONF_TOKEN: "token",
+                    "custom_projects": [{"name": "All projects", "labels": ["Label1"]}],
+                }
+            },
+        )
+        await hass.async_block_till_done()
 
     await async_update_entity(hass, "calendar.all_projects")
     state = hass.states.get("calendar.all_projects")

tests/components/tplink_omada/test_services.py

@@ -57,6 +57,8 @@ async def test_service_reconnect_client(
 
 async def test_service_reconnect_failed_with_invalid_entry(
     hass: HomeAssistant,
+    mock_omada_site_client: MagicMock,
+    mock_omada_client: MagicMock,
     mock_config_entry: MockConfigEntry,
 ) -> None:
     """Test reconnect with invalid config entry raises ServiceValidationError."""
@@ -102,6 +104,8 @@ async def test_service_reconnect_without_config_entry_id(
 
 async def test_service_reconnect_entry_not_loaded(
     hass: HomeAssistant,
+    mock_omada_site_client: MagicMock,
+    mock_omada_client: MagicMock,
     mock_config_entry: MockConfigEntry,
 ) -> None:
     """Test reconnect service raises error when entry is not loaded."""

tests/components/transmission/test_init.py

@@ -30,6 +30,7 @@ from tests.common import MockConfigEntry, async_fire_time_changed
 
 async def test_config_flow_entry_migrate_1_1_to_1_2(
     hass: HomeAssistant,
+    mock_transmission_client: AsyncMock,
 ) -> None:
     """Test that config flow entry is migrated correctly from v1.1 to v1.2."""
     entry = MockConfigEntry(
@@ -150,6 +151,7 @@ async def test_unload_entry(
 )
 async def test_migrate_unique_id(
     hass: HomeAssistant,
+    mock_transmission_client: AsyncMock,
     entity_registry: er.EntityRegistry,
     domain: str,
     old_unique_id: str,

tests/components/unifiprotect/test_config_flow.py

@@ -523,6 +523,10 @@ async def test_form_reauth_auth(
             "homeassistant.components.unifiprotect.async_setup",
             return_value=True,
         ) as mock_setup,
+        patch(
+            "homeassistant.components.unifiprotect.async_setup_entry",
+            return_value=True,
+        ),
         patch(
             "homeassistant.components.unifiprotect.config_flow.ProtectApiClient.get_meta_info",
             return_value=None,
@@ -1917,9 +1921,15 @@ async def test_reauth_empty_credentials_keeps_existing(
 
     nvr.mac = _async_unifi_mac_from_hass(MAC_ADDR)
     bootstrap.nvr = nvr
-    with patch(
-        "homeassistant.components.unifiprotect.async_setup",
-        return_value=True,
+    with (
+        patch(
+            "homeassistant.components.unifiprotect.async_setup",
+            return_value=True,
+        ),
+        patch(
+            "homeassistant.components.unifiprotect.async_setup_entry",
+            return_value=True,
+        ),
     ):
         # Submit with empty credentials - should keep existing
         result = await hass.config_entries.flow.async_configure(
@@ -2003,9 +2013,15 @@ async def test_reauth_credential_update(
 
     nvr.mac = _async_unifi_mac_from_hass(MAC_ADDR)
     bootstrap.nvr = nvr
-    with patch(
-        "homeassistant.components.unifiprotect.async_setup",
-        return_value=True,
+    with (
+        patch(
+            "homeassistant.components.unifiprotect.async_setup",
+            return_value=True,
+        ),
+        patch(
+            "homeassistant.components.unifiprotect.async_setup_entry",
+            return_value=True,
+        ),
     ):
         result = await hass.config_entries.flow.async_configure(
             result["flow_id"],

tests/components/velux/test_init.py

@@ -153,12 +153,9 @@ async def test_reboot_gateway_service_raises_on_exception(
 
 
 async def test_reboot_gateway_service_raises_validation_error(
-    hass: HomeAssistant, mock_config_entry: MockConfigEntry
+    hass: HomeAssistant,
 ) -> None:
     """Test that reboot_gateway service raises ServiceValidationError when no gateway is loaded."""
-    # Add the config entry but don't set it up
-    mock_config_entry.add_to_hass(hass)
-
     # Set up the velux integration's async_setup to register the service
     await async_setup_component(hass, DOMAIN, {})
     await hass.async_block_till_done()

tests/components/wilight/test_config_flow.py

@@ -159,9 +159,10 @@ async def test_full_ssdp_flow_implementation(hass: HomeAssistant) -> None:
         "components": "light",
     }
 
-    result = await hass.config_entries.flow.async_configure(
-        result["flow_id"], user_input={}
-    )
+    with patch("homeassistant.components.wilight.async_setup_entry", return_value=True):
+        result = await hass.config_entries.flow.async_configure(
+            result["flow_id"], user_input={}
+        )
 
     assert result["type"] is FlowResultType.CREATE_ENTRY
     assert result["title"] == f"WL{WILIGHT_ID}"

tests/components/youless/test_config_flows.py

@@ -33,10 +33,13 @@ async def test_full_flow(hass: HomeAssistant) -> None:
     mock_youless = _get_mock_youless_api(
         initialize={"homes": [{"id": 1, "name": "myhome"}]}
     )
-    with patch(
-        "homeassistant.components.youless.config_flow.YoulessAPI",
-        return_value=mock_youless,
-    ) as mocked_youless:
+    with (
+        patch(
+            "homeassistant.components.youless.config_flow.YoulessAPI",
+            return_value=mock_youless,
+        ) as mocked_youless,
+        patch("homeassistant.components.youless.async_setup_entry", return_value=True),
+    ):
         result2 = await hass.config_entries.flow.async_configure(
             result["flow_id"],
             {"host": "localhost"},