Add missing mock fixtures to telegram_bot polling init test

homeassistant/components/smartthings/icons.json

@@ -177,12 +177,6 @@
           "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/strings.json

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

homeassistant/components/smartthings/switch.py

@@ -162,14 +162,6 @@ 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

tests/components/axis/test_init.py

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

tests/components/daikin/test_config_flow.py

@@ -1,8 +1,7 @@
 """Tests for the Daikin config flow."""
 
-from collections.abc import Generator
 from ipaddress import ip_address
-from unittest.mock import AsyncMock, PropertyMock, patch
+from unittest.mock import PropertyMock, patch
 
 from aiohttp import ClientError, web_exceptions
 from pydaikin.exceptions import DaikinException
@@ -21,15 +20,6 @@ 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/emulated_roku/test_config_flow.py

@@ -1,10 +1,5 @@
 """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
@@ -13,15 +8,6 @@ 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,10 +76,6 @@ 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"]
@@ -233,16 +229,10 @@ 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,
-        patch(
-            "homeassistant.components.forked_daapd.async_setup_entry",
-            return_value=True,
-        ),
-    ):
+    with patch(
+        "homeassistant.components.forked_daapd.ForkedDaapdAPI.get_request",
+        autospec=True,
+    ) as mock_get_request:
         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/home_connect/test_init.py

@@ -336,13 +336,7 @@ async def test_entity_migration(
             config_entry=config_entry_v1_1,
         )
 
-    with (
-        patch("homeassistant.components.home_connect.PLATFORMS", platforms),
-        patch(
-            "homeassistant.components.home_connect.async_setup_entry",
-            return_value=True,
-        ),
-    ):
+    with patch("homeassistant.components.home_connect.PLATFORMS", platforms):
         await hass.config_entries.async_setup(config_entry_v1_1.entry_id)
         await hass.async_block_till_done()
 
@@ -370,12 +364,8 @@ async def test_config_entry_unique_id_migration(
     assert config_entry_v1_2.unique_id != "1234567890"
     assert config_entry_v1_2.minor_version == 2
 
-    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()
+    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,7 +1,5 @@
 """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
@@ -11,15 +9,11 @@ from tests.common import assert_setup_component
 
 async def test_setup_full(hass: HomeAssistant) -> None:
     """Test valid configuration."""
-    with patch(
-        "homeassistant.components.homematic.HMConnection",
-        return_value=MagicMock(),
-    ):
-        await async_setup_component(
-            hass,
-            "homematic",
-            {"homematic": {"hosts": {"ccu2": {"host": "127.0.0.1"}}}},
-        )
+    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,
@@ -41,15 +35,11 @@ async def test_setup_full(hass: HomeAssistant) -> None:
 
 async def test_setup_without_optional(hass: HomeAssistant) -> None:
     """Test valid configuration without optional."""
-    with patch(
-        "homeassistant.components.homematic.HMConnection",
-        return_value=MagicMock(),
-    ):
-        await async_setup_component(
-            hass,
-            "homematic",
-            {"homematic": {"hosts": {"ccu2": {"host": "127.0.0.1"}}}},
-        )
+    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,7 +136,6 @@ 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/kostal_plenticore/test_config_flow.py

@@ -400,18 +400,14 @@ async def test_reconfigure(
         return_value={"scb:network": {"Hostname": "scb"}}
     )
 
-    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()
+    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/lunatone/test_config_flow.py

