Fixes

CODEOWNERS

@@ -349,6 +349,8 @@ build.json @home-assistant/supervisor
 /tests/components/deluge/ @tkdrob
 /homeassistant/components/demo/ @home-assistant/core
 /tests/components/demo/ @home-assistant/core
+/homeassistant/components/denon_rs232/ @balloob
+/tests/components/denon_rs232/ @balloob
 /homeassistant/components/denonavr/ @ol-iver @starkillerOG
 /tests/components/denonavr/ @ol-iver @starkillerOG
 /homeassistant/components/derivative/ @afaucogney @karwosts

homeassistant/components/denon_rs232/__init__.py

@@ -0,0 +1,61 @@
+"""The Denon RS232 integration."""
+
+from __future__ import annotations
+
+import logging
+
+from denon_rs232 import DenonReceiver, DenonState
+from denon_rs232.models import MODELS
+
+from homeassistant.config_entries import ConfigEntry
+from homeassistant.const import CONF_PORT, Platform
+from homeassistant.core import HomeAssistant, callback
+from homeassistant.exceptions import ConfigEntryNotReady
+
+from .const import (
+    CONF_MODEL,
+    DOMAIN,  # noqa: F401
+)
+
+PLATFORMS = [Platform.MEDIA_PLAYER]
+
+_LOGGER = logging.getLogger(__name__)
+
+type DenonRS232ConfigEntry = ConfigEntry[DenonReceiver]
+
+
+async def async_setup_entry(hass: HomeAssistant, entry: DenonRS232ConfigEntry) -> bool:
+    """Set up Denon RS232 from a config entry."""
+    port = entry.data[CONF_PORT]
+    model = MODELS[entry.data[CONF_MODEL]]
+    receiver = DenonReceiver(port, model=model)
+
+    try:
+        await receiver.connect()
+    except (ConnectionError, OSError) as err:
+        _LOGGER.error("Error connecting to Denon receiver at %s: %s", port, err)
+        raise ConfigEntryNotReady from err
+
+    entry.runtime_data = receiver
+
+    @callback
+    def _on_disconnect(state: DenonState | None) -> None:
+        if state is None:
+            _LOGGER.warning("Denon receiver disconnected, reloading config entry")
+            hass.config_entries.async_schedule_reload(entry.entry_id)
+
+    entry.async_on_unload(receiver.subscribe(_on_disconnect))
+
+    await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
+
+    return True
+
+
+async def async_unload_entry(hass: HomeAssistant, entry: DenonRS232ConfigEntry) -> bool:
+    """Unload a config entry."""
+    unload_ok = await hass.config_entries.async_unload_platforms(entry, PLATFORMS)
+
+    if unload_ok:
+        await entry.runtime_data.disconnect()
+
+    return unload_ok

homeassistant/components/denon_rs232/config_flow.py

@@ -0,0 +1,65 @@
+"""Config flow for the Denon RS232 integration."""
+
+from __future__ import annotations
+
+import logging
+from typing import Any
+
+from denon_rs232 import DenonReceiver
+from denon_rs232.models import MODELS
+import voluptuous as vol
+
+from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
+from homeassistant.const import CONF_PORT
+
+from .const import CONF_MODEL, DOMAIN
+
+_LOGGER = logging.getLogger(__name__)
+
+MODEL_OPTIONS = {key: model.name for key, model in MODELS.items()}
+
+DATA_SCHEMA = vol.Schema(
+    {
+        vol.Required(CONF_MODEL): vol.In(MODEL_OPTIONS),
+        vol.Required(CONF_PORT): str,
+    }
+)
+
+
+class DenonRS232ConfigFlow(ConfigFlow, domain=DOMAIN):
+    """Handle a config flow for Denon RS232."""
+
+    VERSION = 1
+
+    async def async_step_user(
+        self, user_input: dict[str, Any] | None = None
+    ) -> ConfigFlowResult:
+        """Handle the initial step."""
+        errors: dict[str, str] = {}
+
+        if user_input is not None:
+            self._async_abort_entries_match({CONF_PORT: user_input[CONF_PORT]})
+
+            model = MODELS[user_input[CONF_MODEL]]
+            receiver = DenonReceiver(user_input[CONF_PORT], model=model)
+            try:
+                await receiver.connect()
+            except ConnectionError, OSError:
+                errors["base"] = "cannot_connect"
+            except Exception:
+                _LOGGER.exception("Unexpected exception")
+                errors["base"] = "unknown"
+            else:
+                await receiver.disconnect()
+                return self.async_create_entry(
+                    title=f"Denon {model.name} ({user_input[CONF_PORT]})",
+                    data=user_input,
+                )
+
+        return self.async_show_form(
+            step_id="user",
+            data_schema=self.add_suggested_values_to_schema(
+                DATA_SCHEMA, user_input or {}
+            ),
+            errors=errors,
+        )

homeassistant/components/denon_rs232/const.py

@@ -0,0 +1,4 @@
+"""Constants for the Denon RS232 integration."""
+
+DOMAIN = "denon_rs232"
+CONF_MODEL = "model"

homeassistant/components/denon_rs232/manifest.json

@@ -0,0 +1,12 @@
+{
+  "domain": "denon_rs232",
+  "name": "Denon RS232",
+  "codeowners": ["@balloob"],
+  "config_flow": true,
+  "documentation": "https://www.home-assistant.io/integrations/denon_rs232",
+  "integration_type": "hub",
+  "iot_class": "local_push",
+  "loggers": ["denon_rs232"],
+  "quality_scale": "bronze",
+  "requirements": ["denon-rs232==0.1.0"]
+}

homeassistant/components/denon_rs232/media_player.py

