Add a template binary_sensor platform

homeassistant/components/binary_sensor/template.py

@@ -0,0 +1,122 @@
+"""
+homeassistant.components.binary_sensor.template
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Support for exposing a templated binary_sensor
+"""
+import logging
+
+from homeassistant.components.binary_sensor import (BinarySensorDevice,
+                                                    DOMAIN,
+                                                    SENSOR_CLASSES)
+from homeassistant.const import ATTR_FRIENDLY_NAME, CONF_VALUE_TEMPLATE
+from homeassistant.core import EVENT_STATE_CHANGED
+from homeassistant.exceptions import TemplateError
+from homeassistant.helpers.entity import generate_entity_id
+from homeassistant.helpers import template
+from homeassistant.util import slugify
+
+ENTITY_ID_FORMAT = DOMAIN + '.{}'
+CONF_SENSORS = 'sensors'
+_LOGGER = logging.getLogger(__name__)
+
+
+def setup_platform(hass, config, add_devices, discovery_info=None):
+    """Setup template binary sensors."""
+
+    sensors = []
+    if config.get(CONF_SENSORS) is None:
+        _LOGGER.error('Missing configuration data for binary_sensor platform')
+        return False
+
+    for device, device_config in config[CONF_SENSORS].items():
+
+        if device != slugify(device):
+            _LOGGER.error('Found invalid key for binary_sensor.template: %s. '
+                          'Use %s instead', device, slugify(device))
+            continue
+
+        if not isinstance(device_config, dict):
+            _LOGGER.error('Missing configuration data for binary_sensor %s',
+                          device)
+            continue
+
+        friendly_name = device_config.get(ATTR_FRIENDLY_NAME, device)
+        sensor_class = device_config.get('sensor_class')
+        value_template = device_config.get(CONF_VALUE_TEMPLATE)
+
+        if sensor_class not in SENSOR_CLASSES:
+            _LOGGER.error('Sensor class is not valid')
+            continue
+
+        if value_template is None:
+            _LOGGER.error(
+                'Missing %s for sensor %s', CONF_VALUE_TEMPLATE, device)
+            continue
+
+        sensors.append(
+            BinarySensorTemplate(
+                hass,
+                device,
+                friendly_name,
+                sensor_class,
+                value_template)
+            )
+    if not sensors:
+        _LOGGER.error('No sensors added')
+        return False
+    add_devices(sensors)
+
+    return True
+
+
+class BinarySensorTemplate(BinarySensorDevice):
+    """A virtual binary_sensor that triggers from another sensor."""
+
+    # pylint: disable=too-many-arguments
+    def __init__(self, hass, device, friendly_name, sensor_class,
+                 value_template):
+        self._hass = hass
+        self._device = device
+        self._name = friendly_name
+        self._sensor_class = sensor_class
+        self._template = value_template
+        self._state = None
+
+        self.entity_id = generate_entity_id(
+            ENTITY_ID_FORMAT, device,
+            hass=hass)
+
+        _LOGGER.info('Started template sensor %s', device)
+        hass.bus.listen(EVENT_STATE_CHANGED, self._event_listener)
+
+    def _event_listener(self, event):
+        self.update_ha_state(True)
+
+    @property
+    def should_poll(self):
+        return False
+
+    @property
+    def sensor_class(self):
+        return self._sensor_class
+
+    @property
+    def name(self):
+        return self._name
+
+    @property
+    def is_on(self):
+        return self._state
+
+    def update(self):
+        try:
+            value = template.render(self._hass, self._template)
+        except TemplateError as ex:
+            if ex.args and ex.args[0].startswith(
+                    "UndefinedError: 'None' has no attribute"):
+                # Common during HA startup - so just a warning
+                _LOGGER.warning(ex)
+                return
+            _LOGGER.error(ex)
+            value = 'false'
+        self._state = value.lower() == 'true'

tests/components/binary_sensor/test_template.py

@@ -0,0 +1,111 @@
+"""
+tests.components.binary_sensor.test_template
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Tests for template binary_sensor.
+"""
+
+import unittest
+from unittest import mock
+
+from homeassistant.components.binary_sensor import template
+from homeassistant.exceptions import TemplateError
+
+
+class TestBinarySensorTemplate(unittest.TestCase):
+    @mock.patch.object(template, 'BinarySensorTemplate')
+    def test_setup(self, mock_template):
+        config = {
+            'sensors': {
+                'test': {
+                    'friendly_name': 'virtual thingy',
+                    'value_template': '{{ foo }}',
+                    'sensor_class': 'motion',
+                },
+            }
+        }
+        hass = mock.MagicMock()
+        add_devices = mock.MagicMock()
+        result = template.setup_platform(hass, config, add_devices)
+        self.assertTrue(result)
+        mock_template.assert_called_once_with(hass, 'test', 'virtual thingy',
+                                              'motion', '{{ foo }}')
+        add_devices.assert_called_once_with([mock_template.return_value])
+
+    def test_setup_no_sensors(self):
+        config = {}
+        result = template.setup_platform(None, config, None)
+        self.assertFalse(result)
+
+    def test_setup_invalid_device(self):
+        config = {
+            'sensors': {
+                'foo bar': {},
+            },
+        }
+        result = template.setup_platform(None, config, None)
+        self.assertFalse(result)
+
+    def test_setup_invalid_sensor_class(self):
+        config = {
+            'sensors': {
+                'test': {
+                    'value_template': '{{ foo }}',
+                    'sensor_class': 'foobarnotreal',
+                },
+            },
+        }
+        result = template.setup_platform(None, config, None)
+        self.assertFalse(result)
+
+    def test_setup_invalid_missing_template(self):
+        config = {
+            'sensors': {
+                'test': {
+                    'sensor_class': 'motion',
+                },
+            },
+        }
+        result = template.setup_platform(None, config, None)
+        self.assertFalse(result)
+
+    def test_attributes(self):
+        hass = mock.MagicMock()
+        vs = template.BinarySensorTemplate(hass, 'parent', 'Parent',
+                                           'motion', '{{ 1 > 1 }}')
+        self.assertFalse(vs.should_poll)
+        self.assertEqual('motion', vs.sensor_class)
+        self.assertEqual('Parent', vs.name)
+
+        vs.update()
+        self.assertFalse(vs.is_on)
+
+        vs._template = "{{ 2 > 1 }}"
+        vs.update()
+        self.assertTrue(vs.is_on)
+
+    def test_event(self):
+        hass = mock.MagicMock()
+        vs = template.BinarySensorTemplate(hass, 'parent', 'Parent',
+                                           'motion', '{{ 1 > 1 }}')
+        with mock.patch.object(vs, 'update_ha_state') as mock_update:
+            vs._event_listener(None)
+            mock_update.assert_called_once_with(True)
+
+    def test_update(self):
+        hass = mock.MagicMock()
+        vs = template.BinarySensorTemplate(hass, 'parent', 'Parent',
+                                           'motion', '{{ 2 > 1 }}')
+        self.assertEqual(None, vs._state)
+        vs.update()
+        self.assertTrue(vs._state)
+
+    @mock.patch('homeassistant.helpers.template.render')
+    def test_update_template_error(self, mock_render):
+        hass = mock.MagicMock()
+        vs = template.BinarySensorTemplate(hass, 'parent', 'Parent',
+                                           'motion', '{{ 1 > 1 }}')
+        mock_render.side_effect = TemplateError('foo')
+        vs.update()
+        mock_render.side_effect = TemplateError(
+            "UndefinedError: 'None' has no attribute")
+        vs.update()