Bugfix HomeKit name and serial_number

homeassistant/components/homekit/__init__.py

@@ -21,9 +21,10 @@
 from homeassistant.util import get_local_ip
 from homeassistant.util.decorator import Registry
 from .const import (
-    CONF_AUTO_START, CONF_ENTITY_CONFIG, CONF_FEATURE_LIST, CONF_FILTER,
-    DEFAULT_AUTO_START, DEFAULT_PORT, DEVICE_CLASS_CO2, DEVICE_CLASS_PM25,
-    DOMAIN, HOMEKIT_FILE, SERVICE_HOMEKIT_START, TYPE_OUTLET, TYPE_SWITCH)
+    BRIDGE_NAME, CONF_AUTO_START, CONF_ENTITY_CONFIG, CONF_FEATURE_LIST,
+    CONF_FILTER, DEFAULT_AUTO_START, DEFAULT_PORT, DEVICE_CLASS_CO2,
+    DEVICE_CLASS_PM25, DOMAIN, HOMEKIT_FILE, SERVICE_HOMEKIT_START,
+    TYPE_OUTLET, TYPE_SWITCH)
 from .util import (
     show_setup_message, validate_entity_config, validate_media_player_features)
 
@@ -43,6 +44,8 @@
 
 CONFIG_SCHEMA = vol.Schema({
     DOMAIN: vol.All({
+        vol.Optional(CONF_NAME, default=BRIDGE_NAME):
+            vol.All(cv.string, vol.Length(min=3, max=25)),
         vol.Optional(CONF_PORT, default=DEFAULT_PORT): cv.port,
         vol.Optional(CONF_IP_ADDRESS):
             vol.All(ipaddress.ip_address, cv.string),
@@ -58,13 +61,15 @@ async def async_setup(hass, config):
     _LOGGER.debug('Begin setup HomeKit')
 
     conf = config[DOMAIN]
+    name = conf[CONF_NAME]
     port = conf[CONF_PORT]
     ip_address = conf.get(CONF_IP_ADDRESS)
     auto_start = conf[CONF_AUTO_START]
     entity_filter = conf[CONF_FILTER]
     entity_config = conf[CONF_ENTITY_CONFIG]
 
-    homekit = HomeKit(hass, port, ip_address, entity_filter, entity_config)
+    homekit = HomeKit(hass, name, port, ip_address, entity_filter,
+                      entity_config)
     await hass.async_add_job(homekit.setup)
 
     if auto_start:
@@ -176,9 +181,11 @@ def generate_aid(entity_id):
 class HomeKit():
     """Class to handle all actions between HomeKit and Home Assistant."""
 
-    def __init__(self, hass, port, ip_address, entity_filter, entity_config):
+    def __init__(self, hass, name, port, ip_address, entity_filter,
+                 entity_config):
         """Initialize a HomeKit object."""
         self.hass = hass
+        self._name = name
         self._port = port
         self._ip_address = ip_address
         self._filter = entity_filter
@@ -199,7 +206,7 @@ def setup(self):
         path = self.hass.config.path(HOMEKIT_FILE)
         self.driver = HomeDriver(self.hass, address=ip_addr,
                                  port=self._port, persist_file=path)
-        self.bridge = HomeBridge(self.hass, self.driver)
+        self.bridge = HomeBridge(self.hass, self.driver, self._name)
 
     def add_bridge_accessory(self, state):
         """Try adding accessory to bridge if configured beforehand."""

homeassistant/components/homekit/accessories.py

@@ -17,11 +17,12 @@
 from homeassistant.util import dt as dt_util
 
 from .const import (
-    BRIDGE_MODEL, BRIDGE_NAME, BRIDGE_SERIAL_NUMBER, CHAR_BATTERY_LEVEL,
-    CHAR_CHARGING_STATE, CHAR_STATUS_LOW_BATTERY, DEBOUNCE_TIMEOUT,
-    MANUFACTURER, SERV_BATTERY_SERVICE)
+    BRIDGE_MODEL, CHAR_BATTERY_LEVEL, CHAR_CHARGING_STATE,
+    CHAR_STATUS_LOW_BATTERY, DEBOUNCE_TIMEOUT, MANUFACTURER,
+    SERV_BATTERY_SERVICE)
 from .util import (
-    convert_to_float, show_setup_message, dismiss_setup_message)
+    convert_to_float, generate_serial_number, show_setup_message,
+    dismiss_setup_message)
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -141,12 +142,12 @@ def update_state(self, new_state):
 class HomeBridge(Bridge):
     """Adapter class for Bridge."""
 
-    def __init__(self, hass, driver, name=BRIDGE_NAME):
+    def __init__(self, hass, driver, name):
         """Initialize a Bridge object."""
         super().__init__(driver, name)
         self.set_info_service(
             firmware_revision=__version__, manufacturer=MANUFACTURER,
-            model=BRIDGE_MODEL, serial_number=BRIDGE_SERIAL_NUMBER)
+            model=BRIDGE_MODEL, serial_number=generate_serial_number(name))
         self.hass = hass
 
     def setup_message(self):

homeassistant/components/homekit/const.py

@@ -28,7 +28,6 @@
 # #### String Constants ####
 BRIDGE_MODEL = 'Bridge'
 BRIDGE_NAME = 'Home Assistant Bridge'
-BRIDGE_SERIAL_NUMBER = 'homekit.bridge'
 MANUFACTURER = 'Home Assistant'
 
 # #### Switch Types ####

homeassistant/components/homekit/util.py

@@ -120,6 +120,11 @@ def dismiss_setup_message(hass):
     hass.components.persistent_notification.dismiss(HOMEKIT_NOTIFY_ID)
 
 
+def generate_serial_number(name):
+    """Return serial number for bridge name."""
+    return 'homekit.' + name.lower().replace(' ', '.')
+
+
 def convert_to_float(state):
     """Return float of state, catch errors."""
     try:

tests/components/homekit/test_accessories.py

@@ -10,9 +10,10 @@
 from homeassistant.components.homekit.accessories import (
     debounce, HomeAccessory, HomeBridge, HomeDriver)
 from homeassistant.components.homekit.const import (
-    BRIDGE_MODEL, BRIDGE_NAME, BRIDGE_SERIAL_NUMBER, CHAR_FIRMWARE_REVISION,
-    CHAR_MANUFACTURER, CHAR_MODEL, CHAR_NAME, CHAR_SERIAL_NUMBER,
-    MANUFACTURER, SERV_ACCESSORY_INFO)
+    BRIDGE_MODEL, BRIDGE_NAME, CHAR_FIRMWARE_REVISION, CHAR_MANUFACTURER,
+    CHAR_MODEL, CHAR_NAME, CHAR_SERIAL_NUMBER, MANUFACTURER,
+    SERV_ACCESSORY_INFO)
+from homeassistant.components.homekit.util import generate_serial_number
 from homeassistant.const import (
     __version__, ATTR_BATTERY_CHARGING, ATTR_BATTERY_LEVEL, ATTR_NOW,
     EVENT_TIME_CHANGED)