@@ -0,0 +1,222 @@
+"""Media player platform for the Denon RS232 integration."""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+import logging
+import re
+
+from denon_rs232 import (
+    MIN_VOLUME_DB,
+    VOLUME_DB_RANGE,
+    DenonReceiver,
+    DenonState,
+    InputSource,
+    PowerState,
+)
+from denon_rs232.models import MODELS
+
+from homeassistant.components.media_player import (
+    MediaPlayerDeviceClass,
+    MediaPlayerEntity,
+    MediaPlayerEntityFeature,
+    MediaPlayerState,
+)
+from homeassistant.core import HomeAssistant, callback
+from homeassistant.helpers.device_registry import DeviceInfo
+from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
+
+from . import DenonRS232ConfigEntry
+from .const import DOMAIN
+
+_LOGGER = logging.getLogger(__name__)
+
+PARALLEL_UPDATES = 1
+
+_INVALID_KEY_CHARS = re.compile(r"[^a-z0-9]+")
+
+
+def _source_state_key(source: InputSource) -> str:
+    """Return a translation-safe state key for a source."""
+    return source.name.lower()
+
+
+SOURCE_BY_NAME: dict[str, InputSource] = {
+    _source_state_key(source): source for source in InputSource
+}
+# Backwards compatibility for direct service calls using raw protocol values.
+SOURCE_BY_NAME.update({source.value: source for source in InputSource})
+
+
+def _sound_mode_state_key(sound_mode: str) -> str:
+    """Return a translation-safe state key for a sound mode."""
+    key = _INVALID_KEY_CHARS.sub("_", sound_mode.replace("+", " plus ").lower()).strip(
+        "_"
+    )
+    if key and not key[0].isdigit():
+        return key
+    return f"mode_{key}"
+
+
+async def async_setup_entry(
+    hass: HomeAssistant,
+    config_entry: DenonRS232ConfigEntry,
+    async_add_entities: AddConfigEntryEntitiesCallback,
+) -> None:
+    """Set up the Denon RS232 media player."""
+    receiver = config_entry.runtime_data
+    async_add_entities([DenonRS232MediaPlayer(receiver, config_entry)])
+
+
+class DenonRS232MediaPlayer(MediaPlayerEntity):
+    """Representation of a Denon receiver controlled over RS232."""
+
+    _attr_device_class = MediaPlayerDeviceClass.RECEIVER
+    _attr_supported_features = (
+        MediaPlayerEntityFeature.TURN_ON
+        | MediaPlayerEntityFeature.TURN_OFF
+        | MediaPlayerEntityFeature.VOLUME_SET
+        | MediaPlayerEntityFeature.VOLUME_MUTE
+        | MediaPlayerEntityFeature.VOLUME_STEP
+        | MediaPlayerEntityFeature.SELECT_SOURCE
+        | MediaPlayerEntityFeature.SELECT_SOUND_MODE
+    )
+    _attr_has_entity_name = True
+    _attr_name = None
+    _attr_translation_key = "receiver"
+    _attr_should_poll = False
+
+    def __init__(
+        self,
+        receiver: DenonReceiver,
+        config_entry: DenonRS232ConfigEntry,
+    ) -> None:
+        """Initialize the media player."""
+        self._receiver = receiver
+        self._attr_unique_id = config_entry.entry_id
+
+        model = receiver.model
+        model_name = model.name if model else None
+        self._attr_device_info = DeviceInfo(
+            identifiers={(DOMAIN, config_entry.entry_id)},
+            manufacturer="Denon",
+            model=model_name,
+            name="Denon Receiver",
+        )
+
+        known_sound_modes = (
+            model.surround_modes
+            if model
+            else tuple(
+                sorted(
+                    {
+                        surround_mode
+                        for receiver_model in MODELS.values()
+                        for surround_mode in receiver_model.surround_modes
+                    }
+                )
+            )
+        )
+        self._sound_mode_by_state: dict[str, str] = {
+            _sound_mode_state_key(sound_mode): sound_mode
+            for sound_mode in known_sound_modes
+        }
+
+        if model:
+            self._attr_source_list = sorted(
+                _source_state_key(source) for source in model.input_sources
+            )
+            self._attr_sound_mode_list = list(self._sound_mode_by_state)
+        else:
+            self._attr_source_list = sorted(
+                _source_state_key(source) for source in InputSource
+            )
+            self._attr_sound_mode_list = list(self._sound_mode_by_state)
+
+        self._unsub: Callable[[], None] | None = None
+        self._update_from_state(receiver.state)
+
+    async def async_added_to_hass(self) -> None:
+        """Subscribe to receiver state updates."""
+        self._unsub = self._receiver.subscribe(self._on_state_update)
+
+    async def async_will_remove_from_hass(self) -> None:
+        """Unsubscribe from receiver state updates."""
+        if self._unsub is not None:
+            self._unsub()
+            self._unsub = None
+
+    @callback
+    def _on_state_update(self, state: DenonState | None) -> None:
+        """Handle a state update from the receiver."""
+        if state is None:
+            self._attr_available = False
+        else:
+            self._attr_available = True
+            self._update_from_state(state)
+        self.async_write_ha_state()
+
+    def _update_from_state(self, state: DenonState) -> None:
+        """Update entity attributes from a DenonState snapshot."""
+        if state.power == PowerState.ON:
+            self._attr_state = MediaPlayerState.ON
+        elif state.power == PowerState.STANDBY:
+            self._attr_state = MediaPlayerState.OFF
+        else:
+            self._attr_state = None
+
+        if state.volume is not None:
+            self._attr_volume_level = (state.volume - MIN_VOLUME_DB) / VOLUME_DB_RANGE
+        else:
+            self._attr_volume_level = None
+
+        self._attr_is_volume_muted = state.mute
+
+        if state.input_source is not None:
+            self._attr_source = _source_state_key(state.input_source)
+        else:
+            self._attr_source = None
+
+        if state.surround_mode is not None:
+            self._attr_sound_mode = _sound_mode_state_key(state.surround_mode)
+        else:
+            self._attr_sound_mode = None
+
+    async def async_turn_on(self) -> None:
+        """Turn the receiver on."""
+        await self._receiver.power_on()
+
+    async def async_turn_off(self) -> None:
+        """Turn the receiver off."""
+        await self._receiver.power_standby()
+
+    async def async_set_volume_level(self, volume: float) -> None:
+        """Set volume level, range 0..1."""
+        db = volume * VOLUME_DB_RANGE + MIN_VOLUME_DB
+        await self._receiver.set_volume(db)
+
+    async def async_volume_up(self) -> None:
+        """Volume up."""
+        await self._receiver.volume_up()
+
+    async def async_volume_down(self) -> None:
+        """Volume down."""
+        await self._receiver.volume_down()
+
+    async def async_mute_volume(self, mute: bool) -> None:
+        """Mute or unmute."""
+        if mute:
+            await self._receiver.mute_on()
+        else:
+            await self._receiver.mute_off()
+
+    async def async_select_source(self, source: str) -> None:
+        """Select input source."""
+        if input_source := SOURCE_BY_NAME.get(source):
+            await self._receiver.select_input_source(input_source)
+
+    async def async_select_sound_mode(self, sound_mode: str) -> None:
+        """Select sound mode."""
+        await self._receiver.set_surround_mode(
+            self._sound_mode_by_state.get(sound_mode, sound_mode)
+        )

