denonavr 1.0.0__tar.gz → 1.0.1__tar.gz

{denonavr-1.0.0 → denonavr-1.0.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: denonavr
-Version: 1.0.0
+Version: 1.0.1
 Summary: Automation Library for Denon AVR receivers
 Author-email: Oliver Goetz <scarface@mywoh.de>
 License: MIT

{denonavr-1.0.0 → denonavr-1.0.1}/denonavr/__init__.py

@@ -17,7 +17,7 @@ from .ssdp import async_identify_denonavr_receivers
 logging.getLogger(__name__).addHandler(logging.NullHandler())
 
 __title__ = "denonavr"
-__version__ = "1.0.0"
+__version__ = "1.0.1"
 
 
 async def async_discover():

{denonavr-1.0.0 → denonavr-1.0.1}/denonavr/api.py

@@ -31,7 +31,8 @@ from typing import (
 
 import attr
 import httpx
-from defusedxml.ElementTree import fromstring
+from defusedxml import DefusedXmlException
+from defusedxml.ElementTree import ParseError, fromstring
 
 from .appcommand import AppCommandCmd
 from .const import (
@@ -83,16 +84,86 @@ def telnet_event_map_factory() -> Dict[str, List]:
     return dict(event_map)
 
 
-@attr.s(auto_attribs=True, hash=False, on_setattr=DENON_ATTR_SETATTR)
+@attr.s(auto_attribs=True, hash=False)
+class HTTPXAsyncClient:
+    """Perform cached HTTP calls with httpx.AsyncClient."""
+
+    client_getter: Callable[[], httpx.AsyncClient] = attr.ib(
+        validator=attr.validators.is_callable(),
+        default=get_default_async_client,
+        init=False,
+    )
+
+    def __hash__(self) -> int:
+        """Hash the class using its ID that caching works."""
+        return id(self)
+
+    @cache_result
+    @async_handle_receiver_exceptions
+    async def async_get(
+        self,
+        url: str,
+        timeout: float,
+        read_timeout: float,
+        *,
+        cache_id: Hashable = None,
+    ) -> httpx.Response:
+        """Call GET endpoint of Denon AVR receiver asynchronously."""
+        client = self.client_getter()
+        try:
+            res = await client.get(
+                url, timeout=httpx.Timeout(timeout, read=read_timeout)
+            )
+            res.raise_for_status()
+        finally:
+            # Close the default AsyncClient but keep custom clients open
+            if self.is_default_async_client():
+                await client.aclose()
+
+        return res
+
+    @cache_result
+    @async_handle_receiver_exceptions
+    async def async_post(
+        self,
+        url: str,
+        timeout: float,
+        read_timeout: float,
+        *,
+        content: Optional[bytes] = None,
+        data: Optional[Dict] = None,
+        cache_id: Hashable = None,
+    ) -> httpx.Response:
+        """Call GET endpoint of Denon AVR receiver asynchronously."""
+        client = self.client_getter()
+        try:
+            res = await client.post(
+                url,
+                content=content,
+                data=data,
+                timeout=httpx.Timeout(timeout, read=read_timeout),
+            )
+            res.raise_for_status()
+        finally:
+            # Close the default AsyncClient but keep custom clients open
+            if self.is_default_async_client():
+                await client.aclose()
+
+        return res
+
+    def is_default_async_client(self) -> bool:
+        """Check if default httpx.AsyncClient getter is used."""
+        return self.client_getter is get_default_async_client
+
+
+@attr.s(auto_attribs=True, on_setattr=DENON_ATTR_SETATTR)
 class DenonAVRApi:
     """Perform API calls to Denon AVR REST interface."""
 
     host: str = attr.ib(converter=str, default="localhost")
     port: int = attr.ib(converter=int, default=80)
-    timeout: httpx.Timeout = attr.ib(
-        validator=attr.validators.instance_of(httpx.Timeout),
-        default=httpx.Timeout(2.0, read=15.0),
-    )
+    timeout: float = attr.ib(converter=float, default=2.0)
+    read_timeout: float = attr.ib(converter=float, default=15.0)
     _appcommand_update_tags: Tuple[AppCommandCmd] = attr.ib(
         validator=attr.validators.deep_iterable(
             attr.validators.instance_of(AppCommandCmd),
@@ -107,23 +178,18 @@ class DenonAVRApi:
         ),
         default=attr.Factory(tuple),
     )
-    async_client_getter: Callable[[], httpx.AsyncClient] = attr.ib(
-        validator=attr.validators.is_callable(),
-        default=get_default_async_client,
+    httpx_async_client: HTTPXAsyncClient = attr.ib(
+        validator=attr.validators.instance_of(HTTPXAsyncClient),
+        default=attr.Factory(HTTPXAsyncClient),
         init=False,
     )
 
-    def __hash__(self) -> int:
-        """
-        Hash the class in a custom way that caching works.
-
-        It should react on changes of host and port.
-        """
-        return hash((self.host, self.port))
-
-    @async_handle_receiver_exceptions
     async def async_get(
-        self, request: str, port: Optional[int] = None
+        self,
+        request: str,
+        *,
+        port: Optional[int] = None,
+        cache_id: Hashable = None,
     ) -> httpx.Response:
         """Call GET endpoint of Denon AVR receiver asynchronously."""
         # Use default port of the receiver if no different port is specified
@@ -131,24 +197,18 @@ class DenonAVRApi:
 
         endpoint = f"http://{self.host}:{port}{request}"
 
-        client = self.async_client_getter()
-        try:
-            res = await client.get(endpoint, timeout=self.timeout)
-            res.raise_for_status()
-        finally:
-            # Close the default AsyncClient but keep custom clients open
-            if self.is_default_async_client():
-                await client.aclose()
-
-        return res
+        return await self.httpx_async_client.async_get(
+            endpoint, self.timeout, self.read_timeout, cache_id=cache_id
+        )
 
-    @async_handle_receiver_exceptions
     async def async_post(
         self,
         request: str,
+        *,
         content: Optional[bytes] = None,
         data: Optional[Dict] = None,
         port: Optional[int] = None,
+        cache_id: Hashable = None,
     ) -> httpx.Response:
         """Call POST endpoint of Denon AVR receiver asynchronously."""
         # Use default port of the receiver if no different port is specified
@@ -156,20 +216,15 @@ class DenonAVRApi:
 
         endpoint = f"http://{self.host}:{port}{request}"
 
-        client = self.async_client_getter()
-        try:
-            res = await client.post(
-                endpoint, content=content, data=data, timeout=self.timeout
-            )
-            res.raise_for_status()
-        finally:
-            # Close the default AsyncClient but keep custom clients open
-            if self.is_default_async_client():
-                await client.aclose()
-
-        return res
+        return await self.httpx_async_client.async_post(
+            endpoint,
+            self.timeout,
+            self.read_timeout,
+            content=content,
+            data=data,
+            cache_id=cache_id,
+        )
 
-    @async_handle_receiver_exceptions
     async def async_get_command(self, request: str) -> str:
         """Send HTTP GET command to Denon AVR receiver asynchronously."""
         # HTTP GET to endpoint
@@ -177,34 +232,46 @@ class DenonAVRApi:
         # Return text
         return res.text
 
-    @cache_result
-    @async_handle_receiver_exceptions
     async def async_get_xml(
-        self, request: str, cache_id: Hashable = None
+        self, request: str, *, cache_id: Hashable = None
     ) -> ET.Element:
         """Return XML data from HTTP GET endpoint asynchronously."""
         # HTTP GET to endpoint
-        res = await self.async_get(request)
+        res = await self.async_get(request, cache_id=cache_id)
         # create ElementTree
-        xml_root = fromstring(res.text)
+        try:
+            xml_root = fromstring(res.text)
+        except (
+            ET.ParseError,
+            DefusedXmlException,
+            ParseError,
+            UnicodeDecodeError,
+        ) as err:
+            raise AvrInvalidResponseError(f"XMLParseError: {err}", request) from err
         # Check validity of XML
         self.check_xml_validity(request, xml_root)
         # Return ElementTree element
         return xml_root
 
-    @cache_result
-    @async_handle_receiver_exceptions
     async def async_post_appcommand(
-        self, request: str, cmds: Tuple[AppCommandCmd], cache_id: Hashable = None
+        self, request: str, cmds: Tuple[AppCommandCmd], *, cache_id: Hashable = None
     ) -> ET.Element:
         """Return XML from Appcommand(0300) endpoint asynchronously."""
         # Prepare XML body for POST call
         content = self.prepare_appcommand_body(cmds)
         _LOGGER.debug("Content for %s endpoint: %s", request, content)
         # HTTP POST to endpoint
-        res = await self.async_post(request, content=content)
+        res = await self.async_post(request, content=content, cache_id=cache_id)
         # create ElementTree
-        xml_root = fromstring(res.text)
+        try:
+            xml_root = fromstring(res.text)
+        except (
+            ET.ParseError,
+            DefusedXmlException,
+            ParseError,
+            UnicodeDecodeError,
+        ) as err:
+            raise AvrInvalidResponseError(f"XMLParseError: {err}", request) from err
         # Check validity of XML
         self.check_xml_validity(request, xml_root)
         # Add query tags to result
@@ -350,10 +417,6 @@ class DenonAVRApi:
 
         return body_bytes
 
-    def is_default_async_client(self) -> bool:
-        """Check if default httpx.AsyncClient getter is used."""
-        return self.async_client_getter is get_default_async_client
-
 
 class DenonAVRTelnetProtocol(asyncio.Protocol):
     """Protocol for the Denon AVR Telnet interface."""
@@ -481,8 +544,8 @@ class DenonAVRTelnetApi:
                 "%s: Connection failed on telnet reconnect: %s", self.host, err
             )
             raise AvrNetworkError(f"OSError: {err}", "telnet connect") from err
-        _LOGGER.debug("%s: telnet connection established", self.host)
         self._protocol = cast(DenonAVRTelnetProtocol, transport_protocol[1])
+        _LOGGER.debug("%s: telnet connection established", self.host)
         self._connection_enabled = True
         self._last_message_time = time.monotonic()
         self._schedule_monitor()
@@ -543,7 +606,8 @@ class DenonAVRTelnetApi:
         self._stop_monitor()
         if not self._connection_enabled:
             return
-        self._reconnect_task = asyncio.create_task(self._async_reconnect())
+        if self._reconnect_task is None:
+            self._reconnect_task = asyncio.create_task(self._async_reconnect())
 
     async def async_disconnect(self) -> None:
         """Close the connection to the receiver asynchronously."""
@@ -581,6 +645,12 @@ class DenonAVRTelnetApi:
                     )
                 except AvrNetworkError as err:
                     _LOGGER.debug("%s: %s", self.host, err)
+                except AvrProcessingError as err:
+                    _LOGGER.debug(
+                        "%s: Failed updating state on telnet reconnect: %s",
+                        self.host,
+                        err,
+                    )
                 except Exception as err:  # pylint: disable=broad-except
                     _LOGGER.error(
                         "%s: Unexpected exception on telnet reconnect",
@@ -589,11 +659,13 @@ class DenonAVRTelnetApi:
                     )
                 else:
                     _LOGGER.info("%s: Telnet reconnected", self.host)
-                    return
+                    break
 
             await asyncio.sleep(backoff)
             backoff = min(30.0, backoff * 2)
 
+        self._reconnect_task = None
+
     def register_callback(
         self, event: str, callback: Callable[[str, str, str], Awaitable[None]]
     ) -> None:
@@ -604,6 +676,8 @@ class DenonAVRTelnetApi:
 
         if event not in self._callbacks.keys():
             self._callbacks[event] = []
+        elif callback in self._callbacks[event]:
+            return
         self._callbacks[event].append(callback)
 
     def unregister_callback(
@@ -618,6 +692,8 @@ class DenonAVRTelnetApi:
         self, callback: Callable[[str], Awaitable[None]]
     ) -> None:
         """Register a callback handler for raw telnet messages."""
+        if callback in self._raw_callbacks:
+            return
         self._raw_callbacks.append(callback)
 
     def _unregister_raw_callback(

{denonavr-1.0.0 → denonavr-1.0.1}/denonavr/decorators.py

@@ -10,14 +10,11 @@ This module implements the REST API to Denon AVR receivers.
 import inspect
 import logging
 import time
-import xml.etree.ElementTree as ET
 from functools import wraps
 from typing import Callable, TypeVar
 
 import httpx
 from asyncstdlib import lru_cache
-from defusedxml import DefusedXmlException
-from defusedxml.ElementTree import ParseError
 
 from .exceptions import (
     AvrForbiddenError,
@@ -33,12 +30,7 @@ AnyT = TypeVar("AnyT")
 
 
 def async_handle_receiver_exceptions(func: Callable[..., AnyT]) -> Callable[..., AnyT]:
-    """
-    Handle exceptions raised when calling a Denon AVR endpoint asynchronously.
-
-    The decorated function must either have a string variable as second
-    argument or as "request" keyword argument.
-    """
+    """Handle exceptions raised when calling a Denon AVR endpoint asynchronously."""
 
     @wraps(func)
     async def wrapper(*args, **kwargs):
@@ -64,48 +56,29 @@ def async_handle_receiver_exceptions(func: Callable[..., AnyT]) -> Callable[...,
             raise AvrInvalidResponseError(
                 f"RemoteProtocolError: {err}", err.request
             ) from err
-        except (
-            ET.ParseError,
-            DefusedXmlException,
-            ParseError,
-            UnicodeDecodeError,
-        ) as err:
-            _LOGGER.debug(
-                "Defusedxml parse error on request %s: %s", (args, kwargs), err
-            )
-            raise AvrInvalidResponseError(
-                f"XMLParseError: {err}", (args, kwargs)
-            ) from err
 
     return wrapper
 
 
 def cache_result(func: Callable[..., AnyT]) -> Callable[..., AnyT]:
     """
-    Decorate a function to cache its results with an lru_cache of maxsize 16.
+    Decorate a function to cache its results with an lru_cache of maxsize 32.
 
     This decorator also sets an "cache_id" keyword argument if it is not set yet.
-    When an exception occurs it clears lru_cache to prevent memory leaks in
-    home-assistant when receiver instances are created and deleted right
-    away in case the device is offline on setup.
     """
     if inspect.signature(func).parameters.get("cache_id") is None:
         raise AttributeError(
             f"Function {func} does not have a 'cache_id' keyword parameter"
         )
 
-    lru_decorator = lru_cache(maxsize=16)
+    lru_decorator = lru_cache(maxsize=32)
     cached_func = lru_decorator(func)
 
     @wraps(func)
     async def wrapper(*args, **kwargs):
         if kwargs.get("cache_id") is None:
             kwargs["cache_id"] = time.time()
-        try:
-            return await cached_func(*args, **kwargs)
-        except Exception as err:
-            _LOGGER.debug("Exception raised, clearing cache: %s", err)
-            cached_func.cache_clear()
-            raise
+
+        return await cached_func(*args, **kwargs)
 
     return wrapper

{denonavr-1.0.0 → denonavr-1.0.1}/denonavr/denonavr.py

@@ -519,7 +519,7 @@ class DenonAVR(DenonAVRFoundation):
         """
         if not callable(async_client_getter):
             raise AvrCommandError("Provided object is not callable")
-        self._device.api.async_client_getter = async_client_getter
+        self._device.api.httpx_async_client.client_getter = async_client_getter
 
     async def async_dynamic_eq_off(self) -> None:
         """Turn DynamicEQ off."""

{denonavr-1.0.0 → denonavr-1.0.1}/denonavr/foundation.py

@@ -15,7 +15,6 @@ from copy import deepcopy
 from typing import Dict, List, Optional, Union
 
 import attr
-import httpx
 
 from .api import DenonAVRApi, DenonAVRTelnetApi
 from .appcommand import AppCommandCmd, AppCommands
@@ -146,15 +145,15 @@ class DenonAVRDeviceInfo:
             _LOGGER.debug("Starting device setup")
             # Reduce read timeout during receiver identification
             # deviceinfo endpoint takes very long to return 404
-            timeout = self.api.timeout
-            self.api.timeout = httpx.Timeout(self.api.timeout.connect)
+            read_timeout = self.api.read_timeout
+            self.api.read_timeout = self.api.timeout
             try:
                 _LOGGER.debug("Identifying receiver")
                 await self.async_identify_receiver()
                 _LOGGER.debug("Getting device info")
                 await self.async_get_device_info()
             finally:
-                self.api.timeout = timeout
+                self.api.read_timeout = read_timeout
             _LOGGER.debug("Identifying update method")
             await self.async_identify_update_method()
 
@@ -323,7 +322,7 @@ class DenonAVRDeviceInfo:
                 self._set_friendly_name(xml)
 
     async def async_verify_avr_2016_update_method(
-        self, cache_id: Hashable = None
+        self, *, cache_id: Hashable = None
     ) -> None:
         """Verify if avr 2016 update method is working."""
         # Nothing to do if Appcommand.xml interface is not supported
@@ -833,9 +832,9 @@ def set_api_timeout(
 ) -> float:
     """Change API timeout on timeout changes too."""
     # First change _device.api.host then return value
-    timeout = httpx.Timeout(value, read=max(value, 15.0))
     # pylint: disable=protected-access
-    instance._device.api.timeout = timeout
+    instance._device.api.timeout = value
+    instance._device.api.read_timeout = max(value, 15.0)
     instance._device.telnet_api.timeout = value
     return value
 

{denonavr-1.0.0 → denonavr-1.0.1}/denonavr/input.py

@@ -168,6 +168,13 @@ class DenonAVRInput(DenonAVRFoundation):
         converter=attr.converters.optional(str), default=None
     )
 
+    _renamed_sources_warnings: Set[Tuple[str, str]] = attr.ib(
+        validator=attr.validators.deep_iterable(
+            attr.validators.instance_of(tuple), attr.validators.instance_of(set)
+        ),
+        default=attr.Factory(set),
+    )
+
     # Update tags for attributes
     # AppCommand.xml interface
     appcommand_attrs = {AppCommands.GetAllZoneSource: None}
@@ -516,6 +523,8 @@ class DenonAVRInput(DenonAVRFoundation):
             except AttributeError:
                 continue
 
+        self._replace_duplicate_sources(renamed_sources)
+
         return (renamed_sources, deleted_sources)
 
     async def async_get_changed_sources_status_xml(
@@ -604,6 +613,8 @@ class DenonAVRInput(DenonAVRFoundation):
             except IndexError:
                 _LOGGER.error("List of deleted sources incomplete, continuing anyway")
 
+        self._replace_duplicate_sources(renamed_sources)
+
         return (renamed_sources, deleted_sources)
 
     async def async_update_inputfuncs(
@@ -859,10 +870,13 @@ class DenonAVRInput(DenonAVRFoundation):
     async def _async_test_image_accessible(self) -> None:
         """Test if image URL is accessible."""
         if self._image_available is None and self._image_url is not None:
-            client = self._device.api.async_client_getter()
+            client = self._device.api.httpx_async_client.client_getter()
             try:
                 res = await client.get(
-                    self._image_url, timeout=self._device.api.timeout
+                    self._image_url,
+                    timeout=httpx.Timeout(
+                        self._device.api.timeout, read=self._device.api.read_timeout
+                    ),
                 )
                 res.raise_for_status()
             except httpx.TimeoutException:
@@ -878,7 +892,7 @@ class DenonAVRInput(DenonAVRFoundation):
                 self._image_available = True
             finally:
                 # Close the default AsyncClient but keep custom clients open
-                if self._device.api.is_default_async_client():
+                if self._device.api.httpx_async_client.is_default_async_client():
                     await client.aclose()
         # Already tested that image URL is not accessible
         elif not self._image_available:
@@ -894,6 +908,33 @@ class DenonAVRInput(DenonAVRFoundation):
         self._station = None
         self._image_url = None
 
+    def _replace_duplicate_sources(self, sources: Dict[str, str]) -> None:
+        """Replace duplicate renamed sources (values) with their original names."""
+        seen_values = set()
+        duplicate_values = set()
+
+        for value in sources.values():
+            if value in seen_values:
+                duplicate_values.add(value)
+            seen_values.add(value)
+
+        for duplicate in duplicate_values:
+            for key, value in sources.items():
+                if value == duplicate:
+                    sources[key] = key
+
+                    if (key, value) not in self._renamed_sources_warnings:
+                        _LOGGER.warning(
+                            (
+                                "Input source '%s' is renamed to non-unique name '%s'. "
+                                "Using original name. Please choose unique names in "
+                                "your receiver's web-interface"
+                            ),
+                            key,
+                            value,
+                        )
+                        self._renamed_sources_warnings.add((key, value))
+
     ##############
     # Properties #
     ##############

{denonavr-1.0.0 → denonavr-1.0.1}/denonavr.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: denonavr
-Version: 1.0.0
+Version: 1.0.1
 Summary: Automation Library for Denon AVR receivers
 Author-email: Oliver Goetz <scarface@mywoh.de>
 License: MIT

{denonavr-1.0.0 → denonavr-1.0.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "denonavr"
-version = "1.0.0"
+version = "1.0.1"
 authors = [{name = "Oliver Goetz", email = "scarface@mywoh.de"}]
 license = {text = "MIT"}
 description = "Automation Library for Denon AVR receivers"

{denonavr-1.0.0 → denonavr-1.0.1}/tests/test_denonavr.py

@@ -153,6 +153,7 @@ class TestMainFunctions:
         self.future.set_result(True)
 
     @pytest.mark.asyncio
+    @pytest.mark.httpx_mock(can_send_already_matched_responses=True)
     async def test_receiver_type(self, httpx_mock: HTTPXMock):
         """Check that receiver type is determined correctly."""
         httpx_mock.add_callback(self.custom_matcher)
@@ -172,6 +173,7 @@ class TestMainFunctions:
             )
 
     @pytest.mark.asyncio
+    @pytest.mark.httpx_mock(can_send_already_matched_responses=True)
     async def test_input_func_switch(self, httpx_mock: HTTPXMock):
         """Switch through all input functions of all tested receivers."""
         httpx_mock.add_callback(self.custom_matcher)
@@ -188,6 +190,7 @@ class TestMainFunctions:
                     await self.denon.zones[name].async_set_input_func(input_func)
 
     @pytest.mark.asyncio
+    @pytest.mark.httpx_mock(can_send_already_matched_responses=True)
     async def test_attributes_not_none(self, httpx_mock: HTTPXMock):
         """Check that certain attributes are not None."""
         httpx_mock.add_callback(self.custom_matcher)
@@ -210,6 +213,7 @@ class TestMainFunctions:
             ), f"State is None for receiver {receiver}"
 
     @pytest.mark.asyncio
+    @pytest.mark.httpx_mock(can_send_already_matched_responses=True)
     async def test_sound_mode(self, httpx_mock: HTTPXMock):
         """Check if a valid sound mode is returned."""
         httpx_mock.add_callback(self.custom_matcher)
@@ -393,6 +397,7 @@ class TestMainFunctions:
                 await api.async_connect()
 
     @pytest.mark.asyncio
+    @pytest.mark.httpx_mock(can_send_already_matched_responses=True)
     async def test_receive_callback_called(self, httpx_mock: HTTPXMock):
         """Check that the callback is triggered whena message is received."""
         transport = mock.Mock(is_closing=lambda: False)
@@ -428,6 +433,7 @@ class TestMainFunctions:
             mock_obj.method.assert_called_once()
 
     @pytest.mark.asyncio
+    @pytest.mark.httpx_mock(can_send_already_matched_responses=True)
     async def test_mute_on(self, httpx_mock: HTTPXMock):
         """Check that mute on is processed."""
         transport = mock.Mock(is_closing=lambda: False)
@@ -458,6 +464,7 @@ class TestMainFunctions:
             assert self.denon.muted
 
     @pytest.mark.asyncio
+    @pytest.mark.httpx_mock(can_send_already_matched_responses=True)
     async def test_mute_off(self, httpx_mock: HTTPXMock):
         """Check that mute off is processed."""
         transport = mock.Mock(is_closing=lambda: False)
@@ -488,6 +495,7 @@ class TestMainFunctions:
             assert not self.denon.muted
 
     @pytest.mark.asyncio
+    @pytest.mark.httpx_mock(can_send_already_matched_responses=True)
     async def test_power_on(self, httpx_mock: HTTPXMock):
         """Check that power on is processed."""
         transport = mock.Mock(is_closing=lambda: False)
@@ -518,6 +526,7 @@ class TestMainFunctions:
             assert self.denon.power == "ON"
 
     @pytest.mark.asyncio
+    @pytest.mark.httpx_mock(can_send_already_matched_responses=True)
     async def test_power_off(self, httpx_mock: HTTPXMock):
         """Check that power off is processed."""
         transport = mock.Mock(is_closing=lambda: False)
@@ -548,6 +557,7 @@ class TestMainFunctions:
             assert self.denon.power == "OFF"
 
     @pytest.mark.asyncio
+    @pytest.mark.httpx_mock(can_send_already_matched_responses=True)
     async def test_volume_min(self, httpx_mock: HTTPXMock):
         """Check that minimum volume is processed."""
         transport = mock.Mock(is_closing=lambda: False)
@@ -578,6 +588,7 @@ class TestMainFunctions:
             assert self.denon.volume == -80.0
 
     @pytest.mark.asyncio
+    @pytest.mark.httpx_mock(can_send_already_matched_responses=True)
     async def test_volume_wholenumber(self, httpx_mock: HTTPXMock):
         """Check that whole number volume is processed."""
         transport = mock.Mock(is_closing=lambda: False)
@@ -608,6 +619,7 @@ class TestMainFunctions:
             assert self.denon.volume == -24.0
 
     @pytest.mark.asyncio
+    @pytest.mark.httpx_mock(can_send_already_matched_responses=True)
     async def test_volume_fraction(self, httpx_mock: HTTPXMock):
         """Check that fractional volume is processed."""
         transport = mock.Mock(is_closing=lambda: False)