@@ -146,7 +147,7 @@ async def test_battery_service(hass, hk_driver):
 
 def test_home_bridge(hk_driver):
     """Test HomeBridge class."""
-    bridge = HomeBridge('hass', hk_driver)
+    bridge = HomeBridge('hass', hk_driver, BRIDGE_NAME)
     assert bridge.hass == 'hass'
     assert bridge.display_name == BRIDGE_NAME
     assert bridge.category == 2  # Category.BRIDGE
@@ -158,7 +159,7 @@ def test_home_bridge(hk_driver):
     assert serv.get_characteristic(CHAR_MANUFACTURER).value == MANUFACTURER
     assert serv.get_characteristic(CHAR_MODEL).value == BRIDGE_MODEL
     assert serv.get_characteristic(CHAR_SERIAL_NUMBER).value == \
-        BRIDGE_SERIAL_NUMBER
+        generate_serial_number(BRIDGE_NAME)
 
     bridge = HomeBridge('hass', hk_driver, 'test_name')
     assert bridge.display_name == 'test_name'

tests/components/homekit/test_homekit.py

@@ -9,9 +9,10 @@
     STATUS_STOPPED, STATUS_WAIT)
 from homeassistant.components.homekit.accessories import HomeBridge
 from homeassistant.components.homekit.const import (
-    CONF_AUTO_START, DEFAULT_PORT, DOMAIN, HOMEKIT_FILE, SERVICE_HOMEKIT_START)
+    CONF_AUTO_START, BRIDGE_NAME, DEFAULT_PORT, DOMAIN, HOMEKIT_FILE,
+    SERVICE_HOMEKIT_START)
 from homeassistant.const import (
-    CONF_IP_ADDRESS, CONF_PORT,
+    CONF_NAME, CONF_IP_ADDRESS, CONF_PORT,
     EVENT_HOMEASSISTANT_START, EVENT_HOMEASSISTANT_STOP)
 from homeassistant.core import State
 from homeassistant.helpers.entityfilter import generate_filter
@@ -47,7 +48,8 @@ async def test_setup_min(hass):
         assert await setup.async_setup_component(
             hass, DOMAIN, {DOMAIN: {}})
 
-    mock_homekit.assert_any_call(hass, DEFAULT_PORT, None, ANY, {})
+    mock_homekit.assert_any_call(hass, BRIDGE_NAME, DEFAULT_PORT, None, ANY,
+                                 {})
     assert mock_homekit().setup.called is True
 
     # Test auto start enabled
@@ -60,15 +62,16 @@ async def test_setup_min(hass):
 
 async def test_setup_auto_start_disabled(hass):
     """Test async_setup with auto start disabled and test service calls."""
