diff --git a/homeassistant/components/binary_sensor/homematicip_cloud.py b/homeassistant/components/binary_sensor/homematicip_cloud.py
index 40ffe4984020c9d4e15db74be9e908af01a3543c..72a7db1ac7a8ec7053438db4ae39401115d9c5f0 100644
--- a/homeassistant/components/binary_sensor/homematicip_cloud.py
+++ b/homeassistant/components/binary_sensor/homematicip_cloud.py
@@ -9,8 +9,8 @@ import logging
from homeassistant.components.binary_sensor import BinarySensorDevice
from homeassistant.components.homematicip_cloud import (
- HomematicipGenericDevice, DOMAIN as HOMEMATICIP_CLOUD_DOMAIN,
- ATTR_HOME_ID)
+ HomematicipGenericDevice, DOMAIN as HMIPC_DOMAIN,
+ HMIPC_HAPID)
DEPENDENCIES = ['homematicip_cloud']
@@ -26,12 +26,15 @@ HMIP_OPEN = 'open'
async def async_setup_platform(hass, config, async_add_devices,
discovery_info=None):
- """Set up the HomematicIP binary sensor devices."""
+ """Set up the binary sensor devices."""
+ pass
+
+
+async def async_setup_entry(hass, config_entry, async_add_devices):
+ """Set up the HomematicIP binary sensor from a config entry."""
from homematicip.device import (ShutterContact, MotionDetectorIndoor)
- if discovery_info is None:
- return
- home = hass.data[HOMEMATICIP_CLOUD_DOMAIN][discovery_info[ATTR_HOME_ID]]
+ home = hass.data[HMIPC_DOMAIN][config_entry.data[HMIPC_HAPID]].home
devices = []
for device in home.devices:
if isinstance(device, ShutterContact):
diff --git a/homeassistant/components/climate/homematicip_cloud.py b/homeassistant/components/climate/homematicip_cloud.py
index bf96f1f746d8c27a60a62fec405d328d6de933d7..8cf47159c103fd59b93098daa629a9b759a75f7d 100644
--- a/homeassistant/components/climate/homematicip_cloud.py
+++ b/homeassistant/components/climate/homematicip_cloud.py
@@ -12,8 +12,8 @@ from homeassistant.components.climate import (
STATE_AUTO, STATE_MANUAL)
from homeassistant.const import TEMP_CELSIUS
from homeassistant.components.homematicip_cloud import (
- HomematicipGenericDevice, DOMAIN as HOMEMATICIP_CLOUD_DOMAIN,
- ATTR_HOME_ID)
+ HomematicipGenericDevice, DOMAIN as HMIPC_DOMAIN,
+ HMIPC_HAPID)
_LOGGER = logging.getLogger(__name__)
@@ -30,12 +30,14 @@ HMIP_STATE_TO_HA = {value: key for key, value in HA_STATE_TO_HMIP.items()}
async def async_setup_platform(hass, config, async_add_devices,
discovery_info=None):
"""Set up the HomematicIP climate devices."""
- from homematicip.group import HeatingGroup
+ pass
+
- if discovery_info is None:
- return
- home = hass.data[HOMEMATICIP_CLOUD_DOMAIN][discovery_info[ATTR_HOME_ID]]
+async def async_setup_entry(hass, config_entry, async_add_devices):
+ """Set up the HomematicIP climate from a config entry."""
+ from homematicip.group import HeatingGroup
+ home = hass.data[HMIPC_DOMAIN][config_entry.data[HMIPC_HAPID]].home
devices = []
for device in home.groups:
if isinstance(device, HeatingGroup):
diff --git a/homeassistant/components/homematicip_cloud.py b/homeassistant/components/homematicip_cloud.py
deleted file mode 100644
index 859841dfca64bc68148ef4079db1e0b6a72e49ab..0000000000000000000000000000000000000000
--- a/homeassistant/components/homematicip_cloud.py
+++ /dev/null
@@ -1,262 +0,0 @@
-"""
-Support for HomematicIP components.
-
-For more details about this component, please refer to the documentation at
-https://home-assistant.io/components/homematicip_cloud/
-"""
-
-import asyncio
-import logging
-
-import voluptuous as vol
-
-import homeassistant.helpers.config_validation as cv
-from homeassistant.const import EVENT_HOMEASSISTANT_STOP
-from homeassistant.helpers.aiohttp_client import async_get_clientsession
-from homeassistant.helpers.discovery import async_load_platform
-from homeassistant.helpers.entity import Entity
-from homeassistant.core import callback
-
-REQUIREMENTS = ['homematicip==0.9.4']
-
-_LOGGER = logging.getLogger(__name__)
-
-DOMAIN = 'homematicip_cloud'
-
-COMPONENTS = [
- 'sensor',
- 'binary_sensor',
- 'switch',
- 'light',
- 'climate',
-]
-
-CONF_NAME = 'name'
-CONF_ACCESSPOINT = 'accesspoint'
-CONF_AUTHTOKEN = 'authtoken'
-
-CONFIG_SCHEMA = vol.Schema({
- vol.Optional(DOMAIN, default=[]): vol.All(cv.ensure_list, [vol.Schema({
- vol.Optional(CONF_NAME): vol.Any(cv.string),
- vol.Required(CONF_ACCESSPOINT): cv.string,
- vol.Required(CONF_AUTHTOKEN): cv.string,
- })]),
-}, extra=vol.ALLOW_EXTRA)
-
-HMIP_ACCESS_POINT = 'Access Point'
-HMIP_HUB = 'HmIP-HUB'
-
-ATTR_HOME_ID = 'home_id'
-ATTR_HOME_NAME = 'home_name'
-ATTR_DEVICE_ID = 'device_id'
-ATTR_DEVICE_LABEL = 'device_label'
-ATTR_STATUS_UPDATE = 'status_update'
-ATTR_FIRMWARE_STATE = 'firmware_state'
-ATTR_UNREACHABLE = 'unreachable'
-ATTR_LOW_BATTERY = 'low_battery'
-ATTR_MODEL_TYPE = 'model_type'
-ATTR_GROUP_TYPE = 'group_type'
-ATTR_DEVICE_RSSI = 'device_rssi'
-ATTR_DUTY_CYCLE = 'duty_cycle'
-ATTR_CONNECTED = 'connected'
-ATTR_SABOTAGE = 'sabotage'
-ATTR_OPERATION_LOCK = 'operation_lock'
-
-
-async def async_setup(hass, config):
- """Set up the HomematicIP component."""
- from homematicip.base.base_connection import HmipConnectionError
-
- hass.data.setdefault(DOMAIN, {})
- accesspoints = config.get(DOMAIN, [])
- for conf in accesspoints:
- _websession = async_get_clientsession(hass)
- _hmip = HomematicipConnector(hass, conf, _websession)
- try:
- await _hmip.init()
- except HmipConnectionError:
- _LOGGER.error('Failed to connect to the HomematicIP server, %s.',
- conf.get(CONF_ACCESSPOINT))
- return False
-
- home = _hmip.home
- home.name = conf.get(CONF_NAME)
- home.label = HMIP_ACCESS_POINT
- home.modelType = HMIP_HUB
-
- hass.data[DOMAIN][home.id] = home
- _LOGGER.info('Connected to the HomematicIP server, %s.',
- conf.get(CONF_ACCESSPOINT))
- homeid = {ATTR_HOME_ID: home.id}
- for component in COMPONENTS:
- hass.async_add_job(async_load_platform(hass, component, DOMAIN,
- homeid, config))
-
- hass.loop.create_task(_hmip.connect())
- return True
-
-
-class HomematicipConnector:
- """Manages HomematicIP http and websocket connection."""
-
- def __init__(self, hass, config, websession):
- """Initialize HomematicIP cloud connection."""
- from homematicip.async.home import AsyncHome
-
- self._hass = hass
- self._ws_close_requested = False
- self._retry_task = None
- self._tries = 0
- self._accesspoint = config.get(CONF_ACCESSPOINT)
- _authtoken = config.get(CONF_AUTHTOKEN)
-
- self.home = AsyncHome(hass.loop, websession)
- self.home.set_auth_token(_authtoken)
-
- self.home.on_update(self.async_update)
- self._accesspoint_connected = True
-
- hass.bus.async_listen_once(EVENT_HOMEASSISTANT_STOP, self.close())
-
- async def init(self):
- """Initialize connection."""
- await self.home.init(self._accesspoint)
- await self.home.get_current_state()
-
- @callback
- def async_update(self, *args, **kwargs):
- """Async update the home device.
-
- Triggered when the hmip HOME_CHANGED event has fired.
- There are several occasions for this event to happen.
- We are only interested to check whether the access point
- is still connected. If not, device state changes cannot
- be forwarded to hass. So if access point is disconnected all devices
- are set to unavailable.
- """
- if not self.home.connected:
- _LOGGER.error(
- "HMIP access point has lost connection with the cloud")
- self._accesspoint_connected = False
- self.set_all_to_unavailable()
- elif not self._accesspoint_connected:
- # Explicitly getting an update as device states might have
- # changed during access point disconnect."""
-
- job = self._hass.async_add_job(self.get_state())
- job.add_done_callback(self.get_state_finished)
-
- async def get_state(self):
- """Update hmip state and tell hass."""
- await self.home.get_current_state()
- self.update_all()
-
- def get_state_finished(self, future):
- """Execute when get_state coroutine has finished."""
- from homematicip.base.base_connection import HmipConnectionError
-
- try:
- future.result()
- except HmipConnectionError:
- # Somehow connection could not recover. Will disconnect and
- # so reconnect loop is taking over.
- _LOGGER.error(
- "updating state after himp access point reconnect failed.")
- self._hass.async_add_job(self.home.disable_events())
-
- def set_all_to_unavailable(self):
- """Set all devices to unavailable and tell Hass."""
- for device in self.home.devices:
- device.unreach = True
- self.update_all()
-
- def update_all(self):
- """Signal all devices to update their state."""
- for device in self.home.devices:
- device.fire_update_event()
-
- async def _handle_connection(self):
- """Handle websocket connection."""
- from homematicip.base.base_connection import HmipConnectionError
-
- await self.home.get_current_state()
- hmip_events = await self.home.enable_events()
- try:
- await hmip_events
- except HmipConnectionError:
- return
-
- async def connect(self):
- """Start websocket connection."""
- self._tries = 0
- while True:
- await self._handle_connection()
- if self._ws_close_requested:
- break
- self._ws_close_requested = False
- self._tries += 1
- try:
- self._retry_task = self._hass.async_add_job(asyncio.sleep(
- 2 ** min(9, self._tries), loop=self._hass.loop))
- await self._retry_task
- except asyncio.CancelledError:
- break
- _LOGGER.info('Reconnect (%s) to the HomematicIP cloud server.',
- self._tries)
-
- async def close(self):
- """Close the websocket connection."""
- self._ws_close_requested = True
- if self._retry_task is not None:
- self._retry_task.cancel()
- await self.home.disable_events()
- _LOGGER.info("Closed connection to HomematicIP cloud server.")
-
-
-class HomematicipGenericDevice(Entity):
- """Representation of an HomematicIP generic device."""
-
- def __init__(self, home, device, post=None):
- """Initialize the generic device."""
- self._home = home
- self._device = device
- self.post = post
- _LOGGER.info('Setting up %s (%s)', self.name,
- self._device.modelType)
-
- async def async_added_to_hass(self):
- """Register callbacks."""
- self._device.on_update(self._device_changed)
-
- def _device_changed(self, json, **kwargs):
- """Handle device state changes."""
- _LOGGER.debug('Event %s (%s)', self.name, self._device.modelType)
- self.async_schedule_update_ha_state()
-
- @property
- def name(self):
- """Return the name of the generic device."""
- name = self._device.label
- if self._home.name is not None:
- name = "{} {}".format(self._home.name, name)
- if self.post is not None:
- name = "{} {}".format(name, self.post)
- return name
-
- @property
- def should_poll(self):
- """No polling needed."""
- return False
-
- @property
- def available(self):
- """Device available."""
- return not self._device.unreach
-
- @property
- def device_state_attributes(self):
- """Return the state attributes of the generic device."""
- return {
- ATTR_LOW_BATTERY: self._device.lowBat,
- ATTR_MODEL_TYPE: self._device.modelType
- }
diff --git a/homeassistant/components/homematicip_cloud/.translations/en.json b/homeassistant/components/homematicip_cloud/.translations/en.json
new file mode 100644
index 0000000000000000000000000000000000000000..887a3a5780b0ebc2841936be7d3f14180a9f8017
--- /dev/null
+++ b/homeassistant/components/homematicip_cloud/.translations/en.json
@@ -0,0 +1,30 @@
+{
+ "config": {
+ "title": "HomematicIP Cloud",
+ "step": {
+ "init": {
+ "title": "Pick HomematicIP Accesspoint",
+ "data": {
+ "hapid": "Accesspoint ID (SGTIN)",
+ "pin": "Pin Code (optional)",
+ "name": "Name (optional, used as name prefix for all devices)"
+ }
+ },
+ "link": {
+ "title": "Link Accesspoint",
+ "description": "Press the blue button on the accesspoint and the submit button to register HomematicIP with Home Assistant.\n\n"
+ }
+ },
+ "error": {
+ "register_failed": "Failed to register, please try again.",
+ "invalid_pin": "Invalid PIN, please try again.",
+ "press_the_button": "Please press the blue button.",
+ "timeout_button": "Blue button press timeout, please try again."
+ },
+ "abort": {
+ "unknown": "Unknown error occurred.",
+ "conection_aborted": "Could not connect to HMIP server",
+ "already_configured": "Accesspoint is already configured"
+ }
+ }
+}
diff --git a/homeassistant/components/homematicip_cloud/__init__.py b/homeassistant/components/homematicip_cloud/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..3ff4e438f53c7fc84a73fb9f8fab3376d3cc8300
--- /dev/null
+++ b/homeassistant/components/homematicip_cloud/__init__.py
@@ -0,0 +1,65 @@
+"""
+Support for HomematicIP components.
+
+For more details about this component, please refer to the documentation at
+https://home-assistant.io/components/homematicip_cloud/
+"""
+
+import logging
+
+import voluptuous as vol
+
+import homeassistant.helpers.config_validation as cv
+
+from .const import (
+ DOMAIN, HMIPC_HAPID, HMIPC_AUTHTOKEN, HMIPC_NAME,
+ CONF_ACCESSPOINT, CONF_AUTHTOKEN, CONF_NAME)
+# Loading the config flow file will register the flow
+from .config_flow import configured_haps
+from .hap import HomematicipHAP, HomematicipAuth # noqa: F401
+from .device import HomematicipGenericDevice # noqa: F401
+
+REQUIREMENTS = ['homematicip==0.9.6']
+
+_LOGGER = logging.getLogger(__name__)
+
+CONFIG_SCHEMA = vol.Schema({
+ vol.Optional(DOMAIN, default=[]): vol.All(cv.ensure_list, [vol.Schema({
+ vol.Optional(CONF_NAME, default=''): vol.Any(cv.string),
+ vol.Required(CONF_ACCESSPOINT): cv.string,
+ vol.Required(CONF_AUTHTOKEN): cv.string,
+ })]),
+}, extra=vol.ALLOW_EXTRA)
+
+
+async def async_setup(hass, config):
+ """Set up the HomematicIP component."""
+ hass.data[DOMAIN] = {}
+
+ accesspoints = config.get(DOMAIN, [])
+
+ for conf in accesspoints:
+ if conf[CONF_ACCESSPOINT] not in configured_haps(hass):
+ hass.async_add_job(hass.config_entries.flow.async_init(
+ DOMAIN, source='import', data={
+ HMIPC_HAPID: conf[CONF_ACCESSPOINT],
+ HMIPC_AUTHTOKEN: conf[CONF_AUTHTOKEN],
+ HMIPC_NAME: conf[CONF_NAME],
+ }
+ ))
+
+ return True
+
+
+async def async_setup_entry(hass, entry):
+ """Set up an accsspoint from a config entry."""
+ hap = HomematicipHAP(hass, entry)
+ hapid = entry.data[HMIPC_HAPID].replace('-', '').upper()
+ hass.data[DOMAIN][hapid] = hap
+ return await hap.async_setup()
+
+
+async def async_unload_entry(hass, entry):
+ """Unload a config entry."""
+ hap = hass.data[DOMAIN].pop(entry.data[HMIPC_HAPID])
+ return await hap.async_reset()
diff --git a/homeassistant/components/homematicip_cloud/config_flow.py b/homeassistant/components/homematicip_cloud/config_flow.py
new file mode 100644
index 0000000000000000000000000000000000000000..9e5356d914a5a6ed701337deb084d2c9181d17c2
--- /dev/null
+++ b/homeassistant/components/homematicip_cloud/config_flow.py
@@ -0,0 +1,97 @@
+"""Config flow to configure HomematicIP Cloud."""
+import voluptuous as vol
+
+from homeassistant import config_entries, data_entry_flow
+from homeassistant.core import callback
+
+from .const import (
+ DOMAIN as HMIPC_DOMAIN, _LOGGER,
+ HMIPC_HAPID, HMIPC_AUTHTOKEN, HMIPC_PIN, HMIPC_NAME)
+from .hap import HomematicipAuth
+
+
+@callback
+def configured_haps(hass):
+ """Return a set of the configured accesspoints."""
+ return set(entry.data[HMIPC_HAPID] for entry
+ in hass.config_entries.async_entries(HMIPC_DOMAIN))
+
+
+@config_entries.HANDLERS.register(HMIPC_DOMAIN)
+class HomematicipCloudFlowHandler(data_entry_flow.FlowHandler):
+ """Config flow HomematicIP Cloud."""
+
+ VERSION = 1
+
+ def __init__(self):
+ """Initialize HomematicIP Cloud config flow."""
+ self.auth = None
+
+ async def async_step_init(self, user_input=None):
+ """Handle a flow start."""
+ errors = {}
+
+ if user_input is not None:
+ user_input[HMIPC_HAPID] = \
+ user_input[HMIPC_HAPID].replace('-', '').upper()
+ if user_input[HMIPC_HAPID] in configured_haps(self.hass):
+ return self.async_abort(reason='already_configured')
+
+ self.auth = HomematicipAuth(self.hass, user_input)
+ connected = await self.auth.async_setup()
+ if connected:
+ _LOGGER.info("Connection established")
+ return await self.async_step_link()
+
+ return self.async_show_form(
+ step_id='init',
+ data_schema=vol.Schema({
+ vol.Required(HMIPC_HAPID): str,
+ vol.Optional(HMIPC_PIN): str,
+ vol.Optional(HMIPC_NAME): str,
+ }),
+ errors=errors
+ )
+
+ async def async_step_link(self, user_input=None):
+ """Attempt to link with the HomematicIP Cloud accesspoint."""
+ errors = {}
+
+ pressed = await self.auth.async_checkbutton()
+ if pressed:
+ authtoken = await self.auth.async_register()
+ if authtoken:
+ _LOGGER.info("Write config entry")
+ return self.async_create_entry(
+ title=self.auth.config.get(HMIPC_HAPID),
+ data={
+ HMIPC_HAPID: self.auth.config.get(HMIPC_HAPID),
+ HMIPC_AUTHTOKEN: authtoken,
+ HMIPC_NAME: self.auth.config.get(HMIPC_NAME)
+ })
+ return self.async_abort(reason='conection_aborted')
+ else:
+ errors['base'] = 'press_the_button'
+
+ return self.async_show_form(step_id='link', errors=errors)
+
+ async def async_step_import(self, import_info):
+ """Import a new bridge as a config entry."""
+ hapid = import_info[HMIPC_HAPID]
+ authtoken = import_info[HMIPC_AUTHTOKEN]
+ name = import_info[HMIPC_NAME]
+
+ hapid = hapid.replace('-', '').upper()
+ if hapid in configured_haps(self.hass):
+ return self.async_abort(reason='already_configured')
+
+ _LOGGER.info('Imported authentication for %s', hapid)
+
+ return self.async_create_entry(
+ title=hapid,
+ data={
+ HMIPC_HAPID: hapid,
+ HMIPC_AUTHTOKEN: authtoken,
+ HMIPC_NAME: name
+ }
+ )
diff --git a/homeassistant/components/homematicip_cloud/const.py b/homeassistant/components/homematicip_cloud/const.py
new file mode 100644
index 0000000000000000000000000000000000000000..c40e577ae4a570b7c8308f53bcc10435e3ff03e9
--- /dev/null
+++ b/homeassistant/components/homematicip_cloud/const.py
@@ -0,0 +1,23 @@
+"""Constants for the HomematicIP Cloud component."""
+import logging
+
+_LOGGER = logging.getLogger('homeassistant.components.homematicip_cloud')
+
+DOMAIN = 'homematicip_cloud'
+
+COMPONENTS = [
+ 'binary_sensor',
+ 'climate',
+ 'light',
+ 'sensor',
+ 'switch',
+]
+
+CONF_NAME = 'name'
+CONF_ACCESSPOINT = 'accesspoint'
+CONF_AUTHTOKEN = 'authtoken'
+
+HMIPC_NAME = 'name'
+HMIPC_HAPID = 'hapid'
+HMIPC_AUTHTOKEN = 'authtoken'
+HMIPC_PIN = 'pin'
diff --git a/homeassistant/components/homematicip_cloud/device.py b/homeassistant/components/homematicip_cloud/device.py
new file mode 100644
index 0000000000000000000000000000000000000000..94fe5f40be8db57bd5095f1e055f05942f5d017d
--- /dev/null
+++ b/homeassistant/components/homematicip_cloud/device.py
@@ -0,0 +1,71 @@
+"""GenericDevice for the HomematicIP Cloud component."""
+import logging
+
+from homeassistant.helpers.entity import Entity
+
+_LOGGER = logging.getLogger(__name__)
+
+ATTR_HOME_ID = 'home_id'
+ATTR_HOME_NAME = 'home_name'
+ATTR_DEVICE_ID = 'device_id'
+ATTR_DEVICE_LABEL = 'device_label'
+ATTR_STATUS_UPDATE = 'status_update'
+ATTR_FIRMWARE_STATE = 'firmware_state'
+ATTR_UNREACHABLE = 'unreachable'
+ATTR_LOW_BATTERY = 'low_battery'
+ATTR_MODEL_TYPE = 'model_type'
+ATTR_GROUP_TYPE = 'group_type'
+ATTR_DEVICE_RSSI = 'device_rssi'
+ATTR_DUTY_CYCLE = 'duty_cycle'
+ATTR_CONNECTED = 'connected'
+ATTR_SABOTAGE = 'sabotage'
+ATTR_OPERATION_LOCK = 'operation_lock'
+
+
+class HomematicipGenericDevice(Entity):
+ """Representation of an HomematicIP generic device."""
+
+ def __init__(self, home, device, post=None):
+ """Initialize the generic device."""
+ self._home = home
+ self._device = device
+ self.post = post
+ _LOGGER.info('Setting up %s (%s)', self.name,
+ self._device.modelType)
+
+ async def async_added_to_hass(self):
+ """Register callbacks."""
+ self._device.on_update(self._device_changed)
+
+ def _device_changed(self, json, **kwargs):
+ """Handle device state changes."""
+ _LOGGER.debug('Event %s (%s)', self.name, self._device.modelType)
+ self.async_schedule_update_ha_state()
+
+ @property
+ def name(self):
+ """Return the name of the generic device."""
+ name = self._device.label
+ if (self._home.name is not None and self._home.name != ''):
+ name = "{} {}".format(self._home.name, name)
+ if (self.post is not None and self.post != ''):
+ name = "{} {}".format(name, self.post)
+ return name
+
+ @property
+ def should_poll(self):
+ """No polling needed."""
+ return False
+
+ @property
+ def available(self):
+ """Device available."""
+ return not self._device.unreach
+
+ @property
+ def device_state_attributes(self):
+ """Return the state attributes of the generic device."""
+ return {
+ ATTR_LOW_BATTERY: self._device.lowBat,
+ ATTR_MODEL_TYPE: self._device.modelType
+ }
diff --git a/homeassistant/components/homematicip_cloud/errors.py b/homeassistant/components/homematicip_cloud/errors.py
new file mode 100644
index 0000000000000000000000000000000000000000..cb2925d1a704502592f504b2f28acb0bc0244257
--- /dev/null
+++ b/homeassistant/components/homematicip_cloud/errors.py
@@ -0,0 +1,22 @@
+"""Errors for the HomematicIP component."""
+from homeassistant.exceptions import HomeAssistantError
+
+
+class HmipcException(HomeAssistantError):
+ """Base class for HomematicIP exceptions."""
+
+
+class HmipcConnectionError(HmipcException):
+ """Unable to connect to the HomematicIP cloud server."""
+
+
+class HmipcConnectionWait(HmipcException):
+ """Wait for registration to the HomematicIP cloud server."""
+
+
+class HmipcRegistrationFailed(HmipcException):
+ """Registration on HomematicIP cloud failed."""
+
+
+class HmipcPressButton(HmipcException):
+ """User needs to press the blue button."""
diff --git a/homeassistant/components/homematicip_cloud/hap.py b/homeassistant/components/homematicip_cloud/hap.py
new file mode 100644
index 0000000000000000000000000000000000000000..a4e3e78e860805576cbd0644518ec9193bde8d6e
--- /dev/null
+++ b/homeassistant/components/homematicip_cloud/hap.py
@@ -0,0 +1,256 @@
+"""Accesspoint for the HomematicIP Cloud component."""
+import asyncio
+import logging
+
+from homeassistant import config_entries
+from homeassistant.helpers.aiohttp_client import async_get_clientsession
+from homeassistant.core import callback
+
+from .const import (
+ HMIPC_HAPID, HMIPC_AUTHTOKEN, HMIPC_PIN, HMIPC_NAME,
+ COMPONENTS)
+from .errors import HmipcConnectionError
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class HomematicipAuth(object):
+ """Manages HomematicIP client registration."""
+
+ def __init__(self, hass, config):
+ """Initialize HomematicIP Cloud client registration."""
+ self.hass = hass
+ self.config = config
+ self.auth = None
+
+ async def async_setup(self):
+ """Connect to HomematicIP for registration."""
+ try:
+ self.auth = await self.get_auth(
+ self.hass,
+ self.config.get(HMIPC_HAPID),
+ self.config.get(HMIPC_PIN)
+ )
+ return True
+ except HmipcConnectionError:
+ return False
+
+ async def async_checkbutton(self):
+ """Check blue butten has been pressed."""
+ from homematicip.base.base_connection import HmipConnectionError
+
+ try:
+ await self.auth.isRequestAcknowledged()
+ return True
+ except HmipConnectionError:
+ return False
+
+ async def async_register(self):
+ """Register client at HomematicIP."""
+ from homematicip.base.base_connection import HmipConnectionError
+
+ try:
+ authtoken = await self.auth.requestAuthToken()
+ await self.auth.confirmAuthToken(authtoken)
+ return authtoken
+ except HmipConnectionError:
+ return False
+
+ async def get_auth(self, hass, hapid, pin):
+ """Create a HomematicIP access point object."""
+ from homematicip.aio.auth import AsyncAuth
+ from homematicip.base.base_connection import HmipConnectionError
+
+ auth = AsyncAuth(hass.loop, async_get_clientsession(hass))
+ print(auth)
+ try:
+ await auth.init(hapid)
+ if pin:
+ auth.pin = pin
+ await auth.connectionRequest('HomeAssistant')
+ except HmipConnectionError:
+ return False
+ return auth
+
+
+class HomematicipHAP(object):
+ """Manages HomematicIP http and websocket connection."""
+
+ def __init__(self, hass, config_entry):
+ """Initialize HomematicIP cloud connection."""
+ self.hass = hass
+ self.config_entry = config_entry
+ self.home = None
+
+ self._ws_close_requested = False
+ self._retry_task = None
+ self._tries = 0
+ self._accesspoint_connected = True
+ self._retry_setup = None
+
+ async def async_setup(self, tries=0):
+ """Initialize connection."""
+ try:
+ self.home = await self.get_hap(
+ self.hass,
+ self.config_entry.data.get(HMIPC_HAPID),
+ self.config_entry.data.get(HMIPC_AUTHTOKEN),
+ self.config_entry.data.get(HMIPC_NAME)
+ )
+ except HmipcConnectionError:
+ retry_delay = 2 ** min(tries + 1, 6)
+ _LOGGER.error("Error connecting to HomematicIP with HAP %s. "
+ "Retrying in %d seconds.",
+ self.config_entry.data.get(HMIPC_HAPID), retry_delay)
+
+ async def retry_setup(_now):
+ """Retry setup."""
+ if await self.async_setup(tries + 1):
+ self.config_entry.state = config_entries.ENTRY_STATE_LOADED
+
+ self._retry_setup = self.hass.helpers.event.async_call_later(
+ retry_delay, retry_setup)
+
+ return False
+
+ _LOGGER.info('Connected to HomematicIP with HAP %s.',
+ self.config_entry.data.get(HMIPC_HAPID))
+
+ for component in COMPONENTS:
+ self.hass.async_add_job(
+ self.hass.config_entries.async_forward_entry_setup(
+ self.config_entry, component)
+ )
+ return True
+
+ @callback
+ def async_update(self, *args, **kwargs):
+ """Async update the home device.
+
+ Triggered when the hmip HOME_CHANGED event has fired.
+ There are several occasions for this event to happen.
+ We are only interested to check whether the access point
+ is still connected. If not, device state changes cannot
+ be forwarded to hass. So if access point is disconnected all devices
+ are set to unavailable.
+ """
+ if not self.home.connected:
+ _LOGGER.error(
+ "HMIP access point has lost connection with the cloud")
+ self._accesspoint_connected = False
+ self.set_all_to_unavailable()
+ elif not self._accesspoint_connected:
+ # Explicitly getting an update as device states might have
+ # changed during access point disconnect."""
+
+ job = self.hass.async_add_job(self.get_state())
+ job.add_done_callback(self.get_state_finished)
+
+ async def get_state(self):
+ """Update hmip state and tell hass."""
+ await self.home.get_current_state()
+ self.update_all()
+
+ def get_state_finished(self, future):
+ """Execute when get_state coroutine has finished."""
+ from homematicip.base.base_connection import HmipConnectionError
+
+ try:
+ future.result()
+ except HmipConnectionError:
+ # Somehow connection could not recover. Will disconnect and
+ # so reconnect loop is taking over.
+ _LOGGER.error(
+ "updating state after himp access point reconnect failed.")
+ self.hass.async_add_job(self.home.disable_events())
+
+ def set_all_to_unavailable(self):
+ """Set all devices to unavailable and tell Hass."""
+ for device in self.home.devices:
+ device.unreach = True
+ self.update_all()
+
+ def update_all(self):
+ """Signal all devices to update their state."""
+ for device in self.home.devices:
+ device.fire_update_event()
+
+ async def _handle_connection(self):
+ """Handle websocket connection."""
+ from homematicip.base.base_connection import HmipConnectionError
+
+ try:
+ await self.home.get_current_state()
+ except HmipConnectionError:
+ return
+ hmip_events = await self.home.enable_events()
+ try:
+ await hmip_events
+ except HmipConnectionError:
+ return
+
+ async def async_connect(self):
+ """Start websocket connection."""
+ from homematicip.base.base_connection import HmipConnectionError
+
+ tries = 0
+ while True:
+ try:
+ await self.home.get_current_state()
+ hmip_events = await self.home.enable_events()
+ tries = 0
+ await hmip_events
+ except HmipConnectionError:
+ pass
+
+ if self._ws_close_requested:
+ break
+ self._ws_close_requested = False
+
+ tries += 1
+ retry_delay = 2 ** min(tries + 1, 6)
+ _LOGGER.error("Error connecting to HomematicIP with HAP %s. "
+ "Retrying in %d seconds.",
+ self.config_entry.data.get(HMIPC_HAPID), retry_delay)
+ try:
+ self._retry_task = self.hass.async_add_job(asyncio.sleep(
+ retry_delay, loop=self.hass.loop))
+ await self._retry_task
+ except asyncio.CancelledError:
+ break
+
+ async def async_reset(self):
+ """Close the websocket connection."""
+ self._ws_close_requested = True
+ if self._retry_setup is not None:
+ self._retry_setup.cancel()
+ if self._retry_task is not None:
+ self._retry_task.cancel()
+ self.home.disable_events()
+ _LOGGER.info("Closed connection to HomematicIP cloud server.")
+ for component in COMPONENTS:
+ await self.hass.config_entries.async_forward_entry_unload(
+ self.config_entry, component)
+ return True
+
+ async def get_hap(self, hass, hapid, authtoken, name):
+ """Create a HomematicIP access point object."""
+ from homematicip.aio.home import AsyncHome
+ from homematicip.base.base_connection import HmipConnectionError
+
+ home = AsyncHome(hass.loop, async_get_clientsession(hass))
+
+ home.name = name
+ home.label = 'Access Point'
+ home.modelType = 'HmIP-HAP'
+
+ home.set_auth_token(authtoken)
+ try:
+ await home.init(hapid)
+ await home.get_current_state()
+ except HmipConnectionError:
+ raise HmipcConnectionError
+ home.on_update(self.async_update)
+ hass.loop.create_task(self.async_connect())
+
+ return home
diff --git a/homeassistant/components/homematicip_cloud/strings.json b/homeassistant/components/homematicip_cloud/strings.json
new file mode 100644
index 0000000000000000000000000000000000000000..887a3a5780b0ebc2841936be7d3f14180a9f8017
--- /dev/null
+++ b/homeassistant/components/homematicip_cloud/strings.json
@@ -0,0 +1,30 @@
+{
+ "config": {
+ "title": "HomematicIP Cloud",
+ "step": {
+ "init": {
+ "title": "Pick HomematicIP Accesspoint",
+ "data": {
+ "hapid": "Accesspoint ID (SGTIN)",
+ "pin": "Pin Code (optional)",
+ "name": "Name (optional, used as name prefix for all devices)"
+ }
+ },
+ "link": {
+ "title": "Link Accesspoint",
+ "description": "Press the blue button on the accesspoint and the submit button to register HomematicIP with Home Assistant.\n\n"
+ }
+ },
+ "error": {
+ "register_failed": "Failed to register, please try again.",
+ "invalid_pin": "Invalid PIN, please try again.",
+ "press_the_button": "Please press the blue button.",
+ "timeout_button": "Blue button press timeout, please try again."
+ },
+ "abort": {
+ "unknown": "Unknown error occurred.",
+ "conection_aborted": "Could not connect to HMIP server",
+ "already_configured": "Accesspoint is already configured"
+ }
+ }
+}
diff --git a/homeassistant/components/light/homematicip_cloud.py b/homeassistant/components/light/homematicip_cloud.py
index e433da44ae768b61a897472d7c49b7ff19641aa3..5984fb0365792e1aed9dbff11fd8fe0d4fe370c4 100644
--- a/homeassistant/components/light/homematicip_cloud.py
+++ b/homeassistant/components/light/homematicip_cloud.py
@@ -9,8 +9,8 @@ import logging
from homeassistant.components.light import Light
from homeassistant.components.homematicip_cloud import (
- HomematicipGenericDevice, DOMAIN as HOMEMATICIP_CLOUD_DOMAIN,
- ATTR_HOME_ID)
+ HomematicipGenericDevice, DOMAIN as HMIPC_DOMAIN,
+ HMIPC_HAPID)
DEPENDENCIES = ['homematicip_cloud']
@@ -23,13 +23,16 @@ ATTR_PROFILE_MODE = 'profile_mode'
async def async_setup_platform(hass, config, async_add_devices,
discovery_info=None):
- """Set up the HomematicIP light devices."""
+ """Old way of setting up HomematicIP lights."""
+ pass
+
+
+async def async_setup_entry(hass, config_entry, async_add_devices):
+ """Set up the HomematicIP lights from a config entry."""
from homematicip.device import (
BrandSwitchMeasuring)
- if discovery_info is None:
- return
- home = hass.data[HOMEMATICIP_CLOUD_DOMAIN][discovery_info[ATTR_HOME_ID]]
+ home = hass.data[HMIPC_DOMAIN][config_entry.data[HMIPC_HAPID]].home
devices = []
for device in home.devices:
if isinstance(device, BrandSwitchMeasuring):
diff --git a/homeassistant/components/sensor/homematicip_cloud.py b/homeassistant/components/sensor/homematicip_cloud.py
index ccd1949cc3b2bdc34f01c767c70cb2eddaf5f705..0596bc0b6ccd3e35000fb15e8e257d9447691ac6 100644
--- a/homeassistant/components/sensor/homematicip_cloud.py
+++ b/homeassistant/components/sensor/homematicip_cloud.py
@@ -8,8 +8,8 @@ https://home-assistant.io/components/sensor.homematicip_cloud/
import logging
from homeassistant.components.homematicip_cloud import (
- HomematicipGenericDevice, DOMAIN as HOMEMATICIP_CLOUD_DOMAIN,
- ATTR_HOME_ID)
+ HomematicipGenericDevice, DOMAIN as HMIPC_DOMAIN,
+ HMIPC_HAPID)
from homeassistant.const import (
TEMP_CELSIUS, DEVICE_CLASS_TEMPERATURE, DEVICE_CLASS_HUMIDITY,
DEVICE_CLASS_ILLUMINANCE)
@@ -36,15 +36,17 @@ STATE_SABOTAGE = 'sabotage'
async def async_setup_platform(hass, config, async_add_devices,
discovery_info=None):
"""Set up the HomematicIP sensors devices."""
+ pass
+
+
+async def async_setup_entry(hass, config_entry, async_add_devices):
+ """Set up the HomematicIP sensors from a config entry."""
from homematicip.device import (
HeatingThermostat, TemperatureHumiditySensorWithoutDisplay,
TemperatureHumiditySensorDisplay, MotionDetectorIndoor)
- if discovery_info is None:
- return
- home = hass.data[HOMEMATICIP_CLOUD_DOMAIN][discovery_info[ATTR_HOME_ID]]
+ home = hass.data[HMIPC_DOMAIN][config_entry.data[HMIPC_HAPID]].home
devices = [HomematicipAccesspointStatus(home)]
-
for device in home.devices:
if isinstance(device, HeatingThermostat):
devices.append(HomematicipHeatingThermostat(home, device))
diff --git a/homeassistant/components/switch/__init__.py b/homeassistant/components/switch/__init__.py
index bab2abbad0d83c4c50a44b7ee09eb3c573dfcdfb..b9ee8126ed3c294710279607ae88607eb966c0c7 100644
--- a/homeassistant/components/switch/__init__.py
+++ b/homeassistant/components/switch/__init__.py
@@ -95,7 +95,7 @@ def toggle(hass, entity_id=None):
async def async_setup(hass, config):
"""Track states and offer events for switches."""
- component = EntityComponent(
+ component = hass.data[DOMAIN] = EntityComponent(
_LOGGER, DOMAIN, hass, SCAN_INTERVAL, GROUP_NAME_ALL_SWITCHES)
await component.async_setup(config)
@@ -132,6 +132,16 @@ async def async_setup(hass, config):
return True
+async def async_setup_entry(hass, entry):
+ """Setup a config entry."""
+ return await hass.data[DOMAIN].async_setup_entry(entry)
+
+
+async def async_unload_entry(hass, entry):
+ """Unload a config entry."""
+ return await hass.data[DOMAIN].async_unload_entry(entry)
+
+
class SwitchDevice(ToggleEntity):
"""Representation of a switch."""
diff --git a/homeassistant/components/switch/homematicip_cloud.py b/homeassistant/components/switch/homematicip_cloud.py
index 9123d46c87b2ef45942182ee0393392a0ea09017..68884aaaa02963f66e7f678629b8ff28944c73e0 100644
--- a/homeassistant/components/switch/homematicip_cloud.py
+++ b/homeassistant/components/switch/homematicip_cloud.py
@@ -9,8 +9,8 @@ import logging
from homeassistant.components.switch import SwitchDevice
from homeassistant.components.homematicip_cloud import (
- HomematicipGenericDevice, DOMAIN as HOMEMATICIP_CLOUD_DOMAIN,
- ATTR_HOME_ID)
+ HomematicipGenericDevice, DOMAIN as HMIPC_DOMAIN,
+ HMIPC_HAPID)
DEPENDENCIES = ['homematicip_cloud']
@@ -24,13 +24,16 @@ ATTR_PROFILE_MODE = 'profile_mode'
async def async_setup_platform(hass, config, async_add_devices,
discovery_info=None):
"""Set up the HomematicIP switch devices."""
+ pass
+
+
+async def async_setup_entry(hass, config_entry, async_add_devices):
+ """Set up the HomematicIP switch from a config entry."""
from homematicip.device import (
PlugableSwitch, PlugableSwitchMeasuring,
BrandSwitchMeasuring)
- if discovery_info is None:
- return
- home = hass.data[HOMEMATICIP_CLOUD_DOMAIN][discovery_info[ATTR_HOME_ID]]
+ home = hass.data[HMIPC_DOMAIN][config_entry.data[HMIPC_HAPID]].home
devices = []
for device in home.devices:
if isinstance(device, BrandSwitchMeasuring):
diff --git a/homeassistant/config_entries.py b/homeassistant/config_entries.py
index be67ebd9cc3a2c41c87d7757ff389d89db7a54f1..2e5613057f148f2298d9827609a179bf47321878 100644
--- a/homeassistant/config_entries.py
+++ b/homeassistant/config_entries.py
@@ -127,6 +127,7 @@ HANDLERS = Registry()
FLOWS = [
'cast',
'deconz',
+ 'homematicip_cloud',
'hue',
'nest',
'sonos',
diff --git a/requirements_all.txt b/requirements_all.txt
index 1491e1dbff4122ece0a230eefcd090f2175b6b3b..c72e56821d6f11cc027cd1cd914ad0fb989aa4e4 100644
--- a/requirements_all.txt
+++ b/requirements_all.txt
@@ -421,7 +421,7 @@ home-assistant-frontend==20180704.0
# homekit==0.6
# homeassistant.components.homematicip_cloud
-homematicip==0.9.4
+homematicip==0.9.6
# homeassistant.components.remember_the_milk
httplib2==0.10.3
diff --git a/requirements_test_all.txt b/requirements_test_all.txt
index 476b3d96c3d2e19da7ef218f578d0848d9b9beae..aabbdc44bea154fccc5c9ca22f0bfd07a2fb1a1d 100644
--- a/requirements_test_all.txt
+++ b/requirements_test_all.txt
@@ -83,6 +83,9 @@ holidays==0.9.5
# homeassistant.components.frontend
home-assistant-frontend==20180704.0
+# homeassistant.components.homematicip_cloud
+homematicip==0.9.6
+
# homeassistant.components.influxdb
# homeassistant.components.sensor.influxdb
influxdb==5.0.0
diff --git a/script/gen_requirements_all.py b/script/gen_requirements_all.py
index 7bf87c74de7266123c0428612c0a919d6791619f..9a5b4dd1a43e159f4064812942a9e6d9a4a2c588 100755
--- a/script/gen_requirements_all.py
+++ b/script/gen_requirements_all.py
@@ -56,6 +56,7 @@ TEST_REQUIREMENTS = (
'hbmqtt',
'holidays',
'home-assistant-frontend',
+ 'homematicip',
'influxdb',
'libpurecoollink',
'libsoundtouch',
diff --git a/tests/components/homematicip_cloud/__init__.py b/tests/components/homematicip_cloud/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..1d89bd73183c9121d490dc3cfea04e0260eaa204
--- /dev/null
+++ b/tests/components/homematicip_cloud/__init__.py
@@ -0,0 +1 @@
+"""Tests for the HomematicIP Cloud component."""
diff --git a/tests/components/homematicip_cloud/test_config_flow.py b/tests/components/homematicip_cloud/test_config_flow.py
new file mode 100644
index 0000000000000000000000000000000000000000..1c2e54a1a5dfb8670a48456dadbf819fd0df054a
--- /dev/null
+++ b/tests/components/homematicip_cloud/test_config_flow.py
@@ -0,0 +1,150 @@
+"""Tests for HomematicIP Cloud config flow."""
+from unittest.mock import patch
+
+from homeassistant.components.homematicip_cloud import hap as hmipc
+from homeassistant.components.homematicip_cloud import config_flow, const
+
+from tests.common import MockConfigEntry, mock_coro
+
+
+async def test_flow_works(hass):
+ """Test config flow works."""
+ config = {
+ const.HMIPC_HAPID: 'ABC123',
+ const.HMIPC_PIN: '123',
+ const.HMIPC_NAME: 'hmip',
+ }
+ flow = config_flow.HomematicipCloudFlowHandler()
+ flow.hass = hass
+
+ hap = hmipc.HomematicipAuth(hass, config)
+ with patch.object(hap, 'get_auth', return_value=mock_coro()), \
+ patch.object(hmipc.HomematicipAuth, 'async_checkbutton',
+ return_value=mock_coro(True)), \
+ patch.object(hmipc.HomematicipAuth, 'async_register',
+ return_value=mock_coro(True)):
+ hap.authtoken = 'ABC'
+ result = await flow.async_step_init(user_input=config)
+
+ assert hap.authtoken == 'ABC'
+ assert result['type'] == 'create_entry'
+
+
+async def test_flow_init_connection_error(hass):
+ """Test config flow with accesspoint connection error."""
+ config = {
+ const.HMIPC_HAPID: 'ABC123',
+ const.HMIPC_PIN: '123',
+ const.HMIPC_NAME: 'hmip',
+ }
+ flow = config_flow.HomematicipCloudFlowHandler()
+ flow.hass = hass
+
+ with patch.object(hmipc.HomematicipAuth, 'async_setup',
+ return_value=mock_coro(False)):
+ result = await flow.async_step_init(user_input=config)
+ assert result['type'] == 'form'
+
+
+async def test_flow_link_connection_error(hass):
+ """Test config flow client registration connection error."""
+ config = {
+ const.HMIPC_HAPID: 'ABC123',
+ const.HMIPC_PIN: '123',
+ const.HMIPC_NAME: 'hmip',
+ }
+ flow = config_flow.HomematicipCloudFlowHandler()
+ flow.hass = hass
+
+ with patch.object(hmipc.HomematicipAuth, 'async_setup',
+ return_value=mock_coro(True)), \
+ patch.object(hmipc.HomematicipAuth, 'async_checkbutton',
+ return_value=mock_coro(True)), \
+ patch.object(hmipc.HomematicipAuth, 'async_register',
+ return_value=mock_coro(False)):
+ result = await flow.async_step_init(user_input=config)
+ assert result['type'] == 'abort'
+
+
+async def test_flow_link_press_button(hass):
+ """Test config flow ask for pressing the blue button."""
+ config = {
+ const.HMIPC_HAPID: 'ABC123',
+ const.HMIPC_PIN: '123',
+ const.HMIPC_NAME: 'hmip',
+ }
+ flow = config_flow.HomematicipCloudFlowHandler()
+ flow.hass = hass
+
+ with patch.object(hmipc.HomematicipAuth, 'async_setup',
+ return_value=mock_coro(True)), \
+ patch.object(hmipc.HomematicipAuth, 'async_checkbutton',
+ return_value=mock_coro(False)):
+ result = await flow.async_step_init(user_input=config)
+ assert result['type'] == 'form'
+ assert result['errors'] == {'base': 'press_the_button'}
+
+
+async def test_init_flow_show_form(hass):
+ """Test config flow shows up with a form."""
+ flow = config_flow.HomematicipCloudFlowHandler()
+ flow.hass = hass
+
+ result = await flow.async_step_init(user_input=None)
+ assert result['type'] == 'form'
+
+
+async def test_init_already_configured(hass):
+ """Test accesspoint is already configured."""
+ MockConfigEntry(domain=const.DOMAIN, data={
+ const.HMIPC_HAPID: 'ABC123',
+ }).add_to_hass(hass)
+ config = {
+ const.HMIPC_HAPID: 'ABC123',
+ const.HMIPC_PIN: '123',
+ const.HMIPC_NAME: 'hmip',
+ }
+
+ flow = config_flow.HomematicipCloudFlowHandler()
+ flow.hass = hass
+
+ result = await flow.async_step_init(user_input=config)
+ assert result['type'] == 'abort'
+
+
+async def test_import_config(hass):
+ """Test importing a host with an existing config file."""
+ flow = config_flow.HomematicipCloudFlowHandler()
+ flow.hass = hass
+
+ result = await flow.async_step_import({
+ hmipc.HMIPC_HAPID: 'ABC123',
+ hmipc.HMIPC_AUTHTOKEN: '123',
+ hmipc.HMIPC_NAME: 'hmip'
+ })
+
+ assert result['type'] == 'create_entry'
+ assert result['title'] == 'ABC123'
+ assert result['data'] == {
+ hmipc.HMIPC_HAPID: 'ABC123',
+ hmipc.HMIPC_AUTHTOKEN: '123',
+ hmipc.HMIPC_NAME: 'hmip'
+ }
+
+
+async def test_import_existing_config(hass):
+ """Test abort of an existing accesspoint from config."""
+ flow = config_flow.HomematicipCloudFlowHandler()
+ flow.hass = hass
+
+ MockConfigEntry(domain=const.DOMAIN, data={
+ hmipc.HMIPC_HAPID: 'ABC123',
+ }).add_to_hass(hass)
+
+ result = await flow.async_step_import({
+ hmipc.HMIPC_HAPID: 'ABC123',
+ hmipc.HMIPC_AUTHTOKEN: '123',
+ hmipc.HMIPC_NAME: 'hmip'
+ })
+
+ assert result['type'] == 'abort'
diff --git a/tests/components/homematicip_cloud/test_hap.py b/tests/components/homematicip_cloud/test_hap.py
new file mode 100644
index 0000000000000000000000000000000000000000..5344773fde659563792b8fd2b105beb309180cb2
--- /dev/null
+++ b/tests/components/homematicip_cloud/test_hap.py
@@ -0,0 +1,113 @@
+"""Test HomematicIP Cloud accesspoint."""
+from unittest.mock import Mock, patch
+
+from homeassistant.components.homematicip_cloud import hap as hmipc
+from homeassistant.components.homematicip_cloud import const, errors
+from tests.common import mock_coro
+
+
+async def test_auth_setup(hass):
+ """Test auth setup for client registration."""
+ config = {
+ const.HMIPC_HAPID: 'ABC123',
+ const.HMIPC_PIN: '123',
+ const.HMIPC_NAME: 'hmip',
+ }
+ hap = hmipc.HomematicipAuth(hass, config)
+ with patch.object(hap, 'get_auth', return_value=mock_coro()):
+ assert await hap.async_setup() is True
+
+
+async def test_auth_setup_connection_error(hass):
+ """Test auth setup connection error behaviour."""
+ config = {
+ const.HMIPC_HAPID: 'ABC123',
+ const.HMIPC_PIN: '123',
+ const.HMIPC_NAME: 'hmip',
+ }
+ hap = hmipc.HomematicipAuth(hass, config)
+ with patch.object(hap, 'get_auth',
+ side_effect=errors.HmipcConnectionError):
+ assert await hap.async_setup() is False
+
+
+async def test_auth_auth_check_and_register(hass):
+ """Test auth client registration."""
+ config = {
+ const.HMIPC_HAPID: 'ABC123',
+ const.HMIPC_PIN: '123',
+ const.HMIPC_NAME: 'hmip',
+ }
+ hap = hmipc.HomematicipAuth(hass, config)
+ hap.auth = Mock()
+ with patch.object(hap.auth, 'isRequestAcknowledged',
+ return_value=mock_coro()), \
+ patch.object(hap.auth, 'requestAuthToken',
+ return_value=mock_coro('ABC')), \
+ patch.object(hap.auth, 'confirmAuthToken',
+ return_value=mock_coro()):
+ assert await hap.async_checkbutton() is True
+ assert await hap.async_register() == 'ABC'
+
+
+async def test_hap_setup_works(aioclient_mock):
+ """Test a successful setup of a accesspoint."""
+ hass = Mock()
+ entry = Mock()
+ home = Mock()
+ entry.data = {
+ hmipc.HMIPC_HAPID: 'ABC123',
+ hmipc.HMIPC_AUTHTOKEN: '123',
+ hmipc.HMIPC_NAME: 'hmip',
+ }
+ hap = hmipc.HomematicipHAP(hass, entry)
+ with patch.object(hap, 'get_hap', return_value=mock_coro(home)):
+ assert await hap.async_setup() is True
+
+ assert hap.home is home
+ assert len(hass.config_entries.async_forward_entry_setup.mock_calls) == 5
+ assert hass.config_entries.async_forward_entry_setup.mock_calls[0][1] == \
+ (entry, 'binary_sensor')
+
+
+async def test_hap_setup_connection_error():
+ """Test a failed accesspoint setup."""
+ hass = Mock()
+ entry = Mock()
+ entry.data = {
+ hmipc.HMIPC_HAPID: 'ABC123',
+ hmipc.HMIPC_AUTHTOKEN: '123',
+ hmipc.HMIPC_NAME: 'hmip',
+ }
+ hap = hmipc.HomematicipHAP(hass, entry)
+ with patch.object(hap, 'get_hap',
+ side_effect=errors.HmipcConnectionError):
+ assert await hap.async_setup() is False
+
+ assert len(hass.async_add_job.mock_calls) == 0
+ assert len(hass.config_entries.flow.async_init.mock_calls) == 0
+
+
+async def test_hap_reset_unloads_entry_if_setup():
+ """Test calling reset while the entry has been setup."""
+ hass = Mock()
+ entry = Mock()
+ home = Mock()
+ entry.data = {
+ hmipc.HMIPC_HAPID: 'ABC123',
+ hmipc.HMIPC_AUTHTOKEN: '123',
+ hmipc.HMIPC_NAME: 'hmip',
+ }
+ hap = hmipc.HomematicipHAP(hass, entry)
+ with patch.object(hap, 'get_hap', return_value=mock_coro(home)):
+ assert await hap.async_setup() is True
+
+ assert hap.home is home
+ assert len(hass.services.async_register.mock_calls) == 0
+ assert len(hass.config_entries.async_forward_entry_setup.mock_calls) == 5
+
+ hass.config_entries.async_forward_entry_unload.return_value = \
+ mock_coro(True)
+ await hap.async_reset()
+
+ assert len(hass.config_entries.async_forward_entry_unload.mock_calls) == 5
diff --git a/tests/components/homematicip_cloud/test_init.py b/tests/components/homematicip_cloud/test_init.py
new file mode 100644
index 0000000000000000000000000000000000000000..185372272471bdd258a47192925032f0f7ffd7f0
--- /dev/null
+++ b/tests/components/homematicip_cloud/test_init.py
@@ -0,0 +1,103 @@
+"""Test HomematicIP Cloud setup process."""
+
+from unittest.mock import patch
+
+from homeassistant.setup import async_setup_component
+from homeassistant.components import homematicip_cloud as hmipc
+
+from tests.common import mock_coro, MockConfigEntry
+
+
+async def test_config_with_accesspoint_passed_to_config_entry(hass):
+ """Test that config for a accesspoint are loaded via config entry."""
+ with patch.object(hass, 'config_entries') as mock_config_entries, \
+ patch.object(hmipc, 'configured_haps', return_value=[]):
+ assert await async_setup_component(hass, hmipc.DOMAIN, {
+ hmipc.DOMAIN: {
+ hmipc.CONF_ACCESSPOINT: 'ABC123',
+ hmipc.CONF_AUTHTOKEN: '123',
+ hmipc.CONF_NAME: 'name',
+ }
+ }) is True
+
+ # Flow started for the access point
+ assert len(mock_config_entries.flow.mock_calls) == 2
+
+
+async def test_config_already_registered_not_passed_to_config_entry(hass):
+ """Test that an already registered accesspoint does not get imported."""
+ with patch.object(hass, 'config_entries') as mock_config_entries, \
+ patch.object(hmipc, 'configured_haps', return_value=['ABC123']):
+ assert await async_setup_component(hass, hmipc.DOMAIN, {
+ hmipc.DOMAIN: {
+ hmipc.CONF_ACCESSPOINT: 'ABC123',
+ hmipc.CONF_AUTHTOKEN: '123',
+ hmipc.CONF_NAME: 'name',
+ }
+ }) is True
+
+ # No flow started
+ assert len(mock_config_entries.flow.mock_calls) == 0
+
+
+async def test_setup_entry_successful(hass):
+ """Test setup entry is successful."""
+ entry = MockConfigEntry(domain=hmipc.DOMAIN, data={
+ hmipc.HMIPC_HAPID: 'ABC123',
+ hmipc.HMIPC_AUTHTOKEN: '123',
+ hmipc.HMIPC_NAME: 'hmip',
+ })
+ entry.add_to_hass(hass)
+ with patch.object(hmipc, 'HomematicipHAP') as mock_hap:
+ mock_hap.return_value.async_setup.return_value = mock_coro(True)
+ assert await async_setup_component(hass, hmipc.DOMAIN, {
+ hmipc.DOMAIN: {
+ hmipc.CONF_ACCESSPOINT: 'ABC123',
+ hmipc.CONF_AUTHTOKEN: '123',
+ hmipc.CONF_NAME: 'hmip',
+ }
+ }) is True
+
+ assert len(mock_hap.mock_calls) == 2
+
+
+async def test_setup_defined_accesspoint(hass):
+ """Test we initiate config entry for the accesspoint."""
+ with patch.object(hass, 'config_entries') as mock_config_entries, \
+ patch.object(hmipc, 'configured_haps', return_value=[]):
+ mock_config_entries.flow.async_init.return_value = mock_coro()
+ assert await async_setup_component(hass, hmipc.DOMAIN, {
+ hmipc.DOMAIN: {
+ hmipc.CONF_ACCESSPOINT: 'ABC123',
+ hmipc.CONF_AUTHTOKEN: '123',
+ hmipc.CONF_NAME: 'hmip',
+ }
+ }) is True
+
+ assert len(mock_config_entries.flow.mock_calls) == 1
+ assert mock_config_entries.flow.mock_calls[0][2]['data'] == {
+ hmipc.HMIPC_HAPID: 'ABC123',
+ hmipc.HMIPC_AUTHTOKEN: '123',
+ hmipc.HMIPC_NAME: 'hmip',
+ }
+
+
+async def test_unload_entry(hass):
+ """Test being able to unload an entry."""
+ entry = MockConfigEntry(domain=hmipc.DOMAIN, data={
+ hmipc.HMIPC_HAPID: 'ABC123',
+ hmipc.HMIPC_AUTHTOKEN: '123',
+ hmipc.HMIPC_NAME: 'hmip',
+ })
+ entry.add_to_hass(hass)
+
+ with patch.object(hmipc, 'HomematicipHAP') as mock_hap:
+ mock_hap.return_value.async_setup.return_value = mock_coro(True)
+ assert await async_setup_component(hass, hmipc.DOMAIN, {}) is True
+
+ assert len(mock_hap.return_value.mock_calls) == 1
+
+ mock_hap.return_value.async_reset.return_value = mock_coro(True)
+ assert await hmipc.async_unload_entry(hass, entry)
+ assert len(mock_hap.return_value.async_reset.mock_calls) == 1
+ assert hass.data[hmipc.DOMAIN] == {}