diff --git a/CODEOWNERS b/CODEOWNERS
index 97d2b9f9d9bfe6204d637e0784495f26438c8e1c..6e2efe9101dda161206b367a0ca53de58e640d0e 100644
--- a/CODEOWNERS
+++ b/CODEOWNERS
@@ -137,6 +137,8 @@ build.json @home-assistant/supervisor
/tests/components/blebox/ @bbx-a @riokuu
/homeassistant/components/blink/ @fronzbot
/tests/components/blink/ @fronzbot
+/homeassistant/components/bluemaestro/ @bdraco
+/tests/components/bluemaestro/ @bdraco
/homeassistant/components/blueprint/ @home-assistant/core
/tests/components/blueprint/ @home-assistant/core
/homeassistant/components/bluesound/ @thrawnarn
diff --git a/homeassistant/components/bluemaestro/__init__.py b/homeassistant/components/bluemaestro/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..45eebedcfb2ac54a9b923ba695baf3e500b7e8d9
--- /dev/null
+++ b/homeassistant/components/bluemaestro/__init__.py
@@ -0,0 +1,49 @@
+"""The BlueMaestro integration."""
+from __future__ import annotations
+
+import logging
+
+from bluemaestro_ble import BlueMaestroBluetoothDeviceData
+
+from homeassistant.components.bluetooth import BluetoothScanningMode
+from homeassistant.components.bluetooth.passive_update_processor import (
+ PassiveBluetoothProcessorCoordinator,
+)
+from homeassistant.config_entries import ConfigEntry
+from homeassistant.const import Platform
+from homeassistant.core import HomeAssistant
+
+from .const import DOMAIN
+
+PLATFORMS: list[Platform] = [Platform.SENSOR]
+
+_LOGGER = logging.getLogger(__name__)
+
+
+async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
+ """Set up BlueMaestro BLE device from a config entry."""
+ address = entry.unique_id
+ assert address is not None
+ data = BlueMaestroBluetoothDeviceData()
+ coordinator = hass.data.setdefault(DOMAIN, {})[
+ entry.entry_id
+ ] = PassiveBluetoothProcessorCoordinator(
+ hass,
+ _LOGGER,
+ address=address,
+ mode=BluetoothScanningMode.PASSIVE,
+ update_method=data.update,
+ )
+ await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
+ entry.async_on_unload(
+ coordinator.async_start()
+ ) # only start after all platforms have had a chance to subscribe
+ return True
+
+
+async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
+ """Unload a config entry."""
+ if unload_ok := await hass.config_entries.async_unload_platforms(entry, PLATFORMS):
+ hass.data[DOMAIN].pop(entry.entry_id)
+
+ return unload_ok
diff --git a/homeassistant/components/bluemaestro/config_flow.py b/homeassistant/components/bluemaestro/config_flow.py
new file mode 100644
index 0000000000000000000000000000000000000000..ccb548fa42b472214512e0c36e2cac3dded276e6
--- /dev/null
+++ b/homeassistant/components/bluemaestro/config_flow.py
@@ -0,0 +1,94 @@
+"""Config flow for bluemaestro ble integration."""
+from __future__ import annotations
+
+from typing import Any
+
+from bluemaestro_ble import BlueMaestroBluetoothDeviceData as DeviceData
+import voluptuous as vol
+
+from homeassistant.components.bluetooth import (
+ BluetoothServiceInfoBleak,
+ async_discovered_service_info,
+)
+from homeassistant.config_entries import ConfigFlow
+from homeassistant.const import CONF_ADDRESS
+from homeassistant.data_entry_flow import FlowResult
+
+from .const import DOMAIN
+
+
+class BlueMaestroConfigFlow(ConfigFlow, domain=DOMAIN):
+ """Handle a config flow for bluemaestro."""
+
+ VERSION = 1
+
+ def __init__(self) -> None:
+ """Initialize the config flow."""
+ self._discovery_info: BluetoothServiceInfoBleak | None = None
+ self._discovered_device: DeviceData | None = None
+ self._discovered_devices: dict[str, str] = {}
+
+ async def async_step_bluetooth(
+ self, discovery_info: BluetoothServiceInfoBleak
+ ) -> FlowResult:
+ """Handle the bluetooth discovery step."""
+ await self.async_set_unique_id(discovery_info.address)
+ self._abort_if_unique_id_configured()
+ device = DeviceData()
+ if not device.supported(discovery_info):
+ return self.async_abort(reason="not_supported")
+ self._discovery_info = discovery_info
+ self._discovered_device = device
+ return await self.async_step_bluetooth_confirm()
+
+ async def async_step_bluetooth_confirm(
+ self, user_input: dict[str, Any] | None = None
+ ) -> FlowResult:
+ """Confirm discovery."""
+ assert self._discovered_device is not None
+ device = self._discovered_device
+ assert self._discovery_info is not None
+ discovery_info = self._discovery_info
+ title = device.title or device.get_device_name() or discovery_info.name
+ if user_input is not None:
+ return self.async_create_entry(title=title, data={})
+
+ self._set_confirm_only()
+ placeholders = {"name": title}
+ self.context["title_placeholders"] = placeholders
+ return self.async_show_form(
+ step_id="bluetooth_confirm", description_placeholders=placeholders
+ )
+
+ async def async_step_user(
+ self, user_input: dict[str, Any] | None = None
+ ) -> FlowResult:
+ """Handle the user step to pick discovered device."""
+ if user_input is not None:
+ address = user_input[CONF_ADDRESS]
+ await self.async_set_unique_id(address, raise_on_progress=False)
+ self._abort_if_unique_id_configured()
+ return self.async_create_entry(
+ title=self._discovered_devices[address], data={}
+ )
+
+ current_addresses = self._async_current_ids()
+ for discovery_info in async_discovered_service_info(self.hass, False):
+ address = discovery_info.address
+ if address in current_addresses or address in self._discovered_devices:
+ continue
+ device = DeviceData()
+ if device.supported(discovery_info):
+ self._discovered_devices[address] = (
+ device.title or device.get_device_name() or discovery_info.name
+ )
+
+ if not self._discovered_devices:
+ return self.async_abort(reason="no_devices_found")
+
+ return self.async_show_form(
+ step_id="user",
+ data_schema=vol.Schema(
+ {vol.Required(CONF_ADDRESS): vol.In(self._discovered_devices)}
+ ),
+ )
diff --git a/homeassistant/components/bluemaestro/const.py b/homeassistant/components/bluemaestro/const.py
new file mode 100644
index 0000000000000000000000000000000000000000..757f1b7c8106eb2df88d36cbf0af0640b914430a
--- /dev/null
+++ b/homeassistant/components/bluemaestro/const.py
@@ -0,0 +1,3 @@
+"""Constants for the BlueMaestro integration."""
+
+DOMAIN = "bluemaestro"
diff --git a/homeassistant/components/bluemaestro/device.py b/homeassistant/components/bluemaestro/device.py
new file mode 100644
index 0000000000000000000000000000000000000000..3d6e45468828bcf7cdab5f0ad5326aa8b438700f
--- /dev/null
+++ b/homeassistant/components/bluemaestro/device.py
@@ -0,0 +1,31 @@
+"""Support for BlueMaestro devices."""
+from __future__ import annotations
+
+from bluemaestro_ble import DeviceKey, SensorDeviceInfo
+
+from homeassistant.components.bluetooth.passive_update_processor import (
+ PassiveBluetoothEntityKey,
+)
+from homeassistant.const import ATTR_MANUFACTURER, ATTR_MODEL, ATTR_NAME
+from homeassistant.helpers.entity import DeviceInfo
+
+
+def device_key_to_bluetooth_entity_key(
+ device_key: DeviceKey,
+) -> PassiveBluetoothEntityKey:
+ """Convert a device key to an entity key."""
+ return PassiveBluetoothEntityKey(device_key.key, device_key.device_id)
+
+
+def sensor_device_info_to_hass(
+ sensor_device_info: SensorDeviceInfo,
+) -> DeviceInfo:
+ """Convert a bluemaestro device info to a sensor device info."""
+ hass_device_info = DeviceInfo({})
+ if sensor_device_info.name is not None:
+ hass_device_info[ATTR_NAME] = sensor_device_info.name
+ if sensor_device_info.manufacturer is not None:
+ hass_device_info[ATTR_MANUFACTURER] = sensor_device_info.manufacturer
+ if sensor_device_info.model is not None:
+ hass_device_info[ATTR_MODEL] = sensor_device_info.model
+ return hass_device_info
diff --git a/homeassistant/components/bluemaestro/manifest.json b/homeassistant/components/bluemaestro/manifest.json
new file mode 100644
index 0000000000000000000000000000000000000000..0ff9cdd0794f8b274e31edde2cbe06cccd79d7b1
--- /dev/null
+++ b/homeassistant/components/bluemaestro/manifest.json
@@ -0,0 +1,16 @@
+{
+ "domain": "bluemaestro",
+ "name": "BlueMaestro",
+ "config_flow": true,
+ "documentation": "https://www.home-assistant.io/integrations/bluemaestro",
+ "bluetooth": [
+ {
+ "manufacturer_id": 307,
+ "connectable": false
+ }
+ ],
+ "requirements": ["bluemaestro-ble==0.2.0"],
+ "dependencies": ["bluetooth"],
+ "codeowners": ["@bdraco"],
+ "iot_class": "local_push"
+}
diff --git a/homeassistant/components/bluemaestro/sensor.py b/homeassistant/components/bluemaestro/sensor.py
new file mode 100644
index 0000000000000000000000000000000000000000..8afdef48d51cf6f109d91ef230e92e31b6aa0f55
--- /dev/null
+++ b/homeassistant/components/bluemaestro/sensor.py
@@ -0,0 +1,149 @@
+"""Support for BlueMaestro sensors."""
+from __future__ import annotations
+
+from typing import Optional, Union
+
+from bluemaestro_ble import (
+ SensorDeviceClass as BlueMaestroSensorDeviceClass,
+ SensorUpdate,
+ Units,
+)
+
+from homeassistant import config_entries
+from homeassistant.components.bluetooth.passive_update_processor import (
+ PassiveBluetoothDataProcessor,
+ PassiveBluetoothDataUpdate,
+ PassiveBluetoothProcessorCoordinator,
+ PassiveBluetoothProcessorEntity,
+)
+from homeassistant.components.sensor import (
+ SensorDeviceClass,
+ SensorEntity,
+ SensorEntityDescription,
+ SensorStateClass,
+)
+from homeassistant.const import (
+ PERCENTAGE,
+ PRESSURE_MBAR,
+ SIGNAL_STRENGTH_DECIBELS_MILLIWATT,
+ TEMP_CELSIUS,
+)
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers.entity import EntityCategory
+from homeassistant.helpers.entity_platform import AddEntitiesCallback
+
+from .const import DOMAIN
+from .device import device_key_to_bluetooth_entity_key, sensor_device_info_to_hass
+
+SENSOR_DESCRIPTIONS = {
+ (BlueMaestroSensorDeviceClass.BATTERY, Units.PERCENTAGE): SensorEntityDescription(
+ key=f"{BlueMaestroSensorDeviceClass.BATTERY}_{Units.PERCENTAGE}",
+ device_class=SensorDeviceClass.BATTERY,
+ native_unit_of_measurement=PERCENTAGE,
+ state_class=SensorStateClass.MEASUREMENT,
+ entity_category=EntityCategory.DIAGNOSTIC,
+ ),
+ (BlueMaestroSensorDeviceClass.HUMIDITY, Units.PERCENTAGE): SensorEntityDescription(
+ key=f"{BlueMaestroSensorDeviceClass.HUMIDITY}_{Units.PERCENTAGE}",
+ device_class=SensorDeviceClass.HUMIDITY,
+ native_unit_of_measurement=PERCENTAGE,
+ state_class=SensorStateClass.MEASUREMENT,
+ ),
+ (
+ BlueMaestroSensorDeviceClass.SIGNAL_STRENGTH,
+ Units.SIGNAL_STRENGTH_DECIBELS_MILLIWATT,
+ ): SensorEntityDescription(
+ key=f"{BlueMaestroSensorDeviceClass.SIGNAL_STRENGTH}_{Units.SIGNAL_STRENGTH_DECIBELS_MILLIWATT}",
+ device_class=SensorDeviceClass.SIGNAL_STRENGTH,
+ native_unit_of_measurement=SIGNAL_STRENGTH_DECIBELS_MILLIWATT,
+ state_class=SensorStateClass.MEASUREMENT,
+ entity_category=EntityCategory.DIAGNOSTIC,
+ entity_registry_enabled_default=False,
+ ),
+ (
+ BlueMaestroSensorDeviceClass.TEMPERATURE,
+ Units.TEMP_CELSIUS,
+ ): SensorEntityDescription(
+ key=f"{BlueMaestroSensorDeviceClass.TEMPERATURE}_{Units.TEMP_CELSIUS}",
+ device_class=SensorDeviceClass.TEMPERATURE,
+ native_unit_of_measurement=TEMP_CELSIUS,
+ state_class=SensorStateClass.MEASUREMENT,
+ ),
+ (
+ BlueMaestroSensorDeviceClass.DEW_POINT,
+ Units.TEMP_CELSIUS,
+ ): SensorEntityDescription(
+ key=f"{BlueMaestroSensorDeviceClass.DEW_POINT}_{Units.TEMP_CELSIUS}",
+ device_class=SensorDeviceClass.TEMPERATURE,
+ native_unit_of_measurement=TEMP_CELSIUS,
+ state_class=SensorStateClass.MEASUREMENT,
+ ),
+ (
+ BlueMaestroSensorDeviceClass.PRESSURE,
+ Units.PRESSURE_MBAR,
+ ): SensorEntityDescription(
+ key=f"{BlueMaestroSensorDeviceClass.PRESSURE}_{Units.PRESSURE_MBAR}",
+ device_class=SensorDeviceClass.PRESSURE,
+ native_unit_of_measurement=PRESSURE_MBAR,
+ state_class=SensorStateClass.MEASUREMENT,
+ ),
+}
+
+
+def sensor_update_to_bluetooth_data_update(
+ sensor_update: SensorUpdate,
+) -> PassiveBluetoothDataUpdate:
+ """Convert a sensor update to a bluetooth data update."""
+ return PassiveBluetoothDataUpdate(
+ devices={
+ device_id: sensor_device_info_to_hass(device_info)
+ for device_id, device_info in sensor_update.devices.items()
+ },
+ entity_descriptions={
+ device_key_to_bluetooth_entity_key(device_key): SENSOR_DESCRIPTIONS[
+ (description.device_class, description.native_unit_of_measurement)
+ ]
+ for device_key, description in sensor_update.entity_descriptions.items()
+ if description.device_class and description.native_unit_of_measurement
+ },
+ entity_data={
+ device_key_to_bluetooth_entity_key(device_key): sensor_values.native_value
+ for device_key, sensor_values in sensor_update.entity_values.items()
+ },
+ entity_names={
+ device_key_to_bluetooth_entity_key(device_key): sensor_values.name
+ for device_key, sensor_values in sensor_update.entity_values.items()
+ },
+ )
+
+
+async def async_setup_entry(
+ hass: HomeAssistant,
+ entry: config_entries.ConfigEntry,
+ async_add_entities: AddEntitiesCallback,
+) -> None:
+ """Set up the BlueMaestro BLE sensors."""
+ coordinator: PassiveBluetoothProcessorCoordinator = hass.data[DOMAIN][
+ entry.entry_id
+ ]
+ processor = PassiveBluetoothDataProcessor(sensor_update_to_bluetooth_data_update)
+ entry.async_on_unload(
+ processor.async_add_entities_listener(
+ BlueMaestroBluetoothSensorEntity, async_add_entities
+ )
+ )
+ entry.async_on_unload(coordinator.async_register_processor(processor))
+
+
+class BlueMaestroBluetoothSensorEntity(
+ PassiveBluetoothProcessorEntity[
+ PassiveBluetoothDataProcessor[Optional[Union[float, int]]]
+ ],
+ SensorEntity,
+):
+ """Representation of a BlueMaestro sensor."""
+
+ @property
+ def native_value(self) -> int | float | None:
+ """Return the native value."""
+ return self.processor.entity_data.get(self.entity_key)
diff --git a/homeassistant/components/bluemaestro/strings.json b/homeassistant/components/bluemaestro/strings.json
new file mode 100644
index 0000000000000000000000000000000000000000..a045d84771e33be840d45c347e679a26088d389c
--- /dev/null
+++ b/homeassistant/components/bluemaestro/strings.json
@@ -0,0 +1,22 @@
+{
+ "config": {
+ "flow_title": "[%key:component::bluetooth::config::flow_title%]",
+ "step": {
+ "user": {
+ "description": "[%key:component::bluetooth::config::step::user::description%]",
+ "data": {
+ "address": "[%key:component::bluetooth::config::step::user::data::address%]"
+ }
+ },
+ "bluetooth_confirm": {
+ "description": "[%key:component::bluetooth::config::step::bluetooth_confirm::description%]"
+ }
+ },
+ "abort": {
+ "not_supported": "Device not supported",
+ "no_devices_found": "[%key:common::config_flow::abort::no_devices_found%]",
+ "already_in_progress": "[%key:common::config_flow::abort::already_in_progress%]",
+ "already_configured": "[%key:common::config_flow::abort::already_configured_device%]"
+ }
+ }
+}
diff --git a/homeassistant/components/bluemaestro/translations/en.json b/homeassistant/components/bluemaestro/translations/en.json
new file mode 100644
index 0000000000000000000000000000000000000000..ebd9760c161d868d218aa47eedf7a3c0d0dfb817
--- /dev/null
+++ b/homeassistant/components/bluemaestro/translations/en.json
@@ -0,0 +1,22 @@
+{
+ "config": {
+ "abort": {
+ "already_configured": "Device is already configured",
+ "already_in_progress": "Configuration flow is already in progress",
+ "no_devices_found": "No devices found on the network",
+ "not_supported": "Device not supported"
+ },
+ "flow_title": "{name}",
+ "step": {
+ "bluetooth_confirm": {
+ "description": "Do you want to setup {name}?"
+ },
+ "user": {
+ "data": {
+ "address": "Device"
+ },
+ "description": "Choose a device to setup"
+ }
+ }
+ }
+}
\ No newline at end of file
diff --git a/homeassistant/generated/bluetooth.py b/homeassistant/generated/bluetooth.py
index 14156ada20cecaf4d88a2a0088c5b43672c8dad5..c217cf790b8d18485cfc61376e4081b40b283139 100644
--- a/homeassistant/generated/bluetooth.py
+++ b/homeassistant/generated/bluetooth.py
@@ -7,6 +7,11 @@ from __future__ import annotations
# fmt: off
BLUETOOTH: list[dict[str, bool | str | int | list[int]]] = [
+ {
+ "domain": "bluemaestro",
+ "manufacturer_id": 307,
+ "connectable": False
+ },
{
"domain": "bthome",
"connectable": False,
diff --git a/homeassistant/generated/config_flows.py b/homeassistant/generated/config_flows.py
index 5aa0ed6933612a5ce98e98b6e9afa455bc468938..7e12845cf744ebfa17b26a304088fd83c190321b 100644
--- a/homeassistant/generated/config_flows.py
+++ b/homeassistant/generated/config_flows.py
@@ -48,6 +48,7 @@ FLOWS = {
"balboa",
"blebox",
"blink",
+ "bluemaestro",
"bluetooth",
"bmw_connected_drive",
"bond",
diff --git a/requirements_all.txt b/requirements_all.txt
index a77007b00f80a71697e359f239ec73e96dcc4629..a9c99079d644352a27a87bd95bb086d36dc3e909 100644
--- a/requirements_all.txt
+++ b/requirements_all.txt
@@ -422,6 +422,9 @@ blinkstick==1.2.0
# homeassistant.components.bitcoin
blockchain==1.4.4
+# homeassistant.components.bluemaestro
+bluemaestro-ble==0.2.0
+
# homeassistant.components.decora
# homeassistant.components.zengge
# bluepy==1.3.0
diff --git a/requirements_test_all.txt b/requirements_test_all.txt
index 518af11783d24c14898dd098acb7e3bbee6b5136..60bc497e6d8f88893cb47c9658b975497368ddc8 100644
--- a/requirements_test_all.txt
+++ b/requirements_test_all.txt
@@ -337,6 +337,9 @@ blebox_uniapi==2.0.2
# homeassistant.components.blink
blinkpy==0.19.0
+# homeassistant.components.bluemaestro
+bluemaestro-ble==0.2.0
+
# homeassistant.components.bluetooth
bluetooth-adapters==0.3.4
diff --git a/tests/components/bluemaestro/__init__.py b/tests/components/bluemaestro/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..bd9b86e040fb8d8927d66010fb78f2298c8b45ea
--- /dev/null
+++ b/tests/components/bluemaestro/__init__.py
@@ -0,0 +1,26 @@
+"""Tests for the BlueMaestro integration."""
+
+
+from homeassistant.helpers.service_info.bluetooth import BluetoothServiceInfo
+
+NOT_BLUEMAESTRO_SERVICE_INFO = BluetoothServiceInfo(
+ name="Not it",
+ address="61DE521B-F0BF-9F44-64D4-75BBE1738105",
+ rssi=-63,
+ manufacturer_data={3234: b"\x00\x01"},
+ service_data={},
+ service_uuids=[],
+ source="local",
+)
+
+BLUEMAESTRO_SERVICE_INFO = BluetoothServiceInfo(
+ name="FA17B62C",
+ manufacturer_data={
+ 307: b"\x17d\x0e\x10\x00\x02\x00\xf2\x01\xf2\x00\x83\x01\x00\x01\r\x02\xab\x00\xf2\x01\xf2\x01\r\x02\xab\x00\xf2\x01\xf2\x00\xff\x02N\x00\x00\x00\x00\x00"
+ },
+ address="aa:bb:cc:dd:ee:ff",
+ rssi=-60,
+ service_data={},
+ service_uuids=[],
+ source="local",
+)
diff --git a/tests/components/bluemaestro/conftest.py b/tests/components/bluemaestro/conftest.py
new file mode 100644
index 0000000000000000000000000000000000000000..e40cf1e30f45edbe1f51c2316e5448fbef5cbbe0
--- /dev/null
+++ b/tests/components/bluemaestro/conftest.py
@@ -0,0 +1,8 @@
+"""BlueMaestro session fixtures."""
+
+import pytest
+
+
+@pytest.fixture(autouse=True)
+def mock_bluetooth(enable_bluetooth):
+ """Auto mock bluetooth."""
diff --git a/tests/components/bluemaestro/test_config_flow.py b/tests/components/bluemaestro/test_config_flow.py
new file mode 100644
index 0000000000000000000000000000000000000000..116380a0df0f080952176910069f81678ad1d373
--- /dev/null
+++ b/tests/components/bluemaestro/test_config_flow.py
@@ -0,0 +1,200 @@
+"""Test the BlueMaestro config flow."""
+
+from unittest.mock import patch
+
+from homeassistant import config_entries
+from homeassistant.components.bluemaestro.const import DOMAIN
+from homeassistant.data_entry_flow import FlowResultType
+
+from . import BLUEMAESTRO_SERVICE_INFO, NOT_BLUEMAESTRO_SERVICE_INFO
+
+from tests.common import MockConfigEntry
+
+
+async def test_async_step_bluetooth_valid_device(hass):
+ """Test discovery via bluetooth with a valid device."""
+ result = await hass.config_entries.flow.async_init(
+ DOMAIN,
+ context={"source": config_entries.SOURCE_BLUETOOTH},
+ data=BLUEMAESTRO_SERVICE_INFO,
+ )
+ assert result["type"] == FlowResultType.FORM
+ assert result["step_id"] == "bluetooth_confirm"
+ with patch(
+ "homeassistant.components.bluemaestro.async_setup_entry", return_value=True
+ ):
+ result2 = await hass.config_entries.flow.async_configure(
+ result["flow_id"], user_input={}
+ )
+ assert result2["type"] == FlowResultType.CREATE_ENTRY
+ assert result2["title"] == "Tempo Disc THD EEFF"
+ assert result2["data"] == {}
+ assert result2["result"].unique_id == "aa:bb:cc:dd:ee:ff"
+
+
+async def test_async_step_bluetooth_not_bluemaestro(hass):
+ """Test discovery via bluetooth not bluemaestro."""
+ result = await hass.config_entries.flow.async_init(
+ DOMAIN,
+ context={"source": config_entries.SOURCE_BLUETOOTH},
+ data=NOT_BLUEMAESTRO_SERVICE_INFO,
+ )
+ assert result["type"] == FlowResultType.ABORT
+ assert result["reason"] == "not_supported"
+
+
+async def test_async_step_user_no_devices_found(hass):
+ """Test setup from service info cache with no devices found."""
+ result = await hass.config_entries.flow.async_init(
+ DOMAIN,
+ context={"source": config_entries.SOURCE_USER},
+ )
+ assert result["type"] == FlowResultType.ABORT
+ assert result["reason"] == "no_devices_found"
+
+
+async def test_async_step_user_with_found_devices(hass):
+ """Test setup from service info cache with devices found."""
+ with patch(
+ "homeassistant.components.bluemaestro.config_flow.async_discovered_service_info",
+ return_value=[BLUEMAESTRO_SERVICE_INFO],
+ ):
+ result = await hass.config_entries.flow.async_init(
+ DOMAIN,
+ context={"source": config_entries.SOURCE_USER},
+ )
+ assert result["type"] == FlowResultType.FORM
+ assert result["step_id"] == "user"
+ with patch(
+ "homeassistant.components.bluemaestro.async_setup_entry", return_value=True
+ ):
+ result2 = await hass.config_entries.flow.async_configure(
+ result["flow_id"],
+ user_input={"address": "aa:bb:cc:dd:ee:ff"},
+ )
+ assert result2["type"] == FlowResultType.CREATE_ENTRY
+ assert result2["title"] == "Tempo Disc THD EEFF"
+ assert result2["data"] == {}
+ assert result2["result"].unique_id == "aa:bb:cc:dd:ee:ff"
+
+
+async def test_async_step_user_device_added_between_steps(hass):
+ """Test the device gets added via another flow between steps."""
+ with patch(
+ "homeassistant.components.bluemaestro.config_flow.async_discovered_service_info",
+ return_value=[BLUEMAESTRO_SERVICE_INFO],
+ ):
+ result = await hass.config_entries.flow.async_init(
+ DOMAIN,
+ context={"source": config_entries.SOURCE_USER},
+ )
+ assert result["type"] == FlowResultType.FORM
+ assert result["step_id"] == "user"
+
+ entry = MockConfigEntry(
+ domain=DOMAIN,
+ unique_id="aa:bb:cc:dd:ee:ff",
+ )
+ entry.add_to_hass(hass)
+
+ with patch(
+ "homeassistant.components.bluemaestro.async_setup_entry", return_value=True
+ ):
+ result2 = await hass.config_entries.flow.async_configure(
+ result["flow_id"],
+ user_input={"address": "aa:bb:cc:dd:ee:ff"},
+ )
+ assert result2["type"] == FlowResultType.ABORT
+ assert result2["reason"] == "already_configured"
+
+
+async def test_async_step_user_with_found_devices_already_setup(hass):
+ """Test setup from service info cache with devices found."""
+ entry = MockConfigEntry(
+ domain=DOMAIN,
+ unique_id="aa:bb:cc:dd:ee:ff",
+ )
+ entry.add_to_hass(hass)
+
+ with patch(
+ "homeassistant.components.bluemaestro.config_flow.async_discovered_service_info",
+ return_value=[BLUEMAESTRO_SERVICE_INFO],
+ ):
+ result = await hass.config_entries.flow.async_init(
+ DOMAIN,
+ context={"source": config_entries.SOURCE_USER},
+ )
+ assert result["type"] == FlowResultType.ABORT
+ assert result["reason"] == "no_devices_found"
+
+
+async def test_async_step_bluetooth_devices_already_setup(hass):
+ """Test we can't start a flow if there is already a config entry."""
+ entry = MockConfigEntry(
+ domain=DOMAIN,
+ unique_id="aa:bb:cc:dd:ee:ff",
+ )
+ entry.add_to_hass(hass)
+
+ result = await hass.config_entries.flow.async_init(
+ DOMAIN,
+ context={"source": config_entries.SOURCE_BLUETOOTH},
+ data=BLUEMAESTRO_SERVICE_INFO,
+ )
+ assert result["type"] == FlowResultType.ABORT
+ assert result["reason"] == "already_configured"
+
+
+async def test_async_step_bluetooth_already_in_progress(hass):
+ """Test we can't start a flow for the same device twice."""
+ result = await hass.config_entries.flow.async_init(
+ DOMAIN,
+ context={"source": config_entries.SOURCE_BLUETOOTH},
+ data=BLUEMAESTRO_SERVICE_INFO,
+ )
+ assert result["type"] == FlowResultType.FORM
+ assert result["step_id"] == "bluetooth_confirm"
+
+ result = await hass.config_entries.flow.async_init(
+ DOMAIN,
+ context={"source": config_entries.SOURCE_BLUETOOTH},
+ data=BLUEMAESTRO_SERVICE_INFO,
+ )
+ assert result["type"] == FlowResultType.ABORT
+ assert result["reason"] == "already_in_progress"
+
+
+async def test_async_step_user_takes_precedence_over_discovery(hass):
+ """Test manual setup takes precedence over discovery."""
+ result = await hass.config_entries.flow.async_init(
+ DOMAIN,
+ context={"source": config_entries.SOURCE_BLUETOOTH},
+ data=BLUEMAESTRO_SERVICE_INFO,
+ )
+ assert result["type"] == FlowResultType.FORM
+ assert result["step_id"] == "bluetooth_confirm"
+
+ with patch(
+ "homeassistant.components.bluemaestro.config_flow.async_discovered_service_info",
+ return_value=[BLUEMAESTRO_SERVICE_INFO],
+ ):
+ result = await hass.config_entries.flow.async_init(
+ DOMAIN,
+ context={"source": config_entries.SOURCE_USER},
+ )
+ assert result["type"] == FlowResultType.FORM
+
+ with patch(
+ "homeassistant.components.bluemaestro.async_setup_entry", return_value=True
+ ):
+ result2 = await hass.config_entries.flow.async_configure(
+ result["flow_id"],
+ user_input={"address": "aa:bb:cc:dd:ee:ff"},
+ )
+ assert result2["type"] == FlowResultType.CREATE_ENTRY
+ assert result2["title"] == "Tempo Disc THD EEFF"
+ assert result2["data"] == {}
+ assert result2["result"].unique_id == "aa:bb:cc:dd:ee:ff"
+
+ # Verify the original one was aborted
+ assert not hass.config_entries.flow.async_progress(DOMAIN)
diff --git a/tests/components/bluemaestro/test_sensor.py b/tests/components/bluemaestro/test_sensor.py
new file mode 100644
index 0000000000000000000000000000000000000000..2f964e65481f1acd1d2314995aa64f0d41b0350c
--- /dev/null
+++ b/tests/components/bluemaestro/test_sensor.py
@@ -0,0 +1,50 @@
+"""Test the BlueMaestro sensors."""
+
+from unittest.mock import patch
+
+from homeassistant.components.bluemaestro.const import DOMAIN
+from homeassistant.components.bluetooth import BluetoothChange
+from homeassistant.components.sensor import ATTR_STATE_CLASS
+from homeassistant.const import ATTR_FRIENDLY_NAME, ATTR_UNIT_OF_MEASUREMENT
+
+from . import BLUEMAESTRO_SERVICE_INFO
+
+from tests.common import MockConfigEntry
+
+
+async def test_sensors(hass):
+ """Test setting up creates the sensors."""
+ entry = MockConfigEntry(
+ domain=DOMAIN,
+ unique_id="aa:bb:cc:dd:ee:ff",
+ )
+ entry.add_to_hass(hass)
+
+ saved_callback = None
+
+ def _async_register_callback(_hass, _callback, _matcher, _mode):
+ nonlocal saved_callback
+ saved_callback = _callback
+ return lambda: None
+
+ with patch(
+ "homeassistant.components.bluetooth.update_coordinator.async_register_callback",
+ _async_register_callback,
+ ):
+ assert await hass.config_entries.async_setup(entry.entry_id)
+ await hass.async_block_till_done()
+
+ assert len(hass.states.async_all("sensor")) == 0
+ saved_callback(BLUEMAESTRO_SERVICE_INFO, BluetoothChange.ADVERTISEMENT)
+ await hass.async_block_till_done()
+ assert len(hass.states.async_all("sensor")) == 4
+
+ humid_sensor = hass.states.get("sensor.tempo_disc_thd_eeff_temperature")
+ humid_sensor_attrs = humid_sensor.attributes
+ assert humid_sensor.state == "24.2"
+ assert humid_sensor_attrs[ATTR_FRIENDLY_NAME] == "Tempo Disc THD EEFF Temperature"
+ assert humid_sensor_attrs[ATTR_UNIT_OF_MEASUREMENT] == "°C"
+ assert humid_sensor_attrs[ATTR_STATE_CLASS] == "measurement"
+
+ assert await hass.config_entries.async_unload(entry.entry_id)
+ await hass.async_block_till_done()