-    config = {DOMAIN: {CONF_AUTO_START: False, CONF_PORT: 11111,
-                       CONF_IP_ADDRESS: '172.0.0.0'}}
+    config = {DOMAIN: {CONF_AUTO_START: False, CONF_NAME: 'Test Name',
+                       CONF_PORT: 11111, CONF_IP_ADDRESS: '172.0.0.0'}}
 
     with patch(PATH_HOMEKIT + '.HomeKit') as mock_homekit:
         mock_homekit.return_value = homekit = Mock()
         assert await setup.async_setup_component(
             hass, DOMAIN, config)
 
-    mock_homekit.assert_any_call(hass, 11111, '172.0.0.0', ANY, {})
+    mock_homekit.assert_any_call(hass, 'Test Name', 11111, '172.0.0.0', ANY,
+                                 {})
     assert mock_homekit().setup.called is True
 
     # Test auto_start disabled
@@ -96,7 +99,7 @@ async def test_setup_auto_start_disabled(hass):
 
 async def test_homekit_setup(hass, hk_driver):
     """Test setup of bridge and driver."""
-    homekit = HomeKit(hass, DEFAULT_PORT, None, {}, {})
+    homekit = HomeKit(hass, BRIDGE_NAME, DEFAULT_PORT, None, {}, {})
 
     with patch(PATH_HOMEKIT + '.accessories.HomeDriver',
                return_value=hk_driver) as mock_driver, \
@@ -115,7 +118,7 @@ async def test_homekit_setup(hass, hk_driver):
 
 async def test_homekit_setup_ip_address(hass, hk_driver):
     """Test setup with given IP address."""
-    homekit = HomeKit(hass, DEFAULT_PORT, '172.0.0.0', {}, {})
+    homekit = HomeKit(hass, BRIDGE_NAME, DEFAULT_PORT, '172.0.0.0', {}, {})
 
     with patch(PATH_HOMEKIT + '.accessories.HomeDriver',
                return_value=hk_driver) as mock_driver:
@@ -126,7 +129,7 @@ async def test_homekit_setup_ip_address(hass, hk_driver):
 
 async def test_homekit_add_accessory():
     """Add accessory if config exists and get_acc returns an accessory."""
-    homekit = HomeKit('hass', None, None, lambda entity_id: True, {})
+    homekit = HomeKit('hass', None, None, None, lambda entity_id: True, {})
     homekit.driver = 'driver'
     homekit.bridge = mock_bridge = Mock()
 
@@ -149,7 +152,7 @@ async def test_homekit_add_accessory():
 async def test_homekit_entity_filter(hass):
     """Test the entity filter."""
     entity_filter = generate_filter(['cover'], ['demo.test'], [], [])
-    homekit = HomeKit(hass, None, None, entity_filter, {})
+    homekit = HomeKit(hass, None, None, None, entity_filter, {})
 
     with patch(PATH_HOMEKIT + '.get_accessory') as mock_get_acc:
         mock_get_acc.return_value = None
@@ -169,7 +172,7 @@ async def test_homekit_entity_filter(hass):
 async def test_homekit_start(hass, hk_driver, debounce_patcher):
     """Test HomeKit start method."""
     pin = b'123-45-678'
-    homekit = HomeKit(hass, None, None, {}, {'cover.demo': {}})
+    homekit = HomeKit(hass, None, None, None, {}, {'cover.demo': {}})
     homekit.bridge = 'bridge'
     homekit.driver = hk_driver
 
@@ -199,7 +202,7 @@ async def test_homekit_start(hass, hk_driver, debounce_patcher):
 
 async def test_homekit_stop(hass):
     """Test HomeKit stop method."""
-    homekit = HomeKit(hass, None, None, None, None)
+    homekit = HomeKit(hass, None, None, None, None, None)
     homekit.driver = Mock()
 
     assert homekit.status == STATUS_READY

tests/components/homekit/test_util.py

@@ -7,8 +7,8 @@
     FEATURE_PLAY_PAUSE, TYPE_OUTLET)
 from homeassistant.components.homekit.util import (
     convert_to_float, density_to_air_quality, dismiss_setup_message,
-    show_setup_message, temperature_to_homekit, temperature_to_states,
-    validate_media_player_features)
+    generate_serial_number, show_setup_message, temperature_to_homekit,
+    temperature_to_states, validate_media_player_features)
 from homeassistant.components.homekit.util import validate_entity_config \
     as vec
 from homeassistant.components.persistent_notification import (
@@ -75,6 +75,14 @@ def test_validate_media_player_features():
     assert validate_media_player_features(entity_state, config) is False
 
 
+def test_generate_serial_number():
+    """Test generate_serial_number method."""
+    assert generate_serial_number('Home Assistant') == \
+        'homekit.home.assistant'
+    assert generate_serial_number('My Name-HomeKit') == \
+        'homekit.my.name-homekit'
+
+
 def test_convert_to_float():
     """Test convert_to_float method."""
     assert convert_to_float(12) == 12