homeassistant/components/denon_rs232/quality_scale.yaml

@@ -0,0 +1,60 @@
+rules:
+  # Bronze
+  action-setup: done
+  appropriate-polling: done
+  brands: done
+  common-modules: done
+  config-flow-test-coverage: done
+  config-flow: done
+  dependency-transparency: done
+  docs-actions: done
+  docs-high-level-description: done
+  docs-installation-instructions: done
+  docs-removal-instructions: done
+  entity-event-setup: done
+  entity-unique-id: done
+  has-entity-name: done
+  runtime-data: done
+  test-before-configure: done
+  test-before-setup: done
+  unique-config-entry: done
+
+  # Silver
+  action-exceptions: todo
+  config-entry-unloading: todo
+  docs-configuration-parameters: todo
+  docs-installation-parameters: todo
+  entity-unavailable: todo
+  integration-owner: todo
+  log-when-unavailable: todo
+  parallel-updates: todo
+  reauthentication-flow: todo
+  test-coverage: todo
+
+  # Gold
+  devices: todo
+  diagnostics: todo
+  discovery-update-info: todo
+  discovery: todo
+  docs-data-update: todo
+  docs-examples: todo
+  docs-known-limitations: todo
+  docs-supported-devices: todo
+  docs-supported-functions: todo
+  docs-troubleshooting: todo
+  docs-use-cases: todo
+  dynamic-devices: todo
+  entity-category: todo
+  entity-device-class: todo
+  entity-disabled-by-default: todo
+  entity-translations: todo
+  exception-translations: todo
+  icon-translations: todo
+  reconfiguration-flow: todo
+  repair-issues: todo
+  stale-devices: todo
+
+  # Platinum
+  async-dependency: done
+  inject-websession: todo
+  strict-typing: todo

homeassistant/components/denon_rs232/strings.json

@@ -0,0 +1,122 @@
+{
+  "config": {
+    "abort": {
+      "already_configured": "[%key:common::config_flow::abort::already_configured_device%]"
+    },
+    "error": {
+      "cannot_connect": "[%key:common::config_flow::error::cannot_connect%]",
+      "unknown": "[%key:common::config_flow::error::unknown%]"
+    },
+    "step": {
+      "user": {
+        "data": {
+          "model": "Receiver model",
+          "port": "[%key:common::config_flow::data::port%]"
+        },
+        "data_description": {
+          "model": "Select the receiver model",
+          "port": "Serial port path to connect to"
+        }
+      }
+    }
+  },
+  "entity": {
+    "media_player": {
+      "receiver": {
+        "state_attributes": {
+          "sound_mode": {
+            "name": "Sound mode",
+            "state": {
+              "auro2dsurr": "Auro 2D Surround",
+              "auro3d": "Auro 3D",
+              "auto": "Auto",
+              "classic_concert": "Classic Concert",
+              "direct": "Direct",
+              "dolby_atmos": "Dolby Atmos",
+              "dolby_d_ex": "Dolby Digital EX",
+              "dolby_digital": "Dolby Digital",
+              "dolby_digital_plus": "Dolby Digital+",
+              "dolby_hd": "Dolby HD",
+              "dolby_pl2": "Dolby PL2",
+              "dolby_pl2x": "Dolby PL2x",
+              "dolby_pro_logic": "Dolby Pro Logic",
+              "dolby_surround": "Dolby Surround",
+              "dts96_24": "DTS96/24",
+              "dts_es_dscrt6_1": "DTS ES Discrete 6.1",
+              "dts_es_mtrx6_1": "DTS ES Matrix 6.1",
+              "dts_hd": "DTS HD",
+              "dts_hd_mstr": "DTS HD Master",
+              "dts_neo_6": "DTS Neo:6",
+              "dts_surround": "DTS Surround",
+              "dts_x": "DTS:X",
+              "dts_x_mstr": "DTS:X Master",
+              "jazz_club": "Jazz Club",
+              "matrix": "Matrix",
+              "mch_stereo": "Multichannel Stereo",
+              "mode_5ch_stereo": "5ch Stereo",
+              "mode_7ch_stereo": "7ch Stereo",
+              "mono_movie": "Mono Movie",
+              "multi_ch_direct": "Multi Ch Direct",
+              "multi_ch_in": "Multi Ch In",
+              "multi_ch_pure_d": "Multi Ch Pure Direct",
+              "pure_direct": "Pure Direct",
+              "rock_arena": "Rock Arena",
+              "stereo": "Stereo",
+              "super_stadium": "Super Stadium",
+              "video_game": "Video Game",
+              "virtual": "Virtual",
+              "wide_screen": "Wide Screen"
+            }
+          },
+          "source": {
+            "name": "Source",
+            "state": {
+              "aux1": "Aux 1",
+              "aux2": "Aux 2",
+              "bd": "BD Player",
+              "bt": "Bluetooth",
+              "cd": "CD",
+              "cdr_tape1": "CDR/Tape 1",
+              "dab": "DAB",
+              "dbs_sat": "DBS/Sat",
+              "dock": "Dock",
+              "dvd": "DVD",
+              "dvr": "DVR",
+              "eight_k": "8K",
+              "favorites": "Favorites",
+              "flickr": "Flickr",
+              "game": "Game",
+              "hdp": "HDP",
+              "hdradio": "HD Radio",
+              "ipod": "iPod",
+              "iradio": "Internet Radio",
+              "lastfm": "Last.fm",
+              "md_tape2": "MD/Tape 2",
+              "mplay": "Media Player",
+              "net": "HEOS Music",
+              "net_usb": "Network/USB",
+              "pandora": "Pandora",
+              "phono": "Phono",
+              "sat": "Sat",
+              "sat_cbl": "Satellite/Cable",
+              "server": "Server",
+              "sirius": "Sirius",
+              "siriusxm": "SiriusXM",
+              "spotify": "Spotify",
+              "tuner": "Tuner",
+              "tv": "TV Audio",
+              "tv_cbl": "TV/Cable",
+              "usb_ipod": "USB/iPod",
+              "v_aux": "V. Aux",
+              "vcr_1": "VCR 1",
+              "vcr_2": "VCR 2",
+              "vcr_3": "VCR 3",
+              "vdp": "VDP",
+              "xm": "XM"
+            }
+          }
+        }
+      }
+    }
+  }
+}

homeassistant/generated/config_flows.py

@@ -139,6 +139,7 @@ FLOWS = {
         "deako",
         "deconz",
         "deluge",
+        "denon_rs232",
         "denonavr",
         "devialet",
         "devolo_home_control",

homeassistant/generated/integrations.json

@@ -1313,6 +1313,12 @@
         }
       }
     },
+    "denon_rs232": {
+      "name": "Denon RS232",
+      "integration_type": "hub",
+      "config_flow": true,
+      "iot_class": "local_push"
+    },
     "devialet": {
       "name": "Devialet",
       "integration_type": "device",

requirements_all.txt

@@ -797,6 +797,9 @@ deluge-client==1.10.2
 # homeassistant.components.lametric
 demetriek==1.3.0
 
+# homeassistant.components.denon_rs232
+denon-rs232==0.1.0
+
 # homeassistant.components.denonavr
 denonavr==1.3.2
 

requirements_test_all.txt

@@ -706,6 +706,9 @@ deluge-client==1.10.2
 # homeassistant.components.lametric
 demetriek==1.3.0
 
+# homeassistant.components.denon_rs232
+denon-rs232==0.1.0
+
 # homeassistant.components.denonavr
 denonavr==1.3.2
 

tests/components/denon_rs232/__init__.py

@@ -0,0 +1 @@
+"""Tests for the Denon RS232 integration."""

tests/components/denon_rs232/conftest.py

@@ -0,0 +1,70 @@
+"""Test fixtures for the Denon RS232 integration."""
+
+from unittest.mock import AsyncMock, MagicMock
+
+from denon_rs232 import (
+    DenonReceiver,
+    DenonState,
+    DigitalInputMode,
+    InputSource,
+    PowerState,
+    TunerBand,
+    TunerMode,
+)
+from denon_rs232.models import MODELS
+import pytest
+
+from homeassistant.components.denon_rs232.const import CONF_MODEL, DOMAIN
+from homeassistant.const import CONF_PORT
+
+from tests.common import MockConfigEntry
+
+MOCK_PORT = "/dev/ttyUSB0"
+MOCK_MODEL = "avr_3805"
+
+
+def _default_state() -> DenonState:
+    """Return a DenonState with typical defaults."""
+    return DenonState(
+        power=PowerState.ON,
+        main_zone=True,
+        volume=-30.0,
+        mute=False,
+        input_source=InputSource.CD,
+        surround_mode="STEREO",
+        digital_input=DigitalInputMode.AUTO,
+        tuner_band=TunerBand.FM,
+        tuner_mode=TunerMode.AUTO,
+    )
+
+
+@pytest.fixture
+def mock_receiver() -> MagicMock:
+    """Create a mock DenonReceiver."""
+    receiver = MagicMock(spec=DenonReceiver)
+    receiver.connect = AsyncMock()
+    receiver.disconnect = AsyncMock()
+    receiver.power_on = AsyncMock()
+    receiver.power_standby = AsyncMock()
+    receiver.set_volume = AsyncMock()
+    receiver.volume_up = AsyncMock()
+    receiver.volume_down = AsyncMock()
+    receiver.mute_on = AsyncMock()
+    receiver.mute_off = AsyncMock()
+    receiver.select_input_source = AsyncMock()
+    receiver.set_surround_mode = AsyncMock()
+    receiver.connected = True
+    receiver.state = _default_state()
+    receiver.model = MODELS[MOCK_MODEL]
+    receiver.subscribe = MagicMock(return_value=MagicMock())
+    return receiver
+
+
+@pytest.fixture
+def mock_config_entry() -> MockConfigEntry:
+    """Create a mock config entry."""
+    return MockConfigEntry(
+        domain=DOMAIN,
+        data={CONF_PORT: MOCK_PORT, CONF_MODEL: MOCK_MODEL},
+        title=f"Denon AVR-3805 / AVC-3890 ({MOCK_PORT})",
+    )

tests/components/denon_rs232/test_config_flow.py

@@ -0,0 +1,137 @@
+"""Tests for the Denon RS232 config flow."""
+
+from unittest.mock import AsyncMock, patch
+
+from homeassistant.components.denon_rs232.const import CONF_MODEL, DOMAIN
+from homeassistant.config_entries import SOURCE_USER
+from homeassistant.const import CONF_PORT
+from homeassistant.core import HomeAssistant
+from homeassistant.data_entry_flow import FlowResultType
+
+from tests.common import MockConfigEntry
+
+MOCK_PORT = "/dev/ttyUSB0"
+MOCK_MODEL = "avr_3805"
+
+
+async def test_user_form(hass: HomeAssistant) -> None:
+    """Test we show the user form."""
+    result = await hass.config_entries.flow.async_init(
+        DOMAIN, context={"source": SOURCE_USER}
+    )
+    assert result["type"] is FlowResultType.FORM
+    assert result["step_id"] == "user"
+    assert result["errors"] == {}
+
+
+async def test_user_form_creates_entry(hass: HomeAssistant) -> None:
+    """Test successful config flow creates an entry."""
+    result = await hass.config_entries.flow.async_init(
+        DOMAIN, context={"source": SOURCE_USER}
+    )
+
+    mock_receiver = AsyncMock()
+    mock_receiver.connect = AsyncMock()
+    mock_receiver.disconnect = AsyncMock()
+
+    with patch(
+        "homeassistant.components.denon_rs232.config_flow.DenonReceiver",
+        return_value=mock_receiver,
+    ):
+        result = await hass.config_entries.flow.async_configure(
+            result["flow_id"],
+            {CONF_PORT: MOCK_PORT, CONF_MODEL: MOCK_MODEL},
+        )
+
+    assert result["type"] is FlowResultType.CREATE_ENTRY
+    assert result["title"] == f"Denon AVR-3805 / AVC-3890 ({MOCK_PORT})"
+    assert result["data"] == {CONF_PORT: MOCK_PORT, CONF_MODEL: MOCK_MODEL}
+    mock_receiver.connect.assert_awaited_once()
+    mock_receiver.disconnect.assert_awaited_once()
+
+
+async def test_user_form_cannot_connect(hass: HomeAssistant) -> None:
+    """Test we handle connection errors."""
+    result = await hass.config_entries.flow.async_init(
+        DOMAIN, context={"source": SOURCE_USER}
+    )
+
+    mock_receiver = AsyncMock()
+    mock_receiver.connect = AsyncMock(side_effect=ConnectionError("No response"))
+
+    with patch(
+        "homeassistant.components.denon_rs232.config_flow.DenonReceiver",
+        return_value=mock_receiver,
+    ):
+        result = await hass.config_entries.flow.async_configure(
+            result["flow_id"],
+            {CONF_PORT: MOCK_PORT, CONF_MODEL: MOCK_MODEL},
+        )
+
+    assert result["type"] is FlowResultType.FORM
+    assert result["errors"] == {"base": "cannot_connect"}
+
+
+async def test_user_form_os_error(hass: HomeAssistant) -> None:
+    """Test we handle OS errors (e.g. serial port not found)."""
+    result = await hass.config_entries.flow.async_init(
+        DOMAIN, context={"source": SOURCE_USER}
+    )
+
+    mock_receiver = AsyncMock()
+    mock_receiver.connect = AsyncMock(side_effect=OSError("No such device"))
+
+    with patch(
+        "homeassistant.components.denon_rs232.config_flow.DenonReceiver",
+        return_value=mock_receiver,
+    ):
+        result = await hass.config_entries.flow.async_configure(
+            result["flow_id"],
+            {CONF_PORT: MOCK_PORT, CONF_MODEL: MOCK_MODEL},
+        )
+
+    assert result["type"] is FlowResultType.FORM
+    assert result["errors"] == {"base": "cannot_connect"}
+
+
+async def test_user_form_unknown_error(hass: HomeAssistant) -> None:
+    """Test we handle unexpected errors."""
+    result = await hass.config_entries.flow.async_init(
+        DOMAIN, context={"source": SOURCE_USER}
+    )
+
+    mock_receiver = AsyncMock()
+    mock_receiver.connect = AsyncMock(side_effect=RuntimeError("boom"))
+
+    with patch(
+        "homeassistant.components.denon_rs232.config_flow.DenonReceiver",
+        return_value=mock_receiver,
+    ):
+        result = await hass.config_entries.flow.async_configure(
+            result["flow_id"],
+            {CONF_PORT: MOCK_PORT, CONF_MODEL: MOCK_MODEL},
+        )
+
+    assert result["type"] is FlowResultType.FORM
+    assert result["errors"] == {"base": "unknown"}
+
+
+async def test_duplicate_port_aborts(hass: HomeAssistant) -> None:
+    """Test we abort if the same port is already configured."""
+    entry = MockConfigEntry(
+        domain=DOMAIN,
+        data={CONF_PORT: MOCK_PORT, CONF_MODEL: MOCK_MODEL},
+    )
+    entry.add_to_hass(hass)
+
+    result = await hass.config_entries.flow.async_init(
+        DOMAIN, context={"source": SOURCE_USER}
+    )
+
+    result = await hass.config_entries.flow.async_configure(
+        result["flow_id"],
+        {CONF_PORT: MOCK_PORT, CONF_MODEL: MOCK_MODEL},
+    )
+
+    assert result["type"] is FlowResultType.ABORT
+    assert result["reason"] == "already_configured"

tests/components/denon_rs232/test_media_player.py

@@ -0,0 +1,443 @@
+"""Tests for the Denon RS232 media player platform."""
+
+from unittest.mock import MagicMock, patch
+
+from denon_rs232 import DenonState, InputSource, PowerState
+
+from homeassistant.components.media_player import (
+    ATTR_INPUT_SOURCE,
+    ATTR_INPUT_SOURCE_LIST,
+    ATTR_MEDIA_VOLUME_LEVEL,
+    ATTR_MEDIA_VOLUME_MUTED,
+    ATTR_SOUND_MODE,
+    ATTR_SOUND_MODE_LIST,
+    DOMAIN as MP_DOMAIN,
+    SERVICE_SELECT_SOUND_MODE,
+    SERVICE_SELECT_SOURCE,
+)
+from homeassistant.const import (
+    ATTR_ENTITY_ID,
+    SERVICE_TURN_OFF,
+    SERVICE_TURN_ON,
+    SERVICE_VOLUME_DOWN,
+    SERVICE_VOLUME_MUTE,
+    SERVICE_VOLUME_SET,
+    SERVICE_VOLUME_UP,
+    STATE_OFF,
+    STATE_ON,
+)
+from homeassistant.core import HomeAssistant
+
+from .conftest import _default_state
+
+ENTITY_ID = "media_player.denon_receiver"
+
+
+async def _setup_integration(
+    hass: HomeAssistant,
+    mock_receiver: MagicMock,
+    mock_config_entry,
+) -> None:
+    """Set up the integration with a mock receiver."""
+    mock_config_entry.add_to_hass(hass)
+
+    with patch(
+        "homeassistant.components.denon_rs232.DenonReceiver",
+        return_value=mock_receiver,
+    ):
+        await hass.config_entries.async_setup(mock_config_entry.entry_id)
+        await hass.async_block_till_done()
+
+
+async def test_entity_created(
+    hass: HomeAssistant, mock_receiver, mock_config_entry
+) -> None:
+    """Test media player entity is created with correct state."""
+    await _setup_integration(hass, mock_receiver, mock_config_entry)
+
+    state = hass.states.get(ENTITY_ID)
+    assert state is not None
+    assert state.state == STATE_ON
+
+
+async def test_state_on(hass: HomeAssistant, mock_receiver, mock_config_entry) -> None:
+    """Test state is ON when receiver is powered on."""
+    await _setup_integration(hass, mock_receiver, mock_config_entry)
+
+    state = hass.states.get(ENTITY_ID)
+    assert state.state == STATE_ON
+
+
+async def test_state_off(hass: HomeAssistant, mock_receiver, mock_config_entry) -> None:
+    """Test state is OFF when receiver is in standby."""
+    mock_receiver.state = DenonState(power=PowerState.STANDBY)
+    await _setup_integration(hass, mock_receiver, mock_config_entry)
+
+    state = hass.states.get(ENTITY_ID)
+    assert state.state == STATE_OFF
+
+
+async def test_volume_level(
+    hass: HomeAssistant, mock_receiver, mock_config_entry
+) -> None:
+    """Test volume level is correctly converted from dB to 0..1."""
+    # -30 dB: ((-30) - (-80)) / 98 = 50 / 98 ≈ 0.5102
+    await _setup_integration(hass, mock_receiver, mock_config_entry)
+
+    state = hass.states.get(ENTITY_ID)
+    volume = state.attributes[ATTR_MEDIA_VOLUME_LEVEL]
+    assert abs(volume - 50.0 / 98.0) < 0.001
+
+
+async def test_mute_state(
+    hass: HomeAssistant, mock_receiver, mock_config_entry
+) -> None:
+    """Test mute state is reported."""
+    await _setup_integration(hass, mock_receiver, mock_config_entry)
+
+    state = hass.states.get(ENTITY_ID)
+    assert state.attributes[ATTR_MEDIA_VOLUME_MUTED] is False
+
+
+async def test_source(hass: HomeAssistant, mock_receiver, mock_config_entry) -> None:
+    """Test current source is reported."""
+    await _setup_integration(hass, mock_receiver, mock_config_entry)
+
+    state = hass.states.get(ENTITY_ID)
+    assert state.attributes[ATTR_INPUT_SOURCE] == "cd"
+
+
+async def test_source_net(
+    hass: HomeAssistant, mock_receiver, mock_config_entry
+) -> None:
+    """Test NET source is reported with the translation key."""
+    mock_receiver.state = DenonState(power=PowerState.ON, input_source=InputSource.NET)
+    await _setup_integration(hass, mock_receiver, mock_config_entry)
+
+    state = hass.states.get(ENTITY_ID)
+    assert state.attributes[ATTR_INPUT_SOURCE] == "net"
+
+
+async def test_source_bluetooth(
+    hass: HomeAssistant, mock_receiver, mock_config_entry
+) -> None:
+    """Test BT source is reported with the translation key."""
+    mock_receiver.state = DenonState(power=PowerState.ON, input_source=InputSource.BT)
+    await _setup_integration(hass, mock_receiver, mock_config_entry)
+
+    state = hass.states.get(ENTITY_ID)
+    assert state.attributes[ATTR_INPUT_SOURCE] == "bt"
+
+
+async def test_source_list(
+    hass: HomeAssistant, mock_receiver, mock_config_entry
+) -> None:
+    """Test source list comes from the model definition."""
+    await _setup_integration(hass, mock_receiver, mock_config_entry)
+
+    state = hass.states.get(ENTITY_ID)
+    source_list = state.attributes[ATTR_INPUT_SOURCE_LIST]
+    # AVR-3805 has the legacy sources (no VCR-3, no MD/TAPE2)
+    assert "cd" in source_list
+    assert "dvd" in source_list
+    assert "tuner" in source_list
+    # Should be sorted
+    assert source_list == sorted(source_list)
+
+
+async def test_sound_mode(
+    hass: HomeAssistant, mock_receiver, mock_config_entry
+) -> None:
+    """Test surround mode is reported as sound mode."""
+    await _setup_integration(hass, mock_receiver, mock_config_entry)
+
+    state = hass.states.get(ENTITY_ID)
+    assert state.attributes[ATTR_SOUND_MODE] == "stereo"
+
+
+async def test_sound_mode_list(
+    hass: HomeAssistant, mock_receiver, mock_config_entry
+) -> None:
+    """Test sound mode list comes from the model definition."""
+    await _setup_integration(hass, mock_receiver, mock_config_entry)
+
+    state = hass.states.get(ENTITY_ID)
+    mode_list = state.attributes[ATTR_SOUND_MODE_LIST]
+    assert "direct" in mode_list
+    assert "stereo" in mode_list
+    assert "dolby_digital" in mode_list
+
+
+async def test_turn_on(hass: HomeAssistant, mock_receiver, mock_config_entry) -> None:
+    """Test turning on the receiver."""
+    await _setup_integration(hass, mock_receiver, mock_config_entry)
+
+    await hass.services.async_call(
+        MP_DOMAIN,
+        SERVICE_TURN_ON,
+        {ATTR_ENTITY_ID: ENTITY_ID},
+        blocking=True,
+    )
+    mock_receiver.power_on.assert_awaited_once()
+
+
+async def test_turn_off(hass: HomeAssistant, mock_receiver, mock_config_entry) -> None:
+    """Test turning off the receiver."""
+    await _setup_integration(hass, mock_receiver, mock_config_entry)
+
+    await hass.services.async_call(
+        MP_DOMAIN,
+        SERVICE_TURN_OFF,
+        {ATTR_ENTITY_ID: ENTITY_ID},
+        blocking=True,
+    )
+    mock_receiver.power_standby.assert_awaited_once()
+
+
+async def test_set_volume(
+    hass: HomeAssistant, mock_receiver, mock_config_entry
+) -> None:
+    """Test setting volume level converts from 0..1 to dB."""
+    await _setup_integration(hass, mock_receiver, mock_config_entry)
+
+    await hass.services.async_call(
+        MP_DOMAIN,
+        SERVICE_VOLUME_SET,
+        {ATTR_ENTITY_ID: ENTITY_ID, ATTR_MEDIA_VOLUME_LEVEL: 0.5},
+        blocking=True,
+    )
+    # 0.5 * 98 + (-80) = -31.0
+    mock_receiver.set_volume.assert_awaited_once_with(-31.0)
+
+
+async def test_volume_up(hass: HomeAssistant, mock_receiver, mock_config_entry) -> None:
+    """Test volume up."""
+    await _setup_integration(hass, mock_receiver, mock_config_entry)
+
+    await hass.services.async_call(
+        MP_DOMAIN,
+        SERVICE_VOLUME_UP,
+        {ATTR_ENTITY_ID: ENTITY_ID},
+        blocking=True,
+    )
+    mock_receiver.volume_up.assert_awaited_once()
+
+
+async def test_volume_down(
+    hass: HomeAssistant, mock_receiver, mock_config_entry
+) -> None:
+    """Test volume down."""
+    await _setup_integration(hass, mock_receiver, mock_config_entry)
+
+    await hass.services.async_call(
+        MP_DOMAIN,
+        SERVICE_VOLUME_DOWN,
+        {ATTR_ENTITY_ID: ENTITY_ID},
+        blocking=True,
+    )
+    mock_receiver.volume_down.assert_awaited_once()
+
+
+async def test_mute(hass: HomeAssistant, mock_receiver, mock_config_entry) -> None:
+    """Test muting."""
+    await _setup_integration(hass, mock_receiver, mock_config_entry)
+
+    await hass.services.async_call(
+        MP_DOMAIN,
+        SERVICE_VOLUME_MUTE,
+        {ATTR_ENTITY_ID: ENTITY_ID, ATTR_MEDIA_VOLUME_MUTED: True},
+        blocking=True,
+    )
+    mock_receiver.mute_on.assert_awaited_once()
+
+
+async def test_unmute(hass: HomeAssistant, mock_receiver, mock_config_entry) -> None:
+    """Test unmuting."""
+    await _setup_integration(hass, mock_receiver, mock_config_entry)
+
+    await hass.services.async_call(
+        MP_DOMAIN,
+        SERVICE_VOLUME_MUTE,
+        {ATTR_ENTITY_ID: ENTITY_ID, ATTR_MEDIA_VOLUME_MUTED: False},
+        blocking=True,
+    )
+    mock_receiver.mute_off.assert_awaited_once()
+
+
+async def test_select_source(
+    hass: HomeAssistant, mock_receiver, mock_config_entry
+) -> None:
+    """Test selecting input source."""
+    await _setup_integration(hass, mock_receiver, mock_config_entry)
+
+    await hass.services.async_call(
+        MP_DOMAIN,
+        SERVICE_SELECT_SOURCE,
+        {ATTR_ENTITY_ID: ENTITY_ID, ATTR_INPUT_SOURCE: "dvd"},
+        blocking=True,
+    )
+    mock_receiver.select_input_source.assert_awaited_once_with(InputSource.DVD)
+
+
+async def test_select_source_net(
+    hass: HomeAssistant, mock_receiver, mock_config_entry
+) -> None:
+    """Test selecting NET source."""
+    await _setup_integration(hass, mock_receiver, mock_config_entry)
+
+    await hass.services.async_call(
+        MP_DOMAIN,
+        SERVICE_SELECT_SOURCE,
+        {ATTR_ENTITY_ID: ENTITY_ID, ATTR_INPUT_SOURCE: "net"},
+        blocking=True,
+    )
+    mock_receiver.select_input_source.assert_awaited_once_with(InputSource.NET)
+
+
+async def test_select_source_bluetooth(
+    hass: HomeAssistant, mock_receiver, mock_config_entry
+) -> None:
+    """Test selecting BT source."""
+    await _setup_integration(hass, mock_receiver, mock_config_entry)
+
+    await hass.services.async_call(
+        MP_DOMAIN,
+        SERVICE_SELECT_SOURCE,
+        {ATTR_ENTITY_ID: ENTITY_ID, ATTR_INPUT_SOURCE: "bt"},
+        blocking=True,
+    )
+    mock_receiver.select_input_source.assert_awaited_once_with(InputSource.BT)
+
+
+async def test_select_source_raw_value(
+    hass: HomeAssistant, mock_receiver, mock_config_entry
+) -> None:
+    """Test selecting a raw protocol source value still works."""
+    await _setup_integration(hass, mock_receiver, mock_config_entry)
+
+    await hass.services.async_call(
+        MP_DOMAIN,
+        SERVICE_SELECT_SOURCE,
+        {ATTR_ENTITY_ID: ENTITY_ID, ATTR_INPUT_SOURCE: "DVD"},
+        blocking=True,
+    )
+    mock_receiver.select_input_source.assert_awaited_once_with(InputSource.DVD)
+
+
+async def test_select_source_unknown(
+    hass: HomeAssistant, mock_receiver, mock_config_entry
+) -> None:
+    """Test selecting an unknown source does nothing."""
+    await _setup_integration(hass, mock_receiver, mock_config_entry)
+
+    await hass.services.async_call(
+        MP_DOMAIN,
+        SERVICE_SELECT_SOURCE,
+        {ATTR_ENTITY_ID: ENTITY_ID, ATTR_INPUT_SOURCE: "NONEXISTENT"},
+        blocking=True,
+    )
+    mock_receiver.select_input_source.assert_not_awaited()
+
+
+async def test_select_sound_mode(
+    hass: HomeAssistant, mock_receiver, mock_config_entry
+) -> None:
+    """Test selecting sound mode."""
+    await _setup_integration(hass, mock_receiver, mock_config_entry)
+
+    await hass.services.async_call(
+        MP_DOMAIN,
+        SERVICE_SELECT_SOUND_MODE,
+        {ATTR_ENTITY_ID: ENTITY_ID, ATTR_SOUND_MODE: "dolby_digital"},
+        blocking=True,
+    )
+    mock_receiver.set_surround_mode.assert_awaited_once_with("DOLBY DIGITAL")
+
+
+async def test_select_sound_mode_raw_value(
+    hass: HomeAssistant, mock_receiver, mock_config_entry
+) -> None:
+    """Test selecting a raw protocol sound mode value still works."""
+    await _setup_integration(hass, mock_receiver, mock_config_entry)
+
+    await hass.services.async_call(
+        MP_DOMAIN,
+        SERVICE_SELECT_SOUND_MODE,
+        {ATTR_ENTITY_ID: ENTITY_ID, ATTR_SOUND_MODE: "DOLBY DIGITAL"},
+        blocking=True,
+    )
+    mock_receiver.set_surround_mode.assert_awaited_once_with("DOLBY DIGITAL")
+
+
+async def test_push_update(
+    hass: HomeAssistant, mock_receiver, mock_config_entry
+) -> None:
+    """Test state updates from the receiver via subscribe callback."""
+    await _setup_integration(hass, mock_receiver, mock_config_entry)
+
+    # Get the callback that was passed to subscribe()
+    # The __init__.py subscribe is call [0], media_player subscribe is call [1]
+    media_player_subscribe = mock_receiver.subscribe.call_args_list[1]
+    callback = media_player_subscribe[0][0]
+
+    # Simulate a state change from the receiver
+    new_state = _default_state()
+    new_state.volume = -20.0
+    new_state.input_source = InputSource.DVD
+    new_state.surround_mode = "DOLBY DIGITAL"
+
+    callback(new_state)
+    await hass.async_block_till_done()
+
+    state = hass.states.get(ENTITY_ID)
+    assert state.attributes[ATTR_INPUT_SOURCE] == "dvd"
+    assert state.attributes[ATTR_SOUND_MODE] == "dolby_digital"
+    expected_volume = ((-20.0) - (-80.0)) / 98.0
+    assert abs(state.attributes[ATTR_MEDIA_VOLUME_LEVEL] - expected_volume) < 0.001
+
+
+async def test_push_disconnect(
+    hass: HomeAssistant, mock_receiver, mock_config_entry
+) -> None:
+    """Test entity becomes unavailable on disconnect."""
+    await _setup_integration(hass, mock_receiver, mock_config_entry)
+
+    media_player_subscribe = mock_receiver.subscribe.call_args_list[1]
+    callback = media_player_subscribe[0][0]
+
+    # Simulate disconnect (callback receives None)
+    callback(None)
+    await hass.async_block_till_done()
+
+    state = hass.states.get(ENTITY_ID)
+    assert state.state == "unavailable"
+
+
+async def test_push_reconnect(
+    hass: HomeAssistant, mock_receiver, mock_config_entry
+) -> None:
+    """Test entity becomes available again after disconnect and reconnect."""
+    await _setup_integration(hass, mock_receiver, mock_config_entry)
+
+    media_player_subscribe = mock_receiver.subscribe.call_args_list[1]
+    callback = media_player_subscribe[0][0]
+
+    # Disconnect
+    callback(None)
+    await hass.async_block_till_done()
+    assert hass.states.get(ENTITY_ID).state == "unavailable"
+
+    # Reconnect with new state
+    callback(_default_state())
+    await hass.async_block_till_done()
+    assert hass.states.get(ENTITY_ID).state == STATE_ON
+
+
+async def test_unload(hass: HomeAssistant, mock_receiver, mock_config_entry) -> None:
+    """Test unloading the integration disconnects the receiver."""
+    await _setup_integration(hass, mock_receiver, mock_config_entry)
+
+    await hass.config_entries.async_unload(mock_config_entry.entry_id)
+    await hass.async_block_till_done()
+
+    mock_receiver.disconnect.assert_awaited_once()