diff --git a/homeassistant/brands/shelly.json b/homeassistant/brands/shelly.json
new file mode 100644
index 00000000000..94d683157ee
--- /dev/null
+++ b/homeassistant/brands/shelly.json
@@ -0,0 +1,6 @@
+{
+  "domain": "shelly",
+  "name": "shelly",
+  "integrations": ["shelly"],
+  "iot_standards": ["zwave"]
+}
diff --git a/homeassistant/components/airthings/__init__.py b/homeassistant/components/airthings/__init__.py
index 14e2f28370f..175fd320062 100644
--- a/homeassistant/components/airthings/__init__.py
+++ b/homeassistant/components/airthings/__init__.py
@@ -5,23 +5,22 @@ from __future__ import annotations
 from datetime import timedelta
 import logging
 
-from airthings import Airthings, AirthingsDevice, AirthingsError
+from airthings import Airthings
 
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import CONF_ID, Platform
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.aiohttp_client import async_get_clientsession
-from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed
 
-from .const import CONF_SECRET, DOMAIN
+from .const import CONF_SECRET
+from .coordinator import AirthingsDataUpdateCoordinator
 
 _LOGGER = logging.getLogger(__name__)
 
 PLATFORMS: list[Platform] = [Platform.SENSOR]
 SCAN_INTERVAL = timedelta(minutes=6)
 
-type AirthingsDataCoordinatorType = DataUpdateCoordinator[dict[str, AirthingsDevice]]
-type AirthingsConfigEntry = ConfigEntry[AirthingsDataCoordinatorType]
+type AirthingsConfigEntry = ConfigEntry[AirthingsDataUpdateCoordinator]
 
 
 async def async_setup_entry(hass: HomeAssistant, entry: AirthingsConfigEntry) -> bool:
@@ -32,21 +31,8 @@ async def async_setup_entry(hass: HomeAssistant, entry: AirthingsConfigEntry) ->
         async_get_clientsession(hass),
     )
 
-    async def _update_method() -> dict[str, AirthingsDevice]:
-        """Get the latest data from Airthings."""
-        try:
-            return await airthings.update_devices()  # type: ignore[no-any-return]
-        except AirthingsError as err:
-            raise UpdateFailed(f"Unable to fetch data: {err}") from err
+    coordinator = AirthingsDataUpdateCoordinator(hass, airthings)
 
-    coordinator = DataUpdateCoordinator(
-        hass,
-        _LOGGER,
-        config_entry=entry,
-        name=DOMAIN,
-        update_method=_update_method,
-        update_interval=SCAN_INTERVAL,
-    )
     await coordinator.async_config_entry_first_refresh()
 
     entry.runtime_data = coordinator
diff --git a/homeassistant/components/airthings/coordinator.py b/homeassistant/components/airthings/coordinator.py
new file mode 100644
index 00000000000..6172dc0b6ef
--- /dev/null
+++ b/homeassistant/components/airthings/coordinator.py
@@ -0,0 +1,36 @@
+"""The Airthings integration."""
+
+from datetime import timedelta
+import logging
+
+from airthings import Airthings, AirthingsDevice, AirthingsError
+
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed
+
+from .const import DOMAIN
+
+_LOGGER = logging.getLogger(__name__)
+SCAN_INTERVAL = timedelta(minutes=6)
+
+
+class AirthingsDataUpdateCoordinator(DataUpdateCoordinator[dict[str, AirthingsDevice]]):
+    """Coordinator for Airthings data updates."""
+
+    def __init__(self, hass: HomeAssistant, airthings: Airthings) -> None:
+        """Initialize the coordinator."""
+        super().__init__(
+            hass,
+            _LOGGER,
+            name=DOMAIN,
+            update_method=self._update_method,
+            update_interval=SCAN_INTERVAL,
+        )
+        self.airthings = airthings
+
+    async def _update_method(self) -> dict[str, AirthingsDevice]:
+        """Get the latest data from Airthings."""
+        try:
+            return await self.airthings.update_devices()  # type: ignore[no-any-return]
+        except AirthingsError as err:
+            raise UpdateFailed(f"Unable to fetch data: {err}") from err
diff --git a/homeassistant/components/airthings/sensor.py b/homeassistant/components/airthings/sensor.py
index f2bf8e071f7..a3e4cebe771 100644
--- a/homeassistant/components/airthings/sensor.py
+++ b/homeassistant/components/airthings/sensor.py
@@ -19,6 +19,7 @@ from homeassistant.const import (
     SIGNAL_STRENGTH_DECIBELS,
     EntityCategory,
     UnitOfPressure,
+    UnitOfSoundPressure,
     UnitOfTemperature,
 )
 from homeassistant.core import HomeAssistant
@@ -27,8 +28,9 @@ from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from homeassistant.helpers.typing import StateType
 from homeassistant.helpers.update_coordinator import CoordinatorEntity
 
-from . import AirthingsConfigEntry, AirthingsDataCoordinatorType
+from . import AirthingsConfigEntry
 from .const import DOMAIN
+from .coordinator import AirthingsDataUpdateCoordinator
 
 SENSORS: dict[str, SensorEntityDescription] = {
     "radonShortTermAvg": SensorEntityDescription(
@@ -54,6 +56,12 @@ SENSORS: dict[str, SensorEntityDescription] = {
         native_unit_of_measurement=UnitOfPressure.MBAR,
         state_class=SensorStateClass.MEASUREMENT,
     ),
+    "sla": SensorEntityDescription(
+        key="sla",
+        device_class=SensorDeviceClass.SOUND_PRESSURE,
+        native_unit_of_measurement=UnitOfSoundPressure.WEIGHTED_DECIBEL_A,
+        state_class=SensorStateClass.MEASUREMENT,
+    ),
     "battery": SensorEntityDescription(
         key="battery",
         device_class=SensorDeviceClass.BATTERY,
@@ -140,7 +148,7 @@ async def async_setup_entry(
 
 
 class AirthingsHeaterEnergySensor(
-    CoordinatorEntity[AirthingsDataCoordinatorType], SensorEntity
+    CoordinatorEntity[AirthingsDataUpdateCoordinator], SensorEntity
 ):
     """Representation of a Airthings Sensor device."""
 
@@ -149,7 +157,7 @@ class AirthingsHeaterEnergySensor(
 
     def __init__(
         self,
-        coordinator: AirthingsDataCoordinatorType,
+        coordinator: AirthingsDataUpdateCoordinator,
         airthings_device: AirthingsDevice,
         entity_description: SensorEntityDescription,
     ) -> None:
diff --git a/homeassistant/components/amazon_devices/manifest.json b/homeassistant/components/amazon_devices/manifest.json
index 7593fbd4943..eb9fae6ddbe 100644
--- a/homeassistant/components/amazon_devices/manifest.json
+++ b/homeassistant/components/amazon_devices/manifest.json
@@ -4,27 +4,114 @@
   "codeowners": ["@chemelli74"],
   "config_flow": true,
   "dhcp": [
+    { "macaddress": "007147*" },
+    { "macaddress": "00FC8B*" },
+    { "macaddress": "0812A5*" },
+    { "macaddress": "086AE5*" },
+    { "macaddress": "08849D*" },
+    { "macaddress": "089115*" },
     { "macaddress": "08A6BC*" },
+    { "macaddress": "08C224*" },
+    { "macaddress": "0CDC91*" },
+    { "macaddress": "0CEE99*" },
+    { "macaddress": "1009F9*" },
+    { "macaddress": "109693*" },
     { "macaddress": "10BF67*" },
+    { "macaddress": "10CE02*" },
+    { "macaddress": "140AC5*" },
+    { "macaddress": "149138*" },
+    { "macaddress": "1848BE*" },
+    { "macaddress": "1C12B0*" },
+    { "macaddress": "1C4D66*" },
+    { "macaddress": "1C93C4*" },
+    { "macaddress": "1CFE2B*" },
+    { "macaddress": "244CE3*" },
+    { "macaddress": "24CE33*" },
+    { "macaddress": "2873F6*" },
+    { "macaddress": "2C71FF*" },
+    { "macaddress": "34AFB3*" },
+    { "macaddress": "34D270*" },
+    { "macaddress": "38F73D*" },
+    { "macaddress": "3C5CC4*" },
+    { "macaddress": "3CE441*" },
     { "macaddress": "440049*" },
+    { "macaddress": "40A2DB*" },
+    { "macaddress": "40A9CF*" },
+    { "macaddress": "40B4CD*" },
     { "macaddress": "443D54*" },
+    { "macaddress": "44650D*" },
+    { "macaddress": "485F2D*" },
+    { "macaddress": "48785E*" },
     { "macaddress": "48B423*" },
     { "macaddress": "4C1744*" },
+    { "macaddress": "4CEFC0*" },
+    { "macaddress": "5007C3*" },
     { "macaddress": "50D45C*" },
     { "macaddress": "50DCE7*" },
+    { "macaddress": "50F5DA*" },
+    { "macaddress": "5C415A*" },
+    { "macaddress": "6837E9*" },
+    { "macaddress": "6854FD*" },
+    { "macaddress": "689A87*" },
+    { "macaddress": "68B691*" },
+    { "macaddress": "68DBF5*" },
     { "macaddress": "68F63B*" },
     { "macaddress": "6C0C9A*" },
+    { "macaddress": "6C5697*" },
+    { "macaddress": "7458F3*" },
+    { "macaddress": "74C246*" },
     { "macaddress": "74D637*" },
+    { "macaddress": "74E20C*" },
+    { "macaddress": "74ECB2*" },
+    { "macaddress": "786C84*" },
+    { "macaddress": "78A03F*" },
     { "macaddress": "7C6166*" },
+    { "macaddress": "7C6305*" },
+    { "macaddress": "7CD566*" },
+    { "macaddress": "8871E5*" },
     { "macaddress": "901195*" },
+    { "macaddress": "90235B*" },
+    { "macaddress": "90A822*" },
+    { "macaddress": "90F82E*" },
     { "macaddress": "943A91*" },
     { "macaddress": "98226E*" },
+    { "macaddress": "98CCF3*" },
     { "macaddress": "9CC8E9*" },
+    { "macaddress": "A002DC*" },
+    { "macaddress": "A0D2B1*" },
+    { "macaddress": "A40801*" },
     { "macaddress": "A8E621*" },
+    { "macaddress": "AC416A*" },
+    { "macaddress": "AC63BE*" },
+    { "macaddress": "ACCCFC*" },
+    { "macaddress": "B0739C*" },
+    { "macaddress": "B0CFCB*" },
+    { "macaddress": "B0F7C4*" },
+    { "macaddress": "B85F98*" },
+    { "macaddress": "C091B9*" },
     { "macaddress": "C095CF*" },
+    { "macaddress": "C49500*" },
+    { "macaddress": "C86C3D*" },
+    { "macaddress": "CC9EA2*" },
+    { "macaddress": "CCF735*" },
+    { "macaddress": "DC54D7*" },
     { "macaddress": "D8BE65*" },
+    { "macaddress": "D8FBD6*" },
+    { "macaddress": "DC91BF*" },
+    { "macaddress": "DCA0D0*" },
+    { "macaddress": "E0F728*" },
     { "macaddress": "EC2BEB*" },
-    { "macaddress": "F02F9E*" }
+    { "macaddress": "EC8AC4*" },
+    { "macaddress": "ECA138*" },
+    { "macaddress": "F02F9E*" },
+    { "macaddress": "F0272D*" },
+    { "macaddress": "F0F0A4*" },
+    { "macaddress": "F4032A*" },
+    { "macaddress": "F854B8*" },
+    { "macaddress": "FC492D*" },
+    { "macaddress": "FC65DE*" },
+    { "macaddress": "FCA183*" },
+    { "macaddress": "FCE9D8*" }
   ],
   "documentation": "https://www.home-assistant.io/integrations/amazon_devices",
   "integration_type": "hub",
diff --git a/homeassistant/components/aprilaire/manifest.json b/homeassistant/components/aprilaire/manifest.json
index 6fe3beae3bc..fa30882f669 100644
--- a/homeassistant/components/aprilaire/manifest.json
+++ b/homeassistant/components/aprilaire/manifest.json
@@ -7,5 +7,5 @@
   "integration_type": "device",
   "iot_class": "local_push",
   "loggers": ["pyaprilaire"],
-  "requirements": ["pyaprilaire==0.9.0"]
+  "requirements": ["pyaprilaire==0.9.1"]
 }
diff --git a/homeassistant/components/conversation/manifest.json b/homeassistant/components/conversation/manifest.json
index 2955bb96833..6078d73e99b 100644
--- a/homeassistant/components/conversation/manifest.json
+++ b/homeassistant/components/conversation/manifest.json
@@ -6,5 +6,5 @@
   "documentation": "https://www.home-assistant.io/integrations/conversation",
   "integration_type": "system",
   "quality_scale": "internal",
-  "requirements": ["hassil==2.2.3", "home-assistant-intents==2025.5.7"]
+  "requirements": ["hassil==2.2.3", "home-assistant-intents==2025.5.28"]
 }
diff --git a/homeassistant/components/decora/__init__.py b/homeassistant/components/decora/__init__.py
index 694ff77fdb3..4ba4fb4dee0 100644
--- a/homeassistant/components/decora/__init__.py
+++ b/homeassistant/components/decora/__init__.py
@@ -1 +1,3 @@
 """The decora component."""
+
+DOMAIN = "decora"
diff --git a/homeassistant/components/decora/light.py b/homeassistant/components/decora/light.py
index a7d14b83aca..d0226a24dcc 100644
--- a/homeassistant/components/decora/light.py
+++ b/homeassistant/components/decora/light.py
@@ -21,7 +21,11 @@ from homeassistant.components.light import (
     LightEntity,
 )
 from homeassistant.const import CONF_API_KEY, CONF_DEVICES, CONF_NAME
+from homeassistant.core import DOMAIN as HOMEASSISTANT_DOMAIN
 from homeassistant.helpers import config_validation as cv
+from homeassistant.helpers.issue_registry import IssueSeverity, create_issue
+
+from . import DOMAIN
 
 if TYPE_CHECKING:
     from homeassistant.core import HomeAssistant
@@ -90,6 +94,21 @@ def setup_platform(
     discovery_info: DiscoveryInfoType | None = None,
 ) -> None:
     """Set up an Decora switch."""
+    create_issue(
+        hass,
+        HOMEASSISTANT_DOMAIN,
+        f"deprecated_system_packages_yaml_integration_{DOMAIN}",
+        breaks_in_ha_version="2025.12.0",
+        is_fixable=False,
+        issue_domain=DOMAIN,
+        severity=IssueSeverity.WARNING,
+        translation_key="deprecated_system_packages_yaml_integration",
+        translation_placeholders={
+            "domain": DOMAIN,
+            "integration_title": "Leviton Decora",
+        },
+    )
+
     lights = []
     for address, device_config in config[CONF_DEVICES].items():
         device = {}
diff --git a/homeassistant/components/frontend/manifest.json b/homeassistant/components/frontend/manifest.json
index 32d243b3431..7282482f329 100644
--- a/homeassistant/components/frontend/manifest.json
+++ b/homeassistant/components/frontend/manifest.json
@@ -20,5 +20,5 @@
   "documentation": "https://www.home-assistant.io/integrations/frontend",
   "integration_type": "system",
   "quality_scale": "internal",
-  "requirements": ["home-assistant-frontend==20250527.0"]
+  "requirements": ["home-assistant-frontend==20250531.0"]
 }
diff --git a/homeassistant/components/home_connect/manifest.json b/homeassistant/components/home_connect/manifest.json
index e8a36cd60d9..d4b37552fb7 100644
--- a/homeassistant/components/home_connect/manifest.json
+++ b/homeassistant/components/home_connect/manifest.json
@@ -21,6 +21,6 @@
   "documentation": "https://www.home-assistant.io/integrations/home_connect",
   "iot_class": "cloud_push",
   "loggers": ["aiohomeconnect"],
-  "requirements": ["aiohomeconnect==0.17.0"],
+  "requirements": ["aiohomeconnect==0.17.1"],
   "zeroconf": ["_homeconnect._tcp.local."]
 }
diff --git a/homeassistant/components/homeassistant/strings.json b/homeassistant/components/homeassistant/strings.json
index e4c3e19cf7c..123e625d0fc 100644
--- a/homeassistant/components/homeassistant/strings.json
+++ b/homeassistant/components/homeassistant/strings.json
@@ -18,6 +18,10 @@
       "title": "The {integration_title} YAML configuration is being removed",
       "description": "Configuring {integration_title} using YAML is being removed.\n\nYour existing YAML configuration has been imported into the UI automatically.\n\nRemove the `{domain}` configuration from your configuration.yaml file and restart Home Assistant to fix this issue."
     },
+    "deprecated_system_packages_config_flow_integration": {
+      "title": "The {integration_title} integration is being removed",
+      "description": "The {integration_title} integration is being removed as it requires additional system packages, which can't be installed on supported Home Assistant installations. Remove all \"{integration_title}\" config entries to fix this issue."
+    },
     "deprecated_system_packages_yaml_integration": {
       "title": "The {integration_title} integration is being removed",
       "description": "The {integration_title} integration is being removed as it requires additional system packages, which can't be installed on supported Home Assistant installations. Remove the `{domain}` configuration from your configuration.yaml file and restart Home Assistant to fix this issue."
diff --git a/homeassistant/components/immich/manifest.json b/homeassistant/components/immich/manifest.json
index 454adae5501..5b56a7e3e2d 100644
--- a/homeassistant/components/immich/manifest.json
+++ b/homeassistant/components/immich/manifest.json
@@ -8,5 +8,5 @@
   "iot_class": "local_polling",
   "loggers": ["aioimmich"],
   "quality_scale": "silver",
-  "requirements": ["aioimmich==0.6.0"]
+  "requirements": ["aioimmich==0.7.0"]
 }
diff --git a/homeassistant/components/immich/media_source.py b/homeassistant/components/immich/media_source.py
index 201076f1295..a7c55f9c572 100644
--- a/homeassistant/components/immich/media_source.py
+++ b/homeassistant/components/immich/media_source.py
@@ -3,7 +3,6 @@
 from __future__ import annotations
 
 from logging import getLogger
-import mimetypes
 
 from aiohttp.web import HTTPNotFound, Request, Response, StreamResponse
 from aioimmich.exceptions import ImmichError
@@ -30,11 +29,8 @@ LOGGER = getLogger(__name__)
 
 async def async_get_media_source(hass: HomeAssistant) -> MediaSource:
     """Set up Immich media source."""
-    entries = hass.config_entries.async_entries(
-        DOMAIN, include_disabled=False, include_ignore=False
-    )
     hass.http.register_view(ImmichMediaView(hass))
-    return ImmichMediaSource(hass, entries)
+    return ImmichMediaSource(hass)
 
 
 class ImmichMediaSourceIdentifier:
@@ -42,12 +38,14 @@ class ImmichMediaSourceIdentifier:
 
     def __init__(self, identifier: str) -> None:
         """Split identifier into parts."""
-        parts = identifier.split("/")
-        # coonfig_entry.unique_id/album_id/asset_it/filename
+        parts = identifier.split("|")
+        # config_entry.unique_id|collection|collection_id|asset_id|file_name|mime_type
         self.unique_id = parts[0]
-        self.album_id = parts[1] if len(parts) > 1 else None
-        self.asset_id = parts[2] if len(parts) > 2 else None
-        self.file_name = parts[3] if len(parts) > 2 else None
+        self.collection = parts[1] if len(parts) > 1 else None
+        self.collection_id = parts[2] if len(parts) > 2 else None
+        self.asset_id = parts[3] if len(parts) > 3 else None
+        self.file_name = parts[4] if len(parts) > 3 else None
+        self.mime_type = parts[5] if len(parts) > 3 else None
 
 
 class ImmichMediaSource(MediaSource):
@@ -55,18 +53,17 @@ class ImmichMediaSource(MediaSource):
 
     name = "Immich"
 
-    def __init__(self, hass: HomeAssistant, entries: list[ConfigEntry]) -> None:
+    def __init__(self, hass: HomeAssistant) -> None:
         """Initialize Immich media source."""
         super().__init__(DOMAIN)
         self.hass = hass
-        self.entries = entries
 
     async def async_browse_media(
         self,
         item: MediaSourceItem,
     ) -> BrowseMediaSource:
         """Return media."""
-        if not self.hass.config_entries.async_loaded_entries(DOMAIN):
+        if not (entries := self.hass.config_entries.async_loaded_entries(DOMAIN)):
             raise BrowseError("Immich is not configured")
         return BrowseMediaSource(
             domain=DOMAIN,
@@ -78,15 +75,16 @@ class ImmichMediaSource(MediaSource):
             can_expand=True,
             children_media_class=MediaClass.DIRECTORY,
             children=[
-                *await self._async_build_immich(item),
+                *await self._async_build_immich(item, entries),
             ],
         )
 
     async def _async_build_immich(
-        self, item: MediaSourceItem
+        self, item: MediaSourceItem, entries: list[ConfigEntry]
     ) -> list[BrowseMediaSource]:
         """Handle browsing different immich instances."""
         if not item.identifier:
+            LOGGER.debug("Render all Immich instances")
             return [
                 BrowseMediaSource(
                     domain=DOMAIN,
@@ -97,7 +95,7 @@ class ImmichMediaSource(MediaSource):
                     can_play=False,
                     can_expand=True,
                 )
-                for entry in self.entries
+                for entry in entries
             ]
         identifier = ImmichMediaSourceIdentifier(item.identifier)
         entry: ImmichConfigEntry | None = (
@@ -108,8 +106,22 @@ class ImmichMediaSource(MediaSource):
         assert entry
         immich_api = entry.runtime_data.api
 
-        if identifier.album_id is None:
-            # Get Albums
+        if identifier.collection is None:
+            LOGGER.debug("Render all collections for %s", entry.title)
+            return [
+                BrowseMediaSource(
+                    domain=DOMAIN,
+                    identifier=f"{identifier.unique_id}|albums",
+                    media_class=MediaClass.DIRECTORY,
+                    media_content_type=MediaClass.IMAGE,
+                    title="albums",
+                    can_play=False,
+                    can_expand=True,
+                )
+            ]
+
+        if identifier.collection_id is None:
+            LOGGER.debug("Render all albums for %s", entry.title)
             try:
                 albums = await immich_api.albums.async_get_all_albums()
             except ImmichError:
@@ -118,21 +130,25 @@ class ImmichMediaSource(MediaSource):
             return [
                 BrowseMediaSource(
                     domain=DOMAIN,
-                    identifier=f"{item.identifier}/{album.album_id}",
+                    identifier=f"{identifier.unique_id}|albums|{album.album_id}",
                     media_class=MediaClass.DIRECTORY,
                     media_content_type=MediaClass.IMAGE,
                     title=album.name,
                     can_play=False,
                     can_expand=True,
-                    thumbnail=f"/immich/{identifier.unique_id}/{album.thumbnail_asset_id}/thumb.jpg/thumbnail",
+                    thumbnail=f"/immich/{identifier.unique_id}/{album.thumbnail_asset_id}/thumbnail/image/jpg",
                 )
                 for album in albums
             ]
 
-        # Request items of album
+        LOGGER.debug(
+            "Render all assets of album %s for %s",
+            identifier.collection_id,
+            entry.title,
+        )
         try:
             album_info = await immich_api.albums.async_get_album_info(
-                identifier.album_id
+                identifier.collection_id
             )
         except ImmichError:
             return []
@@ -141,17 +157,18 @@ class ImmichMediaSource(MediaSource):
             BrowseMediaSource(
                 domain=DOMAIN,
                 identifier=(
-                    f"{identifier.unique_id}/"
-                    f"{identifier.album_id}/"
-                    f"{asset.asset_id}/"
-                    f"{asset.file_name}"
+                    f"{identifier.unique_id}|albums|"
+                    f"{identifier.collection_id}|"
+                    f"{asset.asset_id}|"
+                    f"{asset.file_name}|"
+                    f"{asset.mime_type}"
                 ),
                 media_class=MediaClass.IMAGE,
                 media_content_type=asset.mime_type,
                 title=asset.file_name,
                 can_play=False,
                 can_expand=False,
-                thumbnail=f"/immich/{identifier.unique_id}/{asset.asset_id}/{asset.file_name}/thumbnail",
+                thumbnail=f"/immich/{identifier.unique_id}/{asset.asset_id}/thumbnail/{asset.mime_type}",
             )
             for asset in album_info.assets
             if asset.mime_type.startswith("image/")
@@ -161,17 +178,18 @@ class ImmichMediaSource(MediaSource):
             BrowseMediaSource(
                 domain=DOMAIN,
                 identifier=(
-                    f"{identifier.unique_id}/"
-                    f"{identifier.album_id}/"
-                    f"{asset.asset_id}/"
-                    f"{asset.file_name}"
+                    f"{identifier.unique_id}|albums|"
+                    f"{identifier.collection_id}|"
+                    f"{asset.asset_id}|"
+                    f"{asset.file_name}|"
+                    f"{asset.mime_type}"
                 ),
                 media_class=MediaClass.VIDEO,
                 media_content_type=asset.mime_type,
                 title=asset.file_name,
                 can_play=True,
                 can_expand=False,
-                thumbnail=f"/immich/{identifier.unique_id}/{asset.asset_id}/thumbnail.jpg/thumbnail",
+                thumbnail=f"/immich/{identifier.unique_id}/{asset.asset_id}/thumbnail/image/jpeg",
             )
             for asset in album_info.assets
             if asset.mime_type.startswith("video/")
@@ -181,17 +199,23 @@ class ImmichMediaSource(MediaSource):
 
     async def async_resolve_media(self, item: MediaSourceItem) -> PlayMedia:
         """Resolve media to a url."""
-        identifier = ImmichMediaSourceIdentifier(item.identifier)
-        if identifier.file_name is None:
-            raise Unresolvable("No file name")
-        mime_type, _ = mimetypes.guess_type(identifier.file_name)
-        if not isinstance(mime_type, str):
-            raise Unresolvable("No file extension")
+        try:
+            identifier = ImmichMediaSourceIdentifier(item.identifier)
+        except IndexError as err:
+            raise Unresolvable(
+                f"Could not parse identifier: {item.identifier}"
+            ) from err
+
+        if identifier.mime_type is None:
+            raise Unresolvable(
+                f"Could not resolve identifier that has no mime-type: {item.identifier}"
+            )
+
         return PlayMedia(
             (
-                f"/immich/{identifier.unique_id}/{identifier.asset_id}/{identifier.file_name}/fullsize"
+                f"/immich/{identifier.unique_id}/{identifier.asset_id}/fullsize/{identifier.mime_type}"
             ),
-            mime_type,
+            identifier.mime_type,
         )
 
 
@@ -212,10 +236,10 @@ class ImmichMediaView(HomeAssistantView):
         if not self.hass.config_entries.async_loaded_entries(DOMAIN):
             raise HTTPNotFound
 
-        asset_id, file_name, size = location.split("/")
-        mime_type, _ = mimetypes.guess_type(file_name)
-        if not isinstance(mime_type, str):
-            raise HTTPNotFound
+        try:
+            asset_id, size, mime_type_base, mime_type_format = location.split("/")
+        except ValueError as err:
+            raise HTTPNotFound from err
 
         entry: ImmichConfigEntry | None = (
             self.hass.config_entries.async_entry_for_domain_unique_id(
@@ -226,7 +250,7 @@ class ImmichMediaView(HomeAssistantView):
         immich_api = entry.runtime_data.api
 
         # stream response for videos
-        if mime_type.startswith("video/"):
+        if mime_type_base == "video":
             try:
                 resp = await immich_api.assets.async_play_video_stream(asset_id)
             except ImmichError as exc:
@@ -243,4 +267,4 @@ class ImmichMediaView(HomeAssistantView):
             image = await immich_api.assets.async_view_asset(asset_id, size)
         except ImmichError as exc:
             raise HTTPNotFound from exc
-        return Response(body=image, content_type=mime_type)
+        return Response(body=image, content_type=f"{mime_type_base}/{mime_type_format}")
diff --git a/homeassistant/components/iskra/manifest.json b/homeassistant/components/iskra/manifest.json
index caa176ab6b6..3f7c805a917 100644
--- a/homeassistant/components/iskra/manifest.json
+++ b/homeassistant/components/iskra/manifest.json
@@ -7,5 +7,5 @@
   "integration_type": "hub",
   "iot_class": "local_polling",
   "loggers": ["pyiskra"],
-  "requirements": ["pyiskra==0.1.15"]
+  "requirements": ["pyiskra==0.1.19"]
 }
diff --git a/homeassistant/components/jellyfin/__init__.py b/homeassistant/components/jellyfin/__init__.py
index 1cb6219ada0..d22594070ff 100644
--- a/homeassistant/components/jellyfin/__init__.py
+++ b/homeassistant/components/jellyfin/__init__.py
@@ -7,7 +7,7 @@ from homeassistant.exceptions import ConfigEntryAuthFailed, ConfigEntryNotReady
 from homeassistant.helpers import device_registry as dr
 
 from .client_wrapper import CannotConnect, InvalidAuth, create_client, validate_input
-from .const import CONF_CLIENT_DEVICE_ID, DOMAIN, PLATFORMS
+from .const import CONF_CLIENT_DEVICE_ID, DEFAULT_NAME, DOMAIN, PLATFORMS
 from .coordinator import JellyfinConfigEntry, JellyfinDataUpdateCoordinator
 
 
@@ -35,9 +35,18 @@ async def async_setup_entry(hass: HomeAssistant, entry: JellyfinConfigEntry) ->
     coordinator = JellyfinDataUpdateCoordinator(
         hass, entry, client, server_info, user_id
     )
-
     await coordinator.async_config_entry_first_refresh()
 
+    device_registry = dr.async_get(hass)
+    device_registry.async_get_or_create(
+        config_entry_id=entry.entry_id,
+        entry_type=dr.DeviceEntryType.SERVICE,
+        identifiers={(DOMAIN, coordinator.server_id)},
+        manufacturer=DEFAULT_NAME,
+        name=coordinator.server_name,
+        sw_version=coordinator.server_version,
+    )
+
     entry.runtime_data = coordinator
     entry.async_on_unload(client.stop)
 
diff --git a/homeassistant/components/jellyfin/entity.py b/homeassistant/components/jellyfin/entity.py
index 4a3b2b77bb1..107a67d6a89 100644
--- a/homeassistant/components/jellyfin/entity.py
+++ b/homeassistant/components/jellyfin/entity.py
@@ -4,10 +4,10 @@ from __future__ import annotations
 
 from typing import Any
 
-from homeassistant.helpers.device_registry import DeviceEntryType, DeviceInfo
+from homeassistant.helpers.device_registry import DeviceInfo
 from homeassistant.helpers.update_coordinator import CoordinatorEntity
 
-from .const import DEFAULT_NAME, DOMAIN
+from .const import DOMAIN
 from .coordinator import JellyfinDataUpdateCoordinator
 
 
@@ -24,11 +24,7 @@ class JellyfinServerEntity(JellyfinEntity):
         """Initialize the Jellyfin entity."""
         super().__init__(coordinator)
         self._attr_device_info = DeviceInfo(
-            entry_type=DeviceEntryType.SERVICE,
             identifiers={(DOMAIN, coordinator.server_id)},
-            manufacturer=DEFAULT_NAME,
-            name=coordinator.server_name,
-            sw_version=coordinator.server_version,
         )
 
 
diff --git a/homeassistant/components/keyboard/__init__.py b/homeassistant/components/keyboard/__init__.py
index bf935f119d0..227472ff553 100644
--- a/homeassistant/components/keyboard/__init__.py
+++ b/homeassistant/components/keyboard/__init__.py
@@ -11,8 +11,9 @@ from homeassistant.const import (
     SERVICE_VOLUME_MUTE,
     SERVICE_VOLUME_UP,
 )
-from homeassistant.core import HomeAssistant
+from homeassistant.core import DOMAIN as HOMEASSISTANT_DOMAIN, HomeAssistant
 from homeassistant.helpers import config_validation as cv
+from homeassistant.helpers.issue_registry import IssueSeverity, create_issue
 from homeassistant.helpers.typing import ConfigType
 
 DOMAIN = "keyboard"
@@ -24,6 +25,20 @@ CONFIG_SCHEMA = cv.empty_config_schema(DOMAIN)
 
 def setup(hass: HomeAssistant, config: ConfigType) -> bool:
     """Listen for keyboard events."""
+    create_issue(
+        hass,
+        HOMEASSISTANT_DOMAIN,
+        f"deprecated_system_packages_yaml_integration_{DOMAIN}",
+        breaks_in_ha_version="2025.12.0",
+        is_fixable=False,
+        issue_domain=DOMAIN,
+        severity=IssueSeverity.WARNING,
+        translation_key="deprecated_system_packages_yaml_integration",
+        translation_placeholders={
+            "domain": DOMAIN,
+            "integration_title": "Keyboard",
+        },
+    )
 
     keyboard = PyKeyboard()
     keyboard.special_key_assignment()
diff --git a/homeassistant/components/lamarzocco/coordinator.py b/homeassistant/components/lamarzocco/coordinator.py
index f0f64e02c28..b6379f237ae 100644
--- a/homeassistant/components/lamarzocco/coordinator.py
+++ b/homeassistant/components/lamarzocco/coordinator.py
@@ -20,8 +20,8 @@ from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, Upda
 from .const import DOMAIN
 
 SCAN_INTERVAL = timedelta(seconds=15)
-SETTINGS_UPDATE_INTERVAL = timedelta(hours=1)
-SCHEDULE_UPDATE_INTERVAL = timedelta(minutes=5)
+SETTINGS_UPDATE_INTERVAL = timedelta(hours=8)
+SCHEDULE_UPDATE_INTERVAL = timedelta(minutes=30)
 STATISTICS_UPDATE_INTERVAL = timedelta(minutes=15)
 _LOGGER = logging.getLogger(__name__)
 
diff --git a/homeassistant/components/lamarzocco/manifest.json b/homeassistant/components/lamarzocco/manifest.json
index 36a0a489e30..46a29427264 100644
--- a/homeassistant/components/lamarzocco/manifest.json
+++ b/homeassistant/components/lamarzocco/manifest.json
@@ -37,5 +37,5 @@
   "iot_class": "cloud_push",
   "loggers": ["pylamarzocco"],
   "quality_scale": "platinum",
-  "requirements": ["pylamarzocco==2.0.7"]
+  "requirements": ["pylamarzocco==2.0.8"]
 }
diff --git a/homeassistant/components/linkplay/manifest.json b/homeassistant/components/linkplay/manifest.json
index fafc9e66514..eb9b5a87c75 100644
--- a/homeassistant/components/linkplay/manifest.json
+++ b/homeassistant/components/linkplay/manifest.json
@@ -7,6 +7,6 @@
   "integration_type": "hub",
   "iot_class": "local_polling",
   "loggers": ["linkplay"],
-  "requirements": ["python-linkplay==0.2.8"],
+  "requirements": ["python-linkplay==0.2.9"],
   "zeroconf": ["_linkplay._tcp.local."]
 }
diff --git a/homeassistant/components/lirc/__init__.py b/homeassistant/components/lirc/__init__.py
index f5b26743a03..6b8e0d08d52 100644
--- a/homeassistant/components/lirc/__init__.py
+++ b/homeassistant/components/lirc/__init__.py
@@ -7,8 +7,9 @@ import time
 import lirc
 
 from homeassistant.const import EVENT_HOMEASSISTANT_START, EVENT_HOMEASSISTANT_STOP
-from homeassistant.core import HomeAssistant
+from homeassistant.core import DOMAIN as HOMEASSISTANT_DOMAIN, HomeAssistant
 from homeassistant.helpers import config_validation as cv
+from homeassistant.helpers.issue_registry import IssueSeverity, create_issue
 from homeassistant.helpers.typing import ConfigType
 
 _LOGGER = logging.getLogger(__name__)
@@ -26,6 +27,20 @@ CONFIG_SCHEMA = cv.empty_config_schema(DOMAIN)
 
 def setup(hass: HomeAssistant, config: ConfigType) -> bool:
     """Set up the LIRC capability."""
+    create_issue(
+        hass,
+        HOMEASSISTANT_DOMAIN,
+        f"deprecated_system_packages_yaml_integration_{DOMAIN}",
+        breaks_in_ha_version="2025.12.0",
+        is_fixable=False,
+        issue_domain=DOMAIN,
+        severity=IssueSeverity.WARNING,
+        translation_key="deprecated_system_packages_yaml_integration",
+        translation_placeholders={
+            "domain": DOMAIN,
+            "integration_title": "LIRC",
+        },
+    )
     # blocking=True gives unexpected behavior (multiple responses for 1 press)
     # also by not blocking, we allow hass to shut down the thread gracefully
     # on exit.
diff --git a/homeassistant/components/nobo_hub/climate.py b/homeassistant/components/nobo_hub/climate.py
index 771da420213..018f3e2b06a 100644
--- a/homeassistant/components/nobo_hub/climate.py
+++ b/homeassistant/components/nobo_hub/climate.py
@@ -40,7 +40,7 @@ SUPPORT_FLAGS = (
 PRESET_MODES = [PRESET_NONE, PRESET_COMFORT, PRESET_ECO, PRESET_AWAY]
 
 MIN_TEMPERATURE = 7
-MAX_TEMPERATURE = 40
+MAX_TEMPERATURE = 30
 
 
 async def async_setup_entry(
diff --git a/homeassistant/components/opower/manifest.json b/homeassistant/components/opower/manifest.json
index 7ac9f4cc943..0aa26dbb4b1 100644
--- a/homeassistant/components/opower/manifest.json
+++ b/homeassistant/components/opower/manifest.json
@@ -7,5 +7,5 @@
   "documentation": "https://www.home-assistant.io/integrations/opower",
   "iot_class": "cloud_polling",
   "loggers": ["opower"],
-  "requirements": ["opower==0.12.2"]
+  "requirements": ["opower==0.12.3"]
 }
diff --git a/homeassistant/components/probe_plus/manifest.json b/homeassistant/components/probe_plus/manifest.json
index cf61e394a83..e7db39b8ae4 100644
--- a/homeassistant/components/probe_plus/manifest.json
+++ b/homeassistant/components/probe_plus/manifest.json
@@ -15,5 +15,5 @@
   "integration_type": "device",
   "iot_class": "local_push",
   "quality_scale": "bronze",
-  "requirements": ["pyprobeplus==1.0.0"]
+  "requirements": ["pyprobeplus==1.0.1"]
 }
diff --git a/homeassistant/components/recorder/manifest.json b/homeassistant/components/recorder/manifest.json
index 01b5d089bf3..cc6a6979817 100644
--- a/homeassistant/components/recorder/manifest.json
+++ b/homeassistant/components/recorder/manifest.json
@@ -7,7 +7,7 @@
   "iot_class": "local_push",
   "quality_scale": "internal",
   "requirements": [
-    "SQLAlchemy==2.0.40",
+    "SQLAlchemy==2.0.41",
     "fnv-hash-fast==1.5.0",
     "psutil-home-assistant==0.0.1"
   ]
diff --git a/homeassistant/components/reolink/__init__.py b/homeassistant/components/reolink/__init__.py
index 57d41c20521..5fbd64a3d07 100644
--- a/homeassistant/components/reolink/__init__.py
+++ b/homeassistant/components/reolink/__init__.py
@@ -233,6 +233,14 @@ async def async_setup_entry(
         "privacy_mode_change", async_privacy_mode_change, 623
     )
 
+    # ensure host device is setup before connected camera devices that use via_device
+    device_registry = dr.async_get(hass)
+    device_registry.async_get_or_create(
+        config_entry_id=config_entry.entry_id,
+        identifiers={(DOMAIN, host.unique_id)},
+        connections={(dr.CONNECTION_NETWORK_MAC, host.api.mac_address)},
+    )
+
     await hass.config_entries.async_forward_entry_setups(config_entry, PLATFORMS)
 
     config_entry.async_on_unload(
diff --git a/homeassistant/components/reolink/icons.json b/homeassistant/components/reolink/icons.json
index 7df82dfc512..fef175457f7 100644
--- a/homeassistant/components/reolink/icons.json
+++ b/homeassistant/components/reolink/icons.json
@@ -462,6 +462,12 @@
       "doorbell_button_sound": {
         "default": "mdi:volume-high"
       },
+      "hardwired_chime_enabled": {
+        "default": "mdi:bell",
+        "state": {
+          "off": "mdi:bell-off"
+        }
+      },
       "hdr": {
         "default": "mdi:hdr"
       },
diff --git a/homeassistant/components/reolink/manifest.json b/homeassistant/components/reolink/manifest.json
index a6f0b59426a..694dd43a532 100644
--- a/homeassistant/components/reolink/manifest.json
+++ b/homeassistant/components/reolink/manifest.json
@@ -19,5 +19,5 @@
   "iot_class": "local_push",
   "loggers": ["reolink_aio"],
   "quality_scale": "platinum",
-  "requirements": ["reolink-aio==0.13.3"]
+  "requirements": ["reolink-aio==0.13.4"]
 }
diff --git a/homeassistant/components/reolink/strings.json b/homeassistant/components/reolink/strings.json
index 94d2ee3cf27..d1d51d9229a 100644
--- a/homeassistant/components/reolink/strings.json
+++ b/homeassistant/components/reolink/strings.json
@@ -910,6 +910,9 @@
       "auto_focus": {
         "name": "Auto focus"
       },
+      "hardwired_chime_enabled": {
+        "name": "Hardwired chime enabled"
+      },
       "guard_return": {
         "name": "Guard return"
       },
diff --git a/homeassistant/components/reolink/switch.py b/homeassistant/components/reolink/switch.py
index af87a75eece..d9f192a3faa 100644
--- a/homeassistant/components/reolink/switch.py
+++ b/homeassistant/components/reolink/switch.py
@@ -216,6 +216,16 @@ SWITCH_ENTITIES = (
         value=lambda api, ch: api.baichuan.privacy_mode(ch),
         method=lambda api, ch, value: api.baichuan.set_privacy_mode(ch, value),
     ),
+    ReolinkSwitchEntityDescription(
+        key="hardwired_chime_enabled",
+        cmd_key="483",
+        translation_key="hardwired_chime_enabled",
+        entity_category=EntityCategory.CONFIG,
+        entity_registry_enabled_default=False,
+        supported=lambda api, ch: api.supported(ch, "hardwired_chime"),
+        value=lambda api, ch: api.baichuan.hardwired_chime_enabled(ch),
+        method=lambda api, ch, value: api.baichuan.set_ding_dong_ctrl(ch, enable=value),
+    ),
 )
 
 NVR_SWITCH_ENTITIES = (
diff --git a/homeassistant/components/reolink/views.py b/homeassistant/components/reolink/views.py
index 44265244b18..7f062055f7e 100644
--- a/homeassistant/components/reolink/views.py
+++ b/homeassistant/components/reolink/views.py
@@ -52,6 +52,7 @@ class PlaybackProxyView(HomeAssistantView):
             verify_ssl=False,
             ssl_cipher=SSLCipherList.INSECURE,
         )
+        self._vod_type: str | None = None
 
     async def get(
         self,
@@ -68,6 +69,8 @@ class PlaybackProxyView(HomeAssistantView):
 
         filename_decoded = urlsafe_b64decode(filename.encode("utf-8")).decode("utf-8")
         ch = int(channel)
+        if self._vod_type is not None:
+            vod_type = self._vod_type
         try:
             host = get_host(self.hass, config_entry_id)
         except Unresolvable:
@@ -127,6 +130,25 @@ class PlaybackProxyView(HomeAssistantView):
             "apolication/octet-stream",
         ]:
             err_str = f"Reolink playback expected video/mp4 but got {reolink_response.content_type}"
+            if (
+                reolink_response.content_type == "video/x-flv"
+                and vod_type == VodRequestType.PLAYBACK.value
+            ):
+                # next time use DOWNLOAD immediately
+                self._vod_type = VodRequestType.DOWNLOAD.value
+                _LOGGER.debug(
+                    "%s, retrying using download instead of playback cmd", err_str
+                )
+                return await self.get(
+                    request,
+                    config_entry_id,
+                    channel,
+                    stream_res,
+                    self._vod_type,
+                    filename,
+                    retry,
+                )
+
             _LOGGER.error(err_str)
             if reolink_response.content_type == "text/html":
                 text = await reolink_response.text()
@@ -140,7 +162,10 @@ class PlaybackProxyView(HomeAssistantView):
             reolink_response.reason,
             response_headers,
         )
-        response_headers["Content-Type"] = "video/mp4"
+        if "Content-Type" not in response_headers:
+            response_headers["Content-Type"] = reolink_response.content_type
+        if response_headers["Content-Type"] == "apolication/octet-stream":
+            response_headers["Content-Type"] = "application/octet-stream"
 
         response = web.StreamResponse(
             status=reolink_response.status,
diff --git a/homeassistant/components/smlight/manifest.json b/homeassistant/components/smlight/manifest.json
index b2a03a737fc..f47960a65bd 100644
--- a/homeassistant/components/smlight/manifest.json
+++ b/homeassistant/components/smlight/manifest.json
@@ -12,7 +12,7 @@
   "integration_type": "device",
   "iot_class": "local_push",
   "quality_scale": "silver",
-  "requirements": ["pysmlight==0.2.4"],
+  "requirements": ["pysmlight==0.2.5"],
   "zeroconf": [
     {
       "type": "_slzb-06._tcp.local."
diff --git a/homeassistant/components/sms/__init__.py b/homeassistant/components/sms/__init__.py
index 2d18d44de3a..6c7c5374f7d 100644
--- a/homeassistant/components/sms/__init__.py
+++ b/homeassistant/components/sms/__init__.py
@@ -6,9 +6,14 @@ import voluptuous as vol
 
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import CONF_DEVICE, CONF_NAME, Platform
-from homeassistant.core import HomeAssistant
+from homeassistant.core import DOMAIN as HOMEASSISTANT_DOMAIN, HomeAssistant
 from homeassistant.exceptions import ConfigEntryNotReady
 from homeassistant.helpers import config_validation as cv, discovery
+from homeassistant.helpers.issue_registry import (
+    IssueSeverity,
+    async_create_issue,
+    async_delete_issue,
+)
 from homeassistant.helpers.typing import ConfigType
 
 from .const import (
@@ -41,6 +46,7 @@ CONFIG_SCHEMA = vol.Schema(
     },
     extra=vol.ALLOW_EXTRA,
 )
+DEPRECATED_ISSUE_ID = f"deprecated_system_packages_config_flow_integration_{DOMAIN}"
 
 
 async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
@@ -52,6 +58,19 @@ async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
 
 async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
     """Configure Gammu state machine."""
+    async_create_issue(
+        hass,
+        HOMEASSISTANT_DOMAIN,
+        DEPRECATED_ISSUE_ID,
+        breaks_in_ha_version="2025.12.0",
+        is_fixable=False,
+        issue_domain=DOMAIN,
+        severity=IssueSeverity.WARNING,
+        translation_key="deprecated_system_packages_config_flow_integration",
+        translation_placeholders={
+            "integration_title": "SMS notifications via GSM-modem",
+        },
+    )
 
     device = entry.data[CONF_DEVICE]
     connection_mode = "at"
@@ -101,4 +120,7 @@ async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
         gateway = hass.data[DOMAIN].pop(SMS_GATEWAY)[GATEWAY]
         await gateway.terminate_async()
 
+    if not hass.config_entries.async_loaded_entries(DOMAIN):
+        async_delete_issue(hass, HOMEASSISTANT_DOMAIN, DEPRECATED_ISSUE_ID)
+
     return unload_ok
diff --git a/homeassistant/components/snips/__init__.py b/homeassistant/components/snips/__init__.py
index 70837b95ec5..293caeaedac 100644
--- a/homeassistant/components/snips/__init__.py
+++ b/homeassistant/components/snips/__init__.py
@@ -7,8 +7,13 @@ import logging
 import voluptuous as vol
 
 from homeassistant.components import mqtt
-from homeassistant.core import HomeAssistant, ServiceCall
+from homeassistant.core import (
+    DOMAIN as HOMEASSISTANT_DOMAIN,
+    HomeAssistant,
+    ServiceCall,
+)
 from homeassistant.helpers import config_validation as cv, intent
+from homeassistant.helpers.issue_registry import IssueSeverity, async_create_issue
 from homeassistant.helpers.typing import ConfigType
 
 DOMAIN = "snips"
@@ -91,6 +96,20 @@ SERVICE_SCHEMA_FEEDBACK = vol.Schema(
 
 async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
     """Activate Snips component."""
+    async_create_issue(
+        hass,
+        HOMEASSISTANT_DOMAIN,
+        f"deprecated_system_packages_yaml_integration_{DOMAIN}",
+        breaks_in_ha_version="2025.12.0",
+        is_fixable=False,
+        issue_domain=DOMAIN,
+        severity=IssueSeverity.WARNING,
+        translation_key="deprecated_system_packages_yaml_integration",
+        translation_placeholders={
+            "domain": DOMAIN,
+            "integration_title": "Snips",
+        },
+    )
 
     # Make sure MQTT integration is enabled and the client is available
     if not await mqtt.async_wait_for_mqtt_client(hass):
diff --git a/homeassistant/components/sql/manifest.json b/homeassistant/components/sql/manifest.json
index e6a45390120..24433456565 100644
--- a/homeassistant/components/sql/manifest.json
+++ b/homeassistant/components/sql/manifest.json
@@ -6,5 +6,5 @@
   "config_flow": true,
   "documentation": "https://www.home-assistant.io/integrations/sql",
   "iot_class": "local_polling",
-  "requirements": ["SQLAlchemy==2.0.40", "sqlparse==0.5.0"]
+  "requirements": ["SQLAlchemy==2.0.41", "sqlparse==0.5.0"]
 }
diff --git a/homeassistant/components/switchbot_cloud/__init__.py b/homeassistant/components/switchbot_cloud/__init__.py
index c7bf66a5803..7b7f60589f0 100644
--- a/homeassistant/components/switchbot_cloud/__init__.py
+++ b/homeassistant/components/switchbot_cloud/__init__.py
@@ -7,7 +7,13 @@ from dataclasses import dataclass, field
 from logging import getLogger
 
 from aiohttp import web
-from switchbot_api import CannotConnect, Device, InvalidAuth, Remote, SwitchBotAPI
+from switchbot_api import (
+    Device,
+    Remote,
+    SwitchBotAPI,
+    SwitchBotAuthenticationError,
+    SwitchBotConnectionError,
+)
 
 from homeassistant.components import webhook
 from homeassistant.config_entries import ConfigEntry
@@ -175,12 +181,12 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
     api = SwitchBotAPI(token=token, secret=secret)
     try:
         devices = await api.list_devices()
-    except InvalidAuth as ex:
+    except SwitchBotAuthenticationError as ex:
         _LOGGER.error(
             "Invalid authentication while connecting to SwitchBot API: %s", ex
         )
         return False
-    except CannotConnect as ex:
+    except SwitchBotConnectionError as ex:
         raise ConfigEntryNotReady from ex
     _LOGGER.debug("Devices: %s", devices)
     coordinators_by_id: dict[str, SwitchBotCoordinator] = {}
diff --git a/homeassistant/components/switchbot_cloud/config_flow.py b/homeassistant/components/switchbot_cloud/config_flow.py
index eafe823bc0b..0ba1e0295e0 100644
--- a/homeassistant/components/switchbot_cloud/config_flow.py
+++ b/homeassistant/components/switchbot_cloud/config_flow.py
@@ -3,7 +3,11 @@
 from logging import getLogger
 from typing import Any
 
-from switchbot_api import CannotConnect, InvalidAuth, SwitchBotAPI
+from switchbot_api import (
+    SwitchBotAPI,
+    SwitchBotAuthenticationError,
+    SwitchBotConnectionError,
+)
 import voluptuous as vol
 
 from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
@@ -36,9 +40,9 @@ class SwitchBotCloudConfigFlow(ConfigFlow, domain=DOMAIN):
                 await SwitchBotAPI(
                     token=user_input[CONF_API_TOKEN], secret=user_input[CONF_API_KEY]
                 ).list_devices()
-            except CannotConnect:
+            except SwitchBotConnectionError:
                 errors["base"] = "cannot_connect"
-            except InvalidAuth:
+            except SwitchBotAuthenticationError:
                 errors["base"] = "invalid_auth"
             except Exception:
                 _LOGGER.exception("Unexpected exception")
diff --git a/homeassistant/components/switchbot_cloud/coordinator.py b/homeassistant/components/switchbot_cloud/coordinator.py
index 4f047145b47..9fc8f64aa68 100644
--- a/homeassistant/components/switchbot_cloud/coordinator.py
+++ b/homeassistant/components/switchbot_cloud/coordinator.py
@@ -4,7 +4,7 @@ from asyncio import timeout
 from logging import getLogger
 from typing import Any
 
-from switchbot_api import CannotConnect, Device, Remote, SwitchBotAPI
+from switchbot_api import Device, Remote, SwitchBotAPI, SwitchBotConnectionError
 
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.core import HomeAssistant
@@ -70,5 +70,5 @@ class SwitchBotCoordinator(DataUpdateCoordinator[Status]):
                 status: Status = await self._api.get_status(self._device_id)
                 _LOGGER.debug("Refreshing %s with %s", self._device_id, status)
                 return status
-        except CannotConnect as err:
+        except SwitchBotConnectionError as err:
             raise UpdateFailed(f"Error communicating with API: {err}") from err
diff --git a/homeassistant/components/switchbot_cloud/manifest.json b/homeassistant/components/switchbot_cloud/manifest.json
index 83404aac2ba..e0c49d9e739 100644
--- a/homeassistant/components/switchbot_cloud/manifest.json
+++ b/homeassistant/components/switchbot_cloud/manifest.json
@@ -8,5 +8,5 @@
   "integration_type": "hub",
   "iot_class": "cloud_polling",
   "loggers": ["switchbot_api"],
-  "requirements": ["switchbot-api==2.3.1"]
+  "requirements": ["switchbot-api==2.4.0"]
 }
diff --git a/homeassistant/components/tedee/manifest.json b/homeassistant/components/tedee/manifest.json
index bca51f08f93..012e82318ed 100644
--- a/homeassistant/components/tedee/manifest.json
+++ b/homeassistant/components/tedee/manifest.json
@@ -8,5 +8,5 @@
   "iot_class": "local_push",
   "loggers": ["aiotedee"],
   "quality_scale": "platinum",
-  "requirements": ["aiotedee==0.2.20"]
+  "requirements": ["aiotedee==0.2.23"]
 }
diff --git a/homeassistant/components/tensorflow/__init__.py b/homeassistant/components/tensorflow/__init__.py
index 00a695d6aa8..7ed20cbe4b6 100644
--- a/homeassistant/components/tensorflow/__init__.py
+++ b/homeassistant/components/tensorflow/__init__.py
@@ -1 +1,4 @@
 """The tensorflow component."""
+
+DOMAIN = "tensorflow"
+CONF_GRAPH = "graph"
diff --git a/homeassistant/components/tensorflow/image_processing.py b/homeassistant/components/tensorflow/image_processing.py
index 0fb069e8da8..05be56d444d 100644
--- a/homeassistant/components/tensorflow/image_processing.py
+++ b/homeassistant/components/tensorflow/image_processing.py
@@ -26,15 +26,21 @@ from homeassistant.const import (
     CONF_SOURCE,
     EVENT_HOMEASSISTANT_START,
 )
-from homeassistant.core import HomeAssistant, split_entity_id
+from homeassistant.core import (
+    DOMAIN as HOMEASSISTANT_DOMAIN,
+    HomeAssistant,
+    split_entity_id,
+)
 from homeassistant.helpers import config_validation as cv, template
 from homeassistant.helpers.entity_platform import AddEntitiesCallback
+from homeassistant.helpers.issue_registry import IssueSeverity, create_issue
 from homeassistant.helpers.typing import ConfigType, DiscoveryInfoType
 from homeassistant.util.pil import draw_box
 
+from . import CONF_GRAPH, DOMAIN
+
 os.environ["TF_CPP_MIN_LOG_LEVEL"] = "2"
 
-DOMAIN = "tensorflow"
 _LOGGER = logging.getLogger(__name__)
 
 ATTR_MATCHES = "matches"
@@ -47,7 +53,6 @@ CONF_BOTTOM = "bottom"
 CONF_CATEGORIES = "categories"
 CONF_CATEGORY = "category"
 CONF_FILE_OUT = "file_out"
-CONF_GRAPH = "graph"
 CONF_LABELS = "labels"
 CONF_LABEL_OFFSET = "label_offset"
 CONF_LEFT = "left"
@@ -110,6 +115,21 @@ def setup_platform(
     discovery_info: DiscoveryInfoType | None = None,
 ) -> None:
     """Set up the TensorFlow image processing platform."""
+    create_issue(
+        hass,
+        HOMEASSISTANT_DOMAIN,
+        f"deprecated_system_packages_yaml_integration_{DOMAIN}",
+        breaks_in_ha_version="2025.12.0",
+        is_fixable=False,
+        issue_domain=DOMAIN,
+        severity=IssueSeverity.WARNING,
+        translation_key="deprecated_system_packages_yaml_integration",
+        translation_placeholders={
+            "domain": DOMAIN,
+            "integration_title": "Tensorflow",
+        },
+    )
+
     model_config = config[CONF_MODEL]
     model_dir = model_config.get(CONF_MODEL_DIR) or hass.config.path("tensorflow")
     labels = model_config.get(CONF_LABELS) or hass.config.path(
diff --git a/homeassistant/components/tesla_fleet/manifest.json b/homeassistant/components/tesla_fleet/manifest.json
index 53c8e7d554c..8f5ba1468a5 100644
--- a/homeassistant/components/tesla_fleet/manifest.json
+++ b/homeassistant/components/tesla_fleet/manifest.json
@@ -7,5 +7,5 @@
   "documentation": "https://www.home-assistant.io/integrations/tesla_fleet",
   "iot_class": "cloud_polling",
   "loggers": ["tesla-fleet-api"],
-  "requirements": ["tesla-fleet-api==1.0.17"]
+  "requirements": ["tesla-fleet-api==1.1.1"]
 }
diff --git a/homeassistant/components/teslemetry/binary_sensor.py b/homeassistant/components/teslemetry/binary_sensor.py
index 99c21cbe03e..a32c5fea40e 100644
--- a/homeassistant/components/teslemetry/binary_sensor.py
+++ b/homeassistant/components/teslemetry/binary_sensor.py
@@ -125,6 +125,9 @@ VEHICLE_DESCRIPTIONS: tuple[TeslemetryBinarySensorEntityDescription, ...] = (
         key="charge_state_conn_charge_cable",
         polling=True,
         polling_value_fn=lambda x: x != "<invalid>",
+        streaming_listener=lambda vehicle, callback: vehicle.listen_ChargingCableType(
+            lambda value: callback(value != "Unknown")
+        ),
         entity_category=EntityCategory.DIAGNOSTIC,
         device_class=BinarySensorDeviceClass.CONNECTIVITY,
     ),
diff --git a/homeassistant/components/teslemetry/manifest.json b/homeassistant/components/teslemetry/manifest.json
index 855cdc9f364..7fc621eeeae 100644
--- a/homeassistant/components/teslemetry/manifest.json
+++ b/homeassistant/components/teslemetry/manifest.json
@@ -6,5 +6,5 @@
   "documentation": "https://www.home-assistant.io/integrations/teslemetry",
   "iot_class": "cloud_polling",
   "loggers": ["tesla-fleet-api"],
-  "requirements": ["tesla-fleet-api==1.0.17", "teslemetry-stream==0.7.9"]
+  "requirements": ["tesla-fleet-api==1.1.1", "teslemetry-stream==0.7.9"]
 }
diff --git a/homeassistant/components/tessie/manifest.json b/homeassistant/components/tessie/manifest.json
index 3f71bcb95e3..9ad87e9dbbe 100644
--- a/homeassistant/components/tessie/manifest.json
+++ b/homeassistant/components/tessie/manifest.json
@@ -6,5 +6,5 @@
   "documentation": "https://www.home-assistant.io/integrations/tessie",
   "iot_class": "cloud_polling",
   "loggers": ["tessie", "tesla-fleet-api"],
-  "requirements": ["tessie-api==0.1.1", "tesla-fleet-api==1.0.17"]
+  "requirements": ["tessie-api==0.1.1", "tesla-fleet-api==1.1.1"]
 }
diff --git a/homeassistant/components/tessie/media_player.py b/homeassistant/components/tessie/media_player.py
index 139ee07ca5b..ecac11587c1 100644
--- a/homeassistant/components/tessie/media_player.py
+++ b/homeassistant/components/tessie/media_player.py
@@ -20,6 +20,10 @@ STATES = {
     "Stopped": MediaPlayerState.IDLE,
 }
 
+# Tesla uses 31 steps, in 0.333 increments up to 10.333
+VOLUME_STEP = 1 / 31
+VOLUME_FACTOR = 31 / 3  # 10.333
+
 PARALLEL_UPDATES = 0
 
 
@@ -38,6 +42,7 @@ class TessieMediaEntity(TessieEntity, MediaPlayerEntity):
     """Vehicle Location Media Class."""
 
     _attr_device_class = MediaPlayerDeviceClass.SPEAKER
+    _attr_volume_step = VOLUME_STEP
 
     def __init__(
         self,
@@ -57,9 +62,7 @@ class TessieMediaEntity(TessieEntity, MediaPlayerEntity):
     @property
     def volume_level(self) -> float:
         """Volume level of the media player (0..1)."""
-        return self.get("vehicle_state_media_info_audio_volume", 0) / self.get(
-            "vehicle_state_media_info_audio_volume_max", 10.333333
-        )
+        return self.get("vehicle_state_media_info_audio_volume", 0) / VOLUME_FACTOR
 
     @property
     def media_duration(self) -> int | None:
diff --git a/homeassistant/components/workday/binary_sensor.py b/homeassistant/components/workday/binary_sensor.py
index 6b878db8159..a48e19e59b2 100644
--- a/homeassistant/components/workday/binary_sensor.py
+++ b/homeassistant/components/workday/binary_sensor.py
@@ -94,21 +94,59 @@ def _get_obj_holidays(
         language=language,
         categories=set_categories,
     )
+
+    supported_languages = obj_holidays.supported_languages
+    default_language = obj_holidays.default_language
+
+    if default_language and not language:
+        # If no language is set, use the default language
+        LOGGER.debug("Changing language from None to %s", default_language)
+        return country_holidays(  # Return default if no language
+            country,
+            subdiv=province,
+            years=year,
+            language=default_language,
+            categories=set_categories,
+        )
+
     if (
-        (supported_languages := obj_holidays.supported_languages)
+        default_language
         and language
+        and language not in supported_languages
         and language.startswith("en")
     ):
+        # If language does not match supported languages, use the first English variant
+        if default_language.startswith("en"):
+            LOGGER.debug("Changing language from %s to %s", language, default_language)
+            return country_holidays(  # Return default English if default language
+                country,
+                subdiv=province,
+                years=year,
+                language=default_language,
+                categories=set_categories,
+            )
         for lang in supported_languages:
             if lang.startswith("en"):
-                obj_holidays = country_holidays(
+                LOGGER.debug("Changing language from %s to %s", language, lang)
+                return country_holidays(
                     country,
                     subdiv=province,
                     years=year,
                     language=lang,
                     categories=set_categories,
                 )
-            LOGGER.debug("Changing language from %s to %s", language, lang)
+
+    if default_language and language and language not in supported_languages:
+        # If language does not match supported languages, use the default language
+        LOGGER.debug("Changing language from %s to %s", language, default_language)
+        return country_holidays(  # Return default English if default language
+            country,
+            subdiv=province,
+            years=year,
+            language=default_language,
+            categories=set_categories,
+        )
+
     return obj_holidays
 
 
diff --git a/homeassistant/components/workday/config_flow.py b/homeassistant/components/workday/config_flow.py
index b0b1e9fcc02..7a8a8181a9f 100644
--- a/homeassistant/components/workday/config_flow.py
+++ b/homeassistant/components/workday/config_flow.py
@@ -67,8 +67,7 @@ def add_province_and_language_to_schema(
 
     _country = country_holidays(country=country)
     if country_default_language := (_country.default_language):
-        selectable_languages = _country.supported_languages
-        new_selectable_languages = list(selectable_languages)
+        new_selectable_languages = list(_country.supported_languages)
         language_schema = {
             vol.Optional(
                 CONF_LANGUAGE, default=country_default_language
@@ -154,19 +153,7 @@ def validate_custom_dates(user_input: dict[str, Any]) -> None:
             years=year,
             language=language,
         )
-        if (
-            (supported_languages := obj_holidays.supported_languages)
-            and language
-            and language.startswith("en")
-        ):
-            for lang in supported_languages:
-                if lang.startswith("en"):
-                    obj_holidays = country_holidays(
-                        country,
-                        subdiv=province,
-                        years=year,
-                        language=lang,
-                    )
+
     else:
         obj_holidays = HolidayBase(years=year)
 
diff --git a/homeassistant/components/zimi/__init__.py b/homeassistant/components/zimi/__init__.py
index a00dd60ee5f..37244bb49e9 100644
--- a/homeassistant/components/zimi/__init__.py
+++ b/homeassistant/components/zimi/__init__.py
@@ -51,7 +51,7 @@ async def async_setup_entry(hass: HomeAssistant, entry: ZimiConfigEntry) -> bool
         config_entry_id=entry.entry_id,
         identifiers={(DOMAIN, api.mac)},
         manufacturer=api.brand,
-        name=f"{api.network_name}",
+        name=api.network_name,
         model="Zimi Cloud Connect",
         sw_version=api.firmware_version,
         connections={(CONNECTION_NETWORK_MAC, api.mac)},
diff --git a/homeassistant/components/zimi/light.py b/homeassistant/components/zimi/light.py
index a93bbb53b3d..d5b7e10d9b3 100644
--- a/homeassistant/components/zimi/light.py
+++ b/homeassistant/components/zimi/light.py
@@ -32,7 +32,7 @@ async def async_setup_entry(
     ]
 
     lights.extend(
-        [ZimiDimmer(device, api) for device in api.lights if device.type == "dimmer"]
+        ZimiDimmer(device, api) for device in api.lights if device.type == "dimmer"
     )
 
     async_add_entities(lights)
@@ -81,8 +81,6 @@ class ZimiDimmer(ZimiLight):
         super().__init__(device, api)
         self._attr_color_mode = ColorMode.BRIGHTNESS
         self._attr_supported_color_modes = {ColorMode.BRIGHTNESS}
-        if self._device.type != "dimmer":
-            raise ValueError("ZimiDimmer needs a dimmable light")
 
     async def async_turn_on(self, **kwargs: Any) -> None:
         """Instruct the light to turn on (with optional brightness)."""
diff --git a/homeassistant/generated/dhcp.py b/homeassistant/generated/dhcp.py
index a9a026cd655..53907d95ae7 100644
--- a/homeassistant/generated/dhcp.py
+++ b/homeassistant/generated/dhcp.py
@@ -26,22 +26,158 @@ DHCP: Final[list[dict[str, str | bool]]] = [
         "domain": "airzone",
         "macaddress": "E84F25*",
     },
+    {
+        "domain": "amazon_devices",
+        "macaddress": "007147*",
+    },
+    {
+        "domain": "amazon_devices",
+        "macaddress": "00FC8B*",
+    },
+    {
+        "domain": "amazon_devices",
+        "macaddress": "0812A5*",
+    },
+    {
+        "domain": "amazon_devices",
+        "macaddress": "086AE5*",
+    },
+    {
+        "domain": "amazon_devices",
+        "macaddress": "08849D*",
+    },
+    {
+        "domain": "amazon_devices",
+        "macaddress": "089115*",
+    },
     {
         "domain": "amazon_devices",
         "macaddress": "08A6BC*",
     },
+    {
+        "domain": "amazon_devices",
+        "macaddress": "08C224*",
+    },
+    {
+        "domain": "amazon_devices",
+        "macaddress": "0CDC91*",
+    },
+    {
+        "domain": "amazon_devices",
+        "macaddress": "0CEE99*",
+    },
+    {
+        "domain": "amazon_devices",
+        "macaddress": "1009F9*",
+    },
+    {
+        "domain": "amazon_devices",
+        "macaddress": "109693*",
+    },
     {
         "domain": "amazon_devices",
         "macaddress": "10BF67*",
     },
+    {
+        "domain": "amazon_devices",
+        "macaddress": "10CE02*",
+    },
+    {
+        "domain": "amazon_devices",
+        "macaddress": "140AC5*",
+    },
+    {
+        "domain": "amazon_devices",
+        "macaddress": "149138*",
+    },
+    {
+        "domain": "amazon_devices",
+        "macaddress": "1848BE*",
+    },
+    {
+        "domain": "amazon_devices",
+        "macaddress": "1C12B0*",
+    },
+    {
+        "domain": "amazon_devices",
+        "macaddress": "1C4D66*",
+    },
+    {
+        "domain": "amazon_devices",
+        "macaddress": "1C93C4*",
+    },
+    {
+        "domain": "amazon_devices",
+        "macaddress": "1CFE2B*",
+    },
+    {
+        "domain": "amazon_devices",
+        "macaddress": "244CE3*",
+    },
+    {
+        "domain": "amazon_devices",
+        "macaddress": "24CE33*",
+    },
+    {
+        "domain": "amazon_devices",
+        "macaddress": "2873F6*",
+    },
+    {
+        "domain": "amazon_devices",
+        "macaddress": "2C71FF*",
+    },
+    {
+        "domain": "amazon_devices",
+        "macaddress": "34AFB3*",
+    },
+    {
+        "domain": "amazon_devices",
+        "macaddress": "34D270*",
+    },
+    {
+        "domain": "amazon_devices",
+        "macaddress": "38F73D*",
+    },
+    {
+        "domain": "amazon_devices",
+        "macaddress": "3C5CC4*",
+    },
+    {
+        "domain": "amazon_devices",
+        "macaddress": "3CE441*",
+    },
     {
         "domain": "amazon_devices",
         "macaddress": "440049*",
     },
+    {
+        "domain": "amazon_devices",
+        "macaddress": "40A2DB*",
+    },
+    {
+        "domain": "amazon_devices",
+        "macaddress": "40A9CF*",
+    },
+    {
+        "domain": "amazon_devices",
+        "macaddress": "40B4CD*",
+    },
     {
         "domain": "amazon_devices",
         "macaddress": "443D54*",
     },
+    {
+        "domain": "amazon_devices",
+        "macaddress": "44650D*",
+    },
+    {
+        "domain": "amazon_devices",
+        "macaddress": "485F2D*",
+    },
+    {
+        "domain": "amazon_devices",
+        "macaddress": "48785E*",
+    },
     {
         "domain": "amazon_devices",
         "macaddress": "48B423*",
@@ -50,6 +186,14 @@ DHCP: Final[list[dict[str, str | bool]]] = [
         "domain": "amazon_devices",
         "macaddress": "4C1744*",
     },
+    {
+        "domain": "amazon_devices",
+        "macaddress": "4CEFC0*",
+    },
+    {
+        "domain": "amazon_devices",
+        "macaddress": "5007C3*",
+    },
     {
         "domain": "amazon_devices",
         "macaddress": "50D45C*",
@@ -58,6 +202,34 @@ DHCP: Final[list[dict[str, str | bool]]] = [
         "domain": "amazon_devices",
         "macaddress": "50DCE7*",
     },
+    {
+        "domain": "amazon_devices",
+        "macaddress": "50F5DA*",
+    },
+    {
+        "domain": "amazon_devices",
+        "macaddress": "5C415A*",
+    },
+    {
+        "domain": "amazon_devices",
+        "macaddress": "6837E9*",
+    },
+    {
+        "domain": "amazon_devices",
+        "macaddress": "6854FD*",
+    },
+    {
+        "domain": "amazon_devices",
+        "macaddress": "689A87*",
+    },
+    {
+        "domain": "amazon_devices",
+        "macaddress": "68B691*",
+    },
+    {
+        "domain": "amazon_devices",
+        "macaddress": "68DBF5*",
+    },
     {
         "domain": "amazon_devices",
         "macaddress": "68F63B*",
@@ -66,18 +238,70 @@ DHCP: Final[list[dict[str, str | bool]]] = [
         "domain": "amazon_devices",
         "macaddress": "6C0C9A*",
     },
+    {
+        "domain": "amazon_devices",
+        "macaddress": "6C5697*",
+    },
+    {
+        "domain": "amazon_devices",
+        "macaddress": "7458F3*",
+    },
+    {
+        "domain": "amazon_devices",
+        "macaddress": "74C246*",
+    },
     {
         "domain": "amazon_devices",
         "macaddress": "74D637*",
     },
+    {
+        "domain": "amazon_devices",
+        "macaddress": "74E20C*",
+    },
+    {
+        "domain": "amazon_devices",
+        "macaddress": "74ECB2*",
+    },
+    {
+        "domain": "amazon_devices",
+        "macaddress": "786C84*",
+    },
+    {
+        "domain": "amazon_devices",
+        "macaddress": "78A03F*",
+    },
     {
         "domain": "amazon_devices",
         "macaddress": "7C6166*",
     },
+    {
+        "domain": "amazon_devices",
+        "macaddress": "7C6305*",
+    },
+    {
+        "domain": "amazon_devices",
+        "macaddress": "7CD566*",
+    },
+    {
+        "domain": "amazon_devices",
+        "macaddress": "8871E5*",
+    },
     {
         "domain": "amazon_devices",
         "macaddress": "901195*",
     },
+    {
+        "domain": "amazon_devices",
+        "macaddress": "90235B*",
+    },
+    {
+        "domain": "amazon_devices",
+        "macaddress": "90A822*",
+    },
+    {
+        "domain": "amazon_devices",
+        "macaddress": "90F82E*",
+    },
     {
         "domain": "amazon_devices",
         "macaddress": "943A91*",
@@ -86,30 +310,154 @@ DHCP: Final[list[dict[str, str | bool]]] = [
         "domain": "amazon_devices",
         "macaddress": "98226E*",
     },
+    {
+        "domain": "amazon_devices",
+        "macaddress": "98CCF3*",
+    },
     {
         "domain": "amazon_devices",
         "macaddress": "9CC8E9*",
     },
+    {
+        "domain": "amazon_devices",
+        "macaddress": "A002DC*",
+    },
+    {
+        "domain": "amazon_devices",
+        "macaddress": "A0D2B1*",
+    },
+    {
+        "domain": "amazon_devices",
+        "macaddress": "A40801*",
+    },
     {
         "domain": "amazon_devices",
         "macaddress": "A8E621*",
     },
+    {
+        "domain": "amazon_devices",
+        "macaddress": "AC416A*",
+    },
+    {
+        "domain": "amazon_devices",
+        "macaddress": "AC63BE*",
+    },
+    {
+        "domain": "amazon_devices",
+        "macaddress": "ACCCFC*",
+    },
+    {
+        "domain": "amazon_devices",
+        "macaddress": "B0739C*",
+    },
+    {
+        "domain": "amazon_devices",
+        "macaddress": "B0CFCB*",
+    },
+    {
+        "domain": "amazon_devices",
+        "macaddress": "B0F7C4*",
+    },
+    {
+        "domain": "amazon_devices",
+        "macaddress": "B85F98*",
+    },
+    {
+        "domain": "amazon_devices",
+        "macaddress": "C091B9*",
+    },
     {
         "domain": "amazon_devices",
         "macaddress": "C095CF*",
     },
+    {
+        "domain": "amazon_devices",
+        "macaddress": "C49500*",
+    },
+    {
+        "domain": "amazon_devices",
+        "macaddress": "C86C3D*",
+    },
+    {
+        "domain": "amazon_devices",
+        "macaddress": "CC9EA2*",
+    },
+    {
+        "domain": "amazon_devices",
+        "macaddress": "CCF735*",
+    },
+    {
+        "domain": "amazon_devices",
+        "macaddress": "DC54D7*",
+    },
     {
         "domain": "amazon_devices",
         "macaddress": "D8BE65*",
     },
+    {
+        "domain": "amazon_devices",
+        "macaddress": "D8FBD6*",
+    },
+    {
+        "domain": "amazon_devices",
+        "macaddress": "DC91BF*",
+    },
+    {
+        "domain": "amazon_devices",
+        "macaddress": "DCA0D0*",
+    },
+    {
+        "domain": "amazon_devices",
+        "macaddress": "E0F728*",
+    },
     {
         "domain": "amazon_devices",
         "macaddress": "EC2BEB*",
     },
+    {
+        "domain": "amazon_devices",
+        "macaddress": "EC8AC4*",
+    },
+    {
+        "domain": "amazon_devices",
+        "macaddress": "ECA138*",
+    },
     {
         "domain": "amazon_devices",
         "macaddress": "F02F9E*",
     },
+    {
+        "domain": "amazon_devices",
+        "macaddress": "F0272D*",
+    },
+    {
+        "domain": "amazon_devices",
+        "macaddress": "F0F0A4*",
+    },
+    {
+        "domain": "amazon_devices",
+        "macaddress": "F4032A*",
+    },
+    {
+        "domain": "amazon_devices",
+        "macaddress": "F854B8*",
+    },
+    {
+        "domain": "amazon_devices",
+        "macaddress": "FC492D*",
+    },
+    {
+        "domain": "amazon_devices",
+        "macaddress": "FC65DE*",
+    },
+    {
+        "domain": "amazon_devices",
+        "macaddress": "FCA183*",
+    },
+    {
+        "domain": "amazon_devices",
+        "macaddress": "FCE9D8*",
+    },
     {
         "domain": "august",
         "hostname": "connect",
diff --git a/homeassistant/generated/integrations.json b/homeassistant/generated/integrations.json
index 4ae336f3c61..775272f77c4 100644
--- a/homeassistant/generated/integrations.json
+++ b/homeassistant/generated/integrations.json
@@ -5867,10 +5867,18 @@
       "iot_class": "local_push"
     },
     "shelly": {
-      "name": "Shelly",
-      "integration_type": "device",
-      "config_flow": true,
-      "iot_class": "local_push"
+      "name": "shelly",
+      "integrations": {
+        "shelly": {
+          "integration_type": "device",
+          "config_flow": true,
+          "iot_class": "local_push",
+          "name": "Shelly"
+        }
+      },
+      "iot_standards": [
+        "zwave"
+      ]
     },
     "shodan": {
       "name": "Shodan",
diff --git a/homeassistant/helpers/update_coordinator.py b/homeassistant/helpers/update_coordinator.py
index 7130264eb0d..bd85391f98f 100644
--- a/homeassistant/helpers/update_coordinator.py
+++ b/homeassistant/helpers/update_coordinator.py
@@ -138,6 +138,8 @@ class DataUpdateCoordinator(BaseDataUpdateCoordinatorProtocol, Generic[_DataT]):
 
         async def _on_hass_stop(_: Event) -> None:
             """Shutdown coordinator on HomeAssistant stop."""
+            # Already cleared on EVENT_HOMEASSISTANT_STOP, via async_fire_internal
+            self._unsub_shutdown = None
             await self.async_shutdown()
 
         self._unsub_shutdown = self.hass.bus.async_listen_once(
diff --git a/homeassistant/package_constraints.txt b/homeassistant/package_constraints.txt
index 378e9fdce83..1f7e280d8eb 100644
--- a/homeassistant/package_constraints.txt
+++ b/homeassistant/package_constraints.txt
@@ -6,7 +6,7 @@ aiodns==3.4.0
 aiohasupervisor==0.3.1
 aiohttp-asyncmdnsresolver==0.1.1
 aiohttp-fast-zlib==0.2.3
-aiohttp==3.12.2
+aiohttp==3.12.6
 aiohttp_cors==0.7.0
 aiousbwatcher==1.1.1
 aiozoneinfo==0.2.3
@@ -38,8 +38,8 @@ habluetooth==3.48.2
 hass-nabucasa==0.101.0
 hassil==2.2.3
 home-assistant-bluetooth==1.13.1
-home-assistant-frontend==20250527.0
-home-assistant-intents==2025.5.7
+home-assistant-frontend==20250531.0
+home-assistant-intents==2025.5.28
 httpx==0.28.1
 ifaddr==0.2.0
 Jinja2==3.1.6
@@ -63,7 +63,7 @@ PyTurboJPEG==1.7.5
 PyYAML==6.0.2
 requests==2.32.3
 securetar==2025.2.1
-SQLAlchemy==2.0.40
+SQLAlchemy==2.0.41
 standard-aifc==3.13.0
 standard-telnetlib==3.13.0
 typing-extensions>=4.13.0,<5.0
@@ -111,8 +111,8 @@ uuid==1000000000.0.0
 # even newer versions seem to introduce new issues, it's useful for us to pin all these
 # requirements so we can directly link HA versions to these library versions.
 anyio==4.9.0
-h11==0.14.0
-httpcore==1.0.7
+h11==0.16.0
+httpcore==1.0.9
 
 # Ensure we have a hyperframe version that works in Python 3.10
 # 5.2.0 fixed a collections abc deprecation
diff --git a/pyproject.toml b/pyproject.toml
index 6f56a869f2d..d0da221f529 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -28,7 +28,7 @@ dependencies = [
   # change behavior based on presence of supervisor. Deprecated with #127228
   # Lib can be removed with 2025.11
   "aiohasupervisor==0.3.1",
-  "aiohttp==3.12.2",
+  "aiohttp==3.12.6",
   "aiohttp_cors==0.7.0",
   "aiohttp-fast-zlib==0.2.3",
   "aiohttp-asyncmdnsresolver==0.1.1",
@@ -66,7 +66,7 @@ dependencies = [
   # onboarding->cloud->assist_pipeline->conversation->home_assistant_intents. Onboarding needs
   # to be setup in stage 0, but we don't want to also promote cloud with all its
   # dependencies to stage 0.
-  "home-assistant-intents==2025.5.7",
+  "home-assistant-intents==2025.5.28",
   "ifaddr==0.2.0",
   "Jinja2==3.1.6",
   "lru-dict==1.3.0",
@@ -108,7 +108,7 @@ dependencies = [
   "PyYAML==6.0.2",
   "requests==2.32.3",
   "securetar==2025.2.1",
-  "SQLAlchemy==2.0.40",
+  "SQLAlchemy==2.0.41",
   "standard-aifc==3.13.0",
   "standard-telnetlib==3.13.0",
   "typing-extensions>=4.13.0,<5.0",
diff --git a/requirements.txt b/requirements.txt
index e4d1cc5ba30..91edebed063 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -5,7 +5,7 @@
 # Home Assistant Core
 aiodns==3.4.0
 aiohasupervisor==0.3.1
-aiohttp==3.12.2
+aiohttp==3.12.6
 aiohttp_cors==0.7.0
 aiohttp-fast-zlib==0.2.3
 aiohttp-asyncmdnsresolver==0.1.1
@@ -27,7 +27,7 @@ hass-nabucasa==0.101.0
 hassil==2.2.3
 httpx==0.28.1
 home-assistant-bluetooth==1.13.1
-home-assistant-intents==2025.5.7
+home-assistant-intents==2025.5.28
 ifaddr==0.2.0
 Jinja2==3.1.6
 lru-dict==1.3.0
@@ -48,7 +48,7 @@ PyTurboJPEG==1.7.5
 PyYAML==6.0.2
 requests==2.32.3
 securetar==2025.2.1
-SQLAlchemy==2.0.40
+SQLAlchemy==2.0.41
 standard-aifc==3.13.0
 standard-telnetlib==3.13.0
 typing-extensions>=4.13.0,<5.0
diff --git a/requirements_all.txt b/requirements_all.txt
index d8ffc983546..fcc6eeca8eb 100644
--- a/requirements_all.txt
+++ b/requirements_all.txt
@@ -113,7 +113,7 @@ RtmAPI==0.7.2
 
 # homeassistant.components.recorder
 # homeassistant.components.sql
-SQLAlchemy==2.0.40
+SQLAlchemy==2.0.41
 
 # homeassistant.components.tami4
 Tami4EdgeAPI==3.0
@@ -265,7 +265,7 @@ aioharmony==0.5.2
 aiohasupervisor==0.3.1
 
 # homeassistant.components.home_connect
-aiohomeconnect==0.17.0
+aiohomeconnect==0.17.1
 
 # homeassistant.components.homekit_controller
 aiohomekit==3.2.14
@@ -280,7 +280,7 @@ aiohue==4.7.4
 aioimaplib==2.0.1
 
 # homeassistant.components.immich
-aioimmich==0.6.0
+aioimmich==0.7.0
 
 # homeassistant.components.apache_kafka
 aiokafka==0.10.0
@@ -405,7 +405,7 @@ aiosyncthing==0.5.1
 aiotankerkoenig==0.4.2
 
 # homeassistant.components.tedee
-aiotedee==0.2.20
+aiotedee==0.2.23
 
 # homeassistant.components.tractive
 aiotractive==0.6.0
@@ -759,7 +759,7 @@ dbus-fast==2.43.0
 debugpy==1.8.14
 
 # homeassistant.components.decora_wifi
-# decora-wifi==1.4
+decora-wifi==1.4
 
 # homeassistant.components.decora
 # decora==0.6
@@ -1164,10 +1164,10 @@ hole==0.8.0
 holidays==0.73
 
 # homeassistant.components.frontend
-home-assistant-frontend==20250527.0
+home-assistant-frontend==20250531.0
 
 # homeassistant.components.conversation
-home-assistant-intents==2025.5.7
+home-assistant-intents==2025.5.28
 
 # homeassistant.components.homematicip_cloud
 homematicip==2.0.1.1
@@ -1617,7 +1617,7 @@ openwrt-luci-rpc==1.1.17
 openwrt-ubus-rpc==0.0.2
 
 # homeassistant.components.opower
-opower==0.12.2
+opower==0.12.3
 
 # homeassistant.components.oralb
 oralb-ble==0.17.6
@@ -1832,7 +1832,7 @@ pyairnow==1.2.1
 pyairvisual==2023.08.1
 
 # homeassistant.components.aprilaire
-pyaprilaire==0.9.0
+pyaprilaire==0.9.1
 
 # homeassistant.components.asuswrt
 pyasuswrt==0.1.21
@@ -2051,7 +2051,7 @@ pyiqvia==2022.04.0
 pyirishrail==0.0.2
 
 # homeassistant.components.iskra
-pyiskra==0.1.15
+pyiskra==0.1.19
 
 # homeassistant.components.iss
 pyiss==1.0.1
@@ -2096,7 +2096,7 @@ pykwb==0.0.8
 pylacrosse==0.4
 
 # homeassistant.components.lamarzocco
-pylamarzocco==2.0.7
+pylamarzocco==2.0.8
 
 # homeassistant.components.lastfm
 pylast==5.1.0
@@ -2251,7 +2251,7 @@ pyplaato==0.0.19
 pypoint==3.0.0
 
 # homeassistant.components.probe_plus
-pyprobeplus==1.0.0
+pyprobeplus==1.0.1
 
 # homeassistant.components.profiler
 pyprof2calltree==1.4.5
@@ -2353,7 +2353,7 @@ pysmhi==1.0.2
 pysml==0.0.12
 
 # homeassistant.components.smlight
-pysmlight==0.2.4
+pysmlight==0.2.5
 
 # homeassistant.components.snmp
 pysnmp==6.2.6
@@ -2452,7 +2452,7 @@ python-juicenet==1.1.0
 python-kasa[speedups]==0.10.2
 
 # homeassistant.components.linkplay
-python-linkplay==0.2.8
+python-linkplay==0.2.9
 
 # homeassistant.components.lirc
 # python-lirc==1.2.3
@@ -2652,7 +2652,7 @@ renault-api==0.3.1
 renson-endura-delta==1.7.2
 
 # homeassistant.components.reolink
-reolink-aio==0.13.3
+reolink-aio==0.13.4
 
 # homeassistant.components.idteck_prox
 rfk101py==0.0.1
@@ -2859,7 +2859,7 @@ surepy==0.9.0
 swisshydrodata==0.1.0
 
 # homeassistant.components.switchbot_cloud
-switchbot-api==2.3.1
+switchbot-api==2.4.0
 
 # homeassistant.components.synology_srm
 synology-srm==0.2.0
@@ -2900,7 +2900,7 @@ temperusb==1.6.1
 # homeassistant.components.tesla_fleet
 # homeassistant.components.teslemetry
 # homeassistant.components.tessie
-tesla-fleet-api==1.0.17
+tesla-fleet-api==1.1.1
 
 # homeassistant.components.powerwall
 tesla-powerwall==0.5.2
diff --git a/requirements_test_all.txt b/requirements_test_all.txt
index f03e3c6bc6a..f3ee6d091d7 100644
--- a/requirements_test_all.txt
+++ b/requirements_test_all.txt
@@ -107,7 +107,7 @@ RtmAPI==0.7.2
 
 # homeassistant.components.recorder
 # homeassistant.components.sql
-SQLAlchemy==2.0.40
+SQLAlchemy==2.0.41
 
 # homeassistant.components.tami4
 Tami4EdgeAPI==3.0
@@ -250,7 +250,7 @@ aioharmony==0.5.2
 aiohasupervisor==0.3.1
 
 # homeassistant.components.home_connect
-aiohomeconnect==0.17.0
+aiohomeconnect==0.17.1
 
 # homeassistant.components.homekit_controller
 aiohomekit==3.2.14
@@ -265,7 +265,7 @@ aiohue==4.7.4
 aioimaplib==2.0.1
 
 # homeassistant.components.immich
-aioimmich==0.6.0
+aioimmich==0.7.0
 
 # homeassistant.components.apache_kafka
 aiokafka==0.10.0
@@ -387,7 +387,7 @@ aiosyncthing==0.5.1
 aiotankerkoenig==0.4.2
 
 # homeassistant.components.tedee
-aiotedee==0.2.20
+aiotedee==0.2.23
 
 # homeassistant.components.tractive
 aiotractive==0.6.0
@@ -561,6 +561,9 @@ bluecurrent-api==1.2.3
 # homeassistant.components.bluemaestro
 bluemaestro-ble==0.4.1
 
+# homeassistant.components.decora
+# bluepy==1.3.0
+
 # homeassistant.components.bluetooth
 bluetooth-adapters==0.21.4
 
@@ -655,6 +658,9 @@ dbus-fast==2.43.0
 # homeassistant.components.debugpy
 debugpy==1.8.14
 
+# homeassistant.components.decora
+# decora==0.6
+
 # homeassistant.components.ecovacs
 deebot-client==13.2.1
 
@@ -1001,10 +1007,10 @@ hole==0.8.0
 holidays==0.73
 
 # homeassistant.components.frontend
-home-assistant-frontend==20250527.0
+home-assistant-frontend==20250531.0
 
 # homeassistant.components.conversation
-home-assistant-intents==2025.5.7
+home-assistant-intents==2025.5.28
 
 # homeassistant.components.homematicip_cloud
 homematicip==2.0.1.1
@@ -1361,7 +1367,7 @@ openhomedevice==2.2.0
 openwebifpy==4.3.1
 
 # homeassistant.components.opower
-opower==0.12.2
+opower==0.12.3
 
 # homeassistant.components.oralb
 oralb-ble==0.17.6
@@ -1525,7 +1531,7 @@ pyairnow==1.2.1
 pyairvisual==2023.08.1
 
 # homeassistant.components.aprilaire
-pyaprilaire==0.9.0
+pyaprilaire==0.9.1
 
 # homeassistant.components.asuswrt
 pyasuswrt==0.1.21
@@ -1560,6 +1566,9 @@ pybravia==0.3.4
 # homeassistant.components.cloudflare
 pycfdns==3.0.0
 
+# homeassistant.components.tensorflow
+# pycocotools==2.0.6
+
 # homeassistant.components.comfoconnect
 pycomfoconnect==0.5.1
 
@@ -1690,7 +1699,7 @@ pyipp==0.17.0
 pyiqvia==2022.04.0
 
 # homeassistant.components.iskra
-pyiskra==0.1.15
+pyiskra==0.1.19
 
 # homeassistant.components.iss
 pyiss==1.0.1
@@ -1726,7 +1735,7 @@ pykrakenapi==0.1.8
 pykulersky==0.5.8
 
 # homeassistant.components.lamarzocco
-pylamarzocco==2.0.7
+pylamarzocco==2.0.8
 
 # homeassistant.components.lastfm
 pylast==5.1.0
@@ -1860,7 +1869,7 @@ pyplaato==0.0.19
 pypoint==3.0.0
 
 # homeassistant.components.probe_plus
-pyprobeplus==1.0.0
+pyprobeplus==1.0.1
 
 # homeassistant.components.profiler
 pyprof2calltree==1.4.5
@@ -1941,7 +1950,7 @@ pysmhi==1.0.2
 pysml==0.0.12
 
 # homeassistant.components.smlight
-pysmlight==0.2.4
+pysmlight==0.2.5
 
 # homeassistant.components.snmp
 pysnmp==6.2.6
@@ -2010,7 +2019,10 @@ python-juicenet==1.1.0
 python-kasa[speedups]==0.10.2
 
 # homeassistant.components.linkplay
-python-linkplay==0.2.8
+python-linkplay==0.2.9
+
+# homeassistant.components.lirc
+# python-lirc==1.2.3
 
 # homeassistant.components.matter
 python-matter-server==7.0.0
@@ -2095,6 +2107,9 @@ pytrydan==0.8.0
 # homeassistant.components.uptimerobot
 pyuptimerobot==22.2.0
 
+# homeassistant.components.keyboard
+# pyuserinput==0.1.11
+
 # homeassistant.components.vera
 pyvera==0.3.15
 
@@ -2177,7 +2192,7 @@ renault-api==0.3.1
 renson-endura-delta==1.7.2
 
 # homeassistant.components.reolink
-reolink-aio==0.13.3
+reolink-aio==0.13.4
 
 # homeassistant.components.rflink
 rflink==0.0.66
@@ -2339,7 +2354,7 @@ subarulink==0.7.13
 surepy==0.9.0
 
 # homeassistant.components.switchbot_cloud
-switchbot-api==2.3.1
+switchbot-api==2.4.0
 
 # homeassistant.components.system_bridge
 systembridgeconnector==4.1.5
@@ -2359,10 +2374,13 @@ temescal==0.5
 # homeassistant.components.temper
 temperusb==1.6.1
 
+# homeassistant.components.tensorflow
+# tensorflow==2.5.0
+
 # homeassistant.components.tesla_fleet
 # homeassistant.components.teslemetry
 # homeassistant.components.tessie
-tesla-fleet-api==1.0.17
+tesla-fleet-api==1.1.1
 
 # homeassistant.components.powerwall
 tesla-powerwall==0.5.2
@@ -2376,6 +2394,9 @@ teslemetry-stream==0.7.9
 # homeassistant.components.tessie
 tessie-api==0.1.1
 
+# homeassistant.components.tensorflow
+# tf-models-official==2.5.0
+
 # homeassistant.components.thermobeacon
 thermobeacon-ble==0.10.0
 
diff --git a/script/gen_requirements_all.py b/script/gen_requirements_all.py
index 082062c53a0..25bb4278cf5 100755
--- a/script/gen_requirements_all.py
+++ b/script/gen_requirements_all.py
@@ -27,7 +27,6 @@ EXCLUDED_REQUIREMENTS_ALL = {
     "beewi-smartclim",  # depends on bluepy
     "bluepy",
     "decora",
-    "decora-wifi",
     "evdev",
     "face-recognition",
     "pybluez",
@@ -43,7 +42,6 @@ EXCLUDED_REQUIREMENTS_ALL = {
 # Requirements excluded by EXCLUDED_REQUIREMENTS_ALL which should be included when
 # building integration wheels for all architectures.
 INCLUDED_REQUIREMENTS_WHEELS = {
-    "decora-wifi",
     "evdev",
     "pycups",
     "python-gammu",
@@ -138,8 +136,8 @@ uuid==1000000000.0.0
 # even newer versions seem to introduce new issues, it's useful for us to pin all these
 # requirements so we can directly link HA versions to these library versions.
 anyio==4.9.0
-h11==0.14.0
-httpcore==1.0.7
+h11==0.16.0
+httpcore==1.0.9
 
 # Ensure we have a hyperframe version that works in Python 3.10
 # 5.2.0 fixed a collections abc deprecation
diff --git a/script/hassfest/docker/Dockerfile b/script/hassfest/docker/Dockerfile
index 5ca638ef487..647755d8237 100644
--- a/script/hassfest/docker/Dockerfile
+++ b/script/hassfest/docker/Dockerfile
@@ -25,7 +25,7 @@ RUN --mount=from=ghcr.io/astral-sh/uv:0.7.1,source=/uv,target=/bin/uv \
         -c /usr/src/homeassistant/homeassistant/package_constraints.txt \
         -r /usr/src/homeassistant/requirements.txt \
         stdlib-list==0.10.0 pipdeptree==2.26.1 tqdm==4.67.1 ruff==0.11.0 \
-        PyTurboJPEG==1.7.5 go2rtc-client==0.1.3b0 ha-ffmpeg==3.2.2 hassil==2.2.3 home-assistant-intents==2025.5.7 mutagen==1.47.0 pymicro-vad==1.0.1 pyspeex-noise==1.0.2
+        PyTurboJPEG==1.7.5 go2rtc-client==0.1.3b0 ha-ffmpeg==3.2.2 hassil==2.2.3 home-assistant-intents==2025.5.28 mutagen==1.47.0 pymicro-vad==1.0.1 pyspeex-noise==1.0.2
 
 LABEL "name"="hassfest"
 LABEL "maintainer"="Home Assistant <hello@home-assistant.io>"
diff --git a/tests/components/abode/common.py b/tests/components/abode/common.py
index 22ee95cfa57..07dc6cf80cd 100644
--- a/tests/components/abode/common.py
+++ b/tests/components/abode/common.py
@@ -2,7 +2,7 @@
 
 from unittest.mock import patch
 
-from homeassistant.components.abode import DOMAIN as ABODE_DOMAIN
+from homeassistant.components.abode import DOMAIN
 from homeassistant.components.abode.const import CONF_POLLING
 from homeassistant.const import CONF_PASSWORD, CONF_USERNAME
 from homeassistant.core import HomeAssistant
@@ -14,7 +14,7 @@ from tests.common import MockConfigEntry
 async def setup_platform(hass: HomeAssistant, platform: str) -> MockConfigEntry:
     """Set up the Abode platform."""
     mock_entry = MockConfigEntry(
-        domain=ABODE_DOMAIN,
+        domain=DOMAIN,
         data={
             CONF_USERNAME: "user@email.com",
             CONF_PASSWORD: "password",
@@ -27,7 +27,7 @@ async def setup_platform(hass: HomeAssistant, platform: str) -> MockConfigEntry:
         patch("homeassistant.components.abode.PLATFORMS", [platform]),
         patch("jaraco.abode.event_controller.sio"),
     ):
-        assert await async_setup_component(hass, ABODE_DOMAIN, {})
+        assert await async_setup_component(hass, DOMAIN, {})
     await hass.async_block_till_done()
 
     return mock_entry
diff --git a/tests/components/abode/test_camera.py b/tests/components/abode/test_camera.py
index 1fcf250935e..5b55e7e6a63 100644
--- a/tests/components/abode/test_camera.py
+++ b/tests/components/abode/test_camera.py
@@ -2,7 +2,7 @@
 
 from unittest.mock import patch
 
-from homeassistant.components.abode.const import DOMAIN as ABODE_DOMAIN
+from homeassistant.components.abode.const import DOMAIN
 from homeassistant.components.camera import DOMAIN as CAMERA_DOMAIN, CameraState
 from homeassistant.const import ATTR_ENTITY_ID
 from homeassistant.core import HomeAssistant
@@ -35,7 +35,7 @@ async def test_capture_image(hass: HomeAssistant) -> None:
 
     with patch("jaraco.abode.devices.camera.Camera.capture") as mock_capture:
         await hass.services.async_call(
-            ABODE_DOMAIN,
+            DOMAIN,
             "capture_image",
             {ATTR_ENTITY_ID: "camera.test_cam"},
             blocking=True,
diff --git a/tests/components/abode/test_init.py b/tests/components/abode/test_init.py
index ed71cb550a7..071fa5dd88a 100644
--- a/tests/components/abode/test_init.py
+++ b/tests/components/abode/test_init.py
@@ -8,7 +8,7 @@ from jaraco.abode.exceptions import (
     Exception as AbodeException,
 )
 
-from homeassistant.components.abode import DOMAIN as ABODE_DOMAIN, SERVICE_SETTINGS
+from homeassistant.components.abode import DOMAIN, SERVICE_SETTINGS
 from homeassistant.components.alarm_control_panel import DOMAIN as ALARM_DOMAIN
 from homeassistant.config_entries import ConfigEntryState
 from homeassistant.const import CONF_USERNAME
@@ -23,7 +23,7 @@ async def test_change_settings(hass: HomeAssistant) -> None:
 
     with patch("jaraco.abode.client.Client.set_setting") as mock_set_setting:
         await hass.services.async_call(
-            ABODE_DOMAIN,
+            DOMAIN,
             SERVICE_SETTINGS,
             {"setting": "confirm_snd", "value": "loud"},
             blocking=True,
diff --git a/tests/components/abode/test_switch.py b/tests/components/abode/test_switch.py
index 9f8e4d3205b..3e2ff7f502a 100644
--- a/tests/components/abode/test_switch.py
+++ b/tests/components/abode/test_switch.py
@@ -2,10 +2,7 @@
 
 from unittest.mock import patch
 
-from homeassistant.components.abode import (
-    DOMAIN as ABODE_DOMAIN,
-    SERVICE_TRIGGER_AUTOMATION,
-)
+from homeassistant.components.abode import DOMAIN, SERVICE_TRIGGER_AUTOMATION
 from homeassistant.components.switch import DOMAIN as SWITCH_DOMAIN
 from homeassistant.const import (
     ATTR_ENTITY_ID,
@@ -119,7 +116,7 @@ async def test_trigger_automation(hass: HomeAssistant) -> None:
 
     with patch("jaraco.abode.automation.Automation.trigger") as mock:
         await hass.services.async_call(
-            ABODE_DOMAIN,
+            DOMAIN,
             SERVICE_TRIGGER_AUTOMATION,
             {ATTR_ENTITY_ID: AUTOMATION_ID},
             blocking=True,
diff --git a/tests/components/advantage_air/test_sensor.py b/tests/components/advantage_air/test_sensor.py
index 3ea368a59fb..9c1c7b36f0c 100644
--- a/tests/components/advantage_air/test_sensor.py
+++ b/tests/components/advantage_air/test_sensor.py
@@ -3,7 +3,7 @@
 from datetime import timedelta
 from unittest.mock import AsyncMock, patch
 
-from homeassistant.components.advantage_air.const import DOMAIN as ADVANTAGE_AIR_DOMAIN
+from homeassistant.components.advantage_air.const import DOMAIN
 from homeassistant.components.advantage_air.sensor import (
     ADVANTAGE_AIR_SERVICE_SET_TIME_TO,
     ADVANTAGE_AIR_SET_COUNTDOWN_VALUE,
@@ -41,7 +41,7 @@ async def test_sensor_platform(
     value = 20
 
     await hass.services.async_call(
-        ADVANTAGE_AIR_DOMAIN,
+        DOMAIN,
         ADVANTAGE_AIR_SERVICE_SET_TIME_TO,
         {ATTR_ENTITY_ID: [entity_id], ADVANTAGE_AIR_SET_COUNTDOWN_VALUE: value},
         blocking=True,
@@ -61,7 +61,7 @@ async def test_sensor_platform(
 
     value = 0
     await hass.services.async_call(
-        ADVANTAGE_AIR_DOMAIN,
+        DOMAIN,
         ADVANTAGE_AIR_SERVICE_SET_TIME_TO,
         {ATTR_ENTITY_ID: [entity_id], ADVANTAGE_AIR_SET_COUNTDOWN_VALUE: value},
         blocking=True,
diff --git a/tests/components/agent_dvr/__init__.py b/tests/components/agent_dvr/__init__.py
index 3f2fc82101a..39618ab54b8 100644
--- a/tests/components/agent_dvr/__init__.py
+++ b/tests/components/agent_dvr/__init__.py
@@ -4,7 +4,7 @@ from homeassistant.components.agent_dvr.const import DOMAIN, SERVER_URL
 from homeassistant.const import CONF_HOST, CONF_PORT, CONTENT_TYPE_JSON
 from homeassistant.core import HomeAssistant
 
-from tests.common import MockConfigEntry, load_fixture
+from tests.common import MockConfigEntry, async_load_fixture
 from tests.test_util.aiohttp import AiohttpClientMocker
 
 CONF_DATA = {
@@ -34,12 +34,12 @@ async def init_integration(
 
     aioclient_mock.get(
         "http://example.local:8090/command.cgi?cmd=getStatus",
-        text=load_fixture("agent_dvr/status.json"),
+        text=await async_load_fixture(hass, "status.json", DOMAIN),
         headers={"Content-Type": CONTENT_TYPE_JSON},
     )
     aioclient_mock.get(
         "http://example.local:8090/command.cgi?cmd=getObjects",
-        text=load_fixture("agent_dvr/objects.json"),
+        text=await async_load_fixture(hass, "objects.json", DOMAIN),
         headers={"Content-Type": CONTENT_TYPE_JSON},
     )
     entry = create_entry(hass)
diff --git a/tests/components/agent_dvr/test_config_flow.py b/tests/components/agent_dvr/test_config_flow.py
index fee8a40f4f7..88332b833a6 100644
--- a/tests/components/agent_dvr/test_config_flow.py
+++ b/tests/components/agent_dvr/test_config_flow.py
@@ -2,8 +2,7 @@
 
 import pytest
 
-from homeassistant.components.agent_dvr import config_flow
-from homeassistant.components.agent_dvr.const import SERVER_URL
+from homeassistant.components.agent_dvr.const import DOMAIN, SERVER_URL
 from homeassistant.config_entries import SOURCE_USER
 from homeassistant.const import CONF_HOST, CONF_PORT, CONTENT_TYPE_JSON
 from homeassistant.core import HomeAssistant
@@ -11,7 +10,7 @@ from homeassistant.data_entry_flow import FlowResultType
 
 from . import init_integration
 
-from tests.common import load_fixture
+from tests.common import async_load_fixture
 from tests.test_util.aiohttp import AiohttpClientMocker
 
 pytestmark = pytest.mark.usefixtures("mock_setup_entry")
@@ -20,7 +19,7 @@ pytestmark = pytest.mark.usefixtures("mock_setup_entry")
 async def test_show_user_form(hass: HomeAssistant) -> None:
     """Test that the user set up form is served."""
     result = await hass.config_entries.flow.async_init(
-        config_flow.DOMAIN,
+        DOMAIN,
         context={"source": SOURCE_USER},
     )
 
@@ -35,7 +34,7 @@ async def test_user_device_exists_abort(
     await init_integration(hass, aioclient_mock)
 
     result = await hass.config_entries.flow.async_init(
-        config_flow.DOMAIN,
+        DOMAIN,
         context={"source": SOURCE_USER},
         data={CONF_HOST: "example.local", CONF_PORT: 8090},
     )
@@ -51,7 +50,7 @@ async def test_connection_error(
     aioclient_mock.get("http://example.local:8090/command.cgi?cmd=getStatus", text="")
 
     result = await hass.config_entries.flow.async_init(
-        config_flow.DOMAIN,
+        DOMAIN,
         context={"source": SOURCE_USER},
         data={CONF_HOST: "example.local", CONF_PORT: 8090},
     )
@@ -67,18 +66,18 @@ async def test_full_user_flow_implementation(
     """Test the full manual user flow from start to finish."""
     aioclient_mock.get(
         "http://example.local:8090/command.cgi?cmd=getStatus",
-        text=load_fixture("agent_dvr/status.json"),
+        text=await async_load_fixture(hass, "status.json", DOMAIN),
         headers={"Content-Type": CONTENT_TYPE_JSON},
     )
 
     aioclient_mock.get(
         "http://example.local:8090/command.cgi?cmd=getObjects",
-        text=load_fixture("agent_dvr/objects.json"),
+        text=await async_load_fixture(hass, "objects.json", DOMAIN),
         headers={"Content-Type": CONTENT_TYPE_JSON},
     )
 
     result = await hass.config_entries.flow.async_init(
-        config_flow.DOMAIN,
+        DOMAIN,
         context={"source": SOURCE_USER},
     )
 
@@ -95,5 +94,5 @@ async def test_full_user_flow_implementation(
     assert result["title"] == "DESKTOP"
     assert result["type"] is FlowResultType.CREATE_ENTRY
 
-    entries = hass.config_entries.async_entries(config_flow.DOMAIN)
+    entries = hass.config_entries.async_entries(DOMAIN)
     assert entries[0].unique_id == "c0715bba-c2d0-48ef-9e3e-bc81c9ea4447"
diff --git a/tests/components/airgradient/test_button.py b/tests/components/airgradient/test_button.py
index 51fbd87ba67..cdcc05413c3 100644
--- a/tests/components/airgradient/test_button.py
+++ b/tests/components/airgradient/test_button.py
@@ -20,7 +20,7 @@ from . import setup_integration
 from tests.common import (
     MockConfigEntry,
     async_fire_time_changed,
-    load_fixture,
+    async_load_fixture,
     snapshot_platform,
 )
 
@@ -81,7 +81,7 @@ async def test_cloud_creates_no_button(
     assert len(hass.states.async_all()) == 0
 
     mock_cloud_airgradient_client.get_config.return_value = Config.from_json(
-        load_fixture("get_config_local.json", DOMAIN)
+        await async_load_fixture(hass, "get_config_local.json", DOMAIN)
     )
 
     freezer.tick(timedelta(minutes=5))
@@ -91,7 +91,7 @@ async def test_cloud_creates_no_button(
     assert len(hass.states.async_all()) == 2
 
     mock_cloud_airgradient_client.get_config.return_value = Config.from_json(
-        load_fixture("get_config_cloud.json", DOMAIN)
+        await async_load_fixture(hass, "get_config_cloud.json", DOMAIN)
     )
 
     freezer.tick(timedelta(minutes=5))
diff --git a/tests/components/airgradient/test_number.py b/tests/components/airgradient/test_number.py
index 6fa1a7d3e07..9d45cc83d24 100644
--- a/tests/components/airgradient/test_number.py
+++ b/tests/components/airgradient/test_number.py
@@ -24,7 +24,7 @@ from . import setup_integration
 from tests.common import (
     MockConfigEntry,
     async_fire_time_changed,
-    load_fixture,
+    async_load_fixture,
     snapshot_platform,
 )
 
@@ -83,7 +83,7 @@ async def test_cloud_creates_no_number(
     assert len(hass.states.async_all()) == 0
 
     mock_cloud_airgradient_client.get_config.return_value = Config.from_json(
-        load_fixture("get_config_local.json", DOMAIN)
+        await async_load_fixture(hass, "get_config_local.json", DOMAIN)
     )
 
     freezer.tick(timedelta(minutes=5))
@@ -93,7 +93,7 @@ async def test_cloud_creates_no_number(
     assert len(hass.states.async_all()) == 2
 
     mock_cloud_airgradient_client.get_config.return_value = Config.from_json(
-        load_fixture("get_config_cloud.json", DOMAIN)
+        await async_load_fixture(hass, "get_config_cloud.json", DOMAIN)
     )
 
     freezer.tick(timedelta(minutes=5))
diff --git a/tests/components/airgradient/test_select.py b/tests/components/airgradient/test_select.py
index 8782af4e46a..872d87f6e58 100644
--- a/tests/components/airgradient/test_select.py
+++ b/tests/components/airgradient/test_select.py
@@ -23,7 +23,7 @@ from . import setup_integration
 from tests.common import (
     MockConfigEntry,
     async_fire_time_changed,
-    load_fixture,
+    async_load_fixture,
     snapshot_platform,
 )
 
@@ -77,7 +77,7 @@ async def test_cloud_creates_no_number(
     assert len(hass.states.async_all()) == 1
 
     mock_cloud_airgradient_client.get_config.return_value = Config.from_json(
-        load_fixture("get_config_local.json", DOMAIN)
+        await async_load_fixture(hass, "get_config_local.json", DOMAIN)
     )
 
     freezer.tick(timedelta(minutes=5))
@@ -87,7 +87,7 @@ async def test_cloud_creates_no_number(
     assert len(hass.states.async_all()) == 7
 
     mock_cloud_airgradient_client.get_config.return_value = Config.from_json(
-        load_fixture("get_config_cloud.json", DOMAIN)
+        await async_load_fixture(hass, "get_config_cloud.json", DOMAIN)
     )
 
     freezer.tick(timedelta(minutes=5))
diff --git a/tests/components/airgradient/test_sensor.py b/tests/components/airgradient/test_sensor.py
index 7679ba48546..5c2976b97ef 100644
--- a/tests/components/airgradient/test_sensor.py
+++ b/tests/components/airgradient/test_sensor.py
@@ -18,7 +18,7 @@ from . import setup_integration
 from tests.common import (
     MockConfigEntry,
     async_fire_time_changed,
-    load_fixture,
+    async_load_fixture,
     snapshot_platform,
 )
 
@@ -46,14 +46,14 @@ async def test_create_entities(
 ) -> None:
     """Test creating entities."""
     mock_airgradient_client.get_current_measures.return_value = Measures.from_json(
-        load_fixture("measures_after_boot.json", DOMAIN)
+        await async_load_fixture(hass, "measures_after_boot.json", DOMAIN)
     )
     with patch("homeassistant.components.airgradient.PLATFORMS", [Platform.SENSOR]):
         await setup_integration(hass, mock_config_entry)
 
     assert len(hass.states.async_all()) == 0
     mock_airgradient_client.get_current_measures.return_value = Measures.from_json(
-        load_fixture("current_measures_indoor.json", DOMAIN)
+        await async_load_fixture(hass, "current_measures_indoor.json", DOMAIN)
     )
     freezer.tick(timedelta(minutes=1))
     async_fire_time_changed(hass)
diff --git a/tests/components/airgradient/test_switch.py b/tests/components/airgradient/test_switch.py
index 12b319379f6..2bbd3ea808b 100644
--- a/tests/components/airgradient/test_switch.py
+++ b/tests/components/airgradient/test_switch.py
@@ -25,7 +25,7 @@ from . import setup_integration
 from tests.common import (
     MockConfigEntry,
     async_fire_time_changed,
-    load_fixture,
+    async_load_fixture,
     snapshot_platform,
 )
 
@@ -83,7 +83,7 @@ async def test_cloud_creates_no_switch(
     assert len(hass.states.async_all()) == 0
 
     mock_cloud_airgradient_client.get_config.return_value = Config.from_json(
-        load_fixture("get_config_local.json", DOMAIN)
+        await async_load_fixture(hass, "get_config_local.json", DOMAIN)
     )
 
     freezer.tick(timedelta(minutes=5))
@@ -93,7 +93,7 @@ async def test_cloud_creates_no_switch(
     assert len(hass.states.async_all()) == 1
 
     mock_cloud_airgradient_client.get_config.return_value = Config.from_json(
-        load_fixture("get_config_cloud.json", DOMAIN)
+        await async_load_fixture(hass, "get_config_cloud.json", DOMAIN)
     )
 
     freezer.tick(timedelta(minutes=5))
diff --git a/tests/components/airly/__init__.py b/tests/components/airly/__init__.py
index c87c41b5162..401bf641350 100644
--- a/tests/components/airly/__init__.py
+++ b/tests/components/airly/__init__.py
@@ -3,7 +3,7 @@
 from homeassistant.components.airly.const import DOMAIN
 from homeassistant.core import HomeAssistant
 
-from tests.common import MockConfigEntry, load_fixture
+from tests.common import MockConfigEntry, async_load_fixture
 from tests.test_util.aiohttp import AiohttpClientMocker
 
 API_NEAREST_URL = "https://airapi.airly.eu/v2/measurements/nearest?lat=123.000000&lng=456.000000&maxDistanceKM=5.000000"
@@ -34,7 +34,9 @@ async def init_integration(
     )
 
     aioclient_mock.get(
-        API_POINT_URL, text=load_fixture("valid_station.json", DOMAIN), headers=HEADERS
+        API_POINT_URL,
+        text=await async_load_fixture(hass, "valid_station.json", DOMAIN),
+        headers=HEADERS,
     )
     entry.add_to_hass(hass)
     await hass.config_entries.async_setup(entry.entry_id)
diff --git a/tests/components/airly/test_config_flow.py b/tests/components/airly/test_config_flow.py
index 7c0cac805d3..482c97799f6 100644
--- a/tests/components/airly/test_config_flow.py
+++ b/tests/components/airly/test_config_flow.py
@@ -12,7 +12,7 @@ from homeassistant.data_entry_flow import FlowResultType
 
 from . import API_NEAREST_URL, API_POINT_URL
 
-from tests.common import MockConfigEntry, load_fixture, patch
+from tests.common import MockConfigEntry, async_load_fixture, patch
 from tests.test_util.aiohttp import AiohttpClientMocker
 
 CONFIG = {
@@ -55,7 +55,9 @@ async def test_invalid_location(
     hass: HomeAssistant, aioclient_mock: AiohttpClientMocker
 ) -> None:
     """Test that errors are shown when location is invalid."""
-    aioclient_mock.get(API_POINT_URL, text=load_fixture("no_station.json", "airly"))
+    aioclient_mock.get(
+        API_POINT_URL, text=await async_load_fixture(hass, "no_station.json", DOMAIN)
+    )
 
     aioclient_mock.get(
         API_NEAREST_URL,
@@ -74,9 +76,13 @@ async def test_invalid_location_for_point_and_nearest(
 ) -> None:
     """Test an abort when the location is wrong for the point and nearest methods."""
 
-    aioclient_mock.get(API_POINT_URL, text=load_fixture("no_station.json", "airly"))
+    aioclient_mock.get(
+        API_POINT_URL, text=await async_load_fixture(hass, "no_station.json", DOMAIN)
+    )
 
-    aioclient_mock.get(API_NEAREST_URL, text=load_fixture("no_station.json", "airly"))
+    aioclient_mock.get(
+        API_NEAREST_URL, text=await async_load_fixture(hass, "no_station.json", DOMAIN)
+    )
 
     with patch("homeassistant.components.airly.async_setup_entry", return_value=True):
         result = await hass.config_entries.flow.async_init(
@@ -91,7 +97,9 @@ async def test_duplicate_error(
     hass: HomeAssistant, aioclient_mock: AiohttpClientMocker
 ) -> None:
     """Test that errors are shown when duplicates are added."""
-    aioclient_mock.get(API_POINT_URL, text=load_fixture("valid_station.json", "airly"))
+    aioclient_mock.get(
+        API_POINT_URL, text=await async_load_fixture(hass, "valid_station.json", DOMAIN)
+    )
     MockConfigEntry(domain=DOMAIN, unique_id="123-456", data=CONFIG).add_to_hass(hass)
 
     result = await hass.config_entries.flow.async_init(
@@ -106,7 +114,9 @@ async def test_create_entry(
     hass: HomeAssistant, aioclient_mock: AiohttpClientMocker
 ) -> None:
     """Test that the user step works."""
-    aioclient_mock.get(API_POINT_URL, text=load_fixture("valid_station.json", "airly"))
+    aioclient_mock.get(
+        API_POINT_URL, text=await async_load_fixture(hass, "valid_station.json", DOMAIN)
+    )
 
     with patch("homeassistant.components.airly.async_setup_entry", return_value=True):
         result = await hass.config_entries.flow.async_init(
@@ -126,10 +136,13 @@ async def test_create_entry_with_nearest_method(
 ) -> None:
     """Test that the user step works with nearest method."""
 
-    aioclient_mock.get(API_POINT_URL, text=load_fixture("no_station.json", "airly"))
+    aioclient_mock.get(
+        API_POINT_URL, text=await async_load_fixture(hass, "no_station.json", DOMAIN)
+    )
 
     aioclient_mock.get(
-        API_NEAREST_URL, text=load_fixture("valid_station.json", "airly")
+        API_NEAREST_URL,
+        text=await async_load_fixture(hass, "valid_station.json", DOMAIN),
     )
 
     with patch("homeassistant.components.airly.async_setup_entry", return_value=True):
diff --git a/tests/components/airly/test_init.py b/tests/components/airly/test_init.py
index 6fc26110186..b7fa8a44360 100644
--- a/tests/components/airly/test_init.py
+++ b/tests/components/airly/test_init.py
@@ -15,7 +15,7 @@ from homeassistant.helpers import device_registry as dr, entity_registry as er
 
 from . import API_POINT_URL, init_integration
 
-from tests.common import MockConfigEntry, async_fire_time_changed, load_fixture
+from tests.common import MockConfigEntry, async_fire_time_changed, async_load_fixture
 from tests.test_util.aiohttp import AiohttpClientMocker
 
 
@@ -69,7 +69,9 @@ async def test_config_without_unique_id(
         },
     )
 
-    aioclient_mock.get(API_POINT_URL, text=load_fixture("valid_station.json", "airly"))
+    aioclient_mock.get(
+        API_POINT_URL, text=await async_load_fixture(hass, "valid_station.json", DOMAIN)
+    )
     entry.add_to_hass(hass)
     await hass.config_entries.async_setup(entry.entry_id)
     assert entry.state is ConfigEntryState.LOADED
@@ -92,7 +94,9 @@ async def test_config_with_turned_off_station(
         },
     )
 
-    aioclient_mock.get(API_POINT_URL, text=load_fixture("no_station.json", "airly"))
+    aioclient_mock.get(
+        API_POINT_URL, text=await async_load_fixture(hass, "no_station.json", DOMAIN)
+    )
     entry.add_to_hass(hass)
     await hass.config_entries.async_setup(entry.entry_id)
     assert entry.state is ConfigEntryState.SETUP_RETRY
@@ -124,7 +128,7 @@ async def test_update_interval(
 
     aioclient_mock.get(
         API_POINT_URL,
-        text=load_fixture("valid_station.json", "airly"),
+        text=await async_load_fixture(hass, "valid_station.json", DOMAIN),
         headers=HEADERS,
     )
     entry.add_to_hass(hass)
@@ -159,7 +163,7 @@ async def test_update_interval(
 
     aioclient_mock.get(
         "https://airapi.airly.eu/v2/measurements/point?lat=66.660000&lng=111.110000",
-        text=load_fixture("valid_station.json", "airly"),
+        text=await async_load_fixture(hass, "valid_station.json", DOMAIN),
         headers=HEADERS,
     )
     entry.add_to_hass(hass)
@@ -216,7 +220,9 @@ async def test_migrate_device_entry(
         },
     )
 
-    aioclient_mock.get(API_POINT_URL, text=load_fixture("valid_station.json", "airly"))
+    aioclient_mock.get(
+        API_POINT_URL, text=await async_load_fixture(hass, "valid_station.json", DOMAIN)
+    )
     config_entry.add_to_hass(hass)
 
     device_entry = device_registry.async_get_or_create(
diff --git a/tests/components/airly/test_sensor.py b/tests/components/airly/test_sensor.py
index f45bbb65f6f..970ec4e0e2b 100644
--- a/tests/components/airly/test_sensor.py
+++ b/tests/components/airly/test_sensor.py
@@ -7,6 +7,7 @@ from unittest.mock import patch
 from airly.exceptions import AirlyError
 from syrupy.assertion import SnapshotAssertion
 
+from homeassistant.components.airly.const import DOMAIN
 from homeassistant.const import ATTR_ENTITY_ID, STATE_UNAVAILABLE, Platform
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers import entity_registry as er
@@ -15,7 +16,7 @@ from homeassistant.util.dt import utcnow
 
 from . import API_POINT_URL, init_integration
 
-from tests.common import async_fire_time_changed, load_fixture
+from tests.common import async_fire_time_changed, async_load_fixture
 from tests.test_util.aiohttp import AiohttpClientMocker
 
 
@@ -62,7 +63,9 @@ async def test_availability(
     assert state.state == STATE_UNAVAILABLE
 
     aioclient_mock.clear_requests()
-    aioclient_mock.get(API_POINT_URL, text=load_fixture("valid_station.json", "airly"))
+    aioclient_mock.get(
+        API_POINT_URL, text=await async_load_fixture(hass, "valid_station.json", DOMAIN)
+    )
     future = utcnow() + timedelta(minutes=120)
     async_fire_time_changed(hass, future)
     await hass.async_block_till_done()
diff --git a/tests/components/alarm_control_panel/__init__.py b/tests/components/alarm_control_panel/__init__.py
index 1f43c567844..afaae8f1c70 100644
--- a/tests/components/alarm_control_panel/__init__.py
+++ b/tests/components/alarm_control_panel/__init__.py
@@ -1,8 +1,5 @@
 """The tests for Alarm control panel platforms."""
 
-from homeassistant.components.alarm_control_panel import (
-    DOMAIN as ALARM_CONTROL_PANEL_DOMAIN,
-)
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import Platform
 from homeassistant.core import HomeAssistant
@@ -13,7 +10,7 @@ async def help_async_setup_entry_init(
 ) -> bool:
     """Set up test config entry."""
     await hass.config_entries.async_forward_entry_setups(
-        config_entry, [ALARM_CONTROL_PANEL_DOMAIN]
+        config_entry, [Platform.ALARM_CONTROL_PANEL]
     )
     return True
 
diff --git a/tests/components/alarm_control_panel/conftest.py b/tests/components/alarm_control_panel/conftest.py
index 541644def38..d51875b73dc 100644
--- a/tests/components/alarm_control_panel/conftest.py
+++ b/tests/components/alarm_control_panel/conftest.py
@@ -6,12 +6,13 @@ from unittest.mock import MagicMock, patch
 import pytest
 
 from homeassistant.components.alarm_control_panel import (
-    DOMAIN as ALARM_CONTROL_PANEL_DOMAIN,
+    DOMAIN,
     AlarmControlPanelEntity,
     AlarmControlPanelEntityFeature,
 )
 from homeassistant.components.alarm_control_panel.const import CodeFormat
 from homeassistant.config_entries import ConfigEntry, ConfigFlow
+from homeassistant.const import Platform
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers import entity_registry as er, frame
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
@@ -172,7 +173,7 @@ async def setup_alarm_control_panel_platform_test_entity(
     ) -> bool:
         """Set up test config entry."""
         await hass.config_entries.async_forward_entry_setups(
-            config_entry, [ALARM_CONTROL_PANEL_DOMAIN]
+            config_entry, [Platform.ALARM_CONTROL_PANEL]
         )
         return True
 
@@ -201,7 +202,7 @@ async def setup_alarm_control_panel_platform_test_entity(
 
     mock_platform(
         hass,
-        f"{TEST_DOMAIN}.{ALARM_CONTROL_PANEL_DOMAIN}",
+        f"{TEST_DOMAIN}.{DOMAIN}",
         MockPlatform(async_setup_entry=async_setup_entry_platform),
     )
 
diff --git a/tests/components/alarm_control_panel/test_init.py b/tests/components/alarm_control_panel/test_init.py
index 01d103d01aa..bb168c35930 100644
--- a/tests/components/alarm_control_panel/test_init.py
+++ b/tests/components/alarm_control_panel/test_init.py
@@ -6,7 +6,7 @@ import pytest
 
 from homeassistant.components import alarm_control_panel
 from homeassistant.components.alarm_control_panel import (
-    DOMAIN as ALARM_CONTROL_PANEL_DOMAIN,
+    DOMAIN,
     AlarmControlPanelEntityFeature,
     CodeFormat,
 )
@@ -280,9 +280,7 @@ async def test_alarm_control_panel_log_deprecated_state_warning_using_state_prop
         ),
         built_in=False,
     )
-    setup_test_component_platform(
-        hass, ALARM_CONTROL_PANEL_DOMAIN, [entity], from_config_entry=True
-    )
+    setup_test_component_platform(hass, DOMAIN, [entity], from_config_entry=True)
     assert await hass.config_entries.async_setup(config_entry.entry_id)
 
     state = hass.states.get(entity.entity_id)
@@ -343,9 +341,7 @@ async def test_alarm_control_panel_log_deprecated_state_warning_using_attr_state
         ),
         built_in=False,
     )
-    setup_test_component_platform(
-        hass, ALARM_CONTROL_PANEL_DOMAIN, [entity], from_config_entry=True
-    )
+    setup_test_component_platform(hass, DOMAIN, [entity], from_config_entry=True)
     assert await hass.config_entries.async_setup(config_entry.entry_id)
 
     state = hass.states.get(entity.entity_id)
@@ -426,9 +422,7 @@ async def test_alarm_control_panel_deprecated_state_does_not_break_state(
         ),
         built_in=False,
     )
-    setup_test_component_platform(
-        hass, ALARM_CONTROL_PANEL_DOMAIN, [entity], from_config_entry=True
-    )
+    setup_test_component_platform(hass, DOMAIN, [entity], from_config_entry=True)
     assert await hass.config_entries.async_setup(config_entry.entry_id)
 
     state = hass.states.get(entity.entity_id)
diff --git a/tests/components/assist_pipeline/test_select.py b/tests/components/assist_pipeline/test_select.py
index fec34cb2496..c1577b4beaf 100644
--- a/tests/components/assist_pipeline/test_select.py
+++ b/tests/components/assist_pipeline/test_select.py
@@ -16,6 +16,7 @@ from homeassistant.components.assist_pipeline.select import (
 )
 from homeassistant.components.assist_pipeline.vad import VadSensitivity
 from homeassistant.config_entries import ConfigEntry, ConfigEntryState
+from homeassistant.const import Platform
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers import device_registry as dr
 from homeassistant.helpers.device_registry import DeviceInfo
@@ -53,7 +54,9 @@ async def init_select(hass: HomeAssistant, init_components) -> ConfigEntry:
         domain="assist_pipeline", state=ConfigEntryState.LOADED
     )
     config_entry.add_to_hass(hass)
-    await hass.config_entries.async_forward_entry_setups(config_entry, ["select"])
+    await hass.config_entries.async_forward_entry_setups(
+        config_entry, [Platform.SELECT]
+    )
     return config_entry
 
 
@@ -160,8 +163,12 @@ async def test_select_entity_changing_pipelines(
     assert state.state == pipeline_2.name
 
     # Reload config entry to test selected option persists
-    assert await hass.config_entries.async_forward_entry_unload(config_entry, "select")
-    await hass.config_entries.async_forward_entry_setups(config_entry, ["select"])
+    assert await hass.config_entries.async_forward_entry_unload(
+        config_entry, Platform.SELECT
+    )
+    await hass.config_entries.async_forward_entry_setups(
+        config_entry, [Platform.SELECT]
+    )
 
     state = hass.states.get("select.assist_pipeline_test_prefix_pipeline")
     assert state is not None
@@ -208,8 +215,12 @@ async def test_select_entity_changing_vad_sensitivity(
     assert state.state == VadSensitivity.AGGRESSIVE.value
 
     # Reload config entry to test selected option persists
-    assert await hass.config_entries.async_forward_entry_unload(config_entry, "select")
-    await hass.config_entries.async_forward_entry_setups(config_entry, ["select"])
+    assert await hass.config_entries.async_forward_entry_unload(
+        config_entry, Platform.SELECT
+    )
+    await hass.config_entries.async_forward_entry_setups(
+        config_entry, [Platform.SELECT]
+    )
 
     state = hass.states.get("select.assist_pipeline_test_vad_sensitivity")
     assert state is not None
diff --git a/tests/components/assist_satellite/conftest.py b/tests/components/assist_satellite/conftest.py
index 79e4061bacc..8f8d3bb1d9a 100644
--- a/tests/components/assist_satellite/conftest.py
+++ b/tests/components/assist_satellite/conftest.py
@@ -7,7 +7,7 @@ import pytest
 
 from homeassistant.components.assist_pipeline import PipelineEvent
 from homeassistant.components.assist_satellite import (
-    DOMAIN as AS_DOMAIN,
+    DOMAIN,
     AssistSatelliteAnnouncement,
     AssistSatelliteConfiguration,
     AssistSatelliteEntity,
@@ -15,6 +15,7 @@ from homeassistant.components.assist_satellite import (
     AssistSatelliteWakeWord,
 )
 from homeassistant.config_entries import ConfigEntry, ConfigFlow
+from homeassistant.const import Platform
 from homeassistant.core import HomeAssistant, callback
 from homeassistant.helpers.entity import DeviceInfo
 from homeassistant.setup import async_setup_component
@@ -144,14 +145,18 @@ async def init_components(
         hass: HomeAssistant, config_entry: ConfigEntry
     ) -> bool:
         """Set up test config entry."""
-        await hass.config_entries.async_forward_entry_setups(config_entry, [AS_DOMAIN])
+        await hass.config_entries.async_forward_entry_setups(
+            config_entry, [Platform.ASSIST_SATELLITE]
+        )
         return True
 
     async def async_unload_entry_init(
         hass: HomeAssistant, config_entry: ConfigEntry
     ) -> bool:
         """Unload test config entry."""
-        await hass.config_entries.async_forward_entry_unload(config_entry, AS_DOMAIN)
+        await hass.config_entries.async_forward_entry_unload(
+            config_entry, Platform.ASSIST_SATELLITE
+        )
         return True
 
     mock_integration(
@@ -163,7 +168,7 @@ async def init_components(
         ),
     )
     setup_test_component_platform(
-        hass, AS_DOMAIN, [entity, entity2, entity_no_features], from_config_entry=True
+        hass, DOMAIN, [entity, entity2, entity_no_features], from_config_entry=True
     )
     mock_platform(hass, f"{TEST_DOMAIN}.config_flow", Mock())
 
diff --git a/tests/components/aussie_broadband/common.py b/tests/components/aussie_broadband/common.py
index a2bc79a42a6..a2519083946 100644
--- a/tests/components/aussie_broadband/common.py
+++ b/tests/components/aussie_broadband/common.py
@@ -3,10 +3,7 @@
 from typing import Any
 from unittest.mock import patch
 
-from homeassistant.components.aussie_broadband.const import (
-    CONF_SERVICES,
-    DOMAIN as AUSSIE_BROADBAND_DOMAIN,
-)
+from homeassistant.components.aussie_broadband.const import CONF_SERVICES, DOMAIN
 from homeassistant.const import CONF_PASSWORD, CONF_USERNAME, Platform
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.typing import UNDEFINED, UndefinedType
@@ -49,7 +46,7 @@ async def setup_platform(
 ):
     """Set up the Aussie Broadband platform."""
     mock_entry = MockConfigEntry(
-        domain=AUSSIE_BROADBAND_DOMAIN,
+        domain=DOMAIN,
         data=FAKE_DATA,
         options={
             CONF_SERVICES: ["12345678", "87654321", "23456789", "98765432"],
diff --git a/tests/components/axis/conftest.py b/tests/components/axis/conftest.py
index c3377c15955..d2693a83f05 100644
--- a/tests/components/axis/conftest.py
+++ b/tests/components/axis/conftest.py
@@ -12,7 +12,7 @@ from axis.rtsp import Signal, State
 import pytest
 import respx
 
-from homeassistant.components.axis.const import DOMAIN as AXIS_DOMAIN
+from homeassistant.components.axis.const import DOMAIN
 from homeassistant.const import (
     CONF_HOST,
     CONF_MODEL,
@@ -91,7 +91,7 @@ def fixture_config_entry(
 ) -> MockConfigEntry:
     """Define a config entry fixture."""
     return MockConfigEntry(
-        domain=AXIS_DOMAIN,
+        domain=DOMAIN,
         entry_id="676abe5b73621446e6550a2e86ffe3dd",
         unique_id=FORMATTED_MAC,
         data=config_entry_data,
diff --git a/tests/components/axis/test_config_flow.py b/tests/components/axis/test_config_flow.py
index c7c3097aaaa..2d141c4c245 100644
--- a/tests/components/axis/test_config_flow.py
+++ b/tests/components/axis/test_config_flow.py
@@ -12,7 +12,7 @@ from homeassistant.components.axis.const import (
     CONF_VIDEO_SOURCE,
     DEFAULT_STREAM_PROFILE,
     DEFAULT_VIDEO_SOURCE,
-    DOMAIN as AXIS_DOMAIN,
+    DOMAIN,
 )
 from homeassistant.config_entries import (
     SOURCE_DHCP,
@@ -47,7 +47,7 @@ DHCP_FORMATTED_MAC = dr.format_mac(MAC).replace(":", "")
 async def test_flow_manual_configuration(hass: HomeAssistant) -> None:
     """Test that config flow works."""
     result = await hass.config_entries.flow.async_init(
-        AXIS_DOMAIN, context={"source": SOURCE_USER}
+        DOMAIN, context={"source": SOURCE_USER}
     )
 
     assert result["type"] is FlowResultType.FORM
@@ -86,7 +86,7 @@ async def test_manual_configuration_duplicate_fails(
     assert config_entry_setup.data[CONF_HOST] == "1.2.3.4"
 
     result = await hass.config_entries.flow.async_init(
-        AXIS_DOMAIN, context={"source": SOURCE_USER}
+        DOMAIN, context={"source": SOURCE_USER}
     )
 
     assert result["type"] is FlowResultType.FORM
@@ -122,7 +122,7 @@ async def test_flow_fails_on_api(
 ) -> None:
     """Test that config flow fails on faulty credentials."""
     result = await hass.config_entries.flow.async_init(
-        AXIS_DOMAIN, context={"source": SOURCE_USER}
+        DOMAIN, context={"source": SOURCE_USER}
     )
 
     assert result["type"] is FlowResultType.FORM
@@ -152,18 +152,18 @@ async def test_flow_create_entry_multiple_existing_entries_of_same_model(
 ) -> None:
     """Test that create entry can generate a name with other entries."""
     entry = MockConfigEntry(
-        domain=AXIS_DOMAIN,
+        domain=DOMAIN,
         data={CONF_NAME: "M1065-LW 0", CONF_MODEL: "M1065-LW"},
     )
     entry.add_to_hass(hass)
     entry2 = MockConfigEntry(
-        domain=AXIS_DOMAIN,
+        domain=DOMAIN,
         data={CONF_NAME: "M1065-LW 1", CONF_MODEL: "M1065-LW"},
     )
     entry2.add_to_hass(hass)
 
     result = await hass.config_entries.flow.async_init(
-        AXIS_DOMAIN, context={"source": SOURCE_USER}
+        DOMAIN, context={"source": SOURCE_USER}
     )
 
     assert result["type"] is FlowResultType.FORM
@@ -337,7 +337,7 @@ async def test_discovery_flow(
 ) -> None:
     """Test the different discovery flows for new devices work."""
     result = await hass.config_entries.flow.async_init(
-        AXIS_DOMAIN, data=discovery_info, context={"source": source}
+        DOMAIN, data=discovery_info, context={"source": source}
     )
 
     assert result["type"] is FlowResultType.FORM
@@ -420,7 +420,7 @@ async def test_discovered_device_already_configured(
     assert config_entry_setup.data[CONF_HOST] == DEFAULT_HOST
 
     result = await hass.config_entries.flow.async_init(
-        AXIS_DOMAIN, data=discovery_info, context={"source": source}
+        DOMAIN, data=discovery_info, context={"source": source}
     )
 
     assert result["type"] is FlowResultType.ABORT
@@ -488,7 +488,7 @@ async def test_discovery_flow_updated_configuration(
 
     mock_requests("2.3.4.5")
     result = await hass.config_entries.flow.async_init(
-        AXIS_DOMAIN, data=discovery_info, context={"source": source}
+        DOMAIN, data=discovery_info, context={"source": source}
     )
     await hass.async_block_till_done()
 
@@ -546,7 +546,7 @@ async def test_discovery_flow_ignore_non_axis_device(
 ) -> None:
     """Test that discovery flow ignores devices with non Axis OUI."""
     result = await hass.config_entries.flow.async_init(
-        AXIS_DOMAIN, data=discovery_info, context={"source": source}
+        DOMAIN, data=discovery_info, context={"source": source}
     )
 
     assert result["type"] is FlowResultType.ABORT
@@ -595,7 +595,7 @@ async def test_discovery_flow_ignore_link_local_address(
 ) -> None:
     """Test that discovery flow ignores devices with link local addresses."""
     result = await hass.config_entries.flow.async_init(
-        AXIS_DOMAIN, data=discovery_info, context={"source": source}
+        DOMAIN, data=discovery_info, context={"source": source}
     )
 
     assert result["type"] is FlowResultType.ABORT
diff --git a/tests/components/axis/test_hub.py b/tests/components/axis/test_hub.py
index a7da7891d50..2d963cf56fb 100644
--- a/tests/components/axis/test_hub.py
+++ b/tests/components/axis/test_hub.py
@@ -12,7 +12,7 @@ import pytest
 from syrupy.assertion import SnapshotAssertion
 
 from homeassistant.components import axis
-from homeassistant.components.axis.const import DOMAIN as AXIS_DOMAIN
+from homeassistant.components.axis.const import DOMAIN
 from homeassistant.components.binary_sensor import DOMAIN as BINARY_SENSOR_DOMAIN
 from homeassistant.config_entries import SOURCE_ZEROCONF, ConfigEntryState
 from homeassistant.const import STATE_OFF, STATE_ON, STATE_UNAVAILABLE
@@ -43,7 +43,7 @@ async def test_device_registry_entry(
 ) -> None:
     """Successful setup."""
     device_entry = device_registry.async_get_device(
-        identifiers={(AXIS_DOMAIN, config_entry_setup.unique_id)}
+        identifiers={(DOMAIN, config_entry_setup.unique_id)}
     )
     assert device_entry == snapshot
 
@@ -93,7 +93,7 @@ async def test_update_address(
 
     mock_requests("2.3.4.5")
     await hass.config_entries.flow.async_init(
-        AXIS_DOMAIN,
+        DOMAIN,
         data=ZeroconfServiceInfo(
             ip_address=ip_address("2.3.4.5"),
             ip_addresses=[ip_address("2.3.4.5")],
diff --git a/tests/components/balboa/test_init.py b/tests/components/balboa/test_init.py
index ecbadac0c09..1201fd8e6d8 100644
--- a/tests/components/balboa/test_init.py
+++ b/tests/components/balboa/test_init.py
@@ -2,7 +2,7 @@
 
 from unittest.mock import MagicMock
 
-from homeassistant.components.balboa.const import DOMAIN as BALBOA_DOMAIN
+from homeassistant.components.balboa.const import DOMAIN
 from homeassistant.config_entries import ConfigEntryState
 from homeassistant.const import CONF_HOST
 from homeassistant.core import HomeAssistant
@@ -24,7 +24,7 @@ async def test_setup_entry(
 async def test_setup_entry_fails(hass: HomeAssistant, client: MagicMock) -> None:
     """Validate that setup entry also configure the client."""
     config_entry = MockConfigEntry(
-        domain=BALBOA_DOMAIN,
+        domain=DOMAIN,
         data={
             CONF_HOST: TEST_HOST,
         },
diff --git a/tests/components/binary_sensor/test_init.py b/tests/components/binary_sensor/test_init.py
index de2b2565fe1..212cfd737d0 100644
--- a/tests/components/binary_sensor/test_init.py
+++ b/tests/components/binary_sensor/test_init.py
@@ -7,7 +7,7 @@ import pytest
 
 from homeassistant.components import binary_sensor
 from homeassistant.config_entries import ConfigEntry, ConfigFlow
-from homeassistant.const import STATE_OFF, STATE_ON, EntityCategory
+from homeassistant.const import STATE_OFF, STATE_ON, EntityCategory, Platform
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
@@ -62,7 +62,7 @@ async def test_name(hass: HomeAssistant) -> None:
     ) -> bool:
         """Set up test config entry."""
         await hass.config_entries.async_forward_entry_setups(
-            config_entry, [binary_sensor.DOMAIN]
+            config_entry, [Platform.BINARY_SENSOR]
         )
         return True
 
@@ -142,7 +142,7 @@ async def test_entity_category_config_raises_error(
     ) -> bool:
         """Set up test config entry."""
         await hass.config_entries.async_forward_entry_setups(
-            config_entry, [binary_sensor.DOMAIN]
+            config_entry, [Platform.BINARY_SENSOR]
         )
         return True
 
diff --git a/tests/components/blueprint/test_importer.py b/tests/components/blueprint/test_importer.py
index c61be9e2b32..cccbaa3db3e 100644
--- a/tests/components/blueprint/test_importer.py
+++ b/tests/components/blueprint/test_importer.py
@@ -6,11 +6,11 @@ from pathlib import Path
 import pytest
 from syrupy.assertion import SnapshotAssertion
 
-from homeassistant.components.blueprint import importer
+from homeassistant.components.blueprint import DOMAIN, importer
 from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import HomeAssistantError
 
-from tests.common import load_fixture
+from tests.common import async_load_fixture, load_fixture
 from tests.test_util.aiohttp import AiohttpClientMocker
 
 
@@ -161,7 +161,7 @@ async def test_fetch_blueprint_from_github_gist_url(
     """Test fetching blueprint from url."""
     aioclient_mock.get(
         "https://api.github.com/gists/e717ce85dd0d2f1bdcdfc884ea25a344",
-        text=load_fixture("blueprint/github_gist.json"),
+        text=await async_load_fixture(hass, "github_gist.json", DOMAIN),
     )
 
     url = "https://gist.github.com/balloob/e717ce85dd0d2f1bdcdfc884ea25a344"
diff --git a/tests/components/bluesound/test_media_player.py b/tests/components/bluesound/test_media_player.py
index dcff33399f5..d2a72200423 100644
--- a/tests/components/bluesound/test_media_player.py
+++ b/tests/components/bluesound/test_media_player.py
@@ -9,7 +9,7 @@ import pytest
 from syrupy.assertion import SnapshotAssertion
 from syrupy.filters import props
 
-from homeassistant.components.bluesound import DOMAIN as BLUESOUND_DOMAIN
+from homeassistant.components.bluesound import DOMAIN
 from homeassistant.components.bluesound.const import ATTR_MASTER
 from homeassistant.components.bluesound.media_player import (
     SERVICE_CLEAR_TIMER,
@@ -230,7 +230,7 @@ async def test_set_sleep_timer(
 ) -> None:
     """Test the set sleep timer action."""
     await hass.services.async_call(
-        BLUESOUND_DOMAIN,
+        DOMAIN,
         SERVICE_SET_TIMER,
         {ATTR_ENTITY_ID: "media_player.player_name1111"},
         blocking=True,
@@ -247,7 +247,7 @@ async def test_clear_sleep_timer(
     player_mocks.player_data.player.sleep_timer.side_effect = [15, 30, 45, 60, 90, 0]
 
     await hass.services.async_call(
-        BLUESOUND_DOMAIN,
+        DOMAIN,
         SERVICE_CLEAR_TIMER,
         {ATTR_ENTITY_ID: "media_player.player_name1111"},
         blocking=True,
@@ -262,7 +262,7 @@ async def test_join_cannot_join_to_self(
     """Test that joining to self is not allowed."""
     with pytest.raises(ServiceValidationError, match="Cannot join player to itself"):
         await hass.services.async_call(
-            BLUESOUND_DOMAIN,
+            DOMAIN,
             SERVICE_JOIN,
             {
                 ATTR_ENTITY_ID: "media_player.player_name1111",
@@ -280,7 +280,7 @@ async def test_join(
 ) -> None:
     """Test the join action."""
     await hass.services.async_call(
-        BLUESOUND_DOMAIN,
+        DOMAIN,
         SERVICE_JOIN,
         {
             ATTR_ENTITY_ID: "media_player.player_name1111",
@@ -311,7 +311,7 @@ async def test_unjoin(
     await hass.async_block_till_done()
 
     await hass.services.async_call(
-        BLUESOUND_DOMAIN,
+        DOMAIN,
         "unjoin",
         {ATTR_ENTITY_ID: "media_player.player_name1111"},
         blocking=True,
diff --git a/tests/components/bluetooth/test_base_scanner.py b/tests/components/bluetooth/test_base_scanner.py
index acd630863d2..25dc1b9738d 100644
--- a/tests/components/bluetooth/test_base_scanner.py
+++ b/tests/components/bluetooth/test_base_scanner.py
@@ -41,7 +41,7 @@ from . import (
     patch_bluetooth_time,
 )
 
-from tests.common import MockConfigEntry, async_fire_time_changed, load_fixture
+from tests.common import MockConfigEntry, async_fire_time_changed, async_load_fixture
 
 
 @pytest.mark.parametrize("name_2", [None, "w"])
@@ -313,7 +313,7 @@ async def test_restore_history_remote_adapter(
     """Test we can restore history for a remote adapter."""
 
     data = hass_storage[storage.REMOTE_SCANNER_STORAGE_KEY] = json_loads(
-        load_fixture("bluetooth.remote_scanners", bluetooth.DOMAIN)
+        await async_load_fixture(hass, "bluetooth.remote_scanners", bluetooth.DOMAIN)
     )
     now = time.time()
     timestamps = data["data"]["atom-bluetooth-proxy-ceaac4"][
diff --git a/tests/components/bluetooth/test_manager.py b/tests/components/bluetooth/test_manager.py
index bf773b69a99..7488aa6e33c 100644
--- a/tests/components/bluetooth/test_manager.py
+++ b/tests/components/bluetooth/test_manager.py
@@ -63,7 +63,7 @@ from tests.common import (
     MockModule,
     async_call_logger_set_level,
     async_fire_time_changed,
-    load_fixture,
+    async_load_fixture,
     mock_integration,
 )
 
@@ -453,7 +453,7 @@ async def test_restore_history_from_dbus_and_remote_adapters(
     address = "AA:BB:CC:CC:CC:FF"
 
     data = hass_storage[storage.REMOTE_SCANNER_STORAGE_KEY] = json_loads(
-        load_fixture("bluetooth.remote_scanners", bluetooth.DOMAIN)
+        await async_load_fixture(hass, "bluetooth.remote_scanners", bluetooth.DOMAIN)
     )
     now = time.time()
     timestamps = data["data"]["atom-bluetooth-proxy-ceaac4"][
@@ -495,7 +495,9 @@ async def test_restore_history_from_dbus_and_corrupted_remote_adapters(
     address = "AA:BB:CC:CC:CC:FF"
 
     data = hass_storage[storage.REMOTE_SCANNER_STORAGE_KEY] = json_loads(
-        load_fixture("bluetooth.remote_scanners.corrupt", bluetooth.DOMAIN)
+        await async_load_fixture(
+            hass, "bluetooth.remote_scanners.corrupt", bluetooth.DOMAIN
+        )
     )
     now = time.time()
     timestamps = data["data"]["atom-bluetooth-proxy-ceaac4"][
diff --git a/tests/components/bmw_connected_drive/__init__.py b/tests/components/bmw_connected_drive/__init__.py
index 2cd65364604..54711619400 100644
--- a/tests/components/bmw_connected_drive/__init__.py
+++ b/tests/components/bmw_connected_drive/__init__.py
@@ -13,7 +13,7 @@ from homeassistant.components.bmw_connected_drive.const import (
     CONF_GCID,
     CONF_READ_ONLY,
     CONF_REFRESH_TOKEN,
-    DOMAIN as BMW_DOMAIN,
+    DOMAIN,
 )
 from homeassistant.const import CONF_PASSWORD, CONF_REGION, CONF_USERNAME
 from homeassistant.core import HomeAssistant
@@ -34,7 +34,7 @@ FIXTURE_GCID = "DUMMY"
 
 FIXTURE_CONFIG_ENTRY = {
     "entry_id": "1",
-    "domain": BMW_DOMAIN,
+    "domain": DOMAIN,
     "title": FIXTURE_USER_INPUT[CONF_USERNAME],
     "data": {
         CONF_USERNAME: FIXTURE_USER_INPUT[CONF_USERNAME],
diff --git a/tests/components/bmw_connected_drive/test_coordinator.py b/tests/components/bmw_connected_drive/test_coordinator.py
index 2e317ec1334..13c96341dea 100644
--- a/tests/components/bmw_connected_drive/test_coordinator.py
+++ b/tests/components/bmw_connected_drive/test_coordinator.py
@@ -11,7 +11,7 @@ from bimmer_connected.models import (
 from freezegun.api import FrozenDateTimeFactory
 import pytest
 
-from homeassistant.components.bmw_connected_drive import DOMAIN as BMW_DOMAIN
+from homeassistant.components.bmw_connected_drive import DOMAIN
 from homeassistant.components.bmw_connected_drive.const import (
     CONF_REFRESH_TOKEN,
     SCAN_INTERVALS,
@@ -140,7 +140,7 @@ async def test_auth_failed_as_update_failed(
 
     # Verify that no issues are raised and no reauth flow is initialized
     assert len(issue_registry.issues) == 0
-    assert len(hass.config_entries.flow.async_progress_by_handler(BMW_DOMAIN)) == 0
+    assert len(hass.config_entries.flow.async_progress_by_handler(DOMAIN)) == 0
 
 
 @pytest.mark.usefixtures("bmw_fixture")
@@ -190,13 +190,13 @@ async def test_auth_failed_init_reauth(
 
     reauth_issue = issue_registry.async_get_issue(
         HOMEASSISTANT_DOMAIN,
-        f"config_entry_reauth_{BMW_DOMAIN}_{config_entry.entry_id}",
+        f"config_entry_reauth_{DOMAIN}_{config_entry.entry_id}",
     )
     assert reauth_issue.active is True
 
     # Check if reauth flow is initialized correctly
     flow = hass.config_entries.flow.async_get(reauth_issue.data["flow_id"])
-    assert flow["handler"] == BMW_DOMAIN
+    assert flow["handler"] == DOMAIN
     assert flow["context"]["source"] == "reauth"
     assert flow["context"]["unique_id"] == config_entry.unique_id
 
@@ -233,12 +233,12 @@ async def test_captcha_reauth(
 
     reauth_issue = issue_registry.async_get_issue(
         HOMEASSISTANT_DOMAIN,
-        f"config_entry_reauth_{BMW_DOMAIN}_{config_entry.entry_id}",
+        f"config_entry_reauth_{DOMAIN}_{config_entry.entry_id}",
     )
     assert reauth_issue.active is True
 
     # Check if reauth flow is initialized correctly
     flow = hass.config_entries.flow.async_get(reauth_issue.data["flow_id"])
-    assert flow["handler"] == BMW_DOMAIN
+    assert flow["handler"] == DOMAIN
     assert flow["context"]["source"] == "reauth"
     assert flow["context"]["unique_id"] == config_entry.unique_id
diff --git a/tests/components/bmw_connected_drive/test_init.py b/tests/components/bmw_connected_drive/test_init.py
index d0624825cb5..7ffccccf577 100644
--- a/tests/components/bmw_connected_drive/test_init.py
+++ b/tests/components/bmw_connected_drive/test_init.py
@@ -6,10 +6,7 @@ from unittest.mock import patch
 import pytest
 
 from homeassistant.components.bmw_connected_drive import DEFAULT_OPTIONS
-from homeassistant.components.bmw_connected_drive.const import (
-    CONF_READ_ONLY,
-    DOMAIN as BMW_DOMAIN,
-)
+from homeassistant.components.bmw_connected_drive.const import CONF_READ_ONLY, DOMAIN
 from homeassistant.const import Platform
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers import device_registry as dr, entity_registry as er
@@ -82,7 +79,7 @@ async def test_migrate_options_from_data(hass: HomeAssistant) -> None:
         (
             {
                 "domain": SENSOR_DOMAIN,
-                "platform": BMW_DOMAIN,
+                "platform": DOMAIN,
                 "unique_id": f"{VIN}-charging_level_hv",
                 "suggested_object_id": f"{VEHICLE_NAME} charging_level_hv",
                 "disabled_by": None,
@@ -93,7 +90,7 @@ async def test_migrate_options_from_data(hass: HomeAssistant) -> None:
         (
             {
                 "domain": SENSOR_DOMAIN,
-                "platform": BMW_DOMAIN,
+                "platform": DOMAIN,
                 "unique_id": f"{VIN}-remaining_range_total",
                 "suggested_object_id": f"{VEHICLE_NAME} remaining_range_total",
                 "disabled_by": None,
@@ -104,7 +101,7 @@ async def test_migrate_options_from_data(hass: HomeAssistant) -> None:
         (
             {
                 "domain": SENSOR_DOMAIN,
-                "platform": BMW_DOMAIN,
+                "platform": DOMAIN,
                 "unique_id": f"{VIN}-mileage",
                 "suggested_object_id": f"{VEHICLE_NAME} mileage",
                 "disabled_by": None,
@@ -115,7 +112,7 @@ async def test_migrate_options_from_data(hass: HomeAssistant) -> None:
         (
             {
                 "domain": SENSOR_DOMAIN,
-                "platform": BMW_DOMAIN,
+                "platform": DOMAIN,
                 "unique_id": f"{VIN}-charging_status",
                 "suggested_object_id": f"{VEHICLE_NAME} Charging Status",
                 "disabled_by": None,
@@ -126,7 +123,7 @@ async def test_migrate_options_from_data(hass: HomeAssistant) -> None:
         (
             {
                 "domain": BINARY_SENSOR_DOMAIN,
-                "platform": BMW_DOMAIN,
+                "platform": DOMAIN,
                 "unique_id": f"{VIN}-charging_status",
                 "suggested_object_id": f"{VEHICLE_NAME} Charging Status",
                 "disabled_by": None,
@@ -173,7 +170,7 @@ async def test_migrate_unique_ids(
         (
             {
                 "domain": SENSOR_DOMAIN,
-                "platform": BMW_DOMAIN,
+                "platform": DOMAIN,
                 "unique_id": f"{VIN}-charging_level_hv",
                 "suggested_object_id": f"{VEHICLE_NAME} charging_level_hv",
                 "disabled_by": None,
@@ -198,7 +195,7 @@ async def test_dont_migrate_unique_ids(
     # create existing entry with new_unique_id
     existing_entity = entity_registry.async_get_or_create(
         SENSOR_DOMAIN,
-        BMW_DOMAIN,
+        DOMAIN,
         unique_id=f"{VIN}-fuel_and_battery.remaining_battery_percent",
         suggested_object_id=f"{VEHICLE_NAME} fuel_and_battery.remaining_battery_percent",
         config_entry=mock_config_entry,
@@ -241,7 +238,7 @@ async def test_remove_stale_devices(
 
     device_registry.async_get_or_create(
         config_entry_id=mock_config_entry.entry_id,
-        identifiers={(BMW_DOMAIN, "stale_device_id")},
+        identifiers={(DOMAIN, "stale_device_id")},
     )
     device_entries = dr.async_entries_for_config_entry(
         device_registry, mock_config_entry.entry_id
@@ -249,7 +246,7 @@ async def test_remove_stale_devices(
 
     assert len(device_entries) == 1
     device_entry = device_entries[0]
-    assert device_entry.identifiers == {(BMW_DOMAIN, "stale_device_id")}
+    assert device_entry.identifiers == {(DOMAIN, "stale_device_id")}
 
     assert await hass.config_entries.async_setup(mock_config_entry.entry_id)
     await hass.async_block_till_done()
@@ -261,6 +258,4 @@ async def test_remove_stale_devices(
     # Check that the test vehicles are still available but not the stale device
     assert len(device_entries) > 0
     remaining_device_identifiers = set().union(*(d.identifiers for d in device_entries))
-    assert not {(BMW_DOMAIN, "stale_device_id")}.intersection(
-        remaining_device_identifiers
-    )
+    assert not {(DOMAIN, "stale_device_id")}.intersection(remaining_device_identifiers)
diff --git a/tests/components/bmw_connected_drive/test_select.py b/tests/components/bmw_connected_drive/test_select.py
index 878edefac27..51ed5369e51 100644
--- a/tests/components/bmw_connected_drive/test_select.py
+++ b/tests/components/bmw_connected_drive/test_select.py
@@ -8,7 +8,7 @@ import pytest
 import respx
 from syrupy.assertion import SnapshotAssertion
 
-from homeassistant.components.bmw_connected_drive import DOMAIN as BMW_DOMAIN
+from homeassistant.components.bmw_connected_drive import DOMAIN
 from homeassistant.components.bmw_connected_drive.select import SELECT_TYPES
 from homeassistant.const import Platform
 from homeassistant.core import HomeAssistant
@@ -182,9 +182,9 @@ async def test_entity_option_translations(
     # Setup component to load translations
     assert await setup_mocked_integration(hass)
 
-    prefix = f"component.{BMW_DOMAIN}.entity.{Platform.SELECT.value}"
+    prefix = f"component.{DOMAIN}.entity.{Platform.SELECT.value}"
 
-    translations = await async_get_translations(hass, "en", "entity", [BMW_DOMAIN])
+    translations = await async_get_translations(hass, "en", "entity", [DOMAIN])
     translation_states = {
         k for k in translations if k.startswith(prefix) and ".state." in k
     }
diff --git a/tests/components/bmw_connected_drive/test_sensor.py b/tests/components/bmw_connected_drive/test_sensor.py
index c02f6d425cd..12145f89e6d 100644
--- a/tests/components/bmw_connected_drive/test_sensor.py
+++ b/tests/components/bmw_connected_drive/test_sensor.py
@@ -8,7 +8,7 @@ from freezegun.api import FrozenDateTimeFactory
 import pytest
 from syrupy.assertion import SnapshotAssertion
 
-from homeassistant.components.bmw_connected_drive import DOMAIN as BMW_DOMAIN
+from homeassistant.components.bmw_connected_drive import DOMAIN
 from homeassistant.components.bmw_connected_drive.const import SCAN_INTERVALS
 from homeassistant.components.bmw_connected_drive.sensor import SENSOR_TYPES
 from homeassistant.components.sensor import SensorDeviceClass
@@ -96,9 +96,9 @@ async def test_entity_option_translations(
     # Setup component to load translations
     assert await setup_mocked_integration(hass)
 
-    prefix = f"component.{BMW_DOMAIN}.entity.{Platform.SENSOR.value}"
+    prefix = f"component.{DOMAIN}.entity.{Platform.SENSOR.value}"
 
-    translations = await async_get_translations(hass, "en", "entity", [BMW_DOMAIN])
+    translations = await async_get_translations(hass, "en", "entity", [DOMAIN])
     translation_states = {
         k for k in translations if k.startswith(prefix) and ".state." in k
     }
diff --git a/tests/components/bond/common.py b/tests/components/bond/common.py
index 0fcd2d4a99f..174512e9f45 100644
--- a/tests/components/bond/common.py
+++ b/tests/components/bond/common.py
@@ -11,7 +11,7 @@ from aiohttp.client_exceptions import ClientResponseError
 from bond_async import DeviceType
 
 from homeassistant import core
-from homeassistant.components.bond.const import DOMAIN as BOND_DOMAIN
+from homeassistant.components.bond.const import DOMAIN
 from homeassistant.const import CONF_ACCESS_TOKEN, CONF_HOST, STATE_UNAVAILABLE
 from homeassistant.setup import async_setup_component
 from homeassistant.util import utcnow
@@ -77,7 +77,7 @@ async def setup_platform(
 ):
     """Set up the specified Bond platform."""
     mock_entry = MockConfigEntry(
-        domain=BOND_DOMAIN,
+        domain=DOMAIN,
         data={CONF_HOST: "some host", CONF_ACCESS_TOKEN: "test-token"},
     )
     mock_entry.add_to_hass(hass)
@@ -93,7 +93,7 @@ async def setup_platform(
         patch_bond_device_properties(return_value=props),
         patch_bond_device_state(return_value=state),
     ):
-        assert await async_setup_component(hass, BOND_DOMAIN, {})
+        assert await async_setup_component(hass, DOMAIN, {})
         await hass.async_block_till_done()
 
     return mock_entry
diff --git a/tests/components/bond/test_fan.py b/tests/components/bond/test_fan.py
index 6a7ec6d1615..ac38a93a386 100644
--- a/tests/components/bond/test_fan.py
+++ b/tests/components/bond/test_fan.py
@@ -11,7 +11,7 @@ import pytest
 from homeassistant import core
 from homeassistant.components import fan
 from homeassistant.components.bond.const import (
-    DOMAIN as BOND_DOMAIN,
+    DOMAIN,
     SERVICE_SET_FAN_SPEED_TRACKED_STATE,
 )
 from homeassistant.components.bond.fan import PRESET_MODE_BREEZE
@@ -367,7 +367,7 @@ async def test_set_speed_belief_speed_zero(hass: HomeAssistant) -> None:
 
     with patch_bond_action() as mock_action, patch_bond_device_state():
         await hass.services.async_call(
-            BOND_DOMAIN,
+            DOMAIN,
             SERVICE_SET_FAN_SPEED_TRACKED_STATE,
             {ATTR_ENTITY_ID: "fan.name_1", "speed": 0},
             blocking=True,
@@ -391,7 +391,7 @@ async def test_set_speed_belief_speed_api_error(hass: HomeAssistant) -> None:
         patch_bond_device_state(),
     ):
         await hass.services.async_call(
-            BOND_DOMAIN,
+            DOMAIN,
             SERVICE_SET_FAN_SPEED_TRACKED_STATE,
             {ATTR_ENTITY_ID: "fan.name_1", "speed": 100},
             blocking=True,
@@ -406,7 +406,7 @@ async def test_set_speed_belief_speed_100(hass: HomeAssistant) -> None:
 
     with patch_bond_action() as mock_action, patch_bond_device_state():
         await hass.services.async_call(
-            BOND_DOMAIN,
+            DOMAIN,
             SERVICE_SET_FAN_SPEED_TRACKED_STATE,
             {ATTR_ENTITY_ID: "fan.name_1", "speed": 100},
             blocking=True,
diff --git a/tests/components/bond/test_switch.py b/tests/components/bond/test_switch.py
index 3155ec0b167..2389f751843 100644
--- a/tests/components/bond/test_switch.py
+++ b/tests/components/bond/test_switch.py
@@ -7,7 +7,7 @@ import pytest
 
 from homeassistant.components.bond.const import (
     ATTR_POWER_STATE,
-    DOMAIN as BOND_DOMAIN,
+    DOMAIN,
     SERVICE_SET_POWER_TRACKED_STATE,
 )
 from homeassistant.components.switch import DOMAIN as SWITCH_DOMAIN
@@ -94,7 +94,7 @@ async def test_switch_set_power_belief(hass: HomeAssistant) -> None:
 
     with patch_bond_action() as mock_bond_action, patch_bond_device_state():
         await hass.services.async_call(
-            BOND_DOMAIN,
+            DOMAIN,
             SERVICE_SET_POWER_TRACKED_STATE,
             {ATTR_ENTITY_ID: "switch.name_1", ATTR_POWER_STATE: False},
             blocking=True,
@@ -118,7 +118,7 @@ async def test_switch_set_power_belief_api_error(hass: HomeAssistant) -> None:
         patch_bond_device_state(),
     ):
         await hass.services.async_call(
-            BOND_DOMAIN,
+            DOMAIN,
             SERVICE_SET_POWER_TRACKED_STATE,
             {ATTR_ENTITY_ID: "switch.name_1", ATTR_POWER_STATE: False},
             blocking=True,
diff --git a/tests/components/bring/test_diagnostics.py b/tests/components/bring/test_diagnostics.py
index c4b8defca82..ea2656c0aa0 100644
--- a/tests/components/bring/test_diagnostics.py
+++ b/tests/components/bring/test_diagnostics.py
@@ -9,7 +9,7 @@ from syrupy.assertion import SnapshotAssertion
 from homeassistant.components.bring.const import DOMAIN
 from homeassistant.core import HomeAssistant
 
-from tests.common import MockConfigEntry, load_fixture
+from tests.common import MockConfigEntry, async_load_fixture
 from tests.components.diagnostics import get_diagnostics_for_config_entry
 from tests.typing import ClientSessionGenerator
 
@@ -24,8 +24,12 @@ async def test_diagnostics(
 ) -> None:
     """Test diagnostics."""
     mock_bring_client.get_list.side_effect = [
-        BringItemsResponse.from_json(load_fixture("items.json", DOMAIN)),
-        BringItemsResponse.from_json(load_fixture("items2.json", DOMAIN)),
+        BringItemsResponse.from_json(
+            await async_load_fixture(hass, "items.json", DOMAIN)
+        ),
+        BringItemsResponse.from_json(
+            await async_load_fixture(hass, "items2.json", DOMAIN)
+        ),
     ]
     bring_config_entry.add_to_hass(hass)
     await hass.config_entries.async_setup(bring_config_entry.entry_id)
diff --git a/tests/components/bring/test_init.py b/tests/components/bring/test_init.py
index 7f235ea505c..60ae68755ff 100644
--- a/tests/components/bring/test_init.py
+++ b/tests/components/bring/test_init.py
@@ -21,7 +21,7 @@ from homeassistant.helpers import device_registry as dr
 
 from .conftest import UUID
 
-from tests.common import MockConfigEntry, async_fire_time_changed, load_fixture
+from tests.common import MockConfigEntry, async_fire_time_changed, async_load_fixture
 
 
 async def setup_integration(
@@ -240,7 +240,7 @@ async def test_purge_devices(
     )
 
     mock_bring_client.load_lists.return_value = BringListResponse.from_json(
-        load_fixture("lists2.json", DOMAIN)
+        await async_load_fixture(hass, "lists2.json", DOMAIN)
     )
 
     freezer.tick(timedelta(seconds=90))
@@ -265,7 +265,7 @@ async def test_create_devices(
     """Test create device entry for new lists."""
     list_uuid = "b4776778-7f6c-496e-951b-92a35d3db0dd"
     mock_bring_client.load_lists.return_value = BringListResponse.from_json(
-        load_fixture("lists2.json", DOMAIN)
+        await async_load_fixture(hass, "lists2.json", DOMAIN)
     )
     await setup_integration(hass, bring_config_entry)
 
@@ -279,7 +279,7 @@ async def test_create_devices(
     )
 
     mock_bring_client.load_lists.return_value = BringListResponse.from_json(
-        load_fixture("lists.json", DOMAIN)
+        await async_load_fixture(hass, "lists.json", DOMAIN)
     )
     freezer.tick(timedelta(seconds=90))
     async_fire_time_changed(hass)
@@ -310,7 +310,7 @@ async def test_coordinator_update_intervals(
     mock_bring_client.get_activity.reset_mock()
 
     mock_bring_client.load_lists.return_value = BringListResponse.from_json(
-        load_fixture("lists2.json", DOMAIN)
+        await async_load_fixture(hass, "lists2.json", DOMAIN)
     )
     freezer.tick(timedelta(seconds=90))
     async_fire_time_changed(hass)
diff --git a/tests/components/bring/test_sensor.py b/tests/components/bring/test_sensor.py
index f704debcea9..977aa90d8d7 100644
--- a/tests/components/bring/test_sensor.py
+++ b/tests/components/bring/test_sensor.py
@@ -13,7 +13,7 @@ from homeassistant.const import Platform
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers import entity_registry as er
 
-from tests.common import MockConfigEntry, load_fixture, snapshot_platform
+from tests.common import MockConfigEntry, async_load_fixture, snapshot_platform
 
 
 @pytest.fixture(autouse=True)
@@ -36,8 +36,12 @@ async def test_setup(
     """Snapshot test states of sensor platform."""
 
     mock_bring_client.get_list.side_effect = [
-        BringItemsResponse.from_json(load_fixture("items.json", DOMAIN)),
-        BringItemsResponse.from_json(load_fixture("items2.json", DOMAIN)),
+        BringItemsResponse.from_json(
+            await async_load_fixture(hass, "items.json", DOMAIN)
+        ),
+        BringItemsResponse.from_json(
+            await async_load_fixture(hass, "items2.json", DOMAIN)
+        ),
     ]
     bring_config_entry.add_to_hass(hass)
     await hass.config_entries.async_setup(bring_config_entry.entry_id)
@@ -68,7 +72,7 @@ async def test_list_access_states(
     """Snapshot test states of list access sensor."""
 
     mock_bring_client.get_list.return_value = BringItemsResponse.from_json(
-        load_fixture(f"{fixture}.json", DOMAIN)
+        await async_load_fixture(hass, f"{fixture}.json", DOMAIN)
     )
     bring_config_entry.add_to_hass(hass)
     await hass.config_entries.async_setup(bring_config_entry.entry_id)
diff --git a/tests/components/bring/test_todo.py b/tests/components/bring/test_todo.py
index 9df7b892db8..3d4bbaf10db 100644
--- a/tests/components/bring/test_todo.py
+++ b/tests/components/bring/test_todo.py
@@ -22,7 +22,7 @@ from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import HomeAssistantError
 from homeassistant.helpers import entity_registry as er
 
-from tests.common import MockConfigEntry, load_fixture, snapshot_platform
+from tests.common import MockConfigEntry, async_load_fixture, snapshot_platform
 
 
 @pytest.fixture(autouse=True)
@@ -45,8 +45,12 @@ async def test_todo(
 ) -> None:
     """Snapshot test states of todo platform."""
     mock_bring_client.get_list.side_effect = [
-        BringItemsResponse.from_json(load_fixture("items.json", DOMAIN)),
-        BringItemsResponse.from_json(load_fixture("items2.json", DOMAIN)),
+        BringItemsResponse.from_json(
+            await async_load_fixture(hass, "items.json", DOMAIN)
+        ),
+        BringItemsResponse.from_json(
+            await async_load_fixture(hass, "items2.json", DOMAIN)
+        ),
     ]
     bring_config_entry.add_to_hass(hass)
     await hass.config_entries.async_setup(bring_config_entry.entry_id)
diff --git a/tests/components/button/test_init.py b/tests/components/button/test_init.py
index 783fd786a50..f1c730a41b3 100644
--- a/tests/components/button/test_init.py
+++ b/tests/components/button/test_init.py
@@ -20,6 +20,7 @@ from homeassistant.const import (
     CONF_PLATFORM,
     STATE_UNAVAILABLE,
     STATE_UNKNOWN,
+    Platform,
 )
 from homeassistant.core import HomeAssistant, State
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
@@ -136,7 +137,9 @@ async def test_name(hass: HomeAssistant) -> None:
         hass: HomeAssistant, config_entry: ConfigEntry
     ) -> bool:
         """Set up test config entry."""
-        await hass.config_entries.async_forward_entry_setups(config_entry, [DOMAIN])
+        await hass.config_entries.async_forward_entry_setups(
+            config_entry, [Platform.BUTTON]
+        )
         return True
 
     mock_platform(hass, f"{TEST_DOMAIN}.config_flow")
diff --git a/tests/components/calendar/conftest.py b/tests/components/calendar/conftest.py
index 5bf061591ee..ed21f1336c8 100644
--- a/tests/components/calendar/conftest.py
+++ b/tests/components/calendar/conftest.py
@@ -120,7 +120,9 @@ def mock_setup_integration(
         hass: HomeAssistant, config_entry: ConfigEntry
     ) -> bool:
         """Set up test config entry."""
-        await hass.config_entries.async_forward_entry_setups(config_entry, [DOMAIN])
+        await hass.config_entries.async_forward_entry_setups(
+            config_entry, [Platform.CALENDAR]
+        )
         return True
 
     async def async_unload_entry_init(
diff --git a/tests/components/camera/conftest.py b/tests/components/camera/conftest.py
index dcc02cf99fe..5e95bbd6fbe 100644
--- a/tests/components/camera/conftest.py
+++ b/tests/components/camera/conftest.py
@@ -201,7 +201,7 @@ async def mock_test_webrtc_cameras(hass: HomeAssistant) -> None:
     ) -> bool:
         """Set up test config entry."""
         await hass.config_entries.async_forward_entry_setups(
-            config_entry, [camera.DOMAIN]
+            config_entry, [Platform.CAMERA]
         )
         return True
 
@@ -210,7 +210,7 @@ async def mock_test_webrtc_cameras(hass: HomeAssistant) -> None:
     ) -> bool:
         """Unload test config entry."""
         await hass.config_entries.async_forward_entry_unload(
-            config_entry, camera.DOMAIN
+            config_entry, Platform.CAMERA
         )
         return True
 
diff --git a/tests/components/cast/test_helpers.py b/tests/components/cast/test_helpers.py
index 84914db2b3a..2f38a79c777 100644
--- a/tests/components/cast/test_helpers.py
+++ b/tests/components/cast/test_helpers.py
@@ -3,6 +3,7 @@
 from aiohttp import client_exceptions
 import pytest
 
+from homeassistant.components.cast.const import DOMAIN
 from homeassistant.components.cast.helpers import (
     PlaylistError,
     PlaylistItem,
@@ -11,7 +12,7 @@ from homeassistant.components.cast.helpers import (
 )
 from homeassistant.core import HomeAssistant
 
-from tests.common import load_fixture
+from tests.common import async_load_fixture
 from tests.test_util.aiohttp import AiohttpClientMocker
 
 
@@ -40,7 +41,9 @@ async def test_hls_playlist_supported(
 ) -> None:
     """Test playlist parsing of HLS playlist."""
     headers = {"content-type": content_type}
-    aioclient_mock.get(url, text=load_fixture(fixture, "cast"), headers=headers)
+    aioclient_mock.get(
+        url, text=await async_load_fixture(hass, fixture, DOMAIN), headers=headers
+    )
     with pytest.raises(PlaylistSupported):
         await parse_playlist(hass, url)
 
@@ -108,7 +111,9 @@ async def test_parse_playlist(
 ) -> None:
     """Test playlist parsing of HLS playlist."""
     headers = {"content-type": content_type}
-    aioclient_mock.get(url, text=load_fixture(fixture, "cast"), headers=headers)
+    aioclient_mock.get(
+        url, text=await async_load_fixture(hass, fixture, DOMAIN), headers=headers
+    )
     playlist = await parse_playlist(hass, url)
     assert expected_playlist == playlist
 
@@ -132,7 +137,7 @@ async def test_parse_bad_playlist(
     hass: HomeAssistant, aioclient_mock: AiohttpClientMocker, url, fixture
 ) -> None:
     """Test playlist parsing of HLS playlist."""
-    aioclient_mock.get(url, text=load_fixture(fixture, "cast"))
+    aioclient_mock.get(url, text=await async_load_fixture(hass, fixture, DOMAIN))
     with pytest.raises(PlaylistError):
         await parse_playlist(hass, url)
 
diff --git a/tests/components/cast/test_media_player.py b/tests/components/cast/test_media_player.py
index 386b9270571..c56904f1c48 100644
--- a/tests/components/cast/test_media_player.py
+++ b/tests/components/cast/test_media_player.py
@@ -18,6 +18,7 @@ import yarl
 from homeassistant.components import media_player, tts
 from homeassistant.components.cast import media_player as cast
 from homeassistant.components.cast.const import (
+    DOMAIN,
     SIGNAL_HASS_CAST_SHOW_VIEW,
     HomeAssistantControllerData,
 )
@@ -45,7 +46,7 @@ from homeassistant.setup import async_setup_component
 from tests.common import (
     MockConfigEntry,
     assert_setup_component,
-    load_fixture,
+    async_load_fixture,
     mock_platform,
 )
 from tests.components.media_player import common
@@ -1348,7 +1349,7 @@ async def test_entity_play_media_playlist(
 ) -> None:
     """Test playing media."""
     entity_id = "media_player.speaker"
-    aioclient_mock.get(url, text=load_fixture(fixture, "cast"))
+    aioclient_mock.get(url, text=await async_load_fixture(hass, fixture, DOMAIN))
 
     await async_process_ha_core_config(
         hass,
diff --git a/tests/components/climate/conftest.py b/tests/components/climate/conftest.py
index 4ade8606e77..678a1070a2f 100644
--- a/tests/components/climate/conftest.py
+++ b/tests/components/climate/conftest.py
@@ -4,7 +4,6 @@ from collections.abc import Generator
 
 import pytest
 
-from homeassistant.components.climate import DOMAIN as CLIMATE_DOMAIN
 from homeassistant.config_entries import ConfigEntry, ConfigFlow
 from homeassistant.const import Platform
 from homeassistant.core import HomeAssistant
@@ -45,7 +44,7 @@ def register_test_integration(
     ) -> bool:
         """Set up test config entry."""
         await hass.config_entries.async_forward_entry_setups(
-            config_entry, [CLIMATE_DOMAIN]
+            config_entry, [Platform.CLIMATE]
         )
         return True
 
diff --git a/tests/components/climate/test_intent.py b/tests/components/climate/test_intent.py
index 4ce06199eb8..c992480cae7 100644
--- a/tests/components/climate/test_intent.py
+++ b/tests/components/climate/test_intent.py
@@ -59,7 +59,9 @@ def mock_setup_integration(hass: HomeAssistant) -> None:
         hass: HomeAssistant, config_entry: ConfigEntry
     ) -> bool:
         """Set up test config entry."""
-        await hass.config_entries.async_forward_entry_setups(config_entry, [DOMAIN])
+        await hass.config_entries.async_forward_entry_setups(
+            config_entry, [Platform.CLIMATE]
+        )
         return True
 
     async def async_unload_entry_init(
diff --git a/tests/components/color_extractor/test_service.py b/tests/components/color_extractor/test_service.py
index 3f920b7dee2..e46e5843210 100644
--- a/tests/components/color_extractor/test_service.py
+++ b/tests/components/color_extractor/test_service.py
@@ -27,7 +27,7 @@ from homeassistant.core import HomeAssistant
 from homeassistant.setup import async_setup_component
 from homeassistant.util import color as color_util
 
-from tests.common import load_fixture
+from tests.common import async_load_fixture, load_fixture
 from tests.test_util.aiohttp import AiohttpClientMocker
 
 LIGHT_ENTITY = "light.kitchen_lights"
@@ -145,7 +145,7 @@ async def test_url_success(
     aioclient_mock.get(
         url=service_data[ATTR_URL],
         content=base64.b64decode(
-            load_fixture("color_extractor/color_extractor_url.txt")
+            await async_load_fixture(hass, "color_extractor_url.txt", DOMAIN)
         ),
     )
 
@@ -233,9 +233,7 @@ async def test_url_error(
 @patch(
     "builtins.open",
     mock_open(
-        read_data=base64.b64decode(
-            load_fixture("color_extractor/color_extractor_file.txt")
-        )
+        read_data=base64.b64decode(load_fixture("color_extractor_file.txt", DOMAIN))
     ),
     create=True,
 )
diff --git a/tests/components/comelit/conftest.py b/tests/components/comelit/conftest.py
index 8ac77505590..eaf2f6c68b9 100644
--- a/tests/components/comelit/conftest.py
+++ b/tests/components/comelit/conftest.py
@@ -4,11 +4,7 @@ from copy import deepcopy
 
 import pytest
 
-from homeassistant.components.comelit.const import (
-    BRIDGE,
-    DOMAIN as COMELIT_DOMAIN,
-    VEDO,
-)
+from homeassistant.components.comelit.const import BRIDGE, DOMAIN, VEDO
 from homeassistant.const import CONF_HOST, CONF_PIN, CONF_PORT, CONF_TYPE
 
 from .const import (
@@ -60,7 +56,7 @@ def mock_serial_bridge() -> Generator[AsyncMock]:
 def mock_serial_bridge_config_entry() -> MockConfigEntry:
     """Mock a Comelit config entry for Comelit bridge."""
     return MockConfigEntry(
-        domain=COMELIT_DOMAIN,
+        domain=DOMAIN,
         data={
             CONF_HOST: BRIDGE_HOST,
             CONF_PORT: BRIDGE_PORT,
@@ -97,7 +93,7 @@ def mock_vedo() -> Generator[AsyncMock]:
 def mock_vedo_config_entry() -> MockConfigEntry:
     """Mock a Comelit config entry for Comelit vedo."""
     return MockConfigEntry(
-        domain=COMELIT_DOMAIN,
+        domain=DOMAIN,
         data={
             CONF_HOST: VEDO_HOST,
             CONF_PORT: VEDO_PORT,
diff --git a/tests/components/cups/test_sensor.py b/tests/components/cups/test_sensor.py
index 60e7ce5fd44..22e12d61980 100644
--- a/tests/components/cups/test_sensor.py
+++ b/tests/components/cups/test_sensor.py
@@ -2,7 +2,7 @@
 
 from unittest.mock import patch
 
-from homeassistant.components.cups import CONF_PRINTERS, DOMAIN as CUPS_DOMAIN
+from homeassistant.components.cups import CONF_PRINTERS, DOMAIN
 from homeassistant.components.sensor.const import DOMAIN as SENSOR_DOMAIN
 from homeassistant.const import CONF_PLATFORM
 from homeassistant.core import DOMAIN as HOMEASSISTANT_DOMAIN, HomeAssistant
@@ -25,7 +25,7 @@ async def test_repair_issue_is_created(
             {
                 SENSOR_DOMAIN: [
                     {
-                        CONF_PLATFORM: CUPS_DOMAIN,
+                        CONF_PLATFORM: DOMAIN,
                         CONF_PRINTERS: [
                             "printer1",
                         ],
@@ -36,5 +36,5 @@ async def test_repair_issue_is_created(
         await hass.async_block_till_done()
         assert (
             HOMEASSISTANT_DOMAIN,
-            f"deprecated_system_packages_yaml_integration_{CUPS_DOMAIN}",
+            f"deprecated_system_packages_yaml_integration_{DOMAIN}",
         ) in issue_registry.issues
diff --git a/tests/components/deconz/conftest.py b/tests/components/deconz/conftest.py
index 4a74a673ef8..4ae12776f79 100644
--- a/tests/components/deconz/conftest.py
+++ b/tests/components/deconz/conftest.py
@@ -10,7 +10,7 @@ from unittest.mock import patch
 from pydeconz.websocket import Signal
 import pytest
 
-from homeassistant.components.deconz.const import DOMAIN as DECONZ_DOMAIN
+from homeassistant.components.deconz.const import DOMAIN
 from homeassistant.config_entries import SOURCE_USER
 from homeassistant.const import CONF_API_KEY, CONF_HOST, CONF_PORT, CONTENT_TYPE_JSON
 from homeassistant.core import HomeAssistant
@@ -53,7 +53,7 @@ def fixture_config_entry(
 ) -> MockConfigEntry:
     """Define a config entry fixture."""
     return MockConfigEntry(
-        domain=DECONZ_DOMAIN,
+        domain=DOMAIN,
         entry_id="1",
         unique_id=BRIDGE_ID,
         data=config_entry_data,
diff --git a/tests/components/deconz/test_binary_sensor.py b/tests/components/deconz/test_binary_sensor.py
index 288be082f43..7325ed6780c 100644
--- a/tests/components/deconz/test_binary_sensor.py
+++ b/tests/components/deconz/test_binary_sensor.py
@@ -11,7 +11,7 @@ from homeassistant.components.deconz.const import (
     CONF_ALLOW_CLIP_SENSOR,
     CONF_ALLOW_NEW_DEVICES,
     CONF_MASTER_GATEWAY,
-    DOMAIN as DECONZ_DOMAIN,
+    DOMAIN,
 )
 from homeassistant.components.deconz.services import SERVICE_DEVICE_REFRESH
 from homeassistant.const import STATE_OFF, STATE_ON, Platform
@@ -492,7 +492,7 @@ async def test_add_new_binary_sensor_ignored_load_entities_on_service_call(
     deconz_payload["sensors"]["0"] = sensor
     mock_requests()
 
-    await hass.services.async_call(DECONZ_DOMAIN, SERVICE_DEVICE_REFRESH)
+    await hass.services.async_call(DOMAIN, SERVICE_DEVICE_REFRESH)
     await hass.async_block_till_done()
 
     assert len(hass.states.async_all()) == 1
diff --git a/tests/components/deconz/test_config_flow.py b/tests/components/deconz/test_config_flow.py
index fe5fe022427..50a6066d952 100644
--- a/tests/components/deconz/test_config_flow.py
+++ b/tests/components/deconz/test_config_flow.py
@@ -16,7 +16,7 @@ from homeassistant.components.deconz.const import (
     CONF_ALLOW_DECONZ_GROUPS,
     CONF_ALLOW_NEW_DEVICES,
     CONF_MASTER_GATEWAY,
-    DOMAIN as DECONZ_DOMAIN,
+    DOMAIN,
     HASSIO_CONFIGURATION_URL,
 )
 from homeassistant.config_entries import SOURCE_HASSIO, SOURCE_SSDP, SOURCE_USER
@@ -53,7 +53,7 @@ async def test_flow_discovered_bridges(
     )
 
     result = await hass.config_entries.flow.async_init(
-        DECONZ_DOMAIN, context={"source": SOURCE_USER}
+        DOMAIN, context={"source": SOURCE_USER}
     )
 
     assert result["type"] is FlowResultType.FORM
@@ -96,7 +96,7 @@ async def test_flow_manual_configuration_decision(
     )
 
     result = await hass.config_entries.flow.async_init(
-        DECONZ_DOMAIN, context={"source": SOURCE_USER}
+        DOMAIN, context={"source": SOURCE_USER}
     )
 
     result = await hass.config_entries.flow.async_configure(
@@ -151,7 +151,7 @@ async def test_flow_manual_configuration(
     )
 
     result = await hass.config_entries.flow.async_init(
-        DECONZ_DOMAIN, context={"source": SOURCE_USER}
+        DOMAIN, context={"source": SOURCE_USER}
     )
 
     assert result["type"] is FlowResultType.FORM
@@ -197,7 +197,7 @@ async def test_manual_configuration_after_discovery_timeout(
     aioclient_mock.get(pydeconz.utils.URL_DISCOVER, exc=TimeoutError)
 
     result = await hass.config_entries.flow.async_init(
-        DECONZ_DOMAIN, context={"source": SOURCE_USER}
+        DOMAIN, context={"source": SOURCE_USER}
     )
 
     assert result["type"] is FlowResultType.FORM
@@ -212,7 +212,7 @@ async def test_manual_configuration_after_discovery_ResponseError(
     aioclient_mock.get(pydeconz.utils.URL_DISCOVER, exc=pydeconz.errors.ResponseError)
 
     result = await hass.config_entries.flow.async_init(
-        DECONZ_DOMAIN, context={"source": SOURCE_USER}
+        DOMAIN, context={"source": SOURCE_USER}
     )
 
     assert result["type"] is FlowResultType.FORM
@@ -233,7 +233,7 @@ async def test_manual_configuration_update_configuration(
     )
 
     result = await hass.config_entries.flow.async_init(
-        DECONZ_DOMAIN, context={"source": SOURCE_USER}
+        DOMAIN, context={"source": SOURCE_USER}
     )
 
     assert result["type"] is FlowResultType.FORM
@@ -280,7 +280,7 @@ async def test_manual_configuration_dont_update_configuration(
     )
 
     result = await hass.config_entries.flow.async_init(
-        DECONZ_DOMAIN, context={"source": SOURCE_USER}
+        DOMAIN, context={"source": SOURCE_USER}
     )
 
     assert result["type"] is FlowResultType.FORM
@@ -325,7 +325,7 @@ async def test_manual_configuration_timeout_get_bridge(
     )
 
     result = await hass.config_entries.flow.async_init(
-        DECONZ_DOMAIN, context={"source": SOURCE_USER}
+        DOMAIN, context={"source": SOURCE_USER}
     )
 
     assert result["type"] is FlowResultType.FORM
@@ -378,7 +378,7 @@ async def test_link_step_fails(
     )
 
     result = await hass.config_entries.flow.async_init(
-        DECONZ_DOMAIN, context={"source": SOURCE_USER}
+        DOMAIN, context={"source": SOURCE_USER}
     )
 
     result = await hass.config_entries.flow.async_configure(
@@ -437,7 +437,7 @@ async def test_flow_ssdp_discovery(
 ) -> None:
     """Test that config flow for one discovered bridge works."""
     result = await hass.config_entries.flow.async_init(
-        DECONZ_DOMAIN,
+        DOMAIN,
         data=SsdpServiceInfo(
             ssdp_usn="mock_usn",
             ssdp_st="mock_st",
@@ -485,7 +485,7 @@ async def test_ssdp_discovery_update_configuration(
         return_value=True,
     ) as mock_setup_entry:
         result = await hass.config_entries.flow.async_init(
-            DECONZ_DOMAIN,
+            DOMAIN,
             data=SsdpServiceInfo(
                 ssdp_usn="mock_usn",
                 ssdp_st="mock_st",
@@ -511,7 +511,7 @@ async def test_ssdp_discovery_dont_update_configuration(
     """Test if a discovered bridge has already been configured."""
 
     result = await hass.config_entries.flow.async_init(
-        DECONZ_DOMAIN,
+        DOMAIN,
         data=SsdpServiceInfo(
             ssdp_usn="mock_usn",
             ssdp_st="mock_st",
@@ -535,7 +535,7 @@ async def test_ssdp_discovery_dont_update_existing_hassio_configuration(
 ) -> None:
     """Test to ensure the SSDP discovery does not update an Hass.io entry."""
     result = await hass.config_entries.flow.async_init(
-        DECONZ_DOMAIN,
+        DOMAIN,
         data=SsdpServiceInfo(
             ssdp_usn="mock_usn",
             ssdp_st="mock_st",
@@ -556,7 +556,7 @@ async def test_ssdp_discovery_dont_update_existing_hassio_configuration(
 async def test_flow_hassio_discovery(hass: HomeAssistant) -> None:
     """Test hassio discovery flow works."""
     result = await hass.config_entries.flow.async_init(
-        DECONZ_DOMAIN,
+        DOMAIN,
         data=HassioServiceInfo(
             config={
                 "addon": "Mock Addon",
@@ -609,7 +609,7 @@ async def test_hassio_discovery_update_configuration(
         return_value=True,
     ) as mock_setup_entry:
         result = await hass.config_entries.flow.async_init(
-            DECONZ_DOMAIN,
+            DOMAIN,
             data=HassioServiceInfo(
                 config={
                     CONF_HOST: "2.3.4.5",
@@ -637,7 +637,7 @@ async def test_hassio_discovery_update_configuration(
 async def test_hassio_discovery_dont_update_configuration(hass: HomeAssistant) -> None:
     """Test we can update an existing config entry."""
     result = await hass.config_entries.flow.async_init(
-        DECONZ_DOMAIN,
+        DOMAIN,
         data=HassioServiceInfo(
             config={
                 CONF_HOST: "1.2.3.4",
diff --git a/tests/components/deconz/test_deconz_event.py b/tests/components/deconz/test_deconz_event.py
index 8bf7bb146d1..438fe8c17f5 100644
--- a/tests/components/deconz/test_deconz_event.py
+++ b/tests/components/deconz/test_deconz_event.py
@@ -7,7 +7,7 @@ from pydeconz.models.sensor.ancillary_control import (
 from pydeconz.models.sensor.presence import PresenceStatePresenceEvent
 import pytest
 
-from homeassistant.components.deconz.const import DOMAIN as DECONZ_DOMAIN
+from homeassistant.components.deconz.const import DOMAIN
 from homeassistant.components.deconz.deconz_event import (
     ATTR_DURATION,
     ATTR_ROTATION,
@@ -94,7 +94,7 @@ async def test_deconz_events(
     await sensor_ws_data({"id": "1", "state": {"buttonevent": 2000}})
 
     device = device_registry.async_get_device(
-        identifiers={(DECONZ_DOMAIN, "00:00:00:00:00:00:00:01")}
+        identifiers={(DOMAIN, "00:00:00:00:00:00:00:01")}
     )
 
     assert len(captured_events) == 1
@@ -108,7 +108,7 @@ async def test_deconz_events(
     await sensor_ws_data({"id": "3", "state": {"buttonevent": 2000}})
 
     device = device_registry.async_get_device(
-        identifiers={(DECONZ_DOMAIN, "00:00:00:00:00:00:00:03")}
+        identifiers={(DOMAIN, "00:00:00:00:00:00:00:03")}
     )
 
     assert len(captured_events) == 2
@@ -123,7 +123,7 @@ async def test_deconz_events(
     await sensor_ws_data({"id": "4", "state": {"gesture": 0}})
 
     device = device_registry.async_get_device(
-        identifiers={(DECONZ_DOMAIN, "00:00:00:00:00:00:00:04")}
+        identifiers={(DOMAIN, "00:00:00:00:00:00:00:04")}
     )
 
     assert len(captured_events) == 3
@@ -142,7 +142,7 @@ async def test_deconz_events(
     await sensor_ws_data(event_changed_sensor)
 
     device = device_registry.async_get_device(
-        identifiers={(DECONZ_DOMAIN, "00:00:00:00:00:00:00:05")}
+        identifiers={(DOMAIN, "00:00:00:00:00:00:00:05")}
     )
 
     assert len(captured_events) == 4
@@ -250,7 +250,7 @@ async def test_deconz_alarm_events(
     await sensor_ws_data({"state": {"action": AncillaryControlAction.EMERGENCY}})
 
     device = device_registry.async_get_device(
-        identifiers={(DECONZ_DOMAIN, "00:00:00:00:00:00:00:01")}
+        identifiers={(DOMAIN, "00:00:00:00:00:00:00:01")}
     )
 
     assert len(captured_events) == 1
@@ -266,7 +266,7 @@ async def test_deconz_alarm_events(
     await sensor_ws_data({"state": {"action": AncillaryControlAction.FIRE}})
 
     device = device_registry.async_get_device(
-        identifiers={(DECONZ_DOMAIN, "00:00:00:00:00:00:00:01")}
+        identifiers={(DOMAIN, "00:00:00:00:00:00:00:01")}
     )
 
     assert len(captured_events) == 2
@@ -282,7 +282,7 @@ async def test_deconz_alarm_events(
     await sensor_ws_data({"state": {"action": AncillaryControlAction.INVALID_CODE}})
 
     device = device_registry.async_get_device(
-        identifiers={(DECONZ_DOMAIN, "00:00:00:00:00:00:00:01")}
+        identifiers={(DOMAIN, "00:00:00:00:00:00:00:01")}
     )
 
     assert len(captured_events) == 3
@@ -298,7 +298,7 @@ async def test_deconz_alarm_events(
     await sensor_ws_data({"state": {"action": AncillaryControlAction.PANIC}})
 
     device = device_registry.async_get_device(
-        identifiers={(DECONZ_DOMAIN, "00:00:00:00:00:00:00:01")}
+        identifiers={(DOMAIN, "00:00:00:00:00:00:00:01")}
     )
 
     assert len(captured_events) == 4
@@ -366,7 +366,7 @@ async def test_deconz_presence_events(
     )
 
     device = device_registry.async_get_device(
-        identifiers={(DECONZ_DOMAIN, "xx:xx:xx:xx:xx:xx:xx:xx")}
+        identifiers={(DOMAIN, "xx:xx:xx:xx:xx:xx:xx:xx")}
     )
 
     captured_events = async_capture_events(hass, CONF_DECONZ_PRESENCE_EVENT)
@@ -443,7 +443,7 @@ async def test_deconz_relative_rotary_events(
     )
 
     device = device_registry.async_get_device(
-        identifiers={(DECONZ_DOMAIN, "xx:xx:xx:xx:xx:xx:xx:xx")}
+        identifiers={(DOMAIN, "xx:xx:xx:xx:xx:xx:xx:xx")}
     )
 
     captured_events = async_capture_events(hass, CONF_DECONZ_RELATIVE_ROTARY_EVENT)
diff --git a/tests/components/deconz/test_device_trigger.py b/tests/components/deconz/test_device_trigger.py
index 1502cc4081d..5781a4c3ed5 100644
--- a/tests/components/deconz/test_device_trigger.py
+++ b/tests/components/deconz/test_device_trigger.py
@@ -16,7 +16,7 @@ from homeassistant.components.binary_sensor.device_trigger import (
     CONF_TAMPERED,
 )
 from homeassistant.components.deconz import device_trigger
-from homeassistant.components.deconz.const import DOMAIN as DECONZ_DOMAIN
+from homeassistant.components.deconz.const import DOMAIN
 from homeassistant.components.deconz.device_trigger import CONF_SUBTYPE
 from homeassistant.components.device_automation import DeviceAutomationType
 from homeassistant.components.sensor import DOMAIN as SENSOR_DOMAIN
@@ -76,7 +76,7 @@ async def test_get_triggers(
 ) -> None:
     """Test triggers work."""
     device = device_registry.async_get_device(
-        identifiers={(DECONZ_DOMAIN, "d0:cf:5e:ff:fe:71:a4:3a")}
+        identifiers={(DOMAIN, "d0:cf:5e:ff:fe:71:a4:3a")}
     )
     battery_sensor_entry = entity_registry.async_get(
         "sensor.tradfri_on_off_switch_battery"
@@ -89,7 +89,7 @@ async def test_get_triggers(
     expected_triggers = [
         {
             CONF_DEVICE_ID: device.id,
-            CONF_DOMAIN: DECONZ_DOMAIN,
+            CONF_DOMAIN: DOMAIN,
             CONF_PLATFORM: "device",
             CONF_TYPE: device_trigger.CONF_SHORT_PRESS,
             CONF_SUBTYPE: device_trigger.CONF_TURN_ON,
@@ -97,7 +97,7 @@ async def test_get_triggers(
         },
         {
             CONF_DEVICE_ID: device.id,
-            CONF_DOMAIN: DECONZ_DOMAIN,
+            CONF_DOMAIN: DOMAIN,
             CONF_PLATFORM: "device",
             CONF_TYPE: device_trigger.CONF_LONG_PRESS,
             CONF_SUBTYPE: device_trigger.CONF_TURN_ON,
@@ -105,7 +105,7 @@ async def test_get_triggers(
         },
         {
             CONF_DEVICE_ID: device.id,
-            CONF_DOMAIN: DECONZ_DOMAIN,
+            CONF_DOMAIN: DOMAIN,
             CONF_PLATFORM: "device",
             CONF_TYPE: device_trigger.CONF_LONG_RELEASE,
             CONF_SUBTYPE: device_trigger.CONF_TURN_ON,
@@ -113,7 +113,7 @@ async def test_get_triggers(
         },
         {
             CONF_DEVICE_ID: device.id,
-            CONF_DOMAIN: DECONZ_DOMAIN,
+            CONF_DOMAIN: DOMAIN,
             CONF_PLATFORM: "device",
             CONF_TYPE: device_trigger.CONF_SHORT_PRESS,
             CONF_SUBTYPE: device_trigger.CONF_TURN_OFF,
@@ -121,7 +121,7 @@ async def test_get_triggers(
         },
         {
             CONF_DEVICE_ID: device.id,
-            CONF_DOMAIN: DECONZ_DOMAIN,
+            CONF_DOMAIN: DOMAIN,
             CONF_PLATFORM: "device",
             CONF_TYPE: device_trigger.CONF_LONG_PRESS,
             CONF_SUBTYPE: device_trigger.CONF_TURN_OFF,
@@ -129,7 +129,7 @@ async def test_get_triggers(
         },
         {
             CONF_DEVICE_ID: device.id,
-            CONF_DOMAIN: DECONZ_DOMAIN,
+            CONF_DOMAIN: DOMAIN,
             CONF_PLATFORM: "device",
             CONF_TYPE: device_trigger.CONF_LONG_RELEASE,
             CONF_SUBTYPE: device_trigger.CONF_TURN_OFF,
@@ -187,7 +187,7 @@ async def test_get_triggers_for_alarm_event(
 ) -> None:
     """Test triggers work."""
     device = device_registry.async_get_device(
-        identifiers={(DECONZ_DOMAIN, "00:00:00:00:00:00:00:00")}
+        identifiers={(DOMAIN, "00:00:00:00:00:00:00:00")}
     )
     bat_entity = entity_registry.async_get("sensor.keypad_battery")
     low_bat_entity = entity_registry.async_get("binary_sensor.keypad_low_battery")
@@ -272,7 +272,7 @@ async def test_get_triggers_manage_unsupported_remotes(
 ) -> None:
     """Verify no triggers for an unsupported remote."""
     device = device_registry.async_get_device(
-        identifiers={(DECONZ_DOMAIN, "d0:cf:5e:ff:fe:71:a4:3a")}
+        identifiers={(DOMAIN, "d0:cf:5e:ff:fe:71:a4:3a")}
     )
 
     triggers = await async_get_device_automations(
@@ -317,7 +317,7 @@ async def test_functional_device_trigger(
 ) -> None:
     """Test proper matching and attachment of device trigger automation."""
     device = device_registry.async_get_device(
-        identifiers={(DECONZ_DOMAIN, "d0:cf:5e:ff:fe:71:a4:3a")}
+        identifiers={(DOMAIN, "d0:cf:5e:ff:fe:71:a4:3a")}
     )
 
     assert await async_setup_component(
@@ -328,7 +328,7 @@ async def test_functional_device_trigger(
                 {
                     "trigger": {
                         CONF_PLATFORM: "device",
-                        CONF_DOMAIN: DECONZ_DOMAIN,
+                        CONF_DOMAIN: DOMAIN,
                         CONF_DEVICE_ID: device.id,
                         CONF_TYPE: device_trigger.CONF_SHORT_PRESS,
                         CONF_SUBTYPE: device_trigger.CONF_TURN_ON,
@@ -362,7 +362,7 @@ async def test_validate_trigger_unknown_device(hass: HomeAssistant) -> None:
                 {
                     "trigger": {
                         CONF_PLATFORM: "device",
-                        CONF_DOMAIN: DECONZ_DOMAIN,
+                        CONF_DOMAIN: DOMAIN,
                         CONF_DEVICE_ID: "unknown device",
                         CONF_TYPE: device_trigger.CONF_SHORT_PRESS,
                         CONF_SUBTYPE: device_trigger.CONF_TURN_ON,
@@ -388,7 +388,7 @@ async def test_validate_trigger_unsupported_device(
     """Test unsupported device doesn't return a trigger config."""
     device = device_registry.async_get_or_create(
         config_entry_id=config_entry_setup.entry_id,
-        identifiers={(DECONZ_DOMAIN, "d0:cf:5e:ff:fe:71:a4:3a")},
+        identifiers={(DOMAIN, "d0:cf:5e:ff:fe:71:a4:3a")},
         model="unsupported",
     )
 
@@ -400,7 +400,7 @@ async def test_validate_trigger_unsupported_device(
                 {
                     "trigger": {
                         CONF_PLATFORM: "device",
-                        CONF_DOMAIN: DECONZ_DOMAIN,
+                        CONF_DOMAIN: DOMAIN,
                         CONF_DEVICE_ID: device.id,
                         CONF_TYPE: device_trigger.CONF_SHORT_PRESS,
                         CONF_SUBTYPE: device_trigger.CONF_TURN_ON,
@@ -428,13 +428,13 @@ async def test_validate_trigger_unsupported_trigger(
     """Test unsupported trigger does not return a trigger config."""
     device = device_registry.async_get_or_create(
         config_entry_id=config_entry_setup.entry_id,
-        identifiers={(DECONZ_DOMAIN, "d0:cf:5e:ff:fe:71:a4:3a")},
+        identifiers={(DOMAIN, "d0:cf:5e:ff:fe:71:a4:3a")},
         model="TRADFRI on/off switch",
     )
 
     trigger_config = {
         CONF_PLATFORM: "device",
-        CONF_DOMAIN: DECONZ_DOMAIN,
+        CONF_DOMAIN: DOMAIN,
         CONF_DEVICE_ID: device.id,
         CONF_TYPE: "unsupported",
         CONF_SUBTYPE: device_trigger.CONF_TURN_ON,
@@ -470,14 +470,14 @@ async def test_attach_trigger_no_matching_event(
     """Test no matching event for device doesn't return a trigger config."""
     device = device_registry.async_get_or_create(
         config_entry_id=config_entry_setup.entry_id,
-        identifiers={(DECONZ_DOMAIN, "d0:cf:5e:ff:fe:71:a4:3a")},
+        identifiers={(DOMAIN, "d0:cf:5e:ff:fe:71:a4:3a")},
         name="Tradfri switch",
         model="TRADFRI on/off switch",
     )
 
     trigger_config = {
         CONF_PLATFORM: "device",
-        CONF_DOMAIN: DECONZ_DOMAIN,
+        CONF_DOMAIN: DOMAIN,
         CONF_DEVICE_ID: device.id,
         CONF_TYPE: device_trigger.CONF_SHORT_PRESS,
         CONF_SUBTYPE: device_trigger.CONF_TURN_ON,
diff --git a/tests/components/deconz/test_hub.py b/tests/components/deconz/test_hub.py
index f674a6ef6df..cf5edc85a2d 100644
--- a/tests/components/deconz/test_hub.py
+++ b/tests/components/deconz/test_hub.py
@@ -7,7 +7,7 @@ import pytest
 from syrupy.assertion import SnapshotAssertion
 
 from homeassistant.components.deconz.config_flow import DECONZ_MANUFACTURERURL
-from homeassistant.components.deconz.const import DOMAIN as DECONZ_DOMAIN
+from homeassistant.components.deconz.const import DOMAIN
 from homeassistant.config_entries import SOURCE_SSDP
 from homeassistant.const import STATE_OFF, STATE_UNAVAILABLE
 from homeassistant.core import HomeAssistant
@@ -31,7 +31,7 @@ async def test_device_registry_entry(
 ) -> None:
     """Successful setup."""
     device_entry = device_registry.async_get_device(
-        identifiers={(DECONZ_DOMAIN, config_entry_setup.unique_id)}
+        identifiers={(DOMAIN, config_entry_setup.unique_id)}
     )
     assert device_entry == snapshot
 
@@ -80,7 +80,7 @@ async def test_update_address(
         patch("pydeconz.gateway.WSClient") as ws_mock,
     ):
         await hass.config_entries.flow.async_init(
-            DECONZ_DOMAIN,
+            DOMAIN,
             data=SsdpServiceInfo(
                 ssdp_st="mock_st",
                 ssdp_usn="mock_usn",
diff --git a/tests/components/deconz/test_init.py b/tests/components/deconz/test_init.py
index 390d8b9b353..2fed4726082 100644
--- a/tests/components/deconz/test_init.py
+++ b/tests/components/deconz/test_init.py
@@ -6,10 +6,7 @@ from unittest.mock import patch
 import pydeconz
 import pytest
 
-from homeassistant.components.deconz.const import (
-    CONF_MASTER_GATEWAY,
-    DOMAIN as DECONZ_DOMAIN,
-)
+from homeassistant.components.deconz.const import CONF_MASTER_GATEWAY, DOMAIN
 from homeassistant.components.deconz.errors import AuthenticationRequired
 from homeassistant.config_entries import ConfigEntryState
 from homeassistant.core import HomeAssistant
@@ -76,7 +73,7 @@ async def test_setup_entry_multiple_gateways(
     config_entry = await config_entry_factory()
 
     entry2 = MockConfigEntry(
-        domain=DECONZ_DOMAIN,
+        domain=DOMAIN,
         entry_id="2",
         unique_id="01234E56789B",
         data=config_entry.data | {"host": "2.3.4.5"},
@@ -105,7 +102,7 @@ async def test_unload_entry_multiple_gateways(
     config_entry = await config_entry_factory()
 
     entry2 = MockConfigEntry(
-        domain=DECONZ_DOMAIN,
+        domain=DOMAIN,
         entry_id="2",
         unique_id="01234E56789B",
         data=config_entry.data | {"host": "2.3.4.5"},
@@ -127,7 +124,7 @@ async def test_unload_entry_multiple_gateways_parallel(
     config_entry = await config_entry_factory()
 
     entry2 = MockConfigEntry(
-        domain=DECONZ_DOMAIN,
+        domain=DOMAIN,
         entry_id="2",
         unique_id="01234E56789B",
         data=config_entry.data | {"host": "2.3.4.5"},
diff --git a/tests/components/deconz/test_logbook.py b/tests/components/deconz/test_logbook.py
index 57cf8748762..c6e09150f71 100644
--- a/tests/components/deconz/test_logbook.py
+++ b/tests/components/deconz/test_logbook.py
@@ -4,7 +4,7 @@ from typing import Any
 
 import pytest
 
-from homeassistant.components.deconz.const import CONF_GESTURE, DOMAIN as DECONZ_DOMAIN
+from homeassistant.components.deconz.const import CONF_GESTURE, DOMAIN
 from homeassistant.components.deconz.deconz_event import (
     CONF_DECONZ_ALARM_EVENT,
     CONF_DECONZ_EVENT,
@@ -64,7 +64,7 @@ async def test_humanifying_deconz_alarm_event(
     keypad_event_id = slugify(sensor_payload["name"])
     keypad_serial = serial_from_unique_id(sensor_payload["uniqueid"])
     keypad_entry = device_registry.async_get_device(
-        identifiers={(DECONZ_DOMAIN, keypad_serial)}
+        identifiers={(DOMAIN, keypad_serial)}
     )
 
     removed_device_event_id = "removed_device"
@@ -157,25 +157,25 @@ async def test_humanifying_deconz_event(
     switch_event_id = slugify(sensor_payload["1"]["name"])
     switch_serial = serial_from_unique_id(sensor_payload["1"]["uniqueid"])
     switch_entry = device_registry.async_get_device(
-        identifiers={(DECONZ_DOMAIN, switch_serial)}
+        identifiers={(DOMAIN, switch_serial)}
     )
 
     hue_remote_event_id = slugify(sensor_payload["2"]["name"])
     hue_remote_serial = serial_from_unique_id(sensor_payload["2"]["uniqueid"])
     hue_remote_entry = device_registry.async_get_device(
-        identifiers={(DECONZ_DOMAIN, hue_remote_serial)}
+        identifiers={(DOMAIN, hue_remote_serial)}
     )
 
     xiaomi_cube_event_id = slugify(sensor_payload["3"]["name"])
     xiaomi_cube_serial = serial_from_unique_id(sensor_payload["3"]["uniqueid"])
     xiaomi_cube_entry = device_registry.async_get_device(
-        identifiers={(DECONZ_DOMAIN, xiaomi_cube_serial)}
+        identifiers={(DOMAIN, xiaomi_cube_serial)}
     )
 
     faulty_event_id = slugify(sensor_payload["4"]["name"])
     faulty_serial = serial_from_unique_id(sensor_payload["4"]["uniqueid"])
     faulty_entry = device_registry.async_get_device(
-        identifiers={(DECONZ_DOMAIN, faulty_serial)}
+        identifiers={(DOMAIN, faulty_serial)}
     )
 
     removed_device_event_id = "removed_device"
diff --git a/tests/components/deconz/test_services.py b/tests/components/deconz/test_services.py
index 9a30564385c..558eb628705 100644
--- a/tests/components/deconz/test_services.py
+++ b/tests/components/deconz/test_services.py
@@ -9,7 +9,7 @@ import voluptuous as vol
 from homeassistant.components.deconz.const import (
     CONF_BRIDGE_ID,
     CONF_MASTER_GATEWAY,
-    DOMAIN as DECONZ_DOMAIN,
+    DOMAIN,
 )
 from homeassistant.components.deconz.deconz_event import CONF_DECONZ_EVENT
 from homeassistant.components.deconz.services import (
@@ -45,7 +45,7 @@ async def test_configure_service_with_field(
     aioclient_mock = mock_put_request("/lights/2")
 
     await hass.services.async_call(
-        DECONZ_DOMAIN, SERVICE_CONFIGURE_DEVICE, service_data=data, blocking=True
+        DOMAIN, SERVICE_CONFIGURE_DEVICE, service_data=data, blocking=True
     )
     assert aioclient_mock.mock_calls[1][2] == {"on": True, "attr1": 10, "attr2": 20}
 
@@ -74,7 +74,7 @@ async def test_configure_service_with_entity(
     aioclient_mock = mock_put_request("/lights/0")
 
     await hass.services.async_call(
-        DECONZ_DOMAIN, SERVICE_CONFIGURE_DEVICE, service_data=data, blocking=True
+        DOMAIN, SERVICE_CONFIGURE_DEVICE, service_data=data, blocking=True
     )
     assert aioclient_mock.mock_calls[1][2] == {"on": True, "attr1": 10, "attr2": 20}
 
@@ -104,7 +104,7 @@ async def test_configure_service_with_entity_and_field(
     aioclient_mock = mock_put_request("/lights/0/state")
 
     await hass.services.async_call(
-        DECONZ_DOMAIN, SERVICE_CONFIGURE_DEVICE, service_data=data, blocking=True
+        DOMAIN, SERVICE_CONFIGURE_DEVICE, service_data=data, blocking=True
     )
     assert aioclient_mock.mock_calls[1][2] == {"on": True, "attr1": 10, "attr2": 20}
 
@@ -122,9 +122,7 @@ async def test_configure_service_with_faulty_bridgeid(
         SERVICE_DATA: {"on": True},
     }
 
-    await hass.services.async_call(
-        DECONZ_DOMAIN, SERVICE_CONFIGURE_DEVICE, service_data=data
-    )
+    await hass.services.async_call(DOMAIN, SERVICE_CONFIGURE_DEVICE, service_data=data)
     await hass.async_block_till_done()
 
     assert len(aioclient_mock.mock_calls) == 0
@@ -137,7 +135,7 @@ async def test_configure_service_with_faulty_field(hass: HomeAssistant) -> None:
 
     with pytest.raises(vol.Invalid):
         await hass.services.async_call(
-            DECONZ_DOMAIN, SERVICE_CONFIGURE_DEVICE, service_data=data
+            DOMAIN, SERVICE_CONFIGURE_DEVICE, service_data=data
         )
 
 
@@ -153,9 +151,7 @@ async def test_configure_service_with_faulty_entity(
         SERVICE_DATA: {},
     }
 
-    await hass.services.async_call(
-        DECONZ_DOMAIN, SERVICE_CONFIGURE_DEVICE, service_data=data
-    )
+    await hass.services.async_call(DOMAIN, SERVICE_CONFIGURE_DEVICE, service_data=data)
     await hass.async_block_till_done()
 
     assert len(aioclient_mock.mock_calls) == 0
@@ -174,9 +170,7 @@ async def test_calling_service_with_no_master_gateway_fails(
         SERVICE_DATA: {"on": True},
     }
 
-    await hass.services.async_call(
-        DECONZ_DOMAIN, SERVICE_CONFIGURE_DEVICE, service_data=data
-    )
+    await hass.services.async_call(DOMAIN, SERVICE_CONFIGURE_DEVICE, service_data=data)
     await hass.async_block_till_done()
 
     assert len(aioclient_mock.mock_calls) == 0
@@ -227,7 +221,7 @@ async def test_service_refresh_devices(
     mock_requests()
 
     await hass.services.async_call(
-        DECONZ_DOMAIN, SERVICE_DEVICE_REFRESH, service_data={CONF_BRIDGE_ID: BRIDGE_ID}
+        DOMAIN, SERVICE_DEVICE_REFRESH, service_data={CONF_BRIDGE_ID: BRIDGE_ID}
     )
     await hass.async_block_till_done()
 
@@ -293,7 +287,7 @@ async def test_service_refresh_devices_trigger_no_state_update(
     mock_requests()
 
     await hass.services.async_call(
-        DECONZ_DOMAIN, SERVICE_DEVICE_REFRESH, service_data={CONF_BRIDGE_ID: BRIDGE_ID}
+        DOMAIN, SERVICE_DEVICE_REFRESH, service_data={CONF_BRIDGE_ID: BRIDGE_ID}
     )
     await hass.async_block_till_done()
 
@@ -349,7 +343,7 @@ async def test_remove_orphaned_entries_service(
 
     entity_registry.async_get_or_create(
         SENSOR_DOMAIN,
-        DECONZ_DOMAIN,
+        DOMAIN,
         "12345",
         suggested_object_id="Orphaned sensor",
         config_entry=config_entry_setup,
@@ -366,7 +360,7 @@ async def test_remove_orphaned_entries_service(
     )
 
     await hass.services.async_call(
-        DECONZ_DOMAIN,
+        DOMAIN,
         SERVICE_REMOVE_ORPHANED_ENTRIES,
         service_data={CONF_BRIDGE_ID: BRIDGE_ID},
     )
diff --git a/tests/components/deconz/test_switch.py b/tests/components/deconz/test_switch.py
index ed82b0c2ac3..3b49deebddb 100644
--- a/tests/components/deconz/test_switch.py
+++ b/tests/components/deconz/test_switch.py
@@ -4,7 +4,7 @@ from collections.abc import Callable
 
 import pytest
 
-from homeassistant.components.deconz.const import DOMAIN as DECONZ_DOMAIN
+from homeassistant.components.deconz.const import DOMAIN
 from homeassistant.components.light import DOMAIN as LIGHT_DOMAIN
 from homeassistant.components.switch import (
     DOMAIN as SWITCH_DOMAIN,
@@ -110,7 +110,7 @@ async def test_remove_legacy_on_off_output_as_light(
 ) -> None:
     """Test that switch platform cleans up legacy light entities."""
     assert entity_registry.async_get_or_create(
-        LIGHT_DOMAIN, DECONZ_DOMAIN, "00:00:00:00:00:00:00:00-00"
+        LIGHT_DOMAIN, DOMAIN, "00:00:00:00:00:00:00:00-00"
     )
 
     await config_entry_factory()
diff --git a/tests/components/decora/__init__.py b/tests/components/decora/__init__.py
new file mode 100644
index 00000000000..399b353aa0c
--- /dev/null
+++ b/tests/components/decora/__init__.py
@@ -0,0 +1 @@
+"""Decora component tests."""
diff --git a/tests/components/decora/test_light.py b/tests/components/decora/test_light.py
new file mode 100644
index 00000000000..6315d6c3986
--- /dev/null
+++ b/tests/components/decora/test_light.py
@@ -0,0 +1,34 @@
+"""Decora component tests."""
+
+from unittest.mock import Mock, patch
+
+from homeassistant.components.decora import DOMAIN as DECORA_DOMAIN
+from homeassistant.components.light import DOMAIN as PLATFORM_DOMAIN
+from homeassistant.const import CONF_PLATFORM
+from homeassistant.core import DOMAIN as HOMEASSISTANT_DOMAIN, HomeAssistant
+from homeassistant.helpers import issue_registry as ir
+from homeassistant.setup import async_setup_component
+
+
+@patch.dict("sys.modules", {"bluepy": Mock(), "bluepy.btle": Mock(), "decora": Mock()})
+async def test_repair_issue_is_created(
+    hass: HomeAssistant,
+    issue_registry: ir.IssueRegistry,
+) -> None:
+    """Test repair issue is created."""
+    assert await async_setup_component(
+        hass,
+        PLATFORM_DOMAIN,
+        {
+            PLATFORM_DOMAIN: [
+                {
+                    CONF_PLATFORM: DECORA_DOMAIN,
+                }
+            ],
+        },
+    )
+    await hass.async_block_till_done()
+    assert (
+        HOMEASSISTANT_DOMAIN,
+        f"deprecated_system_packages_yaml_integration_{DECORA_DOMAIN}",
+    ) in issue_registry.issues
diff --git a/tests/components/demo/test_stt.py b/tests/components/demo/test_stt.py
index dccdddd84e8..84e972b12af 100644
--- a/tests/components/demo/test_stt.py
+++ b/tests/components/demo/test_stt.py
@@ -5,7 +5,7 @@ from unittest.mock import patch
 
 import pytest
 
-from homeassistant.components.demo import DOMAIN as DEMO_DOMAIN
+from homeassistant.components.demo import DOMAIN
 from homeassistant.const import Platform
 from homeassistant.core import HomeAssistant
 
@@ -26,7 +26,7 @@ async def stt_only(hass: HomeAssistant) -> None:
 @pytest.fixture(autouse=True)
 async def setup_config_entry(hass: HomeAssistant, stt_only) -> None:
     """Set up demo component from config entry."""
-    config_entry = MockConfigEntry(domain=DEMO_DOMAIN)
+    config_entry = MockConfigEntry(domain=DOMAIN)
     config_entry.add_to_hass(hass)
     assert await hass.config_entries.async_setup(config_entry.entry_id)
     await hass.async_block_till_done()
diff --git a/tests/components/devialet/test_diagnostics.py b/tests/components/devialet/test_diagnostics.py
index 6bf643ce682..4bf74d11460 100644
--- a/tests/components/devialet/test_diagnostics.py
+++ b/tests/components/devialet/test_diagnostics.py
@@ -2,11 +2,12 @@
 
 import json
 
+from homeassistant.components.devialet.const import DOMAIN
 from homeassistant.core import HomeAssistant
 
 from . import setup_integration
 
-from tests.common import load_fixture
+from tests.common import async_load_fixture
 from tests.components.diagnostics import get_diagnostics_for_config_entry
 from tests.test_util.aiohttp import AiohttpClientMocker
 from tests.typing import ClientSessionGenerator
@@ -22,12 +23,20 @@ async def test_diagnostics(
 
     assert await get_diagnostics_for_config_entry(hass, hass_client, entry) == {
         "is_available": True,
-        "general_info": json.loads(load_fixture("general_info.json", "devialet")),
-        "sources": json.loads(load_fixture("sources.json", "devialet")),
-        "source_state": json.loads(load_fixture("source_state.json", "devialet")),
-        "volume": json.loads(load_fixture("volume.json", "devialet")),
-        "night_mode": json.loads(load_fixture("night_mode.json", "devialet")),
-        "equalizer": json.loads(load_fixture("equalizer.json", "devialet")),
+        "general_info": json.loads(
+            await async_load_fixture(hass, "general_info.json", DOMAIN)
+        ),
+        "sources": json.loads(await async_load_fixture(hass, "sources.json", DOMAIN)),
+        "source_state": json.loads(
+            await async_load_fixture(hass, "source_state.json", DOMAIN)
+        ),
+        "volume": json.loads(await async_load_fixture(hass, "volume.json", DOMAIN)),
+        "night_mode": json.loads(
+            await async_load_fixture(hass, "night_mode.json", DOMAIN)
+        ),
+        "equalizer": json.loads(
+            await async_load_fixture(hass, "equalizer.json", DOMAIN)
+        ),
         "source_list": [
             "Airplay",
             "Bluetooth",
diff --git a/tests/components/dlib_face_detect/test_image_processing.py b/tests/components/dlib_face_detect/test_image_processing.py
index e3b82a4cedf..d108e11786a 100644
--- a/tests/components/dlib_face_detect/test_image_processing.py
+++ b/tests/components/dlib_face_detect/test_image_processing.py
@@ -2,7 +2,7 @@
 
 from unittest.mock import Mock, patch
 
-from homeassistant.components.dlib_face_detect import DOMAIN as DLIB_DOMAIN
+from homeassistant.components.dlib_face_detect import DOMAIN
 from homeassistant.components.image_processing import DOMAIN as IMAGE_PROCESSING_DOMAIN
 from homeassistant.const import CONF_ENTITY_ID, CONF_PLATFORM, CONF_SOURCE
 from homeassistant.core import DOMAIN as HOMEASSISTANT_DOMAIN, HomeAssistant
@@ -22,7 +22,7 @@ async def test_repair_issue_is_created(
         {
             IMAGE_PROCESSING_DOMAIN: [
                 {
-                    CONF_PLATFORM: DLIB_DOMAIN,
+                    CONF_PLATFORM: DOMAIN,
                     CONF_SOURCE: [
                         {CONF_ENTITY_ID: "camera.test_camera"},
                     ],
@@ -33,5 +33,5 @@ async def test_repair_issue_is_created(
     await hass.async_block_till_done()
     assert (
         HOMEASSISTANT_DOMAIN,
-        f"deprecated_system_packages_yaml_integration_{DLIB_DOMAIN}",
+        f"deprecated_system_packages_yaml_integration_{DOMAIN}",
     ) in issue_registry.issues
diff --git a/tests/components/dlib_face_identify/test_image_processing.py b/tests/components/dlib_face_identify/test_image_processing.py
index f914baeffb9..fbf40efe1e1 100644
--- a/tests/components/dlib_face_identify/test_image_processing.py
+++ b/tests/components/dlib_face_identify/test_image_processing.py
@@ -2,10 +2,7 @@
 
 from unittest.mock import Mock, patch
 
-from homeassistant.components.dlib_face_identify import (
-    CONF_FACES,
-    DOMAIN as DLIB_DOMAIN,
-)
+from homeassistant.components.dlib_face_identify import CONF_FACES, DOMAIN
 from homeassistant.components.image_processing import DOMAIN as IMAGE_PROCESSING_DOMAIN
 from homeassistant.const import CONF_ENTITY_ID, CONF_PLATFORM, CONF_SOURCE
 from homeassistant.core import DOMAIN as HOMEASSISTANT_DOMAIN, HomeAssistant
@@ -25,7 +22,7 @@ async def test_repair_issue_is_created(
         {
             IMAGE_PROCESSING_DOMAIN: [
                 {
-                    CONF_PLATFORM: DLIB_DOMAIN,
+                    CONF_PLATFORM: DOMAIN,
                     CONF_SOURCE: [
                         {CONF_ENTITY_ID: "camera.test_camera"},
                     ],
@@ -37,5 +34,5 @@ async def test_repair_issue_is_created(
     await hass.async_block_till_done()
     assert (
         HOMEASSISTANT_DOMAIN,
-        f"deprecated_system_packages_yaml_integration_{DLIB_DOMAIN}",
+        f"deprecated_system_packages_yaml_integration_{DOMAIN}",
     ) in issue_registry.issues
diff --git a/tests/components/dlna_dmr/conftest.py b/tests/components/dlna_dmr/conftest.py
index 21cb2bc0daf..9170187bc07 100644
--- a/tests/components/dlna_dmr/conftest.py
+++ b/tests/components/dlna_dmr/conftest.py
@@ -10,7 +10,7 @@ from async_upnp_client.client import UpnpDevice, UpnpService
 from async_upnp_client.client_factory import UpnpFactory
 import pytest
 
-from homeassistant.components.dlna_dmr.const import DOMAIN as DLNA_DOMAIN
+from homeassistant.components.dlna_dmr.const import DOMAIN
 from homeassistant.components.dlna_dmr.data import DlnaDmrData
 from homeassistant.const import CONF_DEVICE_ID, CONF_MAC, CONF_TYPE, CONF_URL
 from homeassistant.core import HomeAssistant
@@ -76,7 +76,7 @@ def domain_data_mock(hass: HomeAssistant) -> Mock:
     seal(upnp_device)
     domain_data.upnp_factory.async_create_device.return_value = upnp_device
 
-    hass.data[DLNA_DOMAIN] = domain_data
+    hass.data[DOMAIN] = domain_data
     return domain_data
 
 
@@ -85,7 +85,7 @@ def config_entry_mock() -> MockConfigEntry:
     """Mock a config entry for this platform."""
     return MockConfigEntry(
         unique_id=MOCK_DEVICE_UDN,
-        domain=DLNA_DOMAIN,
+        domain=DOMAIN,
         data={
             CONF_URL: MOCK_DEVICE_LOCATION,
             CONF_DEVICE_ID: MOCK_DEVICE_UDN,
@@ -102,7 +102,7 @@ def config_entry_mock_no_mac() -> MockConfigEntry:
     """Mock a config entry that does not already contain a MAC address."""
     return MockConfigEntry(
         unique_id=MOCK_DEVICE_UDN,
-        domain=DLNA_DOMAIN,
+        domain=DOMAIN,
         data={
             CONF_URL: MOCK_DEVICE_LOCATION,
             CONF_DEVICE_ID: MOCK_DEVICE_UDN,
diff --git a/tests/components/dlna_dmr/test_config_flow.py b/tests/components/dlna_dmr/test_config_flow.py
index e02baceb380..b67c2f7799b 100644
--- a/tests/components/dlna_dmr/test_config_flow.py
+++ b/tests/components/dlna_dmr/test_config_flow.py
@@ -17,7 +17,7 @@ from homeassistant.components.dlna_dmr.const import (
     CONF_CALLBACK_URL_OVERRIDE,
     CONF_LISTEN_PORT,
     CONF_POLL_AVAILABILITY,
-    DOMAIN as DLNA_DOMAIN,
+    DOMAIN,
 )
 from homeassistant.const import CONF_DEVICE_ID, CONF_HOST, CONF_MAC, CONF_TYPE, CONF_URL
 from homeassistant.core import HomeAssistant
@@ -92,7 +92,7 @@ MOCK_DISCOVERY = SsdpServiceInfo(
             ]
         },
     },
-    x_homeassistant_matching_domains={DLNA_DOMAIN},
+    x_homeassistant_matching_domains={DOMAIN},
 )
 
 
@@ -118,7 +118,7 @@ def mock_setup_entry() -> Generator[Mock]:
 async def test_user_flow_undiscovered_manual(hass: HomeAssistant) -> None:
     """Test user-init'd flow, no discovered devices, user entering a valid URL."""
     result = await hass.config_entries.flow.async_init(
-        DLNA_DOMAIN, context={"source": config_entries.SOURCE_USER}
+        DOMAIN, context={"source": config_entries.SOURCE_USER}
     )
     assert result["type"] is FlowResultType.FORM
     assert result["errors"] == {}
@@ -150,7 +150,7 @@ async def test_user_flow_discovered_manual(
     ]
 
     result = await hass.config_entries.flow.async_init(
-        DLNA_DOMAIN, context={"source": config_entries.SOURCE_USER}
+        DOMAIN, context={"source": config_entries.SOURCE_USER}
     )
     assert result["type"] is FlowResultType.FORM
     assert result["errors"] is None
@@ -188,7 +188,7 @@ async def test_user_flow_selected(hass: HomeAssistant, ssdp_scanner_mock: Mock)
     ]
 
     result = await hass.config_entries.flow.async_init(
-        DLNA_DOMAIN, context={"source": config_entries.SOURCE_USER}
+        DOMAIN, context={"source": config_entries.SOURCE_USER}
     )
     assert result["type"] is FlowResultType.FORM
     assert result["errors"] is None
@@ -217,7 +217,7 @@ async def test_user_flow_uncontactable(
     domain_data_mock.upnp_factory.async_create_device.side_effect = UpnpError
 
     result = await hass.config_entries.flow.async_init(
-        DLNA_DOMAIN, context={"source": config_entries.SOURCE_USER}
+        DOMAIN, context={"source": config_entries.SOURCE_USER}
     )
     assert result["type"] is FlowResultType.FORM
     assert result["errors"] == {}
@@ -252,7 +252,7 @@ async def test_user_flow_embedded_st(
     upnp_device.all_devices.append(embedded_device)
 
     result = await hass.config_entries.flow.async_init(
-        DLNA_DOMAIN, context={"source": config_entries.SOURCE_USER}
+        DOMAIN, context={"source": config_entries.SOURCE_USER}
     )
     assert result["type"] is FlowResultType.FORM
     assert result["errors"] == {}
@@ -280,7 +280,7 @@ async def test_user_flow_wrong_st(hass: HomeAssistant, domain_data_mock: Mock) -
     upnp_device.device_type = WRONG_DEVICE_TYPE
 
     result = await hass.config_entries.flow.async_init(
-        DLNA_DOMAIN, context={"source": config_entries.SOURCE_USER}
+        DOMAIN, context={"source": config_entries.SOURCE_USER}
     )
     assert result["type"] is FlowResultType.FORM
     assert result["errors"] == {}
@@ -301,7 +301,7 @@ async def test_ssdp_flow_success(hass: HomeAssistant) -> None:
         logging.DEBUG
     )
     result = await hass.config_entries.flow.async_init(
-        DLNA_DOMAIN,
+        DOMAIN,
         context={"source": config_entries.SOURCE_SSDP},
         data=MOCK_DISCOVERY,
     )
@@ -333,7 +333,7 @@ async def test_ssdp_flow_unavailable(
     message, there's no need to connect to the device to configure it.
     """
     result = await hass.config_entries.flow.async_init(
-        DLNA_DOMAIN,
+        DOMAIN,
         context={"source": config_entries.SOURCE_SSDP},
         data=MOCK_DISCOVERY,
     )
@@ -364,7 +364,7 @@ async def test_ssdp_flow_existing(
     """Test that SSDP discovery of existing config entry updates the URL."""
     config_entry_mock.add_to_hass(hass)
     result = await hass.config_entries.flow.async_init(
-        DLNA_DOMAIN,
+        DOMAIN,
         context={"source": config_entries.SOURCE_SSDP},
         data=SsdpServiceInfo(
             ssdp_usn="mock_usn",
@@ -394,7 +394,7 @@ async def test_ssdp_flow_duplicate_location(
     # New discovery with different UDN but same location
     discovery = dataclasses.replace(MOCK_DISCOVERY, ssdp_udn=CHANGED_DEVICE_UDN)
     result = await hass.config_entries.flow.async_init(
-        DLNA_DOMAIN,
+        DOMAIN,
         context={"source": config_entries.SOURCE_SSDP},
         data=discovery,
     )
@@ -420,7 +420,7 @@ async def test_ssdp_duplicate_mac_ignored_entry(
 
     # SSDP discovery should be aborted
     result = await hass.config_entries.flow.async_init(
-        DLNA_DOMAIN,
+        DOMAIN,
         context={"source": config_entries.SOURCE_SSDP},
         data=discovery,
     )
@@ -443,7 +443,7 @@ async def test_ssdp_duplicate_mac_configured_entry(
 
     # SSDP discovery should be aborted
     result = await hass.config_entries.flow.async_init(
-        DLNA_DOMAIN,
+        DOMAIN,
         context={"source": config_entries.SOURCE_SSDP},
         data=discovery,
     )
@@ -459,7 +459,7 @@ async def test_ssdp_add_mac(
 
     # Start a discovery that adds the MAC address (due to auto-use mock_get_mac_address)
     result = await hass.config_entries.flow.async_init(
-        DLNA_DOMAIN,
+        DOMAIN,
         context={"source": config_entries.SOURCE_SSDP},
         data=MOCK_DISCOVERY,
     )
@@ -480,7 +480,7 @@ async def test_ssdp_dont_remove_mac(
     # Start a discovery that fails when resolving the MAC
     mock_get_mac_address.return_value = None
     result = await hass.config_entries.flow.async_init(
-        DLNA_DOMAIN,
+        DOMAIN,
         context={"source": config_entries.SOURCE_SSDP},
         data=MOCK_DISCOVERY,
     )
@@ -498,7 +498,7 @@ async def test_ssdp_flow_upnp_udn(
     """Test that SSDP discovery ignores the root device's UDN."""
     config_entry_mock.add_to_hass(hass)
     result = await hass.config_entries.flow.async_init(
-        DLNA_DOMAIN,
+        DOMAIN,
         context={"source": config_entries.SOURCE_SSDP},
         data=SsdpServiceInfo(
             ssdp_usn="mock_usn",
@@ -524,7 +524,7 @@ async def test_ssdp_missing_services(hass: HomeAssistant) -> None:
     discovery.upnp = dict(discovery.upnp)
     del discovery.upnp[ATTR_UPNP_SERVICE_LIST]
     result = await hass.config_entries.flow.async_init(
-        DLNA_DOMAIN,
+        DOMAIN,
         context={"source": config_entries.SOURCE_SSDP},
         data=discovery,
     )
@@ -536,7 +536,7 @@ async def test_ssdp_missing_services(hass: HomeAssistant) -> None:
     discovery.upnp = discovery.upnp.copy()
     discovery.upnp[ATTR_UPNP_SERVICE_LIST] = {"bad_key": "bad_value"}
     result = await hass.config_entries.flow.async_init(
-        DLNA_DOMAIN,
+        DOMAIN,
         context={"source": config_entries.SOURCE_SSDP},
         data=discovery,
     )
@@ -554,7 +554,7 @@ async def test_ssdp_missing_services(hass: HomeAssistant) -> None:
         ]
     }
     result = await hass.config_entries.flow.async_init(
-        DLNA_DOMAIN, context={"source": config_entries.SOURCE_SSDP}, data=discovery
+        DOMAIN, context={"source": config_entries.SOURCE_SSDP}, data=discovery
     )
     assert result["type"] is FlowResultType.ABORT
     assert result["reason"] == "not_dmr"
@@ -574,7 +574,7 @@ async def test_ssdp_single_service(hass: HomeAssistant) -> None:
     discovery.upnp[ATTR_UPNP_SERVICE_LIST] = service_list
 
     result = await hass.config_entries.flow.async_init(
-        DLNA_DOMAIN,
+        DOMAIN,
         context={"source": config_entries.SOURCE_SSDP},
         data=discovery,
     )
@@ -585,10 +585,10 @@ async def test_ssdp_single_service(hass: HomeAssistant) -> None:
 async def test_ssdp_ignore_device(hass: HomeAssistant) -> None:
     """Test SSDP discovery ignores certain devices."""
     discovery = dataclasses.replace(MOCK_DISCOVERY)
-    discovery.x_homeassistant_matching_domains = {DLNA_DOMAIN, "other_domain"}
+    discovery.x_homeassistant_matching_domains = {DOMAIN, "other_domain"}
     assert discovery.x_homeassistant_matching_domains
     result = await hass.config_entries.flow.async_init(
-        DLNA_DOMAIN,
+        DOMAIN,
         context={"source": config_entries.SOURCE_SSDP},
         data=discovery,
     )
@@ -599,7 +599,7 @@ async def test_ssdp_ignore_device(hass: HomeAssistant) -> None:
     discovery.upnp = dict(discovery.upnp)
     discovery.upnp[ATTR_UPNP_DEVICE_TYPE] = "urn:schemas-upnp-org:device:ZonePlayer:1"
     result = await hass.config_entries.flow.async_init(
-        DLNA_DOMAIN,
+        DOMAIN,
         context={"source": config_entries.SOURCE_SSDP},
         data=discovery,
     )
@@ -617,7 +617,7 @@ async def test_ssdp_ignore_device(hass: HomeAssistant) -> None:
         discovery.upnp[ATTR_UPNP_MANUFACTURER] = manufacturer
         discovery.upnp[ATTR_UPNP_MODEL_NAME] = model
         result = await hass.config_entries.flow.async_init(
-            DLNA_DOMAIN,
+            DOMAIN,
             context={"source": config_entries.SOURCE_SSDP},
             data=discovery,
         )
@@ -637,7 +637,7 @@ async def test_ignore_flow(hass: HomeAssistant, ssdp_scanner_mock: Mock) -> None
     ]
 
     result = await hass.config_entries.flow.async_init(
-        DLNA_DOMAIN,
+        DOMAIN,
         context={"source": config_entries.SOURCE_IGNORE},
         data={"unique_id": MOCK_DEVICE_UDN, "title": MOCK_DEVICE_NAME},
     )
@@ -661,7 +661,7 @@ async def test_ignore_flow_no_ssdp(
     ssdp_scanner_mock.async_get_discovery_info_by_udn_st.return_value = None
 
     result = await hass.config_entries.flow.async_init(
-        DLNA_DOMAIN,
+        DOMAIN,
         context={"source": config_entries.SOURCE_IGNORE},
         data={"unique_id": MOCK_DEVICE_UDN, "title": MOCK_DEVICE_NAME},
     )
@@ -683,7 +683,7 @@ async def test_get_mac_address_ipv4(
     """Test getting MAC address from IPv4 address for SSDP discovery."""
     # Init'ing the flow should be enough to get the MAC address
     result = await hass.config_entries.flow.async_init(
-        DLNA_DOMAIN,
+        DOMAIN,
         context={"source": config_entries.SOURCE_SSDP},
         data=MOCK_DISCOVERY,
     )
@@ -707,7 +707,7 @@ async def test_get_mac_address_ipv6(
 
     # Init'ing the flow should be enough to get the MAC address
     result = await hass.config_entries.flow.async_init(
-        DLNA_DOMAIN,
+        DOMAIN,
         context={"source": config_entries.SOURCE_SSDP},
         data=discovery,
     )
@@ -728,7 +728,7 @@ async def test_get_mac_address_host(
     DEVICE_LOCATION = f"http://{DEVICE_HOSTNAME}/dmr_description.xml"
 
     result = await hass.config_entries.flow.async_init(
-        DLNA_DOMAIN, context={"source": config_entries.SOURCE_USER}
+        DOMAIN, context={"source": config_entries.SOURCE_USER}
     )
     result = await hass.config_entries.flow.async_configure(
         result["flow_id"], user_input={CONF_URL: DEVICE_LOCATION}
diff --git a/tests/components/dlna_dmr/test_init.py b/tests/components/dlna_dmr/test_init.py
index 38160f117b4..9f43a7c2412 100644
--- a/tests/components/dlna_dmr/test_init.py
+++ b/tests/components/dlna_dmr/test_init.py
@@ -3,7 +3,7 @@
 from unittest.mock import Mock
 
 from homeassistant.components import media_player
-from homeassistant.components.dlna_dmr.const import DOMAIN as DLNA_DOMAIN
+from homeassistant.components.dlna_dmr.const import DOMAIN
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers import entity_registry as er
 from homeassistant.helpers.entity_component import async_update_entity
@@ -23,7 +23,7 @@ async def test_resource_lifecycle(
     """Test that resources are acquired/released as the entity is setup/unloaded."""
     # Set up the config entry
     config_entry_mock.add_to_hass(hass)
-    assert await async_setup_component(hass, DLNA_DOMAIN, {}) is True
+    assert await async_setup_component(hass, DOMAIN, {}) is True
     await hass.async_block_till_done()
 
     # Check the entity is created and working
diff --git a/tests/components/efergy/__init__.py b/tests/components/efergy/__init__.py
index 36efa77cf45..5dc6a6ddd90 100644
--- a/tests/components/efergy/__init__.py
+++ b/tests/components/efergy/__init__.py
@@ -9,7 +9,7 @@ from homeassistant.const import CONF_API_KEY
 from homeassistant.core import HomeAssistant
 from homeassistant.setup import async_setup_component
 
-from tests.common import MockConfigEntry, load_fixture
+from tests.common import MockConfigEntry, async_load_fixture
 from tests.test_util.aiohttp import AiohttpClientMocker
 
 TOKEN = "9p6QGJ7dpZfO3fqPTBk1fyEmjV1cGoLT"
@@ -63,57 +63,57 @@ async def mock_responses(
         return
     aioclient_mock.get(
         f"{base_url}getStatus?token={token}",
-        text=load_fixture("efergy/status.json"),
+        text=await async_load_fixture(hass, "status.json", DOMAIN),
     )
     aioclient_mock.get(
         f"{base_url}getInstant?token={token}",
-        text=load_fixture("efergy/instant.json"),
+        text=await async_load_fixture(hass, "instant.json", DOMAIN),
     )
     aioclient_mock.get(
         f"{base_url}getEnergy?period=day",
-        text=load_fixture("efergy/daily_energy.json"),
+        text=await async_load_fixture(hass, "daily_energy.json", DOMAIN),
     )
     aioclient_mock.get(
         f"{base_url}getEnergy?period=week",
-        text=load_fixture("efergy/weekly_energy.json"),
+        text=await async_load_fixture(hass, "weekly_energy.json", DOMAIN),
     )
     aioclient_mock.get(
         f"{base_url}getEnergy?period=month",
-        text=load_fixture("efergy/monthly_energy.json"),
+        text=await async_load_fixture(hass, "monthly_energy.json", DOMAIN),
     )
     aioclient_mock.get(
         f"{base_url}getEnergy?period=year",
-        text=load_fixture("efergy/yearly_energy.json"),
+        text=await async_load_fixture(hass, "yearly_energy.json", DOMAIN),
     )
     aioclient_mock.get(
         f"{base_url}getBudget?token={token}",
-        text=load_fixture("efergy/budget.json"),
+        text=await async_load_fixture(hass, "budget.json", DOMAIN),
     )
     aioclient_mock.get(
         f"{base_url}getCost?period=day",
-        text=load_fixture("efergy/daily_cost.json"),
+        text=await async_load_fixture(hass, "daily_cost.json", DOMAIN),
     )
     aioclient_mock.get(
         f"{base_url}getCost?period=week",
-        text=load_fixture("efergy/weekly_cost.json"),
+        text=await async_load_fixture(hass, "weekly_cost.json", DOMAIN),
     )
     aioclient_mock.get(
         f"{base_url}getCost?period=month",
-        text=load_fixture("efergy/monthly_cost.json"),
+        text=await async_load_fixture(hass, "monthly_cost.json", DOMAIN),
     )
     aioclient_mock.get(
         f"{base_url}getCost?period=year",
-        text=load_fixture("efergy/yearly_cost.json"),
+        text=await async_load_fixture(hass, "yearly_cost.json", DOMAIN),
     )
     if token == TOKEN:
         aioclient_mock.get(
             f"{base_url}getCurrentValuesSummary?token={token}",
-            text=load_fixture("efergy/current_values_single.json"),
+            text=await async_load_fixture(hass, "current_values_single.json", DOMAIN),
         )
     else:
         aioclient_mock.get(
             f"{base_url}getCurrentValuesSummary?token={token}",
-            text=load_fixture("efergy/current_values_multi.json"),
+            text=await async_load_fixture(hass, "current_values_multi.json", DOMAIN),
         )
 
 
diff --git a/tests/components/electrasmart/test_config_flow.py b/tests/components/electrasmart/test_config_flow.py
index 6b943014cbc..500377fb702 100644
--- a/tests/components/electrasmart/test_config_flow.py
+++ b/tests/components/electrasmart/test_config_flow.py
@@ -13,13 +13,15 @@ from homeassistant.components.electrasmart.const import (
 from homeassistant.core import HomeAssistant
 from homeassistant.data_entry_flow import FlowResultType
 
-from tests.common import load_fixture
+from tests.common import async_load_fixture
 
 
 async def test_form(hass: HomeAssistant) -> None:
     """Test user config."""
 
-    mock_generate_token = loads(load_fixture("generate_token_response.json", DOMAIN))
+    mock_generate_token = loads(
+        await async_load_fixture(hass, "generate_token_response.json", DOMAIN)
+    )
     with patch(
         "electrasmart.api.ElectraAPI.generate_new_token",
         return_value=mock_generate_token,
@@ -47,8 +49,12 @@ async def test_form(hass: HomeAssistant) -> None:
 async def test_one_time_password(hass: HomeAssistant) -> None:
     """Test one time password."""
 
-    mock_generate_token = loads(load_fixture("generate_token_response.json", DOMAIN))
-    mock_otp_response = loads(load_fixture("otp_response.json", DOMAIN))
+    mock_generate_token = loads(
+        await async_load_fixture(hass, "generate_token_response.json", DOMAIN)
+    )
+    mock_otp_response = loads(
+        await async_load_fixture(hass, "otp_response.json", DOMAIN)
+    )
     with (
         patch(
             "electrasmart.api.ElectraAPI.generate_new_token",
@@ -78,7 +84,9 @@ async def test_one_time_password(hass: HomeAssistant) -> None:
 
 async def test_one_time_password_api_error(hass: HomeAssistant) -> None:
     """Test one time password."""
-    mock_generate_token = loads(load_fixture("generate_token_response.json", DOMAIN))
+    mock_generate_token = loads(
+        await async_load_fixture(hass, "generate_token_response.json", DOMAIN)
+    )
     with (
         patch(
             "electrasmart.api.ElectraAPI.generate_new_token",
@@ -124,7 +132,7 @@ async def test_invalid_phone_number(hass: HomeAssistant) -> None:
     """Test invalid phone number."""
 
     mock_invalid_phone_number_response = loads(
-        load_fixture("invalid_phone_number_response.json", DOMAIN)
+        await async_load_fixture(hass, "invalid_phone_number_response.json", DOMAIN)
     )
 
     with patch(
@@ -147,9 +155,11 @@ async def test_invalid_auth(hass: HomeAssistant) -> None:
     """Test invalid auth."""
 
     mock_generate_token_response = loads(
-        load_fixture("generate_token_response.json", DOMAIN)
+        await async_load_fixture(hass, "generate_token_response.json", DOMAIN)
+    )
+    mock_invalid_otp_response = loads(
+        await async_load_fixture(hass, "invalid_otp_response.json", DOMAIN)
     )
-    mock_invalid_otp_response = loads(load_fixture("invalid_otp_response.json", DOMAIN))
 
     with (
         patch(
diff --git a/tests/components/enocean/test_switch.py b/tests/components/enocean/test_switch.py
index 4ddd54fba05..bcdc93f89ba 100644
--- a/tests/components/enocean/test_switch.py
+++ b/tests/components/enocean/test_switch.py
@@ -2,7 +2,7 @@
 
 from enocean.utils import combine_hex
 
-from homeassistant.components.enocean import DOMAIN as ENOCEAN_DOMAIN
+from homeassistant.components.enocean import DOMAIN
 from homeassistant.components.switch import DOMAIN as SWITCH_DOMAIN
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers import entity_registry as er
@@ -13,7 +13,7 @@ from tests.common import MockConfigEntry, assert_setup_component
 SWITCH_CONFIG = {
     "switch": [
         {
-            "platform": ENOCEAN_DOMAIN,
+            "platform": DOMAIN,
             "id": [0xDE, 0xAD, 0xBE, 0xEF],
             "channel": 1,
             "name": "room0",
@@ -35,14 +35,14 @@ async def test_unique_id_migration(
 
     old_unique_id = f"{combine_hex(dev_id)}"
 
-    entry = MockConfigEntry(domain=ENOCEAN_DOMAIN, data={"device": "/dev/null"})
+    entry = MockConfigEntry(domain=DOMAIN, data={"device": "/dev/null"})
 
     entry.add_to_hass(hass)
 
     # Add a switch with an old unique_id to the entity registry
     entity_entry = entity_registry.async_get_or_create(
         SWITCH_DOMAIN,
-        ENOCEAN_DOMAIN,
+        DOMAIN,
         old_unique_id,
         suggested_object_id=entity_name,
         config_entry=entry,
@@ -69,8 +69,6 @@ async def test_unique_id_migration(
 
     assert entity_entry.unique_id == new_unique_id
     assert (
-        entity_registry.async_get_entity_id(
-            SWITCH_DOMAIN, ENOCEAN_DOMAIN, old_unique_id
-        )
+        entity_registry.async_get_entity_id(SWITCH_DOMAIN, DOMAIN, old_unique_id)
         is None
     )
diff --git a/tests/components/esphome/conftest.py b/tests/components/esphome/conftest.py
index 08a581be6d9..9de97bac3eb 100644
--- a/tests/components/esphome/conftest.py
+++ b/tests/components/esphome/conftest.py
@@ -54,9 +54,9 @@ class MockGenericDeviceEntryType(Protocol):
     async def __call__(
         self,
         mock_client: APIClient,
-        entity_info: list[EntityInfo],
-        user_service: list[UserService],
-        states: list[EntityState],
+        entity_info: list[EntityInfo] | None = ...,
+        user_service: list[UserService] | None = ...,
+        states: list[EntityState] | None = ...,
         mock_storage: bool = ...,
     ) -> MockConfigEntry:
         """Mock an ESPHome device entry."""
@@ -685,9 +685,9 @@ async def mock_generic_device_entry(
 
     async def _mock_device_entry(
         mock_client: APIClient,
-        entity_info: list[EntityInfo],
-        user_service: list[UserService],
-        states: list[EntityState],
+        entity_info: list[EntityInfo] | None = None,
+        user_service: list[UserService] | None = None,
+        states: list[EntityState] | None = None,
         mock_storage: bool = False,
     ) -> MockConfigEntry:
         return (
@@ -695,8 +695,8 @@ async def mock_generic_device_entry(
                 hass,
                 mock_client,
                 {},
-                (entity_info, user_service),
-                states,
+                (entity_info or [], user_service or []),
+                states or [],
                 None,
                 hass_storage if mock_storage else None,
             )
diff --git a/tests/components/esphome/test_assist_satellite.py b/tests/components/esphome/test_assist_satellite.py
index 50ce362d7b6..ec6091307b9 100644
--- a/tests/components/esphome/test_assist_satellite.py
+++ b/tests/components/esphome/test_assist_satellite.py
@@ -73,9 +73,6 @@ async def test_no_satellite_without_voice_assistant(
     """Test that an assist satellite entity is not created if a voice assistant is not present."""
     mock_device = await mock_esphome_device(
         mock_client=mock_client,
-        entity_info=[],
-        user_service=[],
-        states=[],
         device_info={},
     )
     await hass.async_block_till_done()
@@ -96,9 +93,6 @@ async def test_pipeline_api_audio(
 
     mock_device = await mock_esphome_device(
         mock_client=mock_client,
-        entity_info=[],
-        user_service=[],
-        states=[],
         device_info={
             "voice_assistant_feature_flags": VoiceAssistantFeature.VOICE_ASSISTANT
             | VoiceAssistantFeature.SPEAKER
@@ -406,9 +400,6 @@ async def test_pipeline_udp_audio(
 
     mock_device = await mock_esphome_device(
         mock_client=mock_client,
-        entity_info=[],
-        user_service=[],
-        states=[],
         device_info={
             "voice_assistant_feature_flags": VoiceAssistantFeature.VOICE_ASSISTANT
             | VoiceAssistantFeature.SPEAKER
@@ -616,9 +607,6 @@ async def test_pipeline_media_player(
 
     mock_device = await mock_esphome_device(
         mock_client=mock_client,
-        entity_info=[],
-        user_service=[],
-        states=[],
         device_info={
             "voice_assistant_feature_flags": VoiceAssistantFeature.VOICE_ASSISTANT
             | VoiceAssistantFeature.API_AUDIO
@@ -762,9 +750,6 @@ async def test_timer_events(
 
     mock_device = await mock_esphome_device(
         mock_client=mock_client,
-        entity_info=[],
-        user_service=[],
-        states=[],
         device_info={
             "voice_assistant_feature_flags": VoiceAssistantFeature.VOICE_ASSISTANT
             | VoiceAssistantFeature.TIMERS
@@ -833,9 +818,6 @@ async def test_unknown_timer_event(
 
     mock_device = await mock_esphome_device(
         mock_client=mock_client,
-        entity_info=[],
-        user_service=[],
-        states=[],
         device_info={
             "voice_assistant_feature_flags": VoiceAssistantFeature.VOICE_ASSISTANT
             | VoiceAssistantFeature.TIMERS
@@ -877,9 +859,6 @@ async def test_streaming_tts_errors(
     """Test error conditions for _stream_tts_audio function."""
     mock_device = await mock_esphome_device(
         mock_client=mock_client,
-        entity_info=[],
-        user_service=[],
-        states=[],
         device_info={
             "voice_assistant_feature_flags": VoiceAssistantFeature.VOICE_ASSISTANT
         },
@@ -1089,9 +1068,6 @@ async def test_announce_message(
     """Test announcement with message."""
     mock_device = await mock_esphome_device(
         mock_client=mock_client,
-        entity_info=[],
-        user_service=[],
-        states=[],
         device_info={
             "voice_assistant_feature_flags": VoiceAssistantFeature.VOICE_ASSISTANT
             | VoiceAssistantFeature.SPEAKER
@@ -1260,9 +1236,6 @@ async def test_announce_message_with_preannounce(
     """Test announcement with message and preannounce media id."""
     mock_device = await mock_esphome_device(
         mock_client=mock_client,
-        entity_info=[],
-        user_service=[],
-        states=[],
         device_info={
             "voice_assistant_feature_flags": VoiceAssistantFeature.VOICE_ASSISTANT
             | VoiceAssistantFeature.SPEAKER
@@ -1334,9 +1307,6 @@ async def test_non_default_supported_features(
     """Test that the start conversation and announce are not set by default."""
     mock_device = await mock_esphome_device(
         mock_client=mock_client,
-        entity_info=[],
-        user_service=[],
-        states=[],
         device_info={
             "voice_assistant_feature_flags": VoiceAssistantFeature.VOICE_ASSISTANT
         },
@@ -1360,9 +1330,6 @@ async def test_start_conversation_message(
     """Test start conversation with message."""
     mock_device = await mock_esphome_device(
         mock_client=mock_client,
-        entity_info=[],
-        user_service=[],
-        states=[],
         device_info={
             "voice_assistant_feature_flags": VoiceAssistantFeature.VOICE_ASSISTANT
             | VoiceAssistantFeature.SPEAKER
@@ -1569,9 +1536,6 @@ async def test_start_conversation_message_with_preannounce(
     """Test start conversation with message and preannounce media id."""
     mock_device = await mock_esphome_device(
         mock_client=mock_client,
-        entity_info=[],
-        user_service=[],
-        states=[],
         device_info={
             "voice_assistant_feature_flags": VoiceAssistantFeature.VOICE_ASSISTANT
             | VoiceAssistantFeature.SPEAKER
@@ -1662,9 +1626,6 @@ async def test_satellite_unloaded_on_disconnect(
     """Test that the assist satellite platform is unloaded on disconnect."""
     mock_device = await mock_esphome_device(
         mock_client=mock_client,
-        entity_info=[],
-        user_service=[],
-        states=[],
         device_info={
             "voice_assistant_feature_flags": VoiceAssistantFeature.VOICE_ASSISTANT
         },
@@ -1694,9 +1655,6 @@ async def test_pipeline_abort(
     """Test aborting a pipeline (no further processing)."""
     mock_device = await mock_esphome_device(
         mock_client=mock_client,
-        entity_info=[],
-        user_service=[],
-        states=[],
         device_info={
             "voice_assistant_feature_flags": VoiceAssistantFeature.VOICE_ASSISTANT
             | VoiceAssistantFeature.API_AUDIO
@@ -1778,9 +1736,6 @@ async def test_get_set_configuration(
 
     mock_device = await mock_esphome_device(
         mock_client=mock_client,
-        entity_info=[],
-        user_service=[],
-        states=[],
         device_info={
             "voice_assistant_feature_flags": VoiceAssistantFeature.VOICE_ASSISTANT
             | VoiceAssistantFeature.ANNOUNCE
@@ -1839,9 +1794,6 @@ async def test_wake_word_select(
 
     mock_device = await mock_esphome_device(
         mock_client=mock_client,
-        entity_info=[],
-        user_service=[],
-        states=[],
         device_info={
             "voice_assistant_feature_flags": VoiceAssistantFeature.VOICE_ASSISTANT
             | VoiceAssistantFeature.ANNOUNCE
diff --git a/tests/components/esphome/test_config_flow.py b/tests/components/esphome/test_config_flow.py
index ead9167d258..3f0148262e4 100644
--- a/tests/components/esphome/test_config_flow.py
+++ b/tests/components/esphome/test_config_flow.py
@@ -1722,9 +1722,6 @@ async def test_option_flow_allow_service_calls(
     """Test config flow options for allow service calls."""
     entry = await mock_generic_device_entry(
         mock_client=mock_client,
-        entity_info=[],
-        user_service=[],
-        states=[],
     )
 
     result = await hass.config_entries.options.async_init(entry.entry_id)
@@ -1767,9 +1764,6 @@ async def test_option_flow_subscribe_logs(
     """Test config flow options with subscribe logs."""
     entry = await mock_generic_device_entry(
         mock_client=mock_client,
-        entity_info=[],
-        user_service=[],
-        states=[],
     )
 
     result = await hass.config_entries.options.async_init(entry.entry_id)
diff --git a/tests/components/esphome/test_diagnostics.py b/tests/components/esphome/test_diagnostics.py
index 84f2243a844..662adc655ae 100644
--- a/tests/components/esphome/test_diagnostics.py
+++ b/tests/components/esphome/test_diagnostics.py
@@ -52,9 +52,6 @@ async def test_diagnostics_with_dashboard_data(
     )
     mock_device = await mock_esphome_device(
         mock_client=mock_client,
-        entity_info=[],
-        user_service=[],
-        states=[],
     )
     await MockDashboardRefresh(hass).async_refresh()
     result = await get_diagnostics_for_config_entry(
diff --git a/tests/components/esphome/test_entity.py b/tests/components/esphome/test_entity.py
index 36185efeb72..9dcfe73b898 100644
--- a/tests/components/esphome/test_entity.py
+++ b/tests/components/esphome/test_entity.py
@@ -59,11 +59,9 @@ async def test_entities_removed(
         BinarySensorState(key=1, state=True, missing_state=False),
         BinarySensorState(key=2, state=True, missing_state=False),
     ]
-    user_service = []
     mock_device = await mock_esphome_device(
         mock_client=mock_client,
         entity_info=entity_info,
-        user_service=user_service,
         states=states,
     )
     entry = mock_device.entry
@@ -106,7 +104,6 @@ async def test_entities_removed(
     mock_device = await mock_esphome_device(
         mock_client=mock_client,
         entity_info=entity_info,
-        user_service=user_service,
         states=states,
         entry=entry,
     )
@@ -151,11 +148,9 @@ async def test_entities_removed_after_reload(
         BinarySensorState(key=1, state=True, missing_state=False),
         BinarySensorState(key=2, state=True, missing_state=False),
     ]
-    user_service = []
     mock_device: MockESPHomeDevice = await mock_esphome_device(
         mock_client=mock_client,
         entity_info=entity_info,
-        user_service=user_service,
         states=states,
     )
     entry = mock_device.entry
@@ -218,7 +213,7 @@ async def test_entities_removed_after_reload(
         ),
     ]
     mock_device.client.list_entities_services = AsyncMock(
-        return_value=(entity_info, user_service)
+        return_value=(entity_info, [])
     )
 
     assert await hass.config_entries.async_setup(entry.entry_id)
@@ -273,11 +268,9 @@ async def test_entities_for_entire_platform_removed(
     states = [
         BinarySensorState(key=1, state=True, missing_state=False),
     ]
-    user_service = []
     mock_device = await mock_esphome_device(
         mock_client=mock_client,
         entity_info=entity_info,
-        user_service=user_service,
         states=states,
     )
     entry = mock_device.entry
@@ -300,13 +293,8 @@ async def test_entities_for_entire_platform_removed(
     assert reg_entry is not None
     assert state.attributes[ATTR_RESTORED] is True
 
-    entity_info = []
-    states = []
     mock_device = await mock_esphome_device(
         mock_client=mock_client,
-        entity_info=entity_info,
-        user_service=user_service,
-        states=states,
         entry=entry,
     )
     assert mock_device.entry.entry_id == entry_id
@@ -336,11 +324,9 @@ async def test_entity_info_object_ids(
         )
     ]
     states = []
-    user_service = []
     await mock_esphome_device(
         mock_client=mock_client,
         entity_info=entity_info,
-        user_service=user_service,
         states=states,
     )
     state = hass.states.get("binary_sensor.test_object_id_is_used")
@@ -373,11 +359,9 @@ async def test_deep_sleep_device(
         BinarySensorState(key=2, state=True, missing_state=False),
         SensorState(key=3, state=123.0, missing_state=False),
     ]
-    user_service = []
     mock_device = await mock_esphome_device(
         mock_client=mock_client,
         entity_info=entity_info,
-        user_service=user_service,
         states=states,
         device_info={"has_deep_sleep": True},
     )
@@ -474,11 +458,9 @@ async def test_esphome_device_without_friendly_name(
         BinarySensorState(key=1, state=True, missing_state=False),
         BinarySensorState(key=2, state=True, missing_state=False),
     ]
-    user_service = []
     await mock_esphome_device(
         mock_client=mock_client,
         entity_info=entity_info,
-        user_service=user_service,
         states=states,
         device_info={"friendly_name": None},
     )
@@ -505,11 +487,9 @@ async def test_entity_without_name_device_with_friendly_name(
     states = [
         BinarySensorState(key=1, state=True, missing_state=False),
     ]
-    user_service = []
     await mock_esphome_device(
         mock_client=mock_client,
         entity_info=entity_info,
-        user_service=user_service,
         states=states,
         device_info={"friendly_name": "The Best Mixer", "name": "mixer"},
     )
@@ -540,7 +520,6 @@ async def test_entity_id_preserved_on_upgrade(
     states = [
         BinarySensorState(key=1, state=True, missing_state=False),
     ]
-    user_service = []
     assert (
         build_unique_id("11:22:33:44:55:AA", entity_info[0])
         == "11:22:33:44:55:AA-binary_sensor-my"
@@ -556,7 +535,6 @@ async def test_entity_id_preserved_on_upgrade(
     await mock_esphome_device(
         mock_client=mock_client,
         entity_info=entity_info,
-        user_service=user_service,
         states=states,
         device_info={"friendly_name": "The Best Mixer", "name": "mixer"},
     )
@@ -583,7 +561,6 @@ async def test_entity_id_preserved_on_upgrade_old_format_entity_id(
     states = [
         BinarySensorState(key=1, state=True, missing_state=False),
     ]
-    user_service = []
     assert (
         build_unique_id("11:22:33:44:55:AA", entity_info[0])
         == "11:22:33:44:55:AA-binary_sensor-my"
@@ -599,7 +576,6 @@ async def test_entity_id_preserved_on_upgrade_old_format_entity_id(
     await mock_esphome_device(
         mock_client=mock_client,
         entity_info=entity_info,
-        user_service=user_service,
         states=states,
         device_info={"name": "mixer"},
     )
@@ -626,11 +602,9 @@ async def test_entity_id_preserved_on_upgrade_when_in_storage(
     states = [
         BinarySensorState(key=1, state=True, missing_state=False),
     ]
-    user_service = []
     device = await mock_esphome_device(
         mock_client=mock_client,
         entity_info=entity_info,
-        user_service=user_service,
         states=states,
         device_info={"friendly_name": "The Best Mixer", "name": "mixer"},
     )
@@ -660,7 +634,6 @@ async def test_entity_id_preserved_on_upgrade_when_in_storage(
     device = await mock_esphome_device(
         mock_client=mock_client,
         entity_info=entity_info,
-        user_service=user_service,
         states=states,
         entry=entry,
         device_info={"friendly_name": "The Best Mixer", "name": "mixer"},
@@ -685,7 +658,6 @@ async def test_deep_sleep_added_after_setup(
                 unique_id="test",
             ),
         ],
-        user_service=[],
         states=[
             BinarySensorState(key=1, state=True, missing_state=False),
         ],
diff --git a/tests/components/esphome/test_manager.py b/tests/components/esphome/test_manager.py
index ac7c7ce1d47..dfadf6ad6d7 100644
--- a/tests/components/esphome/test_manager.py
+++ b/tests/components/esphome/test_manager.py
@@ -80,10 +80,7 @@ async def test_esphome_device_subscribe_logs(
     device = await mock_esphome_device(
         mock_client=mock_client,
         entry=entry,
-        entity_info=[],
-        user_service=[],
         device_info={},
-        states=[],
     )
     await hass.async_block_till_done()
 
@@ -141,14 +138,8 @@ async def test_esphome_device_service_calls_not_allowed(
     issue_registry: ir.IssueRegistry,
 ) -> None:
     """Test a device with service calls not allowed."""
-    entity_info = []
-    states = []
-    user_service = []
     device = await mock_esphome_device(
         mock_client=mock_client,
-        entity_info=entity_info,
-        user_service=user_service,
-        states=states,
         device_info={"esphome_version": "2023.3.0"},
     )
     await hass.async_block_till_done()
@@ -182,17 +173,11 @@ async def test_esphome_device_service_calls_allowed(
 ) -> None:
     """Test a device with service calls are allowed."""
     await async_setup_component(hass, TAG_DOMAIN, {})
-    entity_info = []
-    states = []
-    user_service = []
     hass.config_entries.async_update_entry(
         mock_config_entry, options={CONF_ALLOW_SERVICE_CALLS: True}
     )
     device = await mock_esphome_device(
         mock_client=mock_client,
-        entity_info=entity_info,
-        user_service=user_service,
-        states=states,
         device_info={"esphome_version": "2023.3.0"},
         entry=mock_config_entry,
     )
@@ -337,14 +322,8 @@ async def test_esphome_device_with_old_bluetooth(
     issue_registry: ir.IssueRegistry,
 ) -> None:
     """Test a device with old bluetooth creates an issue."""
-    entity_info = []
-    states = []
-    user_service = []
     await mock_esphome_device(
         mock_client=mock_client,
-        entity_info=entity_info,
-        user_service=user_service,
-        states=states,
         device_info={"bluetooth_proxy_feature_flags": 1, "esphome_version": "2023.3.0"},
     )
     await hass.async_block_till_done()
@@ -364,10 +343,6 @@ async def test_esphome_device_with_password(
     issue_registry: ir.IssueRegistry,
 ) -> None:
     """Test a device with legacy password creates an issue."""
-    entity_info = []
-    states = []
-    user_service = []
-
     entry = MockConfigEntry(
         domain=DOMAIN,
         data={
@@ -379,9 +354,6 @@ async def test_esphome_device_with_password(
     entry.add_to_hass(hass)
     await mock_esphome_device(
         mock_client=mock_client,
-        entity_info=entity_info,
-        user_service=user_service,
-        states=states,
         device_info={"bluetooth_proxy_feature_flags": 0, "esphome_version": "2023.3.0"},
         entry=entry,
     )
@@ -404,14 +376,8 @@ async def test_esphome_device_with_current_bluetooth(
     issue_registry: ir.IssueRegistry,
 ) -> None:
     """Test a device with recent bluetooth does not create an issue."""
-    entity_info = []
-    states = []
-    user_service = []
     await mock_esphome_device(
         mock_client=mock_client,
-        entity_info=entity_info,
-        user_service=user_service,
-        states=states,
         device_info={
             "bluetooth_proxy_feature_flags": 1,
             "esphome_version": STABLE_BLE_VERSION_STR,
@@ -857,9 +823,6 @@ async def test_state_subscription(
     """Test ESPHome subscribes to state changes."""
     device = await mock_esphome_device(
         mock_client=mock_client,
-        entity_info=[],
-        user_service=[],
-        states=[],
     )
     await hass.async_block_till_done()
     hass.states.async_set("binary_sensor.test", "on", {"bool": True, "float": 3.0})
@@ -917,9 +880,6 @@ async def test_state_request(
     """Test ESPHome requests state change."""
     device = await mock_esphome_device(
         mock_client=mock_client,
-        entity_info=[],
-        user_service=[],
-        states=[],
     )
     await hass.async_block_till_done()
     hass.states.async_set("binary_sensor.test", "on", {"bool": True, "float": 3.0})
@@ -944,9 +904,6 @@ async def test_debug_logging(
     assert await async_setup_component(hass, "logger", {"logger": {}})
     await mock_generic_device_entry(
         mock_client=mock_client,
-        entity_info=[],
-        user_service=[],
-        states=[],
     )
     async with async_call_logger_set_level(
         "homeassistant.components.esphome", "DEBUG", hass=hass, caplog=caplog
@@ -966,8 +923,6 @@ async def test_esphome_device_with_dash_in_name_user_services(
     mock_esphome_device: MockESPHomeDeviceType,
 ) -> None:
     """Test a device with user services and a dash in the name."""
-    entity_info = []
-    states = []
     service1 = UserService(
         name="my_service",
         key=1,
@@ -991,10 +946,8 @@ async def test_esphome_device_with_dash_in_name_user_services(
     )
     device = await mock_esphome_device(
         mock_client=mock_client,
-        entity_info=entity_info,
         user_service=[service1, service2],
         device_info={"name": "with-dash"},
-        states=states,
     )
     await hass.async_block_till_done()
     assert hass.services.has_service(DOMAIN, "with_dash_my_service")
@@ -1018,9 +971,7 @@ async def test_esphome_device_with_dash_in_name_user_services(
     mock_client.execute_service.reset_mock()
 
     # Verify the service can be removed
-    mock_client.list_entities_services = AsyncMock(
-        return_value=(entity_info, [service1])
-    )
+    mock_client.list_entities_services = AsyncMock(return_value=([], [service1]))
     await device.mock_disconnect(True)
     await hass.async_block_till_done()
     await device.mock_connect()
@@ -1035,8 +986,6 @@ async def test_esphome_user_services_ignores_invalid_arg_types(
     mock_esphome_device: MockESPHomeDeviceType,
 ) -> None:
     """Test a device with user services and a dash in the name."""
-    entity_info = []
-    states = []
     service1 = UserService(
         name="bad_service",
         key=1,
@@ -1053,10 +1002,8 @@ async def test_esphome_user_services_ignores_invalid_arg_types(
     )
     device = await mock_esphome_device(
         mock_client=mock_client,
-        entity_info=entity_info,
         user_service=[service1, service2],
         device_info={"name": "with-dash"},
-        states=states,
     )
     await hass.async_block_till_done()
     assert not hass.services.has_service(DOMAIN, "with_dash_bad_service")
@@ -1080,9 +1027,7 @@ async def test_esphome_user_services_ignores_invalid_arg_types(
     mock_client.execute_service.reset_mock()
 
     # Verify the service can be removed
-    mock_client.list_entities_services = AsyncMock(
-        return_value=(entity_info, [service2])
-    )
+    mock_client.list_entities_services = AsyncMock(return_value=([], [service2]))
     await device.mock_disconnect(True)
     await hass.async_block_till_done()
     await device.mock_connect()
@@ -1097,8 +1042,6 @@ async def test_esphome_user_service_fails(
     mock_esphome_device: MockESPHomeDeviceType,
 ) -> None:
     """Test executing a user service fails due to disconnect."""
-    entity_info = []
-    states = []
     service1 = UserService(
         name="simple_service",
         key=2,
@@ -1108,10 +1051,8 @@ async def test_esphome_user_service_fails(
     )
     await mock_esphome_device(
         mock_client=mock_client,
-        entity_info=entity_info,
         user_service=[service1],
         device_info={"name": "with-dash"},
-        states=states,
     )
     await hass.async_block_till_done()
     assert hass.services.has_service(DOMAIN, "with_dash_simple_service")
@@ -1153,8 +1094,6 @@ async def test_esphome_user_services_changes(
     mock_esphome_device: MockESPHomeDeviceType,
 ) -> None:
     """Test a device with user services that change arguments."""
-    entity_info = []
-    states = []
     service1 = UserService(
         name="simple_service",
         key=2,
@@ -1164,10 +1103,8 @@ async def test_esphome_user_services_changes(
     )
     device = await mock_esphome_device(
         mock_client=mock_client,
-        entity_info=entity_info,
         user_service=[service1],
         device_info={"name": "with-dash"},
-        states=states,
     )
     await hass.async_block_till_done()
     assert hass.services.has_service(DOMAIN, "with_dash_simple_service")
@@ -1198,9 +1135,7 @@ async def test_esphome_user_services_changes(
     )
 
     # Verify the service can be updated
-    mock_client.list_entities_services = AsyncMock(
-        return_value=(entity_info, [new_service1])
-    )
+    mock_client.list_entities_services = AsyncMock(return_value=([], [new_service1]))
     await device.mock_disconnect(True)
     await hass.async_block_till_done()
     await device.mock_connect()
@@ -1234,10 +1169,7 @@ async def test_esphome_device_with_suggested_area(
     """Test a device with suggested area."""
     device = await mock_esphome_device(
         mock_client=mock_client,
-        entity_info=[],
-        user_service=[],
         device_info={"suggested_area": "kitchen"},
-        states=[],
     )
     await hass.async_block_till_done()
     entry = device.entry
@@ -1256,10 +1188,7 @@ async def test_esphome_device_with_project(
     """Test a device with a project."""
     device = await mock_esphome_device(
         mock_client=mock_client,
-        entity_info=[],
-        user_service=[],
         device_info={"project_name": "mfr.model", "project_version": "2.2.2"},
-        states=[],
     )
     await hass.async_block_till_done()
     entry = device.entry
@@ -1280,10 +1209,7 @@ async def test_esphome_device_with_manufacturer(
     """Test a device with a manufacturer."""
     device = await mock_esphome_device(
         mock_client=mock_client,
-        entity_info=[],
-        user_service=[],
         device_info={"manufacturer": "acme"},
-        states=[],
     )
     await hass.async_block_till_done()
     entry = device.entry
@@ -1302,10 +1228,7 @@ async def test_esphome_device_with_web_server(
     """Test a device with a web server."""
     device = await mock_esphome_device(
         mock_client=mock_client,
-        entity_info=[],
-        user_service=[],
         device_info={"webserver_port": 80},
-        states=[],
     )
     await hass.async_block_till_done()
     entry = device.entry
@@ -1335,10 +1258,7 @@ async def test_esphome_device_with_ipv6_web_server(
     device = await mock_esphome_device(
         mock_client=mock_client,
         entry=entry,
-        entity_info=[],
-        user_service=[],
         device_info={"webserver_port": 80},
-        states=[],
     )
     await hass.async_block_till_done()
     entry = device.entry
@@ -1357,10 +1277,7 @@ async def test_esphome_device_with_compilation_time(
     """Test a device with a compilation_time."""
     device = await mock_esphome_device(
         mock_client=mock_client,
-        entity_info=[],
-        user_service=[],
         device_info={"compilation_time": "comp_time"},
-        states=[],
     )
     await hass.async_block_till_done()
     entry = device.entry
@@ -1378,10 +1295,7 @@ async def test_disconnects_at_close_event(
     """Test the device is disconnected at the close event."""
     await mock_esphome_device(
         mock_client=mock_client,
-        entity_info=[],
-        user_service=[],
         device_info={"compilation_time": "comp_time"},
-        states=[],
     )
     await hass.async_block_till_done()
 
@@ -1410,10 +1324,7 @@ async def test_start_reauth(
     """Test exceptions on connect error trigger reauth."""
     device = await mock_esphome_device(
         mock_client=mock_client,
-        entity_info=[],
-        user_service=[],
         device_info={"compilation_time": "comp_time"},
-        states=[],
     )
     await hass.async_block_till_done()
 
@@ -1435,10 +1346,7 @@ async def test_no_reauth_wrong_mac(
     """Test exceptions on connect error trigger reauth."""
     device = await mock_esphome_device(
         mock_client=mock_client,
-        entity_info=[],
-        user_service=[],
         device_info={"compilation_time": "comp_time"},
-        states=[],
     )
     await hass.async_block_till_done()
 
@@ -1514,14 +1422,9 @@ async def test_device_adds_friendly_name(
     caplog: pytest.LogCaptureFixture,
 ) -> None:
     """Test a device with user services that change arguments."""
-    entity_info = []
-    states = []
     device = await mock_esphome_device(
         mock_client=mock_client,
-        entity_info=entity_info,
-        user_service=[],
         device_info={"name": "nofriendlyname", "friendly_name": ""},
-        states=states,
     )
     await hass.async_block_till_done()
     dev_reg = dr.async_get(hass)
@@ -1582,10 +1485,7 @@ async def test_assist_in_progress_issue_deleted(
     )
     await mock_esphome_device(
         mock_client=mock_client,
-        entity_info=[],
-        user_service=[],
         device_info={},
-        states=[],
         mock_storage=True,
     )
     assert (
diff --git a/tests/components/esphome/test_media_player.py b/tests/components/esphome/test_media_player.py
index 18a997dc09a..e1a0cd6c348 100644
--- a/tests/components/esphome/test_media_player.py
+++ b/tests/components/esphome/test_media_player.py
@@ -328,7 +328,6 @@ async def test_media_player_proxy(
                 ],
             )
         ],
-        user_service=[],
         states=[
             MediaPlayerEntityState(
                 key=1, volume=50, muted=False, state=MediaPlayerState.PAUSED
diff --git a/tests/components/esphome/test_select.py b/tests/components/esphome/test_select.py
index 09a8f739e71..1dc37ca3cad 100644
--- a/tests/components/esphome/test_select.py
+++ b/tests/components/esphome/test_select.py
@@ -107,9 +107,6 @@ async def test_wake_word_select_no_wake_words(
 
     mock_device = await mock_esphome_device(
         mock_client=mock_client,
-        entity_info=[],
-        user_service=[],
-        states=[],
         device_info={
             "voice_assistant_feature_flags": VoiceAssistantFeature.VOICE_ASSISTANT
             | VoiceAssistantFeature.ANNOUNCE
@@ -144,9 +141,6 @@ async def test_wake_word_select_zero_max_wake_words(
 
     mock_device = await mock_esphome_device(
         mock_client=mock_client,
-        entity_info=[],
-        user_service=[],
-        states=[],
         device_info={
             "voice_assistant_feature_flags": VoiceAssistantFeature.VOICE_ASSISTANT
             | VoiceAssistantFeature.ANNOUNCE
@@ -182,9 +176,6 @@ async def test_wake_word_select_no_active_wake_words(
 
     mock_device = await mock_esphome_device(
         mock_client=mock_client,
-        entity_info=[],
-        user_service=[],
-        states=[],
         device_info={
             "voice_assistant_feature_flags": VoiceAssistantFeature.VOICE_ASSISTANT
             | VoiceAssistantFeature.ANNOUNCE
diff --git a/tests/components/esphome/test_update.py b/tests/components/esphome/test_update.py
index a612f44c07f..960cc016efc 100644
--- a/tests/components/esphome/test_update.py
+++ b/tests/components/esphome/test_update.py
@@ -99,9 +99,6 @@ async def test_update_entity(
 
     await mock_esphome_device(
         mock_client=mock_client,
-        entity_info=[],
-        user_service=[],
-        states=[],
     )
 
     state = hass.states.get("update.test_firmware")
@@ -210,9 +207,6 @@ async def test_update_static_info(
 
     mock_device = await mock_esphome_device(
         mock_client=mock_client,
-        entity_info=[],
-        user_service=[],
-        states=[],
     )
 
     state = hass.states.get("update.test_firmware")
@@ -257,9 +251,6 @@ async def test_update_device_state_for_availability(
     await async_get_dashboard(hass).async_refresh()
     mock_device = await mock_esphome_device(
         mock_client=mock_client,
-        entity_info=[],
-        user_service=[],
-        states=[],
         device_info={"has_deep_sleep": has_deep_sleep},
     )
 
@@ -287,9 +278,6 @@ async def test_update_entity_dashboard_not_available_startup(
         await async_get_dashboard(hass).async_refresh()
         await mock_esphome_device(
             mock_client=mock_client,
-            entity_info=[],
-            user_service=[],
-            states=[],
         )
 
     # We have a dashboard but it is not available
@@ -332,9 +320,6 @@ async def test_update_entity_dashboard_discovered_after_startup_but_update_faile
         await hass.async_block_till_done()
         mock_device = await mock_esphome_device(
             mock_client=mock_client,
-            entity_info=[],
-            user_service=[],
-            states=[],
         )
         await hass.async_block_till_done()
     state = hass.states.get("update.test_firmware")
@@ -372,9 +357,6 @@ async def test_update_entity_not_present_without_dashboard(
     """Test ESPHome update entity does not get created if there is no dashboard."""
     await mock_esphome_device(
         mock_client=mock_client,
-        entity_info=[],
-        user_service=[],
-        states=[],
     )
 
     state = hass.states.get("update.test_firmware")
@@ -390,9 +372,6 @@ async def test_update_becomes_available_at_runtime(
     """Test ESPHome update entity when the dashboard has no device at startup but gets them later."""
     await mock_esphome_device(
         mock_client=mock_client,
-        entity_info=[],
-        user_service=[],
-        states=[],
     )
     await hass.async_block_till_done()
     state = hass.states.get("update.test_firmware")
@@ -426,9 +405,6 @@ async def test_update_entity_not_present_with_dashboard_but_unknown_device(
     """Test ESPHome update entity does not get created if the device is unknown to the dashboard."""
     await mock_esphome_device(
         mock_client=mock_client,
-        entity_info=[],
-        user_service=[],
-        states=[],
     )
 
     mock_dashboard["configured"] = [
@@ -473,11 +449,9 @@ async def test_generic_device_update_entity(
             release_url=RELEASE_URL,
         )
     ]
-    user_service = []
     await mock_generic_device_entry(
         mock_client=mock_client,
         entity_info=entity_info,
-        user_service=user_service,
         states=states,
     )
     state = hass.states.get(ENTITY_ID)
@@ -509,11 +483,9 @@ async def test_generic_device_update_entity_has_update(
             release_url=RELEASE_URL,
         )
     ]
-    user_service = []
     mock_device = await mock_esphome_device(
         mock_client=mock_client,
         entity_info=entity_info,
-        user_service=user_service,
         states=states,
     )
     state = hass.states.get(ENTITY_ID)
@@ -591,11 +563,9 @@ async def test_update_entity_release_notes(
         )
     ]
 
-    user_service = []
     mock_device = await mock_esphome_device(
         mock_client=mock_client,
         entity_info=entity_info,
-        user_service=user_service,
         states=[],
     )
 
@@ -676,9 +646,6 @@ async def test_attempt_to_update_twice(
     await async_get_dashboard(hass).async_refresh()
     await mock_esphome_device(
         mock_client=mock_client,
-        entity_info=[],
-        user_service=[],
-        states=[],
     )
     await hass.async_block_till_done()
     state = hass.states.get("update.test_firmware")
@@ -738,9 +705,6 @@ async def test_update_deep_sleep_already_online(
     await async_get_dashboard(hass).async_refresh()
     await mock_esphome_device(
         mock_client=mock_client,
-        entity_info=[],
-        user_service=[],
-        states=[],
         device_info={"has_deep_sleep": True},
     )
     await hass.async_block_till_done()
@@ -783,9 +747,6 @@ async def test_update_deep_sleep_offline(
     await async_get_dashboard(hass).async_refresh()
     device = await mock_esphome_device(
         mock_client=mock_client,
-        entity_info=[],
-        user_service=[],
-        states=[],
         device_info={"has_deep_sleep": True},
     )
     await hass.async_block_till_done()
@@ -835,9 +796,6 @@ async def test_update_deep_sleep_offline_sleep_during_ota(
     await async_get_dashboard(hass).async_refresh()
     device = await mock_esphome_device(
         mock_client=mock_client,
-        entity_info=[],
-        user_service=[],
-        states=[],
         device_info={"has_deep_sleep": True},
     )
     await hass.async_block_till_done()
@@ -916,9 +874,6 @@ async def test_update_deep_sleep_offline_cancelled_unload(
     await async_get_dashboard(hass).async_refresh()
     device = await mock_esphome_device(
         mock_client=mock_client,
-        entity_info=[],
-        user_service=[],
-        states=[],
         device_info={"has_deep_sleep": True},
     )
     await hass.async_block_till_done()
diff --git a/tests/components/event/test_init.py b/tests/components/event/test_init.py
index bc43a234ffc..0cd1f39228f 100644
--- a/tests/components/event/test_init.py
+++ b/tests/components/event/test_init.py
@@ -15,7 +15,7 @@ from homeassistant.components.event import (
     EventEntityDescription,
 )
 from homeassistant.config_entries import ConfigEntry, ConfigFlow
-from homeassistant.const import CONF_PLATFORM, STATE_UNKNOWN
+from homeassistant.const import CONF_PLATFORM, STATE_UNKNOWN, Platform
 from homeassistant.core import HomeAssistant, State
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from homeassistant.helpers.restore_state import STORAGE_KEY as RESTORE_STATE_KEY
@@ -254,7 +254,9 @@ async def test_name(hass: HomeAssistant) -> None:
         hass: HomeAssistant, config_entry: ConfigEntry
     ) -> bool:
         """Set up test config entry."""
-        await hass.config_entries.async_forward_entry_setups(config_entry, [DOMAIN])
+        await hass.config_entries.async_forward_entry_setups(
+            config_entry, [Platform.EVENT]
+        )
         return True
 
     mock_platform(hass, f"{TEST_DOMAIN}.config_flow")
diff --git a/tests/components/flo/conftest.py b/tests/components/flo/conftest.py
index 66b56d1f10b..5b303d5c4b4 100644
--- a/tests/components/flo/conftest.py
+++ b/tests/components/flo/conftest.py
@@ -6,7 +6,7 @@ import time
 
 import pytest
 
-from homeassistant.components.flo.const import DOMAIN as FLO_DOMAIN
+from homeassistant.components.flo.const import DOMAIN
 from homeassistant.const import CONF_PASSWORD, CONF_USERNAME, CONTENT_TYPE_JSON
 
 from .common import TEST_EMAIL_ADDRESS, TEST_PASSWORD, TEST_TOKEN, TEST_USER_ID
@@ -19,7 +19,7 @@ from tests.test_util.aiohttp import AiohttpClientMocker
 def config_entry() -> MockConfigEntry:
     """Config entry version 1 fixture."""
     return MockConfigEntry(
-        domain=FLO_DOMAIN,
+        domain=DOMAIN,
         data={CONF_USERNAME: TEST_USER_ID, CONF_PASSWORD: TEST_PASSWORD},
         version=1,
     )
diff --git a/tests/components/flo/test_services.py b/tests/components/flo/test_services.py
index 980d5906a56..26a5eaa1eda 100644
--- a/tests/components/flo/test_services.py
+++ b/tests/components/flo/test_services.py
@@ -3,7 +3,7 @@
 import pytest
 from voluptuous.error import MultipleInvalid
 
-from homeassistant.components.flo.const import DOMAIN as FLO_DOMAIN
+from homeassistant.components.flo.const import DOMAIN
 from homeassistant.components.flo.switch import (
     ATTR_REVERT_TO_MODE,
     ATTR_SLEEP_MINUTES,
@@ -36,7 +36,7 @@ async def test_services(
     assert aioclient_mock.call_count == 8
 
     await hass.services.async_call(
-        FLO_DOMAIN,
+        DOMAIN,
         SERVICE_RUN_HEALTH_TEST,
         {ATTR_ENTITY_ID: SWITCH_ENTITY_ID},
         blocking=True,
@@ -45,7 +45,7 @@ async def test_services(
     assert aioclient_mock.call_count == 9
 
     await hass.services.async_call(
-        FLO_DOMAIN,
+        DOMAIN,
         SERVICE_SET_AWAY_MODE,
         {ATTR_ENTITY_ID: SWITCH_ENTITY_ID},
         blocking=True,
@@ -54,7 +54,7 @@ async def test_services(
     assert aioclient_mock.call_count == 10
 
     await hass.services.async_call(
-        FLO_DOMAIN,
+        DOMAIN,
         SERVICE_SET_HOME_MODE,
         {ATTR_ENTITY_ID: SWITCH_ENTITY_ID},
         blocking=True,
@@ -63,7 +63,7 @@ async def test_services(
     assert aioclient_mock.call_count == 11
 
     await hass.services.async_call(
-        FLO_DOMAIN,
+        DOMAIN,
         SERVICE_SET_SLEEP_MODE,
         {
             ATTR_ENTITY_ID: SWITCH_ENTITY_ID,
@@ -77,7 +77,7 @@ async def test_services(
 
     # test calling with a string value to ensure it is converted to int
     await hass.services.async_call(
-        FLO_DOMAIN,
+        DOMAIN,
         SERVICE_SET_SLEEP_MODE,
         {
             ATTR_ENTITY_ID: SWITCH_ENTITY_ID,
@@ -92,7 +92,7 @@ async def test_services(
     # test calling with a non string -> int value and ensure exception is thrown
     with pytest.raises(MultipleInvalid):
         await hass.services.async_call(
-            FLO_DOMAIN,
+            DOMAIN,
             SERVICE_SET_SLEEP_MODE,
             {
                 ATTR_ENTITY_ID: SWITCH_ENTITY_ID,
diff --git a/tests/components/foobot/test_sensor.py b/tests/components/foobot/test_sensor.py
index d5461ae71c7..d9d80191075 100644
--- a/tests/components/foobot/test_sensor.py
+++ b/tests/components/foobot/test_sensor.py
@@ -19,7 +19,7 @@ from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import PlatformNotReady
 from homeassistant.setup import async_setup_component
 
-from tests.common import load_fixture
+from tests.common import async_load_fixture
 from tests.test_util.aiohttp import AiohttpClientMocker
 
 VALID_CONFIG = {
@@ -35,11 +35,11 @@ async def test_default_setup(
     """Test the default setup."""
     aioclient_mock.get(
         re.compile("api.foobot.io/v2/owner/.*"),
-        text=load_fixture("devices.json", "foobot"),
+        text=await async_load_fixture(hass, "devices.json", "foobot"),
     )
     aioclient_mock.get(
         re.compile("api.foobot.io/v2/device/.*"),
-        text=load_fixture("data.json", "foobot"),
+        text=await async_load_fixture(hass, "data.json", "foobot"),
     )
     assert await async_setup_component(hass, sensor.DOMAIN, {"sensor": VALID_CONFIG})
     await hass.async_block_till_done()
diff --git a/tests/components/fritzbox/test_binary_sensor.py b/tests/components/fritzbox/test_binary_sensor.py
index ae691f6107e..7df56014b41 100644
--- a/tests/components/fritzbox/test_binary_sensor.py
+++ b/tests/components/fritzbox/test_binary_sensor.py
@@ -9,7 +9,7 @@ from requests.exceptions import HTTPError
 from syrupy.assertion import SnapshotAssertion
 
 from homeassistant.components.binary_sensor import DOMAIN as BINARY_SENSOR_DOMAIN
-from homeassistant.components.fritzbox.const import DOMAIN as FB_DOMAIN
+from homeassistant.components.fritzbox.const import DOMAIN
 from homeassistant.config_entries import ConfigEntryState
 from homeassistant.const import CONF_DEVICES, STATE_UNAVAILABLE, Platform
 from homeassistant.core import HomeAssistant
@@ -35,7 +35,7 @@ async def test_setup(
     device = FritzDeviceBinarySensorMock()
     with patch("homeassistant.components.fritzbox.PLATFORMS", [Platform.BINARY_SENSOR]):
         entry = await setup_config_entry(
-            hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
+            hass, MOCK_CONFIG[DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
         )
     assert entry.state is ConfigEntryState.LOADED
 
@@ -47,7 +47,7 @@ async def test_is_off(hass: HomeAssistant, fritz: Mock) -> None:
     device = FritzDeviceBinarySensorMock()
     device.present = False
     await setup_config_entry(
-        hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
+        hass, MOCK_CONFIG[DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
     )
 
     state = hass.states.get(f"{ENTITY_ID}_alarm")
@@ -67,7 +67,7 @@ async def test_update(hass: HomeAssistant, fritz: Mock) -> None:
     """Test update without error."""
     device = FritzDeviceBinarySensorMock()
     await setup_config_entry(
-        hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
+        hass, MOCK_CONFIG[DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
     )
 
     assert fritz().update_devices.call_count == 1
@@ -86,7 +86,7 @@ async def test_update_error(hass: HomeAssistant, fritz: Mock) -> None:
     device = FritzDeviceBinarySensorMock()
     device.update.side_effect = [mock.DEFAULT, HTTPError("Boom")]
     await setup_config_entry(
-        hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
+        hass, MOCK_CONFIG[DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
     )
 
     assert fritz().update_devices.call_count == 1
@@ -104,7 +104,7 @@ async def test_discover_new_device(hass: HomeAssistant, fritz: Mock) -> None:
     """Test adding new discovered devices during runtime."""
     device = FritzDeviceBinarySensorMock()
     await setup_config_entry(
-        hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
+        hass, MOCK_CONFIG[DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
     )
 
     state = hass.states.get(f"{ENTITY_ID}_alarm")
diff --git a/tests/components/fritzbox/test_button.py b/tests/components/fritzbox/test_button.py
index ada50d7f16c..a964419e0a2 100644
--- a/tests/components/fritzbox/test_button.py
+++ b/tests/components/fritzbox/test_button.py
@@ -6,7 +6,7 @@ from unittest.mock import Mock, patch
 from syrupy.assertion import SnapshotAssertion
 
 from homeassistant.components.button import DOMAIN as BUTTON_DOMAIN, SERVICE_PRESS
-from homeassistant.components.fritzbox.const import DOMAIN as FB_DOMAIN
+from homeassistant.components.fritzbox.const import DOMAIN
 from homeassistant.config_entries import ConfigEntryState
 from homeassistant.const import ATTR_ENTITY_ID, CONF_DEVICES, Platform
 from homeassistant.core import HomeAssistant
@@ -32,7 +32,7 @@ async def test_setup(
     with patch("homeassistant.components.fritzbox.PLATFORMS", [Platform.BUTTON]):
         entry = await setup_config_entry(
             hass,
-            MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0],
+            MOCK_CONFIG[DOMAIN][CONF_DEVICES][0],
             fritz=fritz,
             template=template,
         )
@@ -45,7 +45,7 @@ async def test_apply_template(hass: HomeAssistant, fritz: Mock) -> None:
     """Test if applies works."""
     template = FritzEntityBaseMock()
     await setup_config_entry(
-        hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], fritz=fritz, template=template
+        hass, MOCK_CONFIG[DOMAIN][CONF_DEVICES][0], fritz=fritz, template=template
     )
 
     await hass.services.async_call(
@@ -58,7 +58,7 @@ async def test_discover_new_device(hass: HomeAssistant, fritz: Mock) -> None:
     """Test adding new discovered devices during runtime."""
     template = FritzEntityBaseMock()
     await setup_config_entry(
-        hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], fritz=fritz, template=template
+        hass, MOCK_CONFIG[DOMAIN][CONF_DEVICES][0], fritz=fritz, template=template
     )
 
     state = hass.states.get(ENTITY_ID)
diff --git a/tests/components/fritzbox/test_climate.py b/tests/components/fritzbox/test_climate.py
index e216f7d4b30..3853e9275c8 100644
--- a/tests/components/fritzbox/test_climate.py
+++ b/tests/components/fritzbox/test_climate.py
@@ -34,7 +34,7 @@ from homeassistant.components.fritzbox.climate import (
 from homeassistant.components.fritzbox.const import (
     ATTR_STATE_HOLIDAY_MODE,
     ATTR_STATE_SUMMER_MODE,
-    DOMAIN as FB_DOMAIN,
+    DOMAIN,
 )
 from homeassistant.config_entries import ConfigEntryState
 from homeassistant.const import ATTR_ENTITY_ID, ATTR_TEMPERATURE, CONF_DEVICES, Platform
@@ -66,7 +66,7 @@ async def test_setup(
     device = FritzDeviceClimateMock()
     with patch("homeassistant.components.fritzbox.PLATFORMS", [Platform.CLIMATE]):
         entry = await setup_config_entry(
-            hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
+            hass, MOCK_CONFIG[DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
         )
 
     await snapshot_platform(hass, entity_registry, snapshot, entry.entry_id)
@@ -76,7 +76,7 @@ async def test_hkr_wo_temperature_sensor(hass: HomeAssistant, fritz: Mock) -> No
     """Test hkr without exposing dedicated temperature sensor data block."""
     device = FritzDeviceClimateWithoutTempSensorMock()
     await setup_config_entry(
-        hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
+        hass, MOCK_CONFIG[DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
     )
 
     state = hass.states.get(ENTITY_ID)
@@ -89,7 +89,7 @@ async def test_target_temperature_on(hass: HomeAssistant, fritz: Mock) -> None:
     device = FritzDeviceClimateMock()
     device.target_temperature = 127.0
     await setup_config_entry(
-        hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
+        hass, MOCK_CONFIG[DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
     )
 
     state = hass.states.get(ENTITY_ID)
@@ -102,7 +102,7 @@ async def test_target_temperature_off(hass: HomeAssistant, fritz: Mock) -> None:
     device = FritzDeviceClimateMock()
     device.target_temperature = 126.5
     await setup_config_entry(
-        hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
+        hass, MOCK_CONFIG[DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
     )
 
     state = hass.states.get(ENTITY_ID)
@@ -114,7 +114,7 @@ async def test_update(hass: HomeAssistant, fritz: Mock) -> None:
     """Test update without error."""
     device = FritzDeviceClimateMock()
     await setup_config_entry(
-        hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
+        hass, MOCK_CONFIG[DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
     )
 
     state = hass.states.get(ENTITY_ID)
@@ -145,7 +145,7 @@ async def test_automatic_offset(hass: HomeAssistant, fritz: Mock) -> None:
     device.actual_temperature = 19
     device.target_temperature = 20
     await setup_config_entry(
-        hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
+        hass, MOCK_CONFIG[DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
     )
 
     state = hass.states.get(ENTITY_ID)
@@ -161,7 +161,7 @@ async def test_update_error(hass: HomeAssistant, fritz: Mock) -> None:
     device = FritzDeviceClimateMock()
     fritz().update_devices.side_effect = HTTPError("Boom")
     entry = await setup_config_entry(
-        hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
+        hass, MOCK_CONFIG[DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
     )
     assert entry.state is ConfigEntryState.SETUP_RETRY
 
@@ -214,7 +214,7 @@ async def test_set_temperature(
     device.lock = False
 
     await setup_config_entry(
-        hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
+        hass, MOCK_CONFIG[DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
     )
 
     await hass.services.async_call(
@@ -302,7 +302,7 @@ async def test_set_hvac_mode(
         device.nextchange_endperiod = 0
 
     await setup_config_entry(
-        hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
+        hass, MOCK_CONFIG[DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
     )
 
     await hass.services.async_call(
@@ -343,7 +343,7 @@ async def test_set_preset_mode_comfort(
     device.lock = False
     device.comfort_temperature = comfort_temperature
     await setup_config_entry(
-        hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
+        hass, MOCK_CONFIG[DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
     )
 
     await hass.services.async_call(
@@ -376,7 +376,7 @@ async def test_set_preset_mode_eco(
     device.lock = False
     device.eco_temperature = eco_temperature
     await setup_config_entry(
-        hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
+        hass, MOCK_CONFIG[DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
     )
 
     await hass.services.async_call(
@@ -398,7 +398,7 @@ async def test_set_preset_mode_boost(
     device.lock = False
 
     await setup_config_entry(
-        hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
+        hass, MOCK_CONFIG[DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
     )
 
     await hass.services.async_call(
@@ -417,7 +417,7 @@ async def test_preset_mode_update(hass: HomeAssistant, fritz: Mock) -> None:
     device.comfort_temperature = 23
     device.eco_temperature = 20
     await setup_config_entry(
-        hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
+        hass, MOCK_CONFIG[DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
     )
 
     state = hass.states.get(ENTITY_ID)
@@ -462,7 +462,7 @@ async def test_discover_new_device(hass: HomeAssistant, fritz: Mock) -> None:
     """Test adding new discovered devices during runtime."""
     device = FritzDeviceClimateMock()
     await setup_config_entry(
-        hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
+        hass, MOCK_CONFIG[DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
     )
 
     state = hass.states.get(ENTITY_ID)
@@ -501,7 +501,7 @@ async def test_set_temperature_lock(
 
     device.lock = True
     assert await setup_config_entry(
-        hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
+        hass, MOCK_CONFIG[DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
     )
 
     with pytest.raises(
@@ -559,7 +559,7 @@ async def test_set_hvac_mode_lock(
         device.nextchange_endperiod = 0
 
     assert await setup_config_entry(
-        hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
+        hass, MOCK_CONFIG[DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
     )
 
     with pytest.raises(
@@ -582,7 +582,7 @@ async def test_holidy_summer_mode(
     device.lock = False
 
     await setup_config_entry(
-        hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
+        hass, MOCK_CONFIG[DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
     )
 
     # initial state
diff --git a/tests/components/fritzbox/test_coordinator.py b/tests/components/fritzbox/test_coordinator.py
index 4c329daa640..61de0c99940 100644
--- a/tests/components/fritzbox/test_coordinator.py
+++ b/tests/components/fritzbox/test_coordinator.py
@@ -8,7 +8,7 @@ from unittest.mock import Mock
 from pyfritzhome import LoginError
 from requests.exceptions import ConnectionError, HTTPError
 
-from homeassistant.components.fritzbox.const import DOMAIN as FB_DOMAIN
+from homeassistant.components.fritzbox.const import DOMAIN
 from homeassistant.config_entries import ConfigEntryState
 from homeassistant.const import CONF_DEVICES
 from homeassistant.core import HomeAssistant
@@ -26,8 +26,8 @@ async def test_coordinator_update_after_reboot(
 ) -> None:
     """Test coordinator after reboot."""
     entry = MockConfigEntry(
-        domain=FB_DOMAIN,
-        data=MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0],
+        domain=DOMAIN,
+        data=MOCK_CONFIG[DOMAIN][CONF_DEVICES][0],
         unique_id="any",
     )
     entry.add_to_hass(hass)
@@ -46,8 +46,8 @@ async def test_coordinator_update_after_password_change(
 ) -> None:
     """Test coordinator after password change."""
     entry = MockConfigEntry(
-        domain=FB_DOMAIN,
-        data=MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0],
+        domain=DOMAIN,
+        data=MOCK_CONFIG[DOMAIN][CONF_DEVICES][0],
         unique_id="any",
     )
     entry.add_to_hass(hass)
@@ -66,8 +66,8 @@ async def test_coordinator_update_when_unreachable(
 ) -> None:
     """Test coordinator after reboot."""
     entry = MockConfigEntry(
-        domain=FB_DOMAIN,
-        data=MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0],
+        domain=DOMAIN,
+        data=MOCK_CONFIG[DOMAIN][CONF_DEVICES][0],
         unique_id="any",
     )
     entry.add_to_hass(hass)
@@ -106,8 +106,8 @@ async def test_coordinator_automatic_registry_cleanup(
         )
     ]
     entry = MockConfigEntry(
-        domain=FB_DOMAIN,
-        data=MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0],
+        domain=DOMAIN,
+        data=MOCK_CONFIG[DOMAIN][CONF_DEVICES][0],
         unique_id="any",
     )
     entry.add_to_hass(hass)
diff --git a/tests/components/fritzbox/test_cover.py b/tests/components/fritzbox/test_cover.py
index 75e11983f39..05ef6f5efc4 100644
--- a/tests/components/fritzbox/test_cover.py
+++ b/tests/components/fritzbox/test_cover.py
@@ -6,7 +6,7 @@ from unittest.mock import Mock, call, patch
 from syrupy.assertion import SnapshotAssertion
 
 from homeassistant.components.cover import ATTR_POSITION, DOMAIN as COVER_DOMAIN
-from homeassistant.components.fritzbox.const import DOMAIN as FB_DOMAIN
+from homeassistant.components.fritzbox.const import DOMAIN
 from homeassistant.config_entries import ConfigEntryState
 from homeassistant.const import (
     ATTR_ENTITY_ID,
@@ -45,7 +45,7 @@ async def test_setup(
     device = FritzDeviceCoverMock()
     with patch("homeassistant.components.fritzbox.PLATFORMS", [Platform.COVER]):
         entry = await setup_config_entry(
-            hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
+            hass, MOCK_CONFIG[DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
         )
     assert entry.state is ConfigEntryState.LOADED
 
@@ -56,7 +56,7 @@ async def test_unknown_position(hass: HomeAssistant, fritz: Mock) -> None:
     """Test cover with unknown position."""
     device = FritzDeviceCoverUnknownPositionMock()
     await setup_config_entry(
-        hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
+        hass, MOCK_CONFIG[DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
     )
 
     state = hass.states.get(ENTITY_ID)
@@ -68,7 +68,7 @@ async def test_open_cover(hass: HomeAssistant, fritz: Mock) -> None:
     """Test opening the cover."""
     device = FritzDeviceCoverMock()
     await setup_config_entry(
-        hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
+        hass, MOCK_CONFIG[DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
     )
 
     await hass.services.async_call(
@@ -81,7 +81,7 @@ async def test_close_cover(hass: HomeAssistant, fritz: Mock) -> None:
     """Test closing the device."""
     device = FritzDeviceCoverMock()
     await setup_config_entry(
-        hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
+        hass, MOCK_CONFIG[DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
     )
 
     await hass.services.async_call(
@@ -94,7 +94,7 @@ async def test_set_position_cover(hass: HomeAssistant, fritz: Mock) -> None:
     """Test stopping the device."""
     device = FritzDeviceCoverMock()
     await setup_config_entry(
-        hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
+        hass, MOCK_CONFIG[DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
     )
 
     await hass.services.async_call(
@@ -110,7 +110,7 @@ async def test_stop_cover(hass: HomeAssistant, fritz: Mock) -> None:
     """Test stopping the device."""
     device = FritzDeviceCoverMock()
     await setup_config_entry(
-        hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
+        hass, MOCK_CONFIG[DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
     )
 
     await hass.services.async_call(
@@ -123,7 +123,7 @@ async def test_discover_new_device(hass: HomeAssistant, fritz: Mock) -> None:
     """Test adding new discovered devices during runtime."""
     device = FritzDeviceCoverMock()
     await setup_config_entry(
-        hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
+        hass, MOCK_CONFIG[DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
     )
 
     state = hass.states.get(ENTITY_ID)
diff --git a/tests/components/fritzbox/test_diagnostics.py b/tests/components/fritzbox/test_diagnostics.py
index 21d70b4b6d6..2b834c27d9d 100644
--- a/tests/components/fritzbox/test_diagnostics.py
+++ b/tests/components/fritzbox/test_diagnostics.py
@@ -5,7 +5,7 @@ from __future__ import annotations
 from unittest.mock import Mock
 
 from homeassistant.components.diagnostics import REDACTED
-from homeassistant.components.fritzbox.const import DOMAIN as FB_DOMAIN
+from homeassistant.components.fritzbox.const import DOMAIN
 from homeassistant.components.fritzbox.diagnostics import TO_REDACT
 from homeassistant.const import CONF_DEVICES
 from homeassistant.core import HomeAssistant
@@ -21,9 +21,9 @@ async def test_entry_diagnostics(
     hass: HomeAssistant, hass_client: ClientSessionGenerator, fritz: Mock
 ) -> None:
     """Test config entry diagnostics."""
-    assert await setup_config_entry(hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0])
+    assert await setup_config_entry(hass, MOCK_CONFIG[DOMAIN][CONF_DEVICES][0])
 
-    entries = hass.config_entries.async_entries(FB_DOMAIN)
+    entries = hass.config_entries.async_entries(DOMAIN)
     entry_dict = entries[0].as_dict()
     for key in TO_REDACT:
         entry_dict["data"][key] = REDACTED
diff --git a/tests/components/fritzbox/test_init.py b/tests/components/fritzbox/test_init.py
index 56e3e7a5738..489e5e19588 100644
--- a/tests/components/fritzbox/test_init.py
+++ b/tests/components/fritzbox/test_init.py
@@ -9,7 +9,7 @@ import pytest
 from requests.exceptions import ConnectionError as RequestConnectionError
 
 from homeassistant.components.binary_sensor import DOMAIN as BINARY_SENSOR_DOMAIN
-from homeassistant.components.fritzbox.const import DOMAIN as FB_DOMAIN
+from homeassistant.components.fritzbox.const import DOMAIN
 from homeassistant.components.sensor import DOMAIN as SENSOR_DOMAIN
 from homeassistant.components.switch import DOMAIN as SWITCH_DOMAIN
 from homeassistant.config_entries import ConfigEntryState
@@ -35,7 +35,7 @@ from tests.typing import WebSocketGenerator
 
 async def test_setup(hass: HomeAssistant, fritz: Mock) -> None:
     """Test setup of integration."""
-    assert await setup_config_entry(hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0])
+    assert await setup_config_entry(hass, MOCK_CONFIG[DOMAIN][CONF_DEVICES][0])
     entries = hass.config_entries.async_entries()
     assert entries
     assert len(entries) == 1
@@ -54,7 +54,7 @@ async def test_setup(hass: HomeAssistant, fritz: Mock) -> None:
         (
             {
                 "domain": SENSOR_DOMAIN,
-                "platform": FB_DOMAIN,
+                "platform": DOMAIN,
                 "unique_id": CONF_FAKE_AIN,
                 "unit_of_measurement": UnitOfTemperature.CELSIUS,
             },
@@ -64,7 +64,7 @@ async def test_setup(hass: HomeAssistant, fritz: Mock) -> None:
         (
             {
                 "domain": BINARY_SENSOR_DOMAIN,
-                "platform": FB_DOMAIN,
+                "platform": DOMAIN,
                 "unique_id": CONF_FAKE_AIN,
             },
             CONF_FAKE_AIN,
@@ -83,8 +83,8 @@ async def test_update_unique_id(
     """Test unique_id update of integration."""
     fritz().get_devices.return_value = [FritzDeviceSwitchMock()]
     entry = MockConfigEntry(
-        domain=FB_DOMAIN,
-        data=MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0],
+        domain=DOMAIN,
+        data=MOCK_CONFIG[DOMAIN][CONF_DEVICES][0],
         unique_id="any",
     )
     entry.add_to_hass(hass)
@@ -108,7 +108,7 @@ async def test_update_unique_id(
         (
             {
                 "domain": SENSOR_DOMAIN,
-                "platform": FB_DOMAIN,
+                "platform": DOMAIN,
                 "unique_id": f"{CONF_FAKE_AIN}_temperature",
                 "unit_of_measurement": UnitOfTemperature.CELSIUS,
             },
@@ -117,7 +117,7 @@ async def test_update_unique_id(
         (
             {
                 "domain": BINARY_SENSOR_DOMAIN,
-                "platform": FB_DOMAIN,
+                "platform": DOMAIN,
                 "unique_id": f"{CONF_FAKE_AIN}_alarm",
             },
             f"{CONF_FAKE_AIN}_alarm",
@@ -125,7 +125,7 @@ async def test_update_unique_id(
         (
             {
                 "domain": BINARY_SENSOR_DOMAIN,
-                "platform": FB_DOMAIN,
+                "platform": DOMAIN,
                 "unique_id": f"{CONF_FAKE_AIN}_other",
             },
             f"{CONF_FAKE_AIN}_other",
@@ -142,8 +142,8 @@ async def test_update_unique_id_no_change(
     """Test unique_id is not updated of integration."""
     fritz().get_devices.return_value = [FritzDeviceSwitchMock()]
     entry = MockConfigEntry(
-        domain=FB_DOMAIN,
-        data=MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0],
+        domain=DOMAIN,
+        data=MOCK_CONFIG[DOMAIN][CONF_DEVICES][0],
         unique_id="any",
     )
     entry.add_to_hass(hass)
@@ -167,13 +167,13 @@ async def test_unload_remove(hass: HomeAssistant, fritz: Mock) -> None:
     entity_id = f"{SWITCH_DOMAIN}.{CONF_FAKE_NAME}"
 
     entry = MockConfigEntry(
-        domain=FB_DOMAIN,
-        data=MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0],
+        domain=DOMAIN,
+        data=MOCK_CONFIG[DOMAIN][CONF_DEVICES][0],
         unique_id=entity_id,
     )
     entry.add_to_hass(hass)
 
-    config_entries = hass.config_entries.async_entries(FB_DOMAIN)
+    config_entries = hass.config_entries.async_entries(DOMAIN)
     assert len(config_entries) == 1
     assert entry is config_entries[0]
 
@@ -206,13 +206,13 @@ async def test_logout_on_stop(hass: HomeAssistant, fritz: Mock) -> None:
     entity_id = f"{SWITCH_DOMAIN}.{CONF_FAKE_NAME}"
 
     entry = MockConfigEntry(
-        domain=FB_DOMAIN,
-        data=MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0],
+        domain=DOMAIN,
+        data=MOCK_CONFIG[DOMAIN][CONF_DEVICES][0],
         unique_id=entity_id,
     )
     entry.add_to_hass(hass)
 
-    config_entries = hass.config_entries.async_entries(FB_DOMAIN)
+    config_entries = hass.config_entries.async_entries(DOMAIN)
     assert len(config_entries) == 1
     assert entry is config_entries[0]
 
@@ -240,8 +240,8 @@ async def test_remove_device(
     assert await async_setup_component(hass, "config", {})
     assert await setup_config_entry(
         hass,
-        MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0],
-        f"{FB_DOMAIN}.{CONF_FAKE_NAME}",
+        MOCK_CONFIG[DOMAIN][CONF_DEVICES][0],
+        f"{DOMAIN}.{CONF_FAKE_NAME}",
         FritzDeviceSwitchMock(),
         fritz,
     )
@@ -258,7 +258,7 @@ async def test_remove_device(
 
     orphan_device = device_registry.async_get_or_create(
         config_entry_id=entry.entry_id,
-        identifiers={(FB_DOMAIN, "0000 000000")},
+        identifiers={(DOMAIN, "0000 000000")},
     )
 
     # try to delete good_device
@@ -278,8 +278,8 @@ async def test_remove_device(
 async def test_raise_config_entry_not_ready_when_offline(hass: HomeAssistant) -> None:
     """Config entry state is SETUP_RETRY when fritzbox is offline."""
     entry = MockConfigEntry(
-        domain=FB_DOMAIN,
-        data={CONF_HOST: "any", **MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0]},
+        domain=DOMAIN,
+        data={CONF_HOST: "any", **MOCK_CONFIG[DOMAIN][CONF_DEVICES][0]},
         unique_id="any",
     )
     entry.add_to_hass(hass)
@@ -299,8 +299,8 @@ async def test_raise_config_entry_not_ready_when_offline(hass: HomeAssistant) ->
 async def test_raise_config_entry_error_when_login_fail(hass: HomeAssistant) -> None:
     """Config entry state is SETUP_ERROR when login to fritzbox fail."""
     entry = MockConfigEntry(
-        domain=FB_DOMAIN,
-        data={CONF_HOST: "any", **MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0]},
+        domain=DOMAIN,
+        data={CONF_HOST: "any", **MOCK_CONFIG[DOMAIN][CONF_DEVICES][0]},
         unique_id="any",
     )
     entry.add_to_hass(hass)
diff --git a/tests/components/fritzbox/test_light.py b/tests/components/fritzbox/test_light.py
index 7e6fa05d8cd..db4fa4f0ae1 100644
--- a/tests/components/fritzbox/test_light.py
+++ b/tests/components/fritzbox/test_light.py
@@ -6,11 +6,7 @@ from unittest.mock import Mock, call, patch
 from requests.exceptions import HTTPError
 from syrupy.assertion import SnapshotAssertion
 
-from homeassistant.components.fritzbox.const import (
-    COLOR_MODE,
-    COLOR_TEMP_MODE,
-    DOMAIN as FB_DOMAIN,
-)
+from homeassistant.components.fritzbox.const import COLOR_MODE, COLOR_TEMP_MODE, DOMAIN
 from homeassistant.components.light import (
     ATTR_BRIGHTNESS,
     ATTR_COLOR_TEMP_KELVIN,
@@ -54,7 +50,7 @@ async def test_setup(
 
     with patch("homeassistant.components.fritzbox.PLATFORMS", [Platform.LIGHT]):
         entry = await setup_config_entry(
-            hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
+            hass, MOCK_CONFIG[DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
         )
     assert entry.state is ConfigEntryState.LOADED
 
@@ -75,7 +71,7 @@ async def test_setup_non_color(
 
     with patch("homeassistant.components.fritzbox.PLATFORMS", [Platform.LIGHT]):
         entry = await setup_config_entry(
-            hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
+            hass, MOCK_CONFIG[DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
         )
     assert entry.state is ConfigEntryState.LOADED
 
@@ -97,7 +93,7 @@ async def test_setup_non_color_non_level(
 
     with patch("homeassistant.components.fritzbox.PLATFORMS", [Platform.LIGHT]):
         entry = await setup_config_entry(
-            hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
+            hass, MOCK_CONFIG[DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
         )
     assert entry.state is ConfigEntryState.LOADED
 
@@ -122,7 +118,7 @@ async def test_setup_color(
 
     with patch("homeassistant.components.fritzbox.PLATFORMS", [Platform.LIGHT]):
         entry = await setup_config_entry(
-            hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
+            hass, MOCK_CONFIG[DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
         )
     assert entry.state is ConfigEntryState.LOADED
 
@@ -137,7 +133,7 @@ async def test_turn_on(hass: HomeAssistant, fritz: Mock) -> None:
         "Red": [("100", "70", "10"), ("100", "50", "10"), ("100", "30", "10")]
     }
     assert await setup_config_entry(
-        hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
+        hass, MOCK_CONFIG[DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
     )
 
     await hass.services.async_call(
@@ -162,7 +158,7 @@ async def test_turn_on_color(hass: HomeAssistant, fritz: Mock) -> None:
     }
     device.fullcolorsupport = True
     assert await setup_config_entry(
-        hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
+        hass, MOCK_CONFIG[DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
     )
     await hass.services.async_call(
         LIGHT_DOMAIN,
@@ -191,7 +187,7 @@ async def test_turn_on_color_no_fullcolorsupport(
     }
     device.fullcolorsupport = False
     assert await setup_config_entry(
-        hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
+        hass, MOCK_CONFIG[DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
     )
 
     await hass.services.async_call(
@@ -216,7 +212,7 @@ async def test_turn_off(hass: HomeAssistant, fritz: Mock) -> None:
         "Red": [("100", "70", "10"), ("100", "50", "10"), ("100", "30", "10")]
     }
     assert await setup_config_entry(
-        hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
+        hass, MOCK_CONFIG[DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
     )
     await hass.services.async_call(
         LIGHT_DOMAIN, SERVICE_TURN_OFF, {ATTR_ENTITY_ID: ENTITY_ID}, True
@@ -232,7 +228,7 @@ async def test_update(hass: HomeAssistant, fritz: Mock) -> None:
         "Red": [("100", "70", "10"), ("100", "50", "10"), ("100", "30", "10")]
     }
     assert await setup_config_entry(
-        hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
+        hass, MOCK_CONFIG[DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
     )
     assert fritz().update_devices.call_count == 1
     assert fritz().login.call_count == 1
@@ -254,7 +250,7 @@ async def test_update_error(hass: HomeAssistant, fritz: Mock) -> None:
     }
     fritz().update_devices.side_effect = HTTPError("Boom")
     entry = await setup_config_entry(
-        hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
+        hass, MOCK_CONFIG[DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
     )
     assert entry.state is ConfigEntryState.SETUP_RETRY
     assert fritz().update_devices.call_count == 2
@@ -278,7 +274,7 @@ async def test_discover_new_device(hass: HomeAssistant, fritz: Mock) -> None:
     device.color_mode = COLOR_TEMP_MODE
     device.color_temp = 2700
     assert await setup_config_entry(
-        hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
+        hass, MOCK_CONFIG[DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
     )
 
     state = hass.states.get(ENTITY_ID)
diff --git a/tests/components/fritzbox/test_sensor.py b/tests/components/fritzbox/test_sensor.py
index 4d12e8750a3..fe966a7643c 100644
--- a/tests/components/fritzbox/test_sensor.py
+++ b/tests/components/fritzbox/test_sensor.py
@@ -8,7 +8,7 @@ from requests.exceptions import HTTPError
 from syrupy.assertion import SnapshotAssertion
 
 from homeassistant.components.climate import PRESET_COMFORT, PRESET_ECO
-from homeassistant.components.fritzbox.const import DOMAIN as FB_DOMAIN
+from homeassistant.components.fritzbox.const import DOMAIN
 from homeassistant.components.sensor import DOMAIN as SENSOR_DOMAIN
 from homeassistant.config_entries import ConfigEntryState
 from homeassistant.const import CONF_DEVICES, STATE_UNKNOWN, Platform
@@ -53,7 +53,7 @@ async def test_setup(
 
     with patch("homeassistant.components.fritzbox.PLATFORMS", [Platform.SENSOR]):
         entry = await setup_config_entry(
-            hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
+            hass, MOCK_CONFIG[DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
         )
     assert entry.state is ConfigEntryState.LOADED
 
@@ -64,7 +64,7 @@ async def test_update(hass: HomeAssistant, fritz: Mock) -> None:
     """Test update without error."""
     device = FritzDeviceSensorMock()
     await setup_config_entry(
-        hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
+        hass, MOCK_CONFIG[DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
     )
     assert fritz().update_devices.call_count == 1
     assert fritz().login.call_count == 1
@@ -82,7 +82,7 @@ async def test_update_error(hass: HomeAssistant, fritz: Mock) -> None:
     device = FritzDeviceSensorMock()
     fritz().update_devices.side_effect = HTTPError("Boom")
     entry = await setup_config_entry(
-        hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
+        hass, MOCK_CONFIG[DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
     )
     assert entry.state is ConfigEntryState.SETUP_RETRY
     assert fritz().update_devices.call_count == 2
@@ -100,7 +100,7 @@ async def test_discover_new_device(hass: HomeAssistant, fritz: Mock) -> None:
     """Test adding new discovered devices during runtime."""
     device = FritzDeviceSensorMock()
     await setup_config_entry(
-        hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
+        hass, MOCK_CONFIG[DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
     )
 
     state = hass.states.get(f"{ENTITY_ID}_temperature")
@@ -150,7 +150,7 @@ async def test_next_change_sensors(
     device.nextchange_temperature = next_changes[1]
 
     await setup_config_entry(
-        hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
+        hass, MOCK_CONFIG[DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
     )
 
     base_name = f"{SENSOR_DOMAIN}.{CONF_FAKE_NAME}"
diff --git a/tests/components/fritzbox/test_switch.py b/tests/components/fritzbox/test_switch.py
index d8894c0ae93..86d1f58239d 100644
--- a/tests/components/fritzbox/test_switch.py
+++ b/tests/components/fritzbox/test_switch.py
@@ -7,7 +7,7 @@ import pytest
 from requests.exceptions import HTTPError
 from syrupy.assertion import SnapshotAssertion
 
-from homeassistant.components.fritzbox.const import DOMAIN as FB_DOMAIN
+from homeassistant.components.fritzbox.const import DOMAIN
 from homeassistant.components.switch import DOMAIN as SWITCH_DOMAIN
 from homeassistant.config_entries import ConfigEntryState
 from homeassistant.const import (
@@ -41,7 +41,7 @@ async def test_setup(
     device = FritzDeviceSwitchMock()
     with patch("homeassistant.components.fritzbox.PLATFORMS", [Platform.SWITCH]):
         entry = await setup_config_entry(
-            hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
+            hass, MOCK_CONFIG[DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
         )
     assert entry.state is ConfigEntryState.LOADED
 
@@ -52,7 +52,7 @@ async def test_turn_on(hass: HomeAssistant, fritz: Mock) -> None:
     """Test turn device on."""
     device = FritzDeviceSwitchMock()
     await setup_config_entry(
-        hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
+        hass, MOCK_CONFIG[DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
     )
 
     await hass.services.async_call(
@@ -66,7 +66,7 @@ async def test_turn_off(hass: HomeAssistant, fritz: Mock) -> None:
     device = FritzDeviceSwitchMock()
 
     await setup_config_entry(
-        hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
+        hass, MOCK_CONFIG[DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
     )
 
     await hass.services.async_call(
@@ -82,7 +82,7 @@ async def test_toggle_while_locked(hass: HomeAssistant, fritz: Mock) -> None:
     device.lock = True
 
     await setup_config_entry(
-        hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
+        hass, MOCK_CONFIG[DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
     )
 
     with pytest.raises(
@@ -106,7 +106,7 @@ async def test_update(hass: HomeAssistant, fritz: Mock) -> None:
     """Test update without error."""
     device = FritzDeviceSwitchMock()
     await setup_config_entry(
-        hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
+        hass, MOCK_CONFIG[DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
     )
     assert fritz().update_devices.call_count == 1
     assert fritz().login.call_count == 1
@@ -124,7 +124,7 @@ async def test_update_error(hass: HomeAssistant, fritz: Mock) -> None:
     device = FritzDeviceSwitchMock()
     fritz().update_devices.side_effect = HTTPError("Boom")
     entry = await setup_config_entry(
-        hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
+        hass, MOCK_CONFIG[DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
     )
     assert entry.state is ConfigEntryState.SETUP_RETRY
     assert fritz().update_devices.call_count == 2
@@ -145,7 +145,7 @@ async def test_assume_device_unavailable(hass: HomeAssistant, fritz: Mock) -> No
     device.energy = 0
     device.power = 0
     await setup_config_entry(
-        hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
+        hass, MOCK_CONFIG[DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
     )
 
     state = hass.states.get(ENTITY_ID)
@@ -157,7 +157,7 @@ async def test_discover_new_device(hass: HomeAssistant, fritz: Mock) -> None:
     """Test adding new discovered devices during runtime."""
     device = FritzDeviceSwitchMock()
     await setup_config_entry(
-        hass, MOCK_CONFIG[FB_DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
+        hass, MOCK_CONFIG[DOMAIN][CONF_DEVICES][0], ENTITY_ID, device, fritz
     )
 
     state = hass.states.get(ENTITY_ID)
diff --git a/tests/components/fully_kiosk/test_config_flow.py b/tests/components/fully_kiosk/test_config_flow.py
index 4ce393a417d..2948796f38d 100644
--- a/tests/components/fully_kiosk/test_config_flow.py
+++ b/tests/components/fully_kiosk/test_config_flow.py
@@ -20,7 +20,7 @@ from homeassistant.data_entry_flow import FlowResultType
 from homeassistant.helpers.service_info.dhcp import DhcpServiceInfo
 from homeassistant.helpers.service_info.mqtt import MqttServiceInfo
 
-from tests.common import MockConfigEntry, load_fixture
+from tests.common import MockConfigEntry, async_load_fixture
 
 
 async def test_user_flow(
@@ -220,7 +220,7 @@ async def test_mqtt_discovery_flow(
     mock_setup_entry: AsyncMock,
 ) -> None:
     """Test MQTT discovery configuration flow."""
-    payload = load_fixture("mqtt-discovery-deviceinfo.json", DOMAIN)
+    payload = await async_load_fixture(hass, "mqtt-discovery-deviceinfo.json", DOMAIN)
 
     result = await hass.config_entries.flow.async_init(
         DOMAIN,
diff --git a/tests/components/fully_kiosk/test_init.py b/tests/components/fully_kiosk/test_init.py
index f3fb945c8f0..9a095329829 100644
--- a/tests/components/fully_kiosk/test_init.py
+++ b/tests/components/fully_kiosk/test_init.py
@@ -19,7 +19,7 @@ from homeassistant.const import (
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers import device_registry as dr, entity_registry as er
 
-from tests.common import MockConfigEntry, load_fixture
+from tests.common import MockConfigEntry, async_load_fixture
 
 
 async def test_load_unload_config_entry(
@@ -74,10 +74,10 @@ async def _load_config(
     ) as client_mock:
         client = client_mock.return_value
         client.getDeviceInfo.return_value = json.loads(
-            load_fixture(device_info_fixture, DOMAIN)
+            await async_load_fixture(hass, device_info_fixture, DOMAIN)
         )
         client.getSettings.return_value = json.loads(
-            load_fixture("listsettings.json", DOMAIN)
+            await async_load_fixture(hass, "listsettings.json", DOMAIN)
         )
 
         config_entry.add_to_hass(hass)
diff --git a/tests/components/fyta/conftest.py b/tests/components/fyta/conftest.py
index 92abab7091a..c513b0a12bc 100644
--- a/tests/components/fyta/conftest.py
+++ b/tests/components/fyta/conftest.py
@@ -7,7 +7,7 @@ from unittest.mock import AsyncMock, MagicMock, patch
 from fyta_cli.fyta_models import Credentials, Plant
 import pytest
 
-from homeassistant.components.fyta.const import CONF_EXPIRATION, DOMAIN as FYTA_DOMAIN
+from homeassistant.components.fyta.const import CONF_EXPIRATION, DOMAIN
 from homeassistant.const import CONF_ACCESS_TOKEN, CONF_PASSWORD, CONF_USERNAME
 
 from .const import ACCESS_TOKEN, EXPIRATION, PASSWORD, USERNAME
@@ -19,7 +19,7 @@ from tests.common import MockConfigEntry, load_json_object_fixture
 def mock_config_entry() -> MockConfigEntry:
     """Mock a config entry."""
     return MockConfigEntry(
-        domain=FYTA_DOMAIN,
+        domain=DOMAIN,
         title="fyta_user",
         data={
             CONF_USERNAME: USERNAME,
@@ -37,8 +37,8 @@ def mock_fyta_connector():
     """Build a fixture for the Fyta API that connects successfully and returns one device."""
 
     plants: dict[int, Plant] = {
-        0: Plant.from_dict(load_json_object_fixture("plant_status1.json", FYTA_DOMAIN)),
-        1: Plant.from_dict(load_json_object_fixture("plant_status2.json", FYTA_DOMAIN)),
+        0: Plant.from_dict(load_json_object_fixture("plant_status1.json", DOMAIN)),
+        1: Plant.from_dict(load_json_object_fixture("plant_status2.json", DOMAIN)),
     }
 
     mock_fyta_connector = AsyncMock()
diff --git a/tests/components/fyta/test_binary_sensor.py b/tests/components/fyta/test_binary_sensor.py
index 74081387eb6..de7e78b3ecc 100644
--- a/tests/components/fyta/test_binary_sensor.py
+++ b/tests/components/fyta/test_binary_sensor.py
@@ -9,7 +9,7 @@ from fyta_cli.fyta_models import Plant
 import pytest
 from syrupy.assertion import SnapshotAssertion
 
-from homeassistant.components.fyta.const import DOMAIN as FYTA_DOMAIN
+from homeassistant.components.fyta.const import DOMAIN
 from homeassistant.const import STATE_OFF, STATE_ON, STATE_UNAVAILABLE, Platform
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers import entity_registry as er
@@ -79,14 +79,10 @@ async def test_add_remove_entities(
 
     plants: dict[int, Plant] = {
         0: Plant.from_dict(
-            await async_load_json_object_fixture(
-                hass, "plant_status1.json", FYTA_DOMAIN
-            )
+            await async_load_json_object_fixture(hass, "plant_status1.json", DOMAIN)
         ),
         2: Plant.from_dict(
-            await async_load_json_object_fixture(
-                hass, "plant_status3.json", FYTA_DOMAIN
-            )
+            await async_load_json_object_fixture(hass, "plant_status3.json", DOMAIN)
         ),
     }
     mock_fyta_connector.update_all_plants.return_value = plants
diff --git a/tests/components/fyta/test_image.py b/tests/components/fyta/test_image.py
index 65d445f1ce0..82d2e223744 100644
--- a/tests/components/fyta/test_image.py
+++ b/tests/components/fyta/test_image.py
@@ -10,7 +10,7 @@ from fyta_cli.fyta_models import Plant
 import pytest
 from syrupy.assertion import SnapshotAssertion
 
-from homeassistant.components.fyta.const import DOMAIN as FYTA_DOMAIN
+from homeassistant.components.fyta.const import DOMAIN
 from homeassistant.components.image import ImageEntity
 from homeassistant.const import STATE_UNAVAILABLE, Platform
 from homeassistant.core import HomeAssistant
@@ -84,14 +84,10 @@ async def test_add_remove_entities(
 
     plants: dict[int, Plant] = {
         0: Plant.from_dict(
-            await async_load_json_object_fixture(
-                hass, "plant_status1.json", FYTA_DOMAIN
-            )
+            await async_load_json_object_fixture(hass, "plant_status1.json", DOMAIN)
         ),
         2: Plant.from_dict(
-            await async_load_json_object_fixture(
-                hass, "plant_status3.json", FYTA_DOMAIN
-            )
+            await async_load_json_object_fixture(hass, "plant_status3.json", DOMAIN)
         ),
     }
     mock_fyta_connector.update_all_plants.return_value = plants
@@ -130,13 +126,11 @@ async def test_update_image(
     plants: dict[int, Plant] = {
         0: Plant.from_dict(
             await async_load_json_object_fixture(
-                hass, "plant_status1_update.json", FYTA_DOMAIN
+                hass, "plant_status1_update.json", DOMAIN
             )
         ),
         2: Plant.from_dict(
-            await async_load_json_object_fixture(
-                hass, "plant_status3.json", FYTA_DOMAIN
-            )
+            await async_load_json_object_fixture(hass, "plant_status3.json", DOMAIN)
         ),
     }
     mock_fyta_connector.update_all_plants.return_value = plants
diff --git a/tests/components/fyta/test_init.py b/tests/components/fyta/test_init.py
index 88cb125ecee..461b9ff28ed 100644
--- a/tests/components/fyta/test_init.py
+++ b/tests/components/fyta/test_init.py
@@ -10,7 +10,7 @@ from fyta_cli.fyta_exceptions import (
 )
 import pytest
 
-from homeassistant.components.fyta.const import CONF_EXPIRATION, DOMAIN as FYTA_DOMAIN
+from homeassistant.components.fyta.const import CONF_EXPIRATION, DOMAIN
 from homeassistant.config_entries import ConfigEntryState
 from homeassistant.const import (
     CONF_ACCESS_TOKEN,
@@ -127,7 +127,7 @@ async def test_migrate_config_entry(
 ) -> None:
     """Test successful migration of entry data."""
     entry = MockConfigEntry(
-        domain=FYTA_DOMAIN,
+        domain=DOMAIN,
         title=USERNAME,
         data={
             CONF_USERNAME: USERNAME,
diff --git a/tests/components/fyta/test_sensor.py b/tests/components/fyta/test_sensor.py
index 576eecdab5a..966baefb765 100644
--- a/tests/components/fyta/test_sensor.py
+++ b/tests/components/fyta/test_sensor.py
@@ -9,7 +9,7 @@ from fyta_cli.fyta_models import Plant
 import pytest
 from syrupy.assertion import SnapshotAssertion
 
-from homeassistant.components.fyta.const import DOMAIN as FYTA_DOMAIN
+from homeassistant.components.fyta.const import DOMAIN
 from homeassistant.const import STATE_UNAVAILABLE, Platform
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers import entity_registry as er
@@ -76,14 +76,10 @@ async def test_add_remove_entities(
 
     plants: dict[int, Plant] = {
         0: Plant.from_dict(
-            await async_load_json_object_fixture(
-                hass, "plant_status1.json", FYTA_DOMAIN
-            )
+            await async_load_json_object_fixture(hass, "plant_status1.json", DOMAIN)
         ),
         2: Plant.from_dict(
-            await async_load_json_object_fixture(
-                hass, "plant_status3.json", FYTA_DOMAIN
-            )
+            await async_load_json_object_fixture(hass, "plant_status3.json", DOMAIN)
         ),
     }
     mock_fyta_connector.update_all_plants.return_value = plants
diff --git a/tests/components/generic_hygrostat/test_humidifier.py b/tests/components/generic_hygrostat/test_humidifier.py
index 3acb50fa38d..ee546ef0500 100644
--- a/tests/components/generic_hygrostat/test_humidifier.py
+++ b/tests/components/generic_hygrostat/test_humidifier.py
@@ -9,9 +9,7 @@ import voluptuous as vol
 
 from homeassistant import core as ha
 from homeassistant.components import input_boolean, switch
-from homeassistant.components.generic_hygrostat import (
-    DOMAIN as GENERIC_HYDROSTAT_DOMAIN,
-)
+from homeassistant.components.generic_hygrostat import DOMAIN
 from homeassistant.components.humidifier import (
     ATTR_HUMIDITY,
     DOMAIN as HUMIDIFIER_DOMAIN,
@@ -1862,7 +1860,7 @@ async def test_device_id(
 
     helper_config_entry = MockConfigEntry(
         data={},
-        domain=GENERIC_HYDROSTAT_DOMAIN,
+        domain=DOMAIN,
         options={
             "device_class": "humidifier",
             "dry_tolerance": 2.0,
diff --git a/tests/components/generic_hygrostat/test_init.py b/tests/components/generic_hygrostat/test_init.py
index bd4792f939d..16bb4dc6db5 100644
--- a/tests/components/generic_hygrostat/test_init.py
+++ b/tests/components/generic_hygrostat/test_init.py
@@ -2,9 +2,7 @@
 
 from __future__ import annotations
 
-from homeassistant.components.generic_hygrostat import (
-    DOMAIN as GENERIC_HYDROSTAT_DOMAIN,
-)
+from homeassistant.components.generic_hygrostat import DOMAIN
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers import device_registry as dr, entity_registry as er
 
@@ -45,7 +43,7 @@ async def test_device_cleaning(
     # Configure the configuration entry for helper
     helper_config_entry = MockConfigEntry(
         data={},
-        domain=GENERIC_HYDROSTAT_DOMAIN,
+        domain=DOMAIN,
         options={
             "device_class": "humidifier",
             "dry_tolerance": 2.0,
diff --git a/tests/components/generic_thermostat/test_climate.py b/tests/components/generic_thermostat/test_climate.py
index 65be83bad20..7d606bee93a 100644
--- a/tests/components/generic_thermostat/test_climate.py
+++ b/tests/components/generic_thermostat/test_climate.py
@@ -21,9 +21,7 @@ from homeassistant.components.climate import (
     PRESET_SLEEP,
     HVACMode,
 )
-from homeassistant.components.generic_thermostat.const import (
-    DOMAIN as GENERIC_THERMOSTAT_DOMAIN,
-)
+from homeassistant.components.generic_thermostat.const import DOMAIN
 from homeassistant.const import (
     ATTR_TEMPERATURE,
     SERVICE_RELOAD,
@@ -1492,7 +1490,7 @@ async def test_reload(hass: HomeAssistant) -> None:
     yaml_path = get_fixture_path("configuration.yaml", "generic_thermostat")
     with patch.object(hass_config, "YAML_CONFIG_FILE", yaml_path):
         await hass.services.async_call(
-            GENERIC_THERMOSTAT_DOMAIN,
+            DOMAIN,
             SERVICE_RELOAD,
             {},
             blocking=True,
@@ -1530,7 +1528,7 @@ async def test_device_id(
 
     helper_config_entry = MockConfigEntry(
         data={},
-        domain=GENERIC_THERMOSTAT_DOMAIN,
+        domain=DOMAIN,
         options={
             "name": "Test",
             "heater": "switch.test_source",
diff --git a/tests/components/gios/__init__.py b/tests/components/gios/__init__.py
index 07dbd6502b4..49388428805 100644
--- a/tests/components/gios/__init__.py
+++ b/tests/components/gios/__init__.py
@@ -6,7 +6,7 @@ from unittest.mock import patch
 from homeassistant.components.gios.const import DOMAIN
 from homeassistant.core import HomeAssistant
 
-from tests.common import MockConfigEntry, load_fixture
+from tests.common import MockConfigEntry, async_load_fixture
 
 STATIONS = [
     {"id": 123, "stationName": "Test Name 1", "gegrLat": "99.99", "gegrLon": "88.88"},
@@ -26,9 +26,9 @@ async def init_integration(
         entry_id="86129426118ae32020417a53712d6eef",
     )
 
-    indexes = json.loads(load_fixture("gios/indexes.json"))
-    station = json.loads(load_fixture("gios/station.json"))
-    sensors = json.loads(load_fixture("gios/sensors.json"))
+    indexes = json.loads(await async_load_fixture(hass, "indexes.json", DOMAIN))
+    station = json.loads(await async_load_fixture(hass, "station.json", DOMAIN))
+    sensors = json.loads(await async_load_fixture(hass, "sensors.json", DOMAIN))
     if incomplete_data:
         indexes["stIndexLevel"]["indexLevelName"] = "foo"
         sensors["pm10"]["values"][0]["value"] = None
diff --git a/tests/components/gios/test_config_flow.py b/tests/components/gios/test_config_flow.py
index 3764c52a810..ee783ba57e3 100644
--- a/tests/components/gios/test_config_flow.py
+++ b/tests/components/gios/test_config_flow.py
@@ -14,7 +14,7 @@ from homeassistant.data_entry_flow import FlowResultType
 
 from . import STATIONS
 
-from tests.common import load_fixture
+from tests.common import async_load_fixture
 
 CONFIG = {
     CONF_NAME: "Foo",
@@ -58,7 +58,9 @@ async def test_invalid_sensor_data(hass: HomeAssistant) -> None:
         ),
         patch(
             "homeassistant.components.gios.coordinator.Gios._get_station",
-            return_value=json.loads(load_fixture("gios/station.json")),
+            return_value=json.loads(
+                await async_load_fixture(hass, "station.json", DOMAIN)
+            ),
         ),
         patch(
             "homeassistant.components.gios.coordinator.Gios._get_sensor",
@@ -106,15 +108,21 @@ async def test_create_entry(hass: HomeAssistant) -> None:
         ),
         patch(
             "homeassistant.components.gios.coordinator.Gios._get_station",
-            return_value=json.loads(load_fixture("gios/station.json")),
+            return_value=json.loads(
+                await async_load_fixture(hass, "station.json", DOMAIN)
+            ),
         ),
         patch(
             "homeassistant.components.gios.coordinator.Gios._get_all_sensors",
-            return_value=json.loads(load_fixture("gios/sensors.json")),
+            return_value=json.loads(
+                await async_load_fixture(hass, "sensors.json", DOMAIN)
+            ),
         ),
         patch(
             "homeassistant.components.gios.coordinator.Gios._get_indexes",
-            return_value=json.loads(load_fixture("gios/indexes.json")),
+            return_value=json.loads(
+                await async_load_fixture(hass, "indexes.json", DOMAIN)
+            ),
         ),
     ):
         flow = config_flow.GiosFlowHandler()
diff --git a/tests/components/gios/test_init.py b/tests/components/gios/test_init.py
index bf954d48548..9c7f7270ca4 100644
--- a/tests/components/gios/test_init.py
+++ b/tests/components/gios/test_init.py
@@ -12,7 +12,7 @@ from homeassistant.helpers import device_registry as dr, entity_registry as er
 
 from . import STATIONS, init_integration
 
-from tests.common import MockConfigEntry, load_fixture
+from tests.common import MockConfigEntry, async_load_fixture
 
 
 async def test_async_setup_entry(hass: HomeAssistant) -> None:
@@ -71,9 +71,9 @@ async def test_migrate_device_and_config_entry(
         },
     )
 
-    indexes = json.loads(load_fixture("gios/indexes.json"))
-    station = json.loads(load_fixture("gios/station.json"))
-    sensors = json.loads(load_fixture("gios/sensors.json"))
+    indexes = json.loads(await async_load_fixture(hass, "indexes.json", DOMAIN))
+    station = json.loads(await async_load_fixture(hass, "station.json", DOMAIN))
+    sensors = json.loads(await async_load_fixture(hass, "sensors.json", DOMAIN))
 
     with (
         patch(
diff --git a/tests/components/gios/test_sensor.py b/tests/components/gios/test_sensor.py
index fd343d16525..b4e03dd7488 100644
--- a/tests/components/gios/test_sensor.py
+++ b/tests/components/gios/test_sensor.py
@@ -17,7 +17,7 @@ from homeassistant.util.dt import utcnow
 
 from . import init_integration
 
-from tests.common import async_fire_time_changed, load_fixture, snapshot_platform
+from tests.common import async_fire_time_changed, async_load_fixture, snapshot_platform
 
 
 async def test_sensor(
@@ -32,8 +32,8 @@ async def test_sensor(
 
 async def test_availability(hass: HomeAssistant) -> None:
     """Ensure that we mark the entities unavailable correctly when service causes an error."""
-    indexes = json.loads(load_fixture("gios/indexes.json"))
-    sensors = json.loads(load_fixture("gios/sensors.json"))
+    indexes = json.loads(await async_load_fixture(hass, "indexes.json", DOMAIN))
+    sensors = json.loads(await async_load_fixture(hass, "sensors.json", DOMAIN))
 
     await init_integration(hass)
 
diff --git a/tests/components/github/common.py b/tests/components/github/common.py
index 5007496c9fe..bf48c313adc 100644
--- a/tests/components/github/common.py
+++ b/tests/components/github/common.py
@@ -8,7 +8,7 @@ from homeassistant.components.github.const import CONF_REPOSITORIES, DOMAIN
 from homeassistant.config_entries import ConfigEntryState
 from homeassistant.core import HomeAssistant
 
-from tests.common import MockConfigEntry, load_fixture
+from tests.common import MockConfigEntry, async_load_fixture
 from tests.test_util.aiohttp import AiohttpClientMocker
 
 MOCK_ACCESS_TOKEN = "gho_16C7e42F292c6912E7710c838347Ae178B4a"
@@ -22,12 +22,12 @@ async def setup_github_integration(
     add_entry_to_hass: bool = True,
 ) -> None:
     """Mock setting up the integration."""
-    headers = json.loads(load_fixture("base_headers.json", DOMAIN))
+    headers = json.loads(await async_load_fixture(hass, "base_headers.json", DOMAIN))
     for idx, repository in enumerate(mock_config_entry.options[CONF_REPOSITORIES]):
         aioclient_mock.get(
             f"https://api.github.com/repos/{repository}",
             json={
-                **json.loads(load_fixture("repository.json", DOMAIN)),
+                **json.loads(await async_load_fixture(hass, "repository.json", DOMAIN)),
                 "full_name": repository,
                 "id": idx,
             },
@@ -40,7 +40,7 @@ async def setup_github_integration(
         )
     aioclient_mock.post(
         "https://api.github.com/graphql",
-        json=json.loads(load_fixture("graphql.json", DOMAIN)),
+        json=json.loads(await async_load_fixture(hass, "graphql.json", DOMAIN)),
         headers=headers,
     )
     if add_entry_to_hass:
diff --git a/tests/components/github/test_diagnostics.py b/tests/components/github/test_diagnostics.py
index 806a0ae33cc..2bf8e4ae1b5 100644
--- a/tests/components/github/test_diagnostics.py
+++ b/tests/components/github/test_diagnostics.py
@@ -10,7 +10,7 @@ from homeassistant.core import HomeAssistant
 
 from .common import setup_github_integration
 
-from tests.common import MockConfigEntry, load_fixture
+from tests.common import MockConfigEntry, async_load_fixture
 from tests.components.diagnostics import get_diagnostics_for_config_entry
 from tests.test_util.aiohttp import AiohttpClientMocker
 from tests.typing import ClientSessionGenerator
@@ -30,13 +30,13 @@ async def test_entry_diagnostics(
         mock_config_entry,
         options={CONF_REPOSITORIES: ["home-assistant/core"]},
     )
-    response_json = json.loads(load_fixture("graphql.json", DOMAIN))
+    response_json = json.loads(await async_load_fixture(hass, "graphql.json", DOMAIN))
     response_json["data"]["repository"]["full_name"] = "home-assistant/core"
 
     aioclient_mock.post(
         "https://api.github.com/graphql",
         json=response_json,
-        headers=json.loads(load_fixture("base_headers.json", DOMAIN)),
+        headers=json.loads(await async_load_fixture(hass, "base_headers.json", DOMAIN)),
     )
     aioclient_mock.get(
         "https://api.github.com/rate_limit",
diff --git a/tests/components/github/test_sensor.py b/tests/components/github/test_sensor.py
index b0eaed3ae0e..ada663d941f 100644
--- a/tests/components/github/test_sensor.py
+++ b/tests/components/github/test_sensor.py
@@ -10,7 +10,7 @@ from homeassistant.util import dt as dt_util
 
 from .common import TEST_REPOSITORY
 
-from tests.common import MockConfigEntry, async_fire_time_changed, load_fixture
+from tests.common import MockConfigEntry, async_fire_time_changed, async_load_fixture
 from tests.test_util.aiohttp import AiohttpClientMocker
 
 TEST_SENSOR_ENTITY = "sensor.octocat_hello_world_latest_release"
@@ -27,9 +27,9 @@ async def test_sensor_updates_with_empty_release_array(
     state = hass.states.get(TEST_SENSOR_ENTITY)
     assert state.state == "v1.0.0"
 
-    response_json = json.loads(load_fixture("graphql.json", DOMAIN))
+    response_json = json.loads(await async_load_fixture(hass, "graphql.json", DOMAIN))
     response_json["data"]["repository"]["release"] = None
-    headers = json.loads(load_fixture("base_headers.json", DOMAIN))
+    headers = json.loads(await async_load_fixture(hass, "base_headers.json", DOMAIN))
 
     aioclient_mock.clear_requests()
     aioclient_mock.get(
diff --git a/tests/components/go2rtc/test_init.py b/tests/components/go2rtc/test_init.py
index 38ff82fc9c8..3fca0d27b6b 100644
--- a/tests/components/go2rtc/test_init.py
+++ b/tests/components/go2rtc/test_init.py
@@ -40,7 +40,7 @@ from homeassistant.components.go2rtc.const import (
     RECOMMENDED_VERSION,
 )
 from homeassistant.config_entries import ConfigEntry, ConfigEntryState, ConfigFlow
-from homeassistant.const import CONF_URL
+from homeassistant.const import CONF_URL, Platform
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers import issue_registry as ir
 from homeassistant.helpers.typing import ConfigType
@@ -166,7 +166,7 @@ async def init_test_integration(
     ) -> bool:
         """Set up test config entry."""
         await hass.config_entries.async_forward_entry_setups(
-            config_entry, [CAMERA_DOMAIN]
+            config_entry, [Platform.CAMERA]
         )
         return True
 
@@ -175,7 +175,7 @@ async def init_test_integration(
     ) -> bool:
         """Unload test config entry."""
         await hass.config_entries.async_forward_entry_unload(
-            config_entry, CAMERA_DOMAIN
+            config_entry, Platform.CAMERA
         )
         return True
 
diff --git a/tests/components/goalzero/__init__.py b/tests/components/goalzero/__init__.py
index 7d86f638fc2..1e7f40cc20a 100644
--- a/tests/components/goalzero/__init__.py
+++ b/tests/components/goalzero/__init__.py
@@ -8,7 +8,7 @@ from homeassistant.core import HomeAssistant
 from homeassistant.helpers.device_registry import format_mac
 from homeassistant.helpers.service_info.dhcp import DhcpServiceInfo
 
-from tests.common import MockConfigEntry, load_fixture
+from tests.common import MockConfigEntry, async_load_fixture
 from tests.test_util.aiohttp import AiohttpClientMocker
 
 HOST = "1.2.3.4"
@@ -66,11 +66,11 @@ async def async_init_integration(
     base_url = f"http://{HOST}/"
     aioclient_mock.get(
         f"{base_url}state",
-        text=load_fixture("goalzero/state_data.json"),
+        text=await async_load_fixture(hass, "state_data.json", DOMAIN),
     )
     aioclient_mock.get(
         f"{base_url}sysinfo",
-        text=load_fixture("goalzero/info_data.json"),
+        text=await async_load_fixture(hass, "info_data.json", DOMAIN),
     )
 
     if not skip_setup:
diff --git a/tests/components/goalzero/test_switch.py b/tests/components/goalzero/test_switch.py
index b784cff05aa..d6faa7518a9 100644
--- a/tests/components/goalzero/test_switch.py
+++ b/tests/components/goalzero/test_switch.py
@@ -1,6 +1,6 @@
 """Switch tests for the Goalzero integration."""
 
-from homeassistant.components.goalzero.const import DEFAULT_NAME
+from homeassistant.components.goalzero.const import DEFAULT_NAME, DOMAIN
 from homeassistant.components.switch import DOMAIN as SWITCH_DOMAIN
 from homeassistant.const import (
     ATTR_ENTITY_ID,
@@ -13,7 +13,7 @@ from homeassistant.core import HomeAssistant
 
 from . import async_init_integration
 
-from tests.common import load_fixture
+from tests.common import async_load_fixture
 from tests.test_util.aiohttp import AiohttpClientMocker
 
 
@@ -29,7 +29,7 @@ async def test_switches_states(
     assert hass.states.get(entity_id).state == STATE_OFF
     aioclient_mock.post(
         "http://1.2.3.4/state",
-        text=load_fixture("goalzero/state_change.json"),
+        text=await async_load_fixture(hass, "state_change.json", DOMAIN),
     )
     await hass.services.async_call(
         SWITCH_DOMAIN,
@@ -41,7 +41,7 @@ async def test_switches_states(
     aioclient_mock.clear_requests()
     aioclient_mock.post(
         "http://1.2.3.4/state",
-        text=load_fixture("goalzero/state_data.json"),
+        text=await async_load_fixture(hass, "state_data.json", DOMAIN),
     )
     await hass.services.async_call(
         SWITCH_DOMAIN,
diff --git a/tests/components/google_mail/conftest.py b/tests/components/google_mail/conftest.py
index 7e63282d181..3336d905bc1 100644
--- a/tests/components/google_mail/conftest.py
+++ b/tests/components/google_mail/conftest.py
@@ -16,7 +16,7 @@ from homeassistant.components.google_mail.const import DOMAIN
 from homeassistant.core import HomeAssistant
 from homeassistant.setup import async_setup_component
 
-from tests.common import MockConfigEntry, load_fixture
+from tests.common import MockConfigEntry, async_load_fixture
 from tests.test_util.aiohttp import AiohttpClientMocker
 
 type ComponentSetup = Callable[[], Awaitable[None]]
@@ -112,7 +112,10 @@ async def mock_setup_integration(
             "httplib2.Http.request",
             return_value=(
                 Response({}),
-                bytes(load_fixture("google_mail/get_vacation.json"), encoding="UTF-8"),
+                bytes(
+                    await async_load_fixture(hass, "get_vacation.json", DOMAIN),
+                    encoding="UTF-8",
+                ),
             ),
         ):
             assert await async_setup_component(hass, DOMAIN, {})
diff --git a/tests/components/google_mail/test_config_flow.py b/tests/components/google_mail/test_config_flow.py
index 1e933c8932a..8b8aaa57871 100644
--- a/tests/components/google_mail/test_config_flow.py
+++ b/tests/components/google_mail/test_config_flow.py
@@ -13,7 +13,7 @@ from homeassistant.helpers import config_entry_oauth2_flow
 
 from .conftest import CLIENT_ID, GOOGLE_AUTH_URI, GOOGLE_TOKEN_URI, SCOPES, TITLE
 
-from tests.common import MockConfigEntry, load_fixture
+from tests.common import MockConfigEntry, async_load_fixture
 from tests.test_util.aiohttp import AiohttpClientMocker
 from tests.typing import ClientSessionGenerator
 
@@ -54,7 +54,10 @@ async def test_full_flow(
             "httplib2.Http.request",
             return_value=(
                 Response({}),
-                bytes(load_fixture("google_mail/get_profile.json"), encoding="UTF-8"),
+                bytes(
+                    await async_load_fixture(hass, "get_profile.json", DOMAIN),
+                    encoding="UTF-8",
+                ),
             ),
         ),
     ):
@@ -152,7 +155,10 @@ async def test_reauth(
             "httplib2.Http.request",
             return_value=(
                 Response({}),
-                bytes(load_fixture(f"google_mail/{fixture}.json"), encoding="UTF-8"),
+                bytes(
+                    await async_load_fixture(hass, f"{fixture}.json", DOMAIN),
+                    encoding="UTF-8",
+                ),
             ),
         ),
     ):
@@ -208,7 +214,10 @@ async def test_already_configured(
         "httplib2.Http.request",
         return_value=(
             Response({}),
-            bytes(load_fixture("google_mail/get_profile.json"), encoding="UTF-8"),
+            bytes(
+                await async_load_fixture(hass, "get_profile.json", DOMAIN),
+                encoding="UTF-8",
+            ),
         ),
     ):
         result = await hass.config_entries.flow.async_configure(result["flow_id"])
diff --git a/tests/components/google_mail/test_sensor.py b/tests/components/google_mail/test_sensor.py
index e9dd2da85de..3b88cb327ed 100644
--- a/tests/components/google_mail/test_sensor.py
+++ b/tests/components/google_mail/test_sensor.py
@@ -16,7 +16,7 @@ from homeassistant.util import dt as dt_util
 
 from .conftest import SENSOR, TOKEN, ComponentSetup
 
-from tests.common import async_fire_time_changed, load_fixture
+from tests.common import async_fire_time_changed, async_load_fixture
 
 
 @pytest.mark.parametrize(
@@ -41,7 +41,10 @@ async def test_sensors(
         "httplib2.Http.request",
         return_value=(
             Response({}),
-            bytes(load_fixture(f"google_mail/{fixture}.json"), encoding="UTF-8"),
+            bytes(
+                await async_load_fixture(hass, f"{fixture}.json", DOMAIN),
+                encoding="UTF-8",
+            ),
         ),
     ):
         next_update = dt_util.utcnow() + timedelta(minutes=15)
diff --git a/tests/components/google_tasks/test_config_flow.py b/tests/components/google_tasks/test_config_flow.py
index f8ccc5e048f..ae765d0ab79 100644
--- a/tests/components/google_tasks/test_config_flow.py
+++ b/tests/components/google_tasks/test_config_flow.py
@@ -17,7 +17,7 @@ from homeassistant.core import HomeAssistant
 from homeassistant.data_entry_flow import FlowResultType
 from homeassistant.helpers import config_entry_oauth2_flow
 
-from tests.common import MockConfigEntry, load_fixture
+from tests.common import MockConfigEntry, async_load_fixture
 from tests.test_util.aiohttp import AiohttpClientMocker
 from tests.typing import ClientSessionGenerator
 
@@ -145,7 +145,10 @@ async def test_api_not_enabled(
         "homeassistant.components.google_tasks.config_flow.build",
         side_effect=HttpError(
             Response({"status": "403"}),
-            bytes(load_fixture("google_tasks/api_not_enabled_response.json"), "utf-8"),
+            bytes(
+                await async_load_fixture(hass, "api_not_enabled_response.json", DOMAIN),
+                "utf-8",
+            ),
         ),
     ):
         result = await hass.config_entries.flow.async_configure(result["flow_id"])
diff --git a/tests/components/gree/common.py b/tests/components/gree/common.py
index ca217168b18..aae292b79a0 100644
--- a/tests/components/gree/common.py
+++ b/tests/components/gree/common.py
@@ -6,7 +6,7 @@ from unittest.mock import AsyncMock, Mock
 
 from greeclimate.discovery import Listener
 
-from homeassistant.components.gree.const import DISCOVERY_TIMEOUT, DOMAIN as GREE_DOMAIN
+from homeassistant.components.gree.const import DISCOVERY_TIMEOUT, DOMAIN
 from homeassistant.core import HomeAssistant
 from homeassistant.setup import async_setup_component
 
@@ -93,8 +93,8 @@ def build_device_mock(name="fake-device-1", ipAddress="1.1.1.1", mac="aabbcc1122
 
 async def async_setup_gree(hass: HomeAssistant) -> MockConfigEntry:
     """Set up the gree platform."""
-    entry = MockConfigEntry(domain=GREE_DOMAIN)
+    entry = MockConfigEntry(domain=DOMAIN)
     entry.add_to_hass(hass)
-    await async_setup_component(hass, GREE_DOMAIN, {GREE_DOMAIN: {"climate": {}}})
+    await async_setup_component(hass, DOMAIN, {DOMAIN: {"climate": {}}})
     await hass.async_block_till_done()
     return entry
diff --git a/tests/components/gree/test_config_flow.py b/tests/components/gree/test_config_flow.py
index af374fb4245..aef53538f10 100644
--- a/tests/components/gree/test_config_flow.py
+++ b/tests/components/gree/test_config_flow.py
@@ -5,7 +5,7 @@ from unittest.mock import AsyncMock, patch
 import pytest
 
 from homeassistant import config_entries
-from homeassistant.components.gree.const import DOMAIN as GREE_DOMAIN
+from homeassistant.components.gree.const import DOMAIN
 from homeassistant.core import HomeAssistant
 from homeassistant.data_entry_flow import FlowResultType
 
@@ -24,7 +24,7 @@ async def test_creating_entry_sets_up_climate(
         return_value=FakeDiscovery(),
     ):
         result = await hass.config_entries.flow.async_init(
-            GREE_DOMAIN, context={"source": config_entries.SOURCE_USER}
+            DOMAIN, context={"source": config_entries.SOURCE_USER}
         )
 
         # Confirmation form
@@ -50,7 +50,7 @@ async def test_creating_entry_has_no_devices(
         discovery.return_value.mock_devices = []
 
         result = await hass.config_entries.flow.async_init(
-            GREE_DOMAIN, context={"source": config_entries.SOURCE_USER}
+            DOMAIN, context={"source": config_entries.SOURCE_USER}
         )
 
         # Confirmation form
diff --git a/tests/components/gree/test_init.py b/tests/components/gree/test_init.py
index 026660cf2d1..f2550ab442b 100644
--- a/tests/components/gree/test_init.py
+++ b/tests/components/gree/test_init.py
@@ -2,7 +2,7 @@
 
 from unittest.mock import patch
 
-from homeassistant.components.gree.const import DOMAIN as GREE_DOMAIN
+from homeassistant.components.gree.const import DOMAIN
 from homeassistant.config_entries import ConfigEntryState
 from homeassistant.core import HomeAssistant
 from homeassistant.setup import async_setup_component
@@ -12,7 +12,7 @@ from tests.common import MockConfigEntry
 
 async def test_setup_simple(hass: HomeAssistant) -> None:
     """Test gree integration is setup."""
-    entry = MockConfigEntry(domain=GREE_DOMAIN)
+    entry = MockConfigEntry(domain=DOMAIN)
     entry.add_to_hass(hass)
 
     with (
@@ -25,7 +25,7 @@ async def test_setup_simple(hass: HomeAssistant) -> None:
             return_value=True,
         ) as switch_setup,
     ):
-        assert await async_setup_component(hass, GREE_DOMAIN, {})
+        assert await async_setup_component(hass, DOMAIN, {})
         await hass.async_block_till_done()
 
         assert len(climate_setup.mock_calls) == 1
@@ -39,10 +39,10 @@ async def test_setup_simple(hass: HomeAssistant) -> None:
 async def test_unload_config_entry(hass: HomeAssistant) -> None:
     """Test that the async_unload_entry works."""
     # As we have currently no configuration, we just to pass the domain here.
-    entry = MockConfigEntry(domain=GREE_DOMAIN)
+    entry = MockConfigEntry(domain=DOMAIN)
     entry.add_to_hass(hass)
 
-    assert await async_setup_component(hass, GREE_DOMAIN, {})
+    assert await async_setup_component(hass, DOMAIN, {})
     await hass.async_block_till_done()
 
     await hass.config_entries.async_unload(entry.entry_id)
diff --git a/tests/components/gree/test_switch.py b/tests/components/gree/test_switch.py
index 331b6dfa4a6..582c0b767a5 100644
--- a/tests/components/gree/test_switch.py
+++ b/tests/components/gree/test_switch.py
@@ -6,7 +6,7 @@ from greeclimate.exceptions import DeviceTimeoutError
 import pytest
 from syrupy.assertion import SnapshotAssertion
 
-from homeassistant.components.gree.const import DOMAIN as GREE_DOMAIN
+from homeassistant.components.gree.const import DOMAIN
 from homeassistant.components.switch import DOMAIN as SWITCH_DOMAIN
 from homeassistant.const import (
     ATTR_ENTITY_ID,
@@ -31,9 +31,9 @@ ENTITY_ID_XTRA_FAN = f"{SWITCH_DOMAIN}.fake_device_1_xtra_fan"
 
 async def async_setup_gree(hass: HomeAssistant) -> MockConfigEntry:
     """Set up the gree switch platform."""
-    entry = MockConfigEntry(domain=GREE_DOMAIN)
+    entry = MockConfigEntry(domain=DOMAIN)
     entry.add_to_hass(hass)
-    await async_setup_component(hass, GREE_DOMAIN, {GREE_DOMAIN: {SWITCH_DOMAIN: {}}})
+    await async_setup_component(hass, DOMAIN, {DOMAIN: {SWITCH_DOMAIN: {}}})
     await hass.async_block_till_done()
     return entry
 
diff --git a/tests/components/group/test_sensor.py b/tests/components/group/test_sensor.py
index de48c711587..acbd9c44cbf 100644
--- a/tests/components/group/test_sensor.py
+++ b/tests/components/group/test_sensor.py
@@ -10,7 +10,7 @@ from unittest.mock import patch
 import pytest
 
 from homeassistant import config as hass_config
-from homeassistant.components.group import DOMAIN as GROUP_DOMAIN
+from homeassistant.components.group import DOMAIN
 from homeassistant.components.group.sensor import (
     ATTR_LAST_ENTITY_ID,
     ATTR_MAX_ENTITY_ID,
@@ -77,7 +77,7 @@ async def test_sensors2(
     """Test the sensors."""
     config = {
         SENSOR_DOMAIN: {
-            "platform": GROUP_DOMAIN,
+            "platform": DOMAIN,
             "name": DEFAULT_NAME,
             "type": sensor_type,
             "entities": ["sensor.test_1", "sensor.test_2", "sensor.test_3"],
@@ -121,7 +121,7 @@ async def test_sensors_attributes_defined(hass: HomeAssistant) -> None:
     """Test the sensors."""
     config = {
         SENSOR_DOMAIN: {
-            "platform": GROUP_DOMAIN,
+            "platform": DOMAIN,
             "name": DEFAULT_NAME,
             "type": "sum",
             "entities": ["sensor.test_1", "sensor.test_2", "sensor.test_3"],
@@ -163,7 +163,7 @@ async def test_not_enough_sensor_value(hass: HomeAssistant) -> None:
     """Test that there is nothing done if not enough values available."""
     config = {
         SENSOR_DOMAIN: {
-            "platform": GROUP_DOMAIN,
+            "platform": DOMAIN,
             "name": "test_max",
             "type": "max",
             "ignore_non_numeric": True,
@@ -218,7 +218,7 @@ async def test_reload(hass: HomeAssistant) -> None:
         "sensor",
         {
             SENSOR_DOMAIN: {
-                "platform": GROUP_DOMAIN,
+                "platform": DOMAIN,
                 "name": "test_sensor",
                 "type": "mean",
                 "entities": ["sensor.test_1", "sensor.test_2"],
@@ -236,7 +236,7 @@ async def test_reload(hass: HomeAssistant) -> None:
 
     with patch.object(hass_config, "YAML_CONFIG_FILE", yaml_path):
         await hass.services.async_call(
-            GROUP_DOMAIN,
+            DOMAIN,
             SERVICE_RELOAD,
             {},
             blocking=True,
@@ -255,7 +255,7 @@ async def test_sensor_incorrect_state_with_ignore_non_numeric(
     """Test that non numeric values are ignored in a group."""
     config = {
         SENSOR_DOMAIN: {
-            "platform": GROUP_DOMAIN,
+            "platform": DOMAIN,
             "name": "test_ignore_non_numeric",
             "type": "max",
             "ignore_non_numeric": True,
@@ -296,7 +296,7 @@ async def test_sensor_incorrect_state_with_not_ignore_non_numeric(
     """Test that non numeric values cause a group to be unknown."""
     config = {
         SENSOR_DOMAIN: {
-            "platform": GROUP_DOMAIN,
+            "platform": DOMAIN,
             "name": "test_failure",
             "type": "max",
             "ignore_non_numeric": False,
@@ -333,7 +333,7 @@ async def test_sensor_require_all_states(hass: HomeAssistant) -> None:
     """Test the sum sensor with missing state require all."""
     config = {
         SENSOR_DOMAIN: {
-            "platform": GROUP_DOMAIN,
+            "platform": DOMAIN,
             "name": "test_sum",
             "type": "sum",
             "ignore_non_numeric": False,
@@ -361,7 +361,7 @@ async def test_sensor_calculated_properties(hass: HomeAssistant) -> None:
     """Test the sensor calculating device_class, state_class and unit of measurement."""
     config = {
         SENSOR_DOMAIN: {
-            "platform": GROUP_DOMAIN,
+            "platform": DOMAIN,
             "name": "test_sum",
             "type": "sum",
             "entities": ["sensor.test_1", "sensor.test_2", "sensor.test_3"],
@@ -434,7 +434,7 @@ async def test_sensor_with_uoms_but_no_device_class(
     """Test the sensor works with same uom when there is no device class."""
     config = {
         SENSOR_DOMAIN: {
-            "platform": GROUP_DOMAIN,
+            "platform": DOMAIN,
             "name": "test_sum",
             "type": "sum",
             "entities": ["sensor.test_1", "sensor.test_2", "sensor.test_3"],
@@ -482,9 +482,7 @@ async def test_sensor_with_uoms_but_no_device_class(
     assert state.state == str(float(sum(VALUES)))
 
     assert not [
-        issue
-        for issue in issue_registry.issues.values()
-        if issue.domain == GROUP_DOMAIN
+        issue for issue in issue_registry.issues.values() if issue.domain == DOMAIN
     ]
 
     hass.states.async_set(
@@ -531,7 +529,7 @@ async def test_sensor_calculated_properties_not_same(
     """Test the sensor calculating device_class, state_class and unit of measurement not same."""
     config = {
         SENSOR_DOMAIN: {
-            "platform": GROUP_DOMAIN,
+            "platform": DOMAIN,
             "name": "test_sum",
             "type": "sum",
             "entities": ["sensor.test_1", "sensor.test_2", "sensor.test_3"],
@@ -580,13 +578,13 @@ async def test_sensor_calculated_properties_not_same(
     assert state.attributes.get("unit_of_measurement") is None
 
     assert issue_registry.async_get_issue(
-        GROUP_DOMAIN, "sensor.test_sum_uoms_not_matching_no_device_class"
+        DOMAIN, "sensor.test_sum_uoms_not_matching_no_device_class"
     )
     assert issue_registry.async_get_issue(
-        GROUP_DOMAIN, "sensor.test_sum_device_classes_not_matching"
+        DOMAIN, "sensor.test_sum_device_classes_not_matching"
     )
     assert issue_registry.async_get_issue(
-        GROUP_DOMAIN, "sensor.test_sum_state_classes_not_matching"
+        DOMAIN, "sensor.test_sum_state_classes_not_matching"
     )
 
 
@@ -594,7 +592,7 @@ async def test_sensor_calculated_result_fails_on_uom(hass: HomeAssistant) -> Non
     """Test the sensor calculating fails as UoM not part of device class."""
     config = {
         SENSOR_DOMAIN: {
-            "platform": GROUP_DOMAIN,
+            "platform": DOMAIN,
             "name": "test_sum",
             "type": "sum",
             "entities": ["sensor.test_1", "sensor.test_2", "sensor.test_3"],
@@ -667,7 +665,7 @@ async def test_sensor_calculated_properties_not_convertible_device_class(
     """Test the sensor calculating device_class, state_class and unit of measurement when device class not convertible."""
     config = {
         SENSOR_DOMAIN: {
-            "platform": GROUP_DOMAIN,
+            "platform": DOMAIN,
             "name": "test_sum",
             "type": "sum",
             "entities": ["sensor.test_1", "sensor.test_2", "sensor.test_3"],
@@ -748,7 +746,7 @@ async def test_last_sensor(hass: HomeAssistant) -> None:
     """Test the last sensor."""
     config = {
         SENSOR_DOMAIN: {
-            "platform": GROUP_DOMAIN,
+            "platform": DOMAIN,
             "name": "test_last",
             "type": "last",
             "entities": ["sensor.test_1", "sensor.test_2", "sensor.test_3"],
@@ -775,7 +773,7 @@ async def test_sensors_attributes_added_when_entity_info_available(
     """Test the sensor calculate attributes once all entities attributes are available."""
     config = {
         SENSOR_DOMAIN: {
-            "platform": GROUP_DOMAIN,
+            "platform": DOMAIN,
             "name": DEFAULT_NAME,
             "type": "sum",
             "entities": ["sensor.test_1", "sensor.test_2", "sensor.test_3"],
@@ -830,7 +828,7 @@ async def test_sensor_state_class_no_uom_not_available(
 
     config = {
         SENSOR_DOMAIN: {
-            "platform": GROUP_DOMAIN,
+            "platform": DOMAIN,
             "name": "test_sum",
             "type": "sum",
             "entities": ["sensor.test_1", "sensor.test_2", "sensor.test_3"],
@@ -893,7 +891,7 @@ async def test_sensor_different_attributes_ignore_non_numeric(
     """Test the sensor handles calculating attributes when using ignore_non_numeric."""
     config = {
         SENSOR_DOMAIN: {
-            "platform": GROUP_DOMAIN,
+            "platform": DOMAIN,
             "name": "test_sum",
             "type": "sum",
             "ignore_non_numeric": True,
diff --git a/tests/components/gstreamer/test_media_player.py b/tests/components/gstreamer/test_media_player.py
index 9fcf8eb7cfc..97a42317bfe 100644
--- a/tests/components/gstreamer/test_media_player.py
+++ b/tests/components/gstreamer/test_media_player.py
@@ -2,7 +2,7 @@
 
 from unittest.mock import Mock, patch
 
-from homeassistant.components.gstreamer import DOMAIN as GSTREAMER_DOMAIN
+from homeassistant.components.gstreamer import DOMAIN
 from homeassistant.components.media_player import DOMAIN as PLATFORM_DOMAIN
 from homeassistant.const import CONF_PLATFORM
 from homeassistant.core import DOMAIN as HOMEASSISTANT_DOMAIN, HomeAssistant
@@ -22,7 +22,7 @@ async def test_repair_issue_is_created(
         {
             PLATFORM_DOMAIN: [
                 {
-                    CONF_PLATFORM: GSTREAMER_DOMAIN,
+                    CONF_PLATFORM: DOMAIN,
                 }
             ],
         },
@@ -30,5 +30,5 @@ async def test_repair_issue_is_created(
     await hass.async_block_till_done()
     assert (
         HOMEASSISTANT_DOMAIN,
-        f"deprecated_system_packages_yaml_integration_{GSTREAMER_DOMAIN}",
+        f"deprecated_system_packages_yaml_integration_{DOMAIN}",
     ) in issue_registry.issues
diff --git a/tests/components/habitica/conftest.py b/tests/components/habitica/conftest.py
index fa2b65af6c3..80e09d823cc 100644
--- a/tests/components/habitica/conftest.py
+++ b/tests/components/habitica/conftest.py
@@ -1,6 +1,6 @@
 """Tests for the habitica component."""
 
-from collections.abc import Generator
+from collections.abc import AsyncGenerator, Generator
 from unittest.mock import AsyncMock, MagicMock, patch
 from uuid import UUID
 
@@ -32,7 +32,7 @@ from homeassistant.components.habitica.const import CONF_API_USER, DEFAULT_URL,
 from homeassistant.const import CONF_API_KEY, CONF_URL
 from homeassistant.core import HomeAssistant
 
-from tests.common import MockConfigEntry, load_fixture
+from tests.common import MockConfigEntry, async_load_fixture, load_fixture
 
 ERROR_RESPONSE = HabiticaErrorResponse(success=False, error="error", message="reason")
 ERROR_NOT_AUTHORIZED = NotAuthorizedError(error=ERROR_RESPONSE, headers={})
@@ -75,7 +75,7 @@ def mock_get_tasks(task_type: TaskFilter | None = None) -> HabiticaTasksResponse
 
 
 @pytest.fixture(name="habitica")
-async def mock_habiticalib() -> Generator[AsyncMock]:
+async def mock_habiticalib(hass: HomeAssistant) -> AsyncGenerator[AsyncMock]:
     """Mock habiticalib."""
 
     with (
@@ -89,24 +89,24 @@ async def mock_habiticalib() -> Generator[AsyncMock]:
         client = mock_client.return_value
 
         client.login.return_value = HabiticaLoginResponse.from_json(
-            load_fixture("login.json", DOMAIN)
+            await async_load_fixture(hass, "login.json", DOMAIN)
         )
 
         client.get_user.return_value = HabiticaUserResponse.from_json(
-            load_fixture("user.json", DOMAIN)
+            await async_load_fixture(hass, "user.json", DOMAIN)
         )
 
         client.cast_skill.return_value = HabiticaCastSkillResponse.from_json(
-            load_fixture("cast_skill_response.json", DOMAIN)
+            await async_load_fixture(hass, "cast_skill_response.json", DOMAIN)
         )
         client.toggle_sleep.return_value = HabiticaSleepResponse(
             success=True, data=True
         )
         client.update_score.return_value = HabiticaUserResponse.from_json(
-            load_fixture("score_with_drop.json", DOMAIN)
+            await async_load_fixture(hass, "score_with_drop.json", DOMAIN)
         )
         client.get_group_members.return_value = HabiticaGroupMembersResponse.from_json(
-            load_fixture("party_members.json", DOMAIN)
+            await async_load_fixture(hass, "party_members.json", DOMAIN)
         )
         for func in (
             "leave_quest",
@@ -117,20 +117,20 @@ async def mock_habiticalib() -> Generator[AsyncMock]:
             "accept_quest",
         ):
             getattr(client, func).return_value = HabiticaQuestResponse.from_json(
-                load_fixture("party_quest.json", DOMAIN)
+                await async_load_fixture(hass, "party_quest.json", DOMAIN)
             )
         client.get_content.return_value = HabiticaContentResponse.from_json(
-            load_fixture("content.json", DOMAIN)
+            await async_load_fixture(hass, "content.json", DOMAIN)
         )
         client.get_tasks.side_effect = mock_get_tasks
         client.update_score.return_value = HabiticaScoreResponse.from_json(
-            load_fixture("score_with_drop.json", DOMAIN)
+            await async_load_fixture(hass, "score_with_drop.json", DOMAIN)
         )
         client.update_task.return_value = HabiticaTaskResponse.from_json(
-            load_fixture("task.json", DOMAIN)
+            await async_load_fixture(hass, "task.json", DOMAIN)
         )
         client.create_task.return_value = HabiticaTaskResponse.from_json(
-            load_fixture("task.json", DOMAIN)
+            await async_load_fixture(hass, "task.json", DOMAIN)
         )
         client.delete_task.return_value = HabiticaResponse.from_dict(
             {"data": {}, "success": True}
@@ -143,17 +143,17 @@ async def mock_habiticalib() -> Generator[AsyncMock]:
         )
         client.get_user_anonymized.return_value = (
             HabiticaUserAnonymizedResponse.from_json(
-                load_fixture("anonymized.json", DOMAIN)
+                await async_load_fixture(hass, "anonymized.json", DOMAIN)
             )
         )
         client.update_task.return_value = HabiticaTaskResponse.from_json(
-            load_fixture("task.json", DOMAIN)
+            await async_load_fixture(hass, "task.json", DOMAIN)
         )
         client.create_tag.return_value = HabiticaTagResponse.from_json(
-            load_fixture("create_tag.json", DOMAIN)
+            await async_load_fixture(hass, "create_tag.json", DOMAIN)
         )
         client.create_task.return_value = HabiticaTaskResponse.from_json(
-            load_fixture("task.json", DOMAIN)
+            await async_load_fixture(hass, "task.json", DOMAIN)
         )
         yield client
 
diff --git a/tests/components/habitica/test_binary_sensor.py b/tests/components/habitica/test_binary_sensor.py
index 80acc92385f..7fe7a116c7b 100644
--- a/tests/components/habitica/test_binary_sensor.py
+++ b/tests/components/habitica/test_binary_sensor.py
@@ -13,7 +13,7 @@ from homeassistant.const import STATE_OFF, STATE_ON, Platform
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers import entity_registry as er
 
-from tests.common import MockConfigEntry, load_fixture, snapshot_platform
+from tests.common import MockConfigEntry, async_load_fixture, snapshot_platform
 
 
 @pytest.fixture(autouse=True)
@@ -62,7 +62,7 @@ async def test_pending_quest_states(
     """Test states of pending quest sensor."""
 
     habitica.get_user.return_value = HabiticaUserResponse.from_json(
-        load_fixture(f"{fixture}.json", DOMAIN)
+        await async_load_fixture(hass, f"{fixture}.json", DOMAIN)
     )
 
     config_entry.add_to_hass(hass)
diff --git a/tests/components/habitica/test_button.py b/tests/components/habitica/test_button.py
index dc1a155b541..6e7ccbd3424 100644
--- a/tests/components/habitica/test_button.py
+++ b/tests/components/habitica/test_button.py
@@ -23,7 +23,7 @@ from .conftest import ERROR_BAD_REQUEST, ERROR_NOT_AUTHORIZED, ERROR_TOO_MANY_RE
 from tests.common import (
     MockConfigEntry,
     async_fire_time_changed,
-    load_fixture,
+    async_load_fixture,
     snapshot_platform,
 )
 
@@ -58,7 +58,7 @@ async def test_buttons(
     """Test button entities."""
 
     habitica.get_user.return_value = HabiticaUserResponse.from_json(
-        load_fixture(f"{fixture}.json", DOMAIN)
+        await async_load_fixture(hass, f"{fixture}.json", DOMAIN)
     )
     config_entry.add_to_hass(hass)
     await hass.config_entries.async_setup(config_entry.entry_id)
@@ -167,7 +167,7 @@ async def test_button_press(
     """Test button press method."""
 
     habitica.get_user.return_value = HabiticaUserResponse.from_json(
-        load_fixture(f"{fixture}.json", DOMAIN)
+        await async_load_fixture(hass, f"{fixture}.json", DOMAIN)
     )
 
     config_entry.add_to_hass(hass)
@@ -321,7 +321,7 @@ async def test_button_unavailable(
     """Test buttons are unavailable if conditions are not met."""
 
     habitica.get_user.return_value = HabiticaUserResponse.from_json(
-        load_fixture(f"{fixture}.json", DOMAIN)
+        await async_load_fixture(hass, f"{fixture}.json", DOMAIN)
     )
 
     config_entry.add_to_hass(hass)
@@ -355,7 +355,7 @@ async def test_class_change(
     ]
 
     habitica.get_user.return_value = HabiticaUserResponse.from_json(
-        load_fixture("wizard_fixture.json", DOMAIN)
+        await async_load_fixture(hass, "wizard_fixture.json", DOMAIN)
     )
     config_entry.add_to_hass(hass)
     await hass.config_entries.async_setup(config_entry.entry_id)
@@ -367,7 +367,7 @@ async def test_class_change(
         assert hass.states.get(skill)
 
     habitica.get_user.return_value = HabiticaUserResponse.from_json(
-        load_fixture("healer_fixture.json", DOMAIN)
+        await async_load_fixture(hass, "healer_fixture.json", DOMAIN)
     )
     freezer.tick(timedelta(seconds=60))
     async_fire_time_changed(hass)
diff --git a/tests/components/habitica/test_image.py b/tests/components/habitica/test_image.py
index 17089f57bd7..42a87d21a8a 100644
--- a/tests/components/habitica/test_image.py
+++ b/tests/components/habitica/test_image.py
@@ -18,7 +18,7 @@ from homeassistant.config_entries import ConfigEntryState
 from homeassistant.const import Platform
 from homeassistant.core import HomeAssistant
 
-from tests.common import MockConfigEntry, async_fire_time_changed, load_fixture
+from tests.common import MockConfigEntry, async_fire_time_changed, async_load_fixture
 from tests.typing import ClientSessionGenerator
 
 
@@ -81,7 +81,7 @@ async def test_image_platform(
         )
 
         habitica.get_user.return_value = HabiticaUserResponse.from_json(
-            load_fixture("rogue_fixture.json", DOMAIN)
+            await async_load_fixture(hass, "rogue_fixture.json", DOMAIN)
         )
 
         freezer.tick(timedelta(seconds=60))
diff --git a/tests/components/habitica/test_services.py b/tests/components/habitica/test_services.py
index 774593fa0f6..0e2a99ce215 100644
--- a/tests/components/habitica/test_services.py
+++ b/tests/components/habitica/test_services.py
@@ -89,7 +89,7 @@ from .conftest import (
     ERROR_TOO_MANY_REQUESTS,
 )
 
-from tests.common import MockConfigEntry, load_fixture
+from tests.common import MockConfigEntry, async_load_fixture
 
 REQUEST_EXCEPTION_MSG = "Unable to connect to Habitica: reason"
 RATE_LIMIT_EXCEPTION_MSG = "Rate limit exceeded, try again in 5 seconds"
@@ -1111,7 +1111,7 @@ async def test_update_reward(
     task_id = "5e2ea1df-f6e6-4ba3-bccb-97c5ec63e99b"
 
     habitica.update_task.return_value = HabiticaTaskResponse.from_json(
-        load_fixture("task.json", DOMAIN)
+        await async_load_fixture(hass, "task.json", DOMAIN)
     )
     await hass.services.async_call(
         DOMAIN,
diff --git a/tests/components/habitica/test_todo.py b/tests/components/habitica/test_todo.py
index 3457af78403..0761ce19712 100644
--- a/tests/components/habitica/test_todo.py
+++ b/tests/components/habitica/test_todo.py
@@ -37,7 +37,7 @@ from .conftest import ERROR_NOT_FOUND, ERROR_TOO_MANY_REQUESTS
 from tests.common import (
     MockConfigEntry,
     async_get_persistent_notifications,
-    load_fixture,
+    async_load_fixture,
     snapshot_platform,
 )
 from tests.typing import WebSocketGenerator
@@ -642,7 +642,7 @@ async def test_move_todo_item(
 ) -> None:
     """Test move todo items."""
     reorder_response = HabiticaTaskOrderResponse.from_json(
-        load_fixture(fixture, DOMAIN)
+        await async_load_fixture(hass, fixture, DOMAIN)
     )
     habitica.reorder_task.return_value = reorder_response
     config_entry.add_to_hass(hass)
@@ -788,7 +788,9 @@ async def test_next_due_date(
     dailies_entity = "todo.test_user_dailies"
 
     habitica.get_tasks.side_effect = [
-        HabiticaTasksResponse.from_json(load_fixture(fixture, DOMAIN)),
+        HabiticaTasksResponse.from_json(
+            await async_load_fixture(hass, fixture, DOMAIN)
+        ),
         HabiticaTasksResponse.from_dict({"success": True, "data": []}),
     ]
 
diff --git a/tests/components/hassio/conftest.py b/tests/components/hassio/conftest.py
index ea38865ac5a..a71ee370b32 100644
--- a/tests/components/hassio/conftest.py
+++ b/tests/components/hassio/conftest.py
@@ -63,7 +63,7 @@ async def hassio_client_supervisor(
 
 
 @pytest.fixture
-def hassio_handler(
+async def hassio_handler(
     hass: HomeAssistant, aioclient_mock: AiohttpClientMocker
 ) -> Generator[HassIO]:
     """Create mock hassio handler."""
diff --git a/tests/components/history_stats/test_init.py b/tests/components/history_stats/test_init.py
index 4cd999ba31c..c99d836a822 100644
--- a/tests/components/history_stats/test_init.py
+++ b/tests/components/history_stats/test_init.py
@@ -6,7 +6,7 @@ from homeassistant.components.history_stats.const import (
     CONF_END,
     CONF_START,
     DEFAULT_NAME,
-    DOMAIN as HISTORY_STATS_DOMAIN,
+    DOMAIN,
 )
 from homeassistant.components.recorder import Recorder
 from homeassistant.config_entries import ConfigEntryState
@@ -61,7 +61,7 @@ async def test_device_cleaning(
     # Configure the configuration entry for History stats
     history_stats_config_entry = MockConfigEntry(
         data={},
-        domain=HISTORY_STATS_DOMAIN,
+        domain=DOMAIN,
         options={
             CONF_NAME: DEFAULT_NAME,
             CONF_ENTITY_ID: "binary_sensor.test_source",
diff --git a/tests/components/homeassistant/test_init.py b/tests/components/homeassistant/test_init.py
index fe5d2155f58..530a729e12d 100644
--- a/tests/components/homeassistant/test_init.py
+++ b/tests/components/homeassistant/test_init.py
@@ -10,7 +10,7 @@ from homeassistant import config, core as ha
 from homeassistant.components.homeassistant import (
     ATTR_ENTRY_ID,
     ATTR_SAFE_MODE,
-    DOMAIN as HOMEASSISTANT_DOMAIN,
+    DOMAIN,
     SERVICE_CHECK_CONFIG,
     SERVICE_HOMEASSISTANT_RESTART,
     SERVICE_HOMEASSISTANT_STOP,
@@ -669,14 +669,12 @@ async def test_deprecated_installation_issue_32bit_method(
             "arch": arch,
         },
     ):
-        assert await async_setup_component(hass, HOMEASSISTANT_DOMAIN, {})
+        assert await async_setup_component(hass, DOMAIN, {})
         await hass.async_block_till_done()
 
     assert len(issue_registry.issues) == 1
-    issue = issue_registry.async_get_issue(
-        HOMEASSISTANT_DOMAIN, "deprecated_method_architecture"
-    )
-    assert issue.domain == HOMEASSISTANT_DOMAIN
+    issue = issue_registry.async_get_issue(DOMAIN, "deprecated_method_architecture")
+    assert issue.domain == DOMAIN
     assert issue.severity == ir.IssueSeverity.WARNING
     assert issue.translation_placeholders == {
         "installation_type": installation_type[15:],
@@ -712,14 +710,12 @@ async def test_deprecated_installation_issue_32bit(
             "arch": arch,
         },
     ):
-        assert await async_setup_component(hass, HOMEASSISTANT_DOMAIN, {})
+        assert await async_setup_component(hass, DOMAIN, {})
         await hass.async_block_till_done()
 
     assert len(issue_registry.issues) == 1
-    issue = issue_registry.async_get_issue(
-        HOMEASSISTANT_DOMAIN, "deprecated_architecture"
-    )
-    assert issue.domain == HOMEASSISTANT_DOMAIN
+    issue = issue_registry.async_get_issue(DOMAIN, "deprecated_architecture")
+    assert issue.domain == DOMAIN
     assert issue.severity == ir.IssueSeverity.WARNING
     assert issue.translation_placeholders == {
         "installation_type": installation_type[15:],
@@ -747,12 +743,12 @@ async def test_deprecated_installation_issue_method(
             "arch": "generic-x86-64",
         },
     ):
-        assert await async_setup_component(hass, HOMEASSISTANT_DOMAIN, {})
+        assert await async_setup_component(hass, DOMAIN, {})
         await hass.async_block_till_done()
 
     assert len(issue_registry.issues) == 1
-    issue = issue_registry.async_get_issue(HOMEASSISTANT_DOMAIN, "deprecated_method")
-    assert issue.domain == HOMEASSISTANT_DOMAIN
+    issue = issue_registry.async_get_issue(DOMAIN, "deprecated_method")
+    assert issue.domain == DOMAIN
     assert issue.severity == ir.IssueSeverity.WARNING
     assert issue.translation_placeholders == {
         "installation_type": installation_type[15:],
@@ -789,12 +785,12 @@ async def test_deprecated_installation_issue_aarch64(
             "homeassistant.components.hassio.get_os_info", return_value={"board": board}
         ),
     ):
-        assert await async_setup_component(hass, HOMEASSISTANT_DOMAIN, {})
+        assert await async_setup_component(hass, DOMAIN, {})
         await hass.async_block_till_done()
 
     assert len(issue_registry.issues) == 1
-    issue = issue_registry.async_get_issue(HOMEASSISTANT_DOMAIN, issue_id)
-    assert issue.domain == HOMEASSISTANT_DOMAIN
+    issue = issue_registry.async_get_issue(DOMAIN, issue_id)
+    assert issue.domain == DOMAIN
     assert issue.severity == ir.IssueSeverity.WARNING
     assert issue.translation_placeholders == {
         "installation_guide": "https://www.home-assistant.io/installation/",
@@ -813,12 +809,10 @@ async def test_deprecated_installation_issue_armv7_container(
             "arch": "armv7",
         },
     ):
-        assert await async_setup_component(hass, HOMEASSISTANT_DOMAIN, {})
+        assert await async_setup_component(hass, DOMAIN, {})
         await hass.async_block_till_done()
 
     assert len(issue_registry.issues) == 1
-    issue = issue_registry.async_get_issue(
-        HOMEASSISTANT_DOMAIN, "deprecated_container_armv7"
-    )
-    assert issue.domain == HOMEASSISTANT_DOMAIN
+    issue = issue_registry.async_get_issue(DOMAIN, "deprecated_container_armv7")
+    assert issue.domain == DOMAIN
     assert issue.severity == ir.IssueSeverity.WARNING
diff --git a/tests/components/homeassistant_alerts/test_init.py b/tests/components/homeassistant_alerts/test_init.py
index 0a38778bbee..2dd3b4b1e4a 100644
--- a/tests/components/homeassistant_alerts/test_init.py
+++ b/tests/components/homeassistant_alerts/test_init.py
@@ -21,7 +21,7 @@ from homeassistant.core import HomeAssistant
 from homeassistant.setup import ATTR_COMPONENT, async_setup_component
 from homeassistant.util import dt as dt_util
 
-from tests.common import async_fire_time_changed, load_fixture
+from tests.common import async_fire_time_changed, async_load_fixture
 from tests.test_util.aiohttp import AiohttpClientMocker
 from tests.typing import WebSocketGenerator
 
@@ -108,7 +108,7 @@ async def test_alerts(
     aioclient_mock.clear_requests()
     aioclient_mock.get(
         "https://alerts.home-assistant.io/alerts.json",
-        text=load_fixture("alerts_1.json", "homeassistant_alerts"),
+        text=await async_load_fixture(hass, "alerts_1.json", DOMAIN),
     )
     for alert in expected_alerts:
         stub_alert(aioclient_mock, alert[0])
@@ -159,7 +159,7 @@ async def test_alerts(
                 "breaks_in_ha_version": None,
                 "created": ANY,
                 "dismissed_version": None,
-                "domain": "homeassistant_alerts",
+                "domain": DOMAIN,
                 "ignored": False,
                 "is_fixable": False,
                 "issue_id": f"{alert_id}.markdown_{integration}",
@@ -305,7 +305,7 @@ async def test_alerts_refreshed_on_component_load(
     aioclient_mock.clear_requests()
     aioclient_mock.get(
         "https://alerts.home-assistant.io/alerts.json",
-        text=load_fixture("alerts_1.json", "homeassistant_alerts"),
+        text=await async_load_fixture(hass, "alerts_1.json", DOMAIN),
     )
     for alert in initial_alerts:
         stub_alert(aioclient_mock, alert[0])
@@ -342,7 +342,7 @@ async def test_alerts_refreshed_on_component_load(
                     "breaks_in_ha_version": None,
                     "created": ANY,
                     "dismissed_version": None,
-                    "domain": "homeassistant_alerts",
+                    "domain": DOMAIN,
                     "ignored": False,
                     "is_fixable": False,
                     "issue_id": f"{alert}.markdown_{integration}",
@@ -391,7 +391,7 @@ async def test_alerts_refreshed_on_component_load(
                     "breaks_in_ha_version": None,
                     "created": ANY,
                     "dismissed_version": None,
-                    "domain": "homeassistant_alerts",
+                    "domain": DOMAIN,
                     "ignored": False,
                     "is_fixable": False,
                     "issue_id": f"{alert}.markdown_{integration}",
@@ -438,7 +438,7 @@ async def test_bad_alerts(
     expected_alerts: list[tuple[str, str]],
 ) -> None:
     """Test creating issues based on alerts."""
-    fixture_content = load_fixture(fixture, "homeassistant_alerts")
+    fixture_content = await async_load_fixture(hass, fixture, DOMAIN)
     aioclient_mock.clear_requests()
     aioclient_mock.get(
         "https://alerts.home-assistant.io/alerts.json",
@@ -472,7 +472,7 @@ async def test_bad_alerts(
                 "breaks_in_ha_version": None,
                 "created": ANY,
                 "dismissed_version": None,
-                "domain": "homeassistant_alerts",
+                "domain": DOMAIN,
                 "ignored": False,
                 "is_fixable": False,
                 "issue_id": f"{alert_id}.markdown_{integration}",
@@ -589,7 +589,7 @@ async def test_alerts_change(
     expected_alerts_2: list[tuple[str, str]],
 ) -> None:
     """Test creating issues based on alerts."""
-    fixture_1_content = load_fixture(fixture_1, "homeassistant_alerts")
+    fixture_1_content = await async_load_fixture(hass, fixture_1, DOMAIN)
     aioclient_mock.clear_requests()
     aioclient_mock.get(
         "https://alerts.home-assistant.io/alerts.json",
@@ -633,7 +633,7 @@ async def test_alerts_change(
                 "breaks_in_ha_version": None,
                 "created": ANY,
                 "dismissed_version": None,
-                "domain": "homeassistant_alerts",
+                "domain": DOMAIN,
                 "ignored": False,
                 "is_fixable": False,
                 "issue_id": f"{alert_id}.markdown_{integration}",
@@ -650,7 +650,7 @@ async def test_alerts_change(
         ]
     )
 
-    fixture_2_content = load_fixture(fixture_2, "homeassistant_alerts")
+    fixture_2_content = await async_load_fixture(hass, fixture_2, DOMAIN)
     aioclient_mock.clear_requests()
     aioclient_mock.get(
         "https://alerts.home-assistant.io/alerts.json",
@@ -672,7 +672,7 @@ async def test_alerts_change(
                 "breaks_in_ha_version": None,
                 "created": ANY,
                 "dismissed_version": None,
-                "domain": "homeassistant_alerts",
+                "domain": DOMAIN,
                 "ignored": False,
                 "is_fixable": False,
                 "issue_id": f"{alert_id}.markdown_{integration}",
diff --git a/tests/components/homeassistant_hardware/test_update.py b/tests/components/homeassistant_hardware/test_update.py
index 23d1e546791..81c6f2e0459 100644
--- a/tests/components/homeassistant_hardware/test_update.py
+++ b/tests/components/homeassistant_hardware/test_update.py
@@ -32,7 +32,7 @@ from homeassistant.components.homeassistant_hardware.util import (
 )
 from homeassistant.components.update import UpdateDeviceClass
 from homeassistant.config_entries import ConfigEntry, ConfigEntryState, ConfigFlow
-from homeassistant.const import EVENT_STATE_CHANGED, EntityCategory
+from homeassistant.const import EVENT_STATE_CHANGED, EntityCategory, Platform
 from homeassistant.core import (
     Event,
     EventStateChangedData,
@@ -173,7 +173,9 @@ async def mock_async_setup_entry(
     hass: HomeAssistant, config_entry: ConfigEntry
 ) -> bool:
     """Set up test config entry."""
-    await hass.config_entries.async_forward_entry_setups(config_entry, ["update"])
+    await hass.config_entries.async_forward_entry_setups(
+        config_entry, [Platform.UPDATE]
+    )
     return True
 
 
diff --git a/tests/components/homekit/test_iidmanager.py b/tests/components/homekit/test_iidmanager.py
index 39d2dda8237..592b229f95a 100644
--- a/tests/components/homekit/test_iidmanager.py
+++ b/tests/components/homekit/test_iidmanager.py
@@ -12,7 +12,7 @@ from homeassistant.core import HomeAssistant
 from homeassistant.util.json import json_loads
 from homeassistant.util.uuid import random_uuid_hex
 
-from tests.common import MockConfigEntry, load_fixture
+from tests.common import MockConfigEntry, async_load_fixture
 
 
 async def test_iid_generation_and_restore(
@@ -108,8 +108,8 @@ async def test_iid_migration_to_v2(
     hass: HomeAssistant, iid_storage, hass_storage: dict[str, Any]
 ) -> None:
     """Test iid storage migration."""
-    v1_iids = json_loads(load_fixture("iids_v1", DOMAIN))
-    v2_iids = json_loads(load_fixture("iids_v2", DOMAIN))
+    v1_iids = json_loads(await async_load_fixture(hass, "iids_v1", DOMAIN))
+    v2_iids = json_loads(await async_load_fixture(hass, "iids_v2", DOMAIN))
     hass_storage["homekit.v1.iids"] = v1_iids
     hass_storage["homekit.v2.iids"] = v2_iids
 
@@ -132,8 +132,12 @@ async def test_iid_migration_to_v2_with_underscore(
     hass: HomeAssistant, iid_storage, hass_storage: dict[str, Any]
 ) -> None:
     """Test iid storage migration with underscore."""
-    v1_iids = json_loads(load_fixture("iids_v1_with_underscore", DOMAIN))
-    v2_iids = json_loads(load_fixture("iids_v2_with_underscore", DOMAIN))
+    v1_iids = json_loads(
+        await async_load_fixture(hass, "iids_v1_with_underscore", DOMAIN)
+    )
+    v2_iids = json_loads(
+        await async_load_fixture(hass, "iids_v2_with_underscore", DOMAIN)
+    )
     hass_storage["homekit.v1_with_underscore.iids"] = v1_iids
     hass_storage["homekit.v2_with_underscore.iids"] = v2_iids
 
diff --git a/tests/components/homekit/test_init.py b/tests/components/homekit/test_init.py
index fdf599f41ea..7ab6048fb10 100644
--- a/tests/components/homekit/test_init.py
+++ b/tests/components/homekit/test_init.py
@@ -7,7 +7,7 @@ import pytest
 from homeassistant.components.homekit.const import (
     ATTR_DISPLAY_NAME,
     ATTR_VALUE,
-    DOMAIN as DOMAIN_HOMEKIT,
+    DOMAIN,
     EVENT_HOMEKIT_CHANGED,
 )
 from homeassistant.config_entries import SOURCE_ZEROCONF, ConfigEntryState
@@ -60,12 +60,12 @@ async def test_humanify_homekit_changed_event(hass: HomeAssistant, hk_driver) ->
     )
 
     assert event1["name"] == "HomeKit"
-    assert event1["domain"] == DOMAIN_HOMEKIT
+    assert event1["domain"] == DOMAIN
     assert event1["message"] == "send command lock for Front Door"
     assert event1["entity_id"] == "lock.front_door"
 
     assert event2["name"] == "HomeKit"
-    assert event2["domain"] == DOMAIN_HOMEKIT
+    assert event2["domain"] == DOMAIN
     assert event2["message"] == "send command set_cover_position to 75 for Window"
     assert event2["entity_id"] == "cover.window"
 
@@ -92,7 +92,7 @@ async def test_bridge_with_triggers(
     device_id = entry.device_id
 
     entry = MockConfigEntry(
-        domain=DOMAIN_HOMEKIT,
+        domain=DOMAIN,
         source=SOURCE_ZEROCONF,
         data={
             "name": "HASS Bridge",
diff --git a/tests/components/homematicip_cloud/conftest.py b/tests/components/homematicip_cloud/conftest.py
index bcadf407950..e9f2b7af656 100644
--- a/tests/components/homematicip_cloud/conftest.py
+++ b/tests/components/homematicip_cloud/conftest.py
@@ -9,7 +9,7 @@ from homematicip.connection.rest_connection import RestConnection
 import pytest
 
 from homeassistant.components.homematicip_cloud import (
-    DOMAIN as HMIPC_DOMAIN,
+    DOMAIN,
     async_setup as hmip_async_setup,
 )
 from homeassistant.components.homematicip_cloud.const import (
@@ -53,7 +53,7 @@ def hmip_config_entry_fixture() -> MockConfigEntry:
     }
     return MockConfigEntry(
         version=1,
-        domain=HMIPC_DOMAIN,
+        domain=DOMAIN,
         title="Home Test SN",
         unique_id=HAPID,
         data=entry_data,
@@ -80,7 +80,7 @@ def hmip_config_fixture() -> ConfigType:
         HMIPC_PIN: HAPPIN,
     }
 
-    return {HMIPC_DOMAIN: [entry_data]}
+    return {DOMAIN: [entry_data]}
 
 
 @pytest.fixture(name="dummy_config")
@@ -97,7 +97,7 @@ async def mock_hap_with_service_fixture(
     mock_hap = await default_mock_hap_factory.async_get_mock_hap()
     await hmip_async_setup(hass, dummy_config)
     await hass.async_block_till_done()
-    entry = hass.config_entries.async_entries(HMIPC_DOMAIN)[0]
+    entry = hass.config_entries.async_entries(DOMAIN)[0]
     entry.runtime_data = mock_hap
     return mock_hap
 
diff --git a/tests/components/homematicip_cloud/helper.py b/tests/components/homematicip_cloud/helper.py
index 946ccc569a4..ab5e61c19fa 100644
--- a/tests/components/homematicip_cloud/helper.py
+++ b/tests/components/homematicip_cloud/helper.py
@@ -15,7 +15,7 @@ from homematicip.device import Device
 from homematicip.group import Group
 from homematicip.home import Home
 
-from homeassistant.components.homematicip_cloud import DOMAIN as HMIPC_DOMAIN
+from homeassistant.components.homematicip_cloud import DOMAIN
 from homeassistant.components.homematicip_cloud.entity import (
     ATTR_IS_GROUP,
     ATTR_MODEL_TYPE,
@@ -116,7 +116,7 @@ class HomeFactory:
             "homeassistant.components.homematicip_cloud.hap.HomematicipHAP.get_hap",
             return_value=mock_home,
         ):
-            assert await async_setup_component(self.hass, HMIPC_DOMAIN, {})
+            assert await async_setup_component(self.hass, DOMAIN, {})
 
         await self.hass.async_block_till_done()
 
diff --git a/tests/components/homematicip_cloud/test_climate.py b/tests/components/homematicip_cloud/test_climate.py
index 28d0fca0d80..434f26e0e6f 100644
--- a/tests/components/homematicip_cloud/test_climate.py
+++ b/tests/components/homematicip_cloud/test_climate.py
@@ -18,7 +18,7 @@ from homeassistant.components.climate import (
     HVACAction,
     HVACMode,
 )
-from homeassistant.components.homematicip_cloud import DOMAIN as HMIPC_DOMAIN
+from homeassistant.components.homematicip_cloud import DOMAIN
 from homeassistant.components.homematicip_cloud.climate import (
     ATTR_PRESET_END_TIME,
     PERMANENT_END_TIME,
@@ -617,7 +617,7 @@ async def test_hmip_climate_services(
             {"accesspoint_id": not_existing_hap_id},
             blocking=True,
         )
-    assert excinfo.value.translation_domain == HMIPC_DOMAIN
+    assert excinfo.value.translation_domain == DOMAIN
     assert excinfo.value.translation_key == "access_point_not_found"
     # There is no further call on connection.
     assert len(home._connection.mock_calls) == 10
@@ -665,7 +665,7 @@ async def test_hmip_set_home_cooling_mode(
             {"accesspoint_id": not_existing_hap_id, "cooling": True},
             blocking=True,
         )
-    assert excinfo.value.translation_domain == HMIPC_DOMAIN
+    assert excinfo.value.translation_domain == DOMAIN
     assert excinfo.value.translation_key == "access_point_not_found"
     # There is no further call on connection.
     assert len(home._connection.mock_calls) == 3
diff --git a/tests/components/homematicip_cloud/test_config_flow.py b/tests/components/homematicip_cloud/test_config_flow.py
index d541bce4648..34b46e921eb 100644
--- a/tests/components/homematicip_cloud/test_config_flow.py
+++ b/tests/components/homematicip_cloud/test_config_flow.py
@@ -4,7 +4,7 @@ from unittest.mock import patch
 
 from homeassistant import config_entries
 from homeassistant.components.homematicip_cloud.const import (
-    DOMAIN as HMIPC_DOMAIN,
+    DOMAIN,
     HMIPC_AUTHTOKEN,
     HMIPC_HAPID,
     HMIPC_NAME,
@@ -34,7 +34,7 @@ async def test_flow_works(hass: HomeAssistant, simple_mock_home) -> None:
         ),
     ):
         result = await hass.config_entries.flow.async_init(
-            HMIPC_DOMAIN,
+            DOMAIN,
             context={"source": config_entries.SOURCE_USER},
             data=DEFAULT_CONFIG,
         )
@@ -84,7 +84,7 @@ async def test_flow_init_connection_error(hass: HomeAssistant) -> None:
         return_value=False,
     ):
         result = await hass.config_entries.flow.async_init(
-            HMIPC_DOMAIN,
+            DOMAIN,
             context={"source": config_entries.SOURCE_USER},
             data=DEFAULT_CONFIG,
         )
@@ -110,7 +110,7 @@ async def test_flow_link_connection_error(hass: HomeAssistant) -> None:
         ),
     ):
         result = await hass.config_entries.flow.async_init(
-            HMIPC_DOMAIN,
+            DOMAIN,
             context={"source": config_entries.SOURCE_USER},
             data=DEFAULT_CONFIG,
         )
@@ -132,7 +132,7 @@ async def test_flow_link_press_button(hass: HomeAssistant) -> None:
         ),
     ):
         result = await hass.config_entries.flow.async_init(
-            HMIPC_DOMAIN,
+            DOMAIN,
             context={"source": config_entries.SOURCE_USER},
             data=DEFAULT_CONFIG,
         )
@@ -146,7 +146,7 @@ async def test_init_flow_show_form(hass: HomeAssistant) -> None:
     """Test config flow shows up with a form."""
 
     result = await hass.config_entries.flow.async_init(
-        HMIPC_DOMAIN, context={"source": config_entries.SOURCE_USER}
+        DOMAIN, context={"source": config_entries.SOURCE_USER}
     )
     assert result["type"] is FlowResultType.FORM
     assert result["step_id"] == "init"
@@ -154,13 +154,13 @@ async def test_init_flow_show_form(hass: HomeAssistant) -> None:
 
 async def test_init_already_configured(hass: HomeAssistant) -> None:
     """Test accesspoint is already configured."""
-    MockConfigEntry(domain=HMIPC_DOMAIN, unique_id="ABC123").add_to_hass(hass)
+    MockConfigEntry(domain=DOMAIN, unique_id="ABC123").add_to_hass(hass)
     with patch(
         "homeassistant.components.homematicip_cloud.hap.HomematicipAuth.async_checkbutton",
         return_value=True,
     ):
         result = await hass.config_entries.flow.async_init(
-            HMIPC_DOMAIN,
+            DOMAIN,
             context={"source": config_entries.SOURCE_USER},
             data=DEFAULT_CONFIG,
         )
@@ -189,7 +189,7 @@ async def test_import_config(hass: HomeAssistant, simple_mock_home) -> None:
         ),
     ):
         result = await hass.config_entries.flow.async_init(
-            HMIPC_DOMAIN,
+            DOMAIN,
             context={"source": config_entries.SOURCE_IMPORT},
             data=IMPORT_CONFIG,
         )
@@ -202,7 +202,7 @@ async def test_import_config(hass: HomeAssistant, simple_mock_home) -> None:
 
 async def test_import_existing_config(hass: HomeAssistant) -> None:
     """Test abort of an existing accesspoint from config."""
-    MockConfigEntry(domain=HMIPC_DOMAIN, unique_id="ABC123").add_to_hass(hass)
+    MockConfigEntry(domain=DOMAIN, unique_id="ABC123").add_to_hass(hass)
     with (
         patch(
             "homeassistant.components.homematicip_cloud.hap.HomematicipAuth.async_checkbutton",
@@ -218,7 +218,7 @@ async def test_import_existing_config(hass: HomeAssistant) -> None:
         ),
     ):
         result = await hass.config_entries.flow.async_init(
-            HMIPC_DOMAIN,
+            DOMAIN,
             context={"source": config_entries.SOURCE_IMPORT},
             data=IMPORT_CONFIG,
         )
diff --git a/tests/components/homematicip_cloud/test_hap.py b/tests/components/homematicip_cloud/test_hap.py
index 13aaa4d83ba..2cd41161dde 100644
--- a/tests/components/homematicip_cloud/test_hap.py
+++ b/tests/components/homematicip_cloud/test_hap.py
@@ -7,7 +7,7 @@ from homematicip.connection.connection_context import ConnectionContext
 from homematicip.exceptions.connection_exceptions import HmipConnectionError
 import pytest
 
-from homeassistant.components.homematicip_cloud import DOMAIN as HMIPC_DOMAIN
+from homeassistant.components.homematicip_cloud import DOMAIN
 from homeassistant.components.homematicip_cloud.const import (
     HMIPC_AUTHTOKEN,
     HMIPC_HAPID,
@@ -83,7 +83,7 @@ async def test_hap_setup_works(hass: HomeAssistant) -> None:
     """Test a successful setup of a accesspoint."""
     # This test should not be accessing the integration internals
     entry = MockConfigEntry(
-        domain=HMIPC_DOMAIN,
+        domain=DOMAIN,
         data={HMIPC_HAPID: "ABC123", HMIPC_AUTHTOKEN: "123", HMIPC_NAME: "hmip"},
     )
     home = Mock()
@@ -99,7 +99,7 @@ async def test_hap_setup_connection_error() -> None:
     """Test a failed accesspoint setup."""
     hass = Mock()
     entry = MockConfigEntry(
-        domain=HMIPC_DOMAIN,
+        domain=DOMAIN,
         data={HMIPC_HAPID: "ABC123", HMIPC_AUTHTOKEN: "123", HMIPC_NAME: "hmip"},
     )
     hap = HomematicipHAP(hass, entry)
@@ -119,7 +119,7 @@ async def test_hap_reset_unloads_entry_if_setup(
 ) -> None:
     """Test calling reset while the entry has been setup."""
     mock_hap = await default_mock_hap_factory.async_get_mock_hap()
-    config_entries = hass.config_entries.async_entries(HMIPC_DOMAIN)
+    config_entries = hass.config_entries.async_entries(DOMAIN)
     assert len(config_entries) == 1
     assert config_entries[0].runtime_data == mock_hap
     # hap_reset is called during unload
@@ -132,7 +132,7 @@ async def test_hap_create(
     hass: HomeAssistant, hmip_config_entry: MockConfigEntry, simple_mock_home
 ) -> None:
     """Mock AsyncHome to execute get_hap."""
-    hass.config.components.add(HMIPC_DOMAIN)
+    hass.config.components.add(DOMAIN)
     hap = HomematicipHAP(hass, hmip_config_entry)
     assert hap
     with (
@@ -150,7 +150,7 @@ async def test_hap_create_exception(
     hass: HomeAssistant, hmip_config_entry: MockConfigEntry, mock_connection_init
 ) -> None:
     """Mock AsyncHome to execute get_hap."""
-    hass.config.components.add(HMIPC_DOMAIN)
+    hass.config.components.add(DOMAIN)
 
     hap = HomematicipHAP(hass, hmip_config_entry)
     assert hap
diff --git a/tests/components/homematicip_cloud/test_init.py b/tests/components/homematicip_cloud/test_init.py
index 172119a556c..852935af24b 100644
--- a/tests/components/homematicip_cloud/test_init.py
+++ b/tests/components/homematicip_cloud/test_init.py
@@ -8,7 +8,7 @@ from homematicip.exceptions.connection_exceptions import HmipConnectionError
 from homeassistant.components.homematicip_cloud.const import (
     CONF_ACCESSPOINT,
     CONF_AUTHTOKEN,
-    DOMAIN as HMIPC_DOMAIN,
+    DOMAIN,
     HMIPC_AUTHTOKEN,
     HMIPC_HAPID,
     HMIPC_NAME,
@@ -33,17 +33,15 @@ async def test_config_with_accesspoint_passed_to_config_entry(
         CONF_NAME: "name",
     }
     # no config_entry exists
-    assert len(hass.config_entries.async_entries(HMIPC_DOMAIN)) == 0
+    assert len(hass.config_entries.async_entries(DOMAIN)) == 0
 
     with patch(
         "homeassistant.components.homematicip_cloud.hap.HomematicipHAP.async_connect",
     ):
-        assert await async_setup_component(
-            hass, HMIPC_DOMAIN, {HMIPC_DOMAIN: entry_config}
-        )
+        assert await async_setup_component(hass, DOMAIN, {DOMAIN: entry_config})
 
     # config_entry created for access point
-    config_entries = hass.config_entries.async_entries(HMIPC_DOMAIN)
+    config_entries = hass.config_entries.async_entries(DOMAIN)
     assert len(config_entries) == 1
     assert config_entries[0].data == {
         "authtoken": "123",
@@ -60,10 +58,10 @@ async def test_config_already_registered_not_passed_to_config_entry(
     """Test that an already registered accesspoint does not get imported."""
 
     mock_config = {HMIPC_AUTHTOKEN: "123", HMIPC_HAPID: "ABC123", HMIPC_NAME: "name"}
-    MockConfigEntry(domain=HMIPC_DOMAIN, data=mock_config).add_to_hass(hass)
+    MockConfigEntry(domain=DOMAIN, data=mock_config).add_to_hass(hass)
 
     # one config_entry exists
-    config_entries = hass.config_entries.async_entries(HMIPC_DOMAIN)
+    config_entries = hass.config_entries.async_entries(DOMAIN)
     assert len(config_entries) == 1
     assert config_entries[0].data == {
         "authtoken": "123",
@@ -82,12 +80,10 @@ async def test_config_already_registered_not_passed_to_config_entry(
     with patch(
         "homeassistant.components.homematicip_cloud.hap.HomematicipHAP.async_connect",
     ):
-        assert await async_setup_component(
-            hass, HMIPC_DOMAIN, {HMIPC_DOMAIN: entry_config}
-        )
+        assert await async_setup_component(hass, DOMAIN, {DOMAIN: entry_config})
 
     # no new config_entry created / still one config_entry
-    config_entries = hass.config_entries.async_entries(HMIPC_DOMAIN)
+    config_entries = hass.config_entries.async_entries(DOMAIN)
     assert len(config_entries) == 1
     assert config_entries[0].data == {
         "authtoken": "123",
@@ -114,7 +110,7 @@ async def test_load_entry_fails_due_to_connection_error(
             return_value=ConnectionContext(),
         ),
     ):
-        assert await async_setup_component(hass, HMIPC_DOMAIN, {})
+        assert await async_setup_component(hass, DOMAIN, {})
 
     assert hmip_config_entry.runtime_data
     assert hmip_config_entry.state is ConfigEntryState.SETUP_RETRY
@@ -132,7 +128,7 @@ async def test_load_entry_fails_due_to_generic_exception(
             side_effect=Exception,
         ),
     ):
-        assert await async_setup_component(hass, HMIPC_DOMAIN, {})
+        assert await async_setup_component(hass, DOMAIN, {})
 
     assert hmip_config_entry.runtime_data
     assert hmip_config_entry.state is ConfigEntryState.SETUP_ERROR
@@ -141,7 +137,7 @@ async def test_load_entry_fails_due_to_generic_exception(
 async def test_unload_entry(hass: HomeAssistant) -> None:
     """Test being able to unload an entry."""
     mock_config = {HMIPC_AUTHTOKEN: "123", HMIPC_HAPID: "ABC123", HMIPC_NAME: "name"}
-    MockConfigEntry(domain=HMIPC_DOMAIN, data=mock_config).add_to_hass(hass)
+    MockConfigEntry(domain=DOMAIN, data=mock_config).add_to_hass(hass)
 
     with patch("homeassistant.components.homematicip_cloud.HomematicipHAP") as mock_hap:
         instance = mock_hap.return_value
@@ -153,11 +149,11 @@ async def test_unload_entry(hass: HomeAssistant) -> None:
         instance.home.currentAPVersion = "mock-ap-version"
         instance.async_reset = AsyncMock(return_value=True)
 
-        assert await async_setup_component(hass, HMIPC_DOMAIN, {})
+        assert await async_setup_component(hass, DOMAIN, {})
 
     assert mock_hap.return_value.mock_calls[0][0] == "async_setup"
 
-    config_entries = hass.config_entries.async_entries(HMIPC_DOMAIN)
+    config_entries = hass.config_entries.async_entries(DOMAIN)
     assert len(config_entries) == 1
     assert config_entries[0].runtime_data
     assert config_entries[0].state is ConfigEntryState.LOADED
@@ -183,7 +179,7 @@ async def test_hmip_dump_hap_config_services(
 async def test_setup_services_and_unload_services(hass: HomeAssistant) -> None:
     """Test setup services and unload services."""
     mock_config = {HMIPC_AUTHTOKEN: "123", HMIPC_HAPID: "ABC123", HMIPC_NAME: "name"}
-    MockConfigEntry(domain=HMIPC_DOMAIN, data=mock_config).add_to_hass(hass)
+    MockConfigEntry(domain=DOMAIN, data=mock_config).add_to_hass(hass)
 
     with patch("homeassistant.components.homematicip_cloud.HomematicipHAP") as mock_hap:
         instance = mock_hap.return_value
@@ -195,18 +191,18 @@ async def test_setup_services_and_unload_services(hass: HomeAssistant) -> None:
         instance.home.currentAPVersion = "mock-ap-version"
         instance.async_reset = AsyncMock(return_value=True)
 
-        assert await async_setup_component(hass, HMIPC_DOMAIN, {})
+        assert await async_setup_component(hass, DOMAIN, {})
 
     # Check services are created
-    hmipc_services = hass.services.async_services()[HMIPC_DOMAIN]
+    hmipc_services = hass.services.async_services()[DOMAIN]
     assert len(hmipc_services) == 9
 
-    config_entries = hass.config_entries.async_entries(HMIPC_DOMAIN)
+    config_entries = hass.config_entries.async_entries(DOMAIN)
     assert len(config_entries) == 1
 
     await hass.config_entries.async_unload(config_entries[0].entry_id)
     # Check services are removed
-    assert not hass.services.async_services().get(HMIPC_DOMAIN)
+    assert not hass.services.async_services().get(DOMAIN)
 
 
 async def test_setup_two_haps_unload_one_by_one(hass: HomeAssistant) -> None:
@@ -214,10 +210,10 @@ async def test_setup_two_haps_unload_one_by_one(hass: HomeAssistant) -> None:
 
     # Setup AP1
     mock_config = {HMIPC_AUTHTOKEN: "123", HMIPC_HAPID: "ABC123", HMIPC_NAME: "name"}
-    MockConfigEntry(domain=HMIPC_DOMAIN, data=mock_config).add_to_hass(hass)
+    MockConfigEntry(domain=DOMAIN, data=mock_config).add_to_hass(hass)
     # Setup AP2
     mock_config2 = {HMIPC_AUTHTOKEN: "123", HMIPC_HAPID: "ABC1234", HMIPC_NAME: "name2"}
-    MockConfigEntry(domain=HMIPC_DOMAIN, data=mock_config2).add_to_hass(hass)
+    MockConfigEntry(domain=DOMAIN, data=mock_config2).add_to_hass(hass)
 
     with patch("homeassistant.components.homematicip_cloud.HomematicipHAP") as mock_hap:
         instance = mock_hap.return_value
@@ -229,22 +225,22 @@ async def test_setup_two_haps_unload_one_by_one(hass: HomeAssistant) -> None:
         instance.home.currentAPVersion = "mock-ap-version"
         instance.async_reset = AsyncMock(return_value=True)
 
-        assert await async_setup_component(hass, HMIPC_DOMAIN, {})
+        assert await async_setup_component(hass, DOMAIN, {})
 
-    hmipc_services = hass.services.async_services()[HMIPC_DOMAIN]
+    hmipc_services = hass.services.async_services()[DOMAIN]
     assert len(hmipc_services) == 9
 
-    config_entries = hass.config_entries.async_entries(HMIPC_DOMAIN)
+    config_entries = hass.config_entries.async_entries(DOMAIN)
     assert len(config_entries) == 2
     # unload the first AP
     await hass.config_entries.async_unload(config_entries[0].entry_id)
 
     # services still exists
-    hmipc_services = hass.services.async_services()[HMIPC_DOMAIN]
+    hmipc_services = hass.services.async_services()[DOMAIN]
     assert len(hmipc_services) == 9
 
     # unload the second AP
     await hass.config_entries.async_unload(config_entries[1].entry_id)
 
     # Check services are removed
-    assert not hass.services.async_services().get(HMIPC_DOMAIN)
+    assert not hass.services.async_services().get(DOMAIN)
diff --git a/tests/components/humidifier/conftest.py b/tests/components/humidifier/conftest.py
index 9fe1720ffc0..c03f9faf87e 100644
--- a/tests/components/humidifier/conftest.py
+++ b/tests/components/humidifier/conftest.py
@@ -4,7 +4,6 @@ from collections.abc import Generator
 
 import pytest
 
-from homeassistant.components.humidifier import DOMAIN as HUMIDIFIER_DOMAIN
 from homeassistant.config_entries import ConfigEntry, ConfigFlow
 from homeassistant.const import Platform
 from homeassistant.core import HomeAssistant
@@ -45,7 +44,7 @@ def register_test_integration(
     ) -> bool:
         """Set up test config entry."""
         await hass.config_entries.async_forward_entry_setups(
-            config_entry, [HUMIDIFIER_DOMAIN]
+            config_entry, [Platform.HUMIDIFIER]
         )
         return True
 
diff --git a/tests/components/humidifier/test_init.py b/tests/components/humidifier/test_init.py
index ce54863736b..57bde05ccbc 100644
--- a/tests/components/humidifier/test_init.py
+++ b/tests/components/humidifier/test_init.py
@@ -6,7 +6,7 @@ import pytest
 
 from homeassistant.components.humidifier import (
     ATTR_HUMIDITY,
-    DOMAIN as HUMIDIFIER_DOMAIN,
+    DOMAIN,
     MODE_ECO,
     MODE_NORMAL,
     SERVICE_SET_HUMIDITY,
@@ -77,7 +77,7 @@ async def test_humidity_validation(
     )
 
     setup_test_component_platform(
-        hass, HUMIDIFIER_DOMAIN, entities=[test_humidifier], from_config_entry=True
+        hass, DOMAIN, entities=[test_humidifier], from_config_entry=True
     )
     await hass.config_entries.async_setup(register_test_integration.entry_id)
     await hass.async_block_till_done()
@@ -90,7 +90,7 @@ async def test_humidity_validation(
         match="Provided humidity 1 is not valid. Accepted range is 50 to 60",
     ) as exc:
         await hass.services.async_call(
-            HUMIDIFIER_DOMAIN,
+            DOMAIN,
             SERVICE_SET_HUMIDITY,
             {
                 "entity_id": "humidifier.test",
@@ -107,7 +107,7 @@ async def test_humidity_validation(
         match="Provided humidity 70 is not valid. Accepted range is 50 to 60",
     ) as exc:
         await hass.services.async_call(
-            HUMIDIFIER_DOMAIN,
+            DOMAIN,
             SERVICE_SET_HUMIDITY,
             {
                 "entity_id": "humidifier.test",
diff --git a/tests/components/husqvarna_automower/test_config_flow.py b/tests/components/husqvarna_automower/test_config_flow.py
index d91078d80a2..9c5c040d456 100644
--- a/tests/components/husqvarna_automower/test_config_flow.py
+++ b/tests/components/husqvarna_automower/test_config_flow.py
@@ -20,7 +20,7 @@ from homeassistant.helpers import config_entry_oauth2_flow
 from . import setup_integration
 from .const import CLIENT_ID, USER_ID
 
-from tests.common import MockConfigEntry, load_fixture
+from tests.common import MockConfigEntry, async_load_fixture
 from tests.test_util.aiohttp import AiohttpClientMocker
 from tests.typing import ClientSessionGenerator
 
@@ -84,7 +84,7 @@ async def test_full_flow(
     )
     aioclient_mock.get(
         f"{API_BASE_URL}/{AutomowerEndpoint.mowers}",
-        text=load_fixture(fixture, DOMAIN),
+        text=await async_load_fixture(hass, fixture, DOMAIN),
         exc=exception,
     )
     with (
diff --git a/tests/components/image/conftest.py b/tests/components/image/conftest.py
index 6879bc793bb..0e8b79e751d 100644
--- a/tests/components/image/conftest.py
+++ b/tests/components/image/conftest.py
@@ -6,6 +6,7 @@ import pytest
 
 from homeassistant.components import image
 from homeassistant.config_entries import ConfigEntry, ConfigFlow
+from homeassistant.const import Platform
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.entity_platform import (
     AddConfigEntryEntitiesCallback,
@@ -176,7 +177,7 @@ async def mock_image_config_entry_fixture(
     ) -> bool:
         """Set up test config entry."""
         await hass.config_entries.async_forward_entry_setups(
-            config_entry, [image.DOMAIN]
+            config_entry, [Platform.IMAGE]
         )
         return True
 
@@ -184,7 +185,7 @@ async def mock_image_config_entry_fixture(
         hass: HomeAssistant, config_entry: ConfigEntry
     ) -> bool:
         """Unload test config entry."""
-        await hass.config_entries.async_unload_platforms(config_entry, [image.DOMAIN])
+        await hass.config_entries.async_unload_platforms(config_entry, [Platform.IMAGE])
         return True
 
     mock_integration(
diff --git a/tests/components/immich/test_media_source.py b/tests/components/immich/test_media_source.py
index c8da8d94eeb..5b396a780cc 100644
--- a/tests/components/immich/test_media_source.py
+++ b/tests/components/immich/test_media_source.py
@@ -43,9 +43,15 @@ async def test_get_media_source(hass: HomeAssistant) -> None:
 @pytest.mark.parametrize(
     ("identifier", "exception_msg"),
     [
-        ("unique_id", "No file name"),
-        ("unique_id/album_id", "No file name"),
-        ("unique_id/album_id/asset_id/filename", "No file extension"),
+        ("unique_id", "Could not resolve identifier that has no mime-type"),
+        (
+            "unique_id|albums|album_id",
+            "Could not resolve identifier that has no mime-type",
+        ),
+        (
+            "unique_id|albums|album_id|asset_id|filename",
+            "Could not parse identifier",
+        ),
     ],
 )
 async def test_resolve_media_bad_identifier(
@@ -64,15 +70,20 @@ async def test_resolve_media_bad_identifier(
     ("identifier", "url", "mime_type"),
     [
         (
-            "unique_id/album_id/asset_id/filename.jpg",
-            "/immich/unique_id/asset_id/filename.jpg/fullsize",
+            "unique_id|albums|album_id|asset_id|filename.jpg|image/jpeg",
+            "/immich/unique_id/asset_id/fullsize/image/jpeg",
             "image/jpeg",
         ),
         (
-            "unique_id/album_id/asset_id/filename.png",
-            "/immich/unique_id/asset_id/filename.png/fullsize",
+            "unique_id|albums|album_id|asset_id|filename.png|image/png",
+            "/immich/unique_id/asset_id/fullsize/image/png",
             "image/png",
         ),
+        (
+            "unique_id|albums|album_id|asset_id|filename.mp4|video/mp4",
+            "/immich/unique_id/asset_id/fullsize/video/mp4",
+            "video/mp4",
+        ),
     ],
 )
 async def test_resolve_media_success(
@@ -95,13 +106,82 @@ async def test_browse_media_unconfigured(hass: HomeAssistant) -> None:
 
     source = await async_get_media_source(hass)
     item = MediaSourceItem(
-        hass, DOMAIN, "unique_id/album_id/asset_id/filename.png", None
+        hass, DOMAIN, "unique_id/albums/album_id/asset_id/filename.png", None
     )
     with pytest.raises(BrowseError, match="Immich is not configured"):
         await source.async_browse_media(item)
 
 
-async def test_browse_media_album_error(
+async def test_browse_media_get_root(
+    hass: HomeAssistant,
+    mock_immich: Mock,
+    mock_config_entry: MockConfigEntry,
+) -> None:
+    """Test browse_media returning root media sources."""
+    assert await async_setup_component(hass, "media_source", {})
+
+    with patch("homeassistant.components.immich.PLATFORMS", []):
+        await setup_integration(hass, mock_config_entry)
+
+    source = await async_get_media_source(hass)
+
+    # get root
+    item = MediaSourceItem(hass, DOMAIN, "", None)
+    result = await source.async_browse_media(item)
+
+    assert result
+    assert len(result.children) == 1
+    media_file = result.children[0]
+    assert isinstance(media_file, BrowseMedia)
+    assert media_file.title == "Someone"
+    assert media_file.media_content_id == (
+        "media-source://immich/e7ef5713-9dab-4bd4-b899-715b0ca4379e"
+    )
+
+    # get collections
+    item = MediaSourceItem(hass, DOMAIN, "e7ef5713-9dab-4bd4-b899-715b0ca4379e", None)
+    result = await source.async_browse_media(item)
+
+    assert result
+    assert len(result.children) == 1
+    media_file = result.children[0]
+    assert isinstance(media_file, BrowseMedia)
+    assert media_file.title == "albums"
+    assert media_file.media_content_id == (
+        "media-source://immich/e7ef5713-9dab-4bd4-b899-715b0ca4379e|albums"
+    )
+
+
+async def test_browse_media_get_albums(
+    hass: HomeAssistant,
+    mock_immich: Mock,
+    mock_config_entry: MockConfigEntry,
+) -> None:
+    """Test browse_media returning albums."""
+    assert await async_setup_component(hass, "media_source", {})
+
+    with patch("homeassistant.components.immich.PLATFORMS", []):
+        await setup_integration(hass, mock_config_entry)
+
+    source = await async_get_media_source(hass)
+    item = MediaSourceItem(
+        hass, DOMAIN, "e7ef5713-9dab-4bd4-b899-715b0ca4379e|albums", None
+    )
+    result = await source.async_browse_media(item)
+
+    assert result
+    assert len(result.children) == 1
+    media_file = result.children[0]
+    assert isinstance(media_file, BrowseMedia)
+    assert media_file.title == "My Album"
+    assert media_file.media_content_id == (
+        "media-source://immich/"
+        "e7ef5713-9dab-4bd4-b899-715b0ca4379e|albums|"
+        "721e1a4b-aa12-441e-8d3b-5ac7ab283bb6"
+    )
+
+
+async def test_browse_media_get_albums_error(
     hass: HomeAssistant,
     mock_immich: Mock,
     mock_config_entry: MockConfigEntry,
@@ -124,7 +204,7 @@ async def test_browse_media_album_error(
 
     source = await async_get_media_source(hass)
 
-    item = MediaSourceItem(hass, DOMAIN, mock_config_entry.unique_id, None)
+    item = MediaSourceItem(hass, DOMAIN, f"{mock_config_entry.unique_id}|albums", None)
     result = await source.async_browse_media(item)
 
     assert result
@@ -132,59 +212,7 @@ async def test_browse_media_album_error(
     assert len(result.children) == 0
 
 
-async def test_browse_media_get_root(
-    hass: HomeAssistant,
-    mock_immich: Mock,
-    mock_config_entry: MockConfigEntry,
-) -> None:
-    """Test browse_media returning root media sources."""
-    assert await async_setup_component(hass, "media_source", {})
-
-    with patch("homeassistant.components.immich.PLATFORMS", []):
-        await setup_integration(hass, mock_config_entry)
-
-    source = await async_get_media_source(hass)
-    item = MediaSourceItem(hass, DOMAIN, "", None)
-    result = await source.async_browse_media(item)
-
-    assert result
-    assert len(result.children) == 1
-    media_file = result.children[0]
-    assert isinstance(media_file, BrowseMedia)
-    assert media_file.title == "Someone"
-    assert media_file.media_content_id == (
-        "media-source://immich/e7ef5713-9dab-4bd4-b899-715b0ca4379e"
-    )
-
-
-async def test_browse_media_get_albums(
-    hass: HomeAssistant,
-    mock_immich: Mock,
-    mock_config_entry: MockConfigEntry,
-) -> None:
-    """Test browse_media returning albums."""
-    assert await async_setup_component(hass, "media_source", {})
-
-    with patch("homeassistant.components.immich.PLATFORMS", []):
-        await setup_integration(hass, mock_config_entry)
-
-    source = await async_get_media_source(hass)
-    item = MediaSourceItem(hass, DOMAIN, "e7ef5713-9dab-4bd4-b899-715b0ca4379e", None)
-    result = await source.async_browse_media(item)
-
-    assert result
-    assert len(result.children) == 1
-    media_file = result.children[0]
-    assert isinstance(media_file, BrowseMedia)
-    assert media_file.title == "My Album"
-    assert media_file.media_content_id == (
-        "media-source://immich/"
-        "e7ef5713-9dab-4bd4-b899-715b0ca4379e/"
-        "721e1a4b-aa12-441e-8d3b-5ac7ab283bb6"
-    )
-
-
-async def test_browse_media_get_items_error(
+async def test_browse_media_get_album_items_error(
     hass: HomeAssistant,
     mock_immich: Mock,
     mock_config_entry: MockConfigEntry,
@@ -202,7 +230,7 @@ async def test_browse_media_get_items_error(
     item = MediaSourceItem(
         hass,
         DOMAIN,
-        "e7ef5713-9dab-4bd4-b899-715b0ca4379e/721e1a4b-aa12-441e-8d3b-5ac7ab283bb6",
+        "e7ef5713-9dab-4bd4-b899-715b0ca4379e|albums|721e1a4b-aa12-441e-8d3b-5ac7ab283bb6",
         None,
     )
     result = await source.async_browse_media(item)
@@ -223,7 +251,7 @@ async def test_browse_media_get_items_error(
     item = MediaSourceItem(
         hass,
         DOMAIN,
-        "e7ef5713-9dab-4bd4-b899-715b0ca4379e/721e1a4b-aa12-441e-8d3b-5ac7ab283bb6",
+        "e7ef5713-9dab-4bd4-b899-715b0ca4379e|albums|721e1a4b-aa12-441e-8d3b-5ac7ab283bb6",
         None,
     )
     result = await source.async_browse_media(item)
@@ -233,7 +261,7 @@ async def test_browse_media_get_items_error(
     assert len(result.children) == 0
 
 
-async def test_browse_media_get_items(
+async def test_browse_media_get_album_items(
     hass: HomeAssistant,
     mock_immich: Mock,
     mock_config_entry: MockConfigEntry,
@@ -249,7 +277,7 @@ async def test_browse_media_get_items(
     item = MediaSourceItem(
         hass,
         DOMAIN,
-        "e7ef5713-9dab-4bd4-b899-715b0ca4379e/721e1a4b-aa12-441e-8d3b-5ac7ab283bb6",
+        "e7ef5713-9dab-4bd4-b899-715b0ca4379e|albums|721e1a4b-aa12-441e-8d3b-5ac7ab283bb6",
         None,
     )
     result = await source.async_browse_media(item)
@@ -259,9 +287,9 @@ async def test_browse_media_get_items(
     media_file = result.children[0]
     assert isinstance(media_file, BrowseMedia)
     assert media_file.identifier == (
-        "e7ef5713-9dab-4bd4-b899-715b0ca4379e/"
-        "721e1a4b-aa12-441e-8d3b-5ac7ab283bb6/"
-        "2e94c203-50aa-4ad2-8e29-56dd74e0eff4/filename.jpg"
+        "e7ef5713-9dab-4bd4-b899-715b0ca4379e|albums|"
+        "721e1a4b-aa12-441e-8d3b-5ac7ab283bb6|"
+        "2e94c203-50aa-4ad2-8e29-56dd74e0eff4|filename.jpg|image/jpeg"
     )
     assert media_file.title == "filename.jpg"
     assert media_file.media_class == MediaClass.IMAGE
@@ -270,15 +298,15 @@ async def test_browse_media_get_items(
     assert not media_file.can_expand
     assert media_file.thumbnail == (
         "/immich/e7ef5713-9dab-4bd4-b899-715b0ca4379e/"
-        "2e94c203-50aa-4ad2-8e29-56dd74e0eff4/filename.jpg/thumbnail"
+        "2e94c203-50aa-4ad2-8e29-56dd74e0eff4/thumbnail/image/jpeg"
     )
 
     media_file = result.children[1]
     assert isinstance(media_file, BrowseMedia)
     assert media_file.identifier == (
-        "e7ef5713-9dab-4bd4-b899-715b0ca4379e/"
-        "721e1a4b-aa12-441e-8d3b-5ac7ab283bb6/"
-        "2e65a5f2-db83-44c4-81ab-f5ff20c9bd7b/filename.mp4"
+        "e7ef5713-9dab-4bd4-b899-715b0ca4379e|albums|"
+        "721e1a4b-aa12-441e-8d3b-5ac7ab283bb6|"
+        "2e65a5f2-db83-44c4-81ab-f5ff20c9bd7b|filename.mp4|video/mp4"
     )
     assert media_file.title == "filename.mp4"
     assert media_file.media_class == MediaClass.VIDEO
@@ -287,7 +315,7 @@ async def test_browse_media_get_items(
     assert not media_file.can_expand
     assert media_file.thumbnail == (
         "/immich/e7ef5713-9dab-4bd4-b899-715b0ca4379e/"
-        "2e65a5f2-db83-44c4-81ab-f5ff20c9bd7b/thumbnail.jpg/thumbnail"
+        "2e65a5f2-db83-44c4-81ab-f5ff20c9bd7b/thumbnail/image/jpeg"
     )
 
 
@@ -310,12 +338,12 @@ async def test_media_view(
     with patch("homeassistant.components.immich.PLATFORMS", []):
         await setup_integration(hass, mock_config_entry)
 
-    # wrong url (without file extension)
+    # wrong url (without mime type)
     with pytest.raises(web.HTTPNotFound):
         await view.get(
             request,
             "e7ef5713-9dab-4bd4-b899-715b0ca4379e",
-            "2e94c203-50aa-4ad2-8e29-56dd74e0eff4/filename/thumbnail",
+            "2e94c203-50aa-4ad2-8e29-56dd74e0eff4/thumbnail",
         )
 
     # exception in async_view_asset()
@@ -331,7 +359,7 @@ async def test_media_view(
         await view.get(
             request,
             "e7ef5713-9dab-4bd4-b899-715b0ca4379e",
-            "2e94c203-50aa-4ad2-8e29-56dd74e0eff4/filename.jpg/thumbnail",
+            "2e94c203-50aa-4ad2-8e29-56dd74e0eff4/thumbnail/image/jpeg",
         )
 
     # exception in async_play_video_stream()
@@ -347,7 +375,7 @@ async def test_media_view(
         await view.get(
             request,
             "e7ef5713-9dab-4bd4-b899-715b0ca4379e",
-            "2e65a5f2-db83-44c4-81ab-f5ff20c9bd7b/filename.mp4/fullsize",
+            "2e65a5f2-db83-44c4-81ab-f5ff20c9bd7b/fullsize/video/mp4",
         )
 
     # success
@@ -357,14 +385,14 @@ async def test_media_view(
         result = await view.get(
             request,
             "e7ef5713-9dab-4bd4-b899-715b0ca4379e",
-            "2e94c203-50aa-4ad2-8e29-56dd74e0eff4/filename.jpg/thumbnail",
+            "2e94c203-50aa-4ad2-8e29-56dd74e0eff4/thumbnail/image/jpeg",
         )
         assert isinstance(result, web.Response)
     with patch.object(tempfile, "tempdir", tmp_path):
         result = await view.get(
             request,
             "e7ef5713-9dab-4bd4-b899-715b0ca4379e",
-            "2e94c203-50aa-4ad2-8e29-56dd74e0eff4/filename.jpg/fullsize",
+            "2e94c203-50aa-4ad2-8e29-56dd74e0eff4/fullsize/image/jpeg",
         )
         assert isinstance(result, web.Response)
 
@@ -376,6 +404,6 @@ async def test_media_view(
         result = await view.get(
             request,
             "e7ef5713-9dab-4bd4-b899-715b0ca4379e",
-            "2e65a5f2-db83-44c4-81ab-f5ff20c9bd7b/filename.mp4/fullsize",
+            "2e65a5f2-db83-44c4-81ab-f5ff20c9bd7b/fullsize/video/mp4",
         )
         assert isinstance(result, web.StreamResponse)
diff --git a/tests/components/insteon/test_api_config.py b/tests/components/insteon/test_api_config.py
index 9c85ca6a706..9d38b70c850 100644
--- a/tests/components/insteon/test_api_config.py
+++ b/tests/components/insteon/test_api_config.py
@@ -10,6 +10,7 @@ from homeassistant.components.insteon.const import (
     CONF_HUB_VERSION,
     CONF_OVERRIDE,
     CONF_X10,
+    DOMAIN,
 )
 from homeassistant.core import HomeAssistant
 
@@ -24,7 +25,7 @@ from .mock_connection import mock_failed_connection, mock_successful_connection
 from .mock_devices import MockDevices
 from .mock_setup import async_mock_setup
 
-from tests.common import load_fixture
+from tests.common import async_load_fixture
 from tests.typing import WebSocketGenerator
 
 
@@ -404,7 +405,7 @@ async def test_get_broken_links(
     ws_client, _, _, _ = await async_mock_setup(hass, hass_ws_client)
     devices = MockDevices()
     await devices.async_load()
-    aldb_data = json.loads(load_fixture("insteon/aldb_data.json"))
+    aldb_data = json.loads(await async_load_fixture(hass, "aldb_data.json", DOMAIN))
     devices.fill_aldb("33.33.33", aldb_data)
     await asyncio.sleep(1)
     with patch.object(insteon.api.config, "devices", devices):
diff --git a/tests/components/intent/test_temperature.py b/tests/components/intent/test_temperature.py
index 622e55fe24a..5cd5fd1a6c3 100644
--- a/tests/components/intent/test_temperature.py
+++ b/tests/components/intent/test_temperature.py
@@ -61,7 +61,7 @@ def mock_setup_integration(hass: HomeAssistant) -> None:
     ) -> bool:
         """Set up test config entry."""
         await hass.config_entries.async_forward_entry_setups(
-            config_entry, [CLIMATE_DOMAIN]
+            config_entry, [Platform.CLIMATE]
         )
         return True
 
diff --git a/tests/components/ipp/conftest.py b/tests/components/ipp/conftest.py
index 9a47cc3c355..54b8ed60452 100644
--- a/tests/components/ipp/conftest.py
+++ b/tests/components/ipp/conftest.py
@@ -17,7 +17,7 @@ from homeassistant.const import (
 )
 from homeassistant.core import HomeAssistant
 
-from tests.common import MockConfigEntry, load_fixture
+from tests.common import MockConfigEntry, async_load_fixture
 
 
 @pytest.fixture
@@ -49,6 +49,7 @@ def mock_setup_entry() -> Generator[AsyncMock]:
 
 @pytest.fixture
 async def mock_printer(
+    hass: HomeAssistant,
     request: pytest.FixtureRequest,
 ) -> Printer:
     """Return the mocked printer."""
@@ -56,7 +57,7 @@ async def mock_printer(
     if hasattr(request, "param") and request.param:
         fixture = request.param
 
-    return Printer.from_dict(json.loads(load_fixture(fixture)))
+    return Printer.from_dict(json.loads(await async_load_fixture(hass, fixture)))
 
 
 @pytest.fixture
diff --git a/tests/components/keyboard/__init__.py b/tests/components/keyboard/__init__.py
new file mode 100644
index 00000000000..7bc8a91511f
--- /dev/null
+++ b/tests/components/keyboard/__init__.py
@@ -0,0 +1 @@
+"""Keyboard tests."""
diff --git a/tests/components/keyboard/test_init.py b/tests/components/keyboard/test_init.py
new file mode 100644
index 00000000000..f590c9dd1a4
--- /dev/null
+++ b/tests/components/keyboard/test_init.py
@@ -0,0 +1,29 @@
+"""Keyboard tests."""
+
+from unittest.mock import Mock, patch
+
+from homeassistant.core import DOMAIN as HOMEASSISTANT_DOMAIN, HomeAssistant
+from homeassistant.helpers import issue_registry as ir
+from homeassistant.setup import async_setup_component
+
+
+@patch.dict("sys.modules", pykeyboard=Mock())
+async def test_repair_issue_is_created(
+    hass: HomeAssistant,
+    issue_registry: ir.IssueRegistry,
+) -> None:
+    """Test repair issue is created."""
+    from homeassistant.components.keyboard import (  # pylint:disable=import-outside-toplevel
+        DOMAIN,
+    )
+
+    assert await async_setup_component(
+        hass,
+        DOMAIN,
+        {DOMAIN: {}},
+    )
+    await hass.async_block_till_done()
+    assert (
+        HOMEASSISTANT_DOMAIN,
+        f"deprecated_system_packages_yaml_integration_{DOMAIN}",
+    ) in issue_registry.issues
diff --git a/tests/components/knx/conftest.py b/tests/components/knx/conftest.py
index 0e054f5eb9c..4eefe3166b5 100644
--- a/tests/components/knx/conftest.py
+++ b/tests/components/knx/conftest.py
@@ -26,7 +26,7 @@ from homeassistant.components.knx.const import (
     CONF_KNX_RATE_LIMIT,
     CONF_KNX_STATE_UPDATER,
     DEFAULT_ROUTING_IA,
-    DOMAIN as KNX_DOMAIN,
+    DOMAIN,
 )
 from homeassistant.components.knx.project import STORAGE_KEY as KNX_PROJECT_STORAGE_KEY
 from homeassistant.components.knx.storage.config_store import (
@@ -47,7 +47,7 @@ from tests.common import (
 )
 from tests.typing import WebSocketGenerator
 
-FIXTURE_PROJECT_DATA = load_json_object_fixture("project.json", KNX_DOMAIN)
+FIXTURE_PROJECT_DATA = load_json_object_fixture("project.json", DOMAIN)
 
 
 class KNXTestKit:
@@ -117,19 +117,19 @@ class KNXTestKit:
             self.hass_storage[
                 KNX_CONFIG_STORAGE_KEY
             ] = await async_load_json_object_fixture(
-                self.hass, config_store_fixture, KNX_DOMAIN
+                self.hass, config_store_fixture, DOMAIN
             )
 
         if add_entry_to_hass:
             self.mock_config_entry.add_to_hass(self.hass)
 
-        knx_config = {KNX_DOMAIN: yaml_config or {}}
+        knx_config = {DOMAIN: yaml_config or {}}
         with patch(
             "xknx.xknx.knx_interface_factory",
             return_value=knx_ip_interface_mock(),
             side_effect=fish_xknx,
         ):
-            await async_setup_component(self.hass, KNX_DOMAIN, knx_config)
+            await async_setup_component(self.hass, DOMAIN, knx_config)
             await self.hass.async_block_till_done()
 
     ########################
@@ -313,7 +313,7 @@ def mock_config_entry() -> MockConfigEntry:
     """Return the default mocked config entry."""
     return MockConfigEntry(
         title="KNX",
-        domain=KNX_DOMAIN,
+        domain=DOMAIN,
         data={
             CONF_KNX_CONNECTION_TYPE: CONF_KNX_AUTOMATIC,
             CONF_KNX_RATE_LIMIT: CONF_KNX_DEFAULT_RATE_LIMIT,
diff --git a/tests/components/knx/test_diagnostic.py b/tests/components/knx/test_diagnostic.py
index 3f8bc805855..1b63e4a3f9a 100644
--- a/tests/components/knx/test_diagnostic.py
+++ b/tests/components/knx/test_diagnostic.py
@@ -21,7 +21,7 @@ from homeassistant.components.knx.const import (
     CONF_KNX_SECURE_USER_PASSWORD,
     CONF_KNX_STATE_UPDATER,
     DEFAULT_ROUTING_IA,
-    DOMAIN as KNX_DOMAIN,
+    DOMAIN,
 )
 from homeassistant.core import HomeAssistant
 
@@ -84,7 +84,7 @@ async def test_diagnostic_redact(
     """Test diagnostics redacting data."""
     mock_config_entry: MockConfigEntry = MockConfigEntry(
         title="KNX",
-        domain=KNX_DOMAIN,
+        domain=DOMAIN,
         data={
             CONF_KNX_CONNECTION_TYPE: CONF_KNX_AUTOMATIC,
             CONF_KNX_RATE_LIMIT: CONF_KNX_DEFAULT_RATE_LIMIT,
diff --git a/tests/components/knx/test_init.py b/tests/components/knx/test_init.py
index 579f9b143a2..a26bdc34a36 100644
--- a/tests/components/knx/test_init.py
+++ b/tests/components/knx/test_init.py
@@ -41,7 +41,7 @@ from homeassistant.components.knx.const import (
     CONF_KNX_TUNNELING,
     CONF_KNX_TUNNELING_TCP,
     CONF_KNX_TUNNELING_TCP_SECURE,
-    DOMAIN as KNX_DOMAIN,
+    DOMAIN,
     KNXConfigEntryData,
 )
 from homeassistant.config_entries import ConfigEntryState
@@ -222,17 +222,15 @@ async def test_init_connection_handling(
 
     config_entry = MockConfigEntry(
         title="KNX",
-        domain=KNX_DOMAIN,
+        domain=DOMAIN,
         data=config_entry_data,
     )
     knx.mock_config_entry = config_entry
     await knx.setup_integration()
 
-    assert hass.data.get(KNX_DOMAIN) is not None
+    assert hass.data.get(DOMAIN) is not None
 
-    original_connection_config = (
-        hass.data[KNX_DOMAIN].connection_config().__dict__.copy()
-    )
+    original_connection_config = hass.data[DOMAIN].connection_config().__dict__.copy()
     del original_connection_config["secure_config"]
 
     connection_config_dict = connection_config.__dict__.copy()
@@ -242,19 +240,19 @@ async def test_init_connection_handling(
 
     if connection_config.secure_config is not None:
         assert (
-            hass.data[KNX_DOMAIN].connection_config().secure_config.knxkeys_password
+            hass.data[DOMAIN].connection_config().secure_config.knxkeys_password
             == connection_config.secure_config.knxkeys_password
         )
         assert (
-            hass.data[KNX_DOMAIN].connection_config().secure_config.user_password
+            hass.data[DOMAIN].connection_config().secure_config.user_password
             == connection_config.secure_config.user_password
         )
         assert (
-            hass.data[KNX_DOMAIN].connection_config().secure_config.user_id
+            hass.data[DOMAIN].connection_config().secure_config.user_id
             == connection_config.secure_config.user_id
         )
         assert (
-            hass.data[KNX_DOMAIN]
+            hass.data[DOMAIN]
             .connection_config()
             .secure_config.device_authentication_password
             == connection_config.secure_config.device_authentication_password
@@ -262,9 +260,7 @@ async def test_init_connection_handling(
         if connection_config.secure_config.knxkeys_file_path is not None:
             assert (
                 connection_config.secure_config.knxkeys_file_path
-                in hass.data[KNX_DOMAIN]
-                .connection_config()
-                .secure_config.knxkeys_file_path
+                in hass.data[DOMAIN].connection_config().secure_config.knxkeys_file_path
             )
 
 
@@ -276,9 +272,7 @@ async def _init_switch_and_wait_for_first_state_updater_run(
     config_entry_data: KNXConfigEntryData,
 ) -> None:
     """Return a config entry with default data."""
-    config_entry = MockConfigEntry(
-        title="KNX", domain=KNX_DOMAIN, data=config_entry_data
-    )
+    config_entry = MockConfigEntry(title="KNX", domain=DOMAIN, data=config_entry_data)
     knx.mock_config_entry = config_entry
     await knx.setup_integration()
     await create_ui_entity(
@@ -348,7 +342,7 @@ async def test_async_remove_entry(
     """Test async_setup_entry (for coverage)."""
     config_entry = MockConfigEntry(
         title="KNX",
-        domain=KNX_DOMAIN,
+        domain=DOMAIN,
         data={
             CONF_KNX_KNXKEY_FILENAME: "knx/testcase.knxkeys",
         },
diff --git a/tests/components/linkplay/test_diagnostics.py b/tests/components/linkplay/test_diagnostics.py
index 332359b9769..c14879f0018 100644
--- a/tests/components/linkplay/test_diagnostics.py
+++ b/tests/components/linkplay/test_diagnostics.py
@@ -13,7 +13,7 @@ from homeassistant.core import HomeAssistant
 from . import setup_integration
 from .conftest import HOST, mock_lp_aiohttp_client
 
-from tests.common import MockConfigEntry, load_fixture
+from tests.common import MockConfigEntry, async_load_fixture
 from tests.components.diagnostics import get_diagnostics_for_config_entry
 from tests.typing import ClientSessionGenerator
 
@@ -39,12 +39,12 @@ async def test_diagnostics(
         for endpoint in endpoints:
             mock_session.get(
                 API_ENDPOINT.format(str(endpoint), "getPlayerStatusEx"),
-                text=load_fixture("getPlayerEx.json", DOMAIN),
+                text=await async_load_fixture(hass, "getPlayerEx.json", DOMAIN),
             )
 
             mock_session.get(
                 API_ENDPOINT.format(str(endpoint), "getStatusEx"),
-                text=load_fixture("getStatusEx.json", DOMAIN),
+                text=await async_load_fixture(hass, "getStatusEx.json", DOMAIN),
             )
 
         await setup_integration(hass, mock_config_entry)
diff --git a/tests/components/lirc/__init__.py b/tests/components/lirc/__init__.py
new file mode 100644
index 00000000000..f8e11b194a6
--- /dev/null
+++ b/tests/components/lirc/__init__.py
@@ -0,0 +1 @@
+"""LIRC tests."""
diff --git a/tests/components/lirc/test_init.py b/tests/components/lirc/test_init.py
new file mode 100644
index 00000000000..d6fd7975c77
--- /dev/null
+++ b/tests/components/lirc/test_init.py
@@ -0,0 +1,31 @@
+"""Tests for the LIRC."""
+
+from unittest.mock import Mock, patch
+
+from homeassistant.core import DOMAIN as HOMEASSISTANT_DOMAIN, HomeAssistant
+from homeassistant.helpers import issue_registry as ir
+from homeassistant.setup import async_setup_component
+
+
+@patch.dict("sys.modules", lirc=Mock())
+async def test_repair_issue_is_created(
+    hass: HomeAssistant,
+    issue_registry: ir.IssueRegistry,
+) -> None:
+    """Test repair issue is created."""
+    from homeassistant.components.lirc import (  # pylint: disable=import-outside-toplevel
+        DOMAIN as LIRC_DOMAIN,
+    )
+
+    assert await async_setup_component(
+        hass,
+        LIRC_DOMAIN,
+        {
+            LIRC_DOMAIN: {},
+        },
+    )
+    await hass.async_block_till_done()
+    assert (
+        HOMEASSISTANT_DOMAIN,
+        f"deprecated_system_packages_yaml_integration_{LIRC_DOMAIN}",
+    ) in issue_registry.issues
diff --git a/tests/components/lock/conftest.py b/tests/components/lock/conftest.py
index 254a59cae0d..9cfde2a6b06 100644
--- a/tests/components/lock/conftest.py
+++ b/tests/components/lock/conftest.py
@@ -12,6 +12,7 @@ from homeassistant.components.lock import (
     LockEntityFeature,
 )
 from homeassistant.config_entries import ConfigEntry, ConfigFlow
+from homeassistant.const import Platform
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers import entity_registry as er
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
@@ -99,7 +100,7 @@ async def setup_lock_platform_test_entity(
     ) -> bool:
         """Set up test config entry."""
         await hass.config_entries.async_forward_entry_setups(
-            config_entry, [LOCK_DOMAIN]
+            config_entry, [Platform.LOCK]
         )
         return True
 
diff --git a/tests/components/london_air/test_sensor.py b/tests/components/london_air/test_sensor.py
index d87d9257704..e5207719bbb 100644
--- a/tests/components/london_air/test_sensor.py
+++ b/tests/components/london_air/test_sensor.py
@@ -8,7 +8,7 @@ from homeassistant.components.london_air.sensor import CONF_LOCATIONS, URL
 from homeassistant.core import HomeAssistant
 from homeassistant.setup import async_setup_component
 
-from tests.common import load_fixture
+from tests.common import async_load_fixture
 
 VALID_CONFIG = {"sensor": {"platform": "london_air", CONF_LOCATIONS: ["Merton"]}}
 
@@ -19,7 +19,7 @@ async def test_valid_state(
     """Test for operational london_air sensor with proper attributes."""
     requests_mock.get(
         URL,
-        text=load_fixture("london_air.json", "london_air"),
+        text=await async_load_fixture(hass, "london_air.json", "london_air"),
         status_code=HTTPStatus.OK,
     )
     assert await async_setup_component(hass, "sensor", VALID_CONFIG)
diff --git a/tests/components/london_underground/test_sensor.py b/tests/components/london_underground/test_sensor.py
index 98f1cc0e09b..ccb64401eb5 100644
--- a/tests/components/london_underground/test_sensor.py
+++ b/tests/components/london_underground/test_sensor.py
@@ -2,11 +2,11 @@
 
 from london_tube_status import API_URL
 
-from homeassistant.components.london_underground.const import CONF_LINE
+from homeassistant.components.london_underground.const import CONF_LINE, DOMAIN
 from homeassistant.core import HomeAssistant
 from homeassistant.setup import async_setup_component
 
-from tests.common import load_fixture
+from tests.common import async_load_fixture
 from tests.test_util.aiohttp import AiohttpClientMocker
 
 VALID_CONFIG = {
@@ -20,7 +20,7 @@ async def test_valid_state(
     """Test for operational london_underground sensor with proper attributes."""
     aioclient_mock.get(
         API_URL,
-        text=load_fixture("line_status.json", "london_underground"),
+        text=await async_load_fixture(hass, "line_status.json", DOMAIN),
     )
 
     assert await async_setup_component(hass, "sensor", VALID_CONFIG)
diff --git a/tests/components/loqed/conftest.py b/tests/components/loqed/conftest.py
index ddad8949d7d..edfc1e880f9 100644
--- a/tests/components/loqed/conftest.py
+++ b/tests/components/loqed/conftest.py
@@ -14,14 +14,14 @@ from homeassistant.const import CONF_API_TOKEN, CONF_NAME, CONF_WEBHOOK_ID
 from homeassistant.core import HomeAssistant
 from homeassistant.setup import async_setup_component
 
-from tests.common import MockConfigEntry, load_fixture
+from tests.common import MockConfigEntry, async_load_fixture
 
 
 @pytest.fixture(name="config_entry")
-def config_entry_fixture() -> MockConfigEntry:
+async def config_entry_fixture(hass: HomeAssistant) -> MockConfigEntry:
     """Mock config entry."""
 
-    config = load_fixture("loqed/integration_config.json")
+    config = await async_load_fixture(hass, "integration_config.json", DOMAIN)
     json_config = json.loads(config)
     return MockConfigEntry(
         version=1,
@@ -41,11 +41,13 @@ def config_entry_fixture() -> MockConfigEntry:
 
 
 @pytest.fixture(name="cloud_config_entry")
-def cloud_config_entry_fixture() -> MockConfigEntry:
+async def cloud_config_entry_fixture(hass: HomeAssistant) -> MockConfigEntry:
     """Mock config entry."""
 
-    config = load_fixture("loqed/integration_config.json")
-    webhooks_fixture = json.loads(load_fixture("loqed/get_all_webhooks.json"))
+    config = await async_load_fixture(hass, "integration_config.json", DOMAIN)
+    webhooks_fixture = json.loads(
+        await async_load_fixture(hass, "get_all_webhooks.json", DOMAIN)
+    )
     json_config = json.loads(config)
     return MockConfigEntry(
         version=1,
@@ -66,9 +68,11 @@ def cloud_config_entry_fixture() -> MockConfigEntry:
 
 
 @pytest.fixture(name="lock")
-def lock_fixture() -> loqed.Lock:
+async def lock_fixture(hass: HomeAssistant) -> loqed.Lock:
     """Set up a mock implementation of a Lock."""
-    webhooks_fixture = json.loads(load_fixture("loqed/get_all_webhooks.json"))
+    webhooks_fixture = json.loads(
+        await async_load_fixture(hass, "get_all_webhooks.json", DOMAIN)
+    )
 
     mock_lock = Mock(spec=loqed.Lock, id="Foo", last_key_id=2)
     mock_lock.name = "LOQED smart lock"
@@ -86,7 +90,7 @@ async def integration_fixture(
     config: dict[str, Any] = {DOMAIN: {CONF_API_TOKEN: ""}}
     config_entry.add_to_hass(hass)
 
-    lock_status = json.loads(load_fixture("loqed/status_ok.json"))
+    lock_status = json.loads(await async_load_fixture(hass, "status_ok.json", DOMAIN))
 
     with (
         patch("loqedAPI.loqed.LoqedAPI.async_get_lock", return_value=lock),
diff --git a/tests/components/loqed/test_config_flow.py b/tests/components/loqed/test_config_flow.py
index 6f7da09fa0d..3bdc8f11130 100644
--- a/tests/components/loqed/test_config_flow.py
+++ b/tests/components/loqed/test_config_flow.py
@@ -14,7 +14,7 @@ from homeassistant.core import HomeAssistant
 from homeassistant.data_entry_flow import FlowResultType
 from homeassistant.helpers.service_info.zeroconf import ZeroconfServiceInfo
 
-from tests.common import load_fixture
+from tests.common import async_load_fixture
 from tests.test_util.aiohttp import AiohttpClientMocker
 
 zeroconf_data = ZeroconfServiceInfo(
@@ -30,7 +30,7 @@ zeroconf_data = ZeroconfServiceInfo(
 
 async def test_create_entry_zeroconf(hass: HomeAssistant) -> None:
     """Test we get can create a lock via zeroconf."""
-    lock_result = json.loads(load_fixture("loqed/status_ok.json"))
+    lock_result = json.loads(await async_load_fixture(hass, "status_ok.json", DOMAIN))
 
     with patch(
         "loqedAPI.loqed.LoqedAPI.async_get_lock_details",
@@ -47,7 +47,9 @@ async def test_create_entry_zeroconf(hass: HomeAssistant) -> None:
 
     mock_lock = Mock(spec=loqed.Lock, id="Foo")
     webhook_id = "Webhook_ID"
-    all_locks_response = json.loads(load_fixture("loqed/get_all_locks.json"))
+    all_locks_response = json.loads(
+        await async_load_fixture(hass, "get_all_locks.json", DOMAIN)
+    )
 
     with (
         patch(
@@ -104,10 +106,12 @@ async def test_create_entry_user(
     assert result["type"] is FlowResultType.FORM
     assert result["errors"] is None
 
-    lock_result = json.loads(load_fixture("loqed/status_ok.json"))
+    lock_result = json.loads(await async_load_fixture(hass, "status_ok.json", DOMAIN))
     mock_lock = Mock(spec=loqed.Lock, id="Foo")
     webhook_id = "Webhook_ID"
-    all_locks_response = json.loads(load_fixture("loqed/get_all_locks.json"))
+    all_locks_response = json.loads(
+        await async_load_fixture(hass, "get_all_locks.json", DOMAIN)
+    )
     found_lock = all_locks_response["data"][0]
 
     with (
@@ -191,7 +195,9 @@ async def test_invalid_auth_when_lock_not_found(
     assert result["type"] is FlowResultType.FORM
     assert result["errors"] is None
 
-    all_locks_response = json.loads(load_fixture("loqed/get_all_locks.json"))
+    all_locks_response = json.loads(
+        await async_load_fixture(hass, "get_all_locks.json", DOMAIN)
+    )
 
     with patch(
         "loqedAPI.cloud_loqed.LoqedCloudAPI.async_get_locks",
@@ -219,7 +225,9 @@ async def test_cannot_connect_when_lock_not_reachable(
     assert result["type"] is FlowResultType.FORM
     assert result["errors"] is None
 
-    all_locks_response = json.loads(load_fixture("loqed/get_all_locks.json"))
+    all_locks_response = json.loads(
+        await async_load_fixture(hass, "get_all_locks.json", DOMAIN)
+    )
 
     with (
         patch(
diff --git a/tests/components/loqed/test_init.py b/tests/components/loqed/test_init.py
index e6bff2203a9..0a7323eb7f7 100644
--- a/tests/components/loqed/test_init.py
+++ b/tests/components/loqed/test_init.py
@@ -14,7 +14,7 @@ from homeassistant.core import HomeAssistant
 from homeassistant.helpers.network import get_url
 from homeassistant.setup import async_setup_component
 
-from tests.common import MockConfigEntry, load_fixture
+from tests.common import MockConfigEntry, async_load_fixture
 from tests.typing import ClientSessionGenerator
 
 
@@ -27,10 +27,12 @@ async def test_webhook_accepts_valid_message(
     """Test webhook called with valid message."""
     await async_setup_component(hass, "http", {"http": {}})
     client = await hass_client_no_auth()
-    processed_message = json.loads(load_fixture("loqed/lock_going_to_nightlock.json"))
+    processed_message = json.loads(
+        await async_load_fixture(hass, "lock_going_to_nightlock.json", DOMAIN)
+    )
     lock.receiveWebhook = AsyncMock(return_value=processed_message)
 
-    message = load_fixture("loqed/battery_update.json")
+    message = await async_load_fixture(hass, "battery_update.json", DOMAIN)
     timestamp = 1653304609
     await client.post(
         f"/api/webhook/{integration.data[CONF_WEBHOOK_ID]}",
@@ -47,8 +49,10 @@ async def test_setup_webhook_in_bridge(
     config: dict[str, Any] = {DOMAIN: {}}
     config_entry.add_to_hass(hass)
 
-    lock_status = json.loads(load_fixture("loqed/status_ok.json"))
-    webhooks_fixture = json.loads(load_fixture("loqed/get_all_webhooks.json"))
+    lock_status = json.loads(await async_load_fixture(hass, "status_ok.json", DOMAIN))
+    webhooks_fixture = json.loads(
+        await async_load_fixture(hass, "get_all_webhooks.json", DOMAIN)
+    )
     lock.getWebhooks = AsyncMock(side_effect=[[], webhooks_fixture])
 
     with (
@@ -86,8 +90,10 @@ async def test_setup_cloudhook_in_bridge(
     config: dict[str, Any] = {DOMAIN: {}}
     config_entry.add_to_hass(hass)
 
-    lock_status = json.loads(load_fixture("loqed/status_ok.json"))
-    webhooks_fixture = json.loads(load_fixture("loqed/get_all_webhooks.json"))
+    lock_status = json.loads(await async_load_fixture(hass, "status_ok.json", DOMAIN))
+    webhooks_fixture = json.loads(
+        await async_load_fixture(hass, "get_all_webhooks.json", DOMAIN)
+    )
     lock.getWebhooks = AsyncMock(side_effect=[[], webhooks_fixture])
 
     with (
@@ -114,12 +120,14 @@ async def test_setup_cloudhook_from_entry_in_bridge(
     hass: HomeAssistant, cloud_config_entry: MockConfigEntry, lock: loqed.Lock
 ) -> None:
     """Test webhook setup in loqed bridge."""
-    webhooks_fixture = json.loads(load_fixture("loqed/get_all_webhooks.json"))
+    webhooks_fixture = json.loads(
+        await async_load_fixture(hass, "get_all_webhooks.json", DOMAIN)
+    )
 
     config: dict[str, Any] = {DOMAIN: {}}
     cloud_config_entry.add_to_hass(hass)
 
-    lock_status = json.loads(load_fixture("loqed/status_ok.json"))
+    lock_status = json.loads(await async_load_fixture(hass, "status_ok.json", DOMAIN))
 
     lock.getWebhooks = AsyncMock(side_effect=[[], webhooks_fixture])
 
diff --git a/tests/components/mealie/test_todo.py b/tests/components/mealie/test_todo.py
index e7942887099..d156ef3a0f1 100644
--- a/tests/components/mealie/test_todo.py
+++ b/tests/components/mealie/test_todo.py
@@ -26,7 +26,7 @@ from . import setup_integration
 from tests.common import (
     MockConfigEntry,
     async_fire_time_changed,
-    load_fixture,
+    async_load_fixture,
     snapshot_platform,
 )
 from tests.typing import WebSocketGenerator
@@ -341,7 +341,7 @@ async def test_runtime_management(
 ) -> None:
     """Test for creating and deleting shopping lists."""
     response = ShoppingListsResponse.from_json(
-        load_fixture("get_shopping_lists.json", DOMAIN)
+        await async_load_fixture(hass, "get_shopping_lists.json", DOMAIN)
     ).items
     mock_mealie_client.get_shopping_lists.return_value = ShoppingListsResponse(
         items=[response[0]]
diff --git a/tests/components/metoffice/test_config_flow.py b/tests/components/metoffice/test_config_flow.py
index 87d6e508da2..8488757e0f9 100644
--- a/tests/components/metoffice/test_config_flow.py
+++ b/tests/components/metoffice/test_config_flow.py
@@ -22,7 +22,7 @@ from .const import (
     TEST_SITE_NAME_WAVERTREE,
 )
 
-from tests.common import MockConfigEntry, load_fixture
+from tests.common import MockConfigEntry, async_load_fixture
 
 
 async def test_form(hass: HomeAssistant, requests_mock: requests_mock.Mocker) -> None:
@@ -31,7 +31,7 @@ async def test_form(hass: HomeAssistant, requests_mock: requests_mock.Mocker) ->
     hass.config.longitude = TEST_LONGITUDE_WAVERTREE
 
     # all metoffice test data encapsulated in here
-    mock_json = json.loads(load_fixture("metoffice.json", "metoffice"))
+    mock_json = json.loads(await async_load_fixture(hass, "metoffice.json", DOMAIN))
     wavertree_daily = json.dumps(mock_json["wavertree_daily"])
     requests_mock.get(
         "https://data.hub.api.metoffice.gov.uk/sitespecific/v0/point/daily",
@@ -72,7 +72,7 @@ async def test_form_already_configured(
     hass.config.longitude = TEST_LONGITUDE_WAVERTREE
 
     # all metoffice test data encapsulated in here
-    mock_json = json.loads(load_fixture("metoffice.json", "metoffice"))
+    mock_json = json.loads(await async_load_fixture(hass, "metoffice.json", DOMAIN))
     wavertree_daily = json.dumps(mock_json["wavertree_daily"])
     requests_mock.get(
         "https://data.hub.api.metoffice.gov.uk/sitespecific/v0/point/daily",
@@ -146,7 +146,7 @@ async def test_reauth_flow(
     device_registry: dr.DeviceRegistry,
 ) -> None:
     """Test handling authentication errors and reauth flow."""
-    mock_json = json.loads(load_fixture("metoffice.json", "metoffice"))
+    mock_json = json.loads(await async_load_fixture(hass, "metoffice.json", DOMAIN))
     wavertree_daily = json.dumps(mock_json["wavertree_daily"])
     wavertree_hourly = json.dumps(mock_json["wavertree_hourly"])
     requests_mock.get(
diff --git a/tests/components/metoffice/test_init.py b/tests/components/metoffice/test_init.py
index 2152742625b..47f3d521ef8 100644
--- a/tests/components/metoffice/test_init.py
+++ b/tests/components/metoffice/test_init.py
@@ -13,7 +13,7 @@ from homeassistant.util import utcnow
 
 from .const import METOFFICE_CONFIG_WAVERTREE
 
-from tests.common import MockConfigEntry, async_fire_time_changed, load_fixture
+from tests.common import MockConfigEntry, async_fire_time_changed, async_load_fixture
 
 
 @pytest.mark.freeze_time(datetime.datetime(2024, 11, 23, 12, tzinfo=datetime.UTC))
@@ -23,7 +23,7 @@ async def test_reauth_on_auth_error(
     device_registry: dr.DeviceRegistry,
 ) -> None:
     """Test handling authentication errors and reauth flow."""
-    mock_json = json.loads(load_fixture("metoffice.json", "metoffice"))
+    mock_json = json.loads(await async_load_fixture(hass, "metoffice.json", DOMAIN))
     wavertree_daily = json.dumps(mock_json["wavertree_daily"])
     wavertree_hourly = json.dumps(mock_json["wavertree_hourly"])
     requests_mock.get(
diff --git a/tests/components/metoffice/test_sensor.py b/tests/components/metoffice/test_sensor.py
index dd2824e91b9..bd139873073 100644
--- a/tests/components/metoffice/test_sensor.py
+++ b/tests/components/metoffice/test_sensor.py
@@ -24,7 +24,7 @@ from .const import (
     WAVERTREE_SENSOR_RESULTS,
 )
 
-from tests.common import MockConfigEntry, get_sensor_display_state, load_fixture
+from tests.common import MockConfigEntry, async_load_fixture, get_sensor_display_state
 
 
 @pytest.mark.freeze_time(datetime.datetime(2024, 11, 23, 12, tzinfo=datetime.UTC))
@@ -36,7 +36,7 @@ async def test_one_sensor_site_running(
 ) -> None:
     """Test the Met Office sensor platform."""
     # all metoffice test data encapsulated in here
-    mock_json = json.loads(load_fixture("metoffice.json", "metoffice"))
+    mock_json = json.loads(await async_load_fixture(hass, "metoffice.json", DOMAIN))
     wavertree_hourly = json.dumps(mock_json["wavertree_hourly"])
     wavertree_daily = json.dumps(mock_json["wavertree_daily"])
 
@@ -87,7 +87,7 @@ async def test_two_sensor_sites_running(
     """Test we handle two sets of sensors running for two different sites."""
 
     # all metoffice test data encapsulated in here
-    mock_json = json.loads(load_fixture("metoffice.json", "metoffice"))
+    mock_json = json.loads(await async_load_fixture(hass, "metoffice.json", DOMAIN))
     wavertree_hourly = json.dumps(mock_json["wavertree_hourly"])
     wavertree_daily = json.dumps(mock_json["wavertree_daily"])
     kingslynn_hourly = json.dumps(mock_json["kingslynn_hourly"])
@@ -180,7 +180,7 @@ async def test_legacy_entities_are_removed(
     old_unique_id: str,
 ) -> None:
     """Test the expected entities are deleted."""
-    mock_json = json.loads(load_fixture("metoffice.json", "metoffice"))
+    mock_json = json.loads(await async_load_fixture(hass, "metoffice.json", DOMAIN))
     wavertree_hourly = json.dumps(mock_json["wavertree_hourly"])
     wavertree_daily = json.dumps(mock_json["wavertree_daily"])
 
diff --git a/tests/components/metoffice/test_weather.py b/tests/components/metoffice/test_weather.py
index 48e7626a97f..b2b1a2a0bc7 100644
--- a/tests/components/metoffice/test_weather.py
+++ b/tests/components/metoffice/test_weather.py
@@ -29,7 +29,7 @@ from .const import (
     WAVERTREE_SENSOR_RESULTS,
 )
 
-from tests.common import MockConfigEntry, async_fire_time_changed, load_fixture
+from tests.common import MockConfigEntry, async_fire_time_changed, async_load_fixture
 from tests.typing import WebSocketGenerator
 
 
@@ -43,10 +43,12 @@ def no_sensor():
 
 
 @pytest.fixture
-async def wavertree_data(requests_mock: requests_mock.Mocker) -> dict[str, _Matcher]:
+async def wavertree_data(
+    hass: HomeAssistant, requests_mock: requests_mock.Mocker
+) -> dict[str, _Matcher]:
     """Mock data for the Wavertree location."""
     # all metoffice test data encapsulated in here
-    mock_json = json.loads(load_fixture("metoffice.json", "metoffice"))
+    mock_json = json.loads(await async_load_fixture(hass, "metoffice.json", DOMAIN))
     wavertree_hourly = json.dumps(mock_json["wavertree_hourly"])
     wavertree_daily = json.dumps(mock_json["wavertree_daily"])
 
@@ -194,7 +196,7 @@ async def test_two_weather_sites_running(
     """Test we handle two different weather sites both running."""
 
     # all metoffice test data encapsulated in here
-    mock_json = json.loads(load_fixture("metoffice.json", "metoffice"))
+    mock_json = json.loads(await async_load_fixture(hass, "metoffice.json", DOMAIN))
     kingslynn_hourly = json.dumps(mock_json["kingslynn_hourly"])
     kingslynn_daily = json.dumps(mock_json["kingslynn_daily"])
 
diff --git a/tests/components/microsoft_face/test_init.py b/tests/components/microsoft_face/test_init.py
index 0819dd82f21..a343c633fc7 100644
--- a/tests/components/microsoft_face/test_init.py
+++ b/tests/components/microsoft_face/test_init.py
@@ -21,7 +21,7 @@ from homeassistant.const import ATTR_NAME
 from homeassistant.core import HomeAssistant
 from homeassistant.setup import async_setup_component
 
-from tests.common import assert_setup_component, load_fixture
+from tests.common import assert_setup_component, async_load_fixture
 from tests.test_util.aiohttp import AiohttpClientMocker
 
 
@@ -136,15 +136,15 @@ async def test_setup_component_test_entities(
     """Set up component."""
     aioclient_mock.get(
         ENDPOINT_URL.format("persongroups"),
-        text=load_fixture("persongroups.json", "microsoft_face"),
+        text=await async_load_fixture(hass, "persongroups.json", DOMAIN),
     )
     aioclient_mock.get(
         ENDPOINT_URL.format("persongroups/test_group1/persons"),
-        text=load_fixture("persons.json", "microsoft_face"),
+        text=await async_load_fixture(hass, "persons.json", DOMAIN),
     )
     aioclient_mock.get(
         ENDPOINT_URL.format("persongroups/test_group2/persons"),
-        text=load_fixture("persons.json", "microsoft_face"),
+        text=await async_load_fixture(hass, "persons.json", DOMAIN),
     )
 
     with assert_setup_component(3, mf.DOMAIN):
@@ -204,15 +204,15 @@ async def test_service_person(
     """Set up component, test person services."""
     aioclient_mock.get(
         ENDPOINT_URL.format("persongroups"),
-        text=load_fixture("persongroups.json", "microsoft_face"),
+        text=await async_load_fixture(hass, "persongroups.json", DOMAIN),
     )
     aioclient_mock.get(
         ENDPOINT_URL.format("persongroups/test_group1/persons"),
-        text=load_fixture("persons.json", "microsoft_face"),
+        text=await async_load_fixture(hass, "persons.json", DOMAIN),
     )
     aioclient_mock.get(
         ENDPOINT_URL.format("persongroups/test_group2/persons"),
-        text=load_fixture("persons.json", "microsoft_face"),
+        text=await async_load_fixture(hass, "persons.json", DOMAIN),
     )
 
     with assert_setup_component(3, mf.DOMAIN):
@@ -222,7 +222,7 @@ async def test_service_person(
 
     aioclient_mock.post(
         ENDPOINT_URL.format("persongroups/test_group1/persons"),
-        text=load_fixture("create_person.json", "microsoft_face"),
+        text=await async_load_fixture(hass, "create_person.json", DOMAIN),
     )
     aioclient_mock.delete(
         ENDPOINT_URL.format(
@@ -276,15 +276,15 @@ async def test_service_face(
     """Set up component, test person face services."""
     aioclient_mock.get(
         ENDPOINT_URL.format("persongroups"),
-        text=load_fixture("persongroups.json", "microsoft_face"),
+        text=await async_load_fixture(hass, "persongroups.json", DOMAIN),
     )
     aioclient_mock.get(
         ENDPOINT_URL.format("persongroups/test_group1/persons"),
-        text=load_fixture("persons.json", "microsoft_face"),
+        text=await async_load_fixture(hass, "persons.json", DOMAIN),
     )
     aioclient_mock.get(
         ENDPOINT_URL.format("persongroups/test_group2/persons"),
-        text=load_fixture("persons.json", "microsoft_face"),
+        text=await async_load_fixture(hass, "persons.json", DOMAIN),
     )
 
     CONFIG["camera"] = {"platform": "demo"}
diff --git a/tests/components/microsoft_face_detect/test_image_processing.py b/tests/components/microsoft_face_detect/test_image_processing.py
index 7525663143f..98d61b55c19 100644
--- a/tests/components/microsoft_face_detect/test_image_processing.py
+++ b/tests/components/microsoft_face_detect/test_image_processing.py
@@ -10,7 +10,7 @@ from homeassistant.const import ATTR_ENTITY_PICTURE
 from homeassistant.core import HomeAssistant, callback
 from homeassistant.setup import async_setup_component
 
-from tests.common import assert_setup_component, load_fixture
+from tests.common import assert_setup_component, async_load_fixture
 from tests.components.image_processing import common
 from tests.test_util.aiohttp import AiohttpClientMocker
 
@@ -97,15 +97,17 @@ async def test_ms_detect_process_image(
     """Set up and scan a picture and test plates from event."""
     aioclient_mock.get(
         ENDPOINT_URL.format("persongroups"),
-        text=load_fixture("persongroups.json", "microsoft_face_detect"),
+        text=await async_load_fixture(
+            hass, "persongroups.json", "microsoft_face_detect"
+        ),
     )
     aioclient_mock.get(
         ENDPOINT_URL.format("persongroups/test_group1/persons"),
-        text=load_fixture("persons.json", "microsoft_face_detect"),
+        text=await async_load_fixture(hass, "persons.json", "microsoft_face_detect"),
     )
     aioclient_mock.get(
         ENDPOINT_URL.format("persongroups/test_group2/persons"),
-        text=load_fixture("persons.json", "microsoft_face_detect"),
+        text=await async_load_fixture(hass, "persons.json", "microsoft_face_detect"),
     )
 
     await async_setup_component(hass, IP_DOMAIN, CONFIG)
@@ -127,7 +129,7 @@ async def test_ms_detect_process_image(
 
     aioclient_mock.post(
         ENDPOINT_URL.format("detect"),
-        text=load_fixture("detect.json", "microsoft_face_detect"),
+        text=await async_load_fixture(hass, "detect.json", "microsoft_face_detect"),
         params={"returnFaceAttributes": "age,gender"},
     )
 
diff --git a/tests/components/microsoft_face_identify/test_image_processing.py b/tests/components/microsoft_face_identify/test_image_processing.py
index 1f162e0eb9b..6bd4df3b94b 100644
--- a/tests/components/microsoft_face_identify/test_image_processing.py
+++ b/tests/components/microsoft_face_identify/test_image_processing.py
@@ -10,7 +10,7 @@ from homeassistant.const import ATTR_ENTITY_PICTURE, STATE_UNKNOWN
 from homeassistant.core import HomeAssistant, callback
 from homeassistant.setup import async_setup_component
 
-from tests.common import assert_setup_component, load_fixture
+from tests.common import assert_setup_component, async_load_fixture
 from tests.components.image_processing import common
 from tests.test_util.aiohttp import AiohttpClientMocker
 
@@ -99,15 +99,17 @@ async def test_ms_identify_process_image(
     """Set up and scan a picture and test plates from event."""
     aioclient_mock.get(
         ENDPOINT_URL.format("persongroups"),
-        text=load_fixture("persongroups.json", "microsoft_face_identify"),
+        text=await async_load_fixture(
+            hass, "persongroups.json", "microsoft_face_identify"
+        ),
     )
     aioclient_mock.get(
         ENDPOINT_URL.format("persongroups/test_group1/persons"),
-        text=load_fixture("persons.json", "microsoft_face_identify"),
+        text=await async_load_fixture(hass, "persons.json", "microsoft_face_identify"),
     )
     aioclient_mock.get(
         ENDPOINT_URL.format("persongroups/test_group2/persons"),
-        text=load_fixture("persons.json", "microsoft_face_identify"),
+        text=await async_load_fixture(hass, "persons.json", "microsoft_face_identify"),
     )
 
     await async_setup_component(hass, IP_DOMAIN, CONFIG)
@@ -129,11 +131,11 @@ async def test_ms_identify_process_image(
 
     aioclient_mock.post(
         ENDPOINT_URL.format("detect"),
-        text=load_fixture("detect.json", "microsoft_face_identify"),
+        text=await async_load_fixture(hass, "detect.json", "microsoft_face_identify"),
     )
     aioclient_mock.post(
         ENDPOINT_URL.format("identify"),
-        text=load_fixture("identify.json", "microsoft_face_identify"),
+        text=await async_load_fixture(hass, "identify.json", "microsoft_face_identify"),
     )
 
     common.async_scan(hass, entity_id="image_processing.test_local")
diff --git a/tests/components/mobile_app/test_device_tracker.py b/tests/components/mobile_app/test_device_tracker.py
index 92a956ab629..bc744e05f43 100644
--- a/tests/components/mobile_app/test_device_tracker.py
+++ b/tests/components/mobile_app/test_device_tracker.py
@@ -5,6 +5,7 @@ from typing import Any
 
 from aiohttp.test_utils import TestClient
 
+from homeassistant.const import Platform
 from homeassistant.core import HomeAssistant
 
 
@@ -110,9 +111,11 @@ async def test_restoring_location(
     config_entry = hass.config_entries.async_entries("mobile_app")[1]
 
     # mobile app doesn't support unloading, so we just reload device tracker
-    await hass.config_entries.async_forward_entry_unload(config_entry, "device_tracker")
+    await hass.config_entries.async_forward_entry_unload(
+        config_entry, Platform.DEVICE_TRACKER
+    )
     await hass.config_entries.async_forward_entry_setups(
-        config_entry, ["device_tracker"]
+        config_entry, [Platform.DEVICE_TRACKER]
     )
     await hass.async_block_till_done()
 
diff --git a/tests/components/modern_forms/test_config_flow.py b/tests/components/modern_forms/test_config_flow.py
index 4ec5e92cd72..7e63574d99a 100644
--- a/tests/components/modern_forms/test_config_flow.py
+++ b/tests/components/modern_forms/test_config_flow.py
@@ -15,7 +15,7 @@ from homeassistant.helpers.service_info.zeroconf import ZeroconfServiceInfo
 
 from . import init_integration
 
-from tests.common import load_fixture
+from tests.common import async_load_fixture
 from tests.test_util.aiohttp import AiohttpClientMocker
 
 
@@ -25,7 +25,7 @@ async def test_full_user_flow_implementation(
     """Test the full manual user flow from start to finish."""
     aioclient_mock.post(
         "http://192.168.1.123:80/mf",
-        text=load_fixture("modern_forms/device_info.json"),
+        text=await async_load_fixture(hass, "device_info.json", DOMAIN),
         headers={"Content-Type": CONTENT_TYPE_JSON},
     )
 
@@ -59,7 +59,7 @@ async def test_full_zeroconf_flow_implementation(
     """Test the full manual user flow from start to finish."""
     aioclient_mock.post(
         "http://192.168.1.123:80/mf",
-        text=load_fixture("modern_forms/device_info.json"),
+        text=await async_load_fixture(hass, "device_info.json", DOMAIN),
         headers={"Content-Type": CONTENT_TYPE_JSON},
     )
 
@@ -191,7 +191,7 @@ async def test_user_device_exists_abort(
     """Test we abort zeroconf flow if Modern Forms device already configured."""
     aioclient_mock.post(
         "http://192.168.1.123:80/mf",
-        text=load_fixture("modern_forms/device_info.json"),
+        text=await async_load_fixture(hass, "device_info.json", DOMAIN),
         headers={"Content-Type": CONTENT_TYPE_JSON},
     )
 
diff --git a/tests/components/music_assistant/test_config_flow.py b/tests/components/music_assistant/test_config_flow.py
index 89cda62961b..2f623c1188d 100644
--- a/tests/components/music_assistant/test_config_flow.py
+++ b/tests/components/music_assistant/test_config_flow.py
@@ -20,7 +20,7 @@ from homeassistant.core import HomeAssistant
 from homeassistant.data_entry_flow import FlowResultType
 from homeassistant.helpers.service_info.zeroconf import ZeroconfServiceInfo
 
-from tests.common import MockConfigEntry, load_fixture
+from tests.common import MockConfigEntry, async_load_fixture
 
 SERVER_INFO = {
     "server_id": "1234",
@@ -186,7 +186,7 @@ async def test_flow_user_server_version_invalid(
 
     mock_get_server_info.side_effect = None
     mock_get_server_info.return_value = ServerInfoMessage.from_json(
-        load_fixture("server_info_message.json", DOMAIN)
+        await async_load_fixture(hass, "server_info_message.json", DOMAIN)
     )
 
     assert result["type"] is FlowResultType.FORM
diff --git a/tests/components/netatmo/test_media_source.py b/tests/components/netatmo/test_media_source.py
index 3d787a1a813..755893adb11 100644
--- a/tests/components/netatmo/test_media_source.py
+++ b/tests/components/netatmo/test_media_source.py
@@ -16,7 +16,7 @@ from homeassistant.components.netatmo import DATA_CAMERAS, DATA_EVENTS, DOMAIN
 from homeassistant.core import HomeAssistant
 from homeassistant.setup import async_setup_component
 
-from tests.common import load_fixture
+from tests.common import async_load_fixture
 
 
 async def test_async_browse_media(hass: HomeAssistant) -> None:
@@ -26,7 +26,7 @@ async def test_async_browse_media(hass: HomeAssistant) -> None:
     # Prepare cached Netatmo event date
     hass.data[DOMAIN] = {}
     hass.data[DOMAIN][DATA_EVENTS] = ast.literal_eval(
-        load_fixture("netatmo/events.txt")
+        await async_load_fixture(hass, "events.txt", DOMAIN)
     )
 
     hass.data[DOMAIN][DATA_CAMERAS] = {
diff --git a/tests/components/nordpool/test_init.py b/tests/components/nordpool/test_init.py
index c9b6167ff3c..48ddc59d083 100644
--- a/tests/components/nordpool/test_init.py
+++ b/tests/components/nordpool/test_init.py
@@ -24,7 +24,7 @@ from homeassistant.helpers import device_registry as dr, entity_registry as er
 
 from . import ENTRY_CONFIG
 
-from tests.common import MockConfigEntry, load_fixture
+from tests.common import MockConfigEntry, async_load_fixture
 from tests.test_util.aiohttp import AiohttpClientMocker
 
 
@@ -88,7 +88,7 @@ async def test_reconfigure_cleans_up_device(
     entity_registry: er.EntityRegistry,
 ) -> None:
     """Test clean up devices due to reconfiguration."""
-    nl_json_file = load_fixture("delivery_period_nl.json", DOMAIN)
+    nl_json_file = await async_load_fixture(hass, "delivery_period_nl.json", DOMAIN)
     load_nl_json = json.loads(nl_json_file)
 
     entry = MockConfigEntry(
diff --git a/tests/components/notify/test_init.py b/tests/components/notify/test_init.py
index 0c559ad779f..16a583fdf5c 100644
--- a/tests/components/notify/test_init.py
+++ b/tests/components/notify/test_init.py
@@ -56,7 +56,9 @@ async def help_async_setup_entry_init(
     hass: HomeAssistant, config_entry: ConfigEntry
 ) -> bool:
     """Set up test config entry."""
-    await hass.config_entries.async_forward_entry_setups(config_entry, [DOMAIN])
+    await hass.config_entries.async_forward_entry_setups(
+        config_entry, [Platform.NOTIFY]
+    )
     return True
 
 
diff --git a/tests/components/number/test_init.py b/tests/components/number/test_init.py
index 7d7ee41f9a7..b5e5e18f664 100644
--- a/tests/components/number/test_init.py
+++ b/tests/components/number/test_init.py
@@ -33,6 +33,7 @@ from homeassistant.const import (
     ATTR_ENTITY_ID,
     ATTR_UNIT_OF_MEASUREMENT,
     CONF_PLATFORM,
+    Platform,
     UnitOfTemperature,
     UnitOfVolumeFlowRate,
 )
@@ -983,7 +984,9 @@ async def test_name(hass: HomeAssistant) -> None:
         hass: HomeAssistant, config_entry: ConfigEntry
     ) -> bool:
         """Set up test config entry."""
-        await hass.config_entries.async_forward_entry_setups(config_entry, [DOMAIN])
+        await hass.config_entries.async_forward_entry_setups(
+            config_entry, [Platform.NUMBER]
+        )
         return True
 
     mock_platform(hass, f"{TEST_DOMAIN}.config_flow")
diff --git a/tests/components/nut/test_switch.py b/tests/components/nut/test_switch.py
index f2de5eeb5e6..a38fc47da3e 100644
--- a/tests/components/nut/test_switch.py
+++ b/tests/components/nut/test_switch.py
@@ -5,7 +5,7 @@ from unittest.mock import AsyncMock
 
 import pytest
 
-from homeassistant.components.nut.const import INTEGRATION_SUPPORTED_COMMANDS
+from homeassistant.components.nut.const import DOMAIN, INTEGRATION_SUPPORTED_COMMANDS
 from homeassistant.components.switch import DOMAIN as SWITCH_DOMAIN
 from homeassistant.const import (
     ATTR_ENTITY_ID,
@@ -19,7 +19,7 @@ from homeassistant.helpers import entity_registry as er
 
 from .util import async_init_integration
 
-from tests.common import load_fixture
+from tests.common import async_load_fixture
 
 
 @pytest.mark.parametrize(
@@ -82,8 +82,8 @@ async def test_switch_pdu_dynamic_outlets(
         command = f"outlet.{num!s}.load.off"
         list_commands_return_value[command] = command
 
-    ups_fixture = f"nut/{model}.json"
-    list_vars = json.loads(load_fixture(ups_fixture))
+    ups_fixture = f"{model}.json"
+    list_vars = json.loads(await async_load_fixture(hass, ups_fixture, DOMAIN))
 
     run_command = AsyncMock()
 
diff --git a/tests/components/nut/util.py b/tests/components/nut/util.py
index 49510fc9d72..bd51ab7acc9 100644
--- a/tests/components/nut/util.py
+++ b/tests/components/nut/util.py
@@ -15,7 +15,7 @@ from homeassistant.const import (
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers import entity_registry as er
 
-from tests.common import MockConfigEntry, load_fixture
+from tests.common import MockConfigEntry, async_load_fixture
 
 
 def _get_mock_nutclient(
@@ -59,9 +59,9 @@ async def async_init_integration(
         list_ups = {"ups1": "UPS 1"}
 
     if ups_fixture is not None:
-        ups_fixture = f"nut/{ups_fixture}.json"
+        ups_fixture = f"{ups_fixture}.json"
         if list_vars is None:
-            list_vars = json.loads(load_fixture(ups_fixture))
+            list_vars = json.loads(await async_load_fixture(hass, ups_fixture, DOMAIN))
 
     mock_pynut = _get_mock_nutclient(
         list_ups=list_ups,
diff --git a/tests/components/nyt_games/test_sensor.py b/tests/components/nyt_games/test_sensor.py
index 5802b38dd83..2cabc83605d 100644
--- a/tests/components/nyt_games/test_sensor.py
+++ b/tests/components/nyt_games/test_sensor.py
@@ -18,7 +18,7 @@ from . import setup_integration
 from tests.common import (
     MockConfigEntry,
     async_fire_time_changed,
-    load_fixture,
+    async_load_fixture,
     snapshot_platform,
 )
 
@@ -70,7 +70,7 @@ async def test_new_account(
 ) -> None:
     """Test handling an exception during update."""
     mock_nyt_games_client.get_latest_stats.return_value = WordleStats.from_json(
-        load_fixture("new_account.json", DOMAIN)
+        await async_load_fixture(hass, "new_account.json", DOMAIN)
     ).player.stats
     await setup_integration(hass, mock_config_entry)
 
diff --git a/tests/components/openalpr_cloud/test_image_processing.py b/tests/components/openalpr_cloud/test_image_processing.py
index 143513f9852..4bd0d2248bc 100644
--- a/tests/components/openalpr_cloud/test_image_processing.py
+++ b/tests/components/openalpr_cloud/test_image_processing.py
@@ -9,7 +9,11 @@ from homeassistant.components.openalpr_cloud.image_processing import OPENALPR_AP
 from homeassistant.core import Event, HomeAssistant
 from homeassistant.setup import async_setup_component
 
-from tests.common import assert_setup_component, async_capture_events, load_fixture
+from tests.common import (
+    assert_setup_component,
+    async_capture_events,
+    async_load_fixture,
+)
 from tests.components.image_processing import common
 from tests.test_util.aiohttp import AiohttpClientMocker
 
@@ -136,7 +140,7 @@ async def test_openalpr_process_image(
     aioclient_mock.post(
         OPENALPR_API_URL,
         params=PARAMS,
-        text=load_fixture("alpr_cloud.json", "openalpr_cloud"),
+        text=await async_load_fixture(hass, "alpr_cloud.json", "openalpr_cloud"),
         status=200,
     )
 
diff --git a/tests/components/openhardwaremonitor/test_sensor.py b/tests/components/openhardwaremonitor/test_sensor.py
index 944b5487a96..4eb9aea9d09 100644
--- a/tests/components/openhardwaremonitor/test_sensor.py
+++ b/tests/components/openhardwaremonitor/test_sensor.py
@@ -5,7 +5,7 @@ import requests_mock
 from homeassistant.core import HomeAssistant
 from homeassistant.setup import async_setup_component
 
-from tests.common import load_fixture
+from tests.common import async_load_fixture
 
 
 async def test_setup(hass: HomeAssistant, requests_mock: requests_mock.Mocker) -> None:
@@ -20,7 +20,9 @@ async def test_setup(hass: HomeAssistant, requests_mock: requests_mock.Mocker) -
 
     requests_mock.get(
         "http://localhost:8085/data.json",
-        text=load_fixture("openhardwaremonitor.json", "openhardwaremonitor"),
+        text=await async_load_fixture(
+            hass, "openhardwaremonitor.json", "openhardwaremonitor"
+        ),
     )
 
     await async_setup_component(hass, "sensor", config)
diff --git a/tests/components/renault/test_button.py b/tests/components/renault/test_button.py
index 61754578948..e621f1bce23 100644
--- a/tests/components/renault/test_button.py
+++ b/tests/components/renault/test_button.py
@@ -8,12 +8,13 @@ from renault_api.kamereon import schemas
 from syrupy.assertion import SnapshotAssertion
 
 from homeassistant.components.button import DOMAIN as BUTTON_DOMAIN, SERVICE_PRESS
+from homeassistant.components.renault.const import DOMAIN
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import ATTR_ENTITY_ID, Platform
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers import entity_registry as er
 
-from tests.common import load_fixture, snapshot_platform
+from tests.common import async_load_fixture, snapshot_platform
 
 pytestmark = pytest.mark.usefixtures("patch_renault_account", "patch_get_vehicles")
 
@@ -116,7 +117,7 @@ async def test_button_start_charge(
         "renault_api.renault_vehicle.RenaultVehicle.set_charge_start",
         return_value=(
             schemas.KamereonVehicleHvacStartActionDataSchema.loads(
-                load_fixture("renault/action.set_charge_start.json")
+                await async_load_fixture(hass, "action.set_charge_start.json", DOMAIN)
             )
         ),
     ) as mock_action:
@@ -144,7 +145,7 @@ async def test_button_stop_charge(
         "renault_api.renault_vehicle.RenaultVehicle.set_charge_stop",
         return_value=(
             schemas.KamereonVehicleChargingStartActionDataSchema.loads(
-                load_fixture("renault/action.set_charge_stop.json")
+                await async_load_fixture(hass, "action.set_charge_stop.json", DOMAIN)
             )
         ),
     ) as mock_action:
@@ -172,7 +173,7 @@ async def test_button_start_air_conditioner(
         "renault_api.renault_vehicle.RenaultVehicle.set_ac_start",
         return_value=(
             schemas.KamereonVehicleHvacStartActionDataSchema.loads(
-                load_fixture("renault/action.set_ac_start.json")
+                await async_load_fixture(hass, "action.set_ac_start.json", DOMAIN)
             )
         ),
     ) as mock_action:
diff --git a/tests/components/renault/test_config_flow.py b/tests/components/renault/test_config_flow.py
index 9a7146c96cd..94422ab0e2a 100644
--- a/tests/components/renault/test_config_flow.py
+++ b/tests/components/renault/test_config_flow.py
@@ -19,7 +19,7 @@ from homeassistant.core import HomeAssistant
 from homeassistant.data_entry_flow import FlowResultType
 from homeassistant.helpers import aiohttp_client
 
-from tests.common import MockConfigEntry, get_schema_suggested_value, load_fixture
+from tests.common import MockConfigEntry, async_load_fixture, get_schema_suggested_value
 
 pytestmark = pytest.mark.usefixtures("mock_setup_entry")
 
@@ -76,7 +76,7 @@ async def test_config_flow_single_account(
     type(renault_account).account_id = PropertyMock(return_value="account_id_1")
     renault_account.get_vehicles.return_value = (
         schemas.KamereonVehiclesResponseSchema.loads(
-            load_fixture("renault/vehicle_zoe_40.json")
+            await async_load_fixture(hass, "vehicle_zoe_40.json", DOMAIN)
         )
     )
 
@@ -305,7 +305,7 @@ async def test_reconfigure(
     type(renault_account).account_id = PropertyMock(return_value="account_id_1")
     renault_account.get_vehicles.return_value = (
         schemas.KamereonVehiclesResponseSchema.loads(
-            load_fixture("renault/vehicle_zoe_40.json")
+            await async_load_fixture(hass, "vehicle_zoe_40.json", DOMAIN)
         )
     )
 
@@ -360,7 +360,7 @@ async def test_reconfigure_mismatch(
     type(renault_account).account_id = PropertyMock(return_value="account_id_other")
     renault_account.get_vehicles.return_value = (
         schemas.KamereonVehiclesResponseSchema.loads(
-            load_fixture("renault/vehicle_zoe_40.json")
+            await async_load_fixture(hass, "vehicle_zoe_40.json", DOMAIN)
         )
     )
 
diff --git a/tests/components/renault/test_select.py b/tests/components/renault/test_select.py
index b8ba3ef4b58..73013999e7a 100644
--- a/tests/components/renault/test_select.py
+++ b/tests/components/renault/test_select.py
@@ -7,6 +7,7 @@ import pytest
 from renault_api.kamereon import schemas
 from syrupy.assertion import SnapshotAssertion
 
+from homeassistant.components.renault.const import DOMAIN
 from homeassistant.components.select import (
     ATTR_OPTION,
     DOMAIN as SELECT_DOMAIN,
@@ -19,7 +20,7 @@ from homeassistant.helpers import entity_registry as er
 
 from .const import MOCK_VEHICLES
 
-from tests.common import load_fixture, snapshot_platform
+from tests.common import async_load_fixture, snapshot_platform
 
 pytestmark = pytest.mark.usefixtures("patch_renault_account", "patch_get_vehicles")
 
@@ -126,7 +127,7 @@ async def test_select_charge_mode(
         "renault_api.renault_vehicle.RenaultVehicle.set_charge_mode",
         return_value=(
             schemas.KamereonVehicleHvacStartActionDataSchema.loads(
-                load_fixture("renault/action.set_charge_mode.json")
+                await async_load_fixture(hass, "action.set_charge_mode.json", DOMAIN)
             )
         ),
     ) as mock_action:
diff --git a/tests/components/renault/test_services.py b/tests/components/renault/test_services.py
index eef38c00f36..1bef2023d5b 100644
--- a/tests/components/renault/test_services.py
+++ b/tests/components/renault/test_services.py
@@ -26,7 +26,7 @@ from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import HomeAssistantError, ServiceValidationError
 from homeassistant.helpers import device_registry as dr
 
-from tests.common import load_fixture
+from tests.common import async_load_fixture
 
 pytestmark = pytest.mark.usefixtures("patch_renault_account", "patch_get_vehicles")
 
@@ -67,7 +67,7 @@ async def test_service_set_ac_cancel(
         "renault_api.renault_vehicle.RenaultVehicle.set_ac_stop",
         return_value=(
             schemas.KamereonVehicleHvacStartActionDataSchema.loads(
-                load_fixture("renault/action.set_ac_stop.json")
+                await async_load_fixture(hass, "action.set_ac_stop.json", DOMAIN)
             )
         ),
     ) as mock_action:
@@ -95,7 +95,7 @@ async def test_service_set_ac_start_simple(
         "renault_api.renault_vehicle.RenaultVehicle.set_ac_start",
         return_value=(
             schemas.KamereonVehicleHvacStartActionDataSchema.loads(
-                load_fixture("renault/action.set_ac_start.json")
+                await async_load_fixture(hass, "action.set_ac_start.json", DOMAIN)
             )
         ),
     ) as mock_action:
@@ -125,7 +125,7 @@ async def test_service_set_ac_start_with_date(
         "renault_api.renault_vehicle.RenaultVehicle.set_ac_start",
         return_value=(
             schemas.KamereonVehicleHvacStartActionDataSchema.loads(
-                load_fixture("renault/action.set_ac_start.json")
+                await async_load_fixture(hass, "action.set_ac_start.json", DOMAIN)
             )
         ),
     ) as mock_action:
@@ -154,14 +154,16 @@ async def test_service_set_charge_schedule(
         patch(
             "renault_api.renault_vehicle.RenaultVehicle.http_get",
             return_value=schemas.KamereonResponseSchema.loads(
-                load_fixture("renault/charging_settings.json")
+                await async_load_fixture(hass, "charging_settings.json", DOMAIN)
             ),
         ),
         patch(
             "renault_api.renault_vehicle.RenaultVehicle.set_charge_schedules",
             return_value=(
                 schemas.KamereonVehicleHvacStartActionDataSchema.loads(
-                    load_fixture("renault/action.set_charge_schedules.json")
+                    await async_load_fixture(
+                        hass, "action.set_charge_schedules.json", DOMAIN
+                    )
                 )
             ),
         ) as mock_action,
@@ -204,14 +206,16 @@ async def test_service_set_charge_schedule_multi(
         patch(
             "renault_api.renault_vehicle.RenaultVehicle.http_get",
             return_value=schemas.KamereonResponseSchema.loads(
-                load_fixture("renault/charging_settings.json")
+                await async_load_fixture(hass, "charging_settings.json", DOMAIN)
             ),
         ),
         patch(
             "renault_api.renault_vehicle.RenaultVehicle.set_charge_schedules",
             return_value=(
                 schemas.KamereonVehicleHvacStartActionDataSchema.loads(
-                    load_fixture("renault/action.set_charge_schedules.json")
+                    await async_load_fixture(
+                        hass, "action.set_charge_schedules.json", DOMAIN
+                    )
                 )
             ),
         ) as mock_action,
@@ -250,14 +254,16 @@ async def test_service_set_ac_schedule(
         patch(
             "renault_api.renault_vehicle.RenaultVehicle.get_hvac_settings",
             return_value=schemas.KamereonVehicleDataResponseSchema.loads(
-                load_fixture("renault/hvac_settings.json")
+                await async_load_fixture(hass, "hvac_settings.json", DOMAIN)
             ).get_attributes(schemas.KamereonVehicleHvacSettingsDataSchema),
         ),
         patch(
             "renault_api.renault_vehicle.RenaultVehicle.set_hvac_schedules",
             return_value=(
                 schemas.KamereonVehicleHvacScheduleActionDataSchema.loads(
-                    load_fixture("renault/action.set_ac_schedules.json")
+                    await async_load_fixture(
+                        hass, "action.set_ac_schedules.json", DOMAIN
+                    )
                 )
             ),
         ) as mock_action,
@@ -299,14 +305,16 @@ async def test_service_set_ac_schedule_multi(
         patch(
             "renault_api.renault_vehicle.RenaultVehicle.get_hvac_settings",
             return_value=schemas.KamereonVehicleDataResponseSchema.loads(
-                load_fixture("renault/hvac_settings.json")
+                await async_load_fixture(hass, "hvac_settings.json", DOMAIN)
             ).get_attributes(schemas.KamereonVehicleHvacSettingsDataSchema),
         ),
         patch(
             "renault_api.renault_vehicle.RenaultVehicle.set_hvac_schedules",
             return_value=(
                 schemas.KamereonVehicleHvacScheduleActionDataSchema.loads(
-                    load_fixture("renault/action.set_ac_schedules.json")
+                    await async_load_fixture(
+                        hass, "action.set_ac_schedules.json", DOMAIN
+                    )
                 )
             ),
         ) as mock_action,
diff --git a/tests/components/reolink/test_views.py b/tests/components/reolink/test_views.py
index 3521de072b6..992e47f0575 100644
--- a/tests/components/reolink/test_views.py
+++ b/tests/components/reolink/test_views.py
@@ -58,17 +58,22 @@ def get_mock_session(
     return mock_session
 
 
+@pytest.mark.parametrize(
+    ("content_type"),
+    [("video/mp4"), ("application/octet-stream"), ("apolication/octet-stream")],
+)
 async def test_playback_proxy(
     hass: HomeAssistant,
     reolink_connect: MagicMock,
     config_entry: MockConfigEntry,
     hass_client: ClientSessionGenerator,
     caplog: pytest.LogCaptureFixture,
+    content_type: str,
 ) -> None:
     """Test successful playback proxy URL."""
     reolink_connect.get_vod_source.return_value = (TEST_MIME_TYPE_MP4, TEST_URL)
 
-    mock_session = get_mock_session()
+    mock_session = get_mock_session(content_type=content_type)
 
     with patch(
         "homeassistant.components.reolink.views.async_get_clientsession",
diff --git a/tests/components/roku/conftest.py b/tests/components/roku/conftest.py
index 7ac332a1a6c..f3ff48ef2f1 100644
--- a/tests/components/roku/conftest.py
+++ b/tests/components/roku/conftest.py
@@ -11,7 +11,7 @@ from homeassistant.components.roku.const import DOMAIN
 from homeassistant.const import CONF_HOST
 from homeassistant.core import HomeAssistant
 
-from tests.common import MockConfigEntry, load_fixture
+from tests.common import MockConfigEntry, async_load_fixture
 
 
 def app_icon_url(*args, **kwargs):
@@ -40,6 +40,7 @@ def mock_setup_entry() -> Generator[None]:
 
 @pytest.fixture
 async def mock_device(
+    hass: HomeAssistant,
     request: pytest.FixtureRequest,
 ) -> RokuDevice:
     """Return the mocked roku device."""
@@ -47,7 +48,7 @@ async def mock_device(
     if hasattr(request, "param") and request.param:
         fixture = request.param
 
-    return RokuDevice(json.loads(load_fixture(fixture)))
+    return RokuDevice(json.loads(await async_load_fixture(hass, fixture)))
 
 
 @pytest.fixture
diff --git a/tests/components/sensor/test_init.py b/tests/components/sensor/test_init.py
index b1010c7e7a3..660b5553d62 100644
--- a/tests/components/sensor/test_init.py
+++ b/tests/components/sensor/test_init.py
@@ -31,6 +31,7 @@ from homeassistant.const import (
     PERCENTAGE,
     STATE_UNKNOWN,
     EntityCategory,
+    Platform,
     UnitOfApparentPower,
     UnitOfArea,
     UnitOfBloodGlucoseConcentration,
@@ -2731,7 +2732,7 @@ async def test_name(hass: HomeAssistant) -> None:
     ) -> bool:
         """Set up test config entry."""
         await hass.config_entries.async_forward_entry_setups(
-            config_entry, [SENSOR_DOMAIN]
+            config_entry, [Platform.SENSOR]
         )
         return True
 
diff --git a/tests/components/sfr_box/test_config_flow.py b/tests/components/sfr_box/test_config_flow.py
index 6bf610de661..8c840eb151f 100644
--- a/tests/components/sfr_box/test_config_flow.py
+++ b/tests/components/sfr_box/test_config_flow.py
@@ -14,7 +14,7 @@ from homeassistant.const import CONF_HOST, CONF_PASSWORD, CONF_USERNAME
 from homeassistant.core import HomeAssistant
 from homeassistant.data_entry_flow import FlowResultType
 
-from tests.common import load_fixture
+from tests.common import async_load_fixture
 
 pytestmark = pytest.mark.usefixtures("mock_setup_entry")
 
@@ -46,7 +46,7 @@ async def test_config_flow_skip_auth(
     with patch(
         "homeassistant.components.sfr_box.config_flow.SFRBox.system_get_info",
         return_value=SystemInfo(
-            **json.loads(load_fixture("system_getInfo.json", DOMAIN))
+            **json.loads(await async_load_fixture(hass, "system_getInfo.json", DOMAIN))
         ),
     ):
         result = await hass.config_entries.flow.async_configure(
@@ -84,7 +84,7 @@ async def test_config_flow_with_auth(
     with patch(
         "homeassistant.components.sfr_box.config_flow.SFRBox.system_get_info",
         return_value=SystemInfo(
-            **json.loads(load_fixture("system_getInfo.json", DOMAIN))
+            **json.loads(await async_load_fixture(hass, "system_getInfo.json", DOMAIN))
         ),
     ):
         result = await hass.config_entries.flow.async_configure(
@@ -150,7 +150,9 @@ async def test_config_flow_duplicate_host(
     assert result["type"] is FlowResultType.FORM
     assert result["errors"] == {}
 
-    system_info = SystemInfo(**json.loads(load_fixture("system_getInfo.json", DOMAIN)))
+    system_info = SystemInfo(
+        **json.loads(await async_load_fixture(hass, "system_getInfo.json", DOMAIN))
+    )
     # Ensure mac doesn't match existing mock entry
     system_info.mac_addr = "aa:bb:cc:dd:ee:ff"
     with patch(
@@ -184,7 +186,9 @@ async def test_config_flow_duplicate_mac(
     assert result["type"] is FlowResultType.FORM
     assert result["errors"] == {}
 
-    system_info = SystemInfo(**json.loads(load_fixture("system_getInfo.json", DOMAIN)))
+    system_info = SystemInfo(
+        **json.loads(await async_load_fixture(hass, "system_getInfo.json", DOMAIN))
+    )
     with patch(
         "homeassistant.components.sfr_box.config_flow.SFRBox.system_get_info",
         return_value=system_info,
diff --git a/tests/components/smartthings/test_init.py b/tests/components/smartthings/test_init.py
index 0b8d2e1e632..ab21f1a7b81 100644
--- a/tests/components/smartthings/test_init.py
+++ b/tests/components/smartthings/test_init.py
@@ -38,7 +38,7 @@ from homeassistant.helpers import device_registry as dr, entity_registry as er
 
 from . import setup_integration, trigger_update
 
-from tests.common import MockConfigEntry, load_fixture
+from tests.common import MockConfigEntry, async_load_fixture
 
 
 async def test_devices(
@@ -140,7 +140,9 @@ async def test_create_subscription(
     devices.subscribe.assert_called_once_with(
         "397678e5-9995-4a39-9d9f-ae6ba310236c",
         "5aaaa925-2be1-4e40-b257-e4ef59083324",
-        Subscription.from_json(load_fixture("subscription.json", DOMAIN)),
+        Subscription.from_json(
+            await async_load_fixture(hass, "subscription.json", DOMAIN)
+        ),
     )
 
 
@@ -371,11 +373,11 @@ async def test_hub_via_device(
 ) -> None:
     """Test hub with child devices."""
     mock_smartthings.get_devices.return_value = DeviceResponse.from_json(
-        load_fixture("devices/hub.json", DOMAIN)
+        await async_load_fixture(hass, "devices/hub.json", DOMAIN)
     ).items
     mock_smartthings.get_device_status.side_effect = [
         DeviceStatus.from_json(
-            load_fixture(f"device_status/{fixture}.json", DOMAIN)
+            await async_load_fixture(hass, f"device_status/{fixture}.json", DOMAIN)
         ).components
         for fixture in ("hub", "multipurpose_sensor")
     ]
diff --git a/tests/components/smlight/test_diagnostics.py b/tests/components/smlight/test_diagnostics.py
index 778ef8e5811..e998118e646 100644
--- a/tests/components/smlight/test_diagnostics.py
+++ b/tests/components/smlight/test_diagnostics.py
@@ -9,7 +9,7 @@ from homeassistant.core import HomeAssistant
 
 from .conftest import setup_integration
 
-from tests.common import MockConfigEntry, load_fixture
+from tests.common import MockConfigEntry, async_load_fixture
 from tests.components.diagnostics import get_diagnostics_for_config_entry
 from tests.typing import ClientSessionGenerator
 
@@ -22,7 +22,9 @@ async def test_entry_diagnostics(
     snapshot: SnapshotAssertion,
 ) -> None:
     """Test config entry diagnostics."""
-    mock_smlight_client.get.return_value = load_fixture("logs.txt", DOMAIN)
+    mock_smlight_client.get.return_value = await async_load_fixture(
+        hass, "logs.txt", DOMAIN
+    )
     entry = await setup_integration(hass, mock_config_entry)
 
     result = await get_diagnostics_for_config_entry(hass, hass_client, entry)
diff --git a/tests/components/sms/test_init.py b/tests/components/sms/test_init.py
new file mode 100644
index 00000000000..03cebfe9b52
--- /dev/null
+++ b/tests/components/sms/test_init.py
@@ -0,0 +1,59 @@
+"""Test init."""
+
+from unittest.mock import Mock, patch
+
+from homeassistant.config_entries import ConfigEntryState
+from homeassistant.const import CONF_DEVICE
+from homeassistant.core import DOMAIN as HOMEASSISTANT_DOMAIN, HomeAssistant
+from homeassistant.helpers import issue_registry as ir
+
+from tests.common import MockConfigEntry
+
+
+@patch.dict(
+    "sys.modules",
+    {
+        "gammu": Mock(),
+        "gammu.asyncworker": Mock(),
+    },
+)
+async def test_repair_issue_is_created(
+    hass: HomeAssistant,
+    issue_registry: ir.IssueRegistry,
+) -> None:
+    """Test repair issue is created."""
+    from homeassistant.components.sms import (  # pylint: disable=import-outside-toplevel
+        DEPRECATED_ISSUE_ID,
+        DOMAIN as SMS_DOMAIN,
+    )
+
+    with (
+        patch("homeassistant.components.sms.create_sms_gateway", autospec=True),
+        patch("homeassistant.components.sms.PLATFORMS", []),
+    ):
+        config_entry = MockConfigEntry(
+            title="test",
+            domain=SMS_DOMAIN,
+            data={
+                CONF_DEVICE: "/dev/ttyUSB0",
+            },
+        )
+
+        config_entry.add_to_hass(hass)
+        await hass.config_entries.async_setup(config_entry.entry_id)
+        await hass.async_block_till_done()
+
+        assert config_entry.state is ConfigEntryState.LOADED
+        assert (
+            HOMEASSISTANT_DOMAIN,
+            DEPRECATED_ISSUE_ID,
+        ) in issue_registry.issues
+
+        await hass.config_entries.async_unload(config_entry.entry_id)
+        await hass.async_block_till_done()
+
+        assert config_entry.state is ConfigEntryState.NOT_LOADED
+        assert (
+            HOMEASSISTANT_DOMAIN,
+            DEPRECATED_ISSUE_ID,
+        ) not in issue_registry.issues
diff --git a/tests/components/snips/test_init.py b/tests/components/snips/test_init.py
index 82dbf1cd281..2be6d769f08 100644
--- a/tests/components/snips/test_init.py
+++ b/tests/components/snips/test_init.py
@@ -7,7 +7,8 @@ import pytest
 import voluptuous as vol
 
 from homeassistant.components import snips
-from homeassistant.core import HomeAssistant
+from homeassistant.core import DOMAIN as HOMEASSISTANT_DOMAIN, HomeAssistant
+from homeassistant.helpers import issue_registry as ir
 from homeassistant.helpers.intent import ServiceIntentHandler, async_register
 from homeassistant.setup import async_setup_component
 
@@ -15,9 +16,13 @@ from tests.common import async_fire_mqtt_message, async_mock_intent, async_mock_
 from tests.typing import MqttMockHAClient
 
 
-async def test_snips_config(hass: HomeAssistant, mqtt_mock: MqttMockHAClient) -> None:
+async def test_snips_config(
+    hass: HomeAssistant,
+    mqtt_mock: MqttMockHAClient,
+    issue_registry: ir.IssueRegistry,
+) -> None:
     """Test Snips Config."""
-    result = await async_setup_component(
+    assert await async_setup_component(
         hass,
         "snips",
         {
@@ -28,7 +33,10 @@ async def test_snips_config(hass: HomeAssistant, mqtt_mock: MqttMockHAClient) ->
             }
         },
     )
-    assert result
+    assert (
+        HOMEASSISTANT_DOMAIN,
+        f"deprecated_system_packages_yaml_integration_{snips.DOMAIN}",
+    ) in issue_registry.issues
 
 
 async def test_snips_no_mqtt(
diff --git a/tests/components/spotify/test_media_player.py b/tests/components/spotify/test_media_player.py
index 913034b9636..664418cc377 100644
--- a/tests/components/spotify/test_media_player.py
+++ b/tests/components/spotify/test_media_player.py
@@ -56,7 +56,7 @@ from . import setup_integration
 from tests.common import (
     MockConfigEntry,
     async_fire_time_changed,
-    load_fixture,
+    async_load_fixture,
     snapshot_platform,
 )
 
@@ -95,7 +95,7 @@ async def test_podcast(
     """Test the Spotify entities while listening a podcast."""
     freezer.move_to("2023-10-21")
     mock_spotify.return_value.get_playback.return_value = PlaybackState.from_json(
-        load_fixture("playback_episode.json", DOMAIN)
+        await async_load_fixture(hass, "playback_episode.json", DOMAIN)
     )
     with (
         patch("secrets.token_hex", return_value="mock-token"),
@@ -599,7 +599,9 @@ async def test_fallback_show_image(
     mock_config_entry: MockConfigEntry,
 ) -> None:
     """Test the Spotify media player with a fallback image."""
-    playback = PlaybackState.from_json(load_fixture("playback_episode.json", DOMAIN))
+    playback = PlaybackState.from_json(
+        await async_load_fixture(hass, "playback_episode.json", DOMAIN)
+    )
     playback.item.images = []
     mock_spotify.return_value.get_playback.return_value = playback
     with patch("secrets.token_hex", return_value="mock-token"):
@@ -619,7 +621,9 @@ async def test_no_episode_images(
     mock_config_entry: MockConfigEntry,
 ) -> None:
     """Test the Spotify media player with no episode images."""
-    playback = PlaybackState.from_json(load_fixture("playback_episode.json", DOMAIN))
+    playback = PlaybackState.from_json(
+        await async_load_fixture(hass, "playback_episode.json", DOMAIN)
+    )
     playback.item.images = []
     playback.item.show.images = []
     mock_spotify.return_value.get_playback.return_value = playback
diff --git a/tests/components/stt/test_init.py b/tests/components/stt/test_init.py
index cada4b0c533..98a4117293e 100644
--- a/tests/components/stt/test_init.py
+++ b/tests/components/stt/test_init.py
@@ -15,6 +15,7 @@ from homeassistant.components.stt import (
     async_get_speech_to_text_engine,
 )
 from homeassistant.config_entries import ConfigEntry, ConfigEntryState, ConfigFlow
+from homeassistant.const import Platform
 from homeassistant.core import HomeAssistant, State
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from homeassistant.setup import async_setup_component
@@ -122,14 +123,16 @@ async def mock_config_entry_setup(
         hass: HomeAssistant, config_entry: ConfigEntry
     ) -> bool:
         """Set up test config entry."""
-        await hass.config_entries.async_forward_entry_setups(config_entry, [DOMAIN])
+        await hass.config_entries.async_forward_entry_setups(
+            config_entry, [Platform.STT]
+        )
         return True
 
     async def async_unload_entry_init(
         hass: HomeAssistant, config_entry: ConfigEntry
     ) -> bool:
         """Unload up test config entry."""
-        await hass.config_entries.async_forward_entry_unload(config_entry, DOMAIN)
+        await hass.config_entries.async_forward_entry_unload(config_entry, Platform.STT)
         return True
 
     mock_integration(
diff --git a/tests/components/subaru/test_diagnostics.py b/tests/components/subaru/test_diagnostics.py
index 651689330b1..f93b62b570d 100644
--- a/tests/components/subaru/test_diagnostics.py
+++ b/tests/components/subaru/test_diagnostics.py
@@ -18,7 +18,7 @@ from .conftest import (
     advance_time_to_next_fetch,
 )
 
-from tests.common import load_fixture
+from tests.common import async_load_fixture
 from tests.components.diagnostics import (
     get_diagnostics_for_config_entry,
     get_diagnostics_for_device,
@@ -58,7 +58,7 @@ async def test_device_diagnostics(
     )
     assert reg_device is not None
 
-    raw_data = json.loads(load_fixture("subaru/raw_api_data.json"))
+    raw_data = json.loads(await async_load_fixture(hass, "raw_api_data.json", DOMAIN))
     with patch(MOCK_API_GET_RAW_DATA, return_value=raw_data) as mock_get_raw_data:
         assert (
             await get_diagnostics_for_device(
diff --git a/tests/components/swiss_public_transport/test_sensor.py b/tests/components/swiss_public_transport/test_sensor.py
index e677be44e3b..56cda2e3485 100644
--- a/tests/components/swiss_public_transport/test_sensor.py
+++ b/tests/components/swiss_public_transport/test_sensor.py
@@ -25,7 +25,7 @@ from . import setup_integration
 from tests.common import (
     MockConfigEntry,
     async_fire_time_changed,
-    load_fixture,
+    async_load_fixture,
     snapshot_platform,
 )
 from tests.test_config_entries import FrozenDateTimeFactory
@@ -94,7 +94,7 @@ async def test_fetching_data(
 
     # Set new data and verify it
     mock_opendata_client.connections = json.loads(
-        load_fixture("connections.json", DOMAIN)
+        await async_load_fixture(hass, "connections.json", DOMAIN)
     )[3:6]
     freezer.tick(DEFAULT_UPDATE_TIME)
     async_fire_time_changed(hass)
@@ -114,7 +114,7 @@ async def test_fetching_data(
     # Recover and fetch new data again
     mock_opendata_client.async_get_data.side_effect = None
     mock_opendata_client.connections = json.loads(
-        load_fixture("connections.json", DOMAIN)
+        await async_load_fixture(hass, "connections.json", DOMAIN)
     )[6:9]
     freezer.tick(DEFAULT_UPDATE_TIME)
     async_fire_time_changed(hass)
diff --git a/tests/components/swiss_public_transport/test_service.py b/tests/components/swiss_public_transport/test_service.py
index 4009327e77d..135fb07fda8 100644
--- a/tests/components/swiss_public_transport/test_service.py
+++ b/tests/components/swiss_public_transport/test_service.py
@@ -27,7 +27,7 @@ from homeassistant.exceptions import HomeAssistantError, ServiceValidationError
 
 from . import setup_integration
 
-from tests.common import MockConfigEntry, load_fixture
+from tests.common import MockConfigEntry, async_load_fixture
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -68,9 +68,9 @@ async def test_service_call_fetch_connections_success(
         "homeassistant.components.swiss_public_transport.OpendataTransport",
         return_value=AsyncMock(),
     ) as mock:
-        mock().connections = json.loads(load_fixture("connections.json", DOMAIN))[
-            0 : data.get(ATTR_LIMIT, CONNECTIONS_COUNT) + 2
-        ]
+        mock().connections = json.loads(
+            await async_load_fixture(hass, "connections.json", DOMAIN)
+        )[0 : data.get(ATTR_LIMIT, CONNECTIONS_COUNT) + 2]
 
         await setup_integration(hass, config_entry)
 
@@ -136,7 +136,9 @@ async def test_service_call_fetch_connections_error(
         "homeassistant.components.swiss_public_transport.OpendataTransport",
         return_value=AsyncMock(),
     ) as mock:
-        mock().connections = json.loads(load_fixture("connections.json", DOMAIN))
+        mock().connections = json.loads(
+            await async_load_fixture(hass, "connections.json", DOMAIN)
+        )
 
         await setup_integration(hass, config_entry)
 
@@ -176,7 +178,9 @@ async def test_service_call_load_unload(
         "homeassistant.components.swiss_public_transport.OpendataTransport",
         return_value=AsyncMock(),
     ) as mock:
-        mock().connections = json.loads(load_fixture("connections.json", DOMAIN))
+        mock().connections = json.loads(
+            await async_load_fixture(hass, "connections.json", DOMAIN)
+        )
 
         await setup_integration(hass, config_entry)
 
diff --git a/tests/components/switchbee/test_config_flow.py b/tests/components/switchbee/test_config_flow.py
index c9132972ab4..e2bd8fedee3 100644
--- a/tests/components/switchbee/test_config_flow.py
+++ b/tests/components/switchbee/test_config_flow.py
@@ -14,14 +14,16 @@ from homeassistant.data_entry_flow import FlowResultType
 
 from . import MOCK_FAILED_TO_LOGIN_MSG, MOCK_INVALID_TOKEN_MGS
 
-from tests.common import MockConfigEntry, load_fixture
+from tests.common import MockConfigEntry, async_load_fixture
 
 
 @pytest.mark.parametrize("test_cucode_in_coordinator_data", [False, True])
 async def test_form(hass: HomeAssistant, test_cucode_in_coordinator_data) -> None:
     """Test we get the form."""
 
-    coordinator_data = json.loads(load_fixture("switchbee.json", "switchbee"))
+    coordinator_data = json.loads(
+        await async_load_fixture(hass, "switchbee.json", DOMAIN)
+    )
 
     if test_cucode_in_coordinator_data:
         coordinator_data["data"]["cuCode"] = "300F123456"
@@ -138,7 +140,9 @@ async def test_form_unknown_error(hass: HomeAssistant) -> None:
 async def test_form_entry_exists(hass: HomeAssistant) -> None:
     """Test we handle an already existing entry."""
 
-    coordinator_data = json.loads(load_fixture("switchbee.json", "switchbee"))
+    coordinator_data = json.loads(
+        await async_load_fixture(hass, "switchbee.json", DOMAIN)
+    )
     MockConfigEntry(
         unique_id="a8:21:08:e7:67:b6",
         domain=DOMAIN,
diff --git a/tests/components/switchbot_cloud/test_config_flow.py b/tests/components/switchbot_cloud/test_config_flow.py
index 1d49b503ef2..5eef1805a5a 100644
--- a/tests/components/switchbot_cloud/test_config_flow.py
+++ b/tests/components/switchbot_cloud/test_config_flow.py
@@ -6,8 +6,8 @@ import pytest
 
 from homeassistant import config_entries
 from homeassistant.components.switchbot_cloud.config_flow import (
-    CannotConnect,
-    InvalidAuth,
+    SwitchBotAuthenticationError,
+    SwitchBotConnectionError,
 )
 from homeassistant.components.switchbot_cloud.const import DOMAIN, ENTRY_TITLE
 from homeassistant.const import CONF_API_KEY, CONF_API_TOKEN
@@ -57,8 +57,8 @@ async def test_form(hass: HomeAssistant, mock_setup_entry: AsyncMock) -> None:
 @pytest.mark.parametrize(
     ("error", "message"),
     [
-        (InvalidAuth, "invalid_auth"),
-        (CannotConnect, "cannot_connect"),
+        (SwitchBotAuthenticationError, "invalid_auth"),
+        (SwitchBotConnectionError, "cannot_connect"),
         (Exception, "unknown"),
     ],
 )
diff --git a/tests/components/switchbot_cloud/test_init.py b/tests/components/switchbot_cloud/test_init.py
index bab9200e7c9..b55106e90d9 100644
--- a/tests/components/switchbot_cloud/test_init.py
+++ b/tests/components/switchbot_cloud/test_init.py
@@ -3,7 +3,13 @@
 from unittest.mock import patch
 
 import pytest
-from switchbot_api import CannotConnect, Device, InvalidAuth, PowerState, Remote
+from switchbot_api import (
+    Device,
+    PowerState,
+    Remote,
+    SwitchBotAuthenticationError,
+    SwitchBotConnectionError,
+)
 
 from homeassistant.components.switchbot_cloud import SwitchBotAPI
 from homeassistant.config_entries import ConfigEntryState
@@ -127,8 +133,8 @@ async def test_setup_entry_success(
 @pytest.mark.parametrize(
     ("error", "state"),
     [
-        (InvalidAuth, ConfigEntryState.SETUP_ERROR),
-        (CannotConnect, ConfigEntryState.SETUP_RETRY),
+        (SwitchBotAuthenticationError, ConfigEntryState.SETUP_ERROR),
+        (SwitchBotConnectionError, ConfigEntryState.SETUP_RETRY),
     ],
 )
 async def test_setup_entry_fails_when_listing_devices(
@@ -162,7 +168,7 @@ async def test_setup_entry_fails_when_refreshing(
             hubDeviceId="test-hub-id",
         )
     ]
-    mock_get_status.side_effect = CannotConnect
+    mock_get_status.side_effect = SwitchBotConnectionError
     entry = await configure_integration(hass)
     assert entry.state is ConfigEntryState.SETUP_RETRY
 
diff --git a/tests/components/tado/test_service.py b/tests/components/tado/test_service.py
index 336bef55ea1..0bbde9de76d 100644
--- a/tests/components/tado/test_service.py
+++ b/tests/components/tado/test_service.py
@@ -17,7 +17,7 @@ from homeassistant.exceptions import HomeAssistantError
 
 from .util import async_init_integration
 
-from tests.common import MockConfigEntry, load_fixture
+from tests.common import MockConfigEntry, async_load_fixture
 
 
 async def test_has_services(
@@ -38,7 +38,7 @@ async def test_add_meter_readings(
     await async_init_integration(hass)
 
     config_entry: MockConfigEntry = hass.config_entries.async_entries(DOMAIN)[0]
-    fixture: str = load_fixture("tado/add_readings_success.json")
+    fixture: str = await async_load_fixture(hass, "add_readings_success.json", DOMAIN)
     with patch(
         "PyTado.interface.api.Tado.set_eiq_meter_readings",
         return_value=json.loads(fixture),
@@ -91,7 +91,9 @@ async def test_add_meter_readings_invalid(
     await async_init_integration(hass)
 
     config_entry: MockConfigEntry = hass.config_entries.async_entries(DOMAIN)[0]
-    fixture: str = load_fixture("tado/add_readings_invalid_meter_reading.json")
+    fixture: str = await async_load_fixture(
+        hass, "add_readings_invalid_meter_reading.json", DOMAIN
+    )
     with (
         patch(
             "PyTado.interface.api.Tado.set_eiq_meter_readings",
@@ -120,7 +122,9 @@ async def test_add_meter_readings_duplicate(
     await async_init_integration(hass)
 
     config_entry: MockConfigEntry = hass.config_entries.async_entries(DOMAIN)[0]
-    fixture: str = load_fixture("tado/add_readings_duplicated_meter_reading.json")
+    fixture: str = await async_load_fixture(
+        hass, "add_readings_duplicated_meter_reading.json", DOMAIN
+    )
     with (
         patch(
             "PyTado.interface.api.Tado.set_eiq_meter_readings",
diff --git a/tests/components/tado/util.py b/tests/components/tado/util.py
index 6fd333dff51..8ee7209acb2 100644
--- a/tests/components/tado/util.py
+++ b/tests/components/tado/util.py
@@ -5,7 +5,7 @@ import requests_mock
 from homeassistant.components.tado import CONF_REFRESH_TOKEN, DOMAIN
 from homeassistant.core import HomeAssistant
 
-from tests.common import MockConfigEntry, load_fixture
+from tests.common import MockConfigEntry, async_load_fixture
 
 
 async def async_init_integration(
@@ -14,172 +14,173 @@ async def async_init_integration(
 ):
     """Set up the tado integration in Home Assistant."""
 
-    token_fixture = "tado/token.json"
-    devices_fixture = "tado/devices.json"
-    mobile_devices_fixture = "tado/mobile_devices.json"
-    me_fixture = "tado/me.json"
-    weather_fixture = "tado/weather.json"
-    home_fixture = "tado/home.json"
-    home_state_fixture = "tado/home_state.json"
-    zones_fixture = "tado/zones.json"
-    zone_states_fixture = "tado/zone_states.json"
+    token_fixture = "token.json"
+    devices_fixture = "devices.json"
+    mobile_devices_fixture = "mobile_devices.json"
+    me_fixture = "me.json"
+    weather_fixture = "weather.json"
+    home_fixture = "home.json"
+    home_state_fixture = "home_state.json"
+    zones_fixture = "zones.json"
+    zone_states_fixture = "zone_states.json"
 
     # WR1 Device
-    device_wr1_fixture = "tado/device_wr1.json"
+    device_wr1_fixture = "device_wr1.json"
 
     # Smart AC with fanLevel, Vertical and Horizontal swings
-    zone_6_state_fixture = "tado/smartac4.with_fanlevel.json"
-    zone_6_capabilities_fixture = (
-        "tado/zone_with_fanlevel_horizontal_vertical_swing.json"
-    )
+    zone_6_state_fixture = "smartac4.with_fanlevel.json"
+    zone_6_capabilities_fixture = "zone_with_fanlevel_horizontal_vertical_swing.json"
 
     # Smart AC with Swing
-    zone_5_state_fixture = "tado/smartac3.with_swing.json"
-    zone_5_capabilities_fixture = "tado/zone_with_swing_capabilities.json"
+    zone_5_state_fixture = "smartac3.with_swing.json"
+    zone_5_capabilities_fixture = "zone_with_swing_capabilities.json"
 
     # Water Heater 2
-    zone_4_state_fixture = "tado/tadov2.water_heater.heating.json"
-    zone_4_capabilities_fixture = "tado/water_heater_zone_capabilities.json"
+    zone_4_state_fixture = "tadov2.water_heater.heating.json"
+    zone_4_capabilities_fixture = "water_heater_zone_capabilities.json"
 
     # Smart AC
-    zone_3_state_fixture = "tado/smartac3.cool_mode.json"
-    zone_3_capabilities_fixture = "tado/zone_capabilities.json"
+    zone_3_state_fixture = "smartac3.cool_mode.json"
+    zone_3_capabilities_fixture = "zone_capabilities.json"
 
     # Water Heater
-    zone_2_state_fixture = "tado/tadov2.water_heater.auto_mode.json"
-    zone_2_capabilities_fixture = "tado/water_heater_zone_capabilities.json"
+    zone_2_state_fixture = "tadov2.water_heater.auto_mode.json"
+    zone_2_capabilities_fixture = "water_heater_zone_capabilities.json"
 
     # Tado V2 with manual heating
-    zone_1_state_fixture = "tado/tadov2.heating.manual_mode.json"
-    zone_1_capabilities_fixture = "tado/tadov2.zone_capabilities.json"
+    zone_1_state_fixture = "tadov2.heating.manual_mode.json"
+    zone_1_capabilities_fixture = "tadov2.zone_capabilities.json"
 
     # Device Temp Offset
-    device_temp_offset = "tado/device_temp_offset.json"
+    device_temp_offset = "device_temp_offset.json"
 
     # Zone Default Overlay
-    zone_def_overlay = "tado/zone_default_overlay.json"
+    zone_def_overlay = "zone_default_overlay.json"
 
     with requests_mock.mock() as m:
-        m.post("https://auth.tado.com/oauth/token", text=load_fixture(token_fixture))
+        m.post(
+            "https://auth.tado.com/oauth/token",
+            text=await async_load_fixture(hass, token_fixture, DOMAIN),
+        )
         m.get(
             "https://my.tado.com/api/v2/me",
-            text=load_fixture(me_fixture),
+            text=await async_load_fixture(hass, me_fixture, DOMAIN),
         )
         m.get(
             "https://my.tado.com/api/v2/homes/1/",
-            text=load_fixture(home_fixture),
+            text=await async_load_fixture(hass, home_fixture, DOMAIN),
         )
         m.get(
             "https://my.tado.com/api/v2/homes/1/weather",
-            text=load_fixture(weather_fixture),
+            text=await async_load_fixture(hass, weather_fixture, DOMAIN),
         )
         m.get(
             "https://my.tado.com/api/v2/homes/1/state",
-            text=load_fixture(home_state_fixture),
+            text=await async_load_fixture(hass, home_state_fixture, DOMAIN),
         )
         m.get(
             "https://my.tado.com/api/v2/homes/1/devices",
-            text=load_fixture(devices_fixture),
+            text=await async_load_fixture(hass, devices_fixture, DOMAIN),
         )
         m.get(
             "https://my.tado.com/api/v2/homes/1/mobileDevices",
-            text=load_fixture(mobile_devices_fixture),
+            text=await async_load_fixture(hass, mobile_devices_fixture, DOMAIN),
         )
         m.get(
             "https://my.tado.com/api/v2/devices/WR1/",
-            text=load_fixture(device_wr1_fixture),
+            text=await async_load_fixture(hass, device_wr1_fixture, DOMAIN),
         )
         m.get(
             "https://my.tado.com/api/v2/devices/WR1/temperatureOffset",
-            text=load_fixture(device_temp_offset),
+            text=await async_load_fixture(hass, device_temp_offset, DOMAIN),
         )
         m.get(
             "https://my.tado.com/api/v2/devices/WR4/temperatureOffset",
-            text=load_fixture(device_temp_offset),
+            text=await async_load_fixture(hass, device_temp_offset, DOMAIN),
         )
         m.get(
             "https://my.tado.com/api/v2/homes/1/zones",
-            text=load_fixture(zones_fixture),
+            text=await async_load_fixture(hass, zones_fixture, DOMAIN),
         )
         m.get(
             "https://my.tado.com/api/v2/homes/1/zoneStates",
-            text=load_fixture(zone_states_fixture),
+            text=await async_load_fixture(hass, zone_states_fixture, DOMAIN),
         )
         m.get(
             "https://my.tado.com/api/v2/homes/1/zones/6/capabilities",
-            text=load_fixture(zone_6_capabilities_fixture),
+            text=await async_load_fixture(hass, zone_6_capabilities_fixture, DOMAIN),
         )
         m.get(
             "https://my.tado.com/api/v2/homes/1/zones/5/capabilities",
-            text=load_fixture(zone_5_capabilities_fixture),
+            text=await async_load_fixture(hass, zone_5_capabilities_fixture, DOMAIN),
         )
         m.get(
             "https://my.tado.com/api/v2/homes/1/zones/4/capabilities",
-            text=load_fixture(zone_4_capabilities_fixture),
+            text=await async_load_fixture(hass, zone_4_capabilities_fixture, DOMAIN),
         )
         m.get(
             "https://my.tado.com/api/v2/homes/1/zones/3/capabilities",
-            text=load_fixture(zone_3_capabilities_fixture),
+            text=await async_load_fixture(hass, zone_3_capabilities_fixture, DOMAIN),
         )
         m.get(
             "https://my.tado.com/api/v2/homes/1/zones/2/capabilities",
-            text=load_fixture(zone_2_capabilities_fixture),
+            text=await async_load_fixture(hass, zone_2_capabilities_fixture, DOMAIN),
         )
         m.get(
             "https://my.tado.com/api/v2/homes/1/zones/1/capabilities",
-            text=load_fixture(zone_1_capabilities_fixture),
+            text=await async_load_fixture(hass, zone_1_capabilities_fixture, DOMAIN),
         )
         m.get(
             "https://my.tado.com/api/v2/homes/1/zones/1/defaultOverlay",
-            text=load_fixture(zone_def_overlay),
+            text=await async_load_fixture(hass, zone_def_overlay, DOMAIN),
         )
         m.get(
             "https://my.tado.com/api/v2/homes/1/zones/2/defaultOverlay",
-            text=load_fixture(zone_def_overlay),
+            text=await async_load_fixture(hass, zone_def_overlay, DOMAIN),
         )
         m.get(
             "https://my.tado.com/api/v2/homes/1/zones/3/defaultOverlay",
-            text=load_fixture(zone_def_overlay),
+            text=await async_load_fixture(hass, zone_def_overlay, DOMAIN),
         )
         m.get(
             "https://my.tado.com/api/v2/homes/1/zones/4/defaultOverlay",
-            text=load_fixture(zone_def_overlay),
+            text=await async_load_fixture(hass, zone_def_overlay, DOMAIN),
         )
         m.get(
             "https://my.tado.com/api/v2/homes/1/zones/5/defaultOverlay",
-            text=load_fixture(zone_def_overlay),
+            text=await async_load_fixture(hass, zone_def_overlay, DOMAIN),
         )
         m.get(
             "https://my.tado.com/api/v2/homes/1/zones/6/defaultOverlay",
-            text=load_fixture(zone_def_overlay),
+            text=await async_load_fixture(hass, zone_def_overlay, DOMAIN),
         )
         m.get(
             "https://my.tado.com/api/v2/homes/1/zones/6/state",
-            text=load_fixture(zone_6_state_fixture),
+            text=await async_load_fixture(hass, zone_6_state_fixture, DOMAIN),
         )
         m.get(
             "https://my.tado.com/api/v2/homes/1/zones/5/state",
-            text=load_fixture(zone_5_state_fixture),
+            text=await async_load_fixture(hass, zone_5_state_fixture, DOMAIN),
         )
         m.get(
             "https://my.tado.com/api/v2/homes/1/zones/4/state",
-            text=load_fixture(zone_4_state_fixture),
+            text=await async_load_fixture(hass, zone_4_state_fixture, DOMAIN),
         )
         m.get(
             "https://my.tado.com/api/v2/homes/1/zones/3/state",
-            text=load_fixture(zone_3_state_fixture),
+            text=await async_load_fixture(hass, zone_3_state_fixture, DOMAIN),
         )
         m.get(
             "https://my.tado.com/api/v2/homes/1/zones/2/state",
-            text=load_fixture(zone_2_state_fixture),
+            text=await async_load_fixture(hass, zone_2_state_fixture, DOMAIN),
         )
         m.get(
             "https://my.tado.com/api/v2/homes/1/zones/1/state",
-            text=load_fixture(zone_1_state_fixture),
+            text=await async_load_fixture(hass, zone_1_state_fixture, DOMAIN),
         )
         m.post(
             "https://login.tado.com/oauth2/token",
-            text=load_fixture(token_fixture),
+            text=await async_load_fixture(hass, token_fixture, DOMAIN),
         )
         entry = MockConfigEntry(
             domain=DOMAIN,
diff --git a/tests/components/tedee/snapshots/test_diagnostics.ambr b/tests/components/tedee/snapshots/test_diagnostics.ambr
index 401c519c215..046a8fd210a 100644
--- a/tests/components/tedee/snapshots/test_diagnostics.ambr
+++ b/tests/components/tedee/snapshots/test_diagnostics.ambr
@@ -6,6 +6,7 @@
       'duration_pullspring': 2,
       'is_charging': False,
       'is_connected': True,
+      'is_enabled_auto_pullspring': False,
       'is_enabled_pullspring': 1,
       'lock_id': '**REDACTED**',
       'lock_name': 'Lock-1A2B',
@@ -18,6 +19,7 @@
       'duration_pullspring': 0,
       'is_charging': False,
       'is_connected': True,
+      'is_enabled_auto_pullspring': False,
       'is_enabled_pullspring': 0,
       'lock_id': '**REDACTED**',
       'lock_name': 'Lock-2C3D',
diff --git a/tests/components/tensorflow/__init__.py b/tests/components/tensorflow/__init__.py
new file mode 100644
index 00000000000..458de30c9fa
--- /dev/null
+++ b/tests/components/tensorflow/__init__.py
@@ -0,0 +1 @@
+"""TensorFlow component tests."""
diff --git a/tests/components/tensorflow/test_image_processing.py b/tests/components/tensorflow/test_image_processing.py
new file mode 100644
index 00000000000..06199b9c60c
--- /dev/null
+++ b/tests/components/tensorflow/test_image_processing.py
@@ -0,0 +1,40 @@
+"""Tensorflow test."""
+
+from unittest.mock import Mock, patch
+
+from homeassistant.components.image_processing import DOMAIN as IMAGE_PROCESSING_DOMAINN
+from homeassistant.components.tensorflow import CONF_GRAPH, DOMAIN as TENSORFLOW_DOMAIN
+from homeassistant.const import CONF_ENTITY_ID, CONF_MODEL, CONF_PLATFORM, CONF_SOURCE
+from homeassistant.core import DOMAIN as HOMEASSISTANT_DOMAIN, HomeAssistant
+from homeassistant.helpers import issue_registry as ir
+from homeassistant.setup import async_setup_component
+
+
+@patch.dict("sys.modules", tensorflow=Mock())
+async def test_repair_issue_is_created(
+    hass: HomeAssistant,
+    issue_registry: ir.IssueRegistry,
+) -> None:
+    """Test repair issue is created."""
+    assert await async_setup_component(
+        hass,
+        IMAGE_PROCESSING_DOMAINN,
+        {
+            IMAGE_PROCESSING_DOMAINN: [
+                {
+                    CONF_PLATFORM: TENSORFLOW_DOMAIN,
+                    CONF_SOURCE: [
+                        {CONF_ENTITY_ID: "camera.test_camera"},
+                    ],
+                    CONF_MODEL: {
+                        CONF_GRAPH: ".",
+                    },
+                }
+            ],
+        },
+    )
+    await hass.async_block_till_done()
+    assert (
+        HOMEASSISTANT_DOMAIN,
+        f"deprecated_system_packages_yaml_integration_{TENSORFLOW_DOMAIN}",
+    ) in issue_registry.issues
diff --git a/tests/components/teslemetry/snapshots/test_binary_sensor.ambr b/tests/components/teslemetry/snapshots/test_binary_sensor.ambr
index 8bcd837d06f..06ec0a60434 100644
--- a/tests/components/teslemetry/snapshots/test_binary_sensor.ambr
+++ b/tests/components/teslemetry/snapshots/test_binary_sensor.ambr
@@ -673,7 +673,7 @@
     'last_changed': <ANY>,
     'last_reported': <ANY>,
     'last_updated': <ANY>,
-    'state': 'on',
+    'state': 'unknown',
   })
 # ---
 # name: test_binary_sensor[binary_sensor.test_charge_enable_request-entry]
@@ -3374,7 +3374,7 @@
     'last_changed': <ANY>,
     'last_reported': <ANY>,
     'last_updated': <ANY>,
-    'state': 'on',
+    'state': 'unknown',
   })
 # ---
 # name: test_binary_sensor_refresh[binary_sensor.test_charge_enable_request-statealt]
diff --git a/tests/components/tessie/snapshots/test_media_player.ambr b/tests/components/tessie/snapshots/test_media_player.ambr
index ff0f6c794a7..69a5ca4b86b 100644
--- a/tests/components/tessie/snapshots/test_media_player.ambr
+++ b/tests/components/tessie/snapshots/test_media_player.ambr
@@ -41,7 +41,7 @@
       'device_class': 'speaker',
       'friendly_name': 'Test Media player',
       'supported_features': <MediaPlayerEntityFeature: 0>,
-      'volume_level': 0.22580323309042688,
+      'volume_level': 0.2258032258064516,
     }),
     'context': <ANY>,
     'entity_id': 'media_player.test_media_player',
@@ -64,7 +64,7 @@
       'media_title': 'Song',
       'source': 'Spotify',
       'supported_features': <MediaPlayerEntityFeature: 0>,
-      'volume_level': 0.22580323309042688,
+      'volume_level': 0.2258032258064516,
     }),
     'context': <ANY>,
     'entity_id': 'media_player.test_media_player',
diff --git a/tests/components/todo/conftest.py b/tests/components/todo/conftest.py
index bcee60e1d96..5742f253749 100644
--- a/tests/components/todo/conftest.py
+++ b/tests/components/todo/conftest.py
@@ -6,7 +6,6 @@ from unittest.mock import AsyncMock
 import pytest
 
 from homeassistant.components.todo import (
-    DOMAIN,
     TodoItem,
     TodoItemStatus,
     TodoListEntity,
@@ -38,7 +37,9 @@ def mock_setup_integration(hass: HomeAssistant) -> None:
         hass: HomeAssistant, config_entry: ConfigEntry
     ) -> bool:
         """Set up test config entry."""
-        await hass.config_entries.async_forward_entry_setups(config_entry, [DOMAIN])
+        await hass.config_entries.async_forward_entry_setups(
+            config_entry, [Platform.TODO]
+        )
         return True
 
     async def async_unload_entry_init(
diff --git a/tests/components/tplink/test_diagnostics.py b/tests/components/tplink/test_diagnostics.py
index 7288d631f4a..5587e2af655 100644
--- a/tests/components/tplink/test_diagnostics.py
+++ b/tests/components/tplink/test_diagnostics.py
@@ -5,11 +5,12 @@ import json
 from kasa import Device
 import pytest
 
+from homeassistant.components.tplink.const import DOMAIN
 from homeassistant.core import HomeAssistant
 
 from . import _mocked_device, initialize_config_entry_for_device
 
-from tests.common import load_fixture
+from tests.common import async_load_fixture
 from tests.components.diagnostics import get_diagnostics_for_config_entry
 from tests.typing import ClientSessionGenerator
 
@@ -40,7 +41,7 @@ async def test_diagnostics(
     expected_oui: str | None,
 ) -> None:
     """Test diagnostics for config entry."""
-    diagnostics_data = json.loads(load_fixture(fixture_file, "tplink"))
+    diagnostics_data = json.loads(await async_load_fixture(hass, fixture_file, DOMAIN))
 
     mocked_dev.internal_state = diagnostics_data["device_last_response"]
 
diff --git a/tests/components/trace/test_websocket_api.py b/tests/components/trace/test_websocket_api.py
index 43664c6e7ce..623296b1931 100644
--- a/tests/components/trace/test_websocket_api.py
+++ b/tests/components/trace/test_websocket_api.py
@@ -16,7 +16,7 @@ from homeassistant.helpers.typing import UNDEFINED
 from homeassistant.setup import async_setup_component
 from homeassistant.util.uuid import random_uuid_hex
 
-from tests.common import load_fixture
+from tests.common import async_load_fixture
 from tests.typing import WebSocketGenerator
 
 
@@ -449,7 +449,9 @@ async def test_restore_traces(
         msg_id += 1
         return msg_id
 
-    saved_traces = json.loads(load_fixture(f"trace/{domain}_saved_traces.json"))
+    saved_traces = json.loads(
+        await async_load_fixture(hass, f"{domain}_saved_traces.json", "trace")
+    )
     hass_storage["trace.saved_traces"] = saved_traces
     await _setup_automation_or_script(hass, domain, [])
     await hass.async_start()
@@ -628,7 +630,9 @@ async def test_restore_traces_overflow(
         msg_id += 1
         return msg_id
 
-    saved_traces = json.loads(load_fixture(f"trace/{domain}_saved_traces.json"))
+    saved_traces = json.loads(
+        await async_load_fixture(hass, f"{domain}_saved_traces.json", "trace")
+    )
     hass_storage["trace.saved_traces"] = saved_traces
     sun_config = {
         "id": "sun",
@@ -709,7 +713,9 @@ async def test_restore_traces_late_overflow(
         msg_id += 1
         return msg_id
 
-    saved_traces = json.loads(load_fixture(f"trace/{domain}_saved_traces.json"))
+    saved_traces = json.loads(
+        await async_load_fixture(hass, f"{domain}_saved_traces.json", "trace")
+    )
     hass_storage["trace.saved_traces"] = saved_traces
     sun_config = {
         "id": "sun",
diff --git a/tests/components/tts/common.py b/tests/components/tts/common.py
index 171334c136a..da960b145d9 100644
--- a/tests/components/tts/common.py
+++ b/tests/components/tts/common.py
@@ -25,6 +25,7 @@ from homeassistant.components.tts import (
     _get_cache_files,
 )
 from homeassistant.config_entries import ConfigEntry
+from homeassistant.const import Platform
 from homeassistant.core import HomeAssistant, callback
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from homeassistant.helpers.typing import ConfigType, DiscoveryInfoType
@@ -230,14 +231,16 @@ async def mock_config_entry_setup(
         hass: HomeAssistant, config_entry: ConfigEntry
     ) -> bool:
         """Set up test config entry."""
-        await hass.config_entries.async_forward_entry_setups(config_entry, [TTS_DOMAIN])
+        await hass.config_entries.async_forward_entry_setups(
+            config_entry, [Platform.TTS]
+        )
         return True
 
     async def async_unload_entry_init(
         hass: HomeAssistant, config_entry: ConfigEntry
     ) -> bool:
         """Unload test config entry."""
-        await hass.config_entries.async_forward_entry_unload(config_entry, TTS_DOMAIN)
+        await hass.config_entries.async_forward_entry_unload(config_entry, Platform.TTS)
         return True
 
     mock_integration(
diff --git a/tests/components/uk_transport/test_sensor.py b/tests/components/uk_transport/test_sensor.py
index ba547c5eecc..ba8726209bd 100644
--- a/tests/components/uk_transport/test_sensor.py
+++ b/tests/components/uk_transport/test_sensor.py
@@ -22,7 +22,7 @@ from homeassistant.core import HomeAssistant
 from homeassistant.setup import async_setup_component
 from homeassistant.util.dt import now
 
-from tests.common import load_fixture
+from tests.common import async_load_fixture
 
 BUS_ATCOCODE = "340000368SHE"
 BUS_DIRECTION = "Wantage"
@@ -50,7 +50,7 @@ async def test_bus(hass: HomeAssistant) -> None:
     """Test for operational uk_transport sensor with proper attributes."""
     with requests_mock.Mocker() as mock_req:
         uri = re.compile(UkTransportSensor.TRANSPORT_API_URL_BASE + "*")
-        mock_req.get(uri, text=load_fixture("uk_transport/bus.json"))
+        mock_req.get(uri, text=await async_load_fixture(hass, "uk_transport/bus.json"))
         assert await async_setup_component(hass, "sensor", VALID_CONFIG)
         await hass.async_block_till_done()
 
@@ -75,7 +75,9 @@ async def test_train(hass: HomeAssistant) -> None:
         patch("homeassistant.util.dt.now", return_value=now().replace(hour=13)),
     ):
         uri = re.compile(UkTransportSensor.TRANSPORT_API_URL_BASE + "*")
-        mock_req.get(uri, text=load_fixture("uk_transport/train.json"))
+        mock_req.get(
+            uri, text=await async_load_fixture(hass, "uk_transport/train.json")
+        )
         assert await async_setup_component(hass, "sensor", VALID_CONFIG)
         await hass.async_block_till_done()
 
diff --git a/tests/components/update/test_init.py b/tests/components/update/test_init.py
index f3eb3f9344c..ef1ee22bb57 100644
--- a/tests/components/update/test_init.py
+++ b/tests/components/update/test_init.py
@@ -40,6 +40,7 @@ from homeassistant.const import (
     STATE_ON,
     STATE_UNKNOWN,
     EntityCategory,
+    Platform,
 )
 from homeassistant.core import HomeAssistant, State, callback
 from homeassistant.exceptions import HomeAssistantError
@@ -818,7 +819,9 @@ async def test_name(hass: HomeAssistant) -> None:
         hass: HomeAssistant, config_entry: ConfigEntry
     ) -> bool:
         """Set up test config entry."""
-        await hass.config_entries.async_forward_entry_setups(config_entry, [DOMAIN])
+        await hass.config_entries.async_forward_entry_setups(
+            config_entry, [Platform.UPDATE]
+        )
         return True
 
     mock_platform(hass, f"{TEST_DOMAIN}.config_flow")
diff --git a/tests/components/vacuum/__init__.py b/tests/components/vacuum/__init__.py
index 26e31a87eee..7e27af46bac 100644
--- a/tests/components/vacuum/__init__.py
+++ b/tests/components/vacuum/__init__.py
@@ -3,7 +3,6 @@
 from typing import Any
 
 from homeassistant.components.vacuum import (
-    DOMAIN,
     StateVacuumEntity,
     VacuumActivity,
     VacuumEntityFeature,
@@ -67,7 +66,9 @@ async def help_async_setup_entry_init(
     hass: HomeAssistant, config_entry: ConfigEntry
 ) -> bool:
     """Set up test config entry."""
-    await hass.config_entries.async_forward_entry_setups(config_entry, [DOMAIN])
+    await hass.config_entries.async_forward_entry_setups(
+        config_entry, [Platform.VACUUM]
+    )
     return True
 
 
diff --git a/tests/components/vacuum/conftest.py b/tests/components/vacuum/conftest.py
index 2c700daece0..5938caa5ce4 100644
--- a/tests/components/vacuum/conftest.py
+++ b/tests/components/vacuum/conftest.py
@@ -7,6 +7,7 @@ import pytest
 
 from homeassistant.components.vacuum import DOMAIN as VACUUM_DOMAIN, VacuumEntityFeature
 from homeassistant.config_entries import ConfigEntry, ConfigFlow
+from homeassistant.const import Platform
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers import entity_registry as er, frame
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
@@ -68,7 +69,7 @@ async def setup_vacuum_platform_test_entity(
     ) -> bool:
         """Set up test config entry."""
         await hass.config_entries.async_forward_entry_setups(
-            config_entry, [VACUUM_DOMAIN]
+            config_entry, [Platform.VACUUM]
         )
         return True
 
diff --git a/tests/components/venstar/util.py b/tests/components/venstar/util.py
index 44b3efe0720..f1b8d3a0aee 100644
--- a/tests/components/venstar/util.py
+++ b/tests/components/venstar/util.py
@@ -3,11 +3,12 @@
 import requests_mock
 
 from homeassistant.components.climate import DOMAIN as CLIMATE_DOMAIN
+from homeassistant.components.venstar.const import DOMAIN
 from homeassistant.const import CONF_HOST, CONF_PLATFORM
 from homeassistant.core import HomeAssistant
 from homeassistant.setup import async_setup_component
 
-from tests.common import load_fixture
+from tests.common import async_load_fixture
 
 TEST_MODELS = ["t2k", "colortouch"]
 
@@ -23,19 +24,21 @@ def mock_venstar_devices(f):
             for model in TEST_MODELS:
                 m.get(
                     f"http://venstar-{model}.localdomain/",
-                    text=load_fixture(f"venstar/{model}_root.json"),
+                    text=await async_load_fixture(hass, f"{model}_root.json", DOMAIN),
                 )
                 m.get(
                     f"http://venstar-{model}.localdomain/query/info",
-                    text=load_fixture(f"venstar/{model}_info.json"),
+                    text=await async_load_fixture(hass, f"{model}_info.json", DOMAIN),
                 )
                 m.get(
                     f"http://venstar-{model}.localdomain/query/sensors",
-                    text=load_fixture(f"venstar/{model}_sensors.json"),
+                    text=await async_load_fixture(
+                        hass, f"{model}_sensors.json", DOMAIN
+                    ),
                 )
                 m.get(
                     f"http://venstar-{model}.localdomain/query/alerts",
-                    text=load_fixture(f"venstar/{model}_alerts.json"),
+                    text=await async_load_fixture(hass, f"{model}_alerts.json", DOMAIN),
                 )
             await f(hass)
 
diff --git a/tests/components/vulcan/test_config_flow.py b/tests/components/vulcan/test_config_flow.py
index a51d9727126..e0b7c1a4fdc 100644
--- a/tests/components/vulcan/test_config_flow.py
+++ b/tests/components/vulcan/test_config_flow.py
@@ -15,13 +15,14 @@ from vulcan import (
 from vulcan.model import Student
 
 from homeassistant import config_entries
-from homeassistant.components.vulcan import config_flow, const, register
+from homeassistant.components.vulcan import config_flow, register
 from homeassistant.components.vulcan.config_flow import ClientConnectionError, Keystore
+from homeassistant.components.vulcan.const import DOMAIN
 from homeassistant.const import CONF_PIN, CONF_REGION, CONF_TOKEN
 from homeassistant.core import HomeAssistant
 from homeassistant.data_entry_flow import FlowResultType
 
-from tests.common import MockConfigEntry, load_fixture
+from tests.common import MockConfigEntry, async_load_fixture
 
 fake_keystore = Keystore("", "", "", "", "")
 fake_account = Account(
@@ -53,10 +54,10 @@ async def test_config_flow_auth_success(
     mock_keystore.return_value = fake_keystore
     mock_account.return_value = fake_account
     mock_student.return_value = [
-        Student.load(load_fixture("fake_student_1.json", "vulcan"))
+        Student.load(await async_load_fixture(hass, "fake_student_1.json", DOMAIN))
     ]
     result = await hass.config_entries.flow.async_init(
-        const.DOMAIN, context={"source": config_entries.SOURCE_USER}
+        DOMAIN, context={"source": config_entries.SOURCE_USER}
     )
 
     assert result["type"] is FlowResultType.FORM
@@ -90,12 +91,12 @@ async def test_config_flow_auth_success_with_multiple_students(
     mock_student.return_value = [
         Student.load(student)
         for student in (
-            load_fixture("fake_student_1.json", "vulcan"),
-            load_fixture("fake_student_2.json", "vulcan"),
+            await async_load_fixture(hass, "fake_student_1.json", DOMAIN),
+            await async_load_fixture(hass, "fake_student_2.json", DOMAIN),
         )
     ]
     result = await hass.config_entries.flow.async_init(
-        const.DOMAIN, context={"source": config_entries.SOURCE_USER}
+        DOMAIN, context={"source": config_entries.SOURCE_USER}
     )
 
     assert result["type"] is FlowResultType.FORM
@@ -135,10 +136,10 @@ async def test_config_flow_reauth_success(
     mock_keystore.return_value = fake_keystore
     mock_account.return_value = fake_account
     mock_student.return_value = [
-        Student.load(load_fixture("fake_student_1.json", "vulcan"))
+        Student.load(await async_load_fixture(hass, "fake_student_1.json", DOMAIN))
     ]
     entry = MockConfigEntry(
-        domain=const.DOMAIN,
+        domain=DOMAIN,
         unique_id="0",
         data={"student_id": "0"},
     )
@@ -173,10 +174,10 @@ async def test_config_flow_reauth_without_matching_entries(
     mock_keystore.return_value = fake_keystore
     mock_account.return_value = fake_account
     mock_student.return_value = [
-        Student.load(load_fixture("fake_student_1.json", "vulcan"))
+        Student.load(await async_load_fixture(hass, "fake_student_1.json", DOMAIN))
     ]
     entry = MockConfigEntry(
-        domain=const.DOMAIN,
+        domain=DOMAIN,
         unique_id="0",
         data={"student_id": "1"},
     )
@@ -205,7 +206,7 @@ async def test_config_flow_reauth_with_errors(
     mock_keystore.return_value = fake_keystore
     mock_account.return_value = fake_account
     entry = MockConfigEntry(
-        domain=const.DOMAIN,
+        domain=DOMAIN,
         unique_id="0",
         data={"student_id": "0"},
     )
@@ -303,16 +304,18 @@ async def test_multiple_config_entries(
     mock_keystore.return_value = fake_keystore
     mock_account.return_value = fake_account
     mock_student.return_value = [
-        Student.load(load_fixture("fake_student_1.json", "vulcan"))
+        Student.load(await async_load_fixture(hass, "fake_student_1.json", DOMAIN))
     ]
     MockConfigEntry(
-        domain=const.DOMAIN,
+        domain=DOMAIN,
         unique_id="123456",
-        data=json.loads(load_fixture("fake_config_entry_data.json", "vulcan")),
+        data=json.loads(
+            await async_load_fixture(hass, "fake_config_entry_data.json", DOMAIN)
+        ),
     ).add_to_hass(hass)
     await register.register("token", "region", "000000")
     result = await hass.config_entries.flow.async_init(
-        const.DOMAIN, context={"source": config_entries.SOURCE_USER}
+        DOMAIN, context={"source": config_entries.SOURCE_USER}
     )
 
     assert result["type"] is FlowResultType.FORM
@@ -348,16 +351,18 @@ async def test_multiple_config_entries_using_saved_credentials(
 ) -> None:
     """Test a successful config flow for multiple config entries using saved credentials."""
     mock_student.return_value = [
-        Student.load(load_fixture("fake_student_1.json", "vulcan"))
+        Student.load(await async_load_fixture(hass, "fake_student_1.json", DOMAIN))
     ]
     MockConfigEntry(
-        domain=const.DOMAIN,
+        domain=DOMAIN,
         unique_id="123456",
-        data=json.loads(load_fixture("fake_config_entry_data.json", "vulcan")),
+        data=json.loads(
+            await async_load_fixture(hass, "fake_config_entry_data.json", DOMAIN)
+        ),
     ).add_to_hass(hass)
 
     result = await hass.config_entries.flow.async_init(
-        const.DOMAIN, context={"source": config_entries.SOURCE_USER}
+        DOMAIN, context={"source": config_entries.SOURCE_USER}
     )
 
     assert result["type"] is FlowResultType.FORM
@@ -384,17 +389,19 @@ async def test_multiple_config_entries_using_saved_credentials_2(
 ) -> None:
     """Test a successful config flow for multiple config entries using saved credentials (different situation)."""
     mock_student.return_value = [
-        Student.load(load_fixture("fake_student_1.json", "vulcan")),
-        Student.load(load_fixture("fake_student_2.json", "vulcan")),
+        Student.load(await async_load_fixture(hass, "fake_student_1.json", DOMAIN)),
+        Student.load(await async_load_fixture(hass, "fake_student_2.json", DOMAIN)),
     ]
     MockConfigEntry(
-        domain=const.DOMAIN,
+        domain=DOMAIN,
         unique_id="123456",
-        data=json.loads(load_fixture("fake_config_entry_data.json", "vulcan")),
+        data=json.loads(
+            await async_load_fixture(hass, "fake_config_entry_data.json", DOMAIN)
+        ),
     ).add_to_hass(hass)
 
     result = await hass.config_entries.flow.async_init(
-        const.DOMAIN, context={"source": config_entries.SOURCE_USER}
+        DOMAIN, context={"source": config_entries.SOURCE_USER}
     )
 
     assert result["type"] is FlowResultType.FORM
@@ -430,24 +437,28 @@ async def test_multiple_config_entries_using_saved_credentials_3(
 ) -> None:
     """Test a successful config flow for multiple config entries using saved credentials."""
     mock_student.return_value = [
-        Student.load(load_fixture("fake_student_1.json", "vulcan"))
+        Student.load(await async_load_fixture(hass, "fake_student_1.json", DOMAIN))
     ]
     MockConfigEntry(
         entry_id="456",
-        domain=const.DOMAIN,
+        domain=DOMAIN,
         unique_id="234567",
-        data=json.loads(load_fixture("fake_config_entry_data.json", "vulcan"))
+        data=json.loads(
+            await async_load_fixture(hass, "fake_config_entry_data.json", DOMAIN)
+        )
         | {"student_id": "456"},
     ).add_to_hass(hass)
     MockConfigEntry(
         entry_id="123",
-        domain=const.DOMAIN,
+        domain=DOMAIN,
         unique_id="123456",
-        data=json.loads(load_fixture("fake_config_entry_data.json", "vulcan")),
+        data=json.loads(
+            await async_load_fixture(hass, "fake_config_entry_data.json", DOMAIN)
+        ),
     ).add_to_hass(hass)
 
     result = await hass.config_entries.flow.async_init(
-        const.DOMAIN, context={"source": config_entries.SOURCE_USER}
+        DOMAIN, context={"source": config_entries.SOURCE_USER}
     )
 
     assert result["type"] is FlowResultType.FORM
@@ -483,25 +494,29 @@ async def test_multiple_config_entries_using_saved_credentials_4(
 ) -> None:
     """Test a successful config flow for multiple config entries using saved credentials (different situation)."""
     mock_student.return_value = [
-        Student.load(load_fixture("fake_student_1.json", "vulcan")),
-        Student.load(load_fixture("fake_student_2.json", "vulcan")),
+        Student.load(await async_load_fixture(hass, "fake_student_1.json", DOMAIN)),
+        Student.load(await async_load_fixture(hass, "fake_student_2.json", DOMAIN)),
     ]
     MockConfigEntry(
         entry_id="456",
-        domain=const.DOMAIN,
+        domain=DOMAIN,
         unique_id="234567",
-        data=json.loads(load_fixture("fake_config_entry_data.json", "vulcan"))
+        data=json.loads(
+            await async_load_fixture(hass, "fake_config_entry_data.json", DOMAIN)
+        )
         | {"student_id": "456"},
     ).add_to_hass(hass)
     MockConfigEntry(
         entry_id="123",
-        domain=const.DOMAIN,
+        domain=DOMAIN,
         unique_id="123456",
-        data=json.loads(load_fixture("fake_config_entry_data.json", "vulcan")),
+        data=json.loads(
+            await async_load_fixture(hass, "fake_config_entry_data.json", DOMAIN)
+        ),
     ).add_to_hass(hass)
 
     result = await hass.config_entries.flow.async_init(
-        const.DOMAIN, context={"source": config_entries.SOURCE_USER}
+        DOMAIN, context={"source": config_entries.SOURCE_USER}
     )
 
     assert result["type"] is FlowResultType.FORM
@@ -546,20 +561,24 @@ async def test_multiple_config_entries_without_valid_saved_credentials(
     """Test a unsuccessful config flow for multiple config entries without valid saved credentials."""
     MockConfigEntry(
         entry_id="456",
-        domain=const.DOMAIN,
+        domain=DOMAIN,
         unique_id="234567",
-        data=json.loads(load_fixture("fake_config_entry_data.json", "vulcan"))
+        data=json.loads(
+            await async_load_fixture(hass, "fake_config_entry_data.json", DOMAIN)
+        )
         | {"student_id": "456"},
     ).add_to_hass(hass)
     MockConfigEntry(
         entry_id="123",
-        domain=const.DOMAIN,
+        domain=DOMAIN,
         unique_id="123456",
-        data=json.loads(load_fixture("fake_config_entry_data.json", "vulcan")),
+        data=json.loads(
+            await async_load_fixture(hass, "fake_config_entry_data.json", DOMAIN)
+        ),
     ).add_to_hass(hass)
 
     result = await hass.config_entries.flow.async_init(
-        const.DOMAIN, context={"source": config_entries.SOURCE_USER}
+        DOMAIN, context={"source": config_entries.SOURCE_USER}
     )
 
     assert result["type"] is FlowResultType.FORM
@@ -594,20 +613,24 @@ async def test_multiple_config_entries_using_saved_credentials_with_connections_
     """Test a unsuccessful config flow for multiple config entries without valid saved credentials."""
     MockConfigEntry(
         entry_id="456",
-        domain=const.DOMAIN,
+        domain=DOMAIN,
         unique_id="234567",
-        data=json.loads(load_fixture("fake_config_entry_data.json", "vulcan"))
+        data=json.loads(
+            await async_load_fixture(hass, "fake_config_entry_data.json", DOMAIN)
+        )
         | {"student_id": "456"},
     ).add_to_hass(hass)
     MockConfigEntry(
         entry_id="123",
-        domain=const.DOMAIN,
+        domain=DOMAIN,
         unique_id="123456",
-        data=json.loads(load_fixture("fake_config_entry_data.json", "vulcan")),
+        data=json.loads(
+            await async_load_fixture(hass, "fake_config_entry_data.json", DOMAIN)
+        ),
     ).add_to_hass(hass)
 
     result = await hass.config_entries.flow.async_init(
-        const.DOMAIN, context={"source": config_entries.SOURCE_USER}
+        DOMAIN, context={"source": config_entries.SOURCE_USER}
     )
 
     assert result["type"] is FlowResultType.FORM
@@ -642,20 +665,24 @@ async def test_multiple_config_entries_using_saved_credentials_with_unknown_erro
     """Test a unsuccessful config flow for multiple config entries without valid saved credentials."""
     MockConfigEntry(
         entry_id="456",
-        domain=const.DOMAIN,
+        domain=DOMAIN,
         unique_id="234567",
-        data=json.loads(load_fixture("fake_config_entry_data.json", "vulcan"))
+        data=json.loads(
+            await async_load_fixture(hass, "fake_config_entry_data.json", DOMAIN)
+        )
         | {"student_id": "456"},
     ).add_to_hass(hass)
     MockConfigEntry(
         entry_id="123",
-        domain=const.DOMAIN,
+        domain=DOMAIN,
         unique_id="123456",
-        data=json.loads(load_fixture("fake_config_entry_data.json", "vulcan")),
+        data=json.loads(
+            await async_load_fixture(hass, "fake_config_entry_data.json", DOMAIN)
+        ),
     ).add_to_hass(hass)
 
     result = await hass.config_entries.flow.async_init(
-        const.DOMAIN, context={"source": config_entries.SOURCE_USER}
+        DOMAIN, context={"source": config_entries.SOURCE_USER}
     )
 
     assert result["type"] is FlowResultType.FORM
@@ -694,19 +721,21 @@ async def test_student_already_exists(
     mock_keystore.return_value = fake_keystore
     mock_account.return_value = fake_account
     mock_student.return_value = [
-        Student.load(load_fixture("fake_student_1.json", "vulcan"))
+        Student.load(await async_load_fixture(hass, "fake_student_1.json", DOMAIN))
     ]
     MockConfigEntry(
-        domain=const.DOMAIN,
+        domain=DOMAIN,
         unique_id="0",
-        data=json.loads(load_fixture("fake_config_entry_data.json", "vulcan"))
+        data=json.loads(
+            await async_load_fixture(hass, "fake_config_entry_data.json", DOMAIN)
+        )
         | {"student_id": "0"},
     ).add_to_hass(hass)
 
     await register.register("token", "region", "000000")
 
     result = await hass.config_entries.flow.async_init(
-        const.DOMAIN, context={"source": config_entries.SOURCE_USER}
+        DOMAIN, context={"source": config_entries.SOURCE_USER}
     )
 
     assert result["type"] is FlowResultType.FORM
@@ -733,7 +762,7 @@ async def test_config_flow_auth_invalid_token(
         side_effect=InvalidTokenException,
     ):
         result = await hass.config_entries.flow.async_init(
-            const.DOMAIN, context={"source": config_entries.SOURCE_USER}
+            DOMAIN, context={"source": config_entries.SOURCE_USER}
         )
 
         assert result["type"] is FlowResultType.FORM
@@ -761,7 +790,7 @@ async def test_config_flow_auth_invalid_region(
         side_effect=InvalidSymbolException,
     ):
         result = await hass.config_entries.flow.async_init(
-            const.DOMAIN, context={"source": config_entries.SOURCE_USER}
+            DOMAIN, context={"source": config_entries.SOURCE_USER}
         )
 
         assert result["type"] is FlowResultType.FORM
@@ -787,7 +816,7 @@ async def test_config_flow_auth_invalid_pin(mock_keystore, hass: HomeAssistant)
         side_effect=InvalidPINException,
     ):
         result = await hass.config_entries.flow.async_init(
-            const.DOMAIN, context={"source": config_entries.SOURCE_USER}
+            DOMAIN, context={"source": config_entries.SOURCE_USER}
         )
 
         assert result["type"] is FlowResultType.FORM
@@ -815,7 +844,7 @@ async def test_config_flow_auth_expired_token(
         side_effect=ExpiredTokenException,
     ):
         result = await hass.config_entries.flow.async_init(
-            const.DOMAIN, context={"source": config_entries.SOURCE_USER}
+            DOMAIN, context={"source": config_entries.SOURCE_USER}
         )
 
         assert result["type"] is FlowResultType.FORM
@@ -843,7 +872,7 @@ async def test_config_flow_auth_connection_error(
         side_effect=ClientConnectionError,
     ):
         result = await hass.config_entries.flow.async_init(
-            const.DOMAIN, context={"source": config_entries.SOURCE_USER}
+            DOMAIN, context={"source": config_entries.SOURCE_USER}
         )
 
         assert result["type"] is FlowResultType.FORM
@@ -871,7 +900,7 @@ async def test_config_flow_auth_unknown_error(
         side_effect=Exception,
     ):
         result = await hass.config_entries.flow.async_init(
-            const.DOMAIN, context={"source": config_entries.SOURCE_USER}
+            DOMAIN, context={"source": config_entries.SOURCE_USER}
         )
 
         assert result["type"] is FlowResultType.FORM
diff --git a/tests/components/wake_word/test_init.py b/tests/components/wake_word/test_init.py
index e6e8ff72a6d..402793be926 100644
--- a/tests/components/wake_word/test_init.py
+++ b/tests/components/wake_word/test_init.py
@@ -11,7 +11,7 @@ import pytest
 
 from homeassistant.components import wake_word
 from homeassistant.config_entries import ConfigEntry, ConfigEntryState, ConfigFlow
-from homeassistant.const import EntityCategory
+from homeassistant.const import EntityCategory, Platform
 from homeassistant.core import HomeAssistant, State
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from homeassistant.setup import async_setup_component
@@ -118,7 +118,7 @@ async def mock_config_entry_setup(
     ) -> bool:
         """Set up test config entry."""
         await hass.config_entries.async_forward_entry_setups(
-            config_entry, [wake_word.DOMAIN]
+            config_entry, [Platform.WAKE_WORD]
         )
         return True
 
@@ -127,7 +127,7 @@ async def mock_config_entry_setup(
     ) -> bool:
         """Unload up test config entry."""
         await hass.config_entries.async_forward_entry_unload(
-            config_entry, wake_word.DOMAIN
+            config_entry, Platform.WAKE_WORD
         )
         return True
 
diff --git a/tests/components/waqi/test_config_flow.py b/tests/components/waqi/test_config_flow.py
index fecac7ea0bd..a3fa47abc67 100644
--- a/tests/components/waqi/test_config_flow.py
+++ b/tests/components/waqi/test_config_flow.py
@@ -20,7 +20,7 @@ from homeassistant.const import (
 from homeassistant.core import HomeAssistant
 from homeassistant.data_entry_flow import FlowResultType
 
-from tests.common import load_fixture
+from tests.common import async_load_fixture
 
 pytestmark = pytest.mark.usefixtures("mock_setup_entry")
 
@@ -61,7 +61,9 @@ async def test_full_map_flow(
         patch(
             "aiowaqi.WAQIClient.get_by_ip",
             return_value=WAQIAirQuality.from_dict(
-                json.loads(load_fixture("waqi/air_quality_sensor.json"))
+                json.loads(
+                    await async_load_fixture(hass, "air_quality_sensor.json", DOMAIN)
+                )
             ),
         ),
     ):
@@ -81,13 +83,17 @@ async def test_full_map_flow(
         patch(
             "aiowaqi.WAQIClient.get_by_coordinates",
             return_value=WAQIAirQuality.from_dict(
-                json.loads(load_fixture("waqi/air_quality_sensor.json"))
+                json.loads(
+                    await async_load_fixture(hass, "air_quality_sensor.json", DOMAIN)
+                )
             ),
         ),
         patch(
             "aiowaqi.WAQIClient.get_by_station_number",
             return_value=WAQIAirQuality.from_dict(
-                json.loads(load_fixture("waqi/air_quality_sensor.json"))
+                json.loads(
+                    await async_load_fixture(hass, "air_quality_sensor.json", DOMAIN)
+                )
             ),
         ),
     ):
@@ -147,7 +153,9 @@ async def test_flow_errors(
         patch(
             "aiowaqi.WAQIClient.get_by_ip",
             return_value=WAQIAirQuality.from_dict(
-                json.loads(load_fixture("waqi/air_quality_sensor.json"))
+                json.loads(
+                    await async_load_fixture(hass, "air_quality_sensor.json", DOMAIN)
+                )
             ),
         ),
     ):
@@ -167,7 +175,9 @@ async def test_flow_errors(
         patch(
             "aiowaqi.WAQIClient.get_by_coordinates",
             return_value=WAQIAirQuality.from_dict(
-                json.loads(load_fixture("waqi/air_quality_sensor.json"))
+                json.loads(
+                    await async_load_fixture(hass, "air_quality_sensor.json", DOMAIN)
+                )
             ),
         ),
     ):
@@ -240,7 +250,9 @@ async def test_error_in_second_step(
         patch(
             "aiowaqi.WAQIClient.get_by_ip",
             return_value=WAQIAirQuality.from_dict(
-                json.loads(load_fixture("waqi/air_quality_sensor.json"))
+                json.loads(
+                    await async_load_fixture(hass, "air_quality_sensor.json", DOMAIN)
+                )
             ),
         ),
     ):
@@ -276,13 +288,17 @@ async def test_error_in_second_step(
         patch(
             "aiowaqi.WAQIClient.get_by_coordinates",
             return_value=WAQIAirQuality.from_dict(
-                json.loads(load_fixture("waqi/air_quality_sensor.json"))
+                json.loads(
+                    await async_load_fixture(hass, "air_quality_sensor.json", DOMAIN)
+                )
             ),
         ),
         patch(
             "aiowaqi.WAQIClient.get_by_station_number",
             return_value=WAQIAirQuality.from_dict(
-                json.loads(load_fixture("waqi/air_quality_sensor.json"))
+                json.loads(
+                    await async_load_fixture(hass, "air_quality_sensor.json", DOMAIN)
+                )
             ),
         ),
     ):
diff --git a/tests/components/waqi/test_sensor.py b/tests/components/waqi/test_sensor.py
index 7fd8e214240..7cd045604c8 100644
--- a/tests/components/waqi/test_sensor.py
+++ b/tests/components/waqi/test_sensor.py
@@ -15,7 +15,7 @@ from homeassistant.core import HomeAssistant
 from homeassistant.helpers import entity_registry as er
 from homeassistant.setup import async_setup_component
 
-from tests.common import MockConfigEntry, load_fixture
+from tests.common import MockConfigEntry, async_load_fixture
 
 
 @pytest.mark.usefixtures("entity_registry_enabled_by_default")
@@ -30,7 +30,9 @@ async def test_sensor(
     with patch(
         "aiowaqi.WAQIClient.get_by_station_number",
         return_value=WAQIAirQuality.from_dict(
-            json.loads(load_fixture("waqi/air_quality_sensor.json"))
+            json.loads(
+                await async_load_fixture(hass, "air_quality_sensor.json", DOMAIN)
+            )
         ),
     ):
         assert await async_setup_component(hass, DOMAIN, {})
diff --git a/tests/components/water_heater/test_init.py b/tests/components/water_heater/test_init.py
index 191acdf24f9..58cb3e364e7 100644
--- a/tests/components/water_heater/test_init.py
+++ b/tests/components/water_heater/test_init.py
@@ -19,7 +19,7 @@ from homeassistant.components.water_heater import (
     WaterHeaterEntityFeature,
 )
 from homeassistant.config_entries import ConfigEntry
-from homeassistant.const import UnitOfTemperature
+from homeassistant.const import Platform, UnitOfTemperature
 from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import ServiceValidationError
 from homeassistant.helpers import config_validation as cv
@@ -139,7 +139,9 @@ async def test_operation_mode_validation(
         hass: HomeAssistant, config_entry: ConfigEntry
     ) -> bool:
         """Set up test config entry."""
-        await hass.config_entries.async_forward_entry_setups(config_entry, [DOMAIN])
+        await hass.config_entries.async_forward_entry_setups(
+            config_entry, [Platform.WATER_HEATER]
+        )
         return True
 
     async def async_setup_entry_water_heater_platform(
diff --git a/tests/components/weather/__init__.py b/tests/components/weather/__init__.py
index 301e055129d..9585f327fd3 100644
--- a/tests/components/weather/__init__.py
+++ b/tests/components/weather/__init__.py
@@ -16,10 +16,10 @@ from homeassistant.components.weather import (
     ATTR_FORECAST_NATIVE_WIND_SPEED,
     ATTR_FORECAST_UV_INDEX,
     ATTR_FORECAST_WIND_BEARING,
-    DOMAIN,
     Forecast,
 )
 from homeassistant.config_entries import ConfigEntry
+from homeassistant.const import Platform
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
@@ -84,7 +84,9 @@ async def create_entity(
         hass: HomeAssistant, config_entry: ConfigEntry
     ) -> bool:
         """Set up test config entry."""
-        await hass.config_entries.async_forward_entry_setups(config_entry, [DOMAIN])
+        await hass.config_entries.async_forward_entry_setups(
+            config_entry, [Platform.WEATHER]
+        )
         return True
 
     async def async_setup_entry_weather_platform(
diff --git a/tests/components/weatherflow_cloud/test_sensor.py b/tests/components/weatherflow_cloud/test_sensor.py
index 13ac3910571..59374a80a4b 100644
--- a/tests/components/weatherflow_cloud/test_sensor.py
+++ b/tests/components/weatherflow_cloud/test_sensor.py
@@ -17,7 +17,7 @@ from . import setup_integration
 from tests.common import (
     MockConfigEntry,
     async_fire_time_changed,
-    load_fixture,
+    async_load_fixture,
     snapshot_platform,
 )
 
@@ -48,7 +48,7 @@ async def test_all_entities_with_lightning_error(
     """Test all entities."""
 
     get_observation_response_data = ObservationStationREST.from_json(
-        load_fixture("station_observation_error.json", DOMAIN)
+        await async_load_fixture(hass, "station_observation_error.json", DOMAIN)
     )
 
     with patch(
diff --git a/tests/components/workday/test_binary_sensor.py b/tests/components/workday/test_binary_sensor.py
index 212c3e9d305..8f8894e3536 100644
--- a/tests/components/workday/test_binary_sensor.py
+++ b/tests/components/workday/test_binary_sensor.py
@@ -461,3 +461,49 @@ async def test_only_repairs_for_current_next_year(
 
     assert len(issue_registry.issues) == 2
     assert issue_registry.issues == snapshot
+
+
+async def test_missing_language(
+    hass: HomeAssistant,
+    caplog: pytest.LogCaptureFixture,
+) -> None:
+    """Test when language exist but is empty."""
+    config = {
+        "add_holidays": [],
+        "country": "AU",
+        "days_offset": 0,
+        "excludes": ["sat", "sun", "holiday"],
+        "language": None,
+        "name": "Workday Sensor",
+        "platform": "workday",
+        "province": "QLD",
+        "remove_holidays": [
+            "Labour Day",
+        ],
+        "workdays": ["mon", "tue", "wed", "thu", "fri"],
+    }
+    await init_integration(hass, config)
+    assert "Changing language from None to en_AU" in caplog.text
+
+
+async def test_incorrect_english_variant(
+    hass: HomeAssistant,
+    caplog: pytest.LogCaptureFixture,
+) -> None:
+    """Test when language exist but is empty."""
+    config = {
+        "add_holidays": [],
+        "country": "AU",
+        "days_offset": 0,
+        "excludes": ["sat", "sun", "holiday"],
+        "language": "en_UK",  # Incorrect variant
+        "name": "Workday Sensor",
+        "platform": "workday",
+        "province": "QLD",
+        "remove_holidays": [
+            "Labour Day",
+        ],
+        "workdays": ["mon", "tue", "wed", "thu", "fri"],
+    }
+    await init_integration(hass, config)
+    assert "Changing language from en_UK to en_AU" in caplog.text
diff --git a/tests/components/zimi/test_config_flow.py b/tests/components/zimi/test_config_flow.py
index 9ec0c624b6f..d7008030fca 100644
--- a/tests/components/zimi/test_config_flow.py
+++ b/tests/components/zimi/test_config_flow.py
@@ -63,6 +63,10 @@ async def test_user_discovery_success(
     )
 
     assert result["type"] is FlowResultType.CREATE_ENTRY
+    assert result["context"] == {
+        "source": config_entries.SOURCE_USER,
+        "unique_id": INPUT_MAC,
+    }
     assert result["data"] == {
         "host": INPUT_HOST,
         "port": INPUT_PORT,