@@ -90,7 +90,6 @@ 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:
@@ -125,7 +124,6 @@ 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."""
@@ -155,7 +153,6 @@ 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': 'on',
+    'state': 'off',
   })
 # ---

tests/components/madvr/test_binary_sensor.py

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

tests/components/onvif/test_config_flow.py

@@ -687,11 +687,10 @@ 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)
 
-    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()
+    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,10 +1,8 @@
 """Test the Panasonic Viera config flow."""
 
-from collections.abc import Generator
-from unittest.mock import AsyncMock, patch
+from unittest.mock import patch
 
 from panasonic_viera import SOAPError
-import pytest
 
 from homeassistant import config_entries
 from homeassistant.components.panasonic_viera.const import (
@@ -28,16 +26,6 @@ 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,12 +122,9 @@ 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"),
-        ),
-        patch_async_setup_entry(),
+    with patch(
+        "homeassistant.components.radarr.config_flow.RadarrClient.async_try_zeroconf",
+        return_value=("v3", API_KEY, "/test"),
     ):
         result = await hass.config_entries.flow.async_init(
             DOMAIN,
@@ -142,12 +139,9 @@ 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"),
-        ),
-        patch_async_setup_entry(),
+    with patch(
+        "homeassistant.components.radarr.config_flow.RadarrClient.async_try_zeroconf",
+        return_value=("v3", API_KEY, "/test"),
     ):
         result = await hass.config_entries.flow.async_init(
             DOMAIN,

tests/components/roku/test_config_flow.py

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

tests/components/sharkiq/test_config_flow.py

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

tests/components/sma/test_config_flow.py

@@ -149,9 +149,7 @@ async def test_dhcp_discovery(
 
 
 async def test_dhcp_already_configured(
-    hass: HomeAssistant,
-    mock_config_entry: MockConfigEntry,
-    mock_setup_entry: AsyncMock,
+    hass: HomeAssistant, mock_config_entry: MockConfigEntry
 ) -> None:
     """Test starting a flow by dhcp when already configured."""
     mock_config_entry.add_to_hass(hass)
@@ -164,9 +162,7 @@ async def test_dhcp_already_configured(
 
 
 async def test_dhcp_already_configured_duplicate(
-    hass: HomeAssistant,
-    mock_config_entry: MockConfigEntry,
-    mock_sma_client: MagicMock,
+    hass: HomeAssistant, mock_config_entry: MockConfigEntry
 ) -> None:
     """Test starting a flow by DHCP when already configured and MAC is added."""
     mock_config_entry.add_to_hass(hass)
@@ -284,7 +280,6 @@ 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,55 +244,6 @@
     '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({
@@ -1028,55 +979,6 @@
     '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,16 +7,6 @@ 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, mock_setup_entry: MagicMock) -> None:
+async def test_flow_works(hass: HomeAssistant) -> 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,15 +25,12 @@ async def test_flow_user(hass: HomeAssistant) -> None:
     assert result["step_id"] == "user"
     assert result["errors"] == {}
 
-    with (
-        patch_config_flow_tautulli(AsyncMock()),
-        patch("homeassistant.components.tautulli.async_setup_entry", return_value=True),
-    ):
+    with patch_config_flow_tautulli(AsyncMock()):
         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
@@ -51,15 +48,12 @@ 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()),
-        patch("homeassistant.components.tautulli.async_setup_entry", return_value=True),
-    ):
+    with patch_config_flow_tautulli(AsyncMock()):
         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
@@ -77,15 +71,12 @@ 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()),
-        patch("homeassistant.components.tautulli.async_setup_entry", return_value=True),
-    ):
+    with patch_config_flow_tautulli(AsyncMock()):
         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
@@ -103,15 +94,12 @@ 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()),
-        patch("homeassistant.components.tautulli.async_setup_entry", return_value=True),
-    ):
+    with patch_config_flow_tautulli(AsyncMock()):
         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
@@ -150,15 +138,12 @@ 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()),
-        patch("homeassistant.components.tautulli.async_setup_entry", return_value=True),
-    ):
+    with patch_config_flow_tautulli(AsyncMock()):
         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/telegram_bot/test_telegram_bot.py

@@ -120,7 +120,10 @@ async def test_webhook_platform_init(hass: HomeAssistant, webhook_bot) -> None:
 
 
 async def test_polling_platform_init(
-    hass: HomeAssistant, mock_polling_config_entry: MockConfigEntry
+    hass: HomeAssistant,
+    mock_polling_config_entry: MockConfigEntry,
+    mock_external_calls: None,
+    mock_polling_calls: None,
 ) -> None:
     """Test initialization of the polling platform."""
     mock_polling_config_entry.add_to_hass(hass)

tests/components/tplink_omada/test_services.py

@@ -57,8 +57,6 @@ 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."""
@@ -104,8 +102,6 @@ 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,7 +30,6 @@ 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(
@@ -151,7 +150,6 @@ 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/velux/test_init.py

@@ -153,9 +153,12 @@ async def test_reboot_gateway_service_raises_on_exception(
 
 
 async def test_reboot_gateway_service_raises_validation_error(
-    hass: HomeAssistant,
+    hass: HomeAssistant, mock_config_entry: MockConfigEntry
 ) -> 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,10 +159,9 @@ async def test_full_ssdp_flow_implementation(hass: HomeAssistant) -> None:
         "components": "light",
     }
 
-    with patch("homeassistant.components.wilight.async_setup_entry", return_value=True):
-        result = await hass.config_entries.flow.async_configure(
-            result["flow_id"], user_input={}
-        )
+